![[tokkee]](http://tokkee.org/images/avatar.png){kind=avatar}
summary | shortlog | log | commit | commitdiff | tree
raw | patch | inline | side by side (parent: 51ef1da)
raw | patch | inline | side by side (parent: 51ef1da)
| author | Johannes Schindelin <Johannes.Schindelin@gmx.de> | |
| Mon, 21 Jul 2008 18:03:49 +0000 (19:03 +0100) | ||
| committer | Junio C Hamano <gitster@pobox.com> | |
| Tue, 22 Jul 2008 02:11:50 +0000 (19:11 -0700) |
The name path_list was correct for the first usage of that data structure,
but it really is a general-purpose string list.
$ perl -i -pe 's/path-list/string-list/g' $(git grep -l path-list)
$ perl -i -pe 's/path_list/string_list/g' $(git grep -l path_list)
$ git mv path-list.h string-list.h
$ git mv path-list.c string-list.c
$ perl -i -pe 's/has_path/has_string/g' $(git grep -l has_path)
$ perl -i -pe 's/path/string/g' string-list.[ch]
$ git mv Documentation/technical/api-path-list.txt \
Documentation/technical/api-string-list.txt
$ perl -i -pe 's/strdup_paths/strdup_strings/g' $(git grep -l strdup_paths)
... and then fix all users of string-list to access the member "string"
instead of "path".
Documentation/technical/api-string-list.txt needed some rewrapping, too.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
but it really is a general-purpose string list.
$ perl -i -pe 's/path-list/string-list/g' $(git grep -l path-list)
$ perl -i -pe 's/path_list/string_list/g' $(git grep -l path_list)
$ git mv path-list.h string-list.h
$ git mv path-list.c string-list.c
$ perl -i -pe 's/has_path/has_string/g' $(git grep -l has_path)
$ perl -i -pe 's/path/string/g' string-list.[ch]
$ git mv Documentation/technical/api-path-list.txt \
Documentation/technical/api-string-list.txt
$ perl -i -pe 's/strdup_paths/strdup_strings/g' $(git grep -l strdup_paths)
... and then fix all users of string-list to access the member "string"
instead of "path".
Documentation/technical/api-string-list.txt needed some rewrapping, too.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
28 files changed:
index d2a0a76e6cfb275080f3b66309591888f5302850..f628c1f3b7b706f9d585b96041e5a4b12bc0f62c 100644 (file)
- Use the API. No, really. We have a strbuf (variable length
string), several arrays with the ALLOC_GROW() macro, a
- path_list for sorted string lists, a hash map (mapping struct
+ string_list for sorted string lists, a hash map (mapping struct
objects) named "struct decorate", amongst other things.
- When you come up with an API, document it.
diff --git a/Documentation/technical/api-path-list.txt b/Documentation/technical/api-path-list.txt
+++ /dev/null
@@ -1,126 +0,0 @@
-path-list API
-=============
-
-The path_list API offers a data structure and functions to handle sorted
-and unsorted string lists.
-
-The name is a bit misleading, a path_list may store not only paths but
-strings in general.
-
-The caller:
-
-. Allocates and clears a `struct path_list` variable.
-
-. Initializes the members. You might want to set the flag `strdup_paths`
- if the strings should be strdup()ed. For example, this is necessary
- when you add something like git_path("..."), since that function returns
- a static buffer that will change with the next call to git_path().
-+
-If you need something advanced, you can manually malloc() the `items`
-member (you need this if you add things later) and you should set the
-`nr` and `alloc` members in that case, too.
-
-. Adds new items to the list, using `path_list_append` or `path_list_insert`.
-
-. Can check if a string is in the list using `path_list_has_path` or
- `unsorted_path_list_has_path` and get it from the list using
- `path_list_lookup` for sorted lists.
-
-. Can sort an unsorted list using `sort_path_list`.
-
-. Finally it should free the list using `path_list_clear`.
-
-Example:
-
-----
-struct path_list list;
-int i;
-
-memset(&list, 0, sizeof(struct path_list));
-path_list_append("foo", &list);
-path_list_append("bar", &list);
-for (i = 0; i < list.nr; i++)
- printf("%s\n", list.items[i].path)
-----
-
-NOTE: It is more efficient to build an unsorted list and sort it
-afterwards, instead of building a sorted list (`O(n log n)` instead of
-`O(n^2)`).
-+
-However, if you use the list to check if a certain string was added
-already, you should not do that (using unsorted_path_list_has_path()),
-because the complexity would be quadratic again (but with a worse factor).
-
-Functions
----------
-
-* General ones (works with sorted and unsorted lists as well)
-
-`print_path_list`::
-
- Dump a path_list to stdout, useful mainly for debugging purposes. It
- can take an optional header argument and it writes out the
- string-pointer pairs of the path_list, each one in its own line.
-
-`path_list_clear`::
-
- Free a path_list. The `path` pointer of the items will be freed in case
- the `strdup_paths` member of the path_list is set. The second parameter
- controls if the `util` pointer of the items should be freed or not.
-
-* Functions for sorted lists only
-
-`path_list_has_path`::
-
- Determine if the path_list has a given string or not.
-
-`path_list_insert`::
-
- Insert a new element to the path_list. The returned pointer can be handy
- if you want to write something to the `util` pointer of the
- path_list_item containing the just added string.
-+
-Since this function uses xrealloc() (which die()s if it fails) if the
-list needs to grow, it is safe not to check the pointer. I.e. you may
-write `path_list_insert(...)->util = ...;`.
-
-`path_list_lookup`::
-
- Look up a given string in the path_list, returning the containing
- path_list_item. If the string is not found, NULL is returned.
-
-* Functions for unsorted lists only
-
-`path_list_append`::
-
- Append a new string to the end of the path_list.
-
-`sort_path_list`::
-
- Make an unsorted list sorted.
-
-`unsorted_path_list_has_path`::
-
- It's like `path_list_has_path()` but for unsorted lists.
-+
-This function needs to look through all items, as opposed to its
-counterpart for sorted lists, which performs a binary search.
-
-Data structures
----------------
-
-* `struct path_list_item`
-
-Represents an item of the list. The `path` member is a pointer to the
-string, and you may use the `util` member for any purpose, if you want.
-
-* `struct path_list`
-
-Represents the list itself.
-
-. The array of items are available via the `items` member.
-. The `nr` member contains the number of items stored in the list.
-. The `alloc` member is used to avoid reallocating at every insertion.
- You should not tamper with it.
-. Setting the `strdup_paths` member to 1 will strdup() the strings
- before adding them, see above.
diff --git a/Documentation/technical/api-string-list.txt b/Documentation/technical/api-string-list.txt
--- /dev/null
@@ -0,0 +1,128 @@
+string-list API
+===============
+
+The string_list API offers a data structure and functions to handle sorted
+and unsorted string lists.
+
+The 'string_list' struct used to be called 'path_list', but was renamed
+because it is not specific to paths.
+
+The caller:
+
+. Allocates and clears a `struct string_list` variable.
+
+. Initializes the members. You might want to set the flag `strdup_strings`
+ if the strings should be strdup()ed. For example, this is necessary
+ when you add something like git_path("..."), since that function returns
+ a static buffer that will change with the next call to git_path().
++
+If you need something advanced, you can manually malloc() the `items`
+member (you need this if you add things later) and you should set the
+`nr` and `alloc` members in that case, too.
+
+. Adds new items to the list, using `string_list_append` or
+ `string_list_insert`.
+
+. Can check if a string is in the list using `string_list_has_string` or
+ `unsorted_string_list_has_string` and get it from the list using
+ `string_list_lookup` for sorted lists.
+
+. Can sort an unsorted list using `sort_string_list`.
+
+. Finally it should free the list using `string_list_clear`.
+
+Example:
+
+----
+struct string_list list;
+int i;
+
+memset(&list, 0, sizeof(struct string_list));
+string_list_append("foo", &list);
+string_list_append("bar", &list);
+for (i = 0; i < list.nr; i++)
+ printf("%s\n", list.items[i].path)
+----
+
+NOTE: It is more efficient to build an unsorted list and sort it
+afterwards, instead of building a sorted list (`O(n log n)` instead of
+`O(n^2)`).
++
+However, if you use the list to check if a certain string was added
+already, you should not do that (using unsorted_string_list_has_string()),
+because the complexity would be quadratic again (but with a worse factor).
+
+Functions
+---------
+
+* General ones (works with sorted and unsorted lists as well)
+
+`print_string_list`::
+
+ Dump a string_list to stdout, useful mainly for debugging purposes. It
+ can take an optional header argument and it writes out the
+ string-pointer pairs of the string_list, each one in its own line.
+
+`string_list_clear`::
+
+ Free a string_list. The `string` pointer of the items will be freed in
+ case the `strdup_strings` member of the string_list is set. The second
+ parameter controls if the `util` pointer of the items should be freed
+ or not.
+
+* Functions for sorted lists only
+
+`string_list_has_string`::
+
+ Determine if the string_list has a given string or not.
+
+`string_list_insert`::
+
+ Insert a new element to the string_list. The returned pointer can be
+ handy if you want to write something to the `util` pointer of the
+ string_list_item containing the just added string.
++
+Since this function uses xrealloc() (which die()s if it fails) if the
+list needs to grow, it is safe not to check the pointer. I.e. you may
+write `string_list_insert(...)->util = ...;`.
+
+`string_list_lookup`::
+
+ Look up a given string in the string_list, returning the containing
+ string_list_item. If the string is not found, NULL is returned.
+
+* Functions for unsorted lists only
+
+`string_list_append`::
+
+ Append a new string to the end of the string_list.
+
+`sort_string_list`::
+
+ Make an unsorted list sorted.
+
+`unsorted_string_list_has_string`::
+
+ It's like `string_list_has_string()` but for unsorted lists.
++
+This function needs to look through all items, as opposed to its
+counterpart for sorted lists, which performs a binary search.
+
+Data structures
+---------------
+
+* `struct string_list_item`
+
+Represents an item of the list. The `path` member is a pointer to the
+string, and you may use the `util` member for any purpose, if you want.
+
+* `struct string_list`
+
+Represents the list itself.
+
+. The array of items are available via the `items` member.
+. The `nr` member contains the number of items stored in the list.
+. The `alloc` member is used to avoid reallocating at every insertion.
+ You should not tamper with it.
+. Setting the `strdup_strings` member to 1 will strdup() the strings
+ before adding them, see above.
diff --git a/Makefile b/Makefile
index 551bde9ff0745e5da0bc6cfa3ab3cb915c73b298..b01cf1c9938399e9a7178a8543530ea34bb48b14 100644 (file)
--- a/Makefile
+++ b/Makefile
LIB_H += pack-revindex.h
LIB_H += parse-options.h
LIB_H += patch-ids.h
-LIB_H += path-list.h
+LIB_H += string-list.h
LIB_H += pkt-line.h
LIB_H += progress.h
LIB_H += quote.h
LIB_OBJS += parse-options.o
LIB_OBJS += patch-delta.o
LIB_OBJS += patch-ids.o
-LIB_OBJS += path-list.o
+LIB_OBJS += string-list.o
LIB_OBJS += path.o
LIB_OBJS += pkt-line.o
LIB_OBJS += pretty.o
diff --git a/builtin-apply.c b/builtin-apply.c
index e15471b5b6d13eaffa6108535c067b5002a2b0c0..2216a0bf7cd53adc31346f66a3b9786a1d688bad 100644 (file)
--- a/builtin-apply.c
+++ b/builtin-apply.c
#include "blob.h"
#include "delta.h"
#include "builtin.h"
-#include "path-list.h"
+#include "string-list.h"
/*
* --check turns on checking that the working tree matches the
* the case where more than one patches touch the same file.
*/
-static struct path_list fn_table;
+static struct string_list fn_table;
static uint32_t hash_line(const char *cp, size_t len)
{
static struct patch *in_fn_table(const char *name)
{
- struct path_list_item *item;
+ struct string_list_item *item;
if (name == NULL)
return NULL;
- item = path_list_lookup(name, &fn_table);
+ item = string_list_lookup(name, &fn_table);
if (item != NULL)
return (struct patch *)item->util;
static void add_to_fn_table(struct patch *patch)
{
- struct path_list_item *item;
+ struct string_list_item *item;
/*
* Always add new_name unless patch is a deletion
* file creations and copies
*/
if (patch->new_name != NULL) {
- item = path_list_insert(patch->new_name, &fn_table);
+ item = string_list_insert(patch->new_name, &fn_table);
item->util = patch;
}
* later chunks shouldn't patch old names
*/
if ((patch->new_name == NULL) || (patch->is_rename)) {
- item = path_list_insert(patch->old_name, &fn_table);
+ item = string_list_insert(patch->old_name, &fn_table);
item->util = (struct patch *) -1;
}
}
int skipped_patch = 0;
/* FIXME - memory leak when using multiple patch files as inputs */
- memset(&fn_table, 0, sizeof(struct path_list));
+ memset(&fn_table, 0, sizeof(struct string_list));
strbuf_init(&buf, 0);
patch_input_file = filename;
read_patch_file(&buf, fd);
diff --git a/builtin-blame.c b/builtin-blame.c
index 9bced3b2626eb72ccb4b8756b47163db4c026540..8b6b09b10b8f9dcda0b7224f31c860bb803945f0 100644 (file)
--- a/builtin-blame.c
+++ b/builtin-blame.c
#include "quote.h"
#include "xdiff-interface.h"
#include "cache-tree.h"
-#include "path-list.h"
+#include "string-list.h"
#include "mailmap.h"
#include "parse-options.h"
static int incremental;
static int cmd_is_annotate;
static int xdl_opts = XDF_NEED_MINIMAL;
-static struct path_list mailmap;
+static struct string_list mailmap;
#ifndef DEBUG
#define DEBUG 0
* Used for the command line parsing; check if the path exists
* in the working tree.
*/
-static int has_path_in_work_tree(const char *path)
+static int has_string_in_work_tree(const char *path)
{
struct stat st;
return !lstat(path, &st);
if (argc < 2)
usage_with_options(blame_opt_usage, options);
path = add_prefix(prefix, argv[argc - 1]);
- if (argc == 3 && !has_path_in_work_tree(path)) { /* (2b) */
+ if (argc == 3 && !has_string_in_work_tree(path)) { /* (2b) */
path = add_prefix(prefix, argv[1]);
argv[1] = argv[2];
}
argv[argc - 1] = "--";
setup_work_tree();
- if (!has_path_in_work_tree(path))
+ if (!has_string_in_work_tree(path))
die("cannot stat path %s: %s", path, strerror(errno));
}
diff --git a/builtin-commit.c b/builtin-commit.c
index ed3fe3f7ee033e09f87c0a86dc7db70b13c6a262..97e64de31228c254f0fe073494dd1f823070bf8e 100644 (file)
--- a/builtin-commit.c
+++ b/builtin-commit.c
#include "strbuf.h"
#include "utf8.h"
#include "parse-options.h"
-#include "path-list.h"
+#include "string-list.h"
#include "rerere.h"
#include "unpack-trees.h"
* Take a union of paths in the index and the named tree (typically, "HEAD"),
* and return the paths that match the given pattern in list.
*/
-static int list_paths(struct path_list *list, const char *with_tree,
+static int list_paths(struct string_list *list, const char *with_tree,
const char *prefix, const char **pattern)
{
int i;
continue;
if (!pathspec_match(pattern, m, ce->name, 0))
continue;
- path_list_insert(ce->name, list);
+ string_list_insert(ce->name, list);
}
return report_path_error(m, pattern, prefix ? strlen(prefix) : 0);
}
-static void add_remove_files(struct path_list *list)
+static void add_remove_files(struct string_list *list)
{
int i;
for (i = 0; i < list->nr; i++) {
struct stat st;
- struct path_list_item *p = &(list->items[i]);
+ struct string_list_item *p = &(list->items[i]);
- if (!lstat(p->path, &st)) {
- if (add_to_cache(p->path, &st, 0))
+ if (!lstat(p->string, &st)) {
+ if (add_to_cache(p->string, &st, 0))
die("updating files failed");
} else
- remove_file_from_cache(p->path);
+ remove_file_from_cache(p->string);
}
}
static char *prepare_index(int argc, const char **argv, const char *prefix)
{
int fd;
- struct path_list partial;
+ struct string_list partial;
const char **pathspec = NULL;
if (interactive) {
die("cannot do a partial commit during a merge.");
memset(&partial, 0, sizeof(partial));
- partial.strdup_paths = 1;
+ partial.strdup_strings = 1;
if (list_paths(&partial, initial_commit ? NULL : "HEAD", prefix, pathspec))
exit(1);
diff --git a/builtin-fast-export.c b/builtin-fast-export.c
index a443d594602b3b80964763d3105aaa2480780a87..e508ced6ba13954580632da50d789f221a132224 100644 (file)
--- a/builtin-fast-export.c
+++ b/builtin-fast-export.c
#include "log-tree.h"
#include "revision.h"
#include "decorate.h"
-#include "path-list.h"
+#include "string-list.h"
#include "utf8.h"
#include "parse-options.h"
}
static void get_tags_and_duplicates(struct object_array *pending,
- struct path_list *extra_refs)
+ struct string_list *extra_refs)
{
struct tag *tag;
int i;
case OBJ_TAG:
tag = (struct tag *)e->item;
while (tag && tag->object.type == OBJ_TAG) {
- path_list_insert(full_name, extra_refs)->util = tag;
+ string_list_insert(full_name, extra_refs)->util = tag;
tag = (struct tag *)tag->tagged;
}
if (!tag)
}
if (commit->util)
/* more than one name for the same object */
- path_list_insert(full_name, extra_refs)->util = commit;
+ string_list_insert(full_name, extra_refs)->util = commit;
else
commit->util = full_name;
}
}
-static void handle_tags_and_duplicates(struct path_list *extra_refs)
+static void handle_tags_and_duplicates(struct string_list *extra_refs)
{
struct commit *commit;
int i;
for (i = extra_refs->nr - 1; i >= 0; i--) {
- const char *name = extra_refs->items[i].path;
+ const char *name = extra_refs->items[i].string;
struct object *object = extra_refs->items[i].util;
switch (object->type) {
case OBJ_TAG:
{
struct rev_info revs;
struct object_array commits = { 0, 0, NULL };
- struct path_list extra_refs = { NULL, 0, 0, 0 };
+ struct string_list extra_refs = { NULL, 0, 0, 0 };
struct commit *commit;
char *export_filename = NULL, *import_filename = NULL;
struct option options[] = {
diff --git a/builtin-fetch.c b/builtin-fetch.c
index 61de50a020ace25e110ed1b2fc5d21286bd885d7..7eec4a0e43ad5760f1060a7d5bcf2a5083015130 100644 (file)
--- a/builtin-fetch.c
+++ b/builtin-fetch.c
#include "refs.h"
#include "commit.h"
#include "builtin.h"
-#include "path-list.h"
+#include "string-list.h"
#include "remote.h"
#include "transport.h"
#include "run-command.h"
static int add_existing(const char *refname, const unsigned char *sha1,
int flag, void *cbdata)
{
- struct path_list *list = (struct path_list *)cbdata;
- path_list_insert(refname, list);
+ struct string_list *list = (struct string_list *)cbdata;
+ string_list_insert(refname, list);
return 0;
}
struct ref **head,
struct ref ***tail)
{
- struct path_list existing_refs = { NULL, 0, 0, 0 };
- struct path_list new_refs = { NULL, 0, 0, 1 };
+ struct string_list existing_refs = { NULL, 0, 0, 0 };
+ struct string_list new_refs = { NULL, 0, 0, 1 };
char *ref_name;
int ref_name_len;
const unsigned char *ref_sha1;
}
}
- if (!path_list_has_path(&existing_refs, ref_name) &&
- !path_list_has_path(&new_refs, ref_name) &&
+ if (!string_list_has_string(&existing_refs, ref_name) &&
+ !string_list_has_string(&new_refs, ref_name) &&
(has_sha1_file(ref->old_sha1) ||
will_fetch(head, ref->old_sha1))) {
- path_list_insert(ref_name, &new_refs);
+ string_list_insert(ref_name, &new_refs);
rm = alloc_ref_from_str(ref_name);
rm->peer_ref = alloc_ref_from_str(ref_name);
}
free(ref_name);
}
- path_list_clear(&existing_refs, 0);
- path_list_clear(&new_refs, 0);
+ string_list_clear(&existing_refs, 0);
+ string_list_clear(&new_refs, 0);
}
static int do_fetch(struct transport *transport,
diff --git a/builtin-mailsplit.c b/builtin-mailsplit.c
index 13c60c39a402834fbcdb58928c5b5686b7b05a51..71f3b3b8741e505fc652e6c74c75972f19211f71 100644 (file)
--- a/builtin-mailsplit.c
+++ b/builtin-mailsplit.c
*/
#include "cache.h"
#include "builtin.h"
-#include "path-list.h"
+#include "string-list.h"
static const char git_mailsplit_usage[] =
"git mailsplit [-d<prec>] [-f<n>] [-b] -o<directory> [<mbox>|<Maildir>...]";
exit(1);
}
-static int populate_maildir_list(struct path_list *list, const char *path)
+static int populate_maildir_list(struct string_list *list, const char *path)
{
DIR *dir;
struct dirent *dent;
if (dent->d_name[0] == '.')
continue;
snprintf(name, sizeof(name), "%s/%s", *sub, dent->d_name);
- path_list_insert(name, list);
+ string_list_insert(name, list);
}
closedir(dir);
char name[PATH_MAX];
int ret = -1;
int i;
- struct path_list list = {NULL, 0, 0, 1};
+ struct string_list list = {NULL, 0, 0, 1};
if (populate_maildir_list(&list, maildir) < 0)
goto out;
for (i = 0; i < list.nr; i++) {
FILE *f;
- snprintf(file, sizeof(file), "%s/%s", maildir, list.items[i].path);
+ snprintf(file, sizeof(file), "%s/%s", maildir, list.items[i].string);
f = fopen(file, "r");
if (!f) {
error("cannot open mail %s (%s)", file, strerror(errno));
ret = skip;
out:
- path_list_clear(&list, 1);
+ string_list_clear(&list, 1);
return ret;
}
index 652a2c32bb0913108e0435de86392764da3ad611..43e55bf90154c51b94527b2ab7eb7c60fe36e9ec 100644 (file)
#include "diffcore.h"
#include "tag.h"
#include "unpack-trees.h"
-#include "path-list.h"
+#include "string-list.h"
#include "xdiff-interface.h"
#include "ll-merge.h"
#include "interpolate.h"
unsigned processed:1;
};
-static struct path_list current_file_set = {NULL, 0, 0, 1};
-static struct path_list current_directory_set = {NULL, 0, 0, 1};
+static struct string_list current_file_set = {NULL, 0, 0, 1};
+static struct string_list current_directory_set = {NULL, 0, 0, 1};
static int call_depth = 0;
static int verbosity = 2;
newpath[baselen + len] = '\0';
if (S_ISDIR(mode))
- path_list_insert(newpath, ¤t_directory_set);
+ string_list_insert(newpath, ¤t_directory_set);
else
- path_list_insert(newpath, ¤t_file_set);
+ string_list_insert(newpath, ¤t_file_set);
free(newpath);
return READ_TREE_RECURSIVE;
*/
static struct stage_data *insert_stage_data(const char *path,
struct tree *o, struct tree *a, struct tree *b,
- struct path_list *entries)
+ struct string_list *entries)
{
- struct path_list_item *item;
+ struct string_list_item *item;
struct stage_data *e = xcalloc(1, sizeof(struct stage_data));
get_tree_entry(o->object.sha1, path,
e->stages[1].sha, &e->stages[1].mode);
e->stages[2].sha, &e->stages[2].mode);
get_tree_entry(b->object.sha1, path,
e->stages[3].sha, &e->stages[3].mode);
- item = path_list_insert(path, entries);
+ item = string_list_insert(path, entries);
item->util = e;
return e;
}
* Create a dictionary mapping file names to stage_data objects. The
* dictionary contains one entry for every path with a non-zero stage entry.
*/
-static struct path_list *get_unmerged(void)
+static struct string_list *get_unmerged(void)
{
- struct path_list *unmerged = xcalloc(1, sizeof(struct path_list));
+ struct string_list *unmerged = xcalloc(1, sizeof(struct string_list));
int i;
- unmerged->strdup_paths = 1;
+ unmerged->strdup_strings = 1;
for (i = 0; i < active_nr; i++) {
- struct path_list_item *item;
+ struct string_list_item *item;
struct stage_data *e;
struct cache_entry *ce = active_cache[i];
if (!ce_stage(ce))
continue;
- item = path_list_lookup(ce->name, unmerged);
+ item = string_list_lookup(ce->name, unmerged);
if (!item) {
- item = path_list_insert(ce->name, unmerged);
+ item = string_list_insert(ce->name, unmerged);
item->util = xcalloc(1, sizeof(struct stage_data));
}
e = item->util;
* 'b_tree') to be able to associate the correct cache entries with
* the rename information. 'tree' is always equal to either a_tree or b_tree.
*/
-static struct path_list *get_renames(struct tree *tree,
+static struct string_list *get_renames(struct tree *tree,
struct tree *o_tree,
struct tree *a_tree,
struct tree *b_tree,
- struct path_list *entries)
+ struct string_list *entries)
{
int i;
- struct path_list *renames;
+ struct string_list *renames;
struct diff_options opts;
- renames = xcalloc(1, sizeof(struct path_list));
+ renames = xcalloc(1, sizeof(struct string_list));
diff_setup(&opts);
DIFF_OPT_SET(&opts, RECURSIVE);
opts.detect_rename = DIFF_DETECT_RENAME;
diff_tree_sha1(o_tree->object.sha1, tree->object.sha1, "", &opts);
diffcore_std(&opts);
for (i = 0; i < diff_queued_diff.nr; ++i) {
- struct path_list_item *item;
+ struct string_list_item *item;
struct rename *re;
struct diff_filepair *pair = diff_queued_diff.queue[i];
if (pair->status != 'R') {
re = xmalloc(sizeof(*re));
re->processed = 0;
re->pair = pair;
- item = path_list_lookup(re->pair->one->path, entries);
+ item = string_list_lookup(re->pair->one->path, entries);
if (!item)
re->src_entry = insert_stage_data(re->pair->one->path,
o_tree, a_tree, b_tree, entries);
else
re->src_entry = item->util;
- item = path_list_lookup(re->pair->two->path, entries);
+ item = string_list_lookup(re->pair->two->path, entries);
if (!item)
re->dst_entry = insert_stage_data(re->pair->two->path,
o_tree, a_tree, b_tree, entries);
else
re->dst_entry = item->util;
- item = path_list_insert(pair->one->path, renames);
+ item = string_list_insert(pair->one->path, renames);
item->util = re;
}
opts.output_format = DIFF_FORMAT_NO_OUTPUT;
for (; *p; ++p)
if ('/' == *p)
*p = '_';
- while (path_list_has_path(¤t_file_set, newpath) ||
- path_list_has_path(¤t_directory_set, newpath) ||
+ while (string_list_has_string(¤t_file_set, newpath) ||
+ string_list_has_string(¤t_directory_set, newpath) ||
lstat(newpath, &st) == 0)
sprintf(p, "_%d", suffix++);
- path_list_insert(newpath, ¤t_file_set);
+ string_list_insert(newpath, ¤t_file_set);
return newpath;
}
const char *ren2_dst = ren2->pair->two->path;
const char *dst_name1 = ren1_dst;
const char *dst_name2 = ren2_dst;
- if (path_list_has_path(¤t_directory_set, ren1_dst)) {
+ if (string_list_has_string(¤t_directory_set, ren1_dst)) {
dst_name1 = del[delp++] = unique_path(ren1_dst, branch1);
output(1, "%s is a directory in %s added as %s instead",
ren1_dst, branch2, dst_name1);
remove_file(0, ren1_dst, 0);
}
- if (path_list_has_path(¤t_directory_set, ren2_dst)) {
+ if (string_list_has_string(¤t_directory_set, ren2_dst)) {
dst_name2 = del[delp++] = unique_path(ren2_dst, branch2);
output(1, "%s is a directory in %s added as %s instead",
ren2_dst, branch1, dst_name2);
free(new_path1);
}
-static int process_renames(struct path_list *a_renames,
- struct path_list *b_renames,
+static int process_renames(struct string_list *a_renames,
+ struct string_list *b_renames,
const char *a_branch,
const char *b_branch)
{
int clean_merge = 1, i, j;
- struct path_list a_by_dst = {NULL, 0, 0, 0}, b_by_dst = {NULL, 0, 0, 0};
+ struct string_list a_by_dst = {NULL, 0, 0, 0}, b_by_dst = {NULL, 0, 0, 0};
const struct rename *sre;
for (i = 0; i < a_renames->nr; i++) {
sre = a_renames->items[i].util;
- path_list_insert(sre->pair->two->path, &a_by_dst)->util
+ string_list_insert(sre->pair->two->path, &a_by_dst)->util
= sre->dst_entry;
}
for (i = 0; i < b_renames->nr; i++) {
sre = b_renames->items[i].util;
- path_list_insert(sre->pair->two->path, &b_by_dst)->util
+ string_list_insert(sre->pair->two->path, &b_by_dst)->util
= sre->dst_entry;
}
for (i = 0, j = 0; i < a_renames->nr || j < b_renames->nr;) {
int compare;
char *src;
- struct path_list *renames1, *renames2, *renames2Dst;
+ struct string_list *renames1, *renames2, *renames2Dst;
struct rename *ren1 = NULL, *ren2 = NULL;
const char *branch1, *branch2;
const char *ren1_src, *ren1_dst;
compare = -1;
ren1 = a_renames->items[i++].util;
} else {
- compare = strcmp(a_renames->items[i].path,
- b_renames->items[j].path);
+ compare = strcmp(a_renames->items[i].string,
+ b_renames->items[j].string);
if (compare <= 0)
ren1 = a_renames->items[i++].util;
if (compare >= 0)
}
} else {
/* Renamed in 1, maybe changed in 2 */
- struct path_list_item *item;
+ struct string_list_item *item;
/* we only use sha1 and mode of these */
struct diff_filespec src_other, dst_other;
int try_merge, stage = a_renames == renames1 ? 3: 2;
try_merge = 0;
- if (path_list_has_path(¤t_directory_set, ren1_dst)) {
+ if (string_list_has_string(¤t_directory_set, ren1_dst)) {
clean_merge = 0;
output(1, "CONFLICT (rename/directory): Renamed %s->%s in %s "
" directory %s added in %s",
new_path = unique_path(ren1_dst, branch2);
output(1, "Added as %s instead", new_path);
update_file(0, dst_other.sha1, dst_other.mode, new_path);
- } else if ((item = path_list_lookup(ren1_dst, renames2Dst))) {
+ } else if ((item = string_list_lookup(ren1_dst, renames2Dst))) {
ren2 = item->util;
clean_merge = 0;
ren2->processed = 1;
}
}
}
- path_list_clear(&a_by_dst, 0);
- path_list_clear(&b_by_dst, 0);
+ string_list_clear(&a_by_dst, 0);
+ string_list_clear(&b_by_dst, 0);
return clean_merge;
}
sha = b_sha;
conf = "directory/file";
}
- if (path_list_has_path(¤t_directory_set, path)) {
+ if (string_list_has_string(¤t_directory_set, path)) {
const char *new_path = unique_path(path, add_branch);
clean_merge = 0;
output(1, "CONFLICT (%s): There is a directory with name %s in %s. "
sha1_to_hex(merge->object.sha1));
if (unmerged_cache()) {
- struct path_list *entries, *re_head, *re_merge;
+ struct string_list *entries, *re_head, *re_merge;
int i;
- path_list_clear(¤t_file_set, 1);
- path_list_clear(¤t_directory_set, 1);
+ string_list_clear(¤t_file_set, 1);
+ string_list_clear(¤t_directory_set, 1);
get_files_dirs(head);
get_files_dirs(merge);
clean = process_renames(re_head, re_merge,
branch1, branch2);
for (i = 0; i < entries->nr; i++) {
- const char *path = entries->items[i].path;
+ const char *path = entries->items[i].string;
struct stage_data *e = entries->items[i].util;
if (!e->processed
&& !process_entry(path, e, branch1, branch2))
clean = 0;
}
- path_list_clear(re_merge, 0);
- path_list_clear(re_head, 0);
- path_list_clear(entries, 1);
+ string_list_clear(re_merge, 0);
+ string_list_clear(re_head, 0);
+ string_list_clear(entries, 1);
}
else
diff --git a/builtin-mv.c b/builtin-mv.c
index ba9cedab6dcb92afb83646b2fdb48247d0184f7d..736a0b8bb1f39c47b35cb58f6775a683c5ed9ed7 100644 (file)
--- a/builtin-mv.c
+++ b/builtin-mv.c
#include "builtin.h"
#include "dir.h"
#include "cache-tree.h"
-#include "path-list.h"
+#include "string-list.h"
#include "parse-options.h"
static const char * const builtin_mv_usage[] = {
return get_pathspec(prefix, result);
}
-static void show_list(const char *label, struct path_list *list)
+static void show_list(const char *label, struct string_list *list)
{
if (list->nr > 0) {
int i;
printf("%s", label);
for (i = 0; i < list->nr; i++)
- printf("%s%s", i > 0 ? ", " : "", list->items[i].path);
+ printf("%s%s", i > 0 ? ", " : "",
+ list->items[i].string);
putchar('\n');
}
}
const char **source, **destination, **dest_path;
enum update_mode { BOTH = 0, WORKING_DIRECTORY, INDEX } *modes;
struct stat st;
- struct path_list overwritten = {NULL, 0, 0, 0};
- struct path_list src_for_dst = {NULL, 0, 0, 0};
- struct path_list added = {NULL, 0, 0, 0};
- struct path_list deleted = {NULL, 0, 0, 0};
- struct path_list changed = {NULL, 0, 0, 0};
+ struct string_list overwritten = {NULL, 0, 0, 0};
+ struct string_list src_for_dst = {NULL, 0, 0, 0};
+ struct string_list added = {NULL, 0, 0, 0};
+ struct string_list deleted = {NULL, 0, 0, 0};
+ struct string_list changed = {NULL, 0, 0, 0};
git_config(git_default_config, NULL);
" will overwrite!\n",
bad);
bad = NULL;
- path_list_insert(dst, &overwritten);
+ string_list_insert(dst, &overwritten);
} else
bad = "Cannot overwrite";
}
} else if (cache_name_pos(src, length) < 0)
bad = "not under version control";
- else if (path_list_has_path(&src_for_dst, dst))
+ else if (string_list_has_string(&src_for_dst, dst))
bad = "multiple sources for the same target";
else
- path_list_insert(dst, &src_for_dst);
+ string_list_insert(dst, &src_for_dst);
if (bad) {
if (ignore_errors) {
continue;
if (cache_name_pos(src, strlen(src)) >= 0) {
- path_list_insert(src, &deleted);
+ string_list_insert(src, &deleted);
/* destination can be a directory with 1 file inside */
- if (path_list_has_path(&overwritten, dst))
- path_list_insert(dst, &changed);
+ if (string_list_has_string(&overwritten, dst))
+ string_list_insert(dst, &changed);
else
- path_list_insert(dst, &added);
+ string_list_insert(dst, &added);
} else
- path_list_insert(dst, &added);
+ string_list_insert(dst, &added);
}
if (show_only) {
show_list("Deleting : ", &deleted);
} else {
for (i = 0; i < changed.nr; i++) {
- const char *path = changed.items[i].path;
+ const char *path = changed.items[i].string;
int j = cache_name_pos(path, strlen(path));
struct cache_entry *ce = active_cache[j];
}
for (i = 0; i < added.nr; i++) {
- const char *path = added.items[i].path;
+ const char *path = added.items[i].string;
if (add_file_to_cache(path, verbose ? ADD_CACHE_VERBOSE : 0))
die("updating index entries failed");
}
for (i = 0; i < deleted.nr; i++)
- remove_file_from_cache(deleted.items[i].path);
+ remove_file_from_cache(deleted.items[i].string);
if (active_cache_changed) {
if (write_cache(newfd, active_cache, active_nr) ||
diff --git a/builtin-remote.c b/builtin-remote.c
index db12668cfeb87ca405e7b24f54b11505a701f83c..54d1c3e3d16b2cebcff0c6c57d98756e48472b67 100644 (file)
--- a/builtin-remote.c
+++ b/builtin-remote.c
#include "parse-options.h"
#include "transport.h"
#include "remote.h"
-#include "path-list.h"
+#include "string-list.h"
#include "strbuf.h"
#include "run-command.h"
#include "refs.h"
static int opt_parse_track(const struct option *opt, const char *arg, int not)
{
- struct path_list *list = opt->value;
+ struct string_list *list = opt->value;
if (not)
- path_list_clear(list, 0);
+ string_list_clear(list, 0);
else
- path_list_append(arg, list);
+ string_list_append(arg, list);
return 0;
}
static int add(int argc, const char **argv)
{
int fetch = 0, mirror = 0;
- struct path_list track = { NULL, 0, 0 };
+ struct string_list track = { NULL, 0, 0 };
const char *master = NULL;
struct remote *remote;
struct strbuf buf, buf2;
strbuf_addf(&buf, "remote.%s.fetch", name);
if (track.nr == 0)
- path_list_append("*", &track);
+ string_list_append("*", &track);
for (i = 0; i < track.nr; i++) {
- struct path_list_item *item = track.items + i;
+ struct string_list_item *item = track.items + i;
strbuf_reset(&buf2);
strbuf_addch(&buf2, '+');
if (mirror)
strbuf_addf(&buf2, "refs/%s:refs/%s",
- item->path, item->path);
+ item->string, item->string);
else
strbuf_addf(&buf2, "refs/heads/%s:refs/remotes/%s/%s",
- item->path, name, item->path);
+ item->string, name, item->string);
if (git_config_set_multivar(buf.buf, buf2.buf, "^$", 0))
return 1;
}
strbuf_release(&buf);
strbuf_release(&buf2);
- path_list_clear(&track, 0);
+ string_list_clear(&track, 0);
return 0;
}
struct branch_info {
char *remote;
- struct path_list merge;
+ struct string_list merge;
};
-static struct path_list branch_list;
+static struct string_list branch_list;
static const char *abbrev_ref(const char *name, const char *prefix)
{
{
if (!prefixcmp(key, "branch.")) {
char *name;
- struct path_list_item *item;
+ struct string_list_item *item;
struct branch_info *info;
enum { REMOTE, MERGE } type;
} else
return 0;
- item = path_list_insert(name, &branch_list);
+ item = string_list_insert(name, &branch_list);
if (!item->util)
item->util = xcalloc(sizeof(struct branch_info), 1);
while (space) {
char *merge;
merge = xstrndup(value, space - value);
- path_list_append(merge, &info->merge);
+ string_list_append(merge, &info->merge);
value = abbrev_branch(space + 1);
space = strchr(value, ' ');
}
- path_list_append(xstrdup(value), &info->merge);
+ string_list_append(xstrdup(value), &info->merge);
}
}
return 0;
if (branch_list.nr)
return;
git_config(config_read_branches, NULL);
- sort_path_list(&branch_list);
+ sort_string_list(&branch_list);
}
struct ref_states {
struct remote *remote;
- struct path_list new, stale, tracked;
+ struct string_list new, stale, tracked;
};
static int handle_one_branch(const char *refname,
memset(&refspec, 0, sizeof(refspec));
refspec.dst = (char *)refname;
if (!remote_find_tracking(states->remote, &refspec)) {
- struct path_list_item *item;
+ struct string_list_item *item;
const char *name = abbrev_branch(refspec.src);
/* symbolic refs pointing nowhere were handled already */
if ((flags & REF_ISSYMREF) ||
- unsorted_path_list_has_path(&states->tracked,
+ unsorted_string_list_has_string(&states->tracked,
name) ||
- unsorted_path_list_has_path(&states->new,
+ unsorted_string_list_has_string(&states->new,
name))
return 0;
- item = path_list_append(name, &states->stale);
+ item = string_list_append(name, &states->stale);
item->util = xstrdup(refname);
}
return 0;
die("Could not get fetch map for refspec %s",
states->remote->fetch_refspec[i]);
- states->new.strdup_paths = states->tracked.strdup_paths = 1;
+ states->new.strdup_strings = states->tracked.strdup_strings = 1;
for (ref = fetch_map; ref; ref = ref->next) {
- struct path_list *target = &states->tracked;
+ struct string_list *target = &states->tracked;
unsigned char sha1[20];
void *util = NULL;
if (hashcmp(sha1, ref->new_sha1))
util = &states;
}
- path_list_append(abbrev_branch(ref->name), target)->util = util;
+ string_list_append(abbrev_branch(ref->name), target)->util = util;
}
free_refs(fetch_map);
for_each_ref(handle_one_branch, states);
- sort_path_list(&states->stale);
+ sort_string_list(&states->stale);
return 0;
}
struct branches_for_remote {
struct remote *remote;
- struct path_list *branches;
+ struct string_list *branches;
struct known_remotes *keep;
};
{
struct branches_for_remote *branches = cb_data;
struct refspec refspec;
- struct path_list_item *item;
+ struct string_list_item *item;
struct known_remote *kr;
memset(&refspec, 0, sizeof(refspec));
if (flags & REF_ISSYMREF)
return unlink(git_path(refname));
- item = path_list_append(refname, branches->branches);
+ item = string_list_append(refname, branches->branches);
item->util = xmalloc(20);
hashcpy(item->util, sha1);
return 0;
}
-static int remove_branches(struct path_list *branches)
+static int remove_branches(struct string_list *branches)
{
int i, result = 0;
for (i = 0; i < branches->nr; i++) {
- struct path_list_item *item = branches->items + i;
- const char *refname = item->path;
+ struct string_list_item *item = branches->items + i;
+ const char *refname = item->string;
unsigned char *sha1 = item->util;
if (delete_ref(refname, sha1))
struct remote *remote;
struct strbuf buf;
struct known_remotes known_remotes = { NULL, NULL };
- struct path_list branches = { NULL, 0, 0, 1 };
+ struct string_list branches = { NULL, 0, 0, 1 };
struct branches_for_remote cb_data = { NULL, &branches, &known_remotes };
int i;
read_branches();
for (i = 0; i < branch_list.nr; i++) {
- struct path_list_item *item = branch_list.items + i;
+ struct string_list_item *item = branch_list.items + i;
struct branch_info *info = item->util;
if (info->remote && !strcmp(info->remote, remote->name)) {
const char *keys[] = { "remote", "merge", NULL }, **k;
for (k = keys; *k; k++) {
strbuf_reset(&buf);
strbuf_addf(&buf, "branch.%s.%s",
- item->path, *k);
+ item->string, *k);
if (git_config_set(buf.buf, NULL)) {
strbuf_release(&buf);
return -1;
if (!i)
i = remove_branches(&branches);
- path_list_clear(&branches, 1);
+ string_list_clear(&branches, 1);
return i;
}
-static void show_list(const char *title, struct path_list *list)
+static void show_list(const char *title, struct string_list *list)
{
int i;
printf(title, list->nr > 1 ? "es" : "");
printf("\n ");
for (i = 0; i < list->nr; i++)
- printf("%s%s", i ? " " : "", list->items[i].path);
+ printf("%s%s", i ? " " : "", list->items[i].string);
printf("\n");
}
memset(&refspec, 0, sizeof(refspec));
refspec.dst = (char *)refname;
if (!remote_find_tracking(states->remote, &refspec))
- path_list_append(abbrev_branch(refspec.src), &states->tracked);
+ string_list_append(abbrev_branch(refspec.src), &states->tracked);
return 0;
}
states.remote->url[0] : "(no URL)");
for (i = 0; i < branch_list.nr; i++) {
- struct path_list_item *branch = branch_list.items + i;
+ struct string_list_item *branch = branch_list.items + i;
struct branch_info *info = branch->util;
int j;
printf(" Remote branch%s merged with 'git pull' "
"while on branch %s\n ",
info->merge.nr > 1 ? "es" : "",
- branch->path);
+ branch->string);
for (j = 0; j < info->merge.nr; j++)
- printf(" %s", info->merge.items[j].path);
+ printf(" %s", info->merge.items[j].string);
printf("\n");
}
}
/* NEEDSWORK: free remote */
- path_list_clear(&states.new, 0);
- path_list_clear(&states.stale, 0);
- path_list_clear(&states.tracked, 0);
+ string_list_clear(&states.new, 0);
+ string_list_clear(&states.stale, 0);
+ string_list_clear(&states.tracked, 0);
}
return result;
}
/* NEEDSWORK: free remote */
- path_list_clear(&states.new, 0);
- path_list_clear(&states.stale, 0);
- path_list_clear(&states.tracked, 0);
+ string_list_clear(&states.new, 0);
+ string_list_clear(&states.stale, 0);
+ string_list_clear(&states.tracked, 0);
}
return result;
static int get_one_remote_for_update(struct remote *remote, void *priv)
{
- struct path_list *list = priv;
+ struct string_list *list = priv;
if (!remote->skip_default_update)
- path_list_append(xstrdup(remote->name), list);
+ string_list_append(xstrdup(remote->name), list);
return 0;
}
struct remote_group {
const char *name;
- struct path_list *list;
+ struct string_list *list;
} remote_group;
static int get_remote_group(const char *key, const char *value, void *cb)
int space = strcspn(value, " \t\n");
while (*value) {
if (space > 1)
- path_list_append(xstrndup(value, space),
+ string_list_append(xstrndup(value, space),
remote_group.list);
value += space + (value[space] != '\0');
space = strcspn(value, " \t\n");
static int update(int argc, const char **argv)
{
int i, result = 0;
- struct path_list list = { NULL, 0, 0, 0 };
+ struct string_list list = { NULL, 0, 0, 0 };
static const char *default_argv[] = { NULL, "default", NULL };
if (argc < 2) {
result = for_each_remote(get_one_remote_for_update, &list);
for (i = 0; i < list.nr; i++)
- result |= fetch_remote(list.items[i].path);
+ result |= fetch_remote(list.items[i].string);
/* all names were strdup()ed or strndup()ed */
- list.strdup_paths = 1;
- path_list_clear(&list, 0);
+ list.strdup_strings = 1;
+ string_list_clear(&list, 0);
return result;
}
static int get_one_entry(struct remote *remote, void *priv)
{
- struct path_list *list = priv;
+ struct string_list *list = priv;
- path_list_append(remote->name, list)->util = remote->url_nr ?
+ string_list_append(remote->name, list)->util = remote->url_nr ?
(void *)remote->url[0] : NULL;
if (remote->url_nr > 1)
warning("Remote %s has more than one URL", remote->name);
static int show_all(void)
{
- struct path_list list = { NULL, 0, 0 };
+ struct string_list list = { NULL, 0, 0 };
int result = for_each_remote(get_one_entry, &list);
if (!result) {
int i;
- sort_path_list(&list);
+ sort_string_list(&list);
for (i = 0; i < list.nr; i++) {
- struct path_list_item *item = list.items + i;
- printf("%s%s%s\n", item->path,
+ struct string_list_item *item = list.items + i;
+ printf("%s%s%s\n", item->string,
verbose ? "\t" : "",
verbose && item->util ?
(const char *)item->util : "");
diff --git a/builtin-rerere.c b/builtin-rerere.c
index 580580502cc0d84400edca8e2bda5ce607b43b58..dd4573fe8dcd9dc8edd5a7d41bc8daa83034ee7e 100644 (file)
--- a/builtin-rerere.c
+++ b/builtin-rerere.c
#include "builtin.h"
#include "cache.h"
-#include "path-list.h"
+#include "string-list.h"
#include "rerere.h"
#include "xdiff/xdiff.h"
#include "xdiff-interface.h"
return 0;
}
-static void garbage_collect(struct path_list *rr)
+static void garbage_collect(struct string_list *rr)
{
- struct path_list to_remove = { NULL, 0, 0, 1 };
+ struct string_list to_remove = { NULL, 0, 0, 1 };
DIR *dir;
struct dirent *e;
int i, cutoff;
cutoff = (has_resolution(name)
? cutoff_resolve : cutoff_noresolve);
if (then < now - cutoff * 86400)
- path_list_append(name, &to_remove);
+ string_list_append(name, &to_remove);
}
for (i = 0; i < to_remove.nr; i++)
- unlink_rr_item(to_remove.items[i].path);
- path_list_clear(&to_remove, 0);
+ unlink_rr_item(to_remove.items[i].string);
+ string_list_clear(&to_remove, 0);
}
static int outf(void *dummy, mmbuffer_t *ptr, int nbuf)
int cmd_rerere(int argc, const char **argv, const char *prefix)
{
- struct path_list merge_rr = { NULL, 0, 0, 1 };
+ struct string_list merge_rr = { NULL, 0, 0, 1 };
int i, fd;
if (argc < 2)
garbage_collect(&merge_rr);
else if (!strcmp(argv[1], "status"))
for (i = 0; i < merge_rr.nr; i++)
- printf("%s\n", merge_rr.items[i].path);
+ printf("%s\n", merge_rr.items[i].string);
else if (!strcmp(argv[1], "diff"))
for (i = 0; i < merge_rr.nr; i++) {
- const char *path = merge_rr.items[i].path;
+ const char *path = merge_rr.items[i].string;
const char *name = (const char *)merge_rr.items[i].util;
diff_two(rr_path(name, "preimage"), path, path, path);
}
else
usage(git_rerere_usage);
- path_list_clear(&merge_rr, 1);
+ string_list_clear(&merge_rr, 1);
return 0;
}
diff --git a/builtin-shortlog.c b/builtin-shortlog.c
index 94c4723856924a9643bcaf6c14fd9679667cbbdd..d03f14fdad3d17dde06734d78ddb4aade6ed4f2b 100644 (file)
--- a/builtin-shortlog.c
+++ b/builtin-shortlog.c
#include "cache.h"
#include "commit.h"
#include "diff.h"
-#include "path-list.h"
+#include "string-list.h"
#include "revision.h"
#include "utf8.h"
#include "mailmap.h"
static int compare_by_number(const void *a1, const void *a2)
{
- const struct path_list_item *i1 = a1, *i2 = a2;
- const struct path_list *l1 = i1->util, *l2 = i2->util;
+ const struct string_list_item *i1 = a1, *i2 = a2;
+ const struct string_list *l1 = i1->util, *l2 = i2->util;
if (l1->nr < l2->nr)
return 1;
{
const char *dot3 = log->common_repo_prefix;
char *buffer, *p;
- struct path_list_item *item;
- struct path_list *onelines;
+ struct string_list_item *item;
+ struct string_list *onelines;
char namebuf[1024];
size_t len;
const char *eol;
}
buffer = xstrdup(namebuf);
- item = path_list_insert(buffer, &log->list);
+ item = string_list_insert(buffer, &log->list);
if (item->util == NULL)
- item->util = xcalloc(1, sizeof(struct path_list));
+ item->util = xcalloc(1, sizeof(struct string_list));
else
free(buffer);
onelines->alloc = alloc_nr(onelines->nr);
onelines->items = xrealloc(onelines->items,
onelines->alloc
- * sizeof(struct path_list_item));
+ * sizeof(struct string_list_item));
}
onelines->items[onelines->nr].util = NULL;
- onelines->items[onelines->nr++].path = buffer;
+ onelines->items[onelines->nr++].string = buffer;
}
static void read_from_stdin(struct shortlog *log)
read_mailmap(&log->mailmap, ".mailmap", &log->common_repo_prefix);
- log->list.strdup_paths = 1;
+ log->list.strdup_strings = 1;
log->wrap = DEFAULT_WRAPLEN;
log->in1 = DEFAULT_INDENT1;
log->in2 = DEFAULT_INDENT2;
{
int i, j;
if (log->sort_by_number)
- qsort(log->list.items, log->list.nr, sizeof(struct path_list_item),
+ qsort(log->list.items, log->list.nr, sizeof(struct string_list_item),
compare_by_number);
for (i = 0; i < log->list.nr; i++) {
- struct path_list *onelines = log->list.items[i].util;
+ struct string_list *onelines = log->list.items[i].util;
if (log->summary) {
- printf("%6d\t%s\n", onelines->nr, log->list.items[i].path);
+ printf("%6d\t%s\n", onelines->nr, log->list.items[i].string);
} else {
- printf("%s (%d):\n", log->list.items[i].path, onelines->nr);
+ printf("%s (%d):\n", log->list.items[i].string, onelines->nr);
for (j = onelines->nr - 1; j >= 0; j--) {
- const char *msg = onelines->items[j].path;
+ const char *msg = onelines->items[j].string;
if (log->wrap_lines) {
int col = print_wrapped_text(msg, log->in1, log->in2, log->wrap);
putchar('\n');
}
- onelines->strdup_paths = 1;
- path_list_clear(onelines, 1);
+ onelines->strdup_strings = 1;
+ string_list_clear(onelines, 1);
free(onelines);
log->list.items[i].util = NULL;
}
- log->list.strdup_paths = 1;
- path_list_clear(&log->list, 1);
- log->mailmap.strdup_paths = 1;
- path_list_clear(&log->mailmap, 1);
+ log->list.strdup_strings = 1;
+ string_list_clear(&log->list, 1);
+ log->mailmap.strdup_strings = 1;
+ string_list_clear(&log->mailmap, 1);
}
diff --git a/builtin-show-ref.c b/builtin-show-ref.c
index a323633e296cef1797ab1d218cea83c891bc3b8d..add16004f11375b1ad2b97f9b1bf1ced5c437f81 100644 (file)
--- a/builtin-show-ref.c
+++ b/builtin-show-ref.c
#include "refs.h"
#include "object.h"
#include "tag.h"
-#include "path-list.h"
+#include "string-list.h"
static const char show_ref_usage[] = "git show-ref [-q|--quiet] [--verify] [-h|--head] [-d|--dereference] [-s|--hash[=<length>]] [--abbrev[=<length>]] [--tags] [--heads] [--] [pattern*] < ref-list";
static int add_existing(const char *refname, const unsigned char *sha1, int flag, void *cbdata)
{
- struct path_list *list = (struct path_list *)cbdata;
- path_list_insert(refname, list);
+ struct string_list *list = (struct string_list *)cbdata;
+ string_list_insert(refname, list);
return 0;
}
@@ -114,7 +114,7 @@ static int add_existing(const char *refname, const unsigned char *sha1, int flag
*/
static int exclude_existing(const char *match)
{
- static struct path_list existing_refs = { NULL, 0, 0, 0 };
+ static struct string_list existing_refs = { NULL, 0, 0, 0 };
char buf[1024];
int matchlen = match ? strlen(match) : 0;
fprintf(stderr, "warning: ref '%s' ignored\n", ref);
continue;
}
- if (!path_list_has_path(&existing_refs, ref)) {
+ if (!string_list_has_string(&existing_refs, ref)) {
printf("%s\n", buf);
}
}
diff --git a/diff-no-index.c b/diff-no-index.c
index f6994cf5fb0b9fa570ded7012088ba8b8be5fd71..7d68b7f1bef1039b4996e662fb17968c4e3e3e79 100644 (file)
--- a/diff-no-index.c
+++ b/diff-no-index.c
#include "revision.h"
#include "log-tree.h"
#include "builtin.h"
-#include "path-list.h"
+#include "string-list.h"
-static int read_directory(const char *path, struct path_list *list)
+static int read_directory(const char *path, struct string_list *list)
{
DIR *dir;
struct dirent *e;
while ((e = readdir(dir)))
if (strcmp(".", e->d_name) && strcmp("..", e->d_name))
- path_list_insert(e->d_name, list);
+ string_list_insert(e->d_name, list);
closedir(dir);
return 0;
if (S_ISDIR(mode1) || S_ISDIR(mode2)) {
char buffer1[PATH_MAX], buffer2[PATH_MAX];
- struct path_list p1 = {NULL, 0, 0, 1}, p2 = {NULL, 0, 0, 1};
+ struct string_list p1 = {NULL, 0, 0, 1}, p2 = {NULL, 0, 0, 1};
int len1 = 0, len2 = 0, i1, i2, ret = 0;
if (name1 && read_directory(name1, &p1))
return -1;
if (name2 && read_directory(name2, &p2)) {
- path_list_clear(&p1, 0);
+ string_list_clear(&p1, 0);
return -1;
}
else if (i2 == p2.nr)
comp = -1;
else
- comp = strcmp(p1.items[i1].path,
- p2.items[i2].path);
+ comp = strcmp(p1.items[i1].string,
+ p2.items[i2].string);
if (comp > 0)
n1 = NULL;
else {
n1 = buffer1;
- strncpy(buffer1 + len1, p1.items[i1++].path,
+ strncpy(buffer1 + len1, p1.items[i1++].string,
PATH_MAX - len1);
}
n2 = NULL;
else {
n2 = buffer2;
- strncpy(buffer2 + len2, p2.items[i2++].path,
+ strncpy(buffer2 + len2, p2.items[i2++].string,
PATH_MAX - len2);
}
ret = queue_diff(o, n1, n2);
}
- path_list_clear(&p1, 0);
- path_list_clear(&p2, 0);
+ string_list_clear(&p1, 0);
+ string_list_clear(&p2, 0);
return ret;
} else {
diff --git a/mailmap.c b/mailmap.c
index f0172552e4c42c1526e2395802a41070d43cadae..88fc6f394684436967002ca477eac1e084537348 100644 (file)
--- a/mailmap.c
+++ b/mailmap.c
#include "cache.h"
-#include "path-list.h"
+#include "string-list.h"
#include "mailmap.h"
-int read_mailmap(struct path_list *map, const char *filename, char **repo_abbrev)
+int read_mailmap(struct string_list *map, const char *filename, char **repo_abbrev)
{
char buffer[1024];
FILE *f = fopen(filename, "r");
@@ -54,16 +54,16 @@ int read_mailmap(struct path_list *map, const char *filename, char **repo_abbrev
for (i = 0; i < right_bracket - left_bracket - 1; i++)
email[i] = tolower(left_bracket[i + 1]);
email[right_bracket - left_bracket - 1] = '\0';
- path_list_insert(email, map)->util = name;
+ string_list_insert(email, map)->util = name;
}
fclose(f);
return 0;
}
-int map_email(struct path_list *map, const char *email, char *name, int maxlen)
+int map_email(struct string_list *map, const char *email, char *name, int maxlen)
{
char *p;
- struct path_list_item *item;
+ struct string_list_item *item;
char buf[1024], *mailbuf;
int i;
for (i = 0; i < p - email; i++)
mailbuf[i] = tolower(email[i]);
mailbuf[i] = 0;
- item = path_list_lookup(mailbuf, map);
+ item = string_list_lookup(mailbuf, map);
if (mailbuf != buf)
free(mailbuf);
if (item != NULL) {
diff --git a/mailmap.h b/mailmap.h
index 3503fd2727b7cee39fe8eafcb18ad713b0a2c9e8..6e48f83cedd13e24d50cddf47f037791ddc5ad4b 100644 (file)
--- a/mailmap.h
+++ b/mailmap.h
#ifndef MAILMAP_H
#define MAILMAP_H
-int read_mailmap(struct path_list *map, const char *filename, char **repo_abbrev);
-int map_email(struct path_list *mailmap, const char *email, char *name, int maxlen);
+int read_mailmap(struct string_list *map, const char *filename, char **repo_abbrev);
+int map_email(struct string_list *mailmap, const char *email, char *name, int maxlen);
#endif
diff --git a/path-list.c b/path-list.c
--- a/path-list.c
+++ /dev/null
@@ -1,134 +0,0 @@
-#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;
-}
-
diff --git a/path-list.h b/path-list.h
--- a/path-list.h
+++ /dev/null
@@ -1,28 +0,0 @@
-#ifndef PATH_LIST_H
-#define PATH_LIST_H
-
-struct path_list_item {
- char *path;
- void *util;
-};
-struct path_list
-{
- struct path_list_item *items;
- unsigned int nr, alloc;
- unsigned int strdup_paths:1;
-};
-
-void print_path_list(const char *text, const struct path_list *p);
-void path_list_clear(struct path_list *list, int free_util);
-
-/* Use these functions only on sorted lists: */
-int path_list_has_path(const struct path_list *list, const char *path);
-struct path_list_item *path_list_insert(const char *path, struct path_list *list);
-struct path_list_item *path_list_lookup(const char *path, struct path_list *list);
-
-/* Use these functions only on unsorted lists: */
-struct path_list_item *path_list_append(const char *path, struct path_list *list);
-void sort_path_list(struct path_list *list);
-int unsorted_path_list_has_path(struct path_list *list, const char *path);
-
-#endif /* PATH_LIST_H */
diff --git a/pretty.c b/pretty.c
index 628a5201c1e8aa3b985bf0b382e5511e17d953d4..33ef34a4119812674726254fee3f391fb5734fdb 100644 (file)
--- a/pretty.c
+++ b/pretty.c
#include "utf8.h"
#include "diff.h"
#include "revision.h"
-#include "path-list.h"
+#include "string-list.h"
#include "mailmap.h"
static char *user_format;
static int mailmap_name(struct strbuf *sb, const char *email)
{
- static struct path_list *mail_map;
+ static struct string_list *mail_map;
char buffer[1024];
if (!mail_map) {
diff --git a/reflog-walk.c b/reflog-walk.c
index ee1456b45a2e1bfe08564400c12015889e57cf12..f751fdc8d832cae54647c1a70d888e979d324fd8 100644 (file)
--- a/reflog-walk.c
+++ b/reflog-walk.c
#include "refs.h"
#include "diff.h"
#include "revision.h"
-#include "path-list.h"
+#include "string-list.h"
#include "reflog-walk.h"
struct complete_reflogs {
struct reflog_walk_info {
struct commit_info_lifo reflogs;
- struct path_list complete_reflogs;
+ struct string_list complete_reflogs;
struct commit_reflog *last_commit_reflog;
};
{
unsigned long timestamp = 0;
int recno = -1;
- struct path_list_item *item;
+ struct string_list_item *item;
struct complete_reflogs *reflogs;
char *branch, *at = strchr(name, '@');
struct commit_reflog *commit_reflog;
} else
recno = 0;
- item = path_list_lookup(branch, &info->complete_reflogs);
+ item = string_list_lookup(branch, &info->complete_reflogs);
if (item)
reflogs = item->util;
else {
}
if (!reflogs || reflogs->nr == 0)
return -1;
- path_list_insert(branch, &info->complete_reflogs)->util
+ string_list_insert(branch, &info->complete_reflogs)->util
= reflogs;
}
diff --git a/rerere.c b/rerere.c
index 0456aa6376caa1387284aa8fe42fc1ff66629822..323e493dafee46c0d3f95e3c4cd9c4c9b463bbef 100644 (file)
--- a/rerere.c
+++ b/rerere.c
#include "cache.h"
-#include "path-list.h"
+#include "string-list.h"
#include "rerere.h"
#include "xdiff/xdiff.h"
#include "xdiff-interface.h"
return !stat(rr_path(name, "postimage"), &st);
}
-static void read_rr(struct path_list *rr)
+static void read_rr(struct string_list *rr)
{
unsigned char sha1[20];
char buf[PATH_MAX];
; /* do nothing */
if (i == sizeof(buf))
die("filename too long");
- path_list_insert(buf, rr)->util = name;
+ string_list_insert(buf, rr)->util = name;
}
fclose(in);
}
static struct lock_file write_lock;
-static int write_rr(struct path_list *rr, int out_fd)
+static int write_rr(struct string_list *rr, int out_fd)
{
int i;
for (i = 0; i < rr->nr; i++) {
int length;
if (!rr->items[i].util)
continue;
- path = rr->items[i].path;
+ path = rr->items[i].string;
length = strlen(path) + 1;
if (write_in_full(out_fd, rr->items[i].util, 40) != 40 ||
write_in_full(out_fd, "\t", 1) != 1 ||
return hunk_no;
}
-static int find_conflict(struct path_list *conflict)
+static int find_conflict(struct string_list *conflict)
{
int i;
if (read_cache() < 0)
ce_same_name(e2, e3) &&
S_ISREG(e2->ce_mode) &&
S_ISREG(e3->ce_mode)) {
- path_list_insert((const char *)e2->name, conflict);
+ string_list_insert((const char *)e2->name, conflict);
i++; /* skip over both #2 and #3 */
}
}
static struct lock_file index_lock;
-static int update_paths(struct path_list *update)
+static int update_paths(struct string_list *update)
{
int i;
int fd = hold_locked_index(&index_lock, 0);
return -1;
for (i = 0; i < update->nr; i++) {
- struct path_list_item *item = &update->items[i];
- if (add_file_to_cache(item->path, ADD_CACHE_IGNORE_ERRORS))
+ struct string_list_item *item = &update->items[i];
+ if (add_file_to_cache(item->string, ADD_CACHE_IGNORE_ERRORS))
status = -1;
}
return status;
}
-static int do_plain_rerere(struct path_list *rr, int fd)
+static int do_plain_rerere(struct string_list *rr, int fd)
{
- struct path_list conflict = { NULL, 0, 0, 1 };
- struct path_list update = { NULL, 0, 0, 1 };
+ struct string_list conflict = { NULL, 0, 0, 1 };
+ struct string_list update = { NULL, 0, 0, 1 };
int i;
find_conflict(&conflict);
*/
for (i = 0; i < conflict.nr; i++) {
- const char *path = conflict.items[i].path;
- if (!path_list_has_path(rr, path)) {
+ const char *path = conflict.items[i].string;
+ if (!string_list_has_string(rr, path)) {
unsigned char sha1[20];
char *hex;
int ret;
if (ret < 1)
continue;
hex = xstrdup(sha1_to_hex(sha1));
- path_list_insert(path, rr)->util = hex;
+ string_list_insert(path, rr)->util = hex;
if (mkdir(git_path("rr-cache/%s", hex), 0755))
continue;;
handle_file(path, NULL, rr_path(hex, "preimage"));
for (i = 0; i < rr->nr; i++) {
int ret;
- const char *path = rr->items[i].path;
+ const char *path = rr->items[i].string;
const char *name = (const char *)rr->items[i].util;
if (has_resolution(name)) {
if (!merge(name, path)) {
if (rerere_autoupdate)
- path_list_insert(path, &update);
+ string_list_insert(path, &update);
fprintf(stderr,
"%s '%s' using previous resolution.\n",
rerere_autoupdate
return 1;
}
-int setup_rerere(struct path_list *merge_rr)
+int setup_rerere(struct string_list *merge_rr)
{
int fd;
int rerere(void)
{
- struct path_list merge_rr = { NULL, 0, 0, 1 };
+ struct string_list merge_rr = { NULL, 0, 0, 1 };
int fd;
fd = setup_rerere(&merge_rr);
diff --git a/rerere.h b/rerere.h
index 35b0fa86a3794027c5ccf898982b302849134921..f9b03862fe78b560ee606637be3b1ce972a2cc14 100644 (file)
--- a/rerere.h
+++ b/rerere.h
#ifndef RERERE_H
#define RERERE_H
-#include "path-list.h"
+#include "string-list.h"
-extern int setup_rerere(struct path_list *);
+extern int setup_rerere(struct string_list *);
extern int rerere(void);
#endif
diff --git a/shortlog.h b/shortlog.h
index 6608ee80b08881146b2678dba3120a036b69cc28..bc02cc29ef0d5f640ab390614def995f30fe4691 100644 (file)
--- a/shortlog.h
+++ b/shortlog.h
#ifndef SHORTLOG_H
#define SHORTLOG_H
-#include "path-list.h"
+#include "string-list.h"
struct shortlog {
- struct path_list list;
+ struct string_list list;
int summary;
int wrap_lines;
int sort_by_number;
char *common_repo_prefix;
int email;
- struct path_list mailmap;
+ struct string_list mailmap;
};
void shortlog_init(struct shortlog *log);
diff --git a/string-list.c b/string-list.c
--- /dev/null
+++ b/string-list.c
@@ -0,0 +1,134 @@
+#include "cache.h"
+#include "string-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 string_list *list, const char *string,
+ int *exact_match)
+{
+ int left = -1, right = list->nr;
+
+ while (left + 1 < right) {
+ int middle = (left + right) / 2;
+ int compare = strcmp(string, list->items[middle].string);
+ 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 string_list *list, const char *string)
+{
+ int exact_match;
+ int index = get_entry_index(list, string, &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 string_list_item));
+ }
+ if (index < list->nr)
+ memmove(list->items + index + 1, list->items + index,
+ (list->nr - index)
+ * sizeof(struct string_list_item));
+ list->items[index].string = list->strdup_strings ?
+ xstrdup(string) : (char *)string;
+ list->items[index].util = NULL;
+ list->nr++;
+
+ return index;
+}
+
+struct string_list_item *string_list_insert(const char *string, struct string_list *list)
+{
+ int index = add_entry(list, string);
+
+ if (index < 0)
+ index = -1 - index;
+
+ return list->items + index;
+}
+
+int string_list_has_string(const struct string_list *list, const char *string)
+{
+ int exact_match;
+ get_entry_index(list, string, &exact_match);
+ return exact_match;
+}
+
+struct string_list_item *string_list_lookup(const char *string, struct string_list *list)
+{
+ int exact_match, i = get_entry_index(list, string, &exact_match);
+ if (!exact_match)
+ return NULL;
+ return list->items + i;
+}
+
+void string_list_clear(struct string_list *list, int free_util)
+{
+ if (list->items) {
+ int i;
+ if (list->strdup_strings) {
+ for (i = 0; i < list->nr; i++)
+ free(list->items[i].string);
+ }
+ 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_string_list(const char *text, const struct string_list *p)
+{
+ int i;
+ if ( text )
+ printf("%s\n", text);
+ for (i = 0; i < p->nr; i++)
+ printf("%s:%p\n", p->items[i].string, p->items[i].util);
+}
+
+struct string_list_item *string_list_append(const char *string, struct string_list *list)
+{
+ ALLOC_GROW(list->items, list->nr + 1, list->alloc);
+ list->items[list->nr].string =
+ list->strdup_strings ? xstrdup(string) : (char *)string;
+ return list->items + list->nr++;
+}
+
+static int cmp_items(const void *a, const void *b)
+{
+ const struct string_list_item *one = a;
+ const struct string_list_item *two = b;
+ return strcmp(one->string, two->string);
+}
+
+void sort_string_list(struct string_list *list)
+{
+ qsort(list->items, list->nr, sizeof(*list->items), cmp_items);
+}
+
+int unsorted_string_list_has_string(struct string_list *list, const char *string)
+{
+ int i;
+ for (i = 0; i < list->nr; i++)
+ if (!strcmp(string, list->items[i].string))
+ return 1;
+ return 0;
+}
+
diff --git a/string-list.h b/string-list.h
--- /dev/null
+++ b/string-list.h
@@ -0,0 +1,28 @@
+#ifndef PATH_LIST_H
+#define PATH_LIST_H
+
+struct string_list_item {
+ char *string;
+ void *util;
+};
+struct string_list
+{
+ struct string_list_item *items;
+ unsigned int nr, alloc;
+ unsigned int strdup_strings:1;
+};
+
+void print_string_list(const char *text, const struct string_list *p);
+void string_list_clear(struct string_list *list, int free_util);
+
+/* Use these functions only on sorted lists: */
+int string_list_has_string(const struct string_list *list, const char *string);
+struct string_list_item *string_list_insert(const char *string, struct string_list *list);
+struct string_list_item *string_list_lookup(const char *string, struct string_list *list);
+
+/* Use these functions only on unsorted lists: */
+struct string_list_item *string_list_append(const char *string, struct string_list *list);
+void sort_string_list(struct string_list *list);
+int unsorted_string_list_has_string(struct string_list *list, const char *string);
+
+#endif /* PATH_LIST_H */