comparison: src/list.c
src/list.c
- changeset 1422
- 8bfccb342895
- parent 1419
- e46406fd1b3c
- child 1423
- 9a72258446cd
equal
deleted
inserted
replaced
| 1421:809eb30cd621 | 1422:8bfccb342895 |
|---|---|
| 36 | 36 |
| 37 static int cx_pl_cmpfunc( | 37 static int cx_pl_cmpfunc( |
| 38 const void *l, | 38 const void *l, |
| 39 const void *r | 39 const void *r |
| 40 ) { | 40 ) { |
| 41 // l and r are guaranteed to be non-NULL pointing to the list's memory | |
| 41 void *const *lptr = l; | 42 void *const *lptr = l; |
| 42 void *const *rptr = r; | 43 void *const *rptr = r; |
| 43 const void *left = lptr == NULL ? NULL : *lptr; | 44 const void *left = *lptr; |
| 44 const void *right = rptr == NULL ? NULL : *rptr; | 45 const void *right = *rptr; |
| 46 if (left == NULL) { | |
| 47 // NULL is smaller than any value except NULL | |
| 48 return right == NULL ? 0 : -1; | |
| 49 } else if (right == NULL) { | |
| 50 // any value is larger than NULL | |
| 51 return 1; | |
| 52 } | |
| 45 return cx_pl_cmpfunc_impl(left, right); | 53 return cx_pl_cmpfunc_impl(left, right); |
| 46 } | 54 } |
| 47 | 55 |
| 48 static void cx_pl_hack_cmpfunc(const struct cx_list_s *list) { | 56 static void cx_pl_hack_cmpfunc(const struct cx_list_s *list) { |
| 49 // cast away const - this is the hacky thing | 57 // cast away const - this is the hacky thing |
| 295 const char *src = data; | 303 const char *src = data; |
| 296 size_t i = 0; | 304 size_t i = 0; |
| 297 for (; i < n; i++) { | 305 for (; i < n; i++) { |
| 298 if (NULL == invoke_list_func( | 306 if (NULL == invoke_list_func( |
| 299 insert_element, list, index + i, | 307 insert_element, list, index + i, |
| 300 src + (i * elem_size))) return i; | 308 src + i * elem_size) |
| 309 ) { | |
| 310 return i; // LCOV_EXCL_LINE | |
| 311 } | |
| 301 } | 312 } |
| 302 return i; | 313 return i; |
| 303 } | 314 } |
| 304 | 315 |
| 305 static size_t cx_list_default_insert_sorted_impl( | 316 static size_t cx_list_default_insert_sorted_impl( |
| 334 while (si < n && cmp(list_elm, src) == 0) { | 345 while (si < n && cmp(list_elm, src) == 0) { |
| 335 src += elem_size; | 346 src += elem_size; |
| 336 si++; | 347 si++; |
| 337 inserted++; | 348 inserted++; |
| 338 } | 349 } |
| 339 if (inserted == n) return inserted; | 350 if (inserted == n) { |
| 351 return inserted; | |
| 352 } | |
| 340 } | 353 } |
| 341 continue; | 354 continue; |
| 342 } | 355 } |
| 343 } | 356 } |
| 344 | 357 |
| 355 ins++; | 368 ins++; |
| 356 } | 369 } |
| 357 | 370 |
| 358 // insert the elements at location si | 371 // insert the elements at location si |
| 359 if (ins == 1) { | 372 if (ins == 1) { |
| 360 if (NULL == invoke_list_func( | 373 if (NULL == invoke_list_func(insert_element, list, di, src)) { |
| 361 insert_element, list, di, src)) return inserted; | 374 return inserted; // LCOV_EXCL_LINE |
| 375 } | |
| 362 } else { | 376 } else { |
| 363 size_t r = invoke_list_func(insert_array, list, di, src, ins); | 377 size_t r = invoke_list_func(insert_array, list, di, src, ins); |
| 364 if (r < ins) return inserted + r; | 378 if (r < ins) { |
| 379 return inserted + r; // LCOV_EXCL_LINE | |
| 380 } | |
| 365 } | 381 } |
| 366 inserted += ins; | 382 inserted += ins; |
| 367 di += ins; | 383 di += ins; |
| 368 | 384 |
| 369 // everything inserted? | 385 // everything inserted? |
| 370 if (inserted == n) return inserted; | 386 if (inserted == n) { |
| 387 return inserted; | |
| 388 } | |
| 371 src = next; | 389 src = next; |
| 372 } | 390 } |
| 373 | 391 |
| 374 // insert remaining items | 392 // insert remaining items |
| 375 if (si < n) { | 393 if (si < n) { |
| 397 | 415 |
| 398 void cx_list_default_sort(struct cx_list_s *list) { | 416 void cx_list_default_sort(struct cx_list_s *list) { |
| 399 size_t elem_size = list->collection.elem_size; | 417 size_t elem_size = list->collection.elem_size; |
| 400 size_t list_size = list->collection.size; | 418 size_t list_size = list->collection.size; |
| 401 void *tmp = cxMallocDefault(elem_size * list_size); | 419 void *tmp = cxMallocDefault(elem_size * list_size); |
| 402 if (tmp == NULL) abort(); | 420 if (tmp == NULL) abort(); // LCOV_EXCL_LINE |
| 403 | 421 |
| 404 // copy elements from source array | 422 // copy elements from source array |
| 405 char *loc = tmp; | 423 char *loc = tmp; |
| 406 for (size_t i = 0; i < list_size; i++) { | 424 for (size_t i = 0; i < list_size; i++) { |
| 407 void *src = invoke_list_func(at, list, i); | 425 void *src = invoke_list_func(at, list, i); |
| 430 if (j >= list->collection.size) return 1; | 448 if (j >= list->collection.size) return 1; |
| 431 | 449 |
| 432 size_t elem_size = list->collection.elem_size; | 450 size_t elem_size = list->collection.elem_size; |
| 433 | 451 |
| 434 void *tmp = cxMallocDefault(elem_size); | 452 void *tmp = cxMallocDefault(elem_size); |
| 435 if (tmp == NULL) return 1; | 453 if (tmp == NULL) return 1; // LCOV_EXCL_LINE |
| 436 | 454 |
| 437 void *ip = invoke_list_func(at, list, i); | 455 void *ip = invoke_list_func(at, list, i); |
| 438 void *jp = invoke_list_func(at, list, j); | 456 void *jp = invoke_list_func(at, list, j); |
| 439 | 457 |
| 440 memcpy(tmp, ip, elem_size); | 458 memcpy(tmp, ip, elem_size); |
