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; }