Roll libxml to e905f08123e4a6e7731549e6f09dadff4cab65bd

third_party/libxml/src/timsort.h

 /*
  * taken from https://github.com/swenson/sort
  * Kept as is for the moment to be able to apply upstream patches for that
  * code, currently used only to speed up XPath node sorting, see xpath.c
  */
 
 /*
  * All code in this header, unless otherwise specified, is hereby licensed under the MIT Public License:
 
 Copyright (c) 2010 Christopher Swenson
@@ skipping 305 matching lines @@
 } TEMP_STORAGE_T;
 
 
 static void TIM_SORT_RESIZE(TEMP_STORAGE_T *store, const size_t new_size)
 {
   if (store->alloc < new_size)
   {
     SORT_TYPE *tempstore = (SORT_TYPE *)realloc(store->storage, new_size * sizeof(SORT_TYPE));
     if (tempstore == NULL)
     {
-      fprintf(stderr, "Error allocating temporary storage for tim sort: need %llu bytes", (unsigned long long)(sizeof(SORT_TYPE) * new_size));
+      fprintf(stderr, "Error allocating temporary storage for tim sort: need %lu bytes", (unsigned long) (sizeof(SORT_TYPE) * new_size));
       exit(1);
     }
     store->storage = tempstore;
     store->alloc = new_size;
   }
 }
 
 static void TIM_SORT_MERGE(SORT_TYPE *dst, const TIM_SORT_RUN_T *stack, const int stack_curr, TEMP_STORAGE_T *store)
 {
   const int64_t A = stack[stack_curr - 2].length;
@@ skipping 50 matching lines @@
       else
         dst[k] = dst[j--];
     }
   }
 }
 
 static int TIM_SORT_COLLAPSE(SORT_TYPE *dst, TIM_SORT_RUN_T *stack, int stack_curr, TEMP_STORAGE_T *store, const size_t size)
 {
   while (1) {
     int64_t A, B, C, D;
-    int ABC, BCD, BD, CD;
+    int ABC, BCD, CD;
 
     /* if the stack only has one thing on it, we are done with the collapse */
     if (stack_curr <= 1) {
       break;
     }
 
     /* if this is the last merge, just do it */
     if ((stack_curr == 2) && (stack[0].length + stack[1].length == size)) {
       TIM_SORT_MERGE(dst, stack, stack_curr, store);
       stack[0].length += stack[1].length;
@@ skipping 16 matching lines @@
 
     if (stack_curr >= 4) {
       A = stack[stack_curr - 4].length;
       ABC = (A <= B + C);
     } else {
       ABC = 0;
     }
 
     BCD = (B <= C + D) || ABC;
     CD = (C <= D);
-    BD = (B < D);
 
     /* Both invariants are good */
     if (!BCD && !CD) {
       break;
     }
 
     /* left merge */
     if (BCD && !CD) {
       TIM_SORT_MERGE(dst, stack, stack_curr - 1, store);
       stack[stack_curr - 3].length += stack[stack_curr - 2].length;
@@ skipping 64 matching lines @@
 #undef BINARY_INSERTION_FIND
 #undef BINARY_INSERTION_SORT_START
 #undef BINARY_INSERTION_SORT
 #undef REVERSE_ELEMENTS
 #undef COUNT_RUN
 #undef TIM_SORT
 #undef TIM_SORT_RESIZE
 #undef TIM_SORT_COLLAPSE
 #undef TIM_SORT_RUN_T
 #undef TEMP_STORAGE_T