return error(_("color moved setting must be one of 'no', 'default', 'blocks', 'zebra', 'dimmed-zebra', 'plain'"));
}
-static int parse_color_moved_ws(const char *arg)
+static unsigned parse_color_moved_ws(const char *arg)
{
int ret = 0;
struct string_list l = STRING_LIST_INIT_DUP;
ret |= XDF_IGNORE_WHITESPACE;
else if (!strcmp(sb.buf, "allow-indentation-change"))
ret |= COLOR_MOVED_WS_ALLOW_INDENTATION_CHANGE;
- else
- error(_("ignoring unknown color-moved-ws mode '%s'"), sb.buf);
+ else {
+ ret |= COLOR_MOVED_WS_ERROR;
+ error(_("unknown color-moved-ws mode '%s', possible values are 'ignore-space-change', 'ignore-space-at-eol', 'ignore-all-space', 'allow-indentation-change'"), sb.buf);
+ }
strbuf_release(&sb);
}
if ((ret & COLOR_MOVED_WS_ALLOW_INDENTATION_CHANGE) &&
- (ret & XDF_WHITESPACE_FLAGS))
- die(_("color-moved-ws: allow-indentation-change cannot be combined with other white space modes"));
+ (ret & XDF_WHITESPACE_FLAGS)) {
+ error(_("color-moved-ws: allow-indentation-change cannot be combined with other white space modes"));
+ ret |= COLOR_MOVED_WS_ERROR;
+ }
string_list_clear(&l, 0);
return 0;
}
if (!strcmp(var, "diff.colormovedws")) {
- int cm = parse_color_moved_ws(value);
- if (cm < 0)
+ unsigned cm = parse_color_moved_ws(value);
+ if (cm & COLOR_MOVED_WS_ERROR)
return -1;
diff_color_moved_ws_default = cm;
return 0;
struct hashmap_entry ent;
const struct emitted_diff_symbol *es;
struct moved_entry *next_line;
- struct ws_delta *wsd;
};
/**
};
#define WS_DELTA_INIT { NULL, 0 }
+struct moved_block {
+ struct moved_entry *match;
+ struct ws_delta wsd;
+};
+
+static void moved_block_clear(struct moved_block *b)
+{
+ FREE_AND_NULL(b->wsd.string);
+ b->match = NULL;
+}
+
static int compute_ws_delta(const struct emitted_diff_symbol *a,
const struct emitted_diff_symbol *b,
struct ws_delta *out)
const struct emitted_diff_symbol *shorter = a->len > b->len ? b : a;
int d = longer->len - shorter->len;
+ if (strncmp(longer->line + d, shorter->line, shorter->len))
+ return 0;
+
out->string = xmemdupz(longer->line, d);
out->current_longer = (a == longer);
- return !strncmp(longer->line + d, shorter->line, shorter->len);
+ return 1;
}
static int cmp_in_block_with_wsd(const struct diff_options *o,
const struct moved_entry *cur,
const struct moved_entry *match,
- struct moved_entry *pmb,
+ struct moved_block *pmb,
int n)
{
struct emitted_diff_symbol *l = &o->emitted_symbols->buf[n];
if (strcmp(a, b))
return 1;
- if (!pmb->wsd)
+ if (!pmb->wsd.string)
/*
- * No white space delta was carried forward? This can happen
- * when we exit early in this function and do not carry
- * forward ws.
+ * The white space delta is not active? This can happen
+ * when we exit early in this function.
*/
return 1;
/*
- * The indent changes of the block are known and carried forward in
+ * The indent changes of the block are known and stored in
* pmb->wsd; however we need to check if the indent changes of the
* current line are still the same as before.
*
* one of them for the white spaces, depending which was longer.
*/
- wslen = strlen(pmb->wsd->string);
- if (pmb->wsd->current_longer) {
+ wslen = strlen(pmb->wsd.string);
+ if (pmb->wsd.current_longer) {
c += wslen;
cl -= wslen;
} else {
al -= wslen;
}
- if (strcmp(a, c))
+ if (al != cl || memcmp(a, c, al))
return 1;
return 0;
ret->ent.hash = xdiff_hash_string(l->line, l->len, flags);
ret->es = l;
ret->next_line = NULL;
- ret->wsd = NULL;
return ret;
}
static void pmb_advance_or_null(struct diff_options *o,
struct moved_entry *match,
struct hashmap *hm,
- struct moved_entry **pmb,
+ struct moved_block *pmb,
int pmb_nr)
{
int i;
for (i = 0; i < pmb_nr; i++) {
- struct moved_entry *prev = pmb[i];
+ struct moved_entry *prev = pmb[i].match;
struct moved_entry *cur = (prev && prev->next_line) ?
prev->next_line : NULL;
if (cur && !hm->cmpfn(o, cur, match, NULL)) {
- pmb[i] = cur;
+ pmb[i].match = cur;
} else {
- pmb[i] = NULL;
+ pmb[i].match = NULL;
}
}
}
static void pmb_advance_or_null_multi_match(struct diff_options *o,
struct moved_entry *match,
struct hashmap *hm,
- struct moved_entry **pmb,
+ struct moved_block *pmb,
int pmb_nr, int n)
{
int i;
for (; match; match = hashmap_get_next(hm, match)) {
for (i = 0; i < pmb_nr; i++) {
- struct moved_entry *prev = pmb[i];
+ struct moved_entry *prev = pmb[i].match;
struct moved_entry *cur = (prev && prev->next_line) ?
prev->next_line : NULL;
if (!cur)
continue;
- if (!cmp_in_block_with_wsd(o, cur, match, pmb[i], n))
+ if (!cmp_in_block_with_wsd(o, cur, match, &pmb[i], n))
got_match[i] |= 1;
}
}
for (i = 0; i < pmb_nr; i++) {
if (got_match[i]) {
- /* Carry the white space delta forward */
- pmb[i]->next_line->wsd = pmb[i]->wsd;
- pmb[i] = pmb[i]->next_line;
+ /* Advance to the next line */
+ pmb[i].match = pmb[i].match->next_line;
} else {
- if (pmb[i]->wsd) {
- free(pmb[i]->wsd->string);
- FREE_AND_NULL(pmb[i]->wsd);
- }
- pmb[i] = NULL;
+ moved_block_clear(&pmb[i]);
}
}
+
+ free(got_match);
}
-static int shrink_potential_moved_blocks(struct moved_entry **pmb,
+static int shrink_potential_moved_blocks(struct moved_block *pmb,
int pmb_nr)
{
int lp, rp;
/* Shrink the set of potential block to the remaining running */
for (lp = 0, rp = pmb_nr - 1; lp <= rp;) {
- while (lp < pmb_nr && pmb[lp])
+ while (lp < pmb_nr && pmb[lp].match)
lp++;
/* lp points at the first NULL now */
- while (rp > -1 && !pmb[rp])
+ while (rp > -1 && !pmb[rp].match)
rp--;
/* rp points at the last non-NULL */
if (lp < pmb_nr && rp > -1 && lp < rp) {
pmb[lp] = pmb[rp];
- pmb[rp] = NULL;
+ pmb[rp].match = NULL;
+ pmb[rp].wsd.string = NULL;
rp--;
lp++;
}
struct hashmap *add_lines,
struct hashmap *del_lines)
{
- struct moved_entry **pmb = NULL; /* potentially moved blocks */
+ struct moved_block *pmb = NULL; /* potentially moved blocks */
int pmb_nr = 0, pmb_alloc = 0;
int n, flipped_block = 1, block_length = 0;
}
if (!match) {
+ int i;
+
adjust_last_block(o, n, block_length);
+ for(i = 0; i < pmb_nr; i++)
+ moved_block_clear(&pmb[i]);
pmb_nr = 0;
block_length = 0;
continue;
ALLOC_GROW(pmb, pmb_nr + 1, pmb_alloc);
if (o->color_moved_ws_handling &
COLOR_MOVED_WS_ALLOW_INDENTATION_CHANGE) {
- struct ws_delta *wsd = xmalloc(sizeof(*match->wsd));
- if (compute_ws_delta(l, match->es, wsd)) {
- match->wsd = wsd;
- pmb[pmb_nr++] = match;
- } else
- free(wsd);
+ if (compute_ws_delta(l, match->es,
+ &pmb[pmb_nr].wsd))
+ pmb[pmb_nr++].match = match;
} else {
- pmb[pmb_nr++] = match;
+ pmb[pmb_nr].wsd.string = NULL;
+ pmb[pmb_nr++].match = match;
}
}
}
adjust_last_block(o, n, block_length);
+ for(n = 0; n < pmb_nr; n++)
+ moved_block_clear(&pmb[n]);
free(pmb);
}
static void emit_line_ws_markup(struct diff_options *o,
const char *set_sign, const char *set,
const char *reset,
- char sign, const char *line, int len,
+ int sign_index, const char *line, int len,
unsigned ws_rule, int blank_at_eof)
{
const char *ws = NULL;
+ int sign = o->output_indicators[sign_index];
if (o->ws_error_highlight & ws_rule) {
ws = diff_get_color_opt(o, DIFF_WHITESPACE);
set = diff_get_color_opt(o, DIFF_FILE_OLD);
}
emit_line_ws_markup(o, set_sign, set, reset,
- o->output_indicators[OUTPUT_INDICATOR_CONTEXT],
- line, len,
+ OUTPUT_INDICATOR_CONTEXT, line, len,
flags & (DIFF_SYMBOL_CONTENT_WS_MASK), 0);
break;
case DIFF_SYMBOL_PLUS:
flags &= ~DIFF_SYMBOL_CONTENT_WS_MASK;
}
emit_line_ws_markup(o, set_sign, set, reset,
- o->output_indicators[OUTPUT_INDICATOR_NEW],
- line, len,
+ OUTPUT_INDICATOR_NEW, line, len,
flags & DIFF_SYMBOL_CONTENT_WS_MASK,
flags & DIFF_SYMBOL_CONTENT_BLANK_LINE_EOF);
break;
set = diff_get_color_opt(o, DIFF_CONTEXT_DIM);
}
emit_line_ws_markup(o, set_sign, set, reset,
- o->output_indicators[OUTPUT_INDICATOR_OLD],
- line, len,
+ OUTPUT_INDICATOR_OLD, line, len,
flags & DIFF_SYMBOL_CONTENT_WS_MASK, 0);
break;
case DIFF_SYMBOL_WORDS_PORCELAIN:
}
}
-static void fn_out_diff_words_aux(void *priv, char *line, unsigned long len)
+static void fn_out_diff_words_aux(void *priv,
+ long minus_first, long minus_len,
+ long plus_first, long plus_len,
+ const char *func, long funclen)
{
struct diff_words_data *diff_words = priv;
struct diff_words_style *style = diff_words->style;
- int minus_first, minus_len, plus_first, plus_len;
const char *minus_begin, *minus_end, *plus_begin, *plus_end;
struct diff_options *opt = diff_words->opt;
const char *line_prefix;
- if (line[0] != '@' || parse_hunk_header(line, len,
- &minus_first, &minus_len, &plus_first, &plus_len))
- return;
-
assert(opt);
line_prefix = diff_line_prefix(opt);
xpp.flags = 0;
/* as only the hunk header will be parsed, we need a 0-context */
xecfg.ctxlen = 0;
- if (xdi_diff_outf(&minus, &plus, fn_out_diff_words_aux, diff_words,
- &xpp, &xecfg))
+ if (xdi_diff_outf(&minus, &plus, fn_out_diff_words_aux, NULL,
+ diff_words, &xpp, &xecfg))
die("unable to generate word diff");
free(minus.ptr);
free(plus.ptr);
return 1;
}
+static void checkdiff_consume_hunk(void *priv,
+ long ob, long on, long nb, long nn,
+ const char *func, long funclen)
+
+{
+ struct checkdiff_t *data = priv;
+ data->lineno = nb - 1;
+}
+
static void checkdiff_consume(void *priv, char *line, unsigned long len)
{
struct checkdiff_t *data = priv;
data->o->file, set, reset, ws);
} else if (line[0] == ' ') {
data->lineno++;
- } else if (line[0] == '@') {
- char *plus = strchr(line, '+');
- if (plus)
- data->lineno = strtol(plus, NULL, 10) - 1;
- else
- die("invalid diff");
}
}
}
if (delta && delta_size < deflate_size) {
- char *s = xstrfmt("%lu", orig_size);
+ char *s = xstrfmt("%"PRIuMAX , (uintmax_t)orig_size);
emit_diff_symbol(o, DIFF_SYMBOL_BINARY_DIFF_HEADER_DELTA,
s, strlen(s), 0);
free(s);
options->b_prefix = b;
}
-struct userdiff_driver *get_textconv(struct index_state *istate,
+struct userdiff_driver *get_textconv(struct repository *r,
struct diff_filespec *one)
{
if (!DIFF_FILE_VALID(one))
return NULL;
- diff_filespec_load_driver(one, istate);
- return userdiff_get_textconv(one->driver);
+ diff_filespec_load_driver(one, r->index);
+ return userdiff_get_textconv(r, one->driver);
}
static void builtin_diff(const char *name_a,
}
if (o->flags.allow_textconv) {
- textconv_one = get_textconv(o->repo->index, one);
- textconv_two = get_textconv(o->repo->index, two);
+ textconv_one = get_textconv(o->repo, one);
+ textconv_two = get_textconv(o->repo, two);
}
/* Never use a non-valid filename anywhere if at all possible */
xecfg.ctxlen = strtoul(v, NULL, 10);
if (o->word_diff)
init_diff_words_data(&ecbdata, o, one, two);
- if (xdi_diff_outf(&mf1, &mf2, fn_out_consume, &ecbdata,
- &xpp, &xecfg))
+ if (xdi_diff_outf(&mf1, &mf2, NULL, fn_out_consume,
+ &ecbdata, &xpp, &xecfg))
die("unable to generate diff for %s", one->path);
if (o->word_diff)
free_diff_words_data(&ecbdata);
xpp.anchors_nr = o->anchors_nr;
xecfg.ctxlen = o->context;
xecfg.interhunkctxlen = o->interhunkcontext;
- if (xdi_diff_outf(&mf1, &mf2, diffstat_consume, diffstat,
- &xpp, &xecfg))
+ if (xdi_diff_outf(&mf1, &mf2, discard_hunk_line,
+ diffstat_consume, diffstat, &xpp, &xecfg))
die("unable to generate diffstat for %s", one->path);
}
memset(&xecfg, 0, sizeof(xecfg));
xecfg.ctxlen = 1; /* at least one context line */
xpp.flags = 0;
- if (xdi_diff_outf(&mf1, &mf2, checkdiff_consume, &data,
+ if (xdi_diff_outf(&mf1, &mf2, checkdiff_consume_hunk,
+ checkdiff_consume, &data,
&xpp, &xecfg))
die("unable to generate checkdiff for %s", one->path);
static void strip_prefix(int prefix_length, const char **namep, const char **otherp)
{
/* Strip the prefix but do not molest /dev/null and absolute paths */
- if (*namep && **namep != '/') {
+ if (*namep && !is_absolute_path(*namep)) {
*namep += prefix_length;
if (**namep == '/')
++*namep;
}
- if (*otherp && **otherp != '/') {
+ if (*otherp && !is_absolute_path(*otherp)) {
*otherp += prefix_length;
if (**otherp == '/')
++*otherp;
else if (skip_prefix(arg, "--color-moved=", &arg)) {
int cm = parse_color_moved(arg);
if (cm < 0)
- die("bad --color-moved argument: %s", arg);
+ return error("bad --color-moved argument: %s", arg);
options->color_moved = cm;
} else if (skip_prefix(arg, "--color-moved-ws=", &arg)) {
- options->color_moved_ws_handling = parse_color_moved_ws(arg);
+ unsigned cm = parse_color_moved_ws(arg);
+ if (cm & COLOR_MOVED_WS_ERROR)
+ return -1;
+ options->color_moved_ws_handling = cm;
} else if (skip_to_optional_arg_default(arg, "--color-words", &options->word_regex, NULL)) {
options->use_color = 1;
options->word_diff = DIFF_WORDS_COLOR;
struct patch_id_t *data = priv;
int new_len;
- /* Ignore line numbers when computing the SHA1 of the patch */
- if (starts_with(line, "@@ -"))
- return;
-
new_len = remove_space(line, len);
git_SHA1_Update(data->ctx, line, new_len);
xpp.flags = 0;
xecfg.ctxlen = 3;
xecfg.flags = 0;
- if (xdi_diff_outf(&mf1, &mf2, patch_id_consume, &data,
- &xpp, &xecfg))
+ if (xdi_diff_outf(&mf1, &mf2, discard_hunk_line,
+ patch_id_consume, &data, &xpp, &xecfg))
return error("unable to generate patch-id diff for %s",
p->one->path);
}
if (o->color_moved == COLOR_MOVED_ZEBRA_DIM)
dim_moved_lines(o);
- hashmap_free(&add_lines, 0);
- hashmap_free(&del_lines, 0);
+ hashmap_free(&add_lines, 1);
+ hashmap_free(&del_lines, 1);
}
for (i = 0; i < esm.nr; i++)
df = alloc_filespec(path);
fill_filespec(df, oid, oid_valid, mode);
- textconv = get_textconv(r->index, df);
+ textconv = get_textconv(r, df);
if (!textconv) {
free_filespec(df);
return 0;