/* Various processing of names.
Copyright (C) 1988, 1992, 1994, 1996, 1997, 1998, 1999, 2000, 2001,
- 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
+ 2003, 2004, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
This program is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
- Free Software Foundation; either version 2, or (at your option) any later
+ Free Software Foundation; either version 3, or (at your option) any later
version.
This program is distributed in the hope that it will be useful, but
return 1;
}
+\f
+struct name *
+make_name (const char *file_name)
+{
+ struct name *p = xzalloc (sizeof (*p));
+ if (!file_name)
+ file_name = "";
+ p->name = xstrdup (file_name);
+ p->length = strlen (p->name);
+ return p;
+}
+
+void
+free_name (struct name *p)
+{
+ if (p)
+ {
+ free (p->name);
+ free (p->caname);
+ free (p);
+ }
+}
+
\f
/* Names from the command call. */
static struct name *namelist; /* first name in list, if any */
-static struct name **nametail = &namelist; /* end of name list */
+static struct name *nametail; /* end of name list */
/* File name arguments are processed in two stages: first a
name_array (see below) is filled, then the names from it
static storage and can't be relied upon across two calls.
If CHANGE_DIRS is true, treat any entries of type NELT_CHDIR as
- the request to change to the given directory. If filename_terminator
- is NUL, CHANGE_DIRS is effectively always false.
-
+ the request to change to the given directory.
+
Entries of type NELT_FMASK cause updates of the matching_flags
value. */
struct name_elt *
const char *source;
char *cursor;
- if (filename_terminator == '\0')
- change_dirs = 0;
-
while (name_index != names)
{
struct name_elt *ep;
name_gather (void)
{
/* Buffer able to hold a single name. */
- static struct name *buffer;
- static size_t allocated_size;
+ static struct name *buffer = NULL;
struct name_elt *ep;
{
static int change_dir;
- if (allocated_size == 0)
- {
- allocated_size = offsetof (struct name, name) + NAME_FIELD_SIZE + 1;
- buffer = xmalloc (allocated_size);
- /* FIXME: This memset is overkill, and ugly... */
- memset (buffer, 0, allocated_size);
- }
-
while ((ep = name_next_elt (0)) && ep->type == NELT_CHDIR)
change_dir = chdir_arg (xstrdup (ep->v.name));
if (ep)
{
- size_t needed_size;
-
- buffer->length = strlen (ep->v.name);
- needed_size = offsetof (struct name, name) + buffer->length + 1;
- if (allocated_size < needed_size)
- {
- do
- {
- allocated_size *= 2;
- if (! allocated_size)
- xalloc_die ();
- }
- while (allocated_size < needed_size);
-
- buffer = xrealloc (buffer, allocated_size);
- }
+ free_name (buffer);
+ buffer = make_name (ep->v.name);
buffer->change_dir = change_dir;
- strcpy (buffer->name, ep->v.name);
buffer->next = 0;
buffer->found_count = 0;
buffer->matching_flags = matching_flags;
+ buffer->directory = NULL;
+ buffer->parent = NULL;
+ buffer->cmdline = true;
- namelist = buffer;
- nametail = &namelist->next;
+ namelist = nametail = buffer;
}
else if (change_dir)
- addname (0, change_dir);
+ addname (0, change_dir, false, NULL);
}
else
{
change_dir = chdir_arg (xstrdup (ep->v.name));
if (ep)
- addname (ep->v.name, change_dir);
+ addname (ep->v.name, change_dir, true, NULL);
else
{
if (change_dir != change_dir0)
- addname (0, change_dir);
+ addname (NULL, change_dir, false, NULL);
break;
}
}
/* Add a name to the namelist. */
struct name *
-addname (char const *string, int change_dir)
+addname (char const *string, int change_dir, bool cmdline, struct name *parent)
{
- size_t length = string ? strlen (string) : 0;
- struct name *name = xmalloc (offsetof (struct name, name) + length + 1);
-
- if (string)
- strcpy (name->name, string);
- else
- name->name[0] = 0;
+ struct name *name = make_name (string);
+ name->prev = nametail;
name->next = NULL;
- name->length = length;
name->found_count = 0;
name->matching_flags = matching_flags;
name->change_dir = change_dir;
- name->dir_contents = NULL;
- name->explicit = 1;
+ name->directory = NULL;
+ name->parent = parent;
+ name->cmdline = cmdline;
- *nametail = name;
- nametail = &name->next;
+ if (nametail)
+ nametail->next = name;
+ else
+ namelist = name;
+ nametail = name;
return name;
}
/* Find a match for FILE_NAME (whose string length is LENGTH) in the name
list. */
static struct name *
-namelist_match (char const *file_name, size_t length, bool exact)
+namelist_match (char const *file_name, size_t length)
{
struct name *p;
return NULL;
}
+void
+remname (struct name *name)
+{
+ struct name *p;
+
+ if ((p = name->prev) != NULL)
+ p->next = name->next;
+ else
+ namelist = name->next;
+
+ if ((p = name->next) != NULL)
+ p->prev = name->prev;
+ else
+ nametail = name->prev;
+}
+
/* Return true if and only if name FILE_NAME (from an archive) matches any
name from the namelist. */
-int
+bool
name_match (const char *file_name)
{
size_t length = strlen (file_name);
struct name *cursor = namelist;
if (!cursor)
- return 1;
-
+ return true;
+
if (cursor->name[0] == 0)
{
chdir_do (cursor->change_dir);
- namelist = 0;
- nametail = &namelist;
- return 1;
+ namelist = NULL;
+ nametail = NULL;
+ return true;
}
- cursor = namelist_match (file_name, length, false);
+ cursor = namelist_match (file_name, length);
if (cursor)
{
if (!(ISSLASH (file_name[cursor->length]) && recursion_option)
if (starting_file_option)
{
free (namelist);
- namelist = 0;
- nametail = &namelist;
+ namelist = NULL;
+ nametail = NULL;
}
chdir_do (cursor->change_dir);
{
name_gather (); /* read one more */
if (namelist->found_count)
- return 0;
+ return false;
}
else
- return 0;
+ return false;
}
}
struct name const *cursor;
size_t len;
- if (test_label_option)
- return true;
if (!p->file_name || occurrence_option == 0 || p->had_trailing_slash)
return false;
len = strlen (p->file_name);
for (cursor = namelist; cursor; cursor = cursor->next)
{
- if (cursor->matching_flags /* FIXME: check this */
- || (!WASFOUND (cursor) && cursor->name[0])
+ if ((cursor->name[0] && !WASFOUND (cursor))
|| (len >= cursor->length && ISSLASH (p->file_name[cursor->length])))
return false;
}
return true;
}
-static inline int
-is_pattern (const char *string)
-{
- return strchr (string, '*') || strchr (string, '[') || strchr (string, '?');
-}
-
-static void
+static int
regex_usage_warning (const char *name)
{
static int warned_once = 0;
- if (warn_regex_usage && is_pattern (name))
+ if (warn_regex_usage && fnmatch_pattern_has_wildcards (name, 0))
{
warned_once = 1;
WARN ((0, 0,
- /* TRANSLATORS: The following three msgids form a single sentence.
- */
- _("Pattern matching characters used in file names. Please,")));
+ _("Pattern matching characters used in file names")));
WARN ((0, 0,
- _("use --wildcards to enable pattern matching, or --no-wildcards to")));
- WARN ((0, 0,
- _("suppress this warning.")));
+ _("Use --wildcards to enable pattern matching,"
+ " or --no-wildcards to suppress this warning")));
}
+ return warned_once;
}
/* Print the names of things in the namelist that were not matched. */
if (!WASFOUND (cursor) && cursor->name[0])
{
regex_usage_warning (cursor->name);
- if (cursor->found_count == 0)
- ERROR ((0, 0, _("%s: Not found in archive"),
- quotearg_colon (cursor->name)));
- else
- ERROR ((0, 0, _("%s: Required occurrence not found in archive"),
- quotearg_colon (cursor->name)));
+ ERROR ((0, 0,
+ (cursor->found_count == 0) ?
+ _("%s: Not found in archive") :
+ _("%s: Required occurrence not found in archive"),
+ quotearg_colon (cursor->name)));
}
/* Don't bother freeing the name list; we're about to exit. */
- namelist = 0;
- nametail = &namelist;
+ namelist = NULL;
+ nametail = NULL;
if (same_order_option)
{
}
}
}
+
+void
+label_notfound (void)
+{
+ struct name const *cursor;
+
+ if (!namelist)
+ return;
+
+ for (cursor = namelist; cursor; cursor = cursor->next)
+ if (WASFOUND (cursor))
+ return;
+
+ if (verbose_option)
+ error (0, 0, _("Archive label mismatch"));
+ set_exit_status (TAREXIT_DIFFERS);
+
+ for (cursor = namelist; cursor; cursor = cursor->next)
+ {
+ if (regex_usage_warning (cursor->name))
+ break;
+ }
+
+ /* Don't bother freeing the name list; we're about to exit. */
+ namelist = NULL;
+ nametail = NULL;
+
+ if (same_order_option)
+ {
+ const char *name;
+
+ while ((name = name_next (1)) != NULL
+ && regex_usage_warning (name) == 0)
+ ;
+ }
+}
\f
/* Sorting name lists. */
-/* Sort linked LIST of names, of given LENGTH, using COMPARE to order
- names. Return the sorted list. Apart from the type `struct name'
- and the definition of SUCCESSOR, this is a generic list-sorting
- function, but it's too painful to make it both generic and portable
+/* Sort *singly* linked LIST of names, of given LENGTH, using COMPARE
+ to order names. Return the sorted list. Note that after calling
+ this function, the `prev' links in list elements are messed up.
+
+ Apart from the type `struct name' and the definition of SUCCESSOR,
+ this is a generic list-sorting function, but it's too painful to
+ make it both generic and portable
in C. */
static struct name *
-merge_sort (struct name *list, int length,
- int (*compare) (struct name const*, struct name const*))
+merge_sort_sll (struct name *list, int length,
+ int (*compare) (struct name const*, struct name const*))
{
struct name *first_list;
struct name *second_list;
second_list = SUCCESSOR (cursor);
SUCCESSOR (cursor) = 0;
- first_list = merge_sort (first_list, first_length, compare);
- second_list = merge_sort (second_list, second_length, compare);
+ first_list = merge_sort_sll (first_list, first_length, compare);
+ second_list = merge_sort_sll (second_list, second_length, compare);
merge_point = &result;
while (first_list && second_list)
#undef SUCCESSOR
}
+/* Sort doubly linked LIST of names, of given LENGTH, using COMPARE
+ to order names. Return the sorted list. */
+static struct name *
+merge_sort (struct name *list, int length,
+ int (*compare) (struct name const*, struct name const*))
+{
+ struct name *head, *p, *prev;
+ head = merge_sort_sll (list, length, compare);
+ /* Fixup prev pointers */
+ for (prev = NULL, p = head; p; prev = p, p = p->next)
+ p->prev = prev;
+ return head;
+}
+
/* A comparison function for sorting names. Put found names last;
break ties by string comparison. */
static int
-compare_names (struct name const *n1, struct name const *n2)
+compare_names_found (struct name const *n1, struct name const *n2)
{
- int found_diff = WASFOUND(n2) - WASFOUND(n1);
+ int found_diff = WASFOUND (n2) - WASFOUND (n1);
return found_diff ? found_diff : strcmp (n1->name, n2->name);
}
+
+/* Simple comparison by names. */
+static int
+compare_names (struct name const *n1, struct name const *n2)
+{
+ return strcmp (n1->name, n2->name);
+}
+
\f
/* Add all the dirs under NAME, which names a directory, to the namelist.
If any of the files is a directory, recurse on the subdirectory.
- DEVICE is the device not to leave, if the -l option is specified. */
+ DEVICE is the device not to leave, if the -l option is specified.
+ CMDLINE is true, if the NAME appeared on the command line. */
static void
-add_hierarchy_to_namelist (struct name *name, dev_t device)
+add_hierarchy_to_namelist (struct name *name, dev_t device, bool cmdline)
{
- char *file_name = name->name;
- char *buffer = get_directory_contents (file_name, device);
-
- if (! buffer)
- name->dir_contents = "\0\0\0\0";
- else
+ const char *buffer;
+
+ name_fill_directory (name, device, cmdline);
+ buffer = directory_contents (name->directory);
+ if (buffer)
{
+ struct name *child_head = NULL, *child_tail = NULL;
size_t name_length = name->length;
size_t allocated_length = (name_length >= NAME_FIELD_SIZE
? name_length + NAME_FIELD_SIZE
: NAME_FIELD_SIZE);
char *namebuf = xmalloc (allocated_length + 1);
/* FIXME: + 2 above? */
- char *string;
+ const char *string;
size_t string_length;
int change_dir = name->change_dir;
- name->dir_contents = buffer;
- strcpy (namebuf, file_name);
+ strcpy (namebuf, name->name);
if (! ISSLASH (namebuf[name_length - 1]))
{
namebuf[name_length++] = '/';
namebuf = xrealloc (namebuf, allocated_length + 1);
}
strcpy (namebuf + name_length, string + 1);
- np = addname (namebuf, change_dir);
- np->explicit = 0;
- add_hierarchy_to_namelist (np, device);
+ np = addname (namebuf, change_dir, false, name);
+ if (!child_head)
+ child_head = np;
+ else
+ child_tail->sibling = np;
+ child_tail = np;
+ add_hierarchy_to_namelist (np, device, false);
}
}
free (namebuf);
+ name->child = child_head;
}
}
\f
+/* Auxiliary functions for hashed table of struct name's. */
+
+static size_t
+name_hash (void const *entry, size_t n_buckets)
+{
+ struct name const *name = entry;
+ return hash_string (name->caname, n_buckets);
+}
+
+/* Compare two directories for equality of their names. */
+static bool
+name_compare (void const *entry1, void const *entry2)
+{
+ struct name const *name1 = entry1;
+ struct name const *name2 = entry2;
+ return strcmp (name1->caname, name2->caname) == 0;
+}
+
+\f
+/* Rebase `name' member of CHILD and all its siblings to
+ the new PARENT. */
+static void
+rebase_child_list (struct name *child, struct name *parent)
+{
+ size_t old_prefix_len = child->parent->length;
+ size_t new_prefix_len = parent->length;
+ char *new_prefix = parent->name;
+
+ for (; child; child = child->sibling)
+ {
+ size_t size = child->length - old_prefix_len + new_prefix_len;
+ char *newp = xmalloc (size + 1);
+ strcpy (newp, new_prefix);
+ strcat (newp, child->name + old_prefix_len);
+ free (child->name);
+ child->name = newp;
+ child->length = size;
+
+ rebase_directory (child->directory,
+ child->parent->name, old_prefix_len,
+ new_prefix, new_prefix_len);
+ }
+}
+
/* Collect all the names from argv[] (or whatever), expand them into a
directory tree, and sort them. This gets only subdirectories, not
all files. */
collect_and_sort_names (void)
{
struct name *name;
- struct name *next_name;
+ struct name *next_name, *prev_name = NULL;
int num_names;
struct stat statbuf;
-
+ Hash_table *nametab;
+
name_gather ();
- if (listed_incremental_option)
- read_directory_file ();
-
if (!namelist)
- addname (".", 0);
+ addname (".", 0, false, NULL);
- for (name = namelist; name; name = next_name)
+ if (listed_incremental_option)
{
- next_name = name->next;
- if (name->found_count || name->dir_contents)
+ switch (chdir_count ())
+ {
+ case 0:
+ break;
+
+ case 1:
+ if (namelist->change_dir == 0)
+ USAGE_ERROR ((0, 0,
+ _("Using -C option inside file list is not "
+ "allowed with --listed-incremental")));
+ break;
+
+ default:
+ USAGE_ERROR ((0, 0,
+ _("Only one -C option is allowed with "
+ "--listed-incremental")));
+ }
+
+ read_directory_file ();
+ }
+
+ num_names = 0;
+ for (name = namelist; name; name = name->next, num_names++)
+ {
+ if (name->found_count || name->directory)
continue;
if (name->matching_flags & EXCLUDE_WILDCARDS)
/* NOTE: EXCLUDE_ANCHORED is not relevant here */
/* FIXME: just skip regexps for now */
continue;
chdir_do (name->change_dir);
+
if (name->name[0] == 0)
continue;
if (S_ISDIR (statbuf.st_mode))
{
name->found_count++;
- add_hierarchy_to_namelist (name, statbuf.st_dev);
+ add_hierarchy_to_namelist (name, statbuf.st_dev, true);
}
}
- num_names = 0;
- for (name = namelist; name; name = name->next)
- num_names++;
namelist = merge_sort (namelist, num_names, compare_names);
- for (name = namelist; name; name = name->next)
- name->found_count = 0;
+ num_names = 0;
+ nametab = hash_initialize (0, 0,
+ name_hash,
+ name_compare, NULL);
+ for (name = namelist; name; name = next_name)
+ {
+ next_name = name->next;
+ name->caname = normalize_filename (name->name);
+ if (prev_name)
+ {
+ struct name *p = hash_lookup (nametab, name);
+ if (p)
+ {
+ /* Keep the one listed in the command line */
+ if (!name->parent)
+ {
+ if (p->child)
+ rebase_child_list (p->child, name);
+ /* FIXME: remove_directory (p->caname); ? */
+ remname (p);
+ free_name (p);
+ num_names--;
+ }
+ else
+ {
+ if (name->child)
+ rebase_child_list (name->child, p);
+ /* FIXME: remove_directory (name->caname); ? */
+ remname (name);
+ free_name (name);
+ continue;
+ }
+ }
+ }
+ name->found_count = 0;
+ if (!hash_insert (nametab, name))
+ xalloc_die ();
+ prev_name = name;
+ num_names++;
+ }
+ nametail = prev_name;
+ hash_free (nametab);
+
+ namelist = merge_sort (namelist, num_names, compare_names_found);
if (listed_incremental_option)
{
for (name = namelist; name && name->name[0] == 0; name++)
;
if (name)
- name->dir_contents = append_incremental_renames (name->dir_contents);
+ append_incremental_renames (name->directory);
}
}
1. It returns a pointer to the name it matched, and doesn't set FOUND
in structure. The caller will have to do that if it wants to.
2. If the namelist is empty, it returns null, unlike name_match, which
- returns TRUE.
- 3. The second argument (EXACT) controls matching algorithm. If it
- is TRUE, the exact matching is used. However, regular expressions are
- always matched as such, no matter what the value of EXACT is. */
+ returns TRUE. */
struct name *
-name_scan (const char *file_name, bool exact)
+name_scan (const char *file_name)
{
size_t length = strlen (file_name);
while (1)
{
- struct name *cursor = namelist_match (file_name, length, exact);
+ struct name *cursor = namelist_match (file_name, length);
if (cursor)
return cursor;
find and return all the non-found names in the namelist. */
struct name *gnu_list_name;
-char *
-name_from_list (void)
+struct name const *
+name_from_list ()
{
if (!gnu_list_name)
gnu_list_name = namelist;
{
gnu_list_name->found_count++;
chdir_do (gnu_list_name->change_dir);
- return gnu_list_name->name;
+ return gnu_list_name;
}
- return 0;
+ return NULL;
}
void
{
return excluded_file_name (excluded, name + FILE_SYSTEM_PREFIX_LEN (name));
}
-\f
-/* Names to avoid dumping. */
-static Hash_table *avoided_name_table;
-
-/* Remember to not archive NAME. */
-void
-add_avoided_name (char const *name)
-{
- hash_string_insert (&avoided_name_table, name);
-}
-
-/* Should NAME be avoided when archiving? */
-bool
-is_avoided_name (char const *name)
-{
- return hash_string_lookup (avoided_name_table, name);
-}
-
\f
static Hash_table *individual_file_table;
register_individual_file (char const *name)
{
struct stat st;
-
+
if (deref_stat (dereference_option, name, &st) != 0)
return; /* Will be complained about later */
if (S_ISDIR (st.st_mode))
return;
-
+
hash_string_insert (&individual_file_table, name);
}
if (p[0] == '.' && p[1] == '.' && (ISSLASH (p[2]) || !p[2]))
return 1;
- do
+ while (! ISSLASH (*p))
{
if (! *p++)
return 0;
}
- while (! ISSLASH (*p));
}
}
projects / chaz / tar / blobdiff