summaryrefslogtreecommitdiff
path: root/cpan/Compress-Raw-Zlib
diff options
context:
space:
mode:
authorChris 'BinGOs' Williams <chris@bingosnet.co.uk>2012-03-13 09:43:17 +0000
committerChris 'BinGOs' Williams <chris@bingosnet.co.uk>2012-03-13 09:43:17 +0000
commita7026383bc5a2ca5f518f670ee6d74d55cd994aa (patch)
tree08ad849c1dec4b42ea347fa69f2ddca6298ba11f /cpan/Compress-Raw-Zlib
parentadace0595a25c5339a4c1fff6b4704945abf8814 (diff)
downloadperl-a7026383bc5a2ca5f518f670ee6d74d55cd994aa.tar.gz
Ran zlib2ansi script against zlib-src/ to fix K&R-isms
Diffstat (limited to 'cpan/Compress-Raw-Zlib')
-rw-r--r--cpan/Compress-Raw-Zlib/zlib-src/adler32.c32
-rw-r--r--cpan/Compress-Raw-Zlib/zlib-src/compress.c26
-rw-r--r--cpan/Compress-Raw-Zlib/zlib-src/crc32.c66
-rw-r--r--cpan/Compress-Raw-Zlib/zlib-src/deflate.c186
-rw-r--r--cpan/Compress-Raw-Zlib/zlib-src/infback.c32
-rw-r--r--cpan/Compress-Raw-Zlib/zlib-src/inffast.c6
-rw-r--r--cpan/Compress-Raw-Zlib/zlib-src/inflate.c106
-rw-r--r--cpan/Compress-Raw-Zlib/zlib-src/inftrees.c14
-rw-r--r--cpan/Compress-Raw-Zlib/zlib-src/trees.c144
-rw-r--r--cpan/Compress-Raw-Zlib/zlib-src/uncompr.c10
-rw-r--r--cpan/Compress-Raw-Zlib/zlib-src/zutil.c44
11 files changed, 334 insertions, 332 deletions
diff --git a/cpan/Compress-Raw-Zlib/zlib-src/adler32.c b/cpan/Compress-Raw-Zlib/zlib-src/adler32.c
index a868f073d8..82a84ceed2 100644
--- a/cpan/Compress-Raw-Zlib/zlib-src/adler32.c
+++ b/cpan/Compress-Raw-Zlib/zlib-src/adler32.c
@@ -62,10 +62,10 @@ local uLong adler32_combine_ OF((uLong adler1, uLong adler2, z_off64_t len2));
#endif
/* ========================================================================= */
-uLong ZEXPORT adler32(adler, buf, len)
- uLong adler;
- const Bytef *buf;
- uInt len;
+uLong ZEXPORT adler32(
+ uLong adler,
+ const Bytef *buf,
+ uInt len)
{
unsigned long sum2;
unsigned n;
@@ -133,10 +133,10 @@ uLong ZEXPORT adler32(adler, buf, len)
}
/* ========================================================================= */
-local uLong adler32_combine_(adler1, adler2, len2)
- uLong adler1;
- uLong adler2;
- z_off64_t len2;
+local uLong adler32_combine_(
+ uLong adler1,
+ uLong adler2,
+ z_off64_t len2)
{
unsigned long sum1;
unsigned long sum2;
@@ -162,18 +162,18 @@ local uLong adler32_combine_(adler1, adler2, len2)
}
/* ========================================================================= */
-uLong ZEXPORT adler32_combine(adler1, adler2, len2)
- uLong adler1;
- uLong adler2;
- z_off_t len2;
+uLong ZEXPORT adler32_combine(
+ uLong adler1,
+ uLong adler2,
+ z_off_t len2)
{
return adler32_combine_(adler1, adler2, len2);
}
-uLong ZEXPORT adler32_combine64(adler1, adler2, len2)
- uLong adler1;
- uLong adler2;
- z_off64_t len2;
+uLong ZEXPORT adler32_combine64(
+ uLong adler1,
+ uLong adler2,
+ z_off64_t len2)
{
return adler32_combine_(adler1, adler2, len2);
}
diff --git a/cpan/Compress-Raw-Zlib/zlib-src/compress.c b/cpan/Compress-Raw-Zlib/zlib-src/compress.c
index ea4dfbe9d7..1cb602b92e 100644
--- a/cpan/Compress-Raw-Zlib/zlib-src/compress.c
+++ b/cpan/Compress-Raw-Zlib/zlib-src/compress.c
@@ -19,12 +19,12 @@
memory, Z_BUF_ERROR if there was not enough room in the output buffer,
Z_STREAM_ERROR if the level parameter is invalid.
*/
-int ZEXPORT compress2 (dest, destLen, source, sourceLen, level)
- Bytef *dest;
- uLongf *destLen;
- const Bytef *source;
- uLong sourceLen;
- int level;
+int ZEXPORT compress2 (
+ Bytef *dest,
+ uLongf *destLen,
+ const Bytef *source,
+ uLong sourceLen,
+ int level)
{
z_stream stream;
int err;
@@ -59,11 +59,11 @@ int ZEXPORT compress2 (dest, destLen, source, sourceLen, level)
/* ===========================================================================
*/
-int ZEXPORT compress (dest, destLen, source, sourceLen)
- Bytef *dest;
- uLongf *destLen;
- const Bytef *source;
- uLong sourceLen;
+int ZEXPORT compress (
+ Bytef *dest,
+ uLongf *destLen,
+ const Bytef *source,
+ uLong sourceLen)
{
return compress2(dest, destLen, source, sourceLen, Z_DEFAULT_COMPRESSION);
}
@@ -72,8 +72,8 @@ int ZEXPORT compress (dest, destLen, source, sourceLen)
If the default memLevel or windowBits for deflateInit() is changed, then
this function needs to be updated.
*/
-uLong ZEXPORT compressBound (sourceLen)
- uLong sourceLen;
+uLong ZEXPORT compressBound (
+ uLong sourceLen)
{
return sourceLen + (sourceLen >> 12) + (sourceLen >> 14) +
(sourceLen >> 25) + 13;
diff --git a/cpan/Compress-Raw-Zlib/zlib-src/crc32.c b/cpan/Compress-Raw-Zlib/zlib-src/crc32.c
index ddf0025c05..dfe5aa14cd 100644
--- a/cpan/Compress-Raw-Zlib/zlib-src/crc32.c
+++ b/cpan/Compress-Raw-Zlib/zlib-src/crc32.c
@@ -189,9 +189,9 @@ local void make_crc_table()
}
#ifdef MAKECRCH
-local void write_table(out, table)
- FILE *out;
- const crc_table_t FAR *table;
+local void write_table(
+ FILE *out,
+ const crc_table_t FAR *table)
{
int n;
@@ -226,10 +226,10 @@ const unsigned long FAR * ZEXPORT get_crc_table()
#define DO8 DO1; DO1; DO1; DO1; DO1; DO1; DO1; DO1
/* ========================================================================= */
-unsigned long ZEXPORT crc32(crc, buf, len)
- unsigned long crc;
- const unsigned char FAR *buf;
- uInt len;
+unsigned long ZEXPORT crc32(
+ unsigned long crc,
+ const unsigned char FAR *buf,
+ uInt len)
{
if (buf == Z_NULL) return 0UL;
@@ -269,10 +269,10 @@ unsigned long ZEXPORT crc32(crc, buf, len)
#define DOLIT32 DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4
/* ========================================================================= */
-local unsigned long crc32_little(crc, buf, len)
- unsigned long crc;
- const unsigned char FAR *buf;
- unsigned len;
+local unsigned long crc32_little(
+ unsigned long crc,
+ const unsigned char FAR *buf,
+ unsigned len)
{
register u4 c;
register const u4 FAR *buf4;
@@ -309,10 +309,10 @@ local unsigned long crc32_little(crc, buf, len)
#define DOBIG32 DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4
/* ========================================================================= */
-local unsigned long crc32_big(crc, buf, len)
- unsigned long crc;
- const unsigned char FAR *buf;
- unsigned len;
+local unsigned long crc32_big(
+ unsigned long crc,
+ const unsigned char FAR *buf,
+ unsigned len)
{
register u4 c;
register const u4 FAR *buf4;
@@ -349,9 +349,9 @@ local unsigned long crc32_big(crc, buf, len)
#define GF2_DIM 32 /* dimension of GF(2) vectors (length of CRC) */
/* ========================================================================= */
-local unsigned long gf2_matrix_times(mat, vec)
- unsigned long *mat;
- unsigned long vec;
+local unsigned long gf2_matrix_times(
+ unsigned long *mat,
+ unsigned long vec)
{
unsigned long sum;
@@ -366,9 +366,9 @@ local unsigned long gf2_matrix_times(mat, vec)
}
/* ========================================================================= */
-local void gf2_matrix_square(square, mat)
- unsigned long *square;
- unsigned long *mat;
+local void gf2_matrix_square(
+ unsigned long *square,
+ unsigned long *mat)
{
int n;
@@ -377,10 +377,10 @@ local void gf2_matrix_square(square, mat)
}
/* ========================================================================= */
-local uLong crc32_combine_(crc1, crc2, len2)
- uLong crc1;
- uLong crc2;
- z_off64_t len2;
+local uLong crc32_combine_(
+ uLong crc1,
+ uLong crc2,
+ z_off64_t len2)
{
int n;
unsigned long row;
@@ -433,18 +433,18 @@ local uLong crc32_combine_(crc1, crc2, len2)
}
/* ========================================================================= */
-uLong ZEXPORT crc32_combine(crc1, crc2, len2)
- uLong crc1;
- uLong crc2;
- z_off_t len2;
+uLong ZEXPORT crc32_combine(
+ uLong crc1,
+ uLong crc2,
+ z_off_t len2)
{
return crc32_combine_(crc1, crc2, len2);
}
-uLong ZEXPORT crc32_combine64(crc1, crc2, len2)
- uLong crc1;
- uLong crc2;
- z_off64_t len2;
+uLong ZEXPORT crc32_combine64(
+ uLong crc1,
+ uLong crc2,
+ z_off64_t len2)
{
return crc32_combine_(crc1, crc2, len2);
}
diff --git a/cpan/Compress-Raw-Zlib/zlib-src/deflate.c b/cpan/Compress-Raw-Zlib/zlib-src/deflate.c
index 8bd480eb68..51ca50747a 100644
--- a/cpan/Compress-Raw-Zlib/zlib-src/deflate.c
+++ b/cpan/Compress-Raw-Zlib/zlib-src/deflate.c
@@ -198,11 +198,11 @@ struct static_tree_desc_s {int dummy;}; /* for buggy compilers */
zmemzero((Bytef *)s->head, (unsigned)(s->hash_size-1)*sizeof(*s->head));
/* ========================================================================= */
-int ZEXPORT deflateInit_(strm, level, version, stream_size)
- z_streamp strm;
- int level;
- const char *version;
- int stream_size;
+int ZEXPORT deflateInit_(
+ z_streamp strm,
+ int level,
+ const char *version,
+ int stream_size)
{
return deflateInit2_(strm, level, Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL,
Z_DEFAULT_STRATEGY, version, stream_size);
@@ -210,16 +210,15 @@ int ZEXPORT deflateInit_(strm, level, version, stream_size)
}
/* ========================================================================= */
-int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy,
- version, stream_size)
- z_streamp strm;
- int level;
- int method;
- int windowBits;
- int memLevel;
- int strategy;
- const char *version;
- int stream_size;
+int ZEXPORT deflateInit2_(
+ z_streamp strm,
+ int level,
+ int method,
+ int windowBits,
+ int memLevel,
+ int strategy,
+ const char *version,
+ int stream_size)
{
deflate_state *s;
int wrap = 1;
@@ -320,10 +319,10 @@ int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy,
}
/* ========================================================================= */
-int ZEXPORT deflateSetDictionary (strm, dictionary, dictLength)
- z_streamp strm;
- const Bytef *dictionary;
- uInt dictLength;
+int ZEXPORT deflateSetDictionary (
+ z_streamp strm,
+ const Bytef *dictionary,
+ uInt dictLength)
{
deflate_state *s;
uInt str, n;
@@ -389,8 +388,8 @@ int ZEXPORT deflateSetDictionary (strm, dictionary, dictLength)
}
/* ========================================================================= */
-int ZEXPORT deflateResetKeep (strm)
- z_streamp strm;
+int ZEXPORT deflateResetKeep (
+ z_streamp strm)
{
deflate_state *s;
@@ -424,8 +423,8 @@ int ZEXPORT deflateResetKeep (strm)
}
/* ========================================================================= */
-int ZEXPORT deflateReset (strm)
- z_streamp strm;
+int ZEXPORT deflateReset (
+ z_streamp strm)
{
int ret;
@@ -436,9 +435,9 @@ int ZEXPORT deflateReset (strm)
}
/* ========================================================================= */
-int ZEXPORT deflateSetHeader (strm, head)
- z_streamp strm;
- gz_headerp head;
+int ZEXPORT deflateSetHeader (
+ z_streamp strm,
+ gz_headerp head)
{
if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
if (strm->state->wrap != 2) return Z_STREAM_ERROR;
@@ -447,10 +446,10 @@ int ZEXPORT deflateSetHeader (strm, head)
}
/* ========================================================================= */
-int ZEXPORT deflatePending (strm, pending, bits)
- unsigned *pending;
- int *bits;
- z_streamp strm;
+int ZEXPORT deflatePending (
+ z_streamp strm,
+ unsigned *pending,
+ int *bits)
{
if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
if (pending != Z_NULL)
@@ -461,10 +460,10 @@ int ZEXPORT deflatePending (strm, pending, bits)
}
/* ========================================================================= */
-int ZEXPORT deflatePrime (strm, bits, value)
- z_streamp strm;
- int bits;
- int value;
+int ZEXPORT deflatePrime (
+ z_streamp strm,
+ int bits,
+ int value)
{
deflate_state *s;
int put;
@@ -487,10 +486,10 @@ int ZEXPORT deflatePrime (strm, bits, value)
}
/* ========================================================================= */
-int ZEXPORT deflateParams(strm, level, strategy)
- z_streamp strm;
- int level;
- int strategy;
+int ZEXPORT deflateParams(
+ z_streamp strm,
+ int level,
+ int strategy)
{
deflate_state *s;
compress_func func;
@@ -526,12 +525,12 @@ int ZEXPORT deflateParams(strm, level, strategy)
}
/* ========================================================================= */
-int ZEXPORT deflateTune(strm, good_length, max_lazy, nice_length, max_chain)
- z_streamp strm;
- int good_length;
- int max_lazy;
- int nice_length;
- int max_chain;
+int ZEXPORT deflateTune(
+ z_streamp strm,
+ int good_length,
+ int max_lazy,
+ int nice_length,
+ int max_chain)
{
deflate_state *s;
@@ -561,9 +560,9 @@ int ZEXPORT deflateTune(strm, good_length, max_lazy, nice_length, max_chain)
* upper bound of about 14% expansion does not seem onerous for output buffer
* allocation.
*/
-uLong ZEXPORT deflateBound(strm, sourceLen)
- z_streamp strm;
- uLong sourceLen;
+uLong ZEXPORT deflateBound(
+ z_streamp strm,
+ uLong sourceLen)
{
deflate_state *s;
uLong complen, wraplen;
@@ -623,9 +622,9 @@ uLong ZEXPORT deflateBound(strm, sourceLen)
* IN assertion: the stream state is correct and there is enough room in
* pending_buf.
*/
-local void putShortMSB (s, b)
- deflate_state *s;
- uInt b;
+local void putShortMSB (
+ deflate_state *s,
+ uInt b)
{
put_byte(s, (Byte)(b >> 8));
put_byte(s, (Byte)(b & 0xff));
@@ -637,8 +636,8 @@ local void putShortMSB (s, b)
* to avoid allocating a large strm->next_out buffer and copying into it.
* (See also read_buf()).
*/
-local void flush_pending(strm)
- z_streamp strm;
+local void flush_pending(
+ z_streamp strm)
{
unsigned len;
deflate_state *s = strm->state;
@@ -660,9 +659,9 @@ local void flush_pending(strm)
}
/* ========================================================================= */
-int ZEXPORT deflate (strm, flush)
- z_streamp strm;
- int flush;
+int ZEXPORT deflate (
+ z_streamp strm,
+ int flush)
{
int old_flush; /* value of flush param for previous deflate call */
deflate_state *s;
@@ -974,8 +973,8 @@ int ZEXPORT deflate (strm, flush)
}
/* ========================================================================= */
-int ZEXPORT deflateEnd (strm)
- z_streamp strm;
+int ZEXPORT deflateEnd (
+ z_streamp strm)
{
int status;
@@ -1009,9 +1008,9 @@ int ZEXPORT deflateEnd (strm)
* To simplify the source, this is not supported for 16-bit MSDOS (which
* doesn't have enough memory anyway to duplicate compression states).
*/
-int ZEXPORT deflateCopy (dest, source)
- z_streamp dest;
- z_streamp source;
+int ZEXPORT deflateCopy (
+ z_streamp dest,
+ z_streamp source)
{
#ifdef MAXSEG_64K
return Z_STREAM_ERROR;
@@ -1071,10 +1070,10 @@ int ZEXPORT deflateCopy (dest, source)
* allocating a large strm->next_in buffer and copying from it.
* (See also flush_pending()).
*/
-local int read_buf(strm, buf, size)
- z_streamp strm;
- Bytef *buf;
- unsigned size;
+local int read_buf(
+ z_streamp strm,
+ Bytef *buf,
+ unsigned size)
{
unsigned len = strm->avail_in;
@@ -1101,8 +1100,8 @@ local int read_buf(strm, buf, size)
/* ===========================================================================
* Initialize the "longest match" routines for a new zlib stream
*/
-local void lm_init (s)
- deflate_state *s;
+local void lm_init (
+ deflate_state *s)
{
s->window_size = (ulg)2L*s->w_size;
@@ -1143,9 +1142,9 @@ local void lm_init (s)
/* For 80x86 and 680x0, an optimized version will be provided in match.asm or
* match.S. The code will be functionally equivalent.
*/
-local uInt longest_match(s, cur_match)
- deflate_state *s;
- IPos cur_match; /* current match */
+local uInt longest_match(
+ deflate_state *s,
+ IPos cur_match)
{
unsigned chain_length = s->max_chain_length;/* max hash chain length */
register Bytef *scan = s->window + s->strstart; /* current string */
@@ -1292,9 +1291,9 @@ local uInt longest_match(s, cur_match)
/* ---------------------------------------------------------------------------
* Optimized version for FASTEST only
*/
-local uInt longest_match(s, cur_match)
- deflate_state *s;
- IPos cur_match; /* current match */
+local uInt longest_match(
+ deflate_state *s,
+ IPos cur_match)
{
register Bytef *scan = s->window + s->strstart; /* current string */
register Bytef *match; /* matched string */
@@ -1351,10 +1350,11 @@ local uInt longest_match(s, cur_match)
/* ===========================================================================
* Check that the match at match_start is indeed a match.
*/
-local void check_match(s, start, match, length)
- deflate_state *s;
- IPos start, match;
- int length;
+local void check_match(
+ deflate_state *s,
+ IPos start,
+ IPos match,
+ int length)
{
/* check that the match is indeed a match */
if (zmemcmp(s->window + match,
@@ -1385,8 +1385,8 @@ local void check_match(s, start, match, length)
* performed for at least two bytes (required for the zip translate_eol
* option -- not supported here).
*/
-local void fill_window(s)
- deflate_state *s;
+local void fill_window(
+ deflate_state *s)
{
register unsigned n, m;
register Posf *p;
@@ -1559,9 +1559,9 @@ local void fill_window(s)
* NOTE: this function should be optimized to avoid extra copying from
* window to pending_buf.
*/
-local block_state deflate_stored(s, flush)
- deflate_state *s;
- int flush;
+local block_state deflate_stored(
+ deflate_state *s,
+ int flush)
{
/* Stored blocks are limited to 0xffff bytes, pending_buf is limited
* to pending_buf_size, and each stored block has a 5 byte header:
@@ -1623,9 +1623,9 @@ local block_state deflate_stored(s, flush)
* new strings in the dictionary only for unmatched strings or for short
* matches. It is used only for the fast compression options.
*/
-local block_state deflate_fast(s, flush)
- deflate_state *s;
- int flush;
+local block_state deflate_fast(
+ deflate_state *s,
+ int flush)
{
IPos hash_head; /* head of the hash chain */
int bflush; /* set if current block must be flushed */
@@ -1725,9 +1725,9 @@ local block_state deflate_fast(s, flush)
* evaluation for matches: a match is finally adopted only if there is
* no better match at the next window position.
*/
-local block_state deflate_slow(s, flush)
- deflate_state *s;
- int flush;
+local block_state deflate_slow(
+ deflate_state *s,
+ int flush)
{
IPos hash_head; /* head of hash chain */
int bflush; /* set if current block must be flushed */
@@ -1856,9 +1856,9 @@ local block_state deflate_slow(s, flush)
* one. Do not maintain a hash table. (It will be regenerated if this run of
* deflate switches away from Z_RLE.)
*/
-local block_state deflate_rle(s, flush)
- deflate_state *s;
- int flush;
+local block_state deflate_rle(
+ deflate_state *s,
+ int flush)
{
int bflush; /* set if current block must be flushed */
uInt prev; /* byte at distance one to match */
@@ -1929,9 +1929,9 @@ local block_state deflate_rle(s, flush)
* For Z_HUFFMAN_ONLY, do not look for matches. Do not maintain a hash table.
* (It will be regenerated if this run of deflate switches away from Huffman.)
*/
-local block_state deflate_huff(s, flush)
- deflate_state *s;
- int flush;
+local block_state deflate_huff(
+ deflate_state *s,
+ int flush)
{
int bflush; /* set if current block must be flushed */
diff --git a/cpan/Compress-Raw-Zlib/zlib-src/infback.c b/cpan/Compress-Raw-Zlib/zlib-src/infback.c
index 981aff17c2..60f78dc982 100644
--- a/cpan/Compress-Raw-Zlib/zlib-src/infback.c
+++ b/cpan/Compress-Raw-Zlib/zlib-src/infback.c
@@ -25,12 +25,12 @@ local void fixedtables OF((struct inflate_state FAR *state));
windowBits is in the range 8..15, and window is a user-supplied
window and output buffer that is 2**windowBits bytes.
*/
-int ZEXPORT inflateBackInit_(strm, windowBits, window, version, stream_size)
-z_streamp strm;
-int windowBits;
-unsigned char FAR *window;
-const char *version;
-int stream_size;
+int ZEXPORT inflateBackInit_(
+ z_streamp strm,
+ int windowBits,
+ unsigned char FAR *window,
+ const char *version,
+ int stream_size)
{
struct inflate_state FAR *state;
@@ -79,8 +79,8 @@ int stream_size;
used for threaded applications, since the rewriting of the tables and virgin
may not be thread-safe.
*/
-local void fixedtables(state)
-struct inflate_state FAR *state;
+local void fixedtables(
+ struct inflate_state FAR *state)
{
#ifdef BUILDFIXED
static int virgin = 1;
@@ -247,12 +247,12 @@ struct inflate_state FAR *state;
inflateBack() can also return Z_STREAM_ERROR if the input parameters
are not correct, i.e. strm is Z_NULL or the state was not initialized.
*/
-int ZEXPORT inflateBack(strm, in, in_desc, out, out_desc)
-z_streamp strm;
-in_func in;
-void FAR *in_desc;
-out_func out;
-void FAR *out_desc;
+int ZEXPORT inflateBack(
+ z_streamp strm,
+ in_func in,
+ void FAR *in_desc,
+ out_func out,
+ void FAR *out_desc)
{
struct inflate_state FAR *state;
unsigned char FAR *next; /* next input */
@@ -628,8 +628,8 @@ void FAR *out_desc;
return ret;
}
-int ZEXPORT inflateBackEnd(strm)
-z_streamp strm;
+int ZEXPORT inflateBackEnd(
+ z_streamp strm)
{
if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0)
return Z_STREAM_ERROR;
diff --git a/cpan/Compress-Raw-Zlib/zlib-src/inffast.c b/cpan/Compress-Raw-Zlib/zlib-src/inffast.c
index 2f1d60b43b..155dcc7bde 100644
--- a/cpan/Compress-Raw-Zlib/zlib-src/inffast.c
+++ b/cpan/Compress-Raw-Zlib/zlib-src/inffast.c
@@ -64,9 +64,9 @@
requires strm->avail_out >= 258 for each loop to avoid checking for
output space.
*/
-void ZLIB_INTERNAL inflate_fast(strm, start)
-z_streamp strm;
-unsigned start; /* inflate()'s starting value for strm->avail_out */
+void ZLIB_INTERNAL inflate_fast(
+ z_streamp strm,
+ unsigned start)
{
struct inflate_state FAR *state;
unsigned char FAR *in; /* local strm->next_in */
diff --git a/cpan/Compress-Raw-Zlib/zlib-src/inflate.c b/cpan/Compress-Raw-Zlib/zlib-src/inflate.c
index cc89517bc8..ca45202cf5 100644
--- a/cpan/Compress-Raw-Zlib/zlib-src/inflate.c
+++ b/cpan/Compress-Raw-Zlib/zlib-src/inflate.c
@@ -100,8 +100,8 @@ local int updatewindow OF((z_streamp strm, unsigned out));
local unsigned syncsearch OF((unsigned FAR *have, unsigned char FAR *buf,
unsigned len));
-int ZEXPORT inflateResetKeep(strm)
-z_streamp strm;
+int ZEXPORT inflateResetKeep(
+ z_streamp strm)
{
struct inflate_state FAR *state;
@@ -125,8 +125,8 @@ z_streamp strm;
return Z_OK;
}
-int ZEXPORT inflateReset(strm)
-z_streamp strm;
+int ZEXPORT inflateReset(
+ z_streamp strm)
{
struct inflate_state FAR *state;
@@ -138,9 +138,9 @@ z_streamp strm;
return inflateResetKeep(strm);
}
-int ZEXPORT inflateReset2(strm, windowBits)
-z_streamp strm;
-int windowBits;
+int ZEXPORT inflateReset2(
+ z_streamp strm,
+ int windowBits)
{
int wrap;
struct inflate_state FAR *state;
@@ -176,11 +176,11 @@ int windowBits;
return inflateReset(strm);
}
-int ZEXPORT inflateInit2_(strm, windowBits, version, stream_size)
-z_streamp strm;
-int windowBits;
-const char *version;
-int stream_size;
+int ZEXPORT inflateInit2_(
+ z_streamp strm,
+ int windowBits,
+ const char *version,
+ int stream_size)
{
int ret;
struct inflate_state FAR *state;
@@ -218,18 +218,18 @@ int stream_size;
return ret;
}
-int ZEXPORT inflateInit_(strm, version, stream_size)
-z_streamp strm;
-const char *version;
-int stream_size;
+int ZEXPORT inflateInit_(
+ z_streamp strm,
+ const char *version,
+ int stream_size)
{
return inflateInit2_(strm, DEF_WBITS, version, stream_size);
}
-int ZEXPORT inflatePrime(strm, bits, value)
-z_streamp strm;
-int bits;
-int value;
+int ZEXPORT inflatePrime(
+ z_streamp strm,
+ int bits,
+ int value)
{
struct inflate_state FAR *state;
@@ -257,8 +257,8 @@ int value;
used for threaded applications, since the rewriting of the tables and virgin
may not be thread-safe.
*/
-local void fixedtables(state)
-struct inflate_state FAR *state;
+local void fixedtables(
+ struct inflate_state FAR *state)
{
#ifdef BUILDFIXED
static int virgin = 1;
@@ -375,9 +375,9 @@ void makefixed()
output will fall in the output data, making match copies simpler and faster.
The advantage may be dependent on the size of the processor's data caches.
*/
-local int updatewindow(strm, out)
-z_streamp strm;
-unsigned out;
+local int updatewindow(
+ z_streamp strm,
+ unsigned out)
{
struct inflate_state FAR *state;
unsigned copy, dist;
@@ -606,9 +606,9 @@ unsigned out;
will return Z_BUF_ERROR if it has not reached the end of the stream.
*/
-int ZEXPORT inflate(strm, flush)
-z_streamp strm;
-int flush;
+int ZEXPORT inflate(
+ z_streamp strm,
+ int flush)
{
struct inflate_state FAR *state;
unsigned char FAR *next; /* next input */
@@ -1255,8 +1255,8 @@ int flush;
return ret;
}
-int ZEXPORT inflateEnd(strm)
-z_streamp strm;
+int ZEXPORT inflateEnd(
+ z_streamp strm)
{
struct inflate_state FAR *state;
if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0)
@@ -1269,10 +1269,10 @@ z_streamp strm;
return Z_OK;
}
-int ZEXPORT inflateSetDictionary(strm, dictionary, dictLength)
-z_streamp strm;
-const Bytef *dictionary;
-uInt dictLength;
+int ZEXPORT inflateSetDictionary(
+ z_streamp strm,
+ const Bytef *dictionary,
+ uInt dictLength)
{
struct inflate_state FAR *state;
unsigned long id;
@@ -1312,9 +1312,9 @@ uInt dictLength;
return Z_OK;
}
-int ZEXPORT inflateGetHeader(strm, head)
-z_streamp strm;
-gz_headerp head;
+int ZEXPORT inflateGetHeader(
+ z_streamp strm,
+ gz_headerp head)
{
struct inflate_state FAR *state;
@@ -1340,10 +1340,10 @@ gz_headerp head;
called again with more data and the *have state. *have is initialized to
zero for the first call.
*/
-local unsigned syncsearch(have, buf, len)
-unsigned FAR *have;
-unsigned char FAR *buf;
-unsigned len;
+local unsigned syncsearch(
+ unsigned FAR *have,
+ unsigned char FAR *buf,
+ unsigned len)
{
unsigned got;
unsigned next;
@@ -1363,8 +1363,8 @@ unsigned len;
return next;
}
-int ZEXPORT inflateSync(strm)
-z_streamp strm;
+int ZEXPORT inflateSync(
+ z_streamp strm)
{
unsigned len; /* number of bytes to look at or looked at */
unsigned long in, out; /* temporary to save total_in and total_out */
@@ -1414,8 +1414,8 @@ z_streamp strm;
block. When decompressing, PPP checks that at the end of input packet,
inflate is waiting for these length bytes.
*/
-int ZEXPORT inflateSyncPoint(strm)
-z_streamp strm;
+int ZEXPORT inflateSyncPoint(
+ z_streamp strm)
{
struct inflate_state FAR *state;
@@ -1424,9 +1424,9 @@ z_streamp strm;
return state->mode == STORED && state->bits == 0;
}
-int ZEXPORT inflateCopy(dest, source)
-z_streamp dest;
-z_streamp source;
+int ZEXPORT inflateCopy(
+ z_streamp dest,
+ z_streamp source)
{
struct inflate_state FAR *state;
struct inflate_state FAR *copy;
@@ -1471,9 +1471,9 @@ z_streamp source;
return Z_OK;
}
-int ZEXPORT inflateUndermine(strm, subvert)
-z_streamp strm;
-int subvert;
+int ZEXPORT inflateUndermine(
+ z_streamp strm,
+ int subvert)
{
struct inflate_state FAR *state;
@@ -1488,8 +1488,8 @@ int subvert;
#endif
}
-long ZEXPORT inflateMark(strm)
-z_streamp strm;
+long ZEXPORT inflateMark(
+ z_streamp strm)
{
struct inflate_state FAR *state;
diff --git a/cpan/Compress-Raw-Zlib/zlib-src/inftrees.c b/cpan/Compress-Raw-Zlib/zlib-src/inftrees.c
index 60bbd58bfb..3cfa4be06c 100644
--- a/cpan/Compress-Raw-Zlib/zlib-src/inftrees.c
+++ b/cpan/Compress-Raw-Zlib/zlib-src/inftrees.c
@@ -29,13 +29,13 @@ const char inflate_copyright[] =
table index bits. It will differ if the request is greater than the
longest code or if it is less than the shortest code.
*/
-int ZLIB_INTERNAL inflate_table(type, lens, codes, table, bits, work)
-codetype type;
-unsigned short FAR *lens;
-unsigned codes;
-code FAR * FAR *table;
-unsigned FAR *bits;
-unsigned short FAR *work;
+int ZLIB_INTERNAL inflate_table(
+ codetype type,
+ unsigned short FAR *lens,
+ unsigned codes,
+ code FAR * FAR *table,
+ unsigned FAR *bits,
+ unsigned short FAR *work)
{
unsigned len; /* a code's length in bits */
unsigned sym; /* index of code symbols */
diff --git a/cpan/Compress-Raw-Zlib/zlib-src/trees.c b/cpan/Compress-Raw-Zlib/zlib-src/trees.c
index 8c32b214b1..de0b7f210c 100644
--- a/cpan/Compress-Raw-Zlib/zlib-src/trees.c
+++ b/cpan/Compress-Raw-Zlib/zlib-src/trees.c
@@ -185,10 +185,10 @@ local void gen_trees_header OF((void));
#ifdef DEBUG
local void send_bits OF((deflate_state *s, int value, int length));
-local void send_bits(s, value, length)
- deflate_state *s;
- int value; /* value to send */
- int length; /* number of bits */
+local void send_bits(
+ deflate_state *s,
+ int value,
+ int length)
{
Tracevv((stderr," l %2d v %4x ", length, value));
Assert(length > 0 && length <= 15, "invalid length");
@@ -378,8 +378,8 @@ void gen_trees_header()
/* ===========================================================================
* Initialize the tree data structures for a new zlib stream.
*/
-void ZLIB_INTERNAL _tr_init(s)
- deflate_state *s;
+void ZLIB_INTERNAL _tr_init(
+ deflate_state *s)
{
tr_static_init();
@@ -406,8 +406,8 @@ void ZLIB_INTERNAL _tr_init(s)
/* ===========================================================================
* Initialize a new block.
*/
-local void init_block(s)
- deflate_state *s;
+local void init_block(
+ deflate_state *s)
{
int n; /* iterates over tree elements */
@@ -450,10 +450,10 @@ local void init_block(s)
* when the heap property is re-established (each father smaller than its
* two sons).
*/
-local void pqdownheap(s, tree, k)
- deflate_state *s;
- ct_data *tree; /* the tree to restore */
- int k; /* node to move down */
+local void pqdownheap(
+ deflate_state *s,
+ ct_data *tree,
+ int k)
{
int v = s->heap[k];
int j = k << 1; /* left son of k */
@@ -485,9 +485,9 @@ local void pqdownheap(s, tree, k)
* The length opt_len is updated; static_len is also updated if stree is
* not null.
*/
-local void gen_bitlen(s, desc)
- deflate_state *s;
- tree_desc *desc; /* the tree descriptor */
+local void gen_bitlen(
+ deflate_state *s,
+ tree_desc *desc)
{
ct_data *tree = desc->dyn_tree;
int max_code = desc->max_code;
@@ -572,10 +572,10 @@ local void gen_bitlen(s, desc)
* OUT assertion: the field code is set for all tree elements of non
* zero code length.
*/
-local void gen_codes (tree, max_code, bl_count)
- 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 */
+local void gen_codes (
+ ct_data *tree,
+ int max_code,
+ ushf *bl_count)
{
ush next_code[MAX_BITS+1]; /* next code value for each bit length */
ush code = 0; /* running code value */
@@ -614,9 +614,9 @@ local void gen_codes (tree, max_code, bl_count)
* and corresponding code. The length opt_len is updated; static_len is
* also updated if stree is not null. The field max_code is set.
*/
-local void build_tree(s, desc)
- deflate_state *s;
- tree_desc *desc; /* the tree descriptor */
+local void build_tree(
+ deflate_state *s,
+ tree_desc *desc)
{
ct_data *tree = desc->dyn_tree;
const ct_data *stree = desc->stat_desc->static_tree;
@@ -702,10 +702,10 @@ local void build_tree(s, desc)
* Scan a literal or distance tree to determine the frequencies of the codes
* in the bit length tree.
*/
-local void scan_tree (s, tree, max_code)
- deflate_state *s;
- ct_data *tree; /* the tree to be scanned */
- int max_code; /* and its largest code of non zero frequency */
+local void scan_tree (
+ deflate_state *s,
+ ct_data *tree,
+ int max_code)
{
int n; /* iterates over all tree elements */
int prevlen = -1; /* last emitted length */
@@ -747,10 +747,10 @@ local void scan_tree (s, tree, max_code)
* Send a literal or distance tree in compressed form, using the codes in
* bl_tree.
*/
-local void send_tree (s, tree, max_code)
- deflate_state *s;
- ct_data *tree; /* the tree to be scanned */
- int max_code; /* and its largest code of non zero frequency */
+local void send_tree (
+ deflate_state *s,
+ ct_data *tree,
+ int max_code)
{
int n; /* iterates over all tree elements */
int prevlen = -1; /* last emitted length */
@@ -798,8 +798,8 @@ local void send_tree (s, tree, max_code)
* Construct the Huffman tree for the bit lengths and return the index in
* bl_order of the last bit length code to send.
*/
-local int build_bl_tree(s)
- deflate_state *s;
+local int build_bl_tree(
+ deflate_state *s)
{
int max_blindex; /* index of last bit length code of non zero freq */
@@ -833,9 +833,11 @@ local int build_bl_tree(s)
* lengths of the bit length codes, the literal tree and the distance tree.
* IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4.
*/
-local void send_all_trees(s, lcodes, dcodes, blcodes)
- deflate_state *s;
- int lcodes, dcodes, blcodes; /* number of codes for each tree */
+local void send_all_trees(
+ deflate_state *s,
+ int lcodes,
+ int dcodes,
+ int blcodes)
{
int rank; /* index in bl_order */
@@ -862,11 +864,11 @@ local void send_all_trees(s, lcodes, dcodes, blcodes)
/* ===========================================================================
* Send a stored block
*/
-void ZLIB_INTERNAL _tr_stored_block(s, buf, stored_len, last)
- deflate_state *s;
- charf *buf; /* input block */
- ulg stored_len; /* length of input block */
- int last; /* one if this is the last block for a file */
+void ZLIB_INTERNAL _tr_stored_block(
+ deflate_state *s,
+ charf *buf,
+ ulg stored_len,
+ int last)
{
send_bits(s, (STORED_BLOCK<<1)+last, 3); /* send block type */
#ifdef DEBUG
@@ -879,8 +881,8 @@ void ZLIB_INTERNAL _tr_stored_block(s, buf, stored_len, last)
/* ===========================================================================
* Flush the bits in the bit buffer to pending output (leaves at most 7 bits)
*/
-void ZLIB_INTERNAL _tr_flush_bits(s)
- deflate_state *s;
+void ZLIB_INTERNAL _tr_flush_bits(
+ deflate_state *s)
{
bi_flush(s);
}
@@ -889,8 +891,8 @@ void ZLIB_INTERNAL _tr_flush_bits(s)
* Send one empty static block to give enough lookahead for inflate.
* This takes 10 bits, of which 7 may remain in the bit buffer.
*/
-void ZLIB_INTERNAL _tr_align(s)
- deflate_state *s;
+void ZLIB_INTERNAL _tr_align(
+ deflate_state *s)
{
send_bits(s, STATIC_TREES<<1, 3);
send_code(s, END_BLOCK, static_ltree);
@@ -904,11 +906,11 @@ void ZLIB_INTERNAL _tr_align(s)
* Determine the best encoding for the current block: dynamic trees, static
* trees or store, and output the encoded block to the zip file.
*/
-void ZLIB_INTERNAL _tr_flush_block(s, buf, stored_len, last)
- deflate_state *s;
- charf *buf; /* input block, or NULL if too old */
- ulg stored_len; /* length of input block */
- int last; /* one if this is the last block for a file */
+void ZLIB_INTERNAL _tr_flush_block(
+ deflate_state *s,
+ charf *buf,
+ ulg stored_len,
+ int last)
{
ulg opt_lenb, static_lenb; /* opt_len and static_len in bytes */
int max_blindex = 0; /* index of last bit length code of non zero freq */
@@ -1005,10 +1007,10 @@ void ZLIB_INTERNAL _tr_flush_block(s, buf, stored_len, last)
* Save the match info and tally the frequency counts. Return true if
* the current block must be flushed.
*/
-int ZLIB_INTERNAL _tr_tally (s, dist, lc)
- deflate_state *s;
- unsigned dist; /* distance of matched string */
- unsigned lc; /* match length-MIN_MATCH or unmatched char (if dist==0) */
+int ZLIB_INTERNAL _tr_tally (
+ deflate_state *s,
+ unsigned dist,
+ unsigned lc)
{
s->d_buf[s->last_lit] = (ush)dist;
s->l_buf[s->last_lit++] = (uch)lc;
@@ -1055,10 +1057,10 @@ int ZLIB_INTERNAL _tr_tally (s, dist, lc)
/* ===========================================================================
* Send the block data compressed using the given Huffman trees
*/
-local void compress_block(s, ltree, dtree)
- deflate_state *s;
- ct_data *ltree; /* literal tree */
- ct_data *dtree; /* distance tree */
+local void compress_block(
+ deflate_state *s,
+ ct_data *ltree,
+ ct_data *dtree)
{
unsigned dist; /* distance of matched string */
int lc; /* match length or unmatched char (if dist == 0) */
@@ -1115,8 +1117,8 @@ local void compress_block(s, ltree, dtree)
* (7 {BEL}, 8 {BS}, 11 {VT}, 12 {FF}, 26 {SUB}, 27 {ESC}).
* IN assertion: the fields Freq of dyn_ltree are set.
*/
-local int detect_data_type(s)
- deflate_state *s;
+local int detect_data_type(
+ deflate_state *s)
{
/* black_mask is the bit mask of black-listed bytes
* set bits 0..6, 14..25, and 28..31
@@ -1149,9 +1151,9 @@ local int detect_data_type(s)
* method would use a table)
* IN assertion: 1 <= len <= 15
*/
-local unsigned bi_reverse(code, len)
- unsigned code; /* the value to invert */
- int len; /* its bit length */
+local unsigned bi_reverse(
+ unsigned code,
+ int len)
{
register unsigned res = 0;
do {
@@ -1164,8 +1166,8 @@ local unsigned bi_reverse(code, len)
/* ===========================================================================
* Flush the bit buffer, keeping at most 7 bits in it.
*/
-local void bi_flush(s)
- deflate_state *s;
+local void bi_flush(
+ deflate_state *s)
{
if (s->bi_valid == 16) {
put_short(s, s->bi_buf);
@@ -1181,8 +1183,8 @@ local void bi_flush(s)
/* ===========================================================================
* Flush the bit buffer and align the output on a byte boundary
*/
-local void bi_windup(s)
- deflate_state *s;
+local void bi_windup(
+ deflate_state *s)
{
if (s->bi_valid > 8) {
put_short(s, s->bi_buf);
@@ -1200,11 +1202,11 @@ local void bi_windup(s)
* Copy a stored block, storing first the length and its
* one's complement if requested.
*/
-local void copy_block(s, buf, len, header)
- deflate_state *s;
- charf *buf; /* the input data */
- unsigned len; /* its length */
- int header; /* true if block header must be written */
+local void copy_block(
+ deflate_state *s,
+ charf *buf,
+ unsigned len,
+ int header)
{
bi_windup(s); /* align on byte boundary */
diff --git a/cpan/Compress-Raw-Zlib/zlib-src/uncompr.c b/cpan/Compress-Raw-Zlib/zlib-src/uncompr.c
index ad98be3a5d..9b272e983f 100644
--- a/cpan/Compress-Raw-Zlib/zlib-src/uncompr.c
+++ b/cpan/Compress-Raw-Zlib/zlib-src/uncompr.c
@@ -21,11 +21,11 @@
enough memory, Z_BUF_ERROR if there was not enough room in the output
buffer, or Z_DATA_ERROR if the input data was corrupted.
*/
-int ZEXPORT uncompress (dest, destLen, source, sourceLen)
- Bytef *dest;
- uLongf *destLen;
- const Bytef *source;
- uLong sourceLen;
+int ZEXPORT uncompress (
+ Bytef *dest,
+ uLongf *destLen,
+ const Bytef *source,
+ uLong sourceLen)
{
z_stream stream;
int err;
diff --git a/cpan/Compress-Raw-Zlib/zlib-src/zutil.c b/cpan/Compress-Raw-Zlib/zlib-src/zutil.c
index 8a1d242093..60d638b1a8 100644
--- a/cpan/Compress-Raw-Zlib/zlib-src/zutil.c
+++ b/cpan/Compress-Raw-Zlib/zlib-src/zutil.c
@@ -99,8 +99,8 @@ uLong ZEXPORT zlibCompileFlags()
# endif
int ZLIB_INTERNAL z_verbose = verbose;
-void ZLIB_INTERNAL z_error (m)
- char *m;
+void ZLIB_INTERNAL z_error (
+ char *m)
{
fprintf(stderr, "%s\n", m);
exit(1);
@@ -110,8 +110,8 @@ void ZLIB_INTERNAL z_error (m)
/* exported to allow conversion of error code to string for compress() and
* uncompress()
*/
-const char * ZEXPORT zError(err)
- int err;
+const char * ZEXPORT zError(
+ int err)
{
return ERR_MSG(err);
}
@@ -126,10 +126,10 @@ const char * ZEXPORT zError(err)
#ifndef HAVE_MEMCPY
-void ZLIB_INTERNAL zmemcpy(dest, source, len)
- Bytef* dest;
- const Bytef* source;
- uInt len;
+void ZLIB_INTERNAL zmemcpy(
+ Bytef* dest,
+ const Bytef* source,
+ uInt len)
{
if (len == 0) return;
do {
@@ -137,10 +137,10 @@ void ZLIB_INTERNAL zmemcpy(dest, source, len)
} while (--len != 0);
}
-int ZLIB_INTERNAL zmemcmp(s1, s2, len)
- const Bytef* s1;
- const Bytef* s2;
- uInt len;
+int ZLIB_INTERNAL zmemcmp(
+ const Bytef* s1,
+ const Bytef* s2,
+ uInt len)
{
uInt j;
@@ -150,9 +150,9 @@ int ZLIB_INTERNAL zmemcmp(s1, s2, len)
return 0;
}
-void ZLIB_INTERNAL zmemzero(dest, len)
- Bytef* dest;
- uInt len;
+void ZLIB_INTERNAL zmemzero(
+ Bytef* dest,
+ uInt len)
{
if (len == 0) return;
do {
@@ -278,19 +278,19 @@ extern voidp calloc OF((uInt items, uInt size));
extern void free OF((voidpf ptr));
#endif
-voidpf ZLIB_INTERNAL zcalloc (opaque, items, size)
- voidpf opaque;
- unsigned items;
- unsigned size;
+voidpf ZLIB_INTERNAL zcalloc (
+ voidpf opaque,
+ unsigned items,
+ unsigned size)
{
if (opaque) items += size - size; /* make compiler happy */
return sizeof(uInt) > 2 ? (voidpf)malloc(items * size) :
(voidpf)calloc(items, size);
}
-void ZLIB_INTERNAL zcfree (opaque, ptr)
- voidpf opaque;
- voidpf ptr;
+void ZLIB_INTERNAL zcfree (
+ voidpf opaque,
+ voidpf ptr)
{
free(ptr);
if (opaque) return; /* make compiler happy */