static enum path_treatment treat_one_path(struct dir_struct *dir,
struct strbuf *path,
const struct path_simplify *simplify,
int dtype, struct dirent *de)
{
int exclude;
int has_path_in_index = !!cache_file_exists(path->buf, path->len, ignore_case);
if (dtype == DT_UNKNOWN)
dtype = get_dtype(de, path->buf, path->len);
/* Always exclude indexed files */
if (dtype != DT_DIR && has_path_in_index)
return path_none;
/*
* When we are looking at a directory P in the working tree,
* there are three cases:
*
* (1) P exists in the index. Everything inside the directory P in
* the working tree needs to go when P is checked out from the
* index.
*
* (2) P does not exist in the index, but there is P/Q in the index.
* We know P will stay a directory when we check out the contents
* of the index, but we do not know yet if there is a directory
* P/Q in the working tree to be killed, so we need to recurse.
*
* (3) P does not exist in the index, and there is no P/Q in the index
* to require P to be a directory, either. Only in this case, we
* know that everything inside P will not be killed without
* recursing.
*/
if ((dir->flags & DIR_COLLECT_KILLED_ONLY) &&
(dtype == DT_DIR) &&
!has_path_in_index &&
(directory_exists_in_index(path->buf, path->len) == index_nonexistent))
return path_none;
exclude = is_excluded(dir, path->buf, &dtype);
/*
* Excluded? If we don't explicitly want to show
* ignored files, ignore it
*/
if (exclude && !(dir->flags & (DIR_SHOW_IGNORED|DIR_SHOW_IGNORED_TOO)))
return path_excluded;
switch (dtype) {
default:
return path_none;
case DT_DIR:
strbuf_addch(path, '/');
return treat_directory(dir, path->buf, path->len, exclude,
simplify);
case DT_REG:
case DT_LNK:
return exclude ? path_excluded : path_untracked;
}
}
static enum path_treatment treat_one_path(struct dir_struct *dir,
struct strbuf *path,
const struct path_simplify *simplify,
int dtype, struct dirent *de)
{
int exclude;
if (dtype == DT_UNKNOWN)
dtype = get_dtype(de, path->buf, path->len);
/* Always exclude indexed files */
if (dtype != DT_DIR &&
cache_name_exists(path->buf, path->len, ignore_case))
return path_none;
exclude = is_excluded(dir, path->buf, &dtype);
/*
* Excluded? If we don't explicitly want to show
* ignored files, ignore it
*/
if (exclude && !(dir->flags & (DIR_SHOW_IGNORED|DIR_SHOW_IGNORED_TOO)))
return path_excluded;
switch (dtype) {
default:
return path_none;
case DT_DIR:
strbuf_addch(path, '/');
return treat_directory(dir, path->buf, path->len, exclude,
simplify);
case DT_REG:
case DT_LNK:
return exclude ? path_excluded : path_untracked;
}
}
/**
* @brief Produces list of fragmented files.
*/
static void produce_list_of_fragmented_files(udefrag_job_parameters *jp)
{
winx_file_info *f;
ULONGLONG bad_fragments = 0;
ULONGLONG bad_clusters = 0;
itrace("started creation of fragmented files list");
jp->fragmented_files = prb_create(fragmented_files_compare,(void *)jp,NULL);
for(f = jp->filelist; f; f = f->next){
if(is_fragmented(f) && !is_excluded(f)){
expand_fragmented_files_list(f,jp);
//Old way counts number of fragments and calculates percentage on
// how many TOTAL fragments exist. Seems very inaccurate...
bad_fragments += f->disp.fragments;
bad_clusters += f->disp.clusters; //use clusters instead.
}
if(f->next == jp->filelist) break;
}
jp->pi.bad_fragments = bad_fragments;
jp->pi.bad_clusters = bad_clusters;
jp->pi.fragmented_files_prb = jp->fragmented_files; //pointer for fileslist.cpp to access
jp->pi.isfragfileslist = 1;
itrace("finished creation of fragmented files list");
itrace("fragments total: %u",jp->pi.fragments);
itrace("bad_clusters : %u",jp->pi.bad_clusters);
}
void MainBackupLoop::DealWithDirectory(path rep_path)
{
if (!is_excluded(rep_path))
{
path bak_rep=config_ptr->home_to_backup(rep_path);
if (!is_directory(bak_rep))
{
Utilities(config_ptr).create_directory_tree(bak_rep);
}
loopOverDirectory(rep_path);
}
}
static int check_ok_to_remove(const char *name, int len, int dtype,
const struct cache_entry *ce, struct stat *st,
enum unpack_trees_error_types error_type,
struct unpack_trees_options *o)
{
const struct cache_entry *result;
/*
* It may be that the 'lstat()' succeeded even though
* target 'ce' was absent, because there is an old
* entry that is different only in case..
*
* Ignore that lstat() if it matches.
*/
if (ignore_case && icase_exists(o, name, len, st))
return 0;
if (o->dir &&
is_excluded(o->dir, name, &dtype))
/*
* ce->name is explicitly excluded, so it is Ok to
* overwrite it.
*/
return 0;
if (S_ISDIR(st->st_mode)) {
/*
* We are checking out path "foo" and
* found "foo/." in the working tree.
* This is tricky -- if we have modified
* files that are in "foo/" we would lose
* them.
*/
if (verify_clean_subdirectory(ce, error_type, o) < 0)
return -1;
return 0;
}
/*
* The previous round may already have decided to
* delete this path, which is in a subdirectory that
* is being replaced with a blob.
*/
result = index_file_exists(&o->result, name, len, 0);
if (result) {
if (result->ce_flags & CE_REMOVE)
return 0;
}
return o->gently ? -1 :
add_rejected_path(o, error_type, name);
}
bool PlanTableManager::InsertDataChunks(QString& str_sql_query, QString& str_sql_error) const {
namespace frd = format_reader::dbf;
namespace fr = format_reader;
frd::DbfFormatReader dbf_format_reader;
if (!dbf_format_reader.Open(table_absolute_file_path_))
return false;
fr::Record record;
int record_amount = 0;
table_helper_.TransactionBegin(str_sql_query);
while(dbf_format_reader.Read(record)) {
// exit by cancel operation
if (canceled_) return false;
if (is_excluded(allowed_regions_, record)) {
++record_amount;
continue;
}
do_insert(str_sql_query, record);
++record_amount;
if (record_amount % kDataChunkSize == 0) {
table_helper_.TransactionEnd(str_sql_query);
if (!execute_sql_query(str_sql_query, str_sql_error))
return false;
str_sql_query.clear();
table_helper_.TransactionBegin(str_sql_query);
}
}
table_helper_.TransactionEnd(str_sql_query);
if (!execute_sql_query(str_sql_query, str_sql_error))
return false;
// we skip the dublicate records
// assert(record_amount == dbf_format_reader.records_amount());
return true;
}
int cmd_add(int argc, const char **argv, const char *prefix)
{
int exit_status = 0;
struct pathspec pathspec;
struct dir_struct dir;
int flags;
int add_new_files;
int require_pathspec;
char *seen = NULL;
struct lock_file lock_file = LOCK_INIT;
git_config(add_config, NULL);
argc = parse_options(argc, argv, prefix, builtin_add_options,
builtin_add_usage, PARSE_OPT_KEEP_ARGV0);
if (patch_interactive)
add_interactive = 1;
if (add_interactive)
exit(interactive_add(argc - 1, argv + 1, prefix, patch_interactive));
if (edit_interactive)
return(edit_patch(argc, argv, prefix));
argc--;
argv++;
if (0 <= addremove_explicit)
addremove = addremove_explicit;
else if (take_worktree_changes && ADDREMOVE_DEFAULT)
addremove = 0; /* "-u" was given but not "-A" */
if (addremove && take_worktree_changes)
die(_("-A and -u are mutually incompatible"));
if (!take_worktree_changes && addremove_explicit < 0 && argc)
/* Turn "git add pathspec..." to "git add -A pathspec..." */
addremove = 1;
if (!show_only && ignore_missing)
die(_("Option --ignore-missing can only be used together with --dry-run"));
if (chmod_arg && ((chmod_arg[0] != '-' && chmod_arg[0] != '+') ||
chmod_arg[1] != 'x' || chmod_arg[2]))
die(_("--chmod param '%s' must be either -x or +x"), chmod_arg);
add_new_files = !take_worktree_changes && !refresh_only && !add_renormalize;
require_pathspec = !(take_worktree_changes || (0 < addremove_explicit));
hold_locked_index(&lock_file, LOCK_DIE_ON_ERROR);
flags = ((verbose ? ADD_CACHE_VERBOSE : 0) |
(show_only ? ADD_CACHE_PRETEND : 0) |
(intent_to_add ? ADD_CACHE_INTENT : 0) |
(ignore_add_errors ? ADD_CACHE_IGNORE_ERRORS : 0) |
(!(addremove || take_worktree_changes)
? ADD_CACHE_IGNORE_REMOVAL : 0));
if (require_pathspec && argc == 0) {
fprintf(stderr, _("Nothing specified, nothing added.\n"));
fprintf(stderr, _("Maybe you wanted to say 'git add .'?\n"));
return 0;
}
/*
* Check the "pathspec '%s' did not match any files" block
* below before enabling new magic.
*/
parse_pathspec(&pathspec, PATHSPEC_ATTR,
PATHSPEC_PREFER_FULL |
PATHSPEC_SYMLINK_LEADING_PATH,
prefix, argv);
if (read_cache_preload(&pathspec) < 0)
die(_("index file corrupt"));
die_in_unpopulated_submodule(&the_index, prefix);
die_path_inside_submodule(&the_index, &pathspec);
if (add_new_files) {
int baselen;
/* Set up the default git porcelain excludes */
memset(&dir, 0, sizeof(dir));
if (!ignored_too) {
dir.flags |= DIR_COLLECT_IGNORED;
setup_standard_excludes(&dir);
}
/* This picks up the paths that are not tracked */
baselen = fill_directory(&dir, &the_index, &pathspec);
if (pathspec.nr)
seen = prune_directory(&dir, &pathspec, baselen);
}
if (refresh_only) {
refresh(verbose, &pathspec);
goto finish;
}
if (pathspec.nr) {
int i;
if (!seen)
seen = find_pathspecs_matching_against_index(&pathspec, &the_index);
/*
* file_exists() assumes exact match
*/
GUARD_PATHSPEC(&pathspec,
PATHSPEC_FROMTOP |
PATHSPEC_LITERAL |
PATHSPEC_GLOB |
PATHSPEC_ICASE |
PATHSPEC_EXCLUDE);
for (i = 0; i < pathspec.nr; i++) {
const char *path = pathspec.items[i].match;
if (pathspec.items[i].magic & PATHSPEC_EXCLUDE)
continue;
if (!seen[i] && path[0] &&
((pathspec.items[i].magic &
(PATHSPEC_GLOB | PATHSPEC_ICASE)) ||
!file_exists(path))) {
if (ignore_missing) {
int dtype = DT_UNKNOWN;
if (is_excluded(&dir, &the_index, path, &dtype))
dir_add_ignored(&dir, &the_index,
path, pathspec.items[i].len);
} else
die(_("pathspec '%s' did not match any files"),
pathspec.items[i].original);
}
}
free(seen);
}
plug_bulk_checkin();
if (add_renormalize)
exit_status |= renormalize_tracked_files(&pathspec, flags);
else
exit_status |= add_files_to_cache(prefix, &pathspec, flags);
if (add_new_files)
exit_status |= add_files(&dir, flags);
if (chmod_arg && pathspec.nr)
chmod_pathspec(&pathspec, chmod_arg[0]);
unplug_bulk_checkin();
finish:
if (write_locked_index(&the_index, &lock_file,
COMMIT_LOCK | SKIP_IF_UNCHANGED))
die(_("Unable to write new index file"));
UNLEAK(pathspec);
UNLEAK(dir);
return exit_status;
}
int cmd_add(int argc, const char **argv, const char *prefix)
{
int exit_status = 0;
int newfd;
struct pathspec pathspec;
struct dir_struct dir;
int flags;
int add_new_files;
int require_pathspec;
char *seen = NULL;
int implicit_dot = 0;
struct update_callback_data update_data;
git_config(add_config, NULL);
argc = parse_options(argc, argv, prefix, builtin_add_options,
builtin_add_usage, PARSE_OPT_KEEP_ARGV0);
if (patch_interactive)
add_interactive = 1;
if (add_interactive)
exit(interactive_add(argc - 1, argv + 1, prefix, patch_interactive));
if (edit_interactive)
return(edit_patch(argc, argv, prefix));
argc--;
argv++;
if (0 <= addremove_explicit)
addremove = addremove_explicit;
else if (take_worktree_changes && ADDREMOVE_DEFAULT)
addremove = 0; /* "-u" was given but not "-A" */
if (addremove && take_worktree_changes)
die(_("-A and -u are mutually incompatible"));
/*
* Warn when "git add pathspec..." was given without "-u" or "-A"
* and pathspec... covers a removed path.
*/
memset(&update_data, 0, sizeof(update_data));
if (!take_worktree_changes && addremove_explicit < 0)
update_data.warn_add_would_remove = 1;
if (!take_worktree_changes && addremove_explicit < 0 && argc)
/*
* Turn "git add pathspec..." to "git add -A pathspec..."
* in Git 2.0 but not yet
*/
; /* addremove = 1; */
if (!show_only && ignore_missing)
die(_("Option --ignore-missing can only be used together with --dry-run"));
if (addremove) {
option_with_implicit_dot = "--all";
short_option_with_implicit_dot = "-A";
}
if (take_worktree_changes) {
option_with_implicit_dot = "--update";
short_option_with_implicit_dot = "-u";
}
if (option_with_implicit_dot && !argc) {
static const char *here[2] = { ".", NULL };
argc = 1;
argv = here;
implicit_dot = 1;
}
add_new_files = !take_worktree_changes && !refresh_only;
require_pathspec = !take_worktree_changes;
newfd = hold_locked_index(&lock_file, 1);
flags = ((verbose ? ADD_CACHE_VERBOSE : 0) |
(show_only ? ADD_CACHE_PRETEND : 0) |
(intent_to_add ? ADD_CACHE_INTENT : 0) |
(ignore_add_errors ? ADD_CACHE_IGNORE_ERRORS : 0) |
(!(addremove || take_worktree_changes)
? ADD_CACHE_IGNORE_REMOVAL : 0)) |
(implicit_dot ? ADD_CACHE_IMPLICIT_DOT : 0);
if (require_pathspec && argc == 0) {
fprintf(stderr, _("Nothing specified, nothing added.\n"));
fprintf(stderr, _("Maybe you wanted to say 'git add .'?\n"));
return 0;
}
if (read_cache() < 0)
die(_("index file corrupt"));
/*
* Check the "pathspec '%s' did not match any files" block
* below before enabling new magic.
*/
parse_pathspec(&pathspec, 0,
PATHSPEC_PREFER_FULL |
PATHSPEC_SYMLINK_LEADING_PATH |
PATHSPEC_STRIP_SUBMODULE_SLASH_EXPENSIVE,
prefix, argv);
if (add_new_files) {
int baselen;
struct pathspec empty_pathspec;
/* Set up the default git porcelain excludes */
memset(&dir, 0, sizeof(dir));
if (!ignored_too) {
dir.flags |= DIR_COLLECT_IGNORED;
setup_standard_excludes(&dir);
}
memset(&empty_pathspec, 0, sizeof(empty_pathspec));
/* This picks up the paths that are not tracked */
baselen = fill_directory(&dir, implicit_dot ? &empty_pathspec : &pathspec);
if (pathspec.nr)
seen = prune_directory(&dir, &pathspec, baselen,
implicit_dot ? WARN_IMPLICIT_DOT : 0);
}
if (refresh_only) {
refresh(verbose, &pathspec);
goto finish;
}
if (implicit_dot && prefix)
refresh_cache(REFRESH_QUIET);
if (pathspec.nr) {
int i;
if (!seen)
seen = find_pathspecs_matching_against_index(&pathspec);
/*
* file_exists() assumes exact match
*/
GUARD_PATHSPEC(&pathspec,
PATHSPEC_FROMTOP |
PATHSPEC_LITERAL |
PATHSPEC_GLOB |
PATHSPEC_ICASE);
for (i = 0; i < pathspec.nr; i++) {
const char *path = pathspec.items[i].match;
if (!seen[i] &&
((pathspec.items[i].magic &
(PATHSPEC_GLOB | PATHSPEC_ICASE)) ||
!file_exists(path))) {
if (ignore_missing) {
int dtype = DT_UNKNOWN;
if (is_excluded(&dir, path, &dtype))
dir_add_ignored(&dir, path, pathspec.items[i].len);
} else
die(_("pathspec '%s' did not match any files"),
pathspec.items[i].original);
}
}
free(seen);
}
plug_bulk_checkin();
if ((flags & ADD_CACHE_IMPLICIT_DOT) && prefix) {
/*
* Check for modified files throughout the worktree so
* update_callback has a chance to warn about changes
* outside the cwd.
*/
update_data.implicit_dot = prefix;
update_data.implicit_dot_len = strlen(prefix);
free_pathspec(&pathspec);
memset(&pathspec, 0, sizeof(pathspec));
}
update_data.flags = flags & ~ADD_CACHE_IMPLICIT_DOT;
update_files_in_cache(prefix, &pathspec, &update_data);
exit_status |= !!update_data.add_errors;
if (add_new_files)
exit_status |= add_files(&dir, flags);
unplug_bulk_checkin();
finish:
if (active_cache_changed) {
if (write_cache(newfd, active_cache, active_nr) ||
commit_locked_index(&lock_file))
die(_("Unable to write new index file"));
}
return exit_status;
}
static int
getstats(void)
{
FILE* parts;
time_t now;
now = time(NULL);
if (cache_time + CACHE_TIMEOUT > now) {
return 0;
}
if (!head.indices) {
head.alloc = DISK_INCR;
head.indices = (linux_diskio *)malloc(head.alloc*sizeof(linux_diskio));
}
head.length = 0;
memset(head.indices, 0, head.alloc*sizeof(linux_diskio));
/* Is this a 2.6 kernel? */
parts = fopen("/proc/diskstats", "r");
if (parts) {
char buffer[1024];
while (fgets(buffer, sizeof(buffer), parts)) {
linux_diskio* pTemp;
if (head.length == head.alloc) {
head.alloc += DISK_INCR;
head.indices = (linux_diskio *)realloc(head.indices, head.alloc*sizeof(linux_diskio));
}
pTemp = &head.indices[head.length];
sscanf (buffer, "%d %d", &pTemp->major, &pTemp->minor);
if (sscanf (buffer, "%d %d %s %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu\n",
&pTemp->major, &pTemp->minor, pTemp->name,
&pTemp->rio, &pTemp->rmerge, &pTemp->rsect, &pTemp->ruse,
&pTemp->wio, &pTemp->wmerge, &pTemp->wsect, &pTemp->wuse,
&pTemp->running, &pTemp->use, &pTemp->aveq) != 14)
sscanf (buffer, "%d %d %s %lu %lu %lu %lu\n",
&pTemp->major, &pTemp->minor, pTemp->name,
&pTemp->rio, &pTemp->rsect,
&pTemp->wio, &pTemp->wsect);
if (!is_excluded(pTemp->name))
head.length++;
}
}
else {
/* See if a 2.4 kernel */
char buffer[1024];
int rc;
parts = fopen("/proc/partitions", "r");
if (!parts) {
snmp_log_perror("/proc/partitions");
return 1;
}
/*
* first few fscanfs are garbage we don't care about. skip it.
*/
fgets(buffer, sizeof(buffer), parts);
fgets(buffer, sizeof(buffer), parts);
while (! feof(parts)) {
linux_diskio* pTemp;
if (head.length == head.alloc) {
head.alloc += DISK_INCR;
head.indices = (linux_diskio *)realloc(head.indices, head.alloc*sizeof(linux_diskio));
}
pTemp = &head.indices[head.length];
rc = fscanf (parts, "%d %d %lu %s %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu\n",
&pTemp->major, &pTemp->minor, &pTemp->blocks, pTemp->name,
&pTemp->rio, &pTemp->rmerge, &pTemp->rsect, &pTemp->ruse,
&pTemp->wio, &pTemp->wmerge, &pTemp->wsect, &pTemp->wuse,
&pTemp->running, &pTemp->use, &pTemp->aveq);
if (rc != 15) {
snmp_log(LOG_ERR, "diskio.c: cannot find statistics in /proc/partitions\n");
fclose(parts);
return 1;
}
if (!is_excluded(pTemp->name))
head.length++;
}
}
fclose(parts);
cache_time = now;
return 0;
}
/*! \brief
* Does a grid search.
*/
static gmx_bool
grid_search(gmx_ana_nbsearch_t *d,
gmx_bool (*action)(gmx_ana_nbsearch_t *d, int i, real r2))
{
int i;
rvec dx;
real r2;
if (d->bGrid)
{
int nbi, ci, cai;
nbi = d->prevnbi;
cai = d->prevcai + 1;
for (; nbi < d->ngridnb; ++nbi)
{
ivec cell;
ivec_add(d->testcell, d->gnboffs[nbi], cell);
/* TODO: Support for 2D and screw PBC */
cell[XX] = (cell[XX] + d->ncelldim[XX]) % d->ncelldim[XX];
cell[YY] = (cell[YY] + d->ncelldim[YY]) % d->ncelldim[YY];
cell[ZZ] = (cell[ZZ] + d->ncelldim[ZZ]) % d->ncelldim[ZZ];
ci = grid_index(d, cell);
/* TODO: Calculate the required PBC shift outside the inner loop */
for (; cai < d->ncatoms[ci]; ++cai)
{
i = d->catom[ci][cai];
if (is_excluded(d, i))
{
continue;
}
pbc_dx_aiuc(d->pbc, d->xtest, d->xref[i], dx);
r2 = norm2(dx);
if (r2 <= d->cutoff2)
{
if (action(d, i, r2))
{
d->prevnbi = nbi;
d->prevcai = cai;
d->previ = i;
return TRUE;
}
}
}
d->exclind = 0;
cai = 0;
}
}
else
{
i = d->previ + 1;
for (; i < d->nref; ++i)
{
if (is_excluded(d, i))
{
continue;
}
if (d->pbc)
{
pbc_dx(d->pbc, d->xtest, d->xref[i], dx);
}
else
{
rvec_sub(d->xtest, d->xref[i], dx);
}
r2 = norm2(dx);
if (r2 <= d->cutoff2)
{
if (action(d, i, r2))
{
d->previ = i;
return TRUE;
}
}
}
}
return FALSE;
}
/**
* @brief Searches for all files on disk.
* @return Zero for success, negative value otherwise.
*/
static int find_files(udefrag_job_parameters *jp)
{
int context_menu_handler = 0;
wchar_t parent_directory[MAX_PATH + 1];
wchar_t *p;
wchar_t c;
int flags = 0;
winx_file_info *f;
winx_blockmap *block;
/* check for context menu handler (single files/directories)*/
if(jp->udo.job_flags & UD_JOB_CONTEXT_MENU_HANDLER){
if(jp->udo.cut_filter.count > 0){
if(wcslen(jp->udo.cut_filter.array[0]) >= wcslen(L"C:\\"))
context_menu_handler = 1;
}
}
/* speed up the context menu handler for (single files/directories) & non-NTFS */
if(jp->fs_type != FS_NTFS && context_menu_handler){
/* in case of c:\* or c:\ scan entire disk */
c = jp->udo.cut_filter.array[0][3];
if(c == 0 || c == '*')
goto scan_entire_disk;
/* in case of c:\test;c:\test\* scan parent directory recursively */
if(jp->udo.cut_filter.count > 1)
flags = WINX_FTW_RECURSIVE;
/* in case of c:\test scan parent directory, not recursively */
_snwprintf(parent_directory, MAX_PATH, L"\\??\\%ws", jp->udo.cut_filter.array[0]);
parent_directory[MAX_PATH] = 0;
p = wcsrchr(parent_directory,'\\');
if(p) *p = 0;
if(wcslen(parent_directory) <= wcslen(L"\\??\\C:\\"))
goto scan_entire_disk;
jp->filelist = winx_ftw(parent_directory,
flags | WINX_FTW_DUMP_FILES | \
WINX_FTW_ALLOW_PARTIAL_SCAN | WINX_FTW_SKIP_RESIDENT_STREAMS,
filter,progress_callback,terminator,(void *)jp);
} else {
scan_entire_disk:
jp->filelist = winx_scan_disk(jp->volume_letter,
WINX_FTW_DUMP_FILES | WINX_FTW_ALLOW_PARTIAL_SCAN | \
WINX_FTW_SKIP_RESIDENT_STREAMS,
filter,progress_callback,terminator,(void *)jp);
}
if(jp->filelist == NULL && !jp->termination_router((void *)jp))
return (-1);
/* calculate number of fragmented files; redraw map */
for(f = jp->filelist; f; f = f->next){
/* skip excluded files. if excluded, count as 1 fragment.
obviously if not fragmented, it counts as 1. */
if(!is_fragmented(f) || is_excluded(f)){
jp->pi.fragments ++;
} else {
jp->pi.fragmented ++;
jp->pi.fragments += f->disp.fragments;
}
/* redraw cluster map */
colorize_file(jp,f,DEFAULT_COLOR); //genBTC,-was using wrong alias.
/* add file blocks to the binary search tree - after winx_scan_disk! */
for(block = f->disp.blockmap; block; block = block->next){
if(add_block_to_file_blocks_tree(jp,f,block) < 0) break;
if(block->next == f->disp.blockmap) break;
}
if(f->next == jp->filelist) break;
}
dbg_print_file_counters(jp);
return 0;
}