public inbox for linux-kernel@vger.kernel.org
 help / color / mirror / Atom feed
* [Patch] 2.5.70-bk9 kick FAR out of the zlib
@ 2003-06-05 19:46 Jörn Engel
  2003-06-05 20:09 ` [Patch] 2.5.70-bk9 zlib cleanup #2 ZEXTERN Jörn Engel
  2003-06-05 20:17 ` [Patch] 2.5.70-bk9 kick FAR out of the zlib Richard B. Johnson
  0 siblings, 2 replies; 11+ messages in thread
From: Jörn Engel @ 2003-06-05 19:46 UTC (permalink / raw)
  To: Linus Torvalds; +Cc: Steven Cole, linux-kernel

A while back:

On Fri, 30 May 2003 14:38:07 -0700, Linus Torvalds wrote:
> On Fri, 30 May 2003, Jörn Engel wrote:
> > 
> > How about an all or nothing approach?  If you really want to get rid
> > of K&R, change indentation as well, rip out some of the rather
> > tasteless macros (ZEXPORT, ZEXPORTVA, ZEXTERN, FAR, ...) and so on.
> 
> I'd love to, but I suspect we lack the motivation to do so, and there 
> aren't any obvious upsides. Yes, the code is ugly, but it's also fairly 
> stable so people seldom need to look at it.

Today was a lazy day and that is often motivation enough.  The patch
below removes FAR, the typedefs using FAR (Bytef and friends) and the
function prototypes for zalloc and zfree that should have gone earlier
already.

Hope you like it.

Jörn

-- 
When you close your hand, you own nothing. When you open it up, you
own the whole world.
-- Li Mu Bai in Tiger & Dragon


--- linux-2.5.70-bk9/include/linux/zconf.h~zlib_cleanup_FAR	2003-04-07 19:32:18.000000000 +0200
+++ linux-2.5.70-bk9/include/linux/zconf.h	2003-06-05 21:35:04.000000000 +0200
@@ -66,21 +66,10 @@
 #ifndef ZEXTERN
 #  define ZEXTERN extern
 #endif
-#ifndef FAR
-#   define FAR
-#endif
 
 typedef unsigned char  Byte;  /* 8 bits */
 typedef unsigned int   uInt;  /* 16 bits or more */
 typedef unsigned long  uLong; /* 32 bits or more */
-
-typedef Byte  FAR Bytef;
-typedef char  FAR charf;
-typedef int   FAR intf;
-typedef uInt  FAR uIntf;
-typedef uLong FAR uLongf;
-
-typedef void FAR *voidpf;
 typedef void     *voidp;
 
 #include <linux/types.h> /* for off_t */
--- linux-2.5.70-bk9/include/linux/zlib.h~zlib_cleanup_FAR	2003-06-05 18:26:01.000000000 +0200
+++ linux-2.5.70-bk9/include/linux/zlib.h	2003-06-05 21:30:48.000000000 +0200
@@ -60,22 +60,19 @@
   crash even in case of corrupted input.
 */
 
-typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size));
-typedef void   (*free_func)  OF((voidpf opaque, voidpf address));
-
 struct internal_state;
 
 typedef struct z_stream_s {
-    Bytef    *next_in;  /* next input byte */
+    Byte    *next_in;   /* next input byte */
     uInt     avail_in;  /* number of bytes available at next_in */
     uLong    total_in;  /* total nb of input bytes read so far */
 
-    Bytef    *next_out; /* next output byte should be put there */
+    Byte    *next_out;  /* next output byte should be put there */
     uInt     avail_out; /* remaining free space at next_out */
     uLong    total_out; /* total nb of bytes output so far */
 
     char     *msg;      /* last error message, NULL if no error */
-    struct internal_state FAR *state; /* not visible by applications */
+    struct internal_state *state; /* not visible by applications */
 
     void     *workspace; /* memory allocated for this stream */
     int      ws_num;    /* index in the internal workspace array */
@@ -85,7 +82,7 @@
     uLong   reserved;   /* reserved for future use */
 } z_stream;
 
-typedef z_stream FAR *z_streamp;
+typedef z_stream *z_streamp;
 
 /*
    The application must update next_in and avail_in when avail_in has
@@ -465,7 +462,7 @@
 */
                             
 ZEXTERN int ZEXPORT zlib_deflateSetDictionary OF((z_streamp strm,
-						     const Bytef *dictionary,
+						     const Byte *dictionary,
 						     uInt  dictLength));
 /*
      Initializes the compression dictionary from the given byte sequence
@@ -574,7 +571,7 @@
 */
 
 ZEXTERN int ZEXPORT zlib_inflateSetDictionary OF((z_streamp strm,
-						     const Bytef *dictionary,
+						     const Byte *dictionary,
 						     uInt  dictLength));
 /*
      Initializes the decompression dictionary from the given uncompressed byte
@@ -656,9 +653,9 @@
     struct internal_state {int dummy;}; /* hack for buggy compilers */
 #endif
 
-ZEXTERN const char   * ZEXPORT zlib_zError           OF((int err));
-ZEXTERN int            ZEXPORT zlib_inflateSyncPoint OF((z_streamp z));
-ZEXTERN const uLongf * ZEXPORT zlib_get_crc_table    OF((void));
+ZEXTERN const char  * ZEXPORT zlib_zError           OF((int err));
+ZEXTERN int           ZEXPORT zlib_inflateSyncPoint OF((z_streamp z));
+ZEXTERN const uLong * ZEXPORT zlib_get_crc_table    OF((void));
 
 #ifdef __cplusplus
 }
