react-native-update 10.34.3 → 10.34.4

package/harmony/pushy/src/main/cpp/HDiffPatch/libHDiffPatch/HDiff/private_diff/libdivsufsort/utils.c.inc.h

@@ -0,0 +1,381 @@
+/*
+ * utils.c for libdivsufsort
+ * Copyright (c) 2003-2008 Yuta Mori All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "divsufsort_private.h"
+
+
+/*- Private Function -*/
+
+/* Binary search for inverse bwt. */
+static
+saidx_t
+binarysearch_lower(const saidx_t *A, saidx_t size, saidx_t value) {
+  saidx_t half, i;
+  for(i = 0, half = size >> 1;
+      0 < size;
+      size = half, half >>= 1) {
+    if(A[i + half] < value) {
+      i += half + 1;
+      half -= (size & 1) ^ 1;
+    }
+  }
+  return i;
+}
+
+
+/*- Functions -*/
+
+/* Burrows-Wheeler transform. */
+saint_t
+bw_transform(const sauchar_t *T, sauchar_t *U, saidx_t *SA,
+             saidx_t n, saidx_t *idx) {
+  saidx_t *A, i, j, p, t;
+  saint_t c;
+
+  /* Check arguments. */
+  if((T == NULL) || (U == NULL) || (n < 0) || (idx == NULL)) { return -1; }
+  if(n <= 1) {
+    if(n == 1) { U[0] = T[0]; }
+    *idx = n;
+    return 0;
+  }
+
+  if((A = SA) == NULL) {
+    i = divbwt(T, U, NULL, n);
+    if(0 <= i) { *idx = i; i = 0; }
+    return (saint_t)i;
+  }
+
+  /* BW transform. */
+  if(T == U) {
+    t = n;
+    for(i = 0, j = 0; i < n; ++i) {
+      p = t - 1;
+      t = A[i];
+      if(0 <= p) {
+        c = T[j];
+        U[j] = (j <= p) ? T[p] : (sauchar_t)A[p];
+        A[j] = c;
+        j++;
+      } else {
+        *idx = i;
+      }
+    }
+    p = t - 1;
+    if(0 <= p) {
+      c = T[j];
+      U[j] = (j <= p) ? T[p] : (sauchar_t)A[p];
+      A[j] = c;
+    } else {
+      *idx = i;
+    }
+  } else {
+    U[0] = T[n - 1];
+    for(i = 0; A[i] != 0; ++i) { U[i + 1] = T[A[i] - 1]; }
+    *idx = i + 1;
+    for(++i; i < n; ++i) { U[i] = T[A[i] - 1]; }
+  }
+
+  if(SA == NULL) {
+    /* Deallocate memory. */
+    free(A);
+  }
+
+  return 0;
+}
+
+/* Inverse Burrows-Wheeler transform. */
+saint_t
+inverse_bw_transform(const sauchar_t *T, sauchar_t *U, saidx_t *A,
+                     saidx_t n, saidx_t idx) {
+  saidx_t C[ALPHABET_SIZE];
+  sauchar_t D[ALPHABET_SIZE];
+  saidx_t *B;
+  saidx_t i, p;
+  saint_t c, d;
+
+  /* Check arguments. */
+  if((T == NULL) || (U == NULL) || (n < 0) || (idx < 0) ||
+     (n < idx) || ((0 < n) && (idx == 0))) {
+    return -1;
+  }
+  if(n <= 1) { return 0; }
+
+  if((B = A) == NULL) {
+    /* Allocate n*sizeof(saidx_t) bytes of memory. */
+    if((B = (saidx_t *)malloc((size_t)n * sizeof(saidx_t))) == NULL) { return -2; }
+  }
+
+  /* Inverse BW transform. */
+  for(c = 0; c < ALPHABET_SIZE; ++c) { C[c] = 0; }
+  for(i = 0; i < n; ++i) { ++C[T[i]]; }
+  for(c = 0, d = 0, i = 0; c < ALPHABET_SIZE; ++c) {
+    p = C[c];
+    if(0 < p) {
+      C[c] = i;
+      D[d++] = (sauchar_t)c;
+      i += p;
+    }
+  }
+  for(i = 0; i < idx; ++i) { B[C[T[i]]++] = i; }
+  for( ; i < n; ++i)       { B[C[T[i]]++] = i + 1; }
+  for(c = 0; c < d; ++c) { C[c] = C[D[c]]; }
+  for(i = 0, p = idx; i < n; ++i) {
+    U[i] = D[binarysearch_lower(C, d, p)];
+    p = B[p - 1];
+  }
+
+  if(A == NULL) {
+    /* Deallocate memory. */
+    free(B);
+  }
+
+  return 0;
+}
+
+/* Checks the suffix array SA of the string T. */
+saint_t
+sufcheck(const sauchar_t *T, const saidx_t *SA,
+         saidx_t n, saint_t verbose) {
+  saidx_t C[ALPHABET_SIZE];
+  saidx_t i, p, q, t;
+  saint_t c;
+
+  if(verbose) { fprintf(stderr, "sufcheck: "); }
+
+  /* Check arguments. */
+  if((T == NULL) || (SA == NULL) || (n < 0)) {
+    if(verbose) { fprintf(stderr, "Invalid arguments.\n"); }
+    return -1;
+  }
+  if(n == 0) {
+    if(verbose) { fprintf(stderr, "Done.\n"); }
+    return 0;
+  }
+
+  /* check range: [0..n-1] */
+  for(i = 0; i < n; ++i) {
+    if((SA[i] < 0) || (n <= SA[i])) {
+      if(verbose) {
+        fprintf(stderr, "Out of the range [0,%" PRIdSAIDX_T "].\n"
+                        "  SA[%" PRIdSAIDX_T "]=%" PRIdSAIDX_T "\n",
+                        n - 1, i, SA[i]);
+      }
+      return -2;
+    }
+  }
+
+  /* check first characters. */
+  for(i = 1; i < n; ++i) {
+    if(T[SA[i - 1]] > T[SA[i]]) {
+      if(verbose) {
+        fprintf(stderr, "Suffixes in wrong order.\n"
+                        "  T[SA[%" PRIdSAIDX_T "]=%" PRIdSAIDX_T "]=%d"
+                        " > T[SA[%" PRIdSAIDX_T "]=%" PRIdSAIDX_T "]=%d\n",
+                        i - 1, SA[i - 1], T[SA[i - 1]], i, SA[i], T[SA[i]]);
+      }
+      return -3;
+    }
+  }
+
+  /* check suffixes. */
+  for(i = 0; i < ALPHABET_SIZE; ++i) { C[i] = 0; }
+  for(i = 0; i < n; ++i) { ++C[T[i]]; }
+  for(i = 0, p = 0; i < ALPHABET_SIZE; ++i) {
+    t = C[i];
+    C[i] = p;
+    p += t;
+  }
+
+  q = C[T[n - 1]];
+  C[T[n - 1]] += 1;
+  for(i = 0; i < n; ++i) {
+    p = SA[i];
+    if(0 < p) {
+      c = T[--p];
+      t = C[c];
+    } else {
+      c = T[p = n - 1];
+      t = q;
+    }
+    if((t < 0) || (p != SA[t])) {
+      if(verbose) {
+        fprintf(stderr, "Suffix in wrong position.\n"
+                        "  SA[%" PRIdSAIDX_T "]=%" PRIdSAIDX_T " or\n"
+                        "  SA[%" PRIdSAIDX_T "]=%" PRIdSAIDX_T "\n",
+                        t, (0 <= t) ? SA[t] : -1, i, SA[i]);
+      }
+      return -4;
+    }
+    if(t != q) {
+      ++C[c];
+      if((n <= C[c]) || (T[SA[C[c]]] != c)) { C[c] = -1; }
+    }
+  }
+
+  if(1 <= verbose) { fprintf(stderr, "Done.\n"); }
+  return 0;
+}
+
+
+static
+int
+_compare(const sauchar_t *T, saidx_t Tsize,
+         const sauchar_t *P, saidx_t Psize,
+         saidx_t suf, saidx_t *match) {
+  saidx_t i, j;
+  saint_t r;
+  for(i = suf + *match, j = *match, r = 0;
+      (i < Tsize) && (j < Psize) && ((r = T[i] - P[j]) == 0); ++i, ++j) { }
+  *match = j;
+  return (r == 0) ? -(j != Psize) : r;
+}
+
+/* Search for the pattern P in the string T. */
+saidx_t
+sa_search(const sauchar_t *T, saidx_t Tsize,
+          const sauchar_t *P, saidx_t Psize,
+          const saidx_t *SA, saidx_t SAsize,
+          saidx_t *idx) {
+  saidx_t size, lsize, rsize, half;
+  saidx_t match, lmatch, rmatch;
+  saidx_t llmatch, lrmatch, rlmatch, rrmatch;
+  saidx_t i, j, k;
+  saint_t r;
+
+  if(idx != NULL) { *idx = -1; }
+  if((T == NULL) || (P == NULL) || (SA == NULL) ||
+     (Tsize < 0) || (Psize < 0) || (SAsize < 0)) { return -1; }
+  if((Tsize == 0) || (SAsize == 0)) { return 0; }
+  if(Psize == 0) { if(idx != NULL) { *idx = 0; } return SAsize; }
+
+  for(i = j = k = 0, lmatch = rmatch = 0, size = SAsize, half = size >> 1;
+      0 < size;
+      size = half, half >>= 1) {
+    match = MIN(lmatch, rmatch);
+    r = _compare(T, Tsize, P, Psize, SA[i + half], &match);
+    if(r < 0) {
+      i += half + 1;
+      half -= (size & 1) ^ 1;
+      lmatch = match;
+    } else if(r > 0) {
+      rmatch = match;
+    } else {
+      lsize = half, j = i, rsize = size - half - 1, k = i + half + 1;
+
+      /* left part */
+      for(llmatch = lmatch, lrmatch = match, half = lsize >> 1;
+          0 < lsize;
+          lsize = half, half >>= 1) {
+        lmatch = MIN(llmatch, lrmatch);
+        r = _compare(T, Tsize, P, Psize, SA[j + half], &lmatch);
+        if(r < 0) {
+          j += half + 1;
+          half -= (lsize & 1) ^ 1;
+          llmatch = lmatch;
+        } else {
+          lrmatch = lmatch;
+        }
+      }
+
+      /* right part */
+      for(rlmatch = match, rrmatch = rmatch, half = rsize >> 1;
+          0 < rsize;
+          rsize = half, half >>= 1) {
+        rmatch = MIN(rlmatch, rrmatch);
+        r = _compare(T, Tsize, P, Psize, SA[k + half], &rmatch);
+        if(r <= 0) {
+          k += half + 1;
+          half -= (rsize & 1) ^ 1;
+          rlmatch = rmatch;
+        } else {
+          rrmatch = rmatch;
+        }
+      }
+
+      break;
+    }
+  }
+
+  if(idx != NULL) { *idx = (0 < (k - j)) ? j : i; }
+  return k - j;
+}
+
+/* Search for the character c in the string T. */
+saidx_t
+sa_simplesearch(const sauchar_t *T, saidx_t Tsize,
+                const saidx_t *SA, saidx_t SAsize,
+                saint_t c, saidx_t *idx) {
+  saidx_t size, lsize, rsize, half;
+  saidx_t i, j, k, p;
+  saint_t r;
+
+  if(idx != NULL) { *idx = -1; }
+  if((T == NULL) || (SA == NULL) || (Tsize < 0) || (SAsize < 0)) { return -1; }
+  if((Tsize == 0) || (SAsize == 0)) { return 0; }
+
+  for(i = j = k = 0, size = SAsize, half = size >> 1;
+      0 < size;
+      size = half, half >>= 1) {
+    p = SA[i + half];
+    r = (p < Tsize) ? T[p] - c : -1;
+    if(r < 0) {
+      i += half + 1;
+      half -= (size & 1) ^ 1;
+    } else if(r == 0) {
+      lsize = half, j = i, rsize = size - half - 1, k = i + half + 1;
+
+      /* left part */
+      for(half = lsize >> 1;
+          0 < lsize;
+          lsize = half, half >>= 1) {
+        p = SA[j + half];
+        r = (p < Tsize) ? T[p] - c : -1;
+        if(r < 0) {
+          j += half + 1;
+          half -= (lsize & 1) ^ 1;
+        }
+      }
+
+      /* right part */
+      for(half = rsize >> 1;
+          0 < rsize;
+          rsize = half, half >>= 1) {
+        p = SA[k + half];
+        r = (p < Tsize) ? T[p] - c : -1;
+        if(r <= 0) {
+          k += half + 1;
+          half -= (rsize & 1) ^ 1;
+        }
+      }
+
+      break;
+    }
+  }
+
+  if(idx != NULL) { *idx = (0 < (k - j)) ? j : i; }
+  return k - j;
+}

package/harmony/pushy/src/main/cpp/HDiffPatch/libHDiffPatch/HDiff/private_diff/limit_mem_diff/adler_roll.c

@@ -45,27 +45,7 @@
 #   define _adler64_BASE                0xFFFFFFFBull
 #   define _fast_adler64_BASE           ((uint64_t)1<<32)
 
-
-#ifndef _CPU_IS_LITTLE_ENDIAN
-#   if     (defined(__BYTE_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)) \
-        || defined(__LITTLE_ENDIAN__) \
-        || defined(_M_AMD64) || defined(_M_X64) || defined(__x86_64__) || defined(__AMD64__) \
-        || defined(__amd64__) || defined(_M_IX86) || defined(__i386__) \
-        || defined(_M_IA64) || defined(__ia64__) \
-        || defined(__ARMEL__) || defined(__THUMBEL__) || defined(__AARCH64EL__) \
-        || defined(__MIPSEL__) || defined(__MIPSEL) || defined(_MIPSEL) || defined(__BFIN__)
-#       define _CPU_IS_LITTLE_ENDIAN   1
-#   endif
-#endif
-
-
-//__fast_adler_table create by _gen_fast_adler_table() on MacOSX
-#if (_IS_NEED_FAST_ADLER128) || (_CPU_IS_LITTLE_ENDIAN)
-#   if _IS_NEED_FAST_ADLER128
-static const uint64_t __fast_adler_table[256]={
-#   else
-static const uint64_t __fast_adler_table[128]={
-#   endif
+static const uint64_t __fast_adler_table[256]=/*create by _gen_fast_adler_table*/{
     0xe9834671b5e6a199ull,0x0914fc228c715a7full,0x9d31fb3962abb5afull,0xa3d3c03569f00344ull,
     0x399a5b7264db3b1cull,0x0c036c4f959bb01eull,0x4dc75b77344fbc39ull,0x0ab026b325be7198ull,
     0xe6a1281ebab2d5e6ull,0x53346d230eb13df7ull,0xb363ede943437647ull,0xdea89be55783a9ebull,
@@ -98,7 +78,6 @@ static const uint64_t __fast_adler_table[128]={
     0x55c725b1880c75bbull,0x04747a86d6e226a9ull,0xde31e4b63ba442afull,0x90be6f0656b265b8ull,
     0xe6004b58d491b721ull,0xb13531527e737445ull,0xd9ae2437689bee09ull,0x761828fc1e4160bcull,
     0xdae6bc729e290dc5ull,0x5198300db64afb06ull,0x0800732342d6d3f1ull,0xa1606c218cf682e4ull,
-#   if _IS_NEED_FAST_ADLER128
     0x1838e333280f674eull,0xf32f3622c8b9929full,0x6faa5847b2a5e48bull,0x9bc9239301e76beaull,
     0x6af6da13021eaf55ull,0xb41a06eb9c2568f1ull,0x2d2b1e3bf2355c05ull,0x23392705f4be24f2ull,
     0x2fa3b21fdfb99b28ull,0x4c63f66993a13011ull,0x461b744d68e5f030ull,0x6b2c411820684fffull,
@@ -130,10 +109,7 @@ static const uint64_t __fast_adler_table[128]={
     0x10d604d7d5acf7d9ull,0x5f1ee02d80e62ec4ull,0x094272f2b03a3adcull,0x7c53663013c68fe6ull,
     0xdfc16f8c66e87e96ull,0x513669ffcc854cbcull,0x7b6e2e4729891f10ull,0x366d835f1e25842eull,
     0xb59420af3feb2f8aull,0xc880ce98aab484c7ull,0xf27daa46241716e1ull,0x167b40b03178b385ull,
-    0xfa1ba16937e78784ull,0x21e6ec6ca0b50cf4ull,0xe984c351976999a1ull,0x84d3c2fbb222e66dull,
-#   endif //_IS_NEED_FAST_ADLER128
-};
-#endif
+    0xfa1ba16937e78784ull,0x21e6ec6ca0b50cf4ull,0xe984c351976999a1ull,0x84d3c2fbb222e66dull };
 /*
 #include <set>
 //gen table better than CRC32Table:{0,0x77073096,..,0x2D02EF8D} or CRC64Table
@@ -179,66 +155,9 @@ static bool _gen_fast_adler_table(){
 }
 static bool _null=_gen_fast_adler_table(10735);
 */
-#if _CPU_IS_LITTLE_ENDIAN
 const uint16_t* _private_fast_adler32_table =(const uint16_t*)&__fast_adler_table[0];
 const uint32_t* _private_fast_adler64_table =(const uint32_t*)&__fast_adler_table[0];
-#else
-static const uint16_t __fast_adler32_table[256] ={
-    0xa199, 0xb5e6, 0x4671, 0xe983, 0x5a7f, 0x8c71, 0xfc22, 0x0914, 0xb5af, 0x62ab, 0xfb39, 0x9d31, 0x0344, 0x69f0, 0xc035, 0xa3d3,
-    0x3b1c, 0x64db, 0x5b72, 0x399a, 0xb01e, 0x959b, 0x6c4f, 0x0c03, 0xbc39, 0x344f, 0x5b77, 0x4dc7, 0x7198, 0x25be, 0x26b3, 0x0ab0,
-    0xd5e6, 0xbab2, 0x281e, 0xe6a1, 0x3df7, 0x0eb1, 0x6d23, 0x5334, 0x7647, 0x4343, 0xede9, 0xb363, 0xa9eb, 0x5783, 0x9be5, 0xdea8,
-    0x1c06, 0x4a2e, 0xe553, 0x7b58, 0x9639, 0xd397, 0xfc95, 0xc1fa, 0x388c, 0xb5ec, 0x4075, 0xb0db, 0xfb3d, 0xc573, 0x0617, 0x4cde,
-    0xee95, 0x4b86, 0xdb52, 0xd77e, 0x40c5, 0x1001, 0xc8e8, 0x6527, 0x01cb, 0x8b8e, 0xfaa9, 0x3bb6, 0x583e, 0x9f77, 0x25ac, 0xd119,
-    0x86f0, 0x8ae9, 0x0e03, 0x5938, 0x560b, 0x3a9b, 0xb601, 0xad9e, 0x648e, 0x0f16, 0xf894, 0x36b3, 0xd3b7, 0xfe25, 0x0768, 0x14a5,
-    0x25fd, 0xaaed, 0x0894, 0x06cd, 0xbac1, 0x667a, 0xa3c9, 0x5833, 0xd5cf, 0x92bf, 0x4e5e, 0xd967, 0xf263, 0x00b7, 0xa10b, 0xa36f,
-    0x8782, 0x1233, 0xedb6, 0xcb11, 0xbc13, 0xca15, 0x177f, 0xd10e, 0xb16c, 0x4c60, 0x53c1, 0x7621, 0x07f3, 0x0592, 0x3213, 0x6f8d,
-    0x8d69, 0xef29, 0xf8b4, 0xdba6, 0x6856, 0x1505, 0x8150, 0x409f, 0x09d6, 0x3b76, 0x0a04, 0xf15a, 0xfcc9, 0x53b2, 0x71be, 0x8ad5,
-    0xcc34, 0xa40d, 0xab04, 0xe127, 0x7d81, 0xdd1a, 0xae6b, 0xfe33, 0x6f52, 0x10e2, 0x1ae1, 0x4579, 0x538c, 0x9208, 0x1840, 0xc528,
-    0xee94, 0x444f, 0x50a1, 0xa7b0, 0x3633, 0x0e05, 0x9ddd, 0xaa15, 0x9a7b, 0xc3c9, 0x8e7a, 0x70e8, 0xc699, 0x40f5, 0xf1ae, 0x5627,
-    0x6685, 0x7c21, 0x0ccc, 0x9055, 0x5b88, 0x5b56, 0x3af3, 0x22ca, 0x8372, 0x3f5c, 0x11ad, 0x856d, 0x378c, 0xd749, 0xfc79, 0x70e5,
-    0x8005, 0x0ad8, 0xa93e, 0x5fbe, 0xcf5e, 0x9119, 0x8f9f, 0xb210, 0xb0e6, 0xd069, 0x096b, 0xd01b, 0xef86, 0x3bbb, 0x92ef, 0x9d2e,
-    0x3b0b, 0x8b0b, 0xa1a8, 0xd853, 0xf1f2, 0x7773, 0x0766, 0x3145, 0xfd47, 0x96ce, 0x1c07, 0x935a, 0x245a, 0xb6f5, 0xb877, 0x4d75,
-    0xae38, 0xc4e0, 0x709d, 0xf291, 0x7395, 0x5d4a, 0x717b, 0xeaf6, 0x13a2, 0x3530, 0x729d, 0x14ab, 0x0099, 0x2056, 0x2776, 0x8d2f,
-    0xccb9, 0x7ce6, 0xd5cd, 0x4832, 0x9fa3, 0xd451, 0x0dd3, 0x0cac, 0xa27d, 0x008b, 0xed98, 0x0360, 0xf7c0, 0x6fb2, 0xb6ad, 0x12f6 };
-static const uint32_t __fast_adler64_table[256] ={
-    0xb5e6a199, 0xe9834671, 0x8c715a7f, 0x0914fc22, 0x62abb5af, 0x9d31fb39, 0x69f00344, 0xa3d3c035,
-    0x64db3b1c, 0x399a5b72, 0x959bb01e, 0x0c036c4f, 0x344fbc39, 0x4dc75b77, 0x25be7198, 0x0ab026b3,
-    0xbab2d5e6, 0xe6a1281e, 0x0eb13df7, 0x53346d23, 0x43437647, 0xb363ede9, 0x5783a9eb, 0xdea89be5,
-    0x4a2e1c06, 0x7b58e553, 0xd3979639, 0xc1fafc95, 0xb5ec388c, 0xb0db4075, 0xc573fb3d, 0x4cde0617,
-    0x4b86ee95, 0xd77edb52, 0x100140c5, 0x6527c8e8, 0x8b8e01cb, 0x3bb6faa9, 0x9f77583e, 0xd11925ac,
-    0x8ae986f0, 0x59380e03, 0x3a9b560b, 0xad9eb601, 0x0f16648e, 0x36b3f894, 0xfe25d3b7, 0x14a50768,
-    0xaaed25fd, 0x06cd0894, 0x667abac1, 0x5833a3c9, 0x92bfd5cf, 0xd9674e5e, 0x00b7f263, 0xa36fa10b,
-    0x12338782, 0xcb11edb6, 0xca15bc13, 0xd10e177f, 0x4c60b16c, 0x762153c1, 0x059207f3, 0x6f8d3213,
-    0xef298d69, 0xdba6f8b4, 0x15056856, 0x409f8150, 0x3b7609d6, 0xf15a0a04, 0x53b2fcc9, 0x8ad571be,
-    0xa40dcc34, 0xe127ab04, 0xdd1a7d81, 0xfe33ae6b, 0x10e26f52, 0x45791ae1, 0x9208538c, 0xc5281840,
-    0x444fee94, 0xa7b050a1, 0x0e053633, 0xaa159ddd, 0xc3c99a7b, 0x70e88e7a, 0x40f5c699, 0x5627f1ae,
-    0x7c216685, 0x90550ccc, 0x5b565b88, 0x22ca3af3, 0x3f5c8372, 0x856d11ad, 0xd749378c, 0x70e5fc79,
-    0x0ad88005, 0x5fbea93e, 0x9119cf5e, 0xb2108f9f, 0xd069b0e6, 0xd01b096b, 0x3bbbef86, 0x9d2e92ef,
-    0x8b0b3b0b, 0xd853a1a8, 0x7773f1f2, 0x31450766, 0x96cefd47, 0x935a1c07, 0xb6f5245a, 0x4d75b877,
-    0xc4e0ae38, 0xf291709d, 0x5d4a7395, 0xeaf6717b, 0x353013a2, 0x14ab729d, 0x20560099, 0x8d2f2776,
-    0x7ce6ccb9, 0x4832d5cd, 0xd4519fa3, 0x0cac0dd3, 0x008ba27d, 0x0360ed98, 0x6fb2f7c0, 0x12f6b6ad,
-    0x694823dd, 0x82441585, 0x2317f193, 0x09aa5ce1, 0x92dffce9, 0x4a06eddb, 0x80095313, 0x95613181,
-    0x3a4b5d4b, 0x2dd5ab17, 0xb4ad20be, 0xd4297df4, 0x881cb3c5, 0x61036b5e, 0x0d271952, 0x5ca6be40,
-    0x1c13ed9a, 0xd1a39288, 0x85d5c7ff, 0x76bd0c57, 0x900595da, 0x8ee9e2bc, 0xadeaeb12, 0x77b940bf,
-    0x6589001c, 0x1e1a09de, 0x4c31dc7f, 0x3bd372be, 0x86af13eb, 0x37279e1b, 0x9329fcc0, 0xb9e4d0d0,
-    0xd0d7f7b6, 0x00800dd5, 0xa9cd017f, 0xd9b49a97, 0xc6b9318c, 0x107a9974, 0x0e3d65c5, 0x1e030a54,
-    0x71a2ae9a, 0x298db8ca, 0xdd7e2ea6, 0x7c7e43c4, 0x41d5b0d5, 0x5f35be61, 0xbc4a4198, 0x33b43e0c,
-    0xa0e21f24, 0xd2cfb061, 0x60963539, 0x8c917984, 0xc86fc710, 0x08f07c80, 0x044d34fb, 0x1287cd98,
-    0xbebea104, 0xa0aeab0b, 0xb775e218, 0xd75dc20e, 0xc79211cb, 0x88cab942, 0x19caa6e3, 0x69a032d1,
-    0x3d9db18b, 0x3658c36c, 0x8deb277c, 0xaa2bd1e8, 0xa6ea28e4, 0xebd02f0c, 0x9de0ccd9, 0x0d6e8665,
-    0xca028b95, 0x68189e89, 0x5b18e944, 0xf4c654ee, 0x03824598, 0x26d7a9ea, 0xbbb5de59, 0xc6b26613,
-    0x88152a10, 0x5abd6d33, 0x8fb51b5c, 0x33a9fe83, 0x8b82720e, 0x4cc28094, 0x6687f674, 0x5442aac8,
-    0x1369f26f, 0x99f94f7d, 0x49dd656e, 0xe3b5bb25, 0xe9d7524a, 0xceab6332, 0xa8d417d5, 0x5e730186,
-    0x3ff82ff0, 0x38cda2e2, 0x9da9e9f2, 0xb1eb6f6f, 0xe2643584, 0xc3fe12ad, 0x6a6621ce, 0x18054b2e,
-    0x880c75bb, 0x55c725b1, 0xd6e226a9, 0x04747a86, 0x3ba442af, 0xde31e4b6, 0x56b265b8, 0x90be6f06,
-    0xd491b721, 0xe6004b58, 0x7e737445, 0xb1353152, 0x689bee09, 0xd9ae2437, 0x1e4160bc, 0x761828fc,
-    0x9e290dc5, 0xdae6bc72, 0xb64afb06, 0x5198300d, 0x42d6d3f1, 0x08007323, 0x8cf682e4, 0xa1606c21 };
-const uint16_t* _private_fast_adler32_table =(const uint16_t*)&__fast_adler32_table[0];
-const uint32_t* _private_fast_adler64_table =(const uint32_t*)&__fast_adler64_table[0];
-#endif
-#if _IS_NEED_FAST_ADLER128
 const uint64_t* _private_fast_adler128_table =(const uint64_t*)&__fast_adler_table[0];
-#endif //_IS_NEED_FAST_ADLER128
 
 #define fast_adler_add1(_table, adler,sum,pdata){ \
     (adler) += _table[(unsigned char)(*pdata++)]; \
@@ -266,7 +185,9 @@ const uint64_t* _private_fast_adler128_table =(const uint64_t*)&__fast_adler_tab
     sum+=a0*2+a1;   \
 }
 
-#define _adler_add4(_c_t,adler,sum,pdata){  \
+#define _adler_add8(_c_t,adler,sum,pdata){  \
+    adler_add2(_c_t,adler,sum,pdata);    \
+    adler_add2(_c_t,adler,sum,pdata);    \
     adler_add2(_c_t,adler,sum,pdata);    \
     adler_add2(_c_t,adler,sum,pdata);    \
 }
@@ -279,48 +200,66 @@ const uint64_t* _private_fast_adler128_table =(const uint64_t*)&__fast_adler_tab
 #define _adler_append(uint_t,half_bit,BASE,mod,border1, adler,pdata,n){ \
     uint_t sum=adler>>half_bit;      \
     adler&=(((uint_t)1<<half_bit)-1);\
+_case8:        \
+    switch(n){ \
+        case  8: { adler_add1(adler,sum,pdata); } \
+        case  7: { adler_add1(adler,sum,pdata); } \
+        case  6: { adler_add1(adler,sum,pdata); } \
+        case  5: { adler_add1(adler,sum,pdata); } \
+        case  4: { adler_add1(adler,sum,pdata); } \
+        case  3: { adler_add1(adler,sum,pdata); } \
+        case  2: { adler_add1(adler,sum,pdata); } \
+        case  1: { adler_add1(adler,sum,pdata); } \
+        case  0: {  sum  =mod(sum,BASE);          \
+                    border1(adler,BASE);          \
+                    return adler | (sum<<half_bit); } \
+        default: { /* continue */ } \
+    } \
     while(n>=kFNBest){  \
         size_t fn;      \
         n-=kFNBest;     \
-        fn=(kFNBest>>2);\
+        fn=(kFNBest>>3);\
         do{ \
-            _adler_add4(uint_t,adler,sum,pdata);\
+            _adler_add8(uint_t,adler,sum,pdata);\
         }while(--fn);   \
         sum  =mod(sum,BASE);   \
         adler=mod(adler,BASE); \
     }       \
-    if (n>=4) {         \
+    if (n>8) {         \
         do{ \
-            _adler_add4(uint_t,adler,sum,pdata);\
-            n-=4;       \
-        } while(n>=4);  \
+            _adler_add8(uint_t,adler,sum,pdata);\
+            n-=8;       \
+        } while(n>=8);  \
         adler=mod(adler,BASE); \
     }       \
-    switch(n){ \
-        case  3: { adler_add1(adler,sum,pdata); } \
-        case  2: { adler_add1(adler,sum,pdata); } \
-        case  1: { adler_add1(adler,sum,pdata); } \
-        default: {  sum  =mod(sum,BASE);          \
-                    border1(adler,BASE);          \
-                    return adler | (sum<<half_bit); } \
-    } \
+    goto _case8; \
 }
 
 
 #define _fast_adler_append(SUM,ADLER,return_SUMADLER,_c_t,_table, _adler,pdata,n){ \
     _c_t sum  =(_c_t)SUM(_adler);   \
     _c_t adler=(_c_t)ADLER(_adler); \
-    while(n>=4){ \
-        fast_adler_add2(_c_t,_table,adler,sum,pdata); \
-        fast_adler_add2(_c_t,_table,adler,sum,pdata); \
-        n-=4;      \
-    }   \
+_case8:  \
     switch(n){ \
+        case  8: { fast_adler_add1(_table,adler,sum,pdata); } \
+        case  7: { fast_adler_add1(_table,adler,sum,pdata); } \
+        case  6: { fast_adler_add1(_table,adler,sum,pdata); } \
+        case  5: { fast_adler_add1(_table,adler,sum,pdata); } \
+        case  4: { fast_adler_add1(_table,adler,sum,pdata); } \
         case  3: { fast_adler_add1(_table,adler,sum,pdata); } \
         case  2: { fast_adler_add1(_table,adler,sum,pdata); } \
         case  1: { fast_adler_add1(_table,adler,sum,pdata); } \
-        default: {  return_SUMADLER(sum,adler); }             \
+        case  0: {  return_SUMADLER(sum,adler); }             \
+        default:{ /* continue */} \
     }   \
+    do{ \
+        fast_adler_add2(_c_t,_table,adler,sum,pdata); \
+        fast_adler_add2(_c_t,_table,adler,sum,pdata); \
+        fast_adler_add2(_c_t,_table,adler,sum,pdata); \
+        fast_adler_add2(_c_t,_table,adler,sum,pdata); \
+        n-=8;      \
+    } while(n>=8); \
+    goto _case8;   \
 }
 
 #define  _adler_roll(uint_t,half_bit,BASE,mod,border2,kBestBlockSize,\
@@ -339,8 +278,8 @@ const uint64_t* _private_fast_adler128_table =(const uint64_t*)&__fast_adler_tab
 
 #define  _adler_by_combine(uint_t,half_bit,BASE,mod,border2,border3,   \
                            adler_left,adler_right,len_right){ \
-    const uint_t kMask=(((uint_t)1)<<half_bit)-1;   \
-    const uint_t rem= (uint_t)mod(len_right,BASE);  \
+    const uint_t kMask=((uint_t)1<<half_bit)-1; \
+    uint_t rem= mod(len_right,BASE);  \
     uint_t adler= adler_left&kMask;   \
     uint_t sum  = rem * adler;        \
     adler+= (adler_right&kMask)       \
@@ -378,7 +317,7 @@ uint32_t adler32_append(uint32_t adler,const adler_data_t* pdata,size_t n)
 uint32_t adler32_roll(uint32_t adler,size_t blockSize,adler_data_t out_data,adler_data_t in_data)
     _adler_roll(uint32_t,16,_adler32_BASE,_adler_mod,_adler_border2,
                 adler_roll_kBestBlockSize, adler,blockSize, out_data,in_data)
-uint32_t adler32_by_combine(uint32_t adler_left,uint32_t adler_right,uint64_t len_right)
+uint32_t adler32_by_combine(uint32_t adler_left,uint32_t adler_right,size_t len_right)
     _adler_by_combine(uint32_t,16,_adler32_BASE,_adler_mod,_adler_border2,_adler_border3,
                       adler_left,adler_right,len_right)
 
@@ -394,7 +333,7 @@ uint64_t adler64_by_combine(uint64_t adler_left,uint64_t adler_right,uint64_t le
 uint32_t fast_adler32_append(uint32_t _adler,const adler_data_t* pdata,size_t n)
     _fast_adler_append(__private_fast32_SUM,__private_fast32_ADLER,__private_fast32_SUMADLER,
                        uint32_t,_private_fast_adler32_table, _adler,pdata,n)
-uint32_t fast_adler32_by_combine(uint32_t adler_left,uint32_t adler_right,uint64_t len_right)
+uint32_t fast_adler32_by_combine(uint32_t adler_left,uint32_t adler_right,size_t len_right)
     _fast_adler_by_combine(__private_fast32_SUM,__private_fast32_ADLER,__private_fast32_SUMADLER,
                            uint32_t, adler_left,adler_right,len_right)
 
@@ -405,11 +344,9 @@ uint64_t fast_adler64_by_combine(uint64_t adler_left,uint64_t adler_right,uint64
     _fast_adler_by_combine(__private_fast64_SUM,__private_fast64_ADLER,__private_fast64_SUMADLER,
                            uint32_t, adler_left,adler_right,len_right)
 
-#if _IS_NEED_FAST_ADLER128
 adler128_t fast_adler128_append(adler128_t _adler,const adler_data_t* pdata,size_t n)
     _fast_adler_append(__private_fast128_SUM,__private_fast128_ADLER,__private_fast128_SUMADLER,
                        uint64_t, _private_fast_adler128_table, _adler,pdata,n)
 adler128_t fast_adler128_by_combine(adler128_t adler_left,adler128_t adler_right,uint64_t len_right)
     _fast_adler_by_combine(__private_fast128_SUM,__private_fast128_ADLER,__private_fast128_SUMADLER,
                            uint64_t, adler_left,adler_right,len_right)
-#endif //_IS_NEED_FAST_ADLER128

package/harmony/pushy/src/main/cpp/HDiffPatch/libHDiffPatch/HDiff/private_diff/limit_mem_diff/adler_roll.h

@@ -65,11 +65,7 @@ extern "C" {
 #endif
 
 #ifndef ADLER_INITIAL
-#   define ADLER_INITIAL    1 //must 0 or 1
-#endif
-
-#ifndef _IS_NEED_FAST_ADLER128
-#   define _IS_NEED_FAST_ADLER128   0
+#define ADLER_INITIAL 1 //must 0 or 1
 #endif
 
 #define  __private_fast_adler_roll(SUM,ADLER,return_SUMADLER,_c_t,_table,_tb_t, \
@@ -84,13 +80,13 @@ extern "C" {
 #define  adler32_start(pdata,n) adler32_append(ADLER_INITIAL,pdata,n)
 uint32_t adler32_append(uint32_t adler,const adler_data_t* pdata,size_t n);
 uint32_t adler32_roll(uint32_t adler,size_t blockSize,adler_data_t out_data,adler_data_t in_data);
-uint32_t adler32_by_combine(uint32_t adler_left,uint32_t adler_right,uint64_t len_right);
+uint32_t adler32_by_combine(uint32_t adler_left,uint32_t adler_right,size_t len_right);
 
 #define  adler64_start(pdata,n) adler64_append(ADLER_INITIAL,pdata,n)
 uint64_t adler64_append(uint64_t adler,const adler_data_t* pdata,size_t n);
 uint64_t adler64_roll(uint64_t adler,uint64_t blockSize,adler_data_t out_data,adler_data_t in_data);
 uint64_t adler64_by_combine(uint64_t adler_left,uint64_t adler_right,uint64_t len_right);
-
+    
 #define  fast_adler32_start(pdata,n) fast_adler32_append(ADLER_INITIAL,pdata,n)
 uint32_t fast_adler32_append(uint32_t adler,const adler_data_t* pdata,size_t n);
                         extern const uint16_t* _private_fast_adler32_table;
@@ -101,7 +97,7 @@ __adler_inline static
 uint32_t fast_adler32_roll(uint32_t adler,size_t blockSize,adler_data_t out_data,adler_data_t in_data)
     __private_fast_adler_roll(__private_fast32_SUM,__private_fast32_ADLER,__private_fast32_SUMADLER,
                               uint32_t, _private_fast_adler32_table,uint16_t, adler,blockSize,out_data,in_data)
-uint32_t fast_adler32_by_combine(uint32_t adler_left,uint32_t adler_right,uint64_t len_right);
+uint32_t fast_adler32_by_combine(uint32_t adler_left,uint32_t adler_right,size_t len_right);
 
 #define  fast_adler64_start(pdata,n) fast_adler64_append(ADLER_INITIAL,pdata,n)
 uint64_t fast_adler64_append(uint64_t adler,const adler_data_t* pdata,size_t n);
@@ -115,8 +111,6 @@ uint64_t fast_adler64_roll(uint64_t adler,uint64_t blockSize,adler_data_t out_da
                               uint32_t, _private_fast_adler64_table,uint32_t, adler,blockSize,out_data,in_data)
 uint64_t fast_adler64_by_combine(uint64_t adler_left,uint64_t adler_right,uint64_t len_right);
 
-#if _IS_NEED_FAST_ADLER128
-
 typedef struct adler128_t{
     uint64_t adler;
     uint64_t sum;
@@ -135,7 +129,6 @@ adler128_t fast_adler128_roll(adler128_t adler,uint64_t blockSize,adler_data_t o
                               uint64_t, _private_fast_adler128_table,uint64_t, adler,blockSize,out_data,in_data)
 adler128_t fast_adler128_by_combine(adler128_t adler_left,adler128_t adler_right,uint64_t len_right);
 
-#endif //_IS_NEED_FAST_ADLER128
 
 #ifdef __cplusplus
 }