* Copyright (C) 2005 Junio C Hamano
*/
#include "cache.h"
+#include "config.h"
#include "tempfile.h"
#include "quote.h"
#include "diff.h"
#endif
static int diff_detect_rename_default;
-static int diff_indent_heuristic; /* experimental */
+static int diff_indent_heuristic = 1;
static int diff_rename_limit_default = 400;
static int diff_suppress_blank_empty;
static int diff_use_color_default = -1;
return 0;
}
- if (git_diff_heuristic_config(var, value, cb) < 0)
- return -1;
-
if (!strcmp(var, "diff.wserrorhighlight")) {
int val = parse_ws_error_highlight(value);
if (val < 0)
if (starts_with(var, "submodule."))
return parse_submodule_config_option(var, value);
+ if (git_diff_heuristic_config(var, value, cb) < 0)
+ return -1;
+
return git_default_config(var, value, cb);
}
}
strbuf_add(&msgbuf, line + len, org_len - len);
+ strbuf_complete_line(&msgbuf);
+
emit_line(ecbdata->opt, "", "", msgbuf.buf, msgbuf.len);
strbuf_release(&msgbuf);
}
regfree(ecbdata->diff_words->word_regex);
free(ecbdata->diff_words->word_regex);
}
- free(ecbdata->diff_words);
- ecbdata->diff_words = NULL;
+ FREE_AND_NULL(ecbdata->diff_words);
}
}
len = sane_truncate_line(ecbdata, line, len);
find_lno(line, ecbdata);
emit_hunk_header(ecbdata, line, len);
- if (line[len-1] != '\n')
- putc('\n', o->file);
return;
}
}
}
-void fill_filespec(struct diff_filespec *spec, const unsigned char *sha1,
- int sha1_valid, unsigned short mode)
+void fill_filespec(struct diff_filespec *spec, const struct object_id *oid,
+ int oid_valid, unsigned short mode)
{
if (mode) {
spec->mode = canon_mode(mode);
- hashcpy(spec->oid.hash, sha1);
- spec->oid_valid = sha1_valid;
+ oidcpy(&spec->oid, oid);
+ spec->oid_valid = oid_valid;
}
}
* the work tree has that object contents, return true, so that
* prepare_temp_file() does not have to inflate and extract.
*/
-static int reuse_worktree_file(const char *name, const unsigned char *sha1, int want_file)
+static int reuse_worktree_file(const char *name, const struct object_id *oid, int want_file)
{
const struct cache_entry *ce;
struct stat st;
* objects however would tend to be slower as they need
* to be individually opened and inflated.
*/
- if (!FAST_WORKING_DIRECTORY && !want_file && has_sha1_pack(sha1))
+ if (!FAST_WORKING_DIRECTORY && !want_file && has_sha1_pack(oid->hash))
return 0;
/*
* Similarly, if we'd have to convert the file contents anyway, that
* makes the optimization not worthwhile.
*/
- if (!want_file && would_convert_to_git(name))
+ if (!want_file && would_convert_to_git(&the_index, name))
return 0;
len = strlen(name);
* This is not the sha1 we are looking for, or
* unreusable because it is not a regular file.
*/
- if (hashcmp(sha1, ce->oid.hash) || !S_ISREG(ce->ce_mode))
+ if (oidcmp(oid, &ce->oid) || !S_ISREG(ce->ce_mode))
return 0;
/*
return diff_populate_gitlink(s, size_only);
if (!s->oid_valid ||
- reuse_worktree_file(s->path, s->oid.hash, 0)) {
+ reuse_worktree_file(s->path, &s->oid, 0)) {
struct strbuf buf = STRBUF_INIT;
struct stat st;
int fd;
* point if the path requires us to run the content
* conversion.
*/
- if (size_only && !would_convert_to_git(s->path))
+ if (size_only && !would_convert_to_git(&the_index, s->path))
return 0;
/*
/*
* Convert from working tree format to canonical git format
*/
- if (convert_to_git(s->path, s->data, s->size, &buf, crlf_warn)) {
+ if (convert_to_git(&the_index, s->path, s->data, s->size, &buf, crlf_warn)) {
size_t size = 0;
munmap(s->data, s->size);
s->should_munmap = 0;
void diff_free_filespec_data(struct diff_filespec *s)
{
diff_free_filespec_blob(s);
- free(s->cnt_data);
- s->cnt_data = NULL;
+ FREE_AND_NULL(s->cnt_data);
}
static void prep_temp_blob(const char *path, struct diff_tempfile *temp,
if (!S_ISGITLINK(one->mode) &&
(!one->oid_valid ||
- reuse_worktree_file(name, one->oid.hash, 1))) {
+ reuse_worktree_file(name, &one->oid, 1))) {
struct stat st;
if (lstat(name, &st) < 0) {
if (errno == ENOENT)
/* we can borrow from the file in the work tree */
temp->name = name;
if (!one->oid_valid)
- sha1_to_hex_r(temp->hex, null_sha1);
+ oid_to_hex_r(temp->hex, &null_oid);
else
oid_to_hex_r(temp->hex, &one->oid);
/* Even though we may sometimes borrow the
* contents from the work tree, we always want
* one->mode. mode is trustworthy even when
- * !(one->sha1_valid), as long as
+ * !(one->oid_valid), as long as
* DIFF_FILE_VALID(one).
*/
xsnprintf(temp->mode, sizeof(temp->mode), "%06o", one->mode);
fprintf(o->file, "* Unmerged path %s\n", name);
}
-static void diff_fill_sha1_info(struct diff_filespec *one)
+static void diff_fill_oid_info(struct diff_filespec *one)
{
if (DIFF_FILE_VALID(one)) {
if (!one->oid_valid) {
const char *other;
const char *attr_path;
- name = p->one->path;
- other = (strcmp(name, p->two->path) ? p->two->path : NULL);
+ name = one->path;
+ other = (strcmp(name, two->path) ? two->path : NULL);
attr_path = name;
if (o->prefix_length)
strip_prefix(o->prefix_length, &name, &other);
return;
}
- diff_fill_sha1_info(one);
- diff_fill_sha1_info(two);
+ diff_fill_oid_info(one);
+ diff_fill_oid_info(two);
if (!pgm &&
DIFF_FILE_VALID(one) && DIFF_FILE_VALID(two) &&
if (o->prefix_length)
strip_prefix(o->prefix_length, &name, &other);
- diff_fill_sha1_info(p->one);
- diff_fill_sha1_info(p->two);
+ diff_fill_oid_info(p->one);
+ diff_fill_oid_info(p->two);
builtin_diffstat(name, other, p->one, p->two, diffstat, o, p);
}
if (o->prefix_length)
strip_prefix(o->prefix_length, &name, &other);
- diff_fill_sha1_info(p->one);
- diff_fill_sha1_info(p->two);
+ diff_fill_oid_info(p->one);
+ diff_fill_oid_info(p->two);
builtin_checkdiff(name, other, attr_path, p->one, p->two, o);
}
DIFF_OPT_CLR(options, FUNCCONTEXT);
else if ((argcount = parse_long_opt("output", av, &optarg))) {
char *path = prefix_filename(prefix, optarg);
- options->file = fopen(path, "w");
- if (!options->file)
- die_errno("Could not open '%s'", path);
+ options->file = xfopen(path, "w");
options->close_file = 1;
if (options->use_color != GIT_COLOR_ALWAYS)
options->use_color = GIT_COLOR_NEVER;
}
/* returns 0 upon success, and writes result into sha1 */
-static int diff_get_patch_id(struct diff_options *options, unsigned char *sha1, int diff_header_only)
+static int diff_get_patch_id(struct diff_options *options, struct object_id *oid, int diff_header_only)
{
struct diff_queue_struct *q = &diff_queued_diff;
int i;
if (DIFF_PAIR_UNMERGED(p))
continue;
- diff_fill_sha1_info(p->one);
- diff_fill_sha1_info(p->two);
+ diff_fill_oid_info(p->one);
+ diff_fill_oid_info(p->two);
len1 = remove_space(p->one->path, strlen(p->one->path));
len2 = remove_space(p->two->path, strlen(p->two->path));
if (diff_filespec_is_binary(p->one) ||
diff_filespec_is_binary(p->two)) {
git_SHA1_Update(&ctx, oid_to_hex(&p->one->oid),
- 40);
+ GIT_SHA1_HEXSZ);
git_SHA1_Update(&ctx, oid_to_hex(&p->two->oid),
- 40);
+ GIT_SHA1_HEXSZ);
continue;
}
p->one->path);
}
- git_SHA1_Final(sha1, &ctx);
+ git_SHA1_Final(oid->hash, &ctx);
return 0;
}
-int diff_flush_patch_id(struct diff_options *options, unsigned char *sha1, int diff_header_only)
+int diff_flush_patch_id(struct diff_options *options, struct object_id *oid, int diff_header_only)
{
struct diff_queue_struct *q = &diff_queued_diff;
int i;
- int result = diff_get_patch_id(options, sha1, diff_header_only);
+ int result = diff_get_patch_id(options, oid, diff_header_only);
for (i = 0; i < q->nr; i++)
diff_free_filepair(q->queue[i]);
warning(_(rename_limit_advice), varname, needed);
}
+static void diff_flush_patch_all_file_pairs(struct diff_options *o)
+{
+ int i;
+ struct diff_queue_struct *q = &diff_queued_diff;
+ for (i = 0; i < q->nr; i++) {
+ struct diff_filepair *p = q->queue[i];
+ if (check_pair_status(p))
+ diff_flush_patch(p, o);
+ }
+}
+
void diff_flush(struct diff_options *options)
{
struct diff_queue_struct *q = &diff_queued_diff;
*/
if (options->close_file)
fclose(options->file);
- options->file = fopen("/dev/null", "w");
- if (!options->file)
- die_errno("Could not open /dev/null");
+ options->file = xfopen("/dev/null", "w");
options->close_file = 1;
for (i = 0; i < q->nr; i++) {
struct diff_filepair *p = q->queue[i];
}
}
- for (i = 0; i < q->nr; i++) {
- struct diff_filepair *p = q->queue[i];
- if (check_pair_status(p))
- diff_flush_patch(p, options);
- }
+ diff_flush_patch_all_file_pairs(options);
}
if (output_format & DIFF_FORMAT_CALLBACK)
void diff_addremove(struct diff_options *options,
int addremove, unsigned mode,
- const unsigned char *sha1,
- int sha1_valid,
+ const struct object_id *oid,
+ int oid_valid,
const char *concatpath, unsigned dirty_submodule)
{
struct diff_filespec *one, *two;
two = alloc_filespec(concatpath);
if (addremove != '+')
- fill_filespec(one, sha1, sha1_valid, mode);
+ fill_filespec(one, oid, oid_valid, mode);
if (addremove != '-') {
- fill_filespec(two, sha1, sha1_valid, mode);
+ fill_filespec(two, oid, oid_valid, mode);
two->dirty_submodule = dirty_submodule;
}
void diff_change(struct diff_options *options,
unsigned old_mode, unsigned new_mode,
- const unsigned char *old_sha1,
- const unsigned char *new_sha1,
- int old_sha1_valid, int new_sha1_valid,
+ const struct object_id *old_oid,
+ const struct object_id *new_oid,
+ int old_oid_valid, int new_oid_valid,
const char *concatpath,
unsigned old_dirty_submodule, unsigned new_dirty_submodule)
{
if (DIFF_OPT_TST(options, REVERSE_DIFF)) {
SWAP(old_mode, new_mode);
- SWAP(old_sha1, new_sha1);
- SWAP(old_sha1_valid, new_sha1_valid);
+ SWAP(old_oid, new_oid);
+ SWAP(old_oid_valid, new_oid_valid);
SWAP(old_dirty_submodule, new_dirty_submodule);
}
one = alloc_filespec(concatpath);
two = alloc_filespec(concatpath);
- fill_filespec(one, old_sha1, old_sha1_valid, old_mode);
- fill_filespec(two, new_sha1, new_sha1_valid, new_mode);
+ fill_filespec(one, old_oid, old_oid_valid, old_mode);
+ fill_filespec(two, new_oid, new_oid_valid, new_mode);
one->dirty_submodule = old_dirty_submodule;
two->dirty_submodule = new_dirty_submodule;
p = diff_queue(&diff_queued_diff, one, two);
if (driver->textconv_cache && df->oid_valid) {
*outbuf = notes_cache_get(driver->textconv_cache,
- df->oid.hash,
+ &df->oid,
&size);
if (*outbuf)
return size;
if (driver->textconv_cache && df->oid_valid) {
/* ignore errors, as we might be in a readonly repository */
- notes_cache_put(driver->textconv_cache, df->oid.hash, *outbuf,
+ notes_cache_put(driver->textconv_cache, &df->oid, *outbuf,
size);
/*
* we could save up changes and flush them all at the end,
return size;
}
+int textconv_object(const char *path,
+ unsigned mode,
+ const struct object_id *oid,
+ int oid_valid,
+ char **buf,
+ unsigned long *buf_size)
+{
+ struct diff_filespec *df;
+ struct userdiff_driver *textconv;
+
+ df = alloc_filespec(path);
+ fill_filespec(df, oid, oid_valid, mode);
+ textconv = get_textconv(df);
+ if (!textconv) {
+ free_filespec(df);
+ return 0;
+ }
+
+ *buf_size = fill_textconv(textconv, df, buf);
+ free_filespec(df);
+ return 1;
+}
+
void setup_diff_pager(struct diff_options *opt)
{
/*
OSDN Git Service
