Use correct type for receivers that best matches its data.

For example, when not passing the data to other CF functions, the length of a C string can be size_t as opposed to CFIndex.

Additionally, where appropriate, I replaced a for loop with memcpy to safely copy data between two variables of different data types.

Author: AZero13

CoreFoundation/Base.subproj/CFSortFunctions.c

@@ -223,9 +223,9 @@ static void __CFSortIndexesNMerge(VALUE_TYPE listp1[], INDEX_TYPE cnt1, VALUE_TY
 /* Merging algorithm based on
     "A New Parallel Sorting Algorithm based on Odd-Even Mergesort", Ezequiel Herruzo, et al
 */
-static void __CFSortIndexesN(VALUE_TYPE listp[], INDEX_TYPE count, int32_t ncores, CMP_RESULT_TYPE (^cmp)(INDEX_TYPE, INDEX_TYPE)) {
+static void __CFSortIndexesN(VALUE_TYPE listp[], INDEX_TYPE count, INDEX_TYPE ncores, CMP_RESULT_TYPE (^cmp)(INDEX_TYPE, INDEX_TYPE)) {
     /* Divide the array up into up to ncores, multiple-of-16-sized, chunks */
-    INDEX_TYPE sz = ((((count + ncores - 1) / ncores) + 15) / 16) * 16;
+    INDEX_TYPE sz = (((count + ncores - 1) / ncores) + 15) & ~15;
     INDEX_TYPE num_sect = (count + sz - 1) / sz;
     INDEX_TYPE last_sect_len = count + sz - sz * num_sect;
 
@@ -260,7 +260,7 @@ static void __CFSortIndexesN(VALUE_TYPE listp[], INDEX_TYPE count, int32_t ncore
                 INDEX_TYPE sect2_len = (sect + 1 + (right ? 1 : 2) == num_sect) ? last_sect_len : sz;
                 __CFSortIndexesNMerge(left_base, sz, right_base, sect2_len, listp + sect * sz + sz, right, cmp);
             });
-        memmove(listp + 0 * sz, tmps[0], sz * sizeof(VALUE_TYPE));
+        memmove(listp, tmps[0], sz * sizeof(VALUE_TYPE));
         if (!(num_sect & 0x1)) {
             memmove(listp + (num_sect - 1) * sz, tmps[num_sect - 1], last_sect_len * sizeof(VALUE_TYPE));
         }
@@ -285,7 +285,7 @@ _CF_SORT_INDEXES_EXPORT void CFSortIndexes(CFIndex *indexBuffer, CFIndex count,
         CRSetCrashLogMessage("Size of array to be sorted is too big");
         HALT;
     }
-    int32_t ncores = 0;
+    CFIndex ncores = 0;
     if (opts & kCFSortConcurrent) {
         ncores = __CFActiveProcessorCount();
         if (count < 160 || ncores < 2) {
@@ -307,7 +307,7 @@ _CF_SORT_INDEXES_EXPORT void CFSortIndexes(CFIndex *indexBuffer, CFIndex count,
     } else {
         /* Specifically hard-coded to 8; the count has to be very large before more chunks and/or cores is worthwhile. */
         dispatch_queue_t q = dispatch_queue_create(__CF_QUEUE_NAME("NSSortIndexes"), DISPATCH_QUEUE_CONCURRENT);
-        CFIndex sz = ((((size_t)count + 15) / 16) * 16) / 8;
+        CFIndex sz = ((count + 15) >> 3) & ~1;
         dispatch_apply(8, DISPATCH_APPLY_AUTO, ^(size_t n) {
                 CFIndex idx = n * sz, lim = __CFMin(idx + sz, count);
                 for (; idx < lim; idx++) indexBuffer[idx] = idx;

CoreFoundation/Base.subproj/CFUUID.c

@@ -198,11 +198,11 @@ CFUUIDRef CFUUIDCreateWithBytes(CFAllocatorRef alloc, uint8_t byte0, uint8_t byt
     return __CFUUIDCreateWithBytesPrimitive(alloc, bytes, false);
 }
 
-static void _intToHexChars(UInt32 in, UniChar *out, int digits) {
-    int shift;
+static void _intToHexChars(UInt32 in, UniChar *out, unsigned int digits) {
+    unsigned int shift;
     UInt32 d;
-
-    while (--digits >= 0) {
+    
+    while (digits--) {
         shift = digits << 2;
         d = 0x0FL & (in >> shift);
         if (d <= 9) {

CoreFoundation/PlugIn.subproj/CFBundle_Binary.c

@@ -110,12 +110,12 @@ static char *_cleanedPathForPath(const char *curName) {
     char *thePath = strdup(curName);
     if (thePath) {
         // We are going to process the buffer replacing all "/./" and "//" with "/"
-        CFIndex srcIndex = 0, dstIndex = 0;
-        CFIndex len = strlen(thePath);
+        size_t srcIndex = 0, dstIndex = 0;
+        size_t len = strlen(thePath);
         for (srcIndex=0; srcIndex<len; srcIndex++) {
             thePath[dstIndex] = thePath[srcIndex];
             dstIndex++;
-            while (srcIndex < len-1 && thePath[srcIndex] == '/' && (thePath[srcIndex+1] == '/' || (thePath[srcIndex+1] == '.' && srcIndex < len-2 && thePath[srcIndex+2] == '/'))) srcIndex += (thePath[srcIndex+1] == '/' ? 1 : 2);
+            while (srcIndex + 1 < len && thePath[srcIndex] == '/' && (thePath[srcIndex+1] == '/' || (thePath[srcIndex+1] == '.' && srcIndex + 2 < len && thePath[srcIndex+2] == '/'))) srcIndex += (thePath[srcIndex+1] == '/' ? 1 : 2);
         }
         thePath[dstIndex] = 0;
     }

CoreFoundation/String.subproj/CFString.c

@@ -1815,16 +1815,17 @@ static Boolean __cStrEqual(const void *ptr1, const void *ptr2) {
 static CFHashCode __cStrHash(const void *ptr) {
     // It doesn't quite matter if we convert to Unicode correctly, as long as we do it consistently    
     const char *cStr = (const char *)ptr;
-    CFIndex len = strlen(cStr);
+    size_t len = strlen(cStr);
     CFHashCode result = 0;
     if (len <= 4) {	// All chars
-        unsigned cnt = len;
-        while (cnt--) result += (result << 8) + *cStr++;
+        for (size_t cnt = len; cnt; cnt--) {
+            result += (result << 8) | *cStr++;
+        }
     } else {		// First and last 2 chars
-        result += (result << 8) + cStr[0];
-        result += (result << 8) + cStr[1];
-        result += (result << 8) + cStr[len-2];
-        result += (result << 8) + cStr[len-1];
+        result += (result << 8) | cStr[0];
+        result += (result << 8) | cStr[1];
+        result += (result << 8) | cStr[len-2];
+        result += (result << 8) | cStr[len-1];
     }
     result += (result << (len & 31));
     return result;    

CoreFoundation/String.subproj/CFStringTransform.c

@@ -83,10 +83,7 @@ __CFStringTransformCreate(CFStringRef identifier, bool reverse) {
     if (known) {
 	UniChar buff[kCFStringTransformStackBufferSize];
 	CFIndex len = strlen(known);
-	CFIndex idx;
-	for (idx = 0; idx < len; idx++) {
-	    buff[idx] = known[idx];
-	}
+	memcpy(buff, known, len);
 	made = utrans_openU((const UChar *)buff, len, reverse?UTRANS_REVERSE:UTRANS_FORWARD, NULL, 0, NULL, &icuStatus);
     } else {
 	CFIndex len = CFStringGetLength(identifier);