Formats the source and updates the gcc warning pragmas

1 files changed, 108 insertions, 109 deletions

diff --git a/hl/tools/gif2h5/hdfgifwr.c b/hl/tools/gif2h5/hdfgifwr.c
index d44ff7a..7be68dc 100644
--- a/hl/tools/gif2h5/hdfgifwr.c
+++ b/hl/tools/gif2h5/hdfgifwr.c
@@ -44,7 +44,6 @@
  * Joe Orost               (decvax!vax135!petsd!joe)
  *****************************************************************/
 
-
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -65,32 +64,32 @@ static void flush_char(void);
 #else
 static void compress(), output(), cl_block(), cl_hash();
 static void char_init(), char_out(), flush_char();
-#endif  /* __STDC__ */
+#endif /* __STDC__ */
 
 static byte pc2nc[256];
 
 /***********************************************************************/
 static unsigned long cur_accum = 0;
-static int           cur_bits = 0;
+static int           cur_bits  = 0;
 
-#define MAXCODE(n_bits)     ( (1 << (n_bits)) - 1)
-#define XV_BITS 12    /* BITS was already defined on some systems */
-#define HSIZE  5003            /* 80% occupancy */
+#define MAXCODE(n_bits) ((1 << (n_bits)) - 1)
+#define XV_BITS         12   /* BITS was already defined on some systems */
+#define HSIZE           5003 /* 80% occupancy */
 
-typedef unsigned char   char_type;
+typedef unsigned char char_type;
 
 static int n_bits;                    /* number of bits/code */
 static int maxbits = XV_BITS;         /* user settable max # bits/code */
 static int maxcode;                   /* maximum code, given n_bits */
 static int maxmaxcode = 1 << XV_BITS; /* NEVER generate this */
 
-static  count_int      *htab;
-static  unsigned short *codetab;
+static count_int *     htab;
+static unsigned short *codetab;
 
-#define HashTabOf(i)   htab[i]
-#define CodeTabOf(i)   codetab[i]
+#define HashTabOf(i) htab[i]
+#define CodeTabOf(i) codetab[i]
 
-static int hsize = HSIZE;            /* for dynamic table sizing */
+static int hsize = HSIZE; /* for dynamic table sizing */
 
 /*
  * To save much memory, we overlay the table used by compress() with those
@@ -101,7 +100,7 @@ static int hsize = HSIZE;            /* for dynamic table sizing */
  * used to be 8000 characters).
  */
 
-static int free_ent = 0;                  /* first unused entry */
+static int free_ent = 0; /* first unused entry */
 
 /*
  * block compression parameters -- after all codes are used up,
@@ -109,8 +108,8 @@ static int free_ent = 0;                  /* first unused entry */
  */
 static int clear_flg = 0;
 
-static long int in_count = 1;            /* length of input */
-static long int out_count = 0;           /* # of codes output (for debugging) */
+static long int in_count  = 1; /* length of input */
+static long int out_count = 0; /* # of codes output (for debugging) */
 
 /*
  * compress stdin to stdout
@@ -128,19 +127,19 @@ static long int out_count = 0;           /* # of codes output (for debugging) */
  * about this implementation to ames!jaw.
  */
 
-static int g_init_bits;
+static int   g_init_bits;
 static FILE *g_outfile;
 
 static int ClearCode;
 static int EOFCode;
 
 /*************************************************************/
-int hdfWriteGIF(FILE *fp, byte *pic, int ptype, int w, int h, byte *rmap,
-                byte *gmap, byte *bmap, byte *pc2ncmap, int numcols,
-                int colorstyle, int BitsPerPixel)
+int
+hdfWriteGIF(FILE *fp, byte *pic, int ptype, int w, int h, byte *rmap, byte *gmap, byte *bmap, byte *pc2ncmap,
+            int numcols, int colorstyle, int BitsPerPixel)
 {
-    int InitCodeSize;
-    int i;
+    int   InitCodeSize;
+    int   i;
     byte *pic8 = pic;
 
     if (!(htab = calloc(HSIZE, sizeof(count_int)))) {
@@ -153,15 +152,15 @@ int hdfWriteGIF(FILE *fp, byte *pic, int ptype, int w, int h, byte *rmap,
     }
 
     /* Shut compiler up... */
-    ptype=ptype;
-    rmap=rmap;
-    gmap=gmap;
-    bmap=bmap;
-    numcols=numcols;
-    colorstyle=colorstyle;
+    ptype      = ptype;
+    rmap       = rmap;
+    gmap       = gmap;
+    bmap       = bmap;
+    numcols    = numcols;
+    colorstyle = colorstyle;
 
     for (i = 0; i < 256; i++) {
-      pc2nc[i] = pc2ncmap[i];
+        pc2nc[i] = pc2ncmap[i];
     }
 
     if (BitsPerPixel <= 1)
@@ -170,11 +169,11 @@ int hdfWriteGIF(FILE *fp, byte *pic, int ptype, int w, int h, byte *rmap,
         InitCodeSize = BitsPerPixel;
 
     if (!fp) {
-        fprintf(stderr,  "WriteGIF: file not open for writing\n");
+        fprintf(stderr, "WriteGIF: file not open for writing\n");
         return 1;
     }
 
-    compress(InitCodeSize+1, fp, pic8, w*h);
+    compress(InitCodeSize + 1, fp, pic8, w * h);
 
     free(htab);
     free(codetab);
@@ -182,19 +181,20 @@ int hdfWriteGIF(FILE *fp, byte *pic, int ptype, int w, int h, byte *rmap,
     if (ferror(fp))
         return -1;
 
-    return  0 ;
+    return 0;
 }
 
 /********************************************************/
-static void compress(int init_bits, FILE *outfile, byte *data, int len)
+static void
+compress(int init_bits, FILE *outfile, byte *data, int len)
 {
     register long fcode;
-    register int i = 0;
-    register int c;
-    register int ent;
-    register int disp;
-    register int hsize_reg;
-    register int hshift;
+    register int  i = 0;
+    register int  c;
+    register int  ent;
+    register int  disp;
+    register int  hsize_reg;
+    register int  hshift;
 
     /*
      * Set up the globals:  g_init_bits - initial number of bits g_outfile -
@@ -204,38 +204,38 @@ static void compress(int init_bits, FILE *outfile, byte *data, int len)
     g_outfile   = outfile;
 
     /* initialize 'compress' globals */
-    maxbits = XV_BITS;
-    maxmaxcode = 1<<XV_BITS;
-    hsize = HSIZE;
-    free_ent = 0;
-    clear_flg = 0;
-    in_count = 1;
-    out_count = 0;
-    cur_accum = 0;
-    cur_bits = 0;
+    maxbits    = XV_BITS;
+    maxmaxcode = 1 << XV_BITS;
+    hsize      = HSIZE;
+    free_ent   = 0;
+    clear_flg  = 0;
+    in_count   = 1;
+    out_count  = 0;
+    cur_accum  = 0;
+    cur_bits   = 0;
 
     /* Set up the necessary values */
     out_count = 0;
     clear_flg = 0;
-    in_count = 1;
-    maxcode = MAXCODE(n_bits = g_init_bits);
+    in_count  = 1;
+    maxcode   = MAXCODE(n_bits = g_init_bits);
 
     ClearCode = (1 << (init_bits - 1));
-    EOFCode = ClearCode + 1;
-    free_ent = ClearCode + 2;
+    EOFCode   = ClearCode + 1;
+    free_ent  = ClearCode + 2;
 
     char_init();
     ent = pc2nc[*data++];
     len--;
 
     hshift = 0;
-    for (fcode = (long)hsize; fcode < 65536L; fcode *= 2L )
+    for (fcode = (long)hsize; fcode < 65536L; fcode *= 2L)
         hshift++;
 
     hshift = 8 - hshift; /* set hash code range bound */
 
     hsize_reg = hsize;
-    cl_hash( (count_int) hsize_reg); /* clear hash table */
+    cl_hash((count_int)hsize_reg); /* clear hash table */
 
     output(ClearCode);
 
@@ -244,32 +244,33 @@ static void compress(int init_bits, FILE *outfile, byte *data, int len)
         len--;
         in_count++;
 
-        fcode = (long)(((long) c << maxbits) + ent);
-        i = (((int) c << hshift) ^ ent);    /* xor hashing */
+        fcode = (long)(((long)c << maxbits) + ent);
+        i     = (((int)c << hshift) ^ ent); /* xor hashing */
 
-        if ( HashTabOf (i) == fcode ) {
-            ent = CodeTabOf (i);
+        if (HashTabOf(i) == fcode) {
+            ent = CodeTabOf(i);
             continue;
-        } else if ( (long)HashTabOf (i) < 0) {
+        }
+        else if ((long)HashTabOf(i) < 0) {
             /* empty slot */
             goto nomatch;
         }
 
-        disp = hsize_reg - i;   /* secondary hash (after G. Knott) */
+        disp = hsize_reg - i; /* secondary hash (after G. Knott) */
 
-        if ( i == 0 )
+        if (i == 0)
             disp = 1;
 
 probe:
         if ((i -= disp) < 0)
             i += hsize_reg;
 
-        if (HashTabOf (i) == fcode) {
-            ent = CodeTabOf (i);
+        if (HashTabOf(i) == fcode) {
+            ent = CodeTabOf(i);
             continue;
         }
 
-        if ((long)HashTabOf (i) >= 0)
+        if ((long)HashTabOf(i) >= 0)
             goto probe;
 
 nomatch:
@@ -278,9 +279,10 @@ nomatch:
         ent = c;
 
         if (free_ent < maxmaxcode) {
-	    CodeTabOf (i) = (unsigned short)free_ent++; /* code -> hashtable */
-            HashTabOf (i) = fcode;
-        } else {
+            CodeTabOf(i) = (unsigned short)free_ent++; /* code -> hashtable */
+            HashTabOf(i) = fcode;
+        }
+        else {
             cl_block();
         }
     }
@@ -291,7 +293,6 @@ nomatch:
     output(EOFCode);
 }
 
-
 /*****************************************************************
  * TAG( output )
  *
@@ -309,11 +310,8 @@ nomatch:
  * code in turn.  When the buffer fills up empty it and start over.
  */
 
-static
-unsigned long masks[] = { 0x0000, 0x0001, 0x0003, 0x0007, 0x000F,
-                                  0x001F, 0x003F, 0x007F, 0x00FF,
-                                  0x01FF, 0x03FF, 0x07FF, 0x0FFF,
-                                  0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF };
+static unsigned long masks[] = {0x0000, 0x0001, 0x0003, 0x0007, 0x000F, 0x001F, 0x003F, 0x007F, 0x00FF,
+                                0x01FF, 0x03FF, 0x07FF, 0x0FFF, 0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF};
 
 static void
 output(int code)
@@ -327,8 +325,8 @@ output(int code)
 
     cur_bits += n_bits;
 
-    while( cur_bits >= 8 ) {
-        char_out( (int)((unsigned int) cur_accum & 0xff) );
+    while (cur_bits >= 8) {
+        char_out((int)((unsigned int)cur_accum & 0xff));
         cur_accum >>= 8;
         cur_bits -= 8;
     }
@@ -339,12 +337,13 @@ output(int code)
      */
     if (free_ent > maxcode || clear_flg) {
         if (clear_flg) {
-            maxcode = MAXCODE (n_bits = g_init_bits);
+            maxcode   = MAXCODE(n_bits = g_init_bits);
             clear_flg = 0;
-        } else {
+        }
+        else {
             n_bits++;
 
-            if ( n_bits == maxbits )
+            if (n_bits == maxbits)
                 maxcode = maxmaxcode;
             else
                 maxcode = MAXCODE(n_bits);
@@ -353,17 +352,17 @@ output(int code)
 
     if (code == EOFCode) {
         /* At EOF, write the rest of the buffer */
-        while( cur_bits > 0 ) {
-            char_out( (int)((unsigned int)cur_accum & 0xff) );
+        while (cur_bits > 0) {
+            char_out((int)((unsigned int)cur_accum & 0xff));
             cur_accum >>= 8;
             cur_bits -= 8;
         }
 
         flush_char();
-        fflush( g_outfile );
+        fflush(g_outfile);
 
 #ifdef FOO
-        if(ferror( g_outfile))
+        if (ferror(g_outfile))
             FatalError("unable to write GIF file");
 #endif
     }
@@ -371,45 +370,45 @@ output(int code)
 
 /********************************/
 static void
-cl_block(void)                  /* table clear for block compress */
+cl_block(void) /* table clear for block compress */
 {
     /* Clear out the hash table */
-    cl_hash((count_int) hsize);
-    free_ent = ClearCode + 2;
+    cl_hash((count_int)hsize);
+    free_ent  = ClearCode + 2;
     clear_flg = 1;
     output(ClearCode);
 }
 
 /********************************/
 static void
-cl_hash(count_int hashsize)     /* reset code table */
+cl_hash(count_int hashsize) /* reset code table */
 {
-    count_int *htab_p = htab+hashsize;
-    long i, m1 = -1;
+    count_int *htab_p = htab + hashsize;
+    long       i, m1 = -1;
 
     i = hashsize - 16;
 
-    do {    /* might use Sys V memset(3) here */
-        *(htab_p-16) = m1;
-        *(htab_p-15) = m1;
-        *(htab_p-14) = m1;
-        *(htab_p-13) = m1;
-        *(htab_p-12) = m1;
-        *(htab_p-11) = m1;
-        *(htab_p-10) = m1;
-        *(htab_p-9) = m1;
-        *(htab_p-8) = m1;
-        *(htab_p-7) = m1;
-        *(htab_p-6) = m1;
-        *(htab_p-5) = m1;
-        *(htab_p-4) = m1;
-        *(htab_p-3) = m1;
-        *(htab_p-2) = m1;
-        *(htab_p-1) = m1;
+    do { /* might use Sys V memset(3) here */
+        *(htab_p - 16) = m1;
+        *(htab_p - 15) = m1;
+        *(htab_p - 14) = m1;
+        *(htab_p - 13) = m1;
+        *(htab_p - 12) = m1;
+        *(htab_p - 11) = m1;
+        *(htab_p - 10) = m1;
+        *(htab_p - 9)  = m1;
+        *(htab_p - 8)  = m1;
+        *(htab_p - 7)  = m1;
+        *(htab_p - 6)  = m1;
+        *(htab_p - 5)  = m1;
+        *(htab_p - 4)  = m1;
+        *(htab_p - 3)  = m1;
+        *(htab_p - 2)  = m1;
+        *(htab_p - 1)  = m1;
         htab_p -= 16;
     } while ((i -= 16) >= 0);
 
-    for ( i += 16; i > 0; i-- )
+    for (i += 16; i > 0; i--)
         *--htab_p = m1;
 }
 
@@ -436,7 +435,7 @@ char_init(void)
 /*
  * Define the storage for the packet accumulator
  */
-static char accum[ 256 ];
+static char accum[256];
 
 /*
  * Add a character to the end of the current packet, and if it is 254
@@ -445,7 +444,7 @@ static char accum[ 256 ];
 static void
 char_out(int c)
 {
-    accum[ a_count++ ] = (char)c;
+    accum[a_count++] = (char)c;
 
     if (a_count >= 254)
         flush_char();
@@ -458,8 +457,8 @@ static void
 flush_char(void)
 {
     if (a_count > 0) {
-        fputc( a_count, g_outfile );
-        fwrite( accum, (size_t)1, (size_t)a_count, g_outfile);
+        fputc(a_count, g_outfile);
+        fwrite(accum, (size_t)1, (size_t)a_count, g_outfile);
         a_count = 0;
     }
 }