--- linux-2.5.70-bk9/include/linux/zutil.h~zlib_cleanup_FAR	2003-06-05 18:26:01.000000000 +0200
+++ linux-2.5.70-bk9/include/linux/zutil.h	2003-06-05 21:18:26.000000000 +0200
@@ -24,9 +24,7 @@
 /* compile with -Dlocal if your debugger can't find static symbols */
 
 typedef unsigned char  uch;
-typedef uch FAR uchf;
 typedef unsigned short ush;
-typedef ush FAR ushf;
 typedef unsigned long  ulg;
 
         /* common constants */
@@ -64,7 +62,7 @@
 
          /* functions */
 
-typedef uLong (ZEXPORT *check_func) OF((uLong check, const Bytef *buf,
+typedef uLong (ZEXPORT *check_func) OF((uLong check, const Byte *buf,
 				       uInt len));
 
 
@@ -96,7 +94,7 @@
      if (adler != original_adler) error();
 */
 static inline uLong zlib_adler32(uLong adler,
-				 const Bytef *buf,
+				 const Byte *buf,
 				 uInt len)
 {
     unsigned long s1 = adler & 0xffff;
--- linux-2.5.70-bk9/lib/zlib_deflate/deflate.c~zlib_cleanup_FAR	2003-06-05 20:54:12.000000000 +0200
+++ linux-2.5.70-bk9/lib/zlib_deflate/deflate.c	2003-06-05 21:20:57.000000000 +0200
@@ -73,7 +73,7 @@
 local void lm_init        OF((deflate_state *s));
 local void putShortMSB    OF((deflate_state *s, uInt b));
 local void flush_pending  OF((z_streamp strm));
-local int read_buf        OF((z_streamp strm, Bytef *buf, unsigned size));
+local int read_buf        OF((z_streamp strm, Byte *buf, unsigned size));
 local uInt longest_match  OF((deflate_state *s, IPos cur_match));
 
 #ifdef DEBUG_ZLIB
@@ -161,7 +161,7 @@
  */
 #define CLEAR_HASH(s) \
     s->head[s->hash_size-1] = NIL; \
-    memset((charf *)s->head, 0, (unsigned)(s->hash_size-1)*sizeof(*s->head));
+    memset((char *)s->head, 0, (unsigned)(s->hash_size-1)*sizeof(*s->head));
 
 /* ========================================================================= */
 int zlib_deflateInit_(
@@ -194,7 +194,7 @@
     static char* my_version = ZLIB_VERSION;
     deflate_workspace *mem;
 
-    ushf *overlay;
+    ush *overlay;
     /* We overlay pending_buf and d_buf+l_buf. This works since the average
      * output size for (length,distance) codes is <= 24 bits.
      */
@@ -222,7 +222,7 @@
         return Z_STREAM_ERROR;
     }
     s = (deflate_state *) &(mem->deflate_memory);
-    strm->state = (struct internal_state FAR *)s;
+    strm->state = (struct internal_state *)s;
     s->strm = strm;
 
     s->noheader = noheader;
@@ -235,14 +235,14 @@
     s->hash_mask = s->hash_size - 1;
     s->hash_shift =  ((s->hash_bits+MIN_MATCH-1)/MIN_MATCH);
 
-    s->window = (Bytef *) mem->window_memory;
-    s->prev   = (Posf *)  mem->prev_memory;
-    s->head   = (Posf *)  mem->head_memory;
+    s->window = (Byte *) mem->window_memory;
+    s->prev   = (Pos *)  mem->prev_memory;
+    s->head   = (Pos *)  mem->head_memory;
 
     s->lit_bufsize = 1 << (memLevel + 6); /* 16K elements by default */
 
-    overlay = (ushf *) mem->overlay_memory;
-    s->pending_buf = (uchf *) overlay;
+    overlay = (ush *) mem->overlay_memory;
+    s->pending_buf = (uch *) overlay;
     s->pending_buf_size = (ulg)s->lit_bufsize * (sizeof(ush)+2L);
 
     s->d_buf = overlay + s->lit_bufsize/sizeof(ush);
@@ -258,7 +258,7 @@
 /* ========================================================================= */
 int zlib_deflateSetDictionary(
 	z_streamp strm,
-	const Bytef *dictionary,
+	const Byte *dictionary,
 	uInt  dictLength
 )
 {
@@ -282,7 +282,7 @@
 	dictionary += dictLength - length; /* use the tail of the dictionary */
 #endif
     }
-    memcpy((charf *)s->window, dictionary, length);
+    memcpy((char *)s->window, dictionary, length);
     s->strstart = length;
     s->block_start = (long)length;
 
@@ -583,7 +583,7 @@
 #else
     deflate_state *ds;
     deflate_state *ss;
-    ushf *overlay;
+    ush *overlay;
     deflate_workspace *mem;
 
 
@@ -599,15 +599,15 @@
 
     ds = &(mem->deflate_memory);
 
-    dest->state = (struct internal_state FAR *) ds;
+    dest->state = (struct internal_state *) ds;
     *ds = *ss;
     ds->strm = dest;
 
-    ds->window = (Bytef *) mem->window_memory;
-    ds->prev   = (Posf *)  mem->prev_memory;
-    ds->head   = (Posf *)  mem->head_memory;
-    overlay = (ushf *) mem->overlay_memory;
-    ds->pending_buf = (uchf *) overlay;
+    ds->window = (Byte *) mem->window_memory;
+    ds->prev   = (Pos *)  mem->prev_memory;
+    ds->head   = (Pos *)  mem->head_memory;
+    overlay = (ush *) mem->overlay_memory;
+    ds->pending_buf = (uch *) overlay;
 
     memcpy(ds->window, ss->window, ds->w_size * 2 * sizeof(Byte));
     memcpy(ds->prev, ss->prev, ds->w_size * sizeof(Pos));
@@ -635,7 +635,7 @@
  */
 local int read_buf(
 	z_streamp strm,
-	Bytef *buf,
+	Byte *buf,
 	unsigned size
 )
 {
@@ -698,8 +698,8 @@
     IPos cur_match;                             /* current match */
 {
     unsigned chain_length = s->max_chain_length;/* max hash chain length */
-    register Bytef *scan = s->window + s->strstart; /* current string */
-    register Bytef *match;                       /* matched string */
+    register Byte *scan = s->window + s->strstart; /* current string */
+    register Byte *match;                       /* matched string */
     register int len;                           /* length of current match */
     int best_len = s->prev_length;              /* best match length so far */
     int nice_match = s->nice_match;             /* stop if match long enough */
@@ -708,18 +708,18 @@
     /* Stop when cur_match becomes <= limit. To simplify the code,
      * we prevent matches with the string of window index 0.
      */
-    Posf *prev = s->prev;
+    Pos *prev = s->prev;
     uInt wmask = s->w_mask;
 
 #ifdef UNALIGNED_OK
     /* Compare two bytes at a time. Note: this is not always beneficial.
      * Try with and without -DUNALIGNED_OK to check.
      */
-    register Bytef *strend = s->window + s->strstart + MAX_MATCH - 1;
-    register ush scan_start = *(ushf*)scan;
-    register ush scan_end   = *(ushf*)(scan+best_len-1);
+    register Byte *strend = s->window + s->strstart + MAX_MATCH - 1;
+    register ush scan_start = *(ush*)scan;
+    register ush scan_end   = *(ush*)(scan+best_len-1);
 #else
-    register Bytef *strend = s->window + s->strstart + MAX_MATCH;
+    register Byte *strend = s->window + s->strstart + MAX_MATCH;
     register Byte scan_end1  = scan[best_len-1];
     register Byte scan_end   = scan[best_len];
 #endif
@@ -751,8 +751,8 @@
         /* This code assumes sizeof(unsigned short) == 2. Do not use
          * UNALIGNED_OK if your compiler uses a different size.
          */
-        if (*(ushf*)(match+best_len-1) != scan_end ||
-            *(ushf*)match != scan_start) continue;
+        if (*(ush*)(match+best_len-1) != scan_end ||
+            *(ush*)match != scan_start) continue;
 
         /* It is not necessary to compare scan[2] and match[2] since they are
          * always equal when the other bytes match, given that the hash keys
@@ -766,10 +766,10 @@
         Assert(scan[2] == match[2], "scan[2]?");
         scan++, match++;
         do {
-        } while (*(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
-                 *(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
-                 *(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
-                 *(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
+        } while (*(ush*)(scan+=2) == *(ush*)(match+=2) &&
+                 *(ush*)(scan+=2) == *(ush*)(match+=2) &&
+                 *(ush*)(scan+=2) == *(ush*)(match+=2) &&
+                 *(ush*)(scan+=2) == *(ush*)(match+=2) &&
                  scan < strend);
         /* The funny "do {}" generates better code on most compilers */
 
@@ -818,7 +818,7 @@
             best_len = len;
             if (len >= nice_match) break;
 #ifdef UNALIGNED_OK
-            scan_end = *(ushf*)(scan+best_len-1);
+            scan_end = *(ush*)(scan+best_len-1);
 #else
             scan_end1  = scan[best_len-1];
             scan_end   = scan[best_len];
@@ -841,8 +841,8 @@
     int length;
 {
     /* check that the match is indeed a match */
-    if (memcmp((charf *)s->window + match,
-                (charf *)s->window + start, length) != EQUAL) {
+    if (memcmp((char *)s->window + match,
+                (char *)s->window + start, length) != EQUAL) {
         fprintf(stderr, " start %u, match %u, length %d\n",
 		start, match, length);
         do {
@@ -873,7 +873,7 @@
     deflate_state *s;
 {
     register unsigned n, m;
-    register Posf *p;
+    register Pos *p;
     unsigned more;    /* Amount of free space at the end of the window. */
     uInt wsize = s->w_size;
 
@@ -895,7 +895,7 @@
          */
         } else if (s->strstart >= wsize+MAX_DIST(s)) {
 
-            memcpy((charf *)s->window, (charf *)s->window+wsize,
+            memcpy((char *)s->window, (char *)s->window+wsize,
                    (unsigned)wsize);
             s->match_start -= wsize;
             s->strstart    -= wsize; /* we now have strstart >= MAX_DIST */
@@ -964,8 +964,8 @@
  */
 #define FLUSH_BLOCK_ONLY(s, eof) { \
    zlib_tr_flush_block(s, (s->block_start >= 0L ? \
-                   (charf *)&s->window[(unsigned)s->block_start] : \
-                   (charf *)Z_NULL), \
+                   (char *)&s->window[(unsigned)s->block_start] : \
+                   (char *)Z_NULL), \
 		(ulg)((long)s->strstart - s->block_start), \
 		(eof)); \
    s->block_start = s->strstart; \
--- linux-2.5.70-bk9/lib/zlib_deflate/deftree.c~zlib_cleanup_FAR	2003-06-05 17:48:50.000000000 +0200
+++ linux-2.5.70-bk9/lib/zlib_deflate/deftree.c	2003-06-05 21:23:40.000000000 +0200
@@ -113,7 +113,7 @@
 
 struct static_tree_desc_s {
     const ct_data *static_tree;  /* static tree or NULL */
-    const intf *extra_bits;      /* extra bits for each code or NULL */
+    const int *extra_bits;       /* extra bits for each code or NULL */
     int     extra_base;          /* base index for extra_bits */
     int     elems;               /* max number of elements in the tree */
     int     max_length;          /* max bit length for the codes */
@@ -136,7 +136,7 @@
 local void init_block     OF((deflate_state *s));
 local void pqdownheap     OF((deflate_state *s, ct_data *tree, int k));
 local void gen_bitlen     OF((deflate_state *s, tree_desc *desc));
-local void gen_codes      OF((ct_data *tree, int max_code, ushf *bl_count));
+local void gen_codes      OF((ct_data *tree, int max_code, ush *bl_count));
 local void build_tree     OF((deflate_state *s, tree_desc *desc));
 local void scan_tree      OF((deflate_state *s, ct_data *tree, int max_code));
 local void send_tree      OF((deflate_state *s, ct_data *tree, int max_code));
@@ -149,7 +149,7 @@
 local unsigned bi_reverse OF((unsigned value, int length));
 local void bi_windup      OF((deflate_state *s));
 local void bi_flush       OF((deflate_state *s));
-local void copy_block     OF((deflate_state *s, charf *buf, unsigned len,
+local void copy_block     OF((deflate_state *s, char *buf, unsigned len,
                               int header));
 
 #ifndef DEBUG_ZLIB
@@ -414,7 +414,7 @@
     ct_data *tree        = desc->dyn_tree;
     int max_code         = desc->max_code;
     const ct_data *stree = desc->stat_desc->static_tree;
-    const intf *extra    = desc->stat_desc->extra_bits;
+    const int *extra     = desc->stat_desc->extra_bits;
     int base             = desc->stat_desc->extra_base;
     int max_length       = desc->stat_desc->max_length;
     int h;              /* heap index */
@@ -497,7 +497,7 @@
 local void gen_codes(
 	ct_data *tree,             /* the tree to decorate */
 	int max_code,              /* largest code with non zero frequency */
-	ushf *bl_count             /* number of codes at each bit length */
+	ush *bl_count             /* number of codes at each bit length */
 )
 {
     ush next_code[MAX_BITS+1]; /* next code value for each bit length */
@@ -793,7 +793,7 @@
  */
 void zlib_tr_stored_block(
 	deflate_state *s,
-	charf *buf,       /* input block */
+	char *buf,        /* input block */
 	ulg stored_len,   /* length of input block */
 	int eof           /* true if this is the last block for a file */
 )
@@ -857,7 +857,7 @@
  */
 ulg zlib_tr_flush_block(
 	deflate_state *s,
-	charf *buf,       /* input block, or NULL if too old */
+	char *buf,        /* input block, or NULL if too old */
 	ulg stored_len,   /* length of input block */
 	int eof           /* true if this is the last block for a file */
 )
@@ -914,7 +914,7 @@
     if (stored_len <= opt_lenb && eof && s->compressed_len==0L && seekable()) {
 #  endif
         /* Since LIT_BUFSIZE <= 2*WSIZE, the input data must be there: */
-        if (buf == (charf*)0) error ("block vanished");
+        if (buf == (char*)0) error ("block vanished");
 
         copy_block(s, buf, (unsigned)stored_len, 0); /* without header */
         s->compressed_len = stored_len << 3;
@@ -1090,7 +1090,7 @@
  */
 local void copy_block(
 	deflate_state *s,
-	charf    *buf,    /* the input data */
+	char    *buf,     /* the input data */
 	unsigned len,     /* its length */
 	int      header   /* true if block header must be written */
 )
--- linux-2.5.70-bk9/lib/zlib_deflate/defutil.h~zlib_cleanup_FAR	2003-06-05 20:54:12.000000000 +0200
+++ linux-2.5.70-bk9/lib/zlib_deflate/defutil.h	2003-06-05 21:22:04.000000000 +0200
@@ -46,7 +46,7 @@
         ush  dad;        /* father node in Huffman tree */
         ush  len;        /* length of bit string */
     } dl;
-} FAR ct_data;
+} ct_data;
 
 #define Freq fc.freq
 #define Code fc.code
@@ -59,10 +59,9 @@
     ct_data *dyn_tree;           /* the dynamic tree */
     int     max_code;            /* largest code with non zero frequency */
     static_tree_desc *stat_desc; /* the corresponding static tree */
-} FAR tree_desc;
+} tree_desc;
 
 typedef ush Pos;
-typedef Pos FAR Posf;
 typedef unsigned IPos;
 
 /* A Pos is an index in the character window. We use short instead of int to
@@ -72,9 +71,9 @@
 typedef struct deflate_state {
     z_streamp strm;      /* pointer back to this zlib stream */
     int   status;        /* as the name implies */
-    Bytef *pending_buf;  /* output still pending */
+    Byte *pending_buf;   /* output still pending */
     ulg   pending_buf_size; /* size of pending_buf */
-    Bytef *pending_out;  /* next pending byte to output to the stream */
+    Byte *pending_out;   /* next pending byte to output to the stream */
     int   pending;       /* nb of bytes in the pending buffer */
     int   noheader;      /* suppress zlib header and adler32 */
     Byte  data_type;     /* UNKNOWN, BINARY or ASCII */
@@ -87,7 +86,7 @@
     uInt  w_bits;        /* log2(w_size)  (8..16) */
     uInt  w_mask;        /* w_size - 1 */
 
-    Bytef *window;
+    Byte *window;
     /* Sliding window. Input bytes are read into the second half of the window,
      * and move to the first half later to keep a dictionary of at least wSize
      * bytes. With this organization, matches are limited to a distance of
@@ -102,13 +101,13 @@
      * is directly used as sliding window.
      */
 
-    Posf *prev;
+    Pos *prev;
     /* Link to older string with same hash index. To limit the size of this
      * array to 64K, this link is maintained only for the last 32K strings.
      * An index in this array is thus a window index modulo 32K.
      */
 
-    Posf *head; /* Heads of the hash chains or NIL. */
+    Pos *head; /* Heads of the hash chains or NIL. */
 
     uInt  ins_h;          /* hash index of string to be inserted */
     uInt  hash_size;      /* number of elements in hash table */
@@ -188,7 +187,7 @@
     /* Depth of each subtree used as tie breaker for trees of equal frequency
      */
 
-    uchf *l_buf;          /* buffer for literals or lengths */
+    uch *l_buf;          /* buffer for literals or lengths */
 
     uInt  lit_bufsize;
     /* Size of match buffer for literals/lengths.  There are 4 reasons for
@@ -212,7 +211,7 @@
 
     uInt last_lit;      /* running index in l_buf */
 
-    ushf *d_buf;
+    ush *d_buf;
     /* Buffer for distances. To simplify the code, d_buf and l_buf have
      * the same number of elements. To use different lengths, an extra flag
      * array would be necessary.
@@ -237,7 +236,7 @@
      * are always zero.
      */
 
-} FAR deflate_state;
+} deflate_state;
 
 typedef struct deflate_workspace {
     /* State memory for the deflator */
@@ -267,10 +266,10 @@
         /* in trees.c */
 void zlib_tr_init         OF((deflate_state *s));
 int  zlib_tr_tally        OF((deflate_state *s, unsigned dist, unsigned lc));
-ulg  zlib_tr_flush_block  OF((deflate_state *s, charf *buf, ulg stored_len,
+ulg  zlib_tr_flush_block  OF((deflate_state *s, char *buf, ulg stored_len,
 			      int eof));
 void zlib_tr_align        OF((deflate_state *s));
-void zlib_tr_stored_block OF((deflate_state *s, charf *buf, ulg stored_len,
+void zlib_tr_stored_block OF((deflate_state *s, char *buf, ulg stored_len,
 			      int eof));
 void zlib_tr_stored_type_only OF((deflate_state *));
 
--- linux-2.5.70-bk9/lib/zlib_inflate/infcodes.c~zlib_cleanup_FAR	2003-06-05 17:48:50.000000000 +0200
+++ linux-2.5.70-bk9/lib/zlib_inflate/infcodes.c	2003-06-05 21:12:06.000000000 +0200
@@ -47,11 +47,11 @@
   uInt e;               /* extra bits or operation */
   uLong b;              /* bit buffer */
   uInt k;               /* bits in bit buffer */
-  Bytef *p;             /* input data pointer */
+  Byte *p;              /* input data pointer */
   uInt n;               /* bytes available there */
-  Bytef *q;             /* output window write pointer */
+  Byte *q;              /* output window write pointer */
   uInt m;               /* bytes to end of window or read pointer */
-  Bytef *f;             /* pointer to copy strings from */
+  Byte *f;              /* pointer to copy strings from */
   inflate_codes_statef *c = s->sub.decode.codes;  /* codes state */
 
   /* copy input/output information to locals (UPDATE macro restores) */
--- linux-2.5.70-bk9/lib/zlib_inflate/infcodes.h~zlib_cleanup_FAR	2003-04-07 19:30:59.000000000 +0200
+++ linux-2.5.70-bk9/lib/zlib_inflate/infcodes.h	2003-06-05 21:34:12.000000000 +0200
@@ -14,7 +14,7 @@
 #include "infblock.h"
 
 struct inflate_codes_state;
-typedef struct inflate_codes_state FAR inflate_codes_statef;
+typedef struct inflate_codes_state inflate_codes_statef;
 
 extern inflate_codes_statef *zlib_inflate_codes_new OF((
     uInt, uInt,
--- linux-2.5.70-bk9/lib/zlib_inflate/inftrees.c~zlib_cleanup_FAR	2003-06-05 20:54:12.000000000 +0200
+++ linux-2.5.70-bk9/lib/zlib_inflate/inftrees.c	2003-06-05 21:26:36.000000000 +0200
@@ -23,16 +23,16 @@
 
 
 local int huft_build OF((
-    uIntf *,            /* code lengths in bits */
+    uInt *,             /* code lengths in bits */
     uInt,               /* number of codes */
     uInt,               /* number of "simple" codes */
-    const uIntf *,      /* list of base values for non-simple codes */
-    const uIntf *,      /* list of extra bits for non-simple codes */
-    inflate_huft * FAR*,/* result: starting table */
-    uIntf *,            /* maximum lookup bits (returns actual) */
+    const uInt *,       /* list of base values for non-simple codes */
+    const uInt *,       /* list of extra bits for non-simple codes */
+    inflate_huft **,    /* result: starting table */
+    uInt *,             /* maximum lookup bits (returns actual) */
     inflate_huft *,     /* space for trees */
     uInt *,             /* hufts used in space */
-    uIntf * ));         /* space for values */
+    uInt * ));          /* space for values */
 
 /* Tables for deflate from PKZIP's appnote.txt. */
 local const uInt cplens[31] = { /* Copy lengths for literal codes 257..285 */
@@ -88,16 +88,16 @@
 #define BMAX 15         /* maximum bit length of any code */
 
 local int huft_build(
-	uIntf *b,               /* code lengths in bits (all assumed <= BMAX) */
-	uInt n,                 /* number of codes (assumed <= 288) */
-	uInt s,                 /* number of simple-valued codes (0..s-1) */
-	const uIntf *d,         /* list of base values for non-simple codes */
-	const uIntf *e,         /* list of extra bits for non-simple codes */
-	inflate_huft * FAR *t,  /* result: starting table */
-	uIntf *m,               /* maximum lookup bits, returns actual */
-	inflate_huft *hp,       /* space for trees */
-	uInt *hn,               /* hufts used in space */
-	uIntf *v                /* working area: values in order of bit length */
+	uInt *b,               /* code lengths in bits (all assumed <= BMAX) */
+	uInt n,                /* number of codes (assumed <= 288) */
+	uInt s,                /* number of simple-valued codes (0..s-1) */
+	const uInt *d,         /* list of base values for non-simple codes */
+	const uInt *e,         /* list of extra bits for non-simple codes */
+	inflate_huft **t,      /* result: starting table */
+	uInt *m,               /* maximum lookup bits, returns actual */
+	inflate_huft *hp,      /* space for trees */
+	uInt *hn,              /* hufts used in space */
+	uInt *v                /* working area: values in order of bit length */
 )
 /* Given a list of code lengths and a maximum table size, make a set of
    tables to decode that set of codes.  Return Z_OK on success, Z_BUF_ERROR
@@ -116,13 +116,13 @@
   register int k;               /* number of bits in current code */
   int l;                        /* bits per table (returned in m) */
   uInt mask;                    /* (1 << w) - 1, to avoid cc -O bug on HP */
-  register uIntf *p;            /* pointer into c[], b[], or v[] */
+  register uInt *p;             /* pointer into c[], b[], or v[] */
   inflate_huft *q;              /* points to current table */
   struct inflate_huft_s r;      /* table entry for structure assignment */
   inflate_huft *u[BMAX];        /* table stack */
   register int w;               /* bits before this table == (l * h) */
   uInt x[BMAX+1];               /* bit offsets, then code stack */
-  uIntf *xp;                    /* pointer into x */
+  uInt *xp;                     /* pointer into x */
   int y;                        /* number of dummy codes added */
   uInt z;                       /* number of entries in current table */
 
@@ -290,19 +290,19 @@
 
 
 int zlib_inflate_trees_bits(
-	uIntf *c,               /* 19 code lengths */
-	uIntf *bb,              /* bits tree desired/actual depth */
-	inflate_huft * FAR *tb, /* bits tree result */
+	uInt *c,                /* 19 code lengths */
+	uInt *bb,               /* bits tree desired/actual depth */
+	inflate_huft **tb,      /* bits tree result */
 	inflate_huft *hp,       /* space for trees */
 	z_streamp z             /* for messages */
 )
 {
   int r;
   uInt hn = 0;          /* hufts used in space */
-  uIntf *v;             /* work area for huft_build */
+  uInt *v;              /* work area for huft_build */
   
   v = WS(z)->tree_work_area_1;
-  r = huft_build(c, 19, 19, (uIntf*)Z_NULL, (uIntf*)Z_NULL,
+  r = huft_build(c, 19, 19, (uInt*)Z_NULL, (uInt*)Z_NULL,
                  tb, bb, hp, &hn, v);
   if (r == Z_DATA_ERROR)
     z->msg = (char*)"oversubscribed dynamic bit lengths tree";
@@ -317,18 +317,18 @@
 int zlib_inflate_trees_dynamic(
 	uInt nl,                /* number of literal/length codes */
 	uInt nd,                /* number of distance codes */
-	uIntf *c,               /* that many (total) code lengths */
-	uIntf *bl,              /* literal desired/actual bit depth */
-	uIntf *bd,              /* distance desired/actual bit depth */
-	inflate_huft * FAR *tl, /* literal/length tree result */
-	inflate_huft * FAR *td, /* distance tree result */
+	uInt *c,                /* that many (total) code lengths */
+	uInt *bl,               /* literal desired/actual bit depth */
+	uInt *bd,               /* distance desired/actual bit depth */
+	inflate_huft **tl,      /* literal/length tree result */
+	inflate_huft **td,      /* distance tree result */
 	inflate_huft *hp,       /* space for trees */
 	z_streamp z             /* for messages */
 )
 {
   int r;
   uInt hn = 0;          /* hufts used in space */
-  uIntf *v;             /* work area for huft_build */
+  uInt *v;              /* work area for huft_build */
 
   /* allocate work area */
   v = WS(z)->tree_work_area_2;
@@ -380,10 +380,10 @@
 
 
 int zlib_inflate_trees_fixed(
-	uIntf *bl,               /* literal desired/actual bit depth */
-	uIntf *bd,               /* distance desired/actual bit depth */
-	inflate_huft * FAR *tl,  /* literal/length tree result */
-	inflate_huft * FAR *td,  /* distance tree result */
+	uInt *bl,                /* literal desired/actual bit depth */
+	uInt *bd,                /* distance desired/actual bit depth */
+	inflate_huft **tl,       /* literal/length tree result */
+	inflate_huft **td,       /* distance tree result */
 	z_streamp z              /* for memory allocation */
 )
 {
--- linux-2.5.70-bk9/lib/zlib_inflate/inftrees.h~zlib_cleanup_FAR	2003-06-05 20:54:12.000000000 +0200
+++ linux-2.5.70-bk9/lib/zlib_inflate/inftrees.h	2003-06-05 21:34:42.000000000 +0200
@@ -14,7 +14,7 @@
 #ifndef _INFTREES_H
 #define _INFTREES_H
 
-typedef struct inflate_huft_s FAR inflate_huft;
+typedef struct inflate_huft_s inflate_huft;
 
 struct inflate_huft_s {
   union {
@@ -36,28 +36,28 @@
 #define MANY 1440
 
 extern int zlib_inflate_trees_bits OF((
-    uIntf *,                    /* 19 code lengths */
-    uIntf *,                    /* bits tree desired/actual depth */
-    inflate_huft * FAR *,       /* bits tree result */
+    uInt *,                     /* 19 code lengths */
+    uInt *,                     /* bits tree desired/actual depth */
+    inflate_huft **,            /* bits tree result */
     inflate_huft *,             /* space for trees */
     z_streamp));                /* for messages */
 
 extern int zlib_inflate_trees_dynamic OF((
     uInt,                       /* number of literal/length codes */
     uInt,                       /* number of distance codes */
-    uIntf *,                    /* that many (total) code lengths */
-    uIntf *,                    /* literal desired/actual bit depth */
-    uIntf *,                    /* distance desired/actual bit depth */
-    inflate_huft * FAR *,       /* literal/length tree result */
-    inflate_huft * FAR *,       /* distance tree result */
+    uInt *,                     /* that many (total) code lengths */
+    uInt *,                     /* literal desired/actual bit depth */
+    uInt *,                     /* distance desired/actual bit depth */
+    inflate_huft **,            /* literal/length tree result */
+    inflate_huft **,            /* distance tree result */
     inflate_huft *,             /* space for trees */
     z_streamp));                /* for messages */
 
 extern int zlib_inflate_trees_fixed OF((
-    uIntf *,                    /* literal desired/actual bit depth */
-    uIntf *,                    /* distance desired/actual bit depth */
-    inflate_huft * FAR *,       /* literal/length tree result */
-    inflate_huft * FAR *,       /* distance tree result */
+    uInt *,                     /* literal desired/actual bit depth */
+    uInt *,                     /* distance desired/actual bit depth */
+    inflate_huft **,            /* literal/length tree result */
+    inflate_huft **,            /* distance tree result */
     z_streamp));                /* for memory allocation */
 
 #endif /* _INFTREES_H */
--- linux-2.5.70-bk9/lib/zlib_inflate/infblock.c~zlib_cleanup_FAR	2003-06-05 17:48:50.000000000 +0200
+++ linux-2.5.70-bk9/lib/zlib_inflate/infblock.c	2003-06-05 21:28:38.000000000 +0200
@@ -68,7 +68,7 @@
 void zlib_inflate_blocks_reset(
 	inflate_blocks_statef *s,
 	z_streamp z,
-	uLongf *c
+	uLong *c
 )
 {
   if (c != Z_NULL)
@@ -80,7 +80,7 @@
   s->bitb = 0;
   s->read = s->write = s->window;
   if (s->checkfn != Z_NULL)
-    z->adler = s->check = (*s->checkfn)(0L, (const Bytef *)Z_NULL, 0);
+    z->adler = s->check = (*s->checkfn)(0L, (const Byte *)Z_NULL, 0);
 }
 
 inflate_blocks_statef *zlib_inflate_blocks_new(
@@ -111,9 +111,9 @@
   uInt t;               /* temporary storage */
   uLong b;              /* bit buffer */
   uInt k;               /* bits in bit buffer */
-  Bytef *p;             /* input data pointer */
+  Byte *p;              /* input data pointer */
   uInt n;               /* bytes available there */
-  Bytef *q;             /* output window write pointer */
+  Byte *q;              /* output window write pointer */
   uInt m;               /* bytes to end of window or read pointer */
 
   /* copy input/output information to locals (UPDATE macro restores) */
@@ -340,7 +340,7 @@
 
 void zlib_inflate_set_dictionary(
 	inflate_blocks_statef *s,
-	const Bytef *d,
+	const Byte *d,
 	uInt  n
 )
 {
--- linux-2.5.70-bk9/lib/zlib_inflate/inffast.c~zlib_cleanup_FAR	2003-06-05 17:48:50.000000000 +0200
+++ linux-2.5.70-bk9/lib/zlib_inflate/inffast.c	2003-06-05 21:15:43.000000000 +0200
@@ -38,15 +38,15 @@
   uInt e;               /* extra bits or operation */
   uLong b;              /* bit buffer */
   uInt k;               /* bits in bit buffer */
-  Bytef *p;             /* input data pointer */
+  Byte *p;              /* input data pointer */
   uInt n;               /* bytes available there */
-  Bytef *q;             /* output window write pointer */
+  Byte *q;              /* output window write pointer */
   uInt m;               /* bytes to end of window or read pointer */
   uInt ml;              /* mask for literal/length tree */
   uInt md;              /* mask for distance tree */
   uInt c;               /* bytes to copy */
   uInt d;               /* distance back to copy from */
-  Bytef *r;             /* copy source pointer */
+  Byte *r;              /* copy source pointer */
 
   /* load input, output, bit values */
   LOAD
--- linux-2.5.70-bk9/lib/zlib_inflate/infutil.h~zlib_cleanup_FAR	2003-04-07 19:32:17.000000000 +0200
+++ linux-2.5.70-bk9/lib/zlib_inflate/infutil.h	2003-06-05 21:27:33.000000000 +0200
@@ -40,7 +40,7 @@
     struct {
       uInt table;               /* table lengths (14 bits) */
       uInt index;               /* index into blens (or border) */
-      uIntf *blens;             /* bit lengths of codes */
+      uInt *blens;              /* bit lengths of codes */
       uInt bb;                  /* bit length tree depth */
       inflate_huft *tb;         /* bit length decoding tree */
     } trees;            /* if DTREE, decoding info for trees */
@@ -55,10 +55,10 @@
   uInt bitk;            /* bits in bit buffer */
   uLong bitb;           /* bit buffer */
   inflate_huft *hufts;  /* single malloc for tree space */
-  Bytef *window;        /* sliding window */
-  Bytef *end;           /* one byte after sliding window */
-  Bytef *read;          /* window read pointer */
-  Bytef *write;         /* window write pointer */
+  Byte *window;         /* sliding window */
+  Byte *end;            /* one byte after sliding window */
+  Byte *read;           /* window read pointer */
+  Byte *write;          /* window write pointer */
   check_func checkfn;   /* check function */
   uLong check;          /* check on output */
 
--- linux-2.5.70-bk9/lib/zlib_inflate/infutil.c~zlib_cleanup_FAR	2003-06-05 17:48:50.000000000 +0200
+++ linux-2.5.70-bk9/lib/zlib_inflate/infutil.c	2003-06-05 21:17:26.000000000 +0200
@@ -27,8 +27,8 @@
 )
 {
   uInt n;
-  Bytef *p;
-  Bytef *q;
+  Byte *p;
+  Byte *q;
 
   /* local copies of source and destination pointers */
   p = z->next_out;
--- linux-2.5.70-bk9/lib/zlib_inflate/infblock.h~zlib_cleanup_FAR	2003-04-07 19:31:47.000000000 +0200
+++ linux-2.5.70-bk9/lib/zlib_inflate/infblock.h	2003-06-05 21:34:33.000000000 +0200
@@ -12,7 +12,7 @@
 #define _INFBLOCK_H
 
 struct inflate_blocks_state;
-typedef struct inflate_blocks_state FAR inflate_blocks_statef;
+typedef struct inflate_blocks_state inflate_blocks_statef;
 
 extern inflate_blocks_statef * zlib_inflate_blocks_new OF((
     z_streamp z,
@@ -27,7 +27,7 @@
 extern void zlib_inflate_blocks_reset OF((
     inflate_blocks_statef *,
     z_streamp ,
-    uLongf *));                  /* check value on output */
+    uLong *));                  /* check value on output */
 
 extern int zlib_inflate_blocks_free OF((
     inflate_blocks_statef *,
@@ -35,7 +35,7 @@
 
 extern void zlib_inflate_set_dictionary OF((
     inflate_blocks_statef *s,
-    const Bytef *d,  /* dictionary */
+    const Byte *d,   /* dictionary */
     uInt  n));       /* dictionary length */
 
 extern int zlib_inflate_blocks_sync_point OF((

^ permalink raw reply	[flat|nested] 11+ messages in thread
end of thread, other threads:[~2003-06-06 14:35 UTC | newest]

Thread overview: 11+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2003-06-05 19:46 [Patch] 2.5.70-bk9 kick FAR out of the zlib Jörn Engel
2003-06-05 20:09 ` [Patch] 2.5.70-bk9 zlib cleanup #2 ZEXTERN Jörn Engel
2003-06-05 20:18   ` [Patch] 2.5.70-bk9 zlib cleanup #3 ZEXPORT Jörn Engel
2003-06-05 20:33     ` [Patch] 2.5.70-bk9 zlib cleanup #4 z_off_t Jörn Engel
2003-06-05 20:38       ` Jörn Engel
2003-06-05 20:42         ` Jörn Engel
2003-06-05 20:49       ` [Patch] 2.5.70-bk9 zlib cleanup #5 __32BIT__ and STDC Jörn Engel
2003-06-05 21:14         ` [Patch] 2.5.70-bk9 zlib cleanup #6 OF Jörn Engel
2003-06-05 20:17 ` [Patch] 2.5.70-bk9 kick FAR out of the zlib Richard B. Johnson
2003-06-05 20:31   ` Jörn Engel
2003-06-06 14:49     ` Nicholas Wourms

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox