X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/c801d85f158c4cba50b588807daabdcbd0ed3853..818503a1826c8d32340234318afe6de35f756c2f:/src/zlib/trees.c diff --git a/src/zlib/trees.c b/src/zlib/trees.c index ef31043764..355066108c 100644 --- a/src/zlib/trees.c +++ b/src/zlib/trees.c @@ -1,6 +1,6 @@ /* trees.c -- output deflated data using Huffman coding * Copyright (C) 1995-1998 Jean-loup Gailly - * For conditions of distribution and use, see copyright notice in zlib.h + * For conditions of distribution and use, see copyright notice in zlib.h */ /* @@ -35,7 +35,7 @@ #include "deflate.h" -#ifdef DEBUG +#ifdef __WXDEBUG__ # include #endif @@ -163,11 +163,11 @@ local void copy_block OF((deflate_state *s, charf *buf, unsigned len, local void gen_trees_header OF((void)); #endif -#ifndef DEBUG +#ifndef __WXDEBUG__ # define send_code(s, c, tree) send_bits(s, tree[c].Code, tree[c].Len) /* Send a code of the given tree. c and tree must not have side effects */ -#else /* DEBUG */ +#else /* __WXDEBUG__ */ # define send_code(s, c, tree) \ { if (z_verbose>2) fprintf(stderr,"\ncd %3d ",(c)); \ send_bits(s, tree[c].Code, tree[c].Len); } @@ -186,13 +186,17 @@ local void gen_trees_header OF((void)); * Send a value on a given number of bits. * IN assertion: length <= 16 and value fits in length bits. */ -#ifdef DEBUG +#ifdef __WXDEBUG__ local void send_bits OF((deflate_state *s, int value, int length)); +#if defined(__VISAGECPP__) /* Visualage can't handle this antiquated interface */ +local void send_bits(deflate_state* s, int value, int length) +#else local void send_bits(s, value, length) deflate_state *s; int value; /* value to send */ int length; /* number of bits */ +#endif { Tracevv((stderr," l %2d v %4x ", length, value)); Assert(length > 0 && length <= 15, "invalid length"); @@ -212,7 +216,7 @@ local void send_bits(s, value, length) s->bi_valid += length; } } -#else /* !DEBUG */ +#else /* !__WXDEBUG__ */ #define send_bits(s, value, length) \ { int len = length;\ @@ -227,7 +231,7 @@ local void send_bits(s, value, length) s->bi_valid += len;\ }\ } -#endif /* DEBUG */ +#endif /* __WXDEBUG__ */ #define MAX(a,b) (a >= b ? a : b) @@ -313,7 +317,7 @@ local void tr_static_init() * Genererate the file trees.h describing the static trees. */ #ifdef GEN_TREES_H -# ifndef DEBUG +# ifndef __WXDEBUG__ # include # endif @@ -373,8 +377,12 @@ void gen_trees_header() /* =========================================================================== * Initialize the tree data structures for a new zlib stream. */ +#if defined(__VISAGECPP__) /* Visualage can't handle this antiquated interface */ +void _tr_init(deflate_state* s) +#else void _tr_init(s) deflate_state *s; +#endif { tr_static_init(); @@ -392,7 +400,7 @@ void _tr_init(s) s->bi_buf = 0; s->bi_valid = 0; s->last_eob_len = 8; /* enough lookahead for inflate */ -#ifdef DEBUG +#ifdef __WXDEBUG__ s->bits_sent = 0L; #endif @@ -403,8 +411,12 @@ void _tr_init(s) /* =========================================================================== * Initialize a new block. */ +#if defined(__VISAGECPP__) /* Visualage can't handle this antiquated interface */ +local void init_block(deflate_state* s) +#else local void init_block(s) deflate_state *s; +#endif { int n; /* iterates over tree elements */ @@ -447,10 +459,14 @@ local void init_block(s) * when the heap property is re-established (each father smaller than its * two sons). */ +#if defined(__VISAGECPP__) /* Visualage can't handle this antiquated interface */ +local void pqdownheap(deflate_state* s, ct_data* tree, int k) +#else local void pqdownheap(s, tree, k) deflate_state *s; ct_data *tree; /* the tree to restore */ int k; /* node to move down */ +#endif { int v = s->heap[k]; int j = k << 1; /* left son of k */ @@ -482,9 +498,13 @@ local void pqdownheap(s, tree, k) * The length opt_len is updated; static_len is also updated if stree is * not null. */ +#if defined(__VISAGECPP__) /* Visualage can't handle this antiquated interface */ +local void gen_bitlen(deflate_state* s, tree_desc* desc) +#else local void gen_bitlen(s, desc) deflate_state *s; tree_desc *desc; /* the tree descriptor */ +#endif { ct_data *tree = desc->dyn_tree; int max_code = desc->max_code; @@ -569,10 +589,14 @@ local void gen_bitlen(s, desc) * OUT assertion: the field code is set for all tree elements of non * zero code length. */ +#if defined(__VISAGECPP__) /* Visualage can't handle this antiquated interface */ +local void gen_codes (ct_data* tree, int max_code, ushf* bl_count) +#else 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 */ +#endif { ush next_code[MAX_BITS+1]; /* next code value for each bit length */ ush code = 0; /* running code value */ @@ -588,7 +612,7 @@ local void gen_codes (tree, max_code, bl_count) /* Check that the bit counts in bl_count are consistent. The last code * must be all ones. */ - Assert (code + bl_count[MAX_BITS]-1 == (1<dyn_tree; const ct_data *stree = desc->stat_desc->static_tree; @@ -698,10 +726,14 @@ local void build_tree(s, desc) * Scan a literal or distance tree to determine the frequencies of the codes * in the bit length tree. */ +#if defined(__VISAGECPP__) /* Visualage can't handle this antiquated interface */ +local void scan_tree (deflate_state* s, ct_data* tree, int max_code) +#else 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 */ +#endif { int n; /* iterates over all tree elements */ int prevlen = -1; /* last emitted length */ @@ -743,10 +775,14 @@ local void scan_tree (s, tree, max_code) * Send a literal or distance tree in compressed form, using the codes in * bl_tree. */ +#if defined(__VISAGECPP__) /* Visualage can't handle this antiquated interface */ +local void send_tree (deflate_state* s, ct_data* tree, int max_code) +#else 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 */ +#endif { int n; /* iterates over all tree elements */ int prevlen = -1; /* last emitted length */ @@ -794,8 +830,12 @@ 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. */ +#if defined(__VISAGECPP__) /* Visualage can't handle this antiquated interface */ +local int build_bl_tree( deflate_state* s) +#else local int build_bl_tree(s) deflate_state *s; +#endif { int max_blindex; /* index of last bit length code of non zero freq */ @@ -829,9 +869,13 @@ 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. */ +#if defined(__VISAGECPP__) /* Visualage can't handle this antiquated interface */ +local void send_all_trees(deflate_state* s, int lcodes, int dcodes, int blcodes) +#else local void send_all_trees(s, lcodes, dcodes, blcodes) deflate_state *s; int lcodes, dcodes, blcodes; /* number of codes for each tree */ +#endif { int rank; /* index in bl_order */ @@ -858,11 +902,15 @@ local void send_all_trees(s, lcodes, dcodes, blcodes) /* =========================================================================== * Send a stored block */ +#if defined(__VISAGECPP__) /* Visualage can't handle this antiquated interface */ +void _tr_stored_block(deflate_state* s, charf* buf, ulg stored_len, int eof) +#else void _tr_stored_block(s, buf, stored_len, eof) deflate_state *s; charf *buf; /* input block */ ulg stored_len; /* length of input block */ int eof; /* true if this is the last block for a file */ +#endif { send_bits(s, (STORED_BLOCK<<1)+eof, 3); /* send block type */ s->compressed_len = (s->compressed_len + 3 + 7) & (ulg)~7L; @@ -882,8 +930,12 @@ void _tr_stored_block(s, buf, stored_len, eof) * To simplify the code, we assume the worst case of last real code encoded * on one bit only. */ +#if defined(__VISAGECPP__) /* Visualage can't handle this antiquated interface */ +void _tr_align(deflate_state* s) +#else void _tr_align(s) deflate_state *s; +#endif { send_bits(s, STATIC_TREES<<1, 3); send_code(s, END_BLOCK, static_ltree); @@ -908,11 +960,15 @@ void _tr_align(s) * trees or store, and output the encoded block to the zip file. This function * returns the total compressed length for the file so far. */ +#if defined(__VISAGECPP__) /* Visualage can't handle this antiquated interface */ +ulg _tr_flush_block(deflate_state* s, charf* buf, ulg stored_len, int eof) +#else ulg _tr_flush_block(s, buf, stored_len, eof) deflate_state *s; charf *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 */ +#endif { 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 */ @@ -1020,10 +1076,14 @@ ulg _tr_flush_block(s, buf, stored_len, eof) * Save the match info and tally the frequency counts. Return true if * the current block must be flushed. */ +#if defined(__VISAGECPP__) /* Visualage can't handle this antiquated interface */ +int _tr_tally (deflate_state* s, unsigned dist, unsigned lc) +#else int _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) */ +#endif { s->d_buf[s->last_lit] = (ush)dist; s->l_buf[s->last_lit++] = (uch)lc; @@ -1070,10 +1130,14 @@ int _tr_tally (s, dist, lc) /* =========================================================================== * Send the block data compressed using the given Huffman trees */ +#if defined(__VISAGECPP__) /* Visualage can't handle this antiquated interface */ +local void compress_block(deflate_state* s, ct_data* ltree, ct_data* dtree) +#else local void compress_block(s, ltree, dtree) deflate_state *s; ct_data *ltree; /* literal tree */ ct_data *dtree; /* distance tree */ +#endif { unsigned dist; /* distance of matched string */ int lc; /* match length or unmatched char (if dist == 0) */ @@ -1109,7 +1173,7 @@ local void compress_block(s, ltree, dtree) } /* literal or match pair ? */ /* Check that the overlay between pending_buf and d_buf+l_buf is ok: */ - Assert(s->pending < s->lit_bufsize + 2*lx, "pendingBuf overflow"); + Assert((unsigned)s->pending < s->lit_bufsize + 2*lx, "pendingBuf overflow"); } while (lx < s->last_lit); @@ -1123,8 +1187,12 @@ local void compress_block(s, ltree, dtree) * IN assertion: the fields freq of dyn_ltree are set and the total of all * frequencies does not exceed 64K (to fit in an int on 16 bit machines). */ +#if defined(__VISAGECPP__) /* Visualage can't handle this antiquated interface */ +local void set_data_type(deflate_state* s) +#else local void set_data_type(s) deflate_state *s; +#endif { int n = 0; unsigned ascii_freq = 0; @@ -1140,9 +1208,13 @@ local void set_data_type(s) * method would use a table) * IN assertion: 1 <= len <= 15 */ +#if defined(__VISAGECPP__) /* Visualage can't handle this antiquated interface */ +local unsigned bi_reverse(unsigned code, int len) +#else local unsigned bi_reverse(code, len) unsigned code; /* the value to invert */ int len; /* its bit length */ +#endif { register unsigned res = 0; do { @@ -1155,8 +1227,12 @@ local unsigned bi_reverse(code, len) /* =========================================================================== * Flush the bit buffer, keeping at most 7 bits in it. */ +#if defined(__VISAGECPP__) /* Visualage can't handle this antiquated interface */ +local void bi_flush(deflate_state* s) +#else local void bi_flush(s) deflate_state *s; +#endif { if (s->bi_valid == 16) { put_short(s, s->bi_buf); @@ -1172,8 +1248,12 @@ local void bi_flush(s) /* =========================================================================== * Flush the bit buffer and align the output on a byte boundary */ +#if defined(__VISAGECPP__) /* Visualage can't handle this antiquated interface */ +local void bi_windup(deflate_state* s) +#else local void bi_windup(s) deflate_state *s; +#endif { if (s->bi_valid > 8) { put_short(s, s->bi_buf); @@ -1182,7 +1262,7 @@ local void bi_windup(s) } s->bi_buf = 0; s->bi_valid = 0; -#ifdef DEBUG +#ifdef __WXDEBUG__ s->bits_sent = (s->bits_sent+7) & ~7; #endif } @@ -1191,23 +1271,27 @@ local void bi_windup(s) * Copy a stored block, storing first the length and its * one's complement if requested. */ +#if defined(__VISAGECPP__) /* Visualage can't handle this antiquated interface */ +local void copy_block(deflate_state* s, charf* buf, unsigned len, int header) +#else 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 */ +#endif { bi_windup(s); /* align on byte boundary */ s->last_eob_len = 8; /* enough lookahead for inflate */ if (header) { - put_short(s, (ush)len); + put_short(s, (ush)len); put_short(s, (ush)~len); -#ifdef DEBUG +#ifdef __WXDEBUG__ s->bits_sent += 2*16; #endif } -#ifdef DEBUG +#ifdef __WXDEBUG__ s->bits_sent += (ulg)len<<3; #endif while (len--) {