+name_match (const char *path)
+{
+ size_t length = strlen (path);
+
+ while (1)
+ {
+ struct name *cursor = namelist;
+
+ if (!cursor)
+ return ! files_from_option;
+
+ if (cursor->fake)
+ {
+ chdir_do (cursor->change_dir);
+ namelist = 0;
+ nametail = &namelist;
+ return ! files_from_option;
+ }
+
+ cursor = namelist_match (path, length);
+ if (cursor)
+ {
+ cursor->found = 1; /* remember it matched */
+ if (starting_file_option)
+ {
+ free (namelist);
+ namelist = 0;
+ nametail = &namelist;
+ }
+ chdir_do (cursor->change_dir);
+
+ /* We got a match. */
+ return 1;
+ }
+
+ /* Filename from archive not found in namelist. If we have the whole
+ namelist here, just return 0. Otherwise, read the next name in and
+ compare it. If this was the last name, namelist->found will remain
+ on. If not, we loop to compare the newly read name. */
+
+ if (same_order_option && namelist->found)
+ {
+ name_gather (); /* read one more */
+ if (namelist->found)
+ return 0;
+ }
+ else
+ return 0;
+ }
+}
+
+/* Print the names of things in the namelist that were not matched. */
+void
+names_notfound (void)
+{
+ struct name const *cursor;
+
+ for (cursor = namelist; cursor; cursor = cursor->next)
+ if (!cursor->found && !cursor->fake)
+ ERROR ((0, 0, _("%s: Not found in archive"),
+ quotearg_colon (cursor->name)));
+
+ /* Don't bother freeing the name list; we're about to exit. */
+ namelist = 0;
+ nametail = &namelist;
+
+ if (same_order_option)
+ {
+ char *name;
+
+ while (name = name_next (1), name)
+ ERROR ((0, 0, _("%s: Not found in archive"),
+ quotearg_colon (name)));
+ }
+}
+\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
+ in C. */
+
+static struct name *
+merge_sort (struct name *list, int length,
+ int (*compare) (struct name const*, struct name const*))
+{
+ struct name *first_list;
+ struct name *second_list;
+ int first_length;
+ int second_length;
+ struct name *result;
+ struct name **merge_point;
+ struct name *cursor;
+ int counter;
+
+# define SUCCESSOR(name) ((name)->next)
+
+ if (length == 1)
+ return list;
+
+ if (length == 2)
+ {
+ if ((*compare) (list, SUCCESSOR (list)) > 0)
+ {
+ result = SUCCESSOR (list);
+ SUCCESSOR (result) = list;
+ SUCCESSOR (list) = 0;
+ return result;
+ }
+ return list;
+ }
+
+ first_list = list;
+ first_length = (length + 1) / 2;
+ second_length = length / 2;
+ for (cursor = list, counter = first_length - 1;
+ counter;
+ cursor = SUCCESSOR (cursor), counter--)
+ continue;
+ 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);
+
+ merge_point = &result;
+ while (first_list && second_list)
+ if ((*compare) (first_list, second_list) < 0)
+ {
+ cursor = SUCCESSOR (first_list);
+ *merge_point = first_list;
+ merge_point = &SUCCESSOR (first_list);
+ first_list = cursor;
+ }
+ else
+ {
+ cursor = SUCCESSOR (second_list);
+ *merge_point = second_list;
+ merge_point = &SUCCESSOR (second_list);
+ second_list = cursor;
+ }
+ if (first_list)
+ *merge_point = first_list;
+ else
+ *merge_point = second_list;
+
+ return result;
+
+#undef SUCCESSOR
+}
+
+/* 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)
+{
+ int found_diff = n2->found - n1->found;
+ return found_diff ? found_diff : strcmp (n1->name, n2->name);
+}
+\f
+/* Add all the dirs under NAME, which names a directory, to the namelist.
+ DIRSIZE is the size of the directory, or -1 if not known.
+ 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. */
+
+static void
+add_hierarchy_to_namelist (struct name *name, off_t dirsize, dev_t device)
+{
+ char *path = name->name;
+ char *buffer = get_directory_contents (path, dirsize, device);
+
+ if (! buffer)
+ name->dir_contents = "\0\0\0\0";
+ else
+ {
+ size_t name_length = name->length;
+ size_t allocated_length = (name_length >= NAME_FIELD_SIZE
+ ? name_length + NAME_FIELD_SIZE
+ : NAME_FIELD_SIZE);
+ char *name_buffer = xmalloc (allocated_length + 1);
+ /* FIXME: + 2 above? */
+ char *string;
+ size_t string_length;
+ int change_dir = name->change_dir;
+
+ name->dir_contents = buffer;
+ strcpy (name_buffer, path);
+ if (name_buffer[name_length - 1] != '/')
+ {
+ name_buffer[name_length++] = '/';
+ name_buffer[name_length] = '\0';
+ }
+
+ for (string = buffer; *string; string += string_length + 1)
+ {
+ string_length = strlen (string);
+ if (*string == 'D')
+ {
+ if (name_length + string_length >= allocated_length)
+ {
+ while (name_length + string_length >= allocated_length)
+ allocated_length += NAME_FIELD_SIZE;
+ name_buffer = xrealloc (name_buffer, allocated_length + 1);