mirror of
https://github.com/git/git.git
synced 2024-11-13 20:53:02 +01:00
363d59df1a
Up to now, path-lists were sorted at all times. But sometimes it is much more convenient to build the list and sort it at the end, or sort it not at all. Add path_list_append() and sort_path_list() to allow that. Also, add the unsorted_path_list_has_path() function, to do a linear search. Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de> Signed-off-by: Junio C Hamano <gitster@pobox.com>
134 lines
3 KiB
C
134 lines
3 KiB
C
#include "cache.h"
|
|
#include "path-list.h"
|
|
|
|
/* if there is no exact match, point to the index where the entry could be
|
|
* inserted */
|
|
static int get_entry_index(const struct path_list *list, const char *path,
|
|
int *exact_match)
|
|
{
|
|
int left = -1, right = list->nr;
|
|
|
|
while (left + 1 < right) {
|
|
int middle = (left + right) / 2;
|
|
int compare = strcmp(path, list->items[middle].path);
|
|
if (compare < 0)
|
|
right = middle;
|
|
else if (compare > 0)
|
|
left = middle;
|
|
else {
|
|
*exact_match = 1;
|
|
return middle;
|
|
}
|
|
}
|
|
|
|
*exact_match = 0;
|
|
return right;
|
|
}
|
|
|
|
/* returns -1-index if already exists */
|
|
static int add_entry(struct path_list *list, const char *path)
|
|
{
|
|
int exact_match;
|
|
int index = get_entry_index(list, path, &exact_match);
|
|
|
|
if (exact_match)
|
|
return -1 - index;
|
|
|
|
if (list->nr + 1 >= list->alloc) {
|
|
list->alloc += 32;
|
|
list->items = xrealloc(list->items, list->alloc
|
|
* sizeof(struct path_list_item));
|
|
}
|
|
if (index < list->nr)
|
|
memmove(list->items + index + 1, list->items + index,
|
|
(list->nr - index)
|
|
* sizeof(struct path_list_item));
|
|
list->items[index].path = list->strdup_paths ?
|
|
xstrdup(path) : (char *)path;
|
|
list->items[index].util = NULL;
|
|
list->nr++;
|
|
|
|
return index;
|
|
}
|
|
|
|
struct path_list_item *path_list_insert(const char *path, struct path_list *list)
|
|
{
|
|
int index = add_entry(list, path);
|
|
|
|
if (index < 0)
|
|
index = -1 - index;
|
|
|
|
return list->items + index;
|
|
}
|
|
|
|
int path_list_has_path(const struct path_list *list, const char *path)
|
|
{
|
|
int exact_match;
|
|
get_entry_index(list, path, &exact_match);
|
|
return exact_match;
|
|
}
|
|
|
|
struct path_list_item *path_list_lookup(const char *path, struct path_list *list)
|
|
{
|
|
int exact_match, i = get_entry_index(list, path, &exact_match);
|
|
if (!exact_match)
|
|
return NULL;
|
|
return list->items + i;
|
|
}
|
|
|
|
void path_list_clear(struct path_list *list, int free_util)
|
|
{
|
|
if (list->items) {
|
|
int i;
|
|
if (list->strdup_paths) {
|
|
for (i = 0; i < list->nr; i++)
|
|
free(list->items[i].path);
|
|
}
|
|
if (free_util) {
|
|
for (i = 0; i < list->nr; i++)
|
|
free(list->items[i].util);
|
|
}
|
|
free(list->items);
|
|
}
|
|
list->items = NULL;
|
|
list->nr = list->alloc = 0;
|
|
}
|
|
|
|
void print_path_list(const char *text, const struct path_list *p)
|
|
{
|
|
int i;
|
|
if ( text )
|
|
printf("%s\n", text);
|
|
for (i = 0; i < p->nr; i++)
|
|
printf("%s:%p\n", p->items[i].path, p->items[i].util);
|
|
}
|
|
|
|
struct path_list_item *path_list_append(const char *path, struct path_list *list)
|
|
{
|
|
ALLOC_GROW(list->items, list->nr + 1, list->alloc);
|
|
list->items[list->nr].path =
|
|
list->strdup_paths ? xstrdup(path) : (char *)path;
|
|
return list->items + list->nr++;
|
|
}
|
|
|
|
static int cmp_items(const void *a, const void *b)
|
|
{
|
|
const struct path_list_item *one = a;
|
|
const struct path_list_item *two = b;
|
|
return strcmp(one->path, two->path);
|
|
}
|
|
|
|
void sort_path_list(struct path_list *list)
|
|
{
|
|
qsort(list->items, list->nr, sizeof(*list->items), cmp_items);
|
|
}
|
|
|
|
int unsorted_path_list_has_path(struct path_list *list, const char *path)
|
|
{
|
|
int i;
|
|
for (i = 0; i < list->nr; i++)
|
|
if (!strcmp(path, list->items[i].path))
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|