/* Makes sorted by path list of entries that. The trie is used to keep track of
* identical files. With non-zero dups_only, new files aren't added to the
* trie. */
static entries_t
make_diff_list(trie_t *trie, FileView *view, int *next_id, CompareType ct,
int skip_empty, int dups_only)
{
int i;
strlist_t files = {};
entries_t r = {};
int last_progress = 0;
show_progress("Listing...", 0);
if(flist_custom_active(view) &&
ONE_OF(view->custom.type, CV_REGULAR, CV_VERY))
{
list_view_entries(view, &files);
}
else
{
list_files_recursively(flist_get_dir(view), view->hide_dot, &files);
}
show_progress("Querying...", 0);
for(i = 0; i < files.nitems && !ui_cancellation_requested(); ++i)
{
char progress_msg[128];
int progress;
int existing_id;
char *fingerprint;
const char *const path = files.items[i];
dir_entry_t *const entry = entry_list_add(view, &r.entries, &r.nentries,
path);
if(skip_empty && entry->size == 0)
{
free_dir_entry(view, entry);
--r.nentries;
continue;
}
fingerprint = get_file_fingerprint(path, entry, ct);
/* In case we couldn't obtain fingerprint (e.g., comparing by contents and
* files isn't readable), ignore the file and keep going. */
if(is_null_or_empty(fingerprint))
{
free(fingerprint);
free_dir_entry(view, entry);
--r.nentries;
continue;
}
entry->tag = i;
if(get_file_id(trie, path, fingerprint, &existing_id, ct))
{
entry->id = existing_id;
}
else if(dups_only)
{
entry->id = -1;
}
else
{
entry->id = *next_id;
++*next_id;
put_file_id(trie, path, fingerprint, entry->id, ct);
}
free(fingerprint);
progress = (i*100)/files.nitems;
if(progress != last_progress)
{
last_progress = progress;
snprintf(progress_msg, sizeof(progress_msg), "Querying... %d (% 2d%%)", i,
progress);
show_progress(progress_msg, -1);
}
}
free_string_array(files.items, files.nitems);
return r;
}
static int
add_entry(struct archive_match *a, int flag,
struct archive_entry *entry)
{
struct match_file *f;
const void *pathname;
int r;
f = calloc(1, sizeof(*f));
if (f == NULL)
return (error_nomem(a));
#if defined(_WIN32) && !defined(__CYGWIN__)
pathname = archive_entry_pathname_w(entry);
if (pathname == NULL) {
free(f);
archive_set_error(&(a->archive), EINVAL, "pathname is NULL");
return (ARCHIVE_FAILED);
}
archive_mstring_copy_wcs(&(f->pathname), pathname);
a->exclusion_tree.rbt_ops = &rb_ops_wcs;
#else
(void)rb_ops_wcs;
pathname = archive_entry_pathname(entry);
if (pathname == NULL) {
free(f);
archive_set_error(&(a->archive), EINVAL, "pathname is NULL");
return (ARCHIVE_FAILED);
}
archive_mstring_copy_mbs(&(f->pathname), pathname);
a->exclusion_tree.rbt_ops = &rb_ops_mbs;
#endif
f->flag = flag;
f->mtime_sec = archive_entry_mtime(entry);
f->mtime_nsec = archive_entry_mtime_nsec(entry);
f->ctime_sec = archive_entry_ctime(entry);
f->ctime_nsec = archive_entry_ctime_nsec(entry);
r = __archive_rb_tree_insert_node(&(a->exclusion_tree), &(f->node));
if (!r) {
struct match_file *f2;
/* Get the duplicated file. */
f2 = (struct match_file *)__archive_rb_tree_find_node(
&(a->exclusion_tree), pathname);
/*
* We always overwrite comparison condition.
* If you do not want to overwrite it, you should not
* call archive_match_exclude_entry(). We cannot know
* what behavior you really expect since overwriting
* condition might be different with the flag.
*/
if (f2 != NULL) {
f2->flag = f->flag;
f2->mtime_sec = f->mtime_sec;
f2->mtime_nsec = f->mtime_nsec;
f2->ctime_sec = f->ctime_sec;
f2->ctime_nsec = f->ctime_nsec;
}
/* Release the duplicated file. */
archive_mstring_clean(&(f->pathname));
free(f);
return (ARCHIVE_OK);
}
entry_list_add(&(a->exclusion_entry_list), f);
a->setflag |= TIME_IS_SET;
return (ARCHIVE_OK);
}
Symbol Overload::solve(
ObjectList<Symbol> candidate_functions,
Type implicit_argument_type,
ObjectList<Type> argument_types,
const std::string filename,
int line,
bool &valid,
ObjectList<Symbol>& viable_functions,
ObjectList<Symbol>& argument_conversor)
{
valid = false;
// Try hard to not to do useless work
if (candidate_functions.empty())
{
return Symbol(NULL);
}
scope_entry_list_t* first_candidate_list = NULL;
// Build the candidates list
for (ObjectList<Symbol>::iterator it = candidate_functions.begin();
it != candidate_functions.end();
it++)
{
Symbol sym(*it);
first_candidate_list = entry_list_add(first_candidate_list, sym.get_internal_symbol());
}
// Build the type array
unsigned int i = argument_types.size();
type_t** argument_types_array = new type_t*[argument_types.size() + 1];
argument_types_array[0] = implicit_argument_type.get_internal_type();
for (i = 0; i < argument_types.size(); i++)
{
argument_types_array[i+1] = argument_types[i].get_internal_type();
}
// Now we need a decl_context_t but we were not given any explicitly,
// use the one of the first candidate
decl_context_t decl_context = candidate_functions[0].get_scope().get_decl_context();
// Unfold and mix!
scope_entry_list_t* candidate_list = NULL;
candidate_list = unfold_and_mix_candidate_functions(first_candidate_list,
NULL /* builtins */,
&argument_types_array[1], argument_types.size(),
decl_context,
uniquestr(filename.c_str()), line,
NULL /* explicit template arguments */);
{
ObjectList<Symbol> list;
Scope::convert_to_vector(candidate_list, list);
viable_functions.append(list);
}
candidate_t* candidate_set = NULL;
scope_entry_list_iterator_t* it = NULL;
for (it = entry_list_iterator_begin(candidate_list);
!entry_list_iterator_end(it);
entry_list_iterator_next(it))
{
scope_entry_t* entry = entry_list_iterator_current(it);
if (entry->entity_specs.is_member)
{
candidate_set = add_to_candidate_set(candidate_set,
entry,
argument_types.size() + 1,
argument_types_array);
}
else
{
candidate_set = add_to_candidate_set(candidate_set,
entry,
argument_types.size(),
argument_types_array + 1);
}
}
entry_list_iterator_free(it);
// We also need a scope_entry_t** for holding the conversor argument
scope_entry_t** conversor_per_argument = new scope_entry_t*[argument_types.size() + 1];
// Now invoke all the machinery
scope_entry_t* entry_result =
solve_overload(candidate_set,
decl_context,
uniquestr(filename.c_str()), line,
conversor_per_argument);
if (entry_result != NULL)
{
valid = true;
// Store the arguments
argument_conversor.clear();
for (i = 0; i < argument_types.size(); i++)
{
argument_conversor.append(Symbol(conversor_per_argument[i]));
}
}
// Free the conversor per argument
delete[] conversor_per_argument;
// Free the type array
delete[] argument_types_array;
// Free the scope entry list
free_scope_entry_list(candidate_list);
// This one has been allocated above
free_scope_entry_list(first_candidate_list);
return Symbol(entry_result);
}
