/* Compares two file names according to symbolic link target. Returns standard
* -1, 0, 1 for comparisons. */
static int
compare_targets(const dir_entry_t *f, const dir_entry_t *s)
{
char full_path[PATH_MAX + 1];
char nlink[PATH_MAX + 1], plink[PATH_MAX + 1];
if((f->type == FT_LINK) != (s->type == FT_LINK))
{
/* One of the entries is not a link. */
return (f->type == FT_LINK) ? 1 : -1;
}
if(f->type != FT_LINK)
{
/* Both entries are not symbolic links. */
return 0;
}
/* Both entries are symbolic links. */
get_full_path_of(f, sizeof(full_path), full_path);
if(get_link_target(full_path, nlink, sizeof(nlink)) != 0)
{
return 0;
}
get_full_path_of(s, sizeof(full_path), full_path);
if(get_link_target(full_path, plink, sizeof(plink)) != 0)
{
return 0;
}
return stroscmp(nlink, plink);
}
/* Appends path to the entry to the expanded string. Returns new value of
* expanded string. */
static char *
append_entry(FileView *view, char expanded[], PathType type, dir_entry_t *entry,
int quotes, const char mod[], int for_shell)
{
char path[PATH_MAX];
const char *modified;
switch(type)
{
case PT_NAME:
copy_str(path, sizeof(path), entry->name);
break;
case PT_REL:
get_short_path_of(view, entry, 0, sizeof(path), path);
break;
case PT_FULL:
get_full_path_of(entry, sizeof(path), path);
break;
default:
assert(0 && "Unexpected path type");
path[0] = '\0';
break;
}
modified = apply_mods(path, flist_get_dir(view), mod, for_shell);
expanded = append_path_to_expanded(expanded, quotes, modified);
return expanded;
}
/* Returns non-zero if selection doesn't mix files and directories, otherwise
* zero is returned. */
static int
selection_is_consistent(const FileView *const view)
{
if(view->selected_files > 1)
{
int files = 0, dirs = 0;
int i;
for(i = 0; i < view->list_rows; i++)
{
char full[PATH_MAX];
const dir_entry_t *const curr = &view->dir_entry[i];
if(!curr->selected)
{
continue;
}
get_full_path_of(curr, sizeof(full), full);
if(is_dir_entry(full, curr->type))
{
dirs++;
}
else
{
files++;
}
}
if(dirs > 0 && files > 0)
{
return 0;
}
}
return 1;
}
/* Returns non-zero if selection doesn't mix files and directories, otherwise
* zero is returned. */
static int
selection_is_consistent(FileView *view)
{
int files = 0, dirs = 0;
dir_entry_t *entry;
if(view->selected_files < 2)
{
return 1;
}
entry = NULL;
while(iter_selected_entries(view, &entry))
{
char full[PATH_MAX];
get_full_path_of(entry, sizeof(full), full);
if(is_dir_entry(full, entry->type))
{
++dirs;
}
else
{
++files;
}
}
return (dirs == 0 || files == 0);
}
/* Resolve link target and either navigate inside directory link points to or
* navigate to directory where target is located pointing cursor on
* it (the follow_dirs flag controls behaviour). */
static void
follow_link(FileView *view, int follow_dirs)
{
char *dir, *file;
char full_path[PATH_MAX];
char linkto[PATH_MAX + NAME_MAX];
dir_entry_t *const entry = &curr_view->dir_entry[curr_view->list_pos];
get_full_path_of(entry, sizeof(full_path), full_path);
if(get_link_target_abs(full_path, entry->origin, linkto, sizeof(linkto)) != 0)
{
show_error_msg("Error", "Can't read link.");
return;
}
if(!path_exists(linkto, DEREF))
{
show_error_msg("Broken Link",
"Can't access link destination. It might be broken.");
return;
}
chosp(linkto);
if(is_dir(linkto) && !follow_dirs)
{
dir = strdup(entry->name);
file = NULL;
}
else
{
dir = strdup(linkto);
remove_last_path_component(dir);
file = get_last_path_component(linkto);
}
if(dir[0] != '\0')
{
navigate_to(view, dir);
}
if(file != NULL)
{
const int pos = find_file_pos_in_list(view, file);
if(pos >= 0)
{
flist_set_pos(view, pos);
}
}
free(dir);
}
/* fsdata_traverse() callback that collects names of existing files into a
* list. */
static void
append_valid_nodes(const char name[], int valid, const void *parent_data,
void *data, void *arg)
{
strlist_t *const list = arg;
dir_entry_t *const entry = *(dir_entry_t **)data;
if(valid)
{
char full_path[PATH_MAX];
get_full_path_of(entry, sizeof(full_path), full_path);
list->nitems = add_to_string_array(&list->items, list->nitems, 1,
full_path);
}
}
static void
handle_file(FileView *view, FileHandleExec exec, FileHandleLink follow)
{
char full_path[PATH_MAX];
int executable;
int runnable;
const dir_entry_t *const curr = &view->dir_entry[view->list_pos];
get_full_path_of(curr, sizeof(full_path), full_path);
if(is_dir(full_path) || is_unc_root(view->curr_dir))
{
if(!curr->selected && (curr->type != FT_LINK || follow == FHL_NO_FOLLOW))
{
open_dir(view);
return;
}
}
runnable = is_runnable(view, full_path, curr->type, follow == FHL_FOLLOW);
executable = is_executable(full_path, curr, exec == FHE_NO_RUN, runnable);
if(stats_file_choose_action_set() && (executable || runnable))
{
/* The call below does not return. */
vifm_choose_files(view, 0, NULL);
}
if(executable && !is_dir_entry(full_path, curr->type))
{
execute_file(full_path, exec == FHE_ELEVATE_AND_RUN);
}
else if(runnable)
{
run_selection(view, exec == FHE_NO_RUN);
}
else if(curr->type == FT_LINK)
{
follow_link(view, follow == FHL_FOLLOW);
}
}
/* Fills the list with entries of the view in hierarchical order (pre-order tree
* traversal). */
static void
list_view_entries(const FileView *view, strlist_t *list)
{
int i;
fsdata_t *const tree = fsdata_create(0, 0);
for(i = 0; i < view->list_rows; ++i)
{
if(!fentry_is_dir(&view->dir_entry[i]))
{
char full_path[PATH_MAX];
void *data = &view->dir_entry[i];
get_full_path_of(&view->dir_entry[i], sizeof(full_path), full_path);
fsdata_set(tree, full_path, &data, sizeof(data));
}
}
fsdata_traverse(tree, &append_valid_nodes, list);
fsdata_free(tree);
}
void
dcache_get_of(const dir_entry_t *entry, dcache_result_t *size,
dcache_result_t *nitems)
{
dcache_data_t size_data, nitems_data;
char full_path[PATH_MAX + 1];
get_full_path_of(entry, sizeof(full_path), full_path);
size->value = DCACHE_UNKNOWN;
size->is_valid = 0;
nitems->value = DCACHE_UNKNOWN;
nitems->is_valid = 0;
pthread_mutex_lock(&dcache_size_mutex);
if(fsdata_get(dcache_size, full_path, &size_data, sizeof(size_data)) == 0)
{
size->value = size_data.value;
/* We check strictly for less than to handle scenario when multiple changes
* occurred during the same second. */
size->is_valid = (entry->mtime < size_data.timestamp);
}
pthread_mutex_unlock(&dcache_size_mutex);
pthread_mutex_lock(&dcache_nitems_mutex);
if(fsdata_get(dcache_nitems, full_path, &nitems_data,
sizeof(nitems_data)) == 0)
{
nitems->value = nitems_data.value;
/* We check strictly for less than to handle scenario when multiple changes
* occurred during the same second. */
nitems->is_valid = (entry->mtime < nitems_data.timestamp);
}
pthread_mutex_unlock(&dcache_nitems_mutex);
}
void
quick_view_file(FileView *view)
{
char path[PATH_MAX];
const dir_entry_t *entry;
if(curr_stats.load_stage < 2)
{
return;
}
if(vle_mode_is(VIEW_MODE))
{
return;
}
if(curr_stats.number_of_windows == 1)
{
return;
}
if(draw_abandoned_view_mode())
{
return;
}
ui_view_erase(other_view);
entry = &view->dir_entry[view->list_pos];
get_full_path_of(entry, sizeof(path), path);
switch(view->dir_entry[view->list_pos].type)
{
case FT_CHAR_DEV:
mvwaddstr(other_view->win, LINE, COL, "File is a Character Device");
break;
case FT_BLOCK_DEV:
mvwaddstr(other_view->win, LINE, COL, "File is a Block Device");
break;
#ifndef _WIN32
case FT_SOCK:
mvwaddstr(other_view->win, LINE, COL, "File is a Socket");
break;
#endif
case FT_FIFO:
mvwaddstr(other_view->win, LINE, COL, "File is a Named Pipe");
break;
case FT_LINK:
if(get_link_target_abs(path, entry->origin, path, sizeof(path)) != 0)
{
mvwaddstr(other_view->win, LINE, COL, "Cannot resolve Link");
break;
}
if(!ends_with_slash(path) && is_dir(path))
{
strncat(path, "/", sizeof(path) - strlen(path) - 1);
}
/* break intensionally omitted */
case FT_UNK:
default:
{
const char *viewer;
FILE *fp;
char *const typed_fname = get_typed_fname(path);
viewer = ft_get_viewer(typed_fname);
free(typed_fname);
if(viewer == NULL && is_dir(path))
{
mvwaddstr(other_view->win, LINE, COL, "File is a Directory");
break;
}
if(is_null_or_empty(viewer))
{
fp = os_fopen(path, "rb");
}
else
{
fp = use_info_prog(viewer);
}
if(fp == NULL)
{
mvwaddstr(other_view->win, LINE, COL, "Cannot open file");
break;
}
ui_view_clear(other_view);
wattrset(other_view->win, 0);
view_file(fp, cfg.wrap_quick_view);
fclose(fp);
break;
}
}
refresh_view_win(other_view);
ui_view_title_update(other_view);
}
int
compare_move(FileView *from, FileView *to)
{
char from_path[PATH_MAX], to_path[PATH_MAX];
char *from_fingerprint, *to_fingerprint;
const CompareType ct = from->custom.diff_cmp_type;
dir_entry_t *const curr = &from->dir_entry[from->list_pos];
dir_entry_t *const other = &to->dir_entry[from->list_pos];
if(from->custom.type != CV_DIFF || !from->custom.diff_path_group)
{
status_bar_error("Not in diff mode with path grouping");
return 1;
}
if(curr->id == other->id && !fentry_is_fake(curr) && !fentry_is_fake(other))
{
/* Nothing to do if files are already equal. */
return 0;
}
/* We're going at least to try to update one of views (which might refer to
* the same directory), so schedule a reload. */
ui_view_schedule_reload(from);
ui_view_schedule_reload(to);
if(fentry_is_fake(curr))
{
/* Just remove the other file (it can't be fake entry too). */
return fops_delete_current(to, 1, 0);
}
get_full_path_of(curr, sizeof(from_path), from_path);
get_full_path_of(other, sizeof(to_path), to_path);
if(fentry_is_fake(other))
{
char to_path[PATH_MAX];
char canonical[PATH_MAX];
snprintf(to_path, sizeof(to_path), "%s/%s/%s", flist_get_dir(to),
curr->origin + strlen(flist_get_dir(from)), curr->name);
canonicalize_path(to_path, canonical, sizeof(canonical));
/* Copy current file to position of the other one using relative path with
* different base. */
fops_replace(from, canonical, 0);
/* Update the other entry to not be fake. */
remove_last_path_component(canonical);
replace_string(&other->name, curr->name);
replace_string(&other->origin, canonical);
}
else
{
/* Overwrite file in the other pane with corresponding file from current
* pane. */
fops_replace(from, to_path, 1);
}
/* Obtaining file fingerprint relies on size field of entries, so try to load
* it and ignore if it fails. */
other->size = get_file_size(to_path);
/* Try to update id of the other entry by computing fingerprint of both files
* and checking if they match. */
from_fingerprint = get_file_fingerprint(from_path, curr, ct);
to_fingerprint = get_file_fingerprint(to_path, other, ct);
if(!is_null_or_empty(from_fingerprint) && !is_null_or_empty(to_fingerprint))
{
int match = (strcmp(from_fingerprint, to_fingerprint) == 0);
if(match && ct == CT_CONTENTS)
{
match = files_are_identical(from_path, to_path);
}
if(match)
{
other->id = curr->id;
}
}
free(from_fingerprint);
free(to_fingerprint);
return 0;
}
int
menu_to_custom_view(menu_state_t *m, FileView *view, int very)
{
int i;
char *current = NULL;
const char *const rel_base = get_relative_path_base(m->d, view);
flist_custom_start(view, m->d->title);
for(i = 0; i < m->d->len; ++i)
{
char *path;
int line_num;
/* Skip empty lines. */
if(skip_whitespace(m->d->items[i])[0] == '\0')
{
continue;
}
path = parse_file_spec(m->d->items[i], &line_num, rel_base);
if(path == NULL)
{
continue;
}
flist_custom_add(view, path);
/* Use either exact position or the next path. */
if(i == m->d->pos || (current == NULL && i > m->d->pos))
{
current = path;
continue;
}
free(path);
}
/* If current line and none of the lines below didn't contain valid path, try
* to use file above cursor position. */
if(current == NULL && view->custom.entry_count != 0)
{
char full_path[PATH_MAX];
get_full_path_of(&view->custom.entries[view->custom.entry_count - 1],
sizeof(full_path), full_path);
current = strdup(full_path);
}
if(flist_custom_finish(view, very ? CV_VERY : CV_REGULAR, 0) != 0)
{
free(current);
return 1;
}
if(current != NULL)
{
flist_goto_by_path(view, current);
free(current);
}
return 0;
}
/* Expands macros in the *format string advancing the pointer as it goes. The
* opt represents conditional expression state, should be zero for non-recursive
* calls. Returns newly allocated string, which should be freed by the
* caller. */
static LineWithAttrs
parse_view_macros(view_t *view, const char **format, const char macros[],
int opt)
{
const dir_entry_t *const curr = get_current_entry(view);
LineWithAttrs result = { .line = strdup(""), .attrs = strdup("") };
char c;
int nexpansions = 0;
int has_expander = 0;
if(curr == NULL)
{
return result;
}
while((c = **format) != '\0')
{
size_t width = 0;
int left_align = 0;
char buf[PATH_MAX + 1];
const char *const next = ++*format;
int skip, ok;
if(c != '%' ||
(!char_is_one_of(macros, *next) && !isdigit(*next) &&
(*next != '=' || has_expander)))
{
if(strappendch(&result.line, &result.line_len, c) != 0)
{
break;
}
continue;
}
if(*next == '=')
{
(void)sync_attrs(&result, 0);
if(strappend(&result.line, &result.line_len, "%=") != 0 ||
strappendch(&result.attrs, &result.attrs_len, '=') != 0)
{
break;
}
++*format;
has_expander = 1;
continue;
}
if(*next == '-')
{
left_align = 1;
++*format;
}
while(isdigit(**format))
{
width = width*10 + *(*format)++ - '0';
}
c = *(*format)++;
skip = 0;
ok = 1;
buf[0] = '\0';
switch(c)
{
case 'a':
friendly_size_notation(get_free_space(curr_view->curr_dir), sizeof(buf),
buf);
break;
case 't':
format_entry_name(curr, NF_FULL, sizeof(buf), buf);
break;
case 'T':
if(curr->type == FT_LINK)
{
char full_path[PATH_MAX + 1];
char link_path[PATH_MAX + 1]; //add by sim1
get_full_path_of(curr, sizeof(full_path), full_path);
//mod by sim1 <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
if(get_link_target(full_path, link_path, sizeof(link_path)) != 0)
{
copy_str(buf, sizeof(buf), "Failed to resolve link");
}
else
{
snprintf(buf, sizeof(buf), " -> %s", link_path);
}
//mod by sim1 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
}
break;
case 'f':
get_short_path_of(view, curr, NF_FULL, 0, sizeof(buf), buf);
break;
case 'A':
#ifndef _WIN32
get_perm_string(buf, sizeof(buf), curr->mode);
#else
copy_str(buf, sizeof(buf), attr_str_long(curr->attrs));
#endif
break;
case 'u':
get_uid_string(curr, 0, sizeof(buf), buf);
break;
case 'g':
get_gid_string(curr, 0, sizeof(buf), buf);
break;
case 's':
friendly_size_notation(fentry_get_size(view, curr), sizeof(buf), buf);
break;
//add by sim1 ************************************************
case 'r':
{
char path[PATH_MAX] = {0};
get_full_path_at(view, view->list_pos, sizeof(path), path);
(void)get_rating_string(buf, sizeof(buf), path);
}
break;
case 'n':
{
int nitems = !fentry_is_dir(curr) ? 0 : (int)fentry_get_nitems(view, curr);
snprintf(buf, sizeof(buf), "%d", nitems);
}
break;
//add by sim1 ************************************************
case 'E':
{
uint64_t size = 0U;
typedef int (*iter_f)(view_t *view, dir_entry_t **entry);
/* No current element for visual mode, since it can contain truly
* empty selection when cursor is on ../ directory. */
iter_f iter = vle_mode_is(VISUAL_MODE) ? &iter_selected_entries
: &iter_selection_or_current;
dir_entry_t *entry = NULL;
while(iter(view, &entry))
{
size += fentry_get_size(view, entry);
}
friendly_size_notation(size, sizeof(buf), buf);
}
break;
case 'd':
{
struct tm *tm_ptr = localtime(&curr->mtime);
strftime(buf, sizeof(buf), cfg.time_format, tm_ptr);
}
break;
case '-':
case 'x':
skip = expand_num(buf, sizeof(buf), view->filtered);
break;
case 'l':
skip = expand_num(buf, sizeof(buf), view->list_pos + 1);
break;
case 'L':
skip = expand_num(buf, sizeof(buf), view->list_rows + view->filtered);
break;
case 'S':
skip = expand_num(buf, sizeof(buf), view->list_rows);
break;
case '%':
copy_str(buf, sizeof(buf), "%");
break;
case 'z':
copy_str(buf, sizeof(buf), get_tip());
break;
case 'D':
if(curr_stats.number_of_windows == 1)
{
view_t *const other = (view == curr_view) ? other_view : curr_view;
//mod by sim1
//copy_str(buf, sizeof(buf), replace_home_part(other->curr_dir));
snprintf(buf, sizeof(buf), " ‖ %s", replace_home_part(other->curr_dir));
}
break;
case '[':
{
LineWithAttrs opt = parse_view_macros(view, format, macros, 1);
copy_str(buf, sizeof(buf), opt.line);
free(opt.line);
char *attrs = opt.attrs;
if(sync_attrs(&result, 0) && opt.attrs_len > 0U)
{
if(*attrs != ' ')
{
result.attrs[result.attrs_len - 1U] = *attrs;
}
++attrs;
}
strappend(&result.attrs, &result.attrs_len, attrs);
free(opt.attrs);
break;
}
case ']':
if(opt)
{
if(nexpansions == 0)
{
replace_string(&result.line, "");
replace_string(&result.attrs, "");
result.line_len = 0U;
result.attrs_len = 0U;
}
if(sync_attrs(&result, 0))
{
result.attrs[--result.attrs_len] = '\0';
}
return result;
}
LOG_INFO_MSG("Unmatched %%]");
ok = 0;
break;
case '{':
{
/* Try to find matching closing bracket
* TODO: implement the way to escape it, so that the expr may contain
* closing brackets */
const char *e = strchr(*format, '}');
char *expr = NULL, *resstr = NULL;
var_t res = var_false();
ParsingErrors parsing_error;
/* If there's no matching closing bracket, just add the opening one
* literally */
if(e == NULL)
{
ok = 0;
break;
}
/* Create a NULL-terminated copy of the given expr.
* TODO: we could temporarily use buf for that, to avoid extra
* allocation, but explicitly named variable reads better. */
expr = calloc(e - (*format) + 1 /* NUL-term */, 1);
memcpy(expr, *format, e - (*format));
/* Try to parse expr, and convert the res to string if succeed. */
parsing_error = parse(expr, 0, &res);
if(parsing_error == PE_NO_ERROR)
{
resstr = var_to_str(res);
}
if(resstr != NULL)
{
copy_str(buf, sizeof(buf), resstr);
}
else
{
copy_str(buf, sizeof(buf), "<Invalid expr>");
}
var_free(res);
free(resstr);
free(expr);
*format = e + 1 /* closing bracket */;
}
break;
case '*':
if(width > 9)
{
snprintf(buf, sizeof(buf), "%%%d*", (int)width);
width = 0;
break;
}
(void)sync_attrs(&result, 1);
result.attrs[result.attrs_len - 1] = '0' + width;
width = 0;
break;
default:
LOG_INFO_MSG("Unexpected %%-sequence: %%%c", c);
ok = 0;
break;
}
if(char_is_one_of("tTAugsEd", c) && fentry_is_fake(curr))
{
buf[0] = '\0';
}
if(!ok)
{
*format = next;
if(strappendch(&result.line, &result.line_len, '%') != 0)
{
break;
}
continue;
}
check_expanded_str(buf, skip, &nexpansions);
stralign(buf, width, ' ', left_align);
if(strappend(&result.line, &result.line_len, buf) != 0)
{
break;
}
}
/* Unmatched %[. */
if(opt)
{
(void)strprepend(&result.line, &result.line_len, "%[");
}
if(sync_attrs(&result, 0))
{
result.attrs[--result.attrs_len] = '\0';
}
return result;
}
/* Makes sure that result->attrs has at least as many elements as result->line
* contains characters + extra_width. Returns non-zero if result->attrs has
* extra characters compared to result->line. */
static int
sync_attrs(LineWithAttrs *result, int extra_width)
{
const size_t nchars = utf8_strsw(result->line) + extra_width;
if(result->attrs_len < nchars)
{
char *const new_attrs = format_str("%s%*s", result->attrs,
(int)(nchars - result->attrs_len), "");
free(result->attrs);
result->attrs = new_attrs;
result->attrs_len = nchars;
}
return (result->attrs_len > nchars);
}
/* Prints number into the buffer. Returns non-zero if numeric value is
* "empty" (zero). */
static int
expand_num(char buf[], size_t buf_len, int val)
{
snprintf(buf, buf_len, "%d", val);
return (val == 0);
}
static int
sort_dir_list(const void *one, const void *two)
{
int retval;
char *pfirst, *psecond;
dir_entry_t *const first = (dir_entry_t *)one;
dir_entry_t *const second = (dir_entry_t *)two;
int first_is_dir;
int second_is_dir;
if(is_parent_dir(first->name))
{
return -1;
}
else if(is_parent_dir(second->name))
{
return 1;
}
first_is_dir = is_directory_entry(first);
second_is_dir = is_directory_entry(second);
retval = 0;
switch(sort_type)
{
case SK_BY_NAME:
case SK_BY_INAME:
if(custom_view)
{
retval = compare_entry_names(first, second, sort_type == SK_BY_INAME);
}
else
{
retval = compare_full_file_names(first->name, second->name,
sort_type == SK_BY_INAME);
}
break;
case SK_BY_DIR:
if(first_is_dir != second_is_dir)
{
retval = first_is_dir ? -1 : 1;
}
break;
case SK_BY_TYPE:
retval = strcmp(get_type_str(first->type), get_type_str(second->type));
break;
case SK_BY_FILEEXT:
case SK_BY_EXTENSION:
pfirst = strrchr(first->name, '.');
psecond = strrchr(second->name, '.');
if(first_is_dir && second_is_dir && sort_type == SK_BY_FILEEXT)
{
retval = compare_file_names(first->name, second->name, 0);
}
else if(first_is_dir != second_is_dir && sort_type == SK_BY_FILEEXT)
{
retval = first_is_dir ? -1 : 1;
}
else if(pfirst && psecond)
{
if(pfirst == first->name && psecond != second->name)
{
retval = -1;
}
else if(pfirst != first->name && psecond == second->name)
{
retval = 1;
}
else
{
retval = compare_file_names(++pfirst, ++psecond, 0);
}
}
else if(pfirst || psecond)
retval = pfirst ? -1 : 1;
else
retval = compare_file_names(first->name, second->name, 0);
break;
case SK_BY_SIZE:
{
if(first_is_dir)
{
char full_path[PATH_MAX];
get_full_path_of(first, sizeof(full_path), full_path);
tree_get_data(curr_stats.dirsize_cache, full_path, &first->size);
}
if(second_is_dir)
{
char full_path[PATH_MAX];
get_full_path_of(second, sizeof(full_path), full_path);
tree_get_data(curr_stats.dirsize_cache, full_path, &second->size);
}
retval = (first->size < second->size)
? -1
: (first->size > second->size);
}
break;
case SK_BY_TIME_MODIFIED:
retval = first->mtime - second->mtime;
break;
case SK_BY_TIME_ACCESSED:
retval = first->atime - second->atime;
break;
case SK_BY_TIME_CHANGED:
retval = first->ctime - second->ctime;
break;
#ifndef _WIN32
case SK_BY_MODE:
retval = first->mode - second->mode;
break;
case SK_BY_OWNER_NAME: /* FIXME */
case SK_BY_OWNER_ID:
retval = first->uid - second->uid;
break;
case SK_BY_GROUP_NAME: /* FIXME */
case SK_BY_GROUP_ID:
retval = first->gid - second->gid;
break;
case SK_BY_PERMISSIONS:
{
char first_perm[11], second_perm[11];
get_perm_string(first_perm, sizeof(first_perm), first->mode);
get_perm_string(second_perm, sizeof(second_perm), second->mode);
retval = strcmp(first_perm, second_perm);
}
break;
#endif
}
if(retval == 0)
{
retval = first->list_num - second->list_num;
}
else if(sort_descending)
{
retval = -retval;
}
return retval;
}
int
flist_find_group(const FileView *view, int next)
{
/* TODO: refactor/simplify this function (flist_find_group()). */
const int correction = next ? -1 : 0;
const int lb = correction;
const int ub = view->list_rows + correction;
const int inc = next ? +1 : -1;
int pos = view->list_pos;
dir_entry_t *pentry = &view->dir_entry[pos];
const char *ext = get_last_ext(pentry->name);
size_t char_width = utf8_chrw(pentry->name);
wchar_t ch = towupper(get_first_wchar(pentry->name));
const SortingKey sorting_key =
flist_custom_active(view) && cv_compare(view->custom.type)
? SK_BY_ID
: abs(view->sort[0]);
const int is_dir = fentry_is_dir(pentry);
const char *const type_str = get_type_str(pentry->type);
regmatch_t pmatch = { .rm_so = 0, .rm_eo = 0 };
#ifndef _WIN32
char perms[16];
get_perm_string(perms, sizeof(perms), pentry->mode);
#endif
if(sorting_key == SK_BY_GROUPS)
{
pmatch = get_group_match(&view->primary_group, pentry->name);
}
while(pos > lb && pos < ub)
{
dir_entry_t *nentry;
pos += inc;
nentry = &view->dir_entry[pos];
switch(sorting_key)
{
case SK_BY_FILEEXT:
if(fentry_is_dir(nentry))
{
if(strncmp(pentry->name, nentry->name, char_width) != 0)
{
return pos;
}
}
if(strcmp(get_last_ext(nentry->name), ext) != 0)
{
return pos;
}
break;
case SK_BY_EXTENSION:
if(strcmp(get_last_ext(nentry->name), ext) != 0)
return pos;
break;
case SK_BY_GROUPS:
{
regmatch_t nmatch = get_group_match(&view->primary_group,
nentry->name);
if(pmatch.rm_eo - pmatch.rm_so != nmatch.rm_eo - nmatch.rm_so ||
(pmatch.rm_eo != pmatch.rm_so &&
strncmp(pentry->name + pmatch.rm_so, nentry->name + nmatch.rm_so,
pmatch.rm_eo - pmatch.rm_so + 1U) != 0))
return pos;
}
break;
case SK_BY_TARGET:
if((nentry->type == FT_LINK) != (pentry->type == FT_LINK))
{
/* One of the entries is not a link. */
return pos;
}
if(nentry->type == FT_LINK)
{
/* Both entries are symbolic links. */
char full_path[PATH_MAX];
char nlink[PATH_MAX], plink[PATH_MAX];
get_full_path_of(nentry, sizeof(full_path), full_path);
if(get_link_target(full_path, nlink, sizeof(nlink)) != 0)
{
return pos;
}
get_full_path_of(pentry, sizeof(full_path), full_path);
if(get_link_target(full_path, plink, sizeof(plink)) != 0)
{
return pos;
}
if(stroscmp(nlink, plink) != 0)
{
return pos;
}
}
break;
case SK_BY_NAME:
if(strncmp(pentry->name, nentry->name, char_width) != 0)
return pos;
break;
case SK_BY_INAME:
if((wchar_t)towupper(get_first_wchar(nentry->name)) != ch)
return pos;
break;
case SK_BY_SIZE:
if(nentry->size != pentry->size)
return pos;
break;
case SK_BY_NITEMS:
if(entry_get_nitems(view, nentry) != entry_get_nitems(view, pentry))
return pos;
break;
case SK_BY_TIME_ACCESSED:
if(nentry->atime != pentry->atime)
return pos;
break;
case SK_BY_TIME_CHANGED:
if(nentry->ctime != pentry->ctime)
return pos;
break;
case SK_BY_TIME_MODIFIED:
if(nentry->mtime != pentry->mtime)
return pos;
break;
case SK_BY_DIR:
if(is_dir != fentry_is_dir(nentry))
{
return pos;
}
break;
case SK_BY_TYPE:
if(get_type_str(nentry->type) != type_str)
{
return pos;
}
break;
#ifndef _WIN32
case SK_BY_GROUP_NAME:
case SK_BY_GROUP_ID:
if(nentry->gid != pentry->gid)
return pos;
break;
case SK_BY_OWNER_NAME:
case SK_BY_OWNER_ID:
if(nentry->uid != pentry->uid)
return pos;
break;
case SK_BY_MODE:
if(nentry->mode != pentry->mode)
return pos;
break;
case SK_BY_PERMISSIONS:
{
char nperms[16];
get_perm_string(nperms, sizeof(nperms), nentry->mode);
if(strcmp(nperms, perms) != 0)
{
return pos;
}
break;
}
case SK_BY_NLINKS:
if(nentry->nlinks != pentry->nlinks)
{
return pos;
}
break;
#endif
}
/* Id sorting is builtin only and is defined outside SortingKey
* enumeration. */
if((int)sorting_key == SK_BY_ID)
{
if(nentry->id != pentry->id)
{
return pos;
}
}
}
return pos;
}
/* Finds pointer to the beginning of the last extension of the file name.
* Returns the pointer, which might point to the NUL byte if there are no
* extensions. */
static const char *
get_last_ext(const char name[])
{
const char *const ext = strrchr(name, '.');
return (ext == NULL) ? (name + strlen(name)) : (ext + 1);
}
int
flist_find_dir_group(const FileView *view, int next)
{
const int correction = next ? -1 : 0;
const int lb = correction;
const int ub = view->list_rows + correction;
const int inc = next ? +1 : -1;
int pos = curr_view->list_pos;
dir_entry_t *pentry = &curr_view->dir_entry[pos];
const int is_dir = fentry_is_dir(pentry);
while(pos > lb && pos < ub)
{
dir_entry_t *nentry;
pos += inc;
nentry = &curr_view->dir_entry[pos];
if(is_dir != fentry_is_dir(nentry))
{
break;
}
}
return pos;
}
int
flist_first_sibling(const FileView *view)
{
const int parent = view->list_pos - view->dir_entry[view->list_pos].child_pos;
return (parent == view->list_pos ? 0 : parent + 1);
}
int
flist_last_sibling(const FileView *view)
{
int pos = view->list_pos - view->dir_entry[view->list_pos].child_pos;
if(pos == view->list_pos)
{
/* For top-level entry, find the last top-level entry. */
pos = view->list_rows - 1;
while(view->dir_entry[pos].child_pos != 0)
{
pos -= view->dir_entry[pos].child_pos;
}
}
else
{
/* For non-top-level entry, go to last tree item and go up until our
* child. */
const int parent = pos;
pos = parent + view->dir_entry[parent].child_count;
while(pos - view->dir_entry[pos].child_pos != parent)
{
pos -= view->dir_entry[pos].child_pos;
}
}
return pos;
}
