Builds clean Apple LLVM version 6.0 (clang-600.0.56) (based on LLVM 3.5svn)

8 files changed, 41 insertions, 49 deletions

diff --git a/xdelta3/testing/regtest.cc b/xdelta3/testing/regtest.cc
index 84ee100..69f8f80 100644
--- a/xdelta3/testing/regtest.cc
+++ b/xdelta3/testing/regtest.cc
@@ -1222,7 +1222,7 @@ void UnitTest() {
 // These are Xdelta tests.
 template <class T>
 void MainTest() {
-  XPR(NT "Blocksize %"Q"u windowsize %"Q"u\n",
+  XPR(NT "Blocksize %"Q"u windowsize %zu\n",
       T::BLOCK_SIZE, T::WINDOW_SIZE);
   Regtest<T> regtest;
   TEST(TestEmptyInMemory);
diff --git a/xdelta3/xdelta3-decode.h b/xdelta3/xdelta3-decode.h
index b0051aa..008993d 100644
--- a/xdelta3/xdelta3-decode.h
+++ b/xdelta3/xdelta3-decode.h
@@ -156,7 +156,7 @@ xd3_decode_section (xd3_stream *stream,
           usize_t sect_need = section->size - section->pos;
 
           /* Allocate and copy */
-          sect_take = min (sect_need, stream->avail_in);
+          sect_take = xd3_min (sect_need, stream->avail_in);
 
           if (section->pos == 0)
             {
@@ -582,7 +582,7 @@ xd3_decode_sections (xd3_stream *stream)
   more = (need - stream->dec_winbytes);
 
   /* How much to consume. */
-  take = min (more, stream->avail_in);
+  take = xd3_min (more, stream->avail_in);
 
   /* See if the input is completely available, to avoid copy. */
   copy = (take != more);
diff --git a/xdelta3/xdelta3-djw.h b/xdelta3/xdelta3-djw.h
index 422e06a..080de59 100644
--- a/xdelta3/xdelta3-djw.h
+++ b/xdelta3/xdelta3-djw.h
@@ -456,7 +456,7 @@ djw_build_prefix (const djw_weight *freq, uint8_t *clen, usize_t asize, usize_t
       djw_heapen *h2 = heap_extract (heap, ents, --heap_last);
 
       ents[ents_size].freq   = h1->freq + h2->freq;
-      ents[ents_size].depth  = 1 + max (h1->depth, h2->depth);
+      ents[ents_size].depth  = 1 + xd3_max (h1->depth, h2->depth);
       ents[ents_size].parent = 0;
 
       h1->parent = h2->parent = ents_size;
@@ -525,7 +525,7 @@ djw_build_codes (usize_t *codes, const uint8_t *clen, usize_t asize, usize_t abs
           min_clen = clen[i];
         }
 
-      max_clen = max (max_clen, (usize_t) clen[i]);
+      max_clen = xd3_max (max_clen, (usize_t) clen[i]);
     }
 
   XD3_ASSERT (max_clen <= abs_max);
@@ -1799,7 +1799,7 @@ xd3_decode_huff (xd3_stream     *stream,
             XD3_ASSERT (output_end - output > 0);
             
             /* Decode next sector. */
-            n = min (sector_size, (usize_t) (output_end - output));
+            n = xd3_min (sector_size, (usize_t) (output_end - output));
 
             do
               {
diff --git a/xdelta3/xdelta3-main.h b/xdelta3/xdelta3-main.h
index 018a697..0f51ff8 100644
--- a/xdelta3/xdelta3-main.h
+++ b/xdelta3/xdelta3-main.h
@@ -978,7 +978,7 @@ xd3_posix_io (int fd, uint8_t *buf, size_t size,
 
   while (nproc < size)
     {
-      size_t tryread = min(size - nproc, 1U << 30);
+      size_t tryread = xd3_min(size - nproc, 1U << 30);
       ssize_t result = (*func) (fd, buf + nproc, tryread);
 
       if (result < 0)
@@ -1930,7 +1930,7 @@ main_merge_output (xd3_stream *stream, main_file *ofile)
              inst_pos < stream->whole_target.instlen)
         {
           xd3_winst *inst = &stream->whole_target.inst[inst_pos];
-          usize_t take = min(inst->size, window_size - window_pos);
+          usize_t take = xd3_min(inst->size, window_size - window_pos);
           xoff_t addr;
 
           switch (inst->type)
@@ -1953,8 +1953,8 @@ main_merge_output (xd3_stream *stream, main_file *ofile)
               if (inst->mode != 0)
                 {
                   if (window_srcset) {
-                    window_srcmin = min(window_srcmin, inst->addr);
-                    window_srcmax = max(window_srcmax, inst->addr + take);
+                    window_srcmin = xd3_min (window_srcmin, inst->addr);
+                    window_srcmax = xd3_max (window_srcmax, inst->addr + take);
                   } else {
                     window_srcset = 1;
                     window_srcmin = inst->addr;
@@ -2414,7 +2414,7 @@ main_secondary_decompress_check (main_file  *file,
 {
   int ret;
   usize_t i;
-  usize_t try_read = min (input_size, XD3_ALLOCSIZE);
+  usize_t try_read = xd3_min (input_size, XD3_ALLOCSIZE);
   size_t  check_nread = 0;
   uint8_t check_buf[XD3_ALLOCSIZE];  /* TODO: stack limit */
   const main_extcomp *decompressor = NULL;
@@ -2939,10 +2939,10 @@ main_get_winsize (main_file *ifile) {
 
   if (main_file_stat (ifile, &file_size) == 0)
     {
-      size = (usize_t) min(file_size, (xoff_t) size);
+      size = (usize_t) xd3_min (file_size, (xoff_t) size);
     }
 
-  size = max(size, XD3_ALLOCSIZE);
+  size = xd3_max (size, XD3_ALLOCSIZE);
 
   if (option_verbose > 1)
     {
@@ -3173,7 +3173,7 @@ main_input (xd3_cmd     cmd,
 
       input_remain = XOFF_T_MAX - input_offset;
 
-      try_read = (usize_t) min ((xoff_t) config.winsize, input_remain);
+      try_read = (usize_t) xd3_min ((xoff_t) config.winsize, input_remain);
 
       if ((ret = main_read_primary_input (ifile, main_bdata,
                                           try_read, & nread)))
diff --git a/xdelta3/xdelta3-merge.h b/xdelta3/xdelta3-merge.h
index e65978d..72bc892 100644
--- a/xdelta3/xdelta3-merge.h
+++ b/xdelta3/xdelta3-merge.h
@@ -446,7 +446,7 @@ xd3_merge_source_copy (xd3_stream *stream,
       XD3_ASSERT (sinst->size > sinst_offset);
 
       sinst_left = sinst->size - sinst_offset;
-      this_take = min (iinst.size, sinst_left);
+      this_take = xd3_min (iinst.size, sinst_left);
 
       XD3_ASSERT (this_take > 0);
 
diff --git a/xdelta3/xdelta3-test.h b/xdelta3/xdelta3-test.h
index 948a1d6..659bd31 100644
--- a/xdelta3/xdelta3-test.h
+++ b/xdelta3/xdelta3-test.h
@@ -109,7 +109,7 @@ mt_exp_rand (uint32_t mean, uint32_t max_value)
                               (double)UINT32_MAX));
   uint32_t x = (uint32_t) (mean_d * erand + 0.5);
 
-  return min (x, max_value);
+  return xd3_min (x, max_value);
 }
 
 #if SHELL_TESTS
@@ -300,7 +300,7 @@ test_make_inputs (xd3_stream *stream, xoff_t *ss_out, xoff_t *ts_out)
       double add_prob = (left == 0) ? 0 : (add_left / (double) left);
       int do_copy;
 
-      next = min (left, next);
+      next = xd3_min (left, next);
       do_copy = (next > add_left ||
                  (mt_random (&static_mtrand) / \
                   (double)USIZE_T_MAX) >= add_prob);
@@ -735,10 +735,10 @@ test_address_cache (xd3_stream *stream, int unused)
       p         = (mt_random (&static_mtrand) / (double)USIZE_T_MAX);
       prev_i    = mt_random (&static_mtrand) % offset;
       nearby    = (mt_random (&static_mtrand) % 256) % offset;
-      nearby    = max (1U, nearby);
+      nearby    = xd3_max (1U, nearby);
 
       if (p < 0.1)      { addr = addrs[offset-nearby]; }
-      else if (p < 0.4) { addr = min (addrs[prev_i] + nearby, offset-1); }
+      else if (p < 0.4) { addr = xd3_min (addrs[prev_i] + nearby, offset-1); }
       else              { addr = prev_i; }
 
       if ((ret = xd3_encode_address (stream, addr, offset, & modes[offset]))) { return ret; }
@@ -884,7 +884,7 @@ test_decompress_text (xd3_stream *stream, uint8_t *enc, usize_t enc_size, usize_
 
  input:
   /* Test decoding test_desize input bytes at a time */
-  take = min (enc_size - pos, test_desize);
+  take = xd3_min (enc_size - pos, test_desize);
   CHECK(take > 0);
 
   xd3_avail_input (stream, enc + pos, take);
@@ -1440,7 +1440,7 @@ test_secondary (xd3_stream *stream, const xd3_sec_type *sec, usize_t groups)
            * decoding.  Really looking for faults here. */
           {
             int i;
-            int bytes = min (compress_size, 10U);
+            int bytes = xd3_min (compress_size, 10U);
             for (i = 0; i < bytes * 8; i += 1)
               {
                 dec_input[i/8] ^= 1 << (i%8);
diff --git a/xdelta3/xdelta3.c b/xdelta3/xdelta3.c
index 8513aac..3dcf80c 100644
--- a/xdelta3/xdelta3.c
+++ b/xdelta3/xdelta3.c
@@ -1265,7 +1265,7 @@ xd3_decode_bytes (xd3_stream *stream, uint8_t *buf, usize_t *pos, usize_t size)
         }
 
       want = size - *pos;
-      take = min (want, stream->avail_in);
+      take = xd3_min (want, stream->avail_in);
 
       memcpy (buf + *pos, stream->next_in, (size_t) take);
 
@@ -1325,7 +1325,7 @@ xd3_emit_bytes (xd3_stream     *stream,
           output = (*outputp) = aoutput;
         }
 
-      take = min (output->avail - output->next, size);
+      take = xd3_min (output->avail - output->next, size);
 
       memcpy (output->base + output->next, base, (size_t) take);
 
@@ -2237,7 +2237,7 @@ xd3_set_source (xd3_stream *stream,
       src->max_winsize = xd3_xoff_roundup(src->max_winsize);
       IF_DEBUG1 (DP(RINT "raising src_maxsize to %u\n", src->blksize));
     }
-  src->max_winsize = max(src->max_winsize, XD3_ALLOCSIZE);
+  src->max_winsize = xd3_max (src->max_winsize, XD3_ALLOCSIZE);
 
   return 0;
 }
@@ -2683,7 +2683,7 @@ xd3_iopt_flush_instructions (xd3_stream *stream, int force)
           /* Try to balance the length of both instructions, but avoid
            * making both longer than MAX_MATCH_SPLIT . */
           average = gap / 2;
-          newsize = min (MAX_MATCH_SPLIT, gap - average);
+          newsize = xd3_min (MAX_MATCH_SPLIT, gap - average);
 
           /* Should be possible to simplify this code. */
           if (newsize > r1->size)
@@ -3160,7 +3160,7 @@ xd3_encode_buffer_leftover (xd3_stream *stream)
 
   /* Copy into the buffer. */
   room = stream->winsize - stream->buf_avail;
-  take = min (room, stream->avail_in);
+  take = xd3_min (room, stream->avail_in);
 
   memcpy (stream->buf_in + stream->buf_avail, stream->next_in, take);
 
@@ -3239,7 +3239,7 @@ xd3_encode_init (xd3_stream *stream, int full_init)
 
       if (small_comp)
         {
-          /* TODO: This is under devel: used to have min(sprevsz) here, which sort
+          /* TODO: This is under devel: used to have min (sprevsz) here, which sort
            * of makes sense, but observed fast performance w/ larger tables, which
            * also sort of makes sense. @@@ */
           usize_t hash_values = stream->winsize;
@@ -3580,7 +3580,7 @@ xd3_process_stream (int            is_encode,
                     usize_t        output_size_max)
 {
   usize_t ipos = 0;
-  usize_t n = min(stream->winsize, input_size);
+  usize_t n = xd3_min (stream->winsize, input_size);
 
   (*output_size) = 0;
 
@@ -3596,7 +3596,7 @@ xd3_process_stream (int            is_encode,
         {
         case XD3_OUTPUT: { /* memcpy below */ break; }
         case XD3_INPUT: {
-          n = min(stream->winsize, input_size - ipos);
+          n = xd3_min(stream->winsize, input_size - ipos);
           if (n == 0) 
             {
               goto done;
@@ -3672,7 +3672,7 @@ xd3_process_memory (int            is_encode,
 
   if (is_encode)
     {
-      config.winsize = min(input_size, (usize_t) XD3_DEFAULT_WINSIZE);
+      config.winsize = xd3_min(input_size, (usize_t) XD3_DEFAULT_WINSIZE);
       config.sprevsz = xd3_pow2_roundup (config.winsize);
     }
 
@@ -3927,8 +3927,8 @@ xd3_srcwin_setup (xd3_stream *stream)
    * issued, but we have to decide the source window base and length
    * now.  */
   src->srcbase = stream->match_minaddr;
-  src->srclen  = max ((usize_t) length,
-                      stream->avail_in + (stream->avail_in >> 2));
+  src->srclen  = xd3_max ((usize_t) length,
+                          stream->avail_in + (stream->avail_in >> 2));
 
   if (src->eof_known)
     {
@@ -3936,7 +3936,7 @@ xd3_srcwin_setup (xd3_stream *stream)
        * code that expects to pass a single block w/ getblk == NULL
        * will not function, as the code will return GETSRCBLK asking
        * for the second block. */
-      src->srclen = min (src->srclen, xd3_source_eof(src) - src->srcbase);
+      src->srclen = xd3_min (src->srclen, xd3_source_eof(src) - src->srcbase);
     }
   
   IF_DEBUG1 (DP(RINT "[srcwin_setup_constrained] base %llu len %llu\n",
@@ -4200,7 +4200,7 @@ xd3_source_extend_match (xd3_stream *stream)
               return ret;
             }
 
-          tryrem = min (tryoff, stream->match_maxback - stream->match_back);
+          tryrem = xd3_min (tryoff, stream->match_maxback - stream->match_back);
 
           IF_DEBUG2(DP(RINT "[maxback] maxback %u trysrc %"Q"u/%u tgt %u tryrem %u\n",
                        stream->match_maxback, tryblk, tryoff, streamoff, tryrem));
@@ -4245,7 +4245,7 @@ xd3_source_extend_match (xd3_stream *stream)
           return ret;
         }
 
-      tryrem = min(stream->match_maxfwd - stream->match_fwd,
+      tryrem = xd3_min(stream->match_maxfwd - stream->match_fwd,
                    src->onblk - tryoff);
 
       if (tryrem == 0)
@@ -4587,7 +4587,7 @@ xd3_srcwin_move_point (xd3_stream *stream, usize_t *next_move_point)
 
   /* Begin by advancing at twice the input rate, up to half the
    * maximum window size. */
-  logical_input_cksum_pos = min((stream->total_in + stream->input_position) * 2,
+  logical_input_cksum_pos = xd3_min((stream->total_in + stream->input_position) * 2,
                                 (stream->total_in + stream->input_position) +
                                   (stream->src->max_winsize / 2));
 
@@ -4812,9 +4812,9 @@ XD3_TEMPLATE(xd3_string_match_) (xd3_stream *stream)
    * of length 8 at the next position. */
   if (xd3_iopt_last_matched (stream) > stream->input_position)
     {
-      stream->min_match = max(MIN_MATCH,
-                              1 + xd3_iopt_last_matched(stream) -
-                              stream->input_position);
+      stream->min_match = xd3_max (MIN_MATCH,
+                                   1 + xd3_iopt_last_matched(stream) -
+                                   stream->input_position);
     }
   else
     {
diff --git a/xdelta3/xdelta3.h b/xdelta3/xdelta3.h
index 69204c5..f72cdc9 100644
--- a/xdelta3/xdelta3.h
+++ b/xdelta3/xdelta3.h
@@ -157,11 +157,7 @@ typedef uint64_t xoff_t;
 #define SIZEOF_XOFF_T 8
 #define SIZEOF_USIZE_T 4
 #ifndef WIN32
-#if SIZEOF_SIZE_T == 8
-#define Q "z"
-#else
 #define Q "ll"
-#endif
 #else
 #define Q "I64"
 #endif
@@ -309,12 +305,8 @@ typedef int              (xd3_comp_table_func) (xd3_stream *stream,
 #define XD3_ASSERT(x) (void)0
 #endif  /* XD3_DEBUG */
 
-#ifndef max
-#define max(x,y) ((x) < (y) ? (y) : (x))
-#endif
-#ifndef min
-#define min(x,y) ((x) < (y) ? (x) : (y))
-#endif
+#define xd3_max(x,y) ((x) < (y) ? (y) : (x))
+#define xd3_min(x,y) ((x) < (y) ? (x) : (y))
 
 /****************************************************************
  PUBLIC ENUMS