TEARDOWN()
{
int i;
for(i = 0; i < lwin.list_rows; i++)
free(lwin.dir_entry[i].name);
dynarray_free(lwin.dir_entry);
for(i = 0; i < rwin.list_rows; i++)
free(rwin.dir_entry[i].name);
dynarray_free(rwin.dir_entry);
}
TEARDOWN()
{
int i;
update_string(&cfg.shell, NULL);
for(i = 0; i < lwin.list_rows; i++)
free(lwin.dir_entry[i].name);
dynarray_free(lwin.dir_entry);
for(i = 0; i < rwin.list_rows; i++)
free(rwin.dir_entry[i].name);
dynarray_free(rwin.dir_entry);
}
/* Composes two views containing only files that are unique to each of them.
* Assumes that both lists are sorted by id. */
static void
make_unique_lists(entries_t curr, entries_t other)
{
int i, j = 0;
flist_custom_start(curr_view, "unique");
flist_custom_start(other_view, "unique");
for(i = 0; i < other.nentries; ++i)
{
const int id = other.entries[i].id;
while(j < curr.nentries && curr.entries[j].id < id)
{
flist_custom_put(curr_view, &curr.entries[j]);
++j;
}
if(j >= curr.nentries || curr.entries[j].id != id)
{
flist_custom_put(other_view, &other.entries[i]);
continue;
}
while(j < curr.nentries && curr.entries[j].id == id)
{
free_dir_entry(curr_view, &curr.entries[j++]);
}
while(i < other.nentries && other.entries[i].id == id)
{
free_dir_entry(other_view, &other.entries[i++]);
}
--i;
}
/* Entries' data has been moved out of them or freed, so need to free only the
* lists. */
dynarray_free(curr.entries);
dynarray_free(other.entries);
(void)flist_custom_finish(curr_view, CV_REGULAR, 1);
(void)flist_custom_finish(other_view, CV_REGULAR, 1);
curr_view->list_pos = 0;
other_view->list_pos = 0;
ui_view_schedule_redraw(curr_view);
ui_view_schedule_redraw(other_view);
}
static void algorithm_instance_free(algorithm_instance_t * instance)
{
if (instance) {
dynarray_free(instance->events, (ELEMENT_FREE) event_free);
free(instance);
}
}
void
sort_view(view_t *v)
{
dir_entry_t *unsorted_list;
if(v->sort[0] > SK_LAST)
{
/* Completely skip sorting if primary key isn't set. */
return;
}
view = v;
view_sort = v->sort;
view_sort_groups = v->sort_groups;
custom_view = flist_custom_active(v);
if(!custom_view || !cv_tree(v->custom.type))
{
/* Tree sorting works fine for flat list, but requires a bit more
* resources, so skip it. */
sort_sequence(&v->dir_entry[0], v->list_rows);
return;
}
/* When local filter isn't empty, parent directories disappear and sorting
* stops being aware of tree structure to some degree. Perform one more round
* of stable sorting of origins to group child nodes. */
if(!filter_is_empty(&v->local_filter.filter))
{
flist_custom_uncompress_tree(v);
}
unsorted_list = v->dir_entry;
v->dir_entry = dynarray_extend(NULL, v->list_rows*sizeof(*v->dir_entry));
if(v->dir_entry != NULL)
{
sort_tree_slice(&v->dir_entry[0], unsorted_list, v->list_rows, 1);
}
else
{
/* Just do nothing on memory error. */
v->dir_entry = unsorted_list;
unsorted_list = NULL;
}
if(filter_is_empty(&v->local_filter.filter))
{
dynarray_free(unsorted_list);
}
else
{
filters_drop_temporaries(v, unsorted_list);
}
}
/* Finishes filtering process and frees associated resources. */
static void
local_filter_finish(view_t *view)
{
dynarray_free(view->local_filter.unfiltered);
free(view->local_filter.saved);
view->local_filter.in_progress = 0;
free(view->local_filter.poshist);
view->local_filter.poshist = NULL;
view->local_filter.poshist_len = 0U;
}
static void
free_view(FileView *view)
{
int i;
for(i = 0; i < view->list_rows; ++i)
{
free(view->dir_entry[i].name);
}
dynarray_free(view->dir_entry);
}
static void
teardown_view(FileView *view)
{
int i;
for(i = 0; i < view->list_rows; ++i)
{
free_dir_entry(view, &view->dir_entry[i]);
}
dynarray_free(view->dir_entry);
view->list_rows = 0;
view->selected_files = 0;
}
TEARDOWN()
{
int i;
reset_status(&cfg);
for(i = 0; i < lwin.list_rows; ++i)
{
free_dir_entry(&lwin, &lwin.dir_entry[i]);
}
dynarray_free(lwin.dir_entry);
}
void
view_teardown(FileView *view)
{
int i;
for(i = 0; i < view->list_rows; ++i)
{
free_dir_entry(view, &view->dir_entry[i]);
}
dynarray_free(view->dir_entry);
for(i = 0; i < view->custom.entry_count; ++i)
{
free_dir_entry(view, &view->custom.entries[i]);
}
dynarray_free(view->custom.entries);
filter_dispose(&view->local_filter.filter);
filter_dispose(&view->auto_filter);
filter_dispose(&view->manual_filter);
}
/***********************************************************
* 功能: 释放所有节数据
**********************************************************/
void free_sections()
{
int i;
Section *sec;
for(i = 0; i < sections.count; i++)
{
sec = (Section*)sections.data[i];
if(sec->hashtab != NULL)
free(sec->hashtab);
free(sec->data);
}
dynarray_free(§ions);
}
static void
free_view(FileView *view)
{
int i;
for(i = 0; i < view->list_rows; ++i)
{
free(view->dir_entry[i].name);
}
dynarray_free(view->dir_entry);
filter_dispose(&view->local_filter.filter);
filter_dispose(&view->manual_filter);
filter_dispose(&view->auto_filter);
}
void network_free(network_t * network)
{
if (network) {
dynarray_free(network->probes, (ELEMENT_FREE) probe_free);
close(network->timerfd);
sniffer_free(network->sniffer);
queue_free(network->sendq, (ELEMENT_FREE) probe_free);
queue_free(network->recvq, (ELEMENT_FREE) probe_free);
socketpool_free(network->socketpool);
#ifdef USE_SCHEDULING
probe_group_free(network->scheduled_probes);
#endif
free(network);
}
}
TEARDOWN()
{
int i;
update_string(&cfg.shell, NULL);
stats_update_shell_type("/bin/sh");
for(i = 0; i < lwin.list_rows; ++i)
{
free_dir_entry(&lwin, &lwin.dir_entry[i]);
}
dynarray_free(lwin.dir_entry);
ft_reset(0);
update_string(&cfg.vi_command, NULL);
}
void
if_free(interface_t * * if_p_p)
{
interface_t * if_p;
if (if_p_p == NULL) {
return;
}
if_p = *if_p_p;
if (if_p == NULL) {
return;
}
dynarray_free(&if_p->inet);
free(if_p);
*if_p_p = NULL;
return;
}
void
ifl_free(interface_list_t * * iflist)
{
if (iflist != NULL && *iflist != NULL) {
int i;
interface_list_t * list_p = *iflist;
for (i = 0; i < list_p->count; i++) {
dynarray_free(&list_p->list[i].inet);
}
if (list_p->list)
free(list_p->list);
free(list_p);
*iflist = NULL;
}
return;
}
void
local_filter_cancel(view_t *view)
{
if(!view->local_filter.in_progress)
{
return;
}
(void)filter_set(&view->local_filter.filter, view->local_filter.saved);
dynarray_free(view->dir_entry);
view->dir_entry = NULL;
view->list_rows = 0;
update_filtering_lists(view, 1, 1);
local_filter_finish(view);
}
void
view_teardown(FileView *view)
{
int i;
for(i = 0; i < view->list_rows; ++i)
{
free_dir_entry(view, &view->dir_entry[i]);
}
dynarray_free(view->dir_entry);
filter_dispose(&view->local_filter.filter);
filter_dispose(&view->manual_filter);
filter_dispose(&view->auto_filter);
fswatch_free(view->watch);
view->watch = NULL;
}
STATIC void
DHCPv6SocketReleaseGlobals(DHCPv6SocketGlobalsRef * globals_p)
{
DHCPv6SocketGlobalsRef globals;
if (globals_p == NULL) {
return;
}
globals = *globals_p;
if (globals == NULL) {
return;
}
*globals_p = NULL;
dynarray_free(&globals->sockets);
FDCalloutRelease(&globals->read_fd);
timer_callout_free(&globals->timer_callout);
bzero(globals, sizeof(*globals));
free(globals);
return;
}
void
filters_drop_temporaries(view_t *view, dir_entry_t entries[])
{
/* This is basically a simplified version of update_filtering_lists(). Not
* sure if it's worth merging them. */
int i;
size_t list_size = 0U;
for(i = 0; i < view->list_rows; ++i)
{
dir_entry_t *new_entry;
dir_entry_t *const entry = &view->dir_entry[i];
/* The tag field links to position of nodes passed through filter in the
* list of visible files. Removed nodes have -1. */
entry->tag = -1;
if(entry->temporary)
{
fentry_free(view, entry);
continue;
}
new_entry = add_dir_entry(&entries, &list_size, entry);
if(new_entry != NULL)
{
entry->tag = list_size - 1U;
/* We basically grow the tree node by node while performing
* reparenting. */
reparent_tree_node(entry, new_entry);
}
}
dynarray_free(view->dir_entry);
view->dir_entry = entries;
view->list_rows = list_size;
}
static void probe_layers_free(probe_t * probe) {
dynarray_free(probe->layers, (ELEMENT_FREE) layer_free);
}
int
compare_one_pane(FileView *view, CompareType ct, ListType lt, int skip_empty)
{
int i, dup_id;
FileView *other = (view == curr_view) ? other_view : curr_view;
const char *const title = (lt == LT_ALL) ? "compare"
: (lt == LT_DUPS) ? "dups" : "nondups";
int next_id = 1;
entries_t curr;
trie_t *trie = trie_create();
ui_cancellation_reset();
ui_cancellation_enable();
curr = make_diff_list(trie, view, &next_id, ct, skip_empty, 0);
ui_cancellation_disable();
trie_free_with_data(trie, &free_compare_records);
/* Clear progress message displayed by make_diff_list(). */
ui_sb_quick_msg_clear();
if(ui_cancellation_requested())
{
free_dir_entries(view, &curr.entries, &curr.nentries);
status_bar_message("Comparison has been cancelled");
return 1;
}
qsort(curr.entries, curr.nentries, sizeof(*curr.entries), &id_sorter);
flist_custom_start(view, title);
dup_id = -1;
next_id = 0;
for(i = 0; i < curr.nentries; ++i)
{
dir_entry_t *entry = &curr.entries[i];
if(lt == LT_ALL)
{
flist_custom_put(view, entry);
continue;
}
if(entry->id == dup_id)
{
put_or_free(view, entry, next_id, lt == LT_DUPS);
continue;
}
dup_id = (i < curr.nentries - 1 && entry[0].id == entry[1].id)
? entry->id
: -1;
if(entry->id == dup_id)
{
put_or_free(view, entry, ++next_id, lt == LT_DUPS);
continue;
}
put_or_free(view, entry, next_id, lt == LT_UNIQUE);
}
/* Entries' data has been moved out of them or freed, so need to free only the
* list. */
dynarray_free(curr.entries);
if(flist_custom_finish(view, lt == LT_UNIQUE ? CV_REGULAR : CV_COMPARE,
0) != 0)
{
show_error_msg("Comparison", "No results to display");
return 0;
}
/* Leave the other pane, if it's in the CV_DIFF mode, two panes are needed for
* this. */
if(other->custom.type == CV_DIFF)
{
cd_updir(other, 1);
}
view->list_pos = 0;
ui_view_schedule_redraw(view);
return 0;
}
/* Composes side-by-side comparison of files in two views. */
static void
fill_side_by_side(entries_t curr, entries_t other, int group_paths)
{
enum { UP, LEFT, DIAG };
int i, j;
/* Describes results of solving sub-problems. */
int (*d)[other.nentries + 1] =
reallocarray(NULL, curr.nentries + 1, sizeof(*d));
/* Describes paths (backtracking handles ambiguity badly). */
char (*p)[other.nentries + 1] =
reallocarray(NULL, curr.nentries + 1, sizeof(*p));
for(i = 0; i <= curr.nentries; ++i)
{
for(j = 0; j <= other.nentries; ++j)
{
if(i == 0)
{
d[i][j] = j;
p[i][j] = LEFT;
}
else if(j == 0)
{
d[i][j] = i;
p[i][j] = UP;
}
else
{
const dir_entry_t *centry = &curr.entries[curr.nentries - i];
const dir_entry_t *oentry = &other.entries[other.nentries - j];
d[i][j] = MIN(d[i - 1][j] + 1, d[i][j - 1] + 1);
p[i][j] = d[i][j] == d[i - 1][j] + 1 ? UP : LEFT;
if((centry->id == oentry->id ||
(group_paths && stroscmp(centry->name, oentry->name) == 0)) &&
d[i - 1][j - 1] <= d[i][j])
{
d[i][j] = d[i - 1][j - 1];
p[i][j] = DIAG;
}
}
}
}
i = curr.nentries;
j = other.nentries;
while(i != 0 || j != 0)
{
switch(p[i][j])
{
dir_entry_t *e;
case UP:
e = &curr.entries[curr.nentries - 1 - --i];
flist_custom_put(curr_view, e);
flist_custom_add_separator(other_view, e->id);
break;
case LEFT:
e = &other.entries[other.nentries - 1 - --j];
flist_custom_put(other_view, e);
flist_custom_add_separator(curr_view, e->id);
break;
case DIAG:
flist_custom_put(curr_view, &curr.entries[curr.nentries - 1 - --i]);
flist_custom_put(other_view, &other.entries[other.nentries - 1 - --j]);
break;
}
}
free(d);
free(p);
/* Entries' data has been moved out of them, so need to free only the
* lists. */
dynarray_free(curr.entries);
dynarray_free(other.entries);
}
void
DHCPLeaseListFree(DHCPLeaseListRef list_p)
{
dynarray_free(list_p);
}
