check that the version of __sync_sub_and_fetch that returns a value is supported...

[wxWidgets.git] / src / zlib / trees.c

diff --git a/src/zlib/trees.c b/src/zlib/trees.c
index 24c68cb580375d7c142b998f66a815e4106595df..395e4e16814e5e1d863fdbd38790e1508a8e5dcf 100644 (file)
--- a/src/zlib/trees.c
+++ b/src/zlib/trees.c
@@ -1,6 +1,6 @@
 /* trees.c -- output deflated data using Huffman coding
 /* 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 
+ * Copyright (C) 1995-2005 Jean-loup Gailly
+ * For conditions of distribution and use, see copyright notice in zlib.h

  */
 
 /*
  */
 
 /*


@@ -35,7 +35,7 @@
 
 #include "deflate.h"
 
 
 #include "deflate.h"
 

-#ifdef __WXDEBUG__
+#ifdef DEBUG

 #  include <ctype.h>
 #endif
 
 #  include <ctype.h>
 #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
 
 local void gen_trees_header OF((void));
 #endif
 

-#ifndef __WXDEBUG__
+#ifndef DEBUG

 #  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 */
 
 #  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 /* __WXDEBUG__ */
+#else /* DEBUG */

 #  define send_code(s, c, tree) \
      { if (z_verbose>2) fprintf(stderr,"\ncd %3d ",(c)); \
        send_bits(s, tree[c].Code, tree[c].Len); }
 #  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,7 +186,7 @@ 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.
  */
  * Send a value on a given number of bits.
  * IN assertion: length <= 16 and value fits in length bits.
  */

-#ifdef __WXDEBUG__
+#ifdef DEBUG

 local void send_bits      OF((deflate_state *s, int value, int length));
 
 local void send_bits(s, value, length)
 local void send_bits      OF((deflate_state *s, int value, int length));
 
 local void send_bits(s, value, length)


@@ -212,7 +212,7 @@ local void send_bits(s, value, length)
         s->bi_valid += length;
     }
 }
         s->bi_valid += length;
     }
 }

-#else /* !__WXDEBUG__ */
+#else /* !DEBUG */

 
 #define send_bits(s, value, length) \
 { int len = length;\
 
 #define send_bits(s, value, length) \
 { int len = length;\


@@ -227,10 +227,9 @@ local void send_bits(s, value, length)
     s->bi_valid += len;\
   }\
 }
     s->bi_valid += len;\
   }\
 }

-#endif /* __WXDEBUG__ */
+#endif /* DEBUG */

 
 
 
 

-#define MAX(a,b) (a >= b ? a : b)

 /* the arguments must not have side effects */
 
 /* ===========================================================================
 /* the arguments must not have side effects */
 
 /* ===========================================================================


@@ -250,6 +249,13 @@ local void tr_static_init()
 
     if (static_init_done) return;
 
 
     if (static_init_done) return;
 

+    /* For some embedded targets, global variables are not initialized: */
+    static_l_desc.static_tree = static_ltree;
+    static_l_desc.extra_bits = extra_lbits;
+    static_d_desc.static_tree = static_dtree;
+    static_d_desc.extra_bits = extra_dbits;
+    static_bl_desc.extra_bits = extra_blbits;
+

     /* Initialize the mapping length (0..255) -> length code (0..28) */
     length = 0;
     for (code = 0; code < LENGTH_CODES-1; code++) {
     /* Initialize the mapping length (0..255) -> length code (0..28) */
     length = 0;
     for (code = 0; code < LENGTH_CODES-1; code++) {


@@ -313,7 +319,7 @@ local void tr_static_init()
  * Genererate the file trees.h describing the static trees.
  */
 #ifdef GEN_TREES_H
  * Genererate the file trees.h describing the static trees.
  */
 #ifdef GEN_TREES_H

-#  ifndef __WXDEBUG__
+#  ifndef DEBUG

 #    include <stdio.h>
 #  endif
 
 #    include <stdio.h>
 #  endif
 


@@ -328,42 +334,42 @@ void gen_trees_header()
 
     Assert (header != NULL, "Can't open trees.h");
     fprintf(header,
 
     Assert (header != NULL, "Can't open trees.h");
     fprintf(header,

-           "/* header created automatically with -DGEN_TREES_H */\n\n");
+            "/* header created automatically with -DGEN_TREES_H */\n\n");

 
     fprintf(header, "local const ct_data static_ltree[L_CODES+2] = {\n");
     for (i = 0; i < L_CODES+2; i++) {
 
     fprintf(header, "local const ct_data static_ltree[L_CODES+2] = {\n");
     for (i = 0; i < L_CODES+2; i++) {

-       fprintf(header, "{{%3u},{%3u}}%s", static_ltree[i].Code,
-               static_ltree[i].Len, SEPARATOR(i, L_CODES+1, 5));
+        fprintf(header, "{{%3u},{%3u}}%s", static_ltree[i].Code,
+                static_ltree[i].Len, SEPARATOR(i, L_CODES+1, 5));

     }
 
     fprintf(header, "local const ct_data static_dtree[D_CODES] = {\n");
     for (i = 0; i < D_CODES; i++) {
     }
 
     fprintf(header, "local const ct_data static_dtree[D_CODES] = {\n");
     for (i = 0; i < D_CODES; i++) {

-       fprintf(header, "{{%2u},{%2u}}%s", static_dtree[i].Code,
-               static_dtree[i].Len, SEPARATOR(i, D_CODES-1, 5));
+        fprintf(header, "{{%2u},{%2u}}%s", static_dtree[i].Code,
+                static_dtree[i].Len, SEPARATOR(i, D_CODES-1, 5));

     }
 
     fprintf(header, "const uch _dist_code[DIST_CODE_LEN] = {\n");
     for (i = 0; i < DIST_CODE_LEN; i++) {
     }
 
     fprintf(header, "const uch _dist_code[DIST_CODE_LEN] = {\n");
     for (i = 0; i < DIST_CODE_LEN; i++) {

-       fprintf(header, "%2u%s", _dist_code[i],
-               SEPARATOR(i, DIST_CODE_LEN-1, 20));
+        fprintf(header, "%2u%s", _dist_code[i],
+                SEPARATOR(i, DIST_CODE_LEN-1, 20));

     }
 
     fprintf(header, "const uch _length_code[MAX_MATCH-MIN_MATCH+1]= {\n");
     for (i = 0; i < MAX_MATCH-MIN_MATCH+1; i++) {
     }
 
     fprintf(header, "const uch _length_code[MAX_MATCH-MIN_MATCH+1]= {\n");
     for (i = 0; i < MAX_MATCH-MIN_MATCH+1; i++) {

-       fprintf(header, "%2u%s", _length_code[i],
-               SEPARATOR(i, MAX_MATCH-MIN_MATCH, 20));
+        fprintf(header, "%2u%s", _length_code[i],
+                SEPARATOR(i, MAX_MATCH-MIN_MATCH, 20));

     }
 
     fprintf(header, "local const int base_length[LENGTH_CODES] = {\n");
     for (i = 0; i < LENGTH_CODES; i++) {
     }
 
     fprintf(header, "local const int base_length[LENGTH_CODES] = {\n");
     for (i = 0; i < LENGTH_CODES; i++) {

-       fprintf(header, "%1u%s", base_length[i],
-               SEPARATOR(i, LENGTH_CODES-1, 20));
+        fprintf(header, "%1u%s", base_length[i],
+                SEPARATOR(i, LENGTH_CODES-1, 20));

     }
 
     fprintf(header, "local const int base_dist[D_CODES] = {\n");
     for (i = 0; i < D_CODES; i++) {
     }
 
     fprintf(header, "local const int base_dist[D_CODES] = {\n");
     for (i = 0; i < D_CODES; i++) {

-       fprintf(header, "%5u%s", base_dist[i],
-               SEPARATOR(i, D_CODES-1, 10));
+        fprintf(header, "%5u%s", base_dist[i],
+                SEPARATOR(i, D_CODES-1, 10));

     }
 
     fclose(header);
     }
 
     fclose(header);


@@ -378,8 +384,6 @@ void _tr_init(s)
 {
     tr_static_init();
 
 {
     tr_static_init();
 

-    s->compressed_len = 0L;
-

     s->l_desc.dyn_tree = s->dyn_ltree;
     s->l_desc.stat_desc = &static_l_desc;
 
     s->l_desc.dyn_tree = s->dyn_ltree;
     s->l_desc.stat_desc = &static_l_desc;
 


@@ -392,7 +396,8 @@ void _tr_init(s)
     s->bi_buf = 0;
     s->bi_valid = 0;
     s->last_eob_len = 8; /* enough lookahead for inflate */
     s->bi_buf = 0;
     s->bi_valid = 0;
     s->last_eob_len = 8; /* enough lookahead for inflate */

-#ifdef __WXDEBUG__
+#ifdef DEBUG
+    s->compressed_len = 0L;

     s->bits_sent = 0L;
 #endif
 
     s->bits_sent = 0L;
 #endif
 


@@ -550,7 +555,7 @@ local void gen_bitlen(s, desc)
         while (n != 0) {
             m = s->heap[--h];
             if (m > max_code) continue;
         while (n != 0) {
             m = s->heap[--h];
             if (m > max_code) continue;

-            if (tree[m].Len != (unsigned) bits) {
+            if ((unsigned) tree[m].Len != (unsigned) bits) {

                 Trace((stderr,"code %d bits %d->%d\n", m, tree[m].Len, bits));
                 s->opt_len += ((long)bits - (long)tree[m].Len)
                               *(long)tree[m].Freq;
                 Trace((stderr,"code %d bits %d->%d\n", m, tree[m].Len, bits));
                 s->opt_len += ((long)bits - (long)tree[m].Len)
                               *(long)tree[m].Freq;


@@ -669,7 +674,8 @@ local void build_tree(s, desc)
 
         /* Create a new node father of n and m */
         tree[node].Freq = tree[n].Freq + tree[m].Freq;
 
         /* Create a new node father of n and m */
         tree[node].Freq = tree[n].Freq + tree[m].Freq;

-        s->depth[node] = (uch) (MAX(s->depth[n], s->depth[m]) + 1);
+        s->depth[node] = (uch)((s->depth[n] >= s->depth[m] ?
+                                s->depth[n] : s->depth[m]) + 1);

         tree[n].Dad = tree[m].Dad = (ush)node;
 #ifdef DUMP_BL_TREE
         if (tree == s->bl_tree) {
         tree[n].Dad = tree[m].Dad = (ush)node;
 #ifdef DUMP_BL_TREE
         if (tree == s->bl_tree) {


@@ -865,9 +871,10 @@ void _tr_stored_block(s, buf, stored_len, eof)
     int eof;          /* true if this is the last block for a file */
 {
     send_bits(s, (STORED_BLOCK<<1)+eof, 3);  /* send block type */
     int eof;          /* true if this is the last block for a file */
 {
     send_bits(s, (STORED_BLOCK<<1)+eof, 3);  /* send block type */

+#ifdef DEBUG

     s->compressed_len = (s->compressed_len + 3 + 7) & (ulg)~7L;
     s->compressed_len += (stored_len + 4) << 3;
     s->compressed_len = (s->compressed_len + 3 + 7) & (ulg)~7L;
     s->compressed_len += (stored_len + 4) << 3;

-
+#endif

     copy_block(s, buf, (unsigned)stored_len, 1); /* with header */
 }
 
     copy_block(s, buf, (unsigned)stored_len, 1); /* with header */
 }
 


@@ -887,7 +894,9 @@ void _tr_align(s)
 {
     send_bits(s, STATIC_TREES<<1, 3);
     send_code(s, END_BLOCK, static_ltree);
 {
     send_bits(s, STATIC_TREES<<1, 3);
     send_code(s, END_BLOCK, static_ltree);

+#ifdef DEBUG

     s->compressed_len += 10L; /* 3 for block type, 7 for EOB */
     s->compressed_len += 10L; /* 3 for block type, 7 for EOB */

+#endif

     bi_flush(s);
     /* Of the 10 bits for the empty block, we have already sent
      * (10 - bi_valid) bits. The lookahead for the last real code (before
     bi_flush(s);
     /* Of the 10 bits for the empty block, we have already sent
      * (10 - bi_valid) bits. The lookahead for the last real code (before


@@ -897,7 +906,9 @@ void _tr_align(s)
     if (1 + s->last_eob_len + 10 - s->bi_valid < 9) {
         send_bits(s, STATIC_TREES<<1, 3);
         send_code(s, END_BLOCK, static_ltree);
     if (1 + s->last_eob_len + 10 - s->bi_valid < 9) {
         send_bits(s, STATIC_TREES<<1, 3);
         send_code(s, END_BLOCK, static_ltree);

+#ifdef DEBUG

         s->compressed_len += 10L;
         s->compressed_len += 10L;

+#endif

         bi_flush(s);
     }
     s->last_eob_len = 7;
         bi_flush(s);
     }
     s->last_eob_len = 7;


@@ -905,10 +916,9 @@ void _tr_align(s)
 
 /* ===========================================================================
  * Determine the best encoding for the current block: dynamic trees, static
 
 /* ===========================================================================
  * Determine the best encoding for the current block: dynamic trees, static

- * trees or store, and output the encoded block to the zip file. This function
- * returns the total compressed length for the file so far.
+ * trees or store, and output the encoded block to the zip file.

  */
  */

-ulg _tr_flush_block(s, buf, stored_len, eof)
+void _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 */
     deflate_state *s;
     charf *buf;       /* input block, or NULL if too old */
     ulg stored_len;   /* length of input block */


@@ -920,60 +930,42 @@ ulg _tr_flush_block(s, buf, stored_len, eof)
     /* Build the Huffman trees unless a stored block is forced */
     if (s->level > 0) {
 
     /* Build the Huffman trees unless a stored block is forced */
     if (s->level > 0) {
 

-        /* Check if the file is ascii or binary */
-       if (s->data_type == Z_UNKNOWN) set_data_type(s);
+        /* Check if the file is binary or text */
+        if (stored_len > 0 && s->strm->data_type == Z_UNKNOWN)
+            set_data_type(s);

 
 

-       /* Construct the literal and distance trees */
-       build_tree(s, (tree_desc *)(&(s->l_desc)));
-       Tracev((stderr, "\nlit data: dyn %ld, stat %ld", s->opt_len,
-               s->static_len));
+        /* Construct the literal and distance trees */
+        build_tree(s, (tree_desc *)(&(s->l_desc)));
+        Tracev((stderr, "\nlit data: dyn %ld, stat %ld", s->opt_len,
+                s->static_len));

 
 

-       build_tree(s, (tree_desc *)(&(s->d_desc)));
-       Tracev((stderr, "\ndist data: dyn %ld, stat %ld", s->opt_len,
-               s->static_len));
-       /* At this point, opt_len and static_len are the total bit lengths of
-        * the compressed block data, excluding the tree representations.
-        */
+        build_tree(s, (tree_desc *)(&(s->d_desc)));
+        Tracev((stderr, "\ndist data: dyn %ld, stat %ld", s->opt_len,
+                s->static_len));
+        /* At this point, opt_len and static_len are the total bit lengths of
+         * the compressed block data, excluding the tree representations.
+         */

 
 

-       /* Build the bit length tree for the above two trees, and get the index
-        * in bl_order of the last bit length code to send.
-        */
-       max_blindex = build_bl_tree(s);
+        /* Build the bit length tree for the above two trees, and get the index
+         * in bl_order of the last bit length code to send.
+         */
+        max_blindex = build_bl_tree(s);

 
 

-       /* Determine the best encoding. Compute first the block length in bytes*/
-       opt_lenb = (s->opt_len+3+7)>>3;
-       static_lenb = (s->static_len+3+7)>>3;
+        /* Determine the best encoding. Compute the block lengths in bytes. */
+        opt_lenb = (s->opt_len+3+7)>>3;
+        static_lenb = (s->static_len+3+7)>>3;

 
 

-       Tracev((stderr, "\nopt %lu(%lu) stat %lu(%lu) stored %lu lit %u ",
-               opt_lenb, s->opt_len, static_lenb, s->static_len, stored_len,
-               s->last_lit));
+        Tracev((stderr, "\nopt %lu(%lu) stat %lu(%lu) stored %lu lit %u ",
+                opt_lenb, s->opt_len, static_lenb, s->static_len, stored_len,
+                s->last_lit));

 
 

-       if (static_lenb <= opt_lenb) opt_lenb = static_lenb;
+        if (static_lenb <= opt_lenb) opt_lenb = static_lenb;

 
     } else {
         Assert(buf != (char*)0, "lost buf");
 
     } else {
         Assert(buf != (char*)0, "lost buf");

-       opt_lenb = static_lenb = stored_len + 5; /* force a stored block */
+        opt_lenb = static_lenb = stored_len + 5; /* force a stored block */

     }
 
     }
 

-    /* If compression failed and this is the first and last block,
-     * and if the .zip file can be seeked (to rewrite the local header),
-     * the whole file is transformed into a stored file:
-     */
-#ifdef STORED_FILE_OK
-#  ifdef FORCE_STORED_FILE
-    if (eof && s->compressed_len == 0L) { /* force stored file */
-#  else
-    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");
-
-        copy_block(buf, (unsigned)stored_len, 0); /* without header */
-        s->compressed_len = stored_len << 3;
-        s->method = STORED;
-    } else
-#endif /* STORED_FILE_OK */
-

 #ifdef FORCE_STORED
     if (buf != (char*)0) { /* force stored block */
 #else
 #ifdef FORCE_STORED
     if (buf != (char*)0) { /* force stored block */
 #else


@@ -991,29 +983,36 @@ ulg _tr_flush_block(s, buf, stored_len, eof)
 #ifdef FORCE_STATIC
     } else if (static_lenb >= 0) { /* force static trees */
 #else
 #ifdef FORCE_STATIC
     } else if (static_lenb >= 0) { /* force static trees */
 #else

-    } else if (static_lenb == opt_lenb) {
+    } else if (s->strategy == Z_FIXED || static_lenb == opt_lenb) {

 #endif
         send_bits(s, (STATIC_TREES<<1)+eof, 3);
         compress_block(s, (ct_data *)static_ltree, (ct_data *)static_dtree);
 #endif
         send_bits(s, (STATIC_TREES<<1)+eof, 3);
         compress_block(s, (ct_data *)static_ltree, (ct_data *)static_dtree);

+#ifdef DEBUG

         s->compressed_len += 3 + s->static_len;
         s->compressed_len += 3 + s->static_len;

+#endif

     } else {
         send_bits(s, (DYN_TREES<<1)+eof, 3);
         send_all_trees(s, s->l_desc.max_code+1, s->d_desc.max_code+1,
                        max_blindex+1);
         compress_block(s, (ct_data *)s->dyn_ltree, (ct_data *)s->dyn_dtree);
     } else {
         send_bits(s, (DYN_TREES<<1)+eof, 3);
         send_all_trees(s, s->l_desc.max_code+1, s->d_desc.max_code+1,
                        max_blindex+1);
         compress_block(s, (ct_data *)s->dyn_ltree, (ct_data *)s->dyn_dtree);

+#ifdef DEBUG

         s->compressed_len += 3 + s->opt_len;
         s->compressed_len += 3 + s->opt_len;

+#endif

     }
     Assert (s->compressed_len == s->bits_sent, "bad compressed size");
     }
     Assert (s->compressed_len == s->bits_sent, "bad compressed size");

+    /* The above check is made mod 2^32, for files larger than 512 MB
+     * and uLong implemented on 32 bits.
+     */

     init_block(s);
 
     if (eof) {
         bi_windup(s);
     init_block(s);
 
     if (eof) {
         bi_windup(s);

+#ifdef DEBUG

         s->compressed_len += 7;  /* align on byte boundary */
         s->compressed_len += 7;  /* align on byte boundary */

+#endif

     }
     Tracev((stderr,"\ncomprlen %lu(%lu) ", s->compressed_len>>3,
            s->compressed_len-7*eof));
     }
     Tracev((stderr,"\ncomprlen %lu(%lu) ", s->compressed_len>>3,
            s->compressed_len-7*eof));

-
-    return s->compressed_len >> 3;

 }
 
 /* ===========================================================================
 }
 
 /* ===========================================================================


@@ -1109,7 +1108,8 @@ 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: */
         } /* 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((uInt)(s->pending) < s->lit_bufsize + 2*lx,
+               "pendingBuf overflow");

 
     } while (lx < s->last_lit);
 
 
     } while (lx < s->last_lit);
 


@@ -1118,21 +1118,24 @@ local void compress_block(s, ltree, dtree)
 }
 
 /* ===========================================================================
 }
 
 /* ===========================================================================

- * Set the data type to ASCII or BINARY, using a crude approximation:
- * binary if more than 20% of the bytes are <= 6 or >= 128, ascii otherwise.
- * 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).
+ * Set the data type to BINARY or TEXT, using a crude approximation:
+ * set it to Z_TEXT if all symbols are either printable characters (33 to 255)
+ * or white spaces (9 to 13, or 32); or set it to Z_BINARY otherwise.
+ * IN assertion: the fields Freq of dyn_ltree are set.

  */
 local void set_data_type(s)
     deflate_state *s;
 {
  */
 local void set_data_type(s)
     deflate_state *s;
 {

-    int n = 0;
-    unsigned ascii_freq = 0;
-    unsigned bin_freq = 0;
-    while (n < 7)        bin_freq += s->dyn_ltree[n++].Freq;
-    while (n < 128)    ascii_freq += s->dyn_ltree[n++].Freq;
-    while (n < LITERALS) bin_freq += s->dyn_ltree[n++].Freq;
-    s->data_type = (Byte)(bin_freq > (ascii_freq >> 2) ? Z_BINARY : Z_ASCII);
+    int n;
+
+    for (n = 0; n < 9; n++)
+        if (s->dyn_ltree[n].Freq != 0)
+            break;
+    if (n == 9)
+        for (n = 14; n < 32; n++)
+            if (s->dyn_ltree[n].Freq != 0)
+                break;
+    s->strm->data_type = (n == 32) ? Z_TEXT : Z_BINARY;

 }
 
 /* ===========================================================================
 }
 
 /* ===========================================================================


@@ -1182,7 +1185,7 @@ local void bi_windup(s)
     }
     s->bi_buf = 0;
     s->bi_valid = 0;
     }
     s->bi_buf = 0;
     s->bi_valid = 0;

-#ifdef __WXDEBUG__
+#ifdef DEBUG

     s->bits_sent = (s->bits_sent+7) & ~7;
 #endif
 }
     s->bits_sent = (s->bits_sent+7) & ~7;
 #endif
 }


@@ -1201,13 +1204,13 @@ local void copy_block(s, buf, len, header)
     s->last_eob_len = 8; /* enough lookahead for inflate */
 
     if (header) {
     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);
         put_short(s, (ush)~len);

-#ifdef __WXDEBUG__
+#ifdef DEBUG

         s->bits_sent += 2*16;
 #endif
     }
         s->bits_sent += 2*16;
 #endif
     }

-#ifdef __WXDEBUG__
+#ifdef DEBUG

     s->bits_sent += (ulg)len<<3;
 #endif
     while (len--) {
     s->bits_sent += (ulg)len<<3;
 #endif
     while (len--) {