/* 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); }