git
/
diff.c
7374 строки · 203.4 Кб
1/*2* Copyright (C) 2005 Junio C Hamano3*/4{133if (!strcasecmp(var, "plain"))134return DIFF_CONTEXT;135return LOOKUP_CONFIG(color_diff_slots, var);136}137{141char *params_copy = xstrdup(params_string);142struct string_list params = STRING_LIST_INIT_NODUP;143int ret = 0;144int i;145}190{193if (!strcmp(value, "log"))194options->submodule_format = DIFF_SUBMODULE_LOG;195else if (!strcmp(value, "short"))196options->submodule_format = DIFF_SUBMODULE_SHORT;197else if (!strcmp(value, "diff"))198options->submodule_format = DIFF_SUBMODULE_INLINE_DIFF;199/*200* Please update $__git_diff_submodule_formats in201* git-completion.bash when you add new formats.202*/203else204return -1;205return 0;206}207{210if (!value)211return DIFF_DETECT_RENAME;212if (!strcasecmp(value, "copies") || !strcasecmp(value, "copy"))213return DIFF_DETECT_COPY;214return git_config_bool(var,value) ? DIFF_DETECT_RENAME : 0;215}216{219if (!value)220return -1;221else if (!strcasecmp(value, "myers") || !strcasecmp(value, "default"))222return 0;223else if (!strcasecmp(value, "minimal"))224return XDF_NEED_MINIMAL;225else if (!strcasecmp(value, "patience"))226return XDF_PATIENCE_DIFF;227else if (!strcasecmp(value, "histogram"))228return XDF_HISTOGRAM_DIFF;229/*230* Please update $__git_diff_algorithms in git-completion.bash231* when you add new algorithms.232*/233return -1;234}235{238const char *rest;239if (skip_prefix(*arg, token, &rest) && (!*rest || *rest == ',')) {240*arg = rest;241return 1;242}243return 0;244}245{248const char *orig_arg = arg;249unsigned val = 0;250}272/*274* These are to give UI layer defaults.275* The core-level commands such as git-diff-files should276* never be affected by the setting of diff.renames277* the user happens to have in the configuration file.278*/279void init_diff_ui_defaults(void)280{281diff_detect_rename_default = DIFF_DETECT_RENAME;282}283{287if (!strcmp(var, "diff.indentheuristic"))288diff_indent_heuristic = git_config_bool(var, value);289return 0;290}291{294switch (git_parse_maybe_bool(arg)) {295case 0:296return COLOR_MOVED_NO;297case 1:298return COLOR_MOVED_DEFAULT;299default:300break;301}302}320{323int ret = 0;324struct string_list l = STRING_LIST_INIT_DUP;325struct string_list_item *i;326}362{366if (!strcmp(var, "diff.color") || !strcmp(var, "color.diff")) {367diff_use_color_default = git_config_colorbool(var, value);368return 0;369}370if (!strcmp(var, "diff.colormoved")) {371int cm = parse_color_moved(value);372if (cm < 0)373return -1;374diff_color_moved_default = cm;375return 0;376}377if (!strcmp(var, "diff.colormovedws")) {378unsigned cm;379if (!value)380return config_error_nonbool(var);381cm = parse_color_moved_ws(value);382if (cm & COLOR_MOVED_WS_ERROR)383return -1;384diff_color_moved_ws_default = cm;385return 0;386}387if (!strcmp(var, "diff.context")) {388diff_context_default = git_config_int(var, value, ctx->kvi);389if (diff_context_default < 0)390return -1;391return 0;392}393if (!strcmp(var, "diff.interhunkcontext")) {394diff_interhunk_context_default = git_config_int(var, value,395ctx->kvi);396if (diff_interhunk_context_default < 0)397return -1;398return 0;399}400if (!strcmp(var, "diff.renames")) {401diff_detect_rename_default = git_config_rename(var, value);402return 0;403}404if (!strcmp(var, "diff.autorefreshindex")) {405diff_auto_refresh_index = git_config_bool(var, value);406return 0;407}408if (!strcmp(var, "diff.mnemonicprefix")) {409diff_mnemonic_prefix = git_config_bool(var, value);410return 0;411}412if (!strcmp(var, "diff.noprefix")) {413diff_no_prefix = git_config_bool(var, value);414return 0;415}416if (!strcmp(var, "diff.srcprefix")) {417FREE_AND_NULL(diff_src_prefix);418return git_config_string(&diff_src_prefix, var, value);419}420if (!strcmp(var, "diff.dstprefix")) {421FREE_AND_NULL(diff_dst_prefix);422return git_config_string(&diff_dst_prefix, var, value);423}424if (!strcmp(var, "diff.relative")) {425diff_relative = git_config_bool(var, value);426return 0;427}428if (!strcmp(var, "diff.statnamewidth")) {429diff_stat_name_width = git_config_int(var, value, ctx->kvi);430return 0;431}432if (!strcmp(var, "diff.statgraphwidth")) {433diff_stat_graph_width = git_config_int(var, value, ctx->kvi);434return 0;435}436if (!strcmp(var, "diff.external"))437return git_config_string(&external_diff_cfg.cmd, var, value);438if (!strcmp(var, "diff.trustexitcode")) {439external_diff_cfg.trust_exit_code = git_config_bool(var, value);440return 0;441}442if (!strcmp(var, "diff.wordregex"))443return git_config_string(&diff_word_regex_cfg, var, value);444if (!strcmp(var, "diff.orderfile"))445return git_config_pathname(&diff_order_file_cfg, var, value);446}477{481const char *name;482}539{542int need_one = quote_c_style(one, NULL, NULL, CQUOTE_NODQ);543int need_two = quote_c_style(two, NULL, NULL, CQUOTE_NODQ);544struct strbuf res = STRBUF_INIT;545}557{560static struct external_diff external_diff_env, *external_diff_ptr;561static int done_preparing = 0;562}575/*577* Keep track of files used for diffing. Sometimes such an entry578* refers to a temporary file, sometimes to an existing file, and579* sometimes to "/dev/null".580*/581static struct diff_tempfile {582/*583* filename external diff should read from, or NULL if this584* entry is currently not in use:585*/586const char *name;587* If this diff_tempfile instance refers to a temporary file,593* this tempfile object is used to manage its lifetime.594*/595struct tempfile *tempfile;596} diff_temp[2];597{613int count, ch, completely_empty = 1, nl_just_seen = 0;614count = 0;615while (0 < size--) {616ch = *data++;617if (ch == '\n') {618count++;619nl_just_seen = 1;620completely_empty = 0;621}622else {623nl_just_seen = 0;624completely_empty = 0;625}626}627if (completely_empty)628return 0;629if (!nl_just_seen)630count++; /* no trailing newline */631return count;632}633{637if (!DIFF_FILE_VALID(one)) {638mf->ptr = (char *)""; /* does not matter */639mf->size = 0;640return 0;641}642else if (diff_populate_filespec(r, one, NULL))643return -1;644}649/* like fill_mmfile, but only for size, so we can avoid retrieving blob */651static unsigned long diff_filespec_size(struct repository *r,652struct diff_filespec *one)653{654struct diff_populate_filespec_options dpf_options = {655.check_size_only = 1,656};657}663{666char *ptr = mf->ptr;667long size = mf->size;668int cnt = 0;669}689{693int l1, l2, at;694l1 = count_trailing_blank(mf1);695l2 = count_trailing_blank(mf2);696if (l2 <= l1) {697ecbdata->blank_at_eof_in_preimage = 0;698ecbdata->blank_at_eof_in_postimage = 0;699return;700}701at = count_lines(mf1->ptr, mf1->size);702ecbdata->blank_at_eof_in_preimage = (at - l1) + 1;703}707{712int has_trailing_newline, has_trailing_carriage_return;713int needs_reset = 0; /* at the end of the line */714FILE *file = o->file;715}762{766emit_line_0(o, set, NULL, 0, reset, 0, line, len);767}768DIFF_SYMBOL_SEPARATOR804};805/*806* Flags for content lines:807* 0..12 are whitespace rules808* 13-15 are WSEH_NEW | WSEH_OLD | WSEH_CONTEXT809* 16 is marking if the line is blank at EOF810*/811#define DIFF_SYMBOL_CONTENT_BLANK_LINE_EOF (1<<16)812#define DIFF_SYMBOL_MOVED_LINE (1<<17)813#define DIFF_SYMBOL_MOVED_LINE_ALT (1<<18)814#define DIFF_SYMBOL_MOVED_LINE_UNINTERESTING (1<<19)815#define DIFF_SYMBOL_CONTENT_WS_MASK (WSEH_NEW | WSEH_OLD | WSEH_CONTEXT | WS_RULE_MASK)816/*818* This struct is used when we need to buffer the output of the diff output.819*820* NEEDSWORK: Instead of storing a copy of the line, add an offset pointer821* into the pre/post image file. This pointer could be a union with the822* line pointer. By storing an offset into the file instead of the literal line,823* we can decrease the memory footprint for the buffered output. At first we824* may want to only have indirection for the content lines, but we could also825* enhance the state for emitting prefabricated lines, e.g. the similarity826* score line or hunk/file headers would only need to store a number or path827* and then the output can be constructed later on depending on state.828*/829struct emitted_diff_symbol {830const char *line;831int len;832int flags;833int indent_off; /* Offset to first non-whitespace character */834int indent_width; /* The visual width of the indentation */835unsigned id;836enum diff_symbol s;837};838#define EMITTED_DIFF_SYMBOL_INIT { 0 }839{849struct emitted_diff_symbol *f;850}859{862if (!e)863return;864free(e->buf);865free(e);866}867{883unsigned int off = 0, i;884int width = 0, tab_width = es->flags & WS_TAB_WIDTH_MASK;885const char *s = es->line;886const int len = es->len;887}920{924int a_width = a->indent_width,925b_width = b->indent_width;926}932{937int a_width = cur->es->indent_width, b_width = l->indent_width;938int delta;939* If 'l' and 'cur' are both blank then we don't need to check the946* indent. We only need to check cur as we know the strings match.947* */948if (a_width == INDENT_BLANKLINE)949return 0;950* The indent changes of the block are known and stored in pmb->wsd;953* however we need to check if the indent changes of the current line954* match those of the current block.955*/956delta = b_width - a_width;957* If the previous lines of this block were all blank then set its960* whitespace delta.961*/962if (pmb->wsd == INDENT_BLANKLINE)963pmb->wsd = delta;964}967{978const struct diff_options *diffopt = hashmap_cmp_fn_data;979const struct emitted_diff_symbol *a, *b;980unsigned flags = diffopt->color_moved_ws_handling981& XDF_WHITESPACE_FLAGS;982}991{995unsigned flags = o->color_moved_ws_handling & XDF_WHITESPACE_FLAGS;996unsigned int hash = xdiff_hash_string(l->line + l->indent_off,997l->len - l->indent_off, flags);998}1002{1010struct moved_entry *prev_line = NULL;1011struct mem_pool interned_pool;1012struct hashmap interned_map;1013struct moved_entry_list *entry_list = NULL;1014size_t entry_list_alloc = 0;1015unsigned id = 0;1016int n;1017}1068{1074int i, j;1075}1096{1104struct moved_block *pmb = *pmb_p;1105int pmb_alloc = *pmb_alloc_p, pmb_nr = *pmb_nr_p;1106* The current line is the start of a new block.1109* Setup the set of potential blocks.1110*/1111for (; match; match = match->next_match) {1112ALLOC_GROW(pmb, pmb_nr + 1, pmb_alloc);1113if (o->color_moved_ws_handling &1114COLOR_MOVED_WS_ALLOW_INDENTATION_CHANGE)1115pmb[pmb_nr].wsd = compute_ws_delta(l, match->es);1116else1117pmb[pmb_nr].wsd = 0;1118pmb[pmb_nr++].match = match;1119}1120}1125/*1127* If o->color_moved is COLOR_MOVED_PLAIN, this function does nothing.1128*1129* Otherwise, if the last block has fewer alphanumeric characters than1130* COLOR_MOVED_MIN_ALNUM_COUNT, unset DIFF_SYMBOL_MOVED_LINE on all lines in1131* that block.1132*1133* The last block consists of the (n - block_length)'th line up to but not1134* including the nth line.1135*1136* Returns 0 if the last block is empty or is unset by this function, non zero1137* otherwise.1138*1139* NEEDSWORK: This uses the same heuristic as blame_entry_score() in blame.c.1140* Think of a way to unify them.1141*/1142#define DIFF_SYMBOL_MOVED_LINE_ZEBRA_MASK \1143(DIFF_SYMBOL_MOVED_LINE | DIFF_SYMBOL_MOVED_LINE_ALT)1144static int adjust_last_block(struct diff_options *o, int n, int block_length)1145{1146int i, alnum_count = 0;1147if (o->color_moved == COLOR_MOVED_PLAIN)1148return block_length;1149for (i = 1; i < block_length + 1; i++) {1150const char *c = o->emitted_symbols->buf[n - i].line;1151for (; *c; c++) {1152if (!isalnum(*c))1153continue;1154alnum_count++;1155if (alnum_count >= COLOR_MOVED_MIN_ALNUM_COUNT)1156return 1;1157}1158}1159for (i = 1; i < block_length + 1; i++)1160o->emitted_symbols->buf[n - i].flags &= ~DIFF_SYMBOL_MOVED_LINE_ZEBRA_MASK;1161return 0;1162}1163/* Find blocks of moved code, delegate actual coloring decision to helper */1165static void mark_color_as_moved(struct diff_options *o,1166struct moved_entry_list *entry_list)1167{1168struct moved_block *pmb = NULL; /* potentially moved blocks */1169int pmb_nr = 0, pmb_alloc = 0;1170int n, flipped_block = 0, block_length = 0;1171enum diff_symbol moved_symbol = DIFF_SYMBOL_BINARY_DIFF_HEADER;1172* Rewind in case there is another match1194* starting at the second line of the block1195*/1196match = NULL;1197n -= block_length;1198}1199pmb_nr = 0;1200block_length = 0;1201flipped_block = 0;1202}1203if (!match) {1204moved_symbol = DIFF_SYMBOL_BINARY_DIFF_HEADER;1205continue;1206}1207* Rewind in case there is another match1221* starting at the second line of the block1222*/1223n -= block_length;1224else1225fill_potential_moved_blocks(o, match, l,1226&pmb, &pmb_alloc,1227&pmb_nr);1228}1253{1256int n;1257for (n = 0; n < o->emitted_symbols->nr; n++) {1258struct emitted_diff_symbol *prev = (n != 0) ?1259&o->emitted_symbols->buf[n - 1] : NULL;1260struct emitted_diff_symbol *l = &o->emitted_symbols->buf[n];1261struct emitted_diff_symbol *next =1262(n < o->emitted_symbols->nr - 1) ?1263&o->emitted_symbols->buf[n + 1] : NULL;1264* If prev or next are not a plus or minus line,1275* pretend they don't exist1276*/1277if (prev && prev->s != DIFF_SYMBOL_PLUS &&1278prev->s != DIFF_SYMBOL_MINUS)1279prev = NULL;1280if (next && next->s != DIFF_SYMBOL_PLUS &&1281next->s != DIFF_SYMBOL_MINUS)1282next = NULL;1283* The boundary to prev and next are not interesting,1307* so this line is not interesting as a whole1308*/1309l->flags |= DIFF_SYMBOL_MOVED_LINE_UNINTERESTING;1310}1311}1312{1319const char *ws = NULL;1320int sign = o->output_indicators[sign_index];1321}1343{1347static const char *nneof = " No newline at end of file\n";1348const char *context, *reset, *set, *set_sign, *meta, *fraginfo;1349* Skip the prefix character, if any. With1501* diff_suppress_blank_empty, there may be1502* none.1503*/1504if (line[0] != '\n') {1505line++;1506len--;1507}1508emit_line(o, context, reset, line, len);1509break;1510case DIFF_SYMBOL_FILEPAIR_PLUS:1511meta = diff_get_color_opt(o, DIFF_METAINFO);1512reset = diff_get_color_opt(o, DIFF_RESET);1513fprintf(o->file, "%s%s+++ %s%s%s\n", diff_line_prefix(o), meta,1514line, reset,1515strchr(line, ' ') ? "\t" : "");1516break;1517case DIFF_SYMBOL_FILEPAIR_MINUS:1518meta = diff_get_color_opt(o, DIFF_METAINFO);1519reset = diff_get_color_opt(o, DIFF_RESET);1520fprintf(o->file, "%s%s--- %s%s%s\n", diff_line_prefix(o), meta,1521line, reset,1522strchr(line, ' ') ? "\t" : "");1523break;1524case DIFF_SYMBOL_BINARY_FILES:1525case DIFF_SYMBOL_HEADER:1526fprintf(o->file, "%s", line);1527break;1528case DIFF_SYMBOL_BINARY_DIFF_HEADER:1529fprintf(o->file, "%sGIT binary patch\n", diff_line_prefix(o));1530break;1531case DIFF_SYMBOL_BINARY_DIFF_HEADER_DELTA:1532fprintf(o->file, "%sdelta %s\n", diff_line_prefix(o), line);1533break;1534case DIFF_SYMBOL_BINARY_DIFF_HEADER_LITERAL:1535fprintf(o->file, "%sliteral %s\n", diff_line_prefix(o), line);1536break;1537case DIFF_SYMBOL_BINARY_DIFF_FOOTER:1538fputs(diff_line_prefix(o), o->file);1539fputc('\n', o->file);1540break;1541case DIFF_SYMBOL_REWRITE_DIFF:1542fraginfo = diff_get_color(o->use_color, DIFF_FRAGINFO);1543reset = diff_get_color_opt(o, DIFF_RESET);1544emit_line(o, fraginfo, reset, line, len);1545break;1546case DIFF_SYMBOL_SUBMODULE_ADD:1547set = diff_get_color_opt(o, DIFF_FILE_NEW);1548reset = diff_get_color_opt(o, DIFF_RESET);1549emit_line(o, set, reset, line, len);1550break;1551case DIFF_SYMBOL_SUBMODULE_DEL:1552set = diff_get_color_opt(o, DIFF_FILE_OLD);1553reset = diff_get_color_opt(o, DIFF_RESET);1554emit_line(o, set, reset, line, len);1555break;1556case DIFF_SYMBOL_SUBMODULE_UNTRACKED:1557fprintf(o->file, "%sSubmodule %s contains untracked content\n",1558diff_line_prefix(o), line);1559break;1560case DIFF_SYMBOL_SUBMODULE_MODIFIED:1561fprintf(o->file, "%sSubmodule %s contains modified content\n",1562diff_line_prefix(o), line);1563break;1564case DIFF_SYMBOL_STATS_SUMMARY_NO_FILES:1565emit_line(o, "", "", " 0 files changed\n",1566strlen(" 0 files changed\n"));1567break;1568case DIFF_SYMBOL_STATS_SUMMARY_ABBREV:1569emit_line(o, "", "", " ...\n", strlen(" ...\n"));1570break;1571case DIFF_SYMBOL_WORD_DIFF:1572fprintf(o->file, "%.*s", len, line);1573break;1574case DIFF_SYMBOL_STAT_SEP:1575fputs(o->stat_sep, o->file);1576break;1577default:1578BUG("unknown diff symbol");1579}1580}1581{1585struct emitted_diff_symbol e = {1586.line = line, .len = len, .flags = flags, .s = s1587};1588}1594{1597emit_diff_symbol(o, DIFF_SYMBOL_SUBMODULE_DEL, line, strlen(line), 0);1598}1599{1602emit_diff_symbol(o, DIFF_SYMBOL_SUBMODULE_ADD, line, strlen(line), 0);1603}1604{1607emit_diff_symbol(o, DIFF_SYMBOL_SUBMODULE_UNTRACKED,1608path, strlen(path), 0);1609}1610{1613emit_diff_symbol(o, DIFF_SYMBOL_SUBMODULE_MODIFIED,1614path, strlen(path), 0);1615}1616{1619emit_diff_symbol(o, DIFF_SYMBOL_SUBMODULE_HEADER,1620header, strlen(header), 0);1621}1622{1625emit_diff_symbol(o, DIFF_SYMBOL_SUBMODULE_ERROR, err, strlen(err), 0);1626}1627{1631emit_diff_symbol(o, DIFF_SYMBOL_SUBMODULE_PIPETHROUGH, line, len, 0);1632}1633{1636if (!((ecbdata->ws_rule & WS_BLANK_AT_EOF) &&1637ecbdata->blank_at_eof_in_preimage &&1638ecbdata->blank_at_eof_in_postimage &&1639ecbdata->blank_at_eof_in_preimage <= ecbdata->lno_in_preimage &&1640ecbdata->blank_at_eof_in_postimage <= ecbdata->lno_in_postimage))1641return 0;1642return ws_blank_line(line, len);1643}1644{1648unsigned flags = WSEH_NEW | ecbdata->ws_rule;1649if (new_blank_line_at_eof(ecbdata, line, len))1650flags |= DIFF_SYMBOL_CONTENT_BLANK_LINE_EOF;1651}1654{1658unsigned flags = WSEH_OLD | ecbdata->ws_rule;1659emit_diff_symbol(ecbdata->opt, DIFF_SYMBOL_MINUS, line, len, flags);1660}1661{1665unsigned flags = WSEH_CONTEXT | ecbdata->ws_rule;1666emit_diff_symbol(ecbdata->opt, DIFF_SYMBOL_CONTEXT, line, len, flags);1667}1668{1672const char *context = diff_get_color(ecbdata->color_diff, DIFF_CONTEXT);1673const char *frag = diff_get_color(ecbdata->color_diff, DIFF_FRAGINFO);1674const char *func = diff_get_color(ecbdata->color_diff, DIFF_FUNCINFO);1675const char *reset = diff_get_color(ecbdata->color_diff, DIFF_RESET);1676const char *reverse = ecbdata->color_diff ? GIT_COLOR_REVERSE : "";1677static const char atat[2] = { '@', '@' };1678const char *cp, *ep;1679struct strbuf msgbuf = STRBUF_INIT;1680int org_len = len;1681int i = 1;1682* As a hunk header must begin with "@@ -<old>, +<new> @@",1685* it always is at least 10 bytes long.1686*/1687if (len < 10 ||1688memcmp(line, atat, 2) ||1689!(ep = memmem(line + 2, len - 2, atat, 2))) {1690emit_diff_symbol(ecbdata->opt,1691DIFF_SYMBOL_CONTEXT_MARKER, line, len, 0);1692return;1693}1694ep += 2; /* skip over @@ */1695* trailing "\r\n"1708*/1709for ( ; i < 3; i++)1710if (line[len - i] == '\r' || line[len - i] == '\n')1711len--;1712}1735{1738int i;1739for (i = 0; i < ARRAY_SIZE(diff_temp); i++)1740if (!diff_temp[i].name)1741return diff_temp + i;1742BUG("diff is failing to clean up its tempfiles");1743}1744{1747int i;1748for (i = 0; i < ARRAY_SIZE(diff_temp); i++) {1749if (is_tempfile_active(diff_temp[i].tempfile))1750delete_tempfile(&diff_temp[i].tempfile);1751diff_temp[i].name = NULL;1752}1753}1754{1757switch (count) {1758case 0:1759strbuf_addstr(out, "0,0");1760break;1761case 1:1762strbuf_addstr(out, "1");1763break;1764default:1765strbuf_addf(out, "1,%d", count);1766break;1767}1768}1769{1773const char *endp = NULL;1774}1793{1802int lc_a, lc_b;1803static struct strbuf a_name = STRBUF_INIT, b_name = STRBUF_INIT;1804const char *a_prefix, *b_prefix;1805char *data_one, *data_two;1806size_t size_one, size_two;1807struct emit_callback ecbdata;1808struct strbuf out = STRBUF_INIT;1809}1872{1885ALLOC_GROW(buffer->text.ptr, buffer->text.size + len, buffer->alloc);1886line++;1887len--;1888memcpy(buffer->text.ptr + buffer->text.size, line, len);1889buffer->text.size += len;1890buffer->text.ptr[buffer->text.size] = '\0';1891}1892* color is enabled */1898};1899{1927int print = 0;1928struct strbuf sb = STRBUF_INIT;1929}1967/*1969* '--color-words' algorithm can be described as:1970*1971* 1. collect the minus/plus lines of a diff hunk, divided into1972* minus-lines and plus-lines;1973*1974* 2. break both minus-lines and plus-lines into words and1975* place them into two mmfile_t with one word for each line;1976*1977* 3. use xdiff to run diff on the two mmfile_t to get the words level diff;1978*1979* And for the common parts of the both file, we output the plus side text.1980* diff_words->current_plus is used to trace the current position of the plus file1981* which printed. diff_words->last_minus is used to trace the last minus word1982* printed.1983*1984* For '--graph' to work with '--color-words', we need to output the graph prefix1985* on each line of color words output. Generally, there are two conditions on1986* which we should output the prefix.1987*1988* 1. diff_words->last_minus == 0 &&1989* diff_words->current_plus == diff_words->plus.text.ptr1990*1991* that is: the plus text must start as a new line, and if there is no minus1992* word printed, a graph prefix must be printed.1993*1994* 2. diff_words->current_plus > diff_words->plus.text.ptr &&1995* *(diff_words->current_plus - 1) == '\n'1996*1997* that is: a graph prefix must be printed following a '\n'1998*/1999static int color_words_output_graph_prefix(struct diff_words_data *diff_words)2000{2001if ((diff_words->last_minus == 0 &&2002diff_words->current_plus == diff_words->plus.text.ptr) ||2003(diff_words->current_plus > diff_words->plus.text.ptr &&2004*(diff_words->current_plus - 1) == '\n')) {2005return 1;2006} else {2007return 0;2008}2009}2010{2016struct diff_words_data *diff_words = priv;2017struct diff_words_style *style = diff_words->style;2018const char *minus_begin, *minus_end, *plus_begin, *plus_end;2019struct diff_options *opt = diff_words->opt;2020const char *line_prefix;2021}2063/* This function starts looking at *begin, and returns 0 iff a word was found. */2065static int find_word_boundaries(mmfile_t *buffer, regex_t *word_regex,2066int *begin, int *end)2067{2068while (word_regex && *begin < buffer->size) {2069regmatch_t match[1];2070if (!regexec_buf(word_regex, buffer->ptr + *begin,2071buffer->size - *begin, 1, match, 0)) {2072char *p = memchr(buffer->ptr + *begin + match[0].rm_so,2073'\n', match[0].rm_eo - match[0].rm_so);2074*end = p ? p - buffer->ptr : match[0].rm_eo + *begin;2075*begin += match[0].rm_so;2076if (*begin == *end)2077(*begin)++;2078else2079return *begin > *end;2080} else {2081return -1;2082}2083}2084}2098/*2100* This function splits the words in buffer->text, stores the list with2101* newline separator into out, and saves the offsets of the original words2102* in buffer->orig.2103*/2104static void diff_words_fill(struct diff_words_buffer *buffer, mmfile_t *out,2105regex_t *word_regex)2106{2107int i, j;2108long alloc = 0;2109}2138/* this executes the word diff on the accumulated buffers */2140static void diff_words_show(struct diff_words_data *diff_words)2141{2142xpparam_t xpp;2143xdemitconf_t xecfg;2144mmfile_t minus, plus;2145struct diff_words_style *style = diff_words->style;2146}2192/* In "color-words" mode, show word-diff of words accumulated in the buffer */2194static void diff_words_flush(struct emit_callback *ecbdata)2195{2196struct diff_options *wo = ecbdata->diff_words->opt;2197* NEEDSWORK:2209* Instead of appending each, concat all words to a line?2210*/2211for (i = 0; i < wol->nr; i++)2212append_emitted_diff_symbol(o, &wol->buf[i]);2213}2220{2224/* Use already-loaded driver */2225if (one->driver)2226return;2227}2235{2239diff_filespec_load_driver(one, istate);2240return one->driver->word_regex;2241}2242{2248int i;2249struct diff_options *o = xmalloc(sizeof(struct diff_options));2250memcpy(o, orig_opts, sizeof(struct diff_options));2251}2288{2291if (ecbdata->diff_words) {2292diff_words_flush(ecbdata);2293free_emitted_diff_symbols(ecbdata->diff_words->opt->emitted_symbols);2294free (ecbdata->diff_words->opt);2295free (ecbdata->diff_words->minus.text.ptr);2296free (ecbdata->diff_words->minus.orig);2297free (ecbdata->diff_words->plus.text.ptr);2298free (ecbdata->diff_words->plus.orig);2299if (ecbdata->diff_words->word_regex) {2300regfree(ecbdata->diff_words->word_regex);2301free(ecbdata->diff_words->word_regex);2302}2303FREE_AND_NULL(ecbdata->diff_words);2304}2305}2306{2309if (want_color(diff_use_color))2310return diff_colors[ix];2311return "";2312}2313{2316struct strbuf *msgbuf;2317if (!opt->output_prefix)2318return "";2319}2323{2326const char *cp;2327unsigned long allot;2328size_t l = len;2329}2339{2342const char *p;2343ecbdata->lno_in_preimage = 0;2344ecbdata->lno_in_postimage = 0;2345p = strchr(line, '-');2346if (!p)2347return; /* cannot happen */2348ecbdata->lno_in_preimage = strtol(p + 1, NULL, 10);2349p = strchr(p, '+');2350if (!p)2351return; /* cannot happen */2352ecbdata->lno_in_postimage = strtol(p + 1, NULL, 10);2353}2354{2357struct emit_callback *ecbdata = priv;2358struct diff_options *o = ecbdata->opt;2359* Eat the "no newline at eof" marker as if we2409* saw a "+" or "-" line with nothing on it,2410* and return without diff_words_flush() to2411* defer processing. If this is the end of2412* preimage, more "+" lines may come after it.2413*/2414return 0;2415}2416diff_words_flush(ecbdata);2417emit_diff_symbol(o, s, line, len, 0);2418return 0;2419}2420}2444{2447const char *old_name = a;2448const char *new_name = b;2449int pfx_length, sfx_length;2450int pfx_adjust_for_slash;2451int len_a = strlen(a);2452int len_b = strlen(b);2453int a_midlen, b_midlen;2454int qlen_a = quote_c_style(a, NULL, NULL, 0);2455int qlen_b = quote_c_style(b, NULL, NULL, 0);2456* If there is a common prefix, it must end in a slash. In2479* that case we let this loop run 1 into the prefix to see the2480* same slash.2481*2482* If there is no common prefix, we cannot do this as it would2483* underrun the input strings.2484*/2485pfx_adjust_for_slash = (pfx_length ? 1 : 0);2486while (a + pfx_length - pfx_adjust_for_slash <= old_name &&2487b + pfx_length - pfx_adjust_for_slash <= new_name &&2488*old_name == *new_name) {2489if (*old_name == '/')2490sfx_length = len_a - (old_name - a);2491old_name--;2492new_name--;2493}2494* pfx{mid-a => mid-b}sfx2497* {pfx-a => pfx-b}sfx2498* pfx{sfx-a => sfx-b}2499* name-a => name-b2500*/2501a_midlen = len_a - pfx_length - sfx_length;2502b_midlen = len_b - pfx_length - sfx_length;2503if (a_midlen < 0)2504a_midlen = 0;2505if (b_midlen < 0)2506b_midlen = 0;2507}2521{2526struct diffstat_file *x;2527CALLOC_ARRAY(x, 1);2528ALLOC_GROW(diffstat->files, diffstat->nr + 1, diffstat->alloc);2529diffstat->files[diffstat->nr++] = x;2530if (name_b) {2531x->from_name = xstrdup(name_a);2532x->name = xstrdup(name_b);2533x->is_renamed = 1;2534}2535else {2536x->from_name = NULL;2537x->name = xstrdup(name_a);2538}2539return x;2540}2541{2544struct diffstat_t *diffstat = priv;2545struct diffstat_file *x = diffstat->files[diffstat->nr - 1];2546}2556{2561if (!it)2562return 0;2563/*2564* make sure that at least one '-' or '+' is printed if2565* there is any change to this path. The easiest way is to2566* scale linearly as if the allotted width is one column shorter2567* than it is, and then add 1 to the result.2568*/2569return 1 + (it * (width - 1) / max_change);2570}2571{2575if (cnt <= 0)2576return;2577strbuf_addstr(out, set);2578strbuf_addchars(out, ch, cnt);2579strbuf_addstr(out, reset);2580}2581{2584struct strbuf pname = STRBUF_INIT;2585}2599{2603struct strbuf sb = STRBUF_INIT;2604* For binary diff, the caller may want to print "x files2618* changed" with insertions == 0 && deletions == 0.2619*2620* Not omitting "0 insertions(+), 0 deletions(-)" in this case2621* is probably less confusing (i.e skip over "2 files changed2622* but nothing about added/removed lines? Is this a bug in Git?").2623*/2624if (insertions || deletions == 0) {2625strbuf_addf(&sb,2626(insertions == 1) ? ", %d insertion(+)" : ", %d insertions(+)",2627insertions);2628}2629}2640{2644struct diff_options o;2645memset(&o, 0, sizeof(o));2646o.file = fp;2647}2650{2653int i, len, add, del, adds = 0, dels = 0;2654uintmax_t max_change = 0, max_len = 0;2655int total_files = data->nr, count;2656int width, name_width, graph_width, number_width = 0, bin_width = 0;2657const char *reset, *add_c, *del_c;2658int extra_shown = 0;2659const char *line_prefix = diff_line_prefix(options);2660struct strbuf out = STRBUF_INIT;2661* Find the longest filename and max number of changes2673*/2674for (i = 0; (i < count) && (i < data->nr); i++) {2675struct diffstat_file *file = data->files[i];2676uintmax_t change = file->added + file->deleted;2677* We have width = stat_width or term_columns() columns total.2709* We want a maximum of min(max_len, stat_name_width) for the name part.2710* We want a maximum of min(max_change, stat_graph_width) for the +- part.2711* We also need 1 for " " and 4 + decimal_width(max_change)2712* for " | NNNN " and one the empty column at the end, altogether2713* 6 + decimal_width(max_change).2714*2715* If there's not enough space, we will use the smaller of2716* stat_name_width (if set) and 5/8*width for the filename,2717* and the rest for constant elements + graph part, but no more2718* than stat_graph_width for the graph part.2719* (5/8 gives 50 for filename and 30 for the constant parts + graph2720* for the standard terminal size).2721*2722* In other words: stat_width limits the maximum width, and2723* stat_name_width fixes the maximum width of the filename,2724* and is also used to divide available columns if there2725* aren't enough.2726*2727* Binary files are displayed with "Bin XXX -> YYY bytes"2728* instead of the change count and graph. This part is treated2729* similarly to the graph part, except that it is not2730* "scaled". If total width is too small to accommodate the2731* guaranteed minimum width of the filename part and the2732* separators and this message, this message will "overflow"2733* making the line longer than the maximum width.2734*/2735* NEEDSWORK: line_prefix is often used for "log --graph" output2738* and contains ANSI-colored string. utf8_strnwidth() should be2739* used to correctly count the display width instead of strlen().2740*/2741if (options->stat_width == -1)2742width = term_columns() - strlen(line_prefix);2743else2744width = options->stat_width ? options->stat_width : 80;2745number_width = decimal_width(max_change) > number_width ?2746decimal_width(max_change) : number_width;2747* Guarantee 3/8*16 == 6 for the graph part2755* and 5/8*16 == 10 for the filename part2756*/2757if (width < 16 + 6 + number_width)2758width = 16 + 6 + number_width;2759* First assign sizes that are wanted, ignoring available width.2762* strlen("Bin XXX -> YYY bytes") == bin_width, and the part2763* starting from "XXX" should fit in graph_width.2764*/2765graph_width = max_change + 4 > bin_width ? max_change : bin_width - 4;2766if (options->stat_graph_width &&2767options->stat_graph_width < graph_width)2768graph_width = options->stat_graph_width;2769* Adjust adjustable widths not to exceed maximum width2776*/2777if (name_width + number_width + 6 + graph_width > width) {2778if (graph_width > width * 3/8 - number_width - 6) {2779graph_width = width * 3/8 - number_width - 6;2780if (graph_width < 6)2781graph_width = 6;2782}2783* From here name_width is the width of the name area,2795* and graph_width is the width of the graph area.2796* max_change is used to scale graph properly.2797*/2798for (i = 0; i < count; i++) {2799const char *prefix = "";2800struct diffstat_file *file = data->files[i];2801char *name = file->print_name;2802uintmax_t added = file->added;2803uintmax_t deleted = file->deleted;2804int name_len, padding;2805* "scale" the filename2811*/2812len = name_width;2813name_len = utf8_strwidth(name);2814if (name_width < name_len) {2815char *slash;2816prefix = "...";2817len -= 3;2818/*2819* NEEDSWORK: (name_len - len) counts the display2820* width, which would be shorter than the byte2821* length of the corresponding substring.2822* Advancing "name" by that number of bytes does2823* *NOT* skip over that many columns, so it is2824* very likely that chomping the pathname at the2825* slash we will find starting from "name" will2826* leave the resulting string still too long.2827*/2828name += name_len - len;2829slash = strchr(name, '/');2830if (slash)2831name = slash;2832}2833padding = len - utf8_strwidth(name);2834if (padding < 0)2835padding = 0;2836* scale the add/delete2871*/2872add = added;2873del = deleted;2874}2927{2930int i, adds = 0, dels = 0, total_files = data->nr;2931}2949{2952int i;2953}2986{3000unsigned long sum_changes = 0;3001unsigned int sources = 0;3002const char *line_prefix = diff_line_prefix(opt);3003* We don't report dirstat's for3030* - the top level3031* - or cases where everything came from a single directory3032* under this directory (sources == 1).3033*/3034if (baselen && sources != 1) {3035if (sum_changes) {3036int permille = sum_changes * 1000 / changed;3037if (permille >= dir->permille) {3038fprintf(opt->file, "%s%4d.%01d%% %.*s\n", line_prefix,3039permille / 10, permille % 10, baselen, base);3040if (!dir->cumulative)3041return 0;3042}3043}3044}3045return sum_changes;3046}3047{3050const struct dirstat_file *a = _a;3051const struct dirstat_file *b = _b;3052return strcmp(a->name, b->name);3053}3054{3059struct dirstat_file *to_free = dir->files;3060}3072{3075int i;3076unsigned long changed;3077struct dirstat_dir dir;3078struct diff_queue_struct *q = &diff_queued_diff;3079* The SHA1 has not changed, so pre-/post-content is3101* identical. We can therefore skip looking at the3102* file contents altogether.3103*/3104damage = 0;3105goto found_damage;3106}3107* In --dirstat-by-file mode, we don't really need to3111* look at the actual file contents at all.3112* The fact that the SHA1 changed is enough for us to3113* add this file to the list of results3114* (with each file contributing equal damage).3115*/3116damage = 1;3117goto found_damage;3118}3119* Original minus copied is the removed material,3142* added is the new material. They are both damages3143* made to the preimage.3144* If the resulting damage is zero, we know that3145* diffcore_count_changes() considers the two entries to3146* be identical, but since the oid changed, we3147* know that there must have been _some_ kind of change,3148* so we force all entries to have damage > 0.3149*/3150damage = (p->one->size - copied) + added;3151if (!damage)3152damage = 1;3153}3164{3167int i;3168unsigned long changed;3169struct dirstat_dir dir;3170* binary files counts bytes, not lines. Must find some3187* way to normalize binary bytes vs. textual lines.3188* The following heuristic assumes that there are 643189* bytes per "line".3190* This is stupid and ugly, but very cheap...3191*/3192damage = DIV_ROUND_UP(damage, 64);3193ALLOC_GROW(dir.files, dir.nr + 1, dir.alloc);3194dir.files[dir.nr].name = file->name;3195dir.files[dir.nr].changed = damage;3196changed += damage;3197dir.nr++;3198}3199}3202{3205free(f->print_name);3206free(f->name);3207free(f->from_name);3208free(f);3209}3210{3213int i;3214for (i = 0; i < diffstat->nr; i++)3215free_diffstat_file(diffstat->files[i]);3216free(diffstat->files);3217}3218{3230char firstchar;3231int cnt;3232}3250{3257struct checkdiff_t *data = priv;3258data->lineno = nb - 1;3259}3260{3263struct checkdiff_t *data = priv;3264int marker_size = data->conflict_marker_size;3265const char *ws = diff_get_color(data->o->use_color, DIFF_WHITESPACE);3266const char *reset = diff_get_color(data->o->use_color, DIFF_RESET);3267const char *set = diff_get_color(data->o->use_color, DIFF_FILE_NEW);3268char *err;3269const char *line_prefix;3270}3299{3304int bound;3305unsigned char *deflated;3306git_zstream stream;3307}3322{3326void *cp;3327void *delta;3328void *deflated;3329void *data;3330unsigned long orig_size;3331unsigned long delta_size;3332unsigned long deflate_size;3333unsigned long data_size;3334* whichever is smaller.3337*/3338delta = NULL;3339deflated = deflate_it(two->ptr, two->size, &deflate_size);3340if (one->size && two->size) {3341delta = diff_delta(one->ptr, one->size,3342two->ptr, two->size,3343&delta_size, deflate_size);3344if (delta) {3345void *to_free = delta;3346orig_size = delta_size;3347delta = deflate_it(delta, delta_size, &delta_size);3348free(to_free);3349}3350}3351}3394{3398emit_diff_symbol(o, DIFF_SYMBOL_BINARY_DIFF_HEADER, NULL, 0, 0);3399emit_binary_diff_body(o, one, two);3400emit_binary_diff_body(o, two, one);3401}3402{3406struct diff_populate_filespec_options dpf_options = {3407.check_binary = 1,3408};3409}3426{3430diff_filespec_load_driver(one, o->repo->index);3431return one->driver->funcname.pattern ? &one->driver->funcname : NULL;3432}3433{3436if (!options->a_prefix)3437options->a_prefix = a;3438if (!options->b_prefix)3439options->b_prefix = b;3440}3441{3444options->a_prefix = options->b_prefix = "";3445}3446{3449options->a_prefix = diff_src_prefix ? diff_src_prefix : "a/";3450options->b_prefix = diff_dst_prefix ? diff_dst_prefix : "b/";3451}3452{3456if (!DIFF_FILE_VALID(one))3457return NULL;3458}3462{3466if (!o->additional_path_headers)3467return NULL;3468return strmap_get(o->additional_path_headers, path);3469}3470{3477const char *next, *newline;3478}3487{3494int i;3495}3500{3504/*3505* This function specifically looks for pairs injected by3506* create_filepairs_for_header_only_notifications(). Such3507* pairs are "phoney" in that they do not represent any3508* content or even mode difference, but were inserted because3509* diff_queued_diff previously had no pair associated with3510* that path but we needed some pair to avoid losing the3511* "remerge CONFLICT" header associated with the path.3512*/3513return !DIFF_FILE_VALID(one) && !DIFF_FILE_VALID(two);3514}3515{3519long value = parse_algorithm_value(alg);3520}3531{3541mmfile_t mf1, mf2;3542const char *lbl[2];3543char *a_one, *b_two;3544const char *meta = diff_get_color_opt(o, DIFF_METAINFO);3545const char *reset = diff_get_color_opt(o, DIFF_RESET);3546const char *a_prefix, *b_prefix;3547struct userdiff_driver *textconv_one = NULL;3548struct userdiff_driver *textconv_two = NULL;3549struct strbuf header = STRBUF_INIT;3550const char *line_prefix = diff_line_prefix(o);3551* We should only reach this point for pairs generated from3595* create_filepairs_for_header_only_notifications(). For3596* these, we want to avoid the "/dev/null" special casing3597* above, because we do not want such pairs shown as either3598* "new file" or "deleted file" below.3599*/3600lbl[0] = a_one;3601lbl[1] = b_two;3602}3603strbuf_addf(&header, "%s%sdiff --git %s %s%s\n", line_prefix, meta, a_one, b_two, reset);3604if (lbl[0][0] == '/') {3605/* /dev/null */3606strbuf_addf(&header, "%s%snew file mode %06o%s\n", line_prefix, meta, two->mode, reset);3607if (xfrm_msg)3608strbuf_addstr(&header, xfrm_msg);3609o->found_changes = 1;3610must_show_header = 1;3611}3612else if (lbl[1][0] == '/') {3613strbuf_addf(&header, "%s%sdeleted file mode %06o%s\n", line_prefix, meta, one->mode, reset);3614if (xfrm_msg)3615strbuf_addstr(&header, xfrm_msg);3616o->found_changes = 1;3617must_show_header = 1;3618}3619else {3620if (one->mode != two->mode) {3621strbuf_addf(&header, "%s%sold mode %06o%s\n", line_prefix, meta, one->mode, reset);3622strbuf_addf(&header, "%s%snew mode %06o%s\n", line_prefix, meta, two->mode, reset);3623o->found_changes = 1;3624must_show_header = 1;3625}3626if (xfrm_msg)3627strbuf_addstr(&header, xfrm_msg);3628* we do not run diff between different kind3631* of objects.3632*/3633if ((one->mode ^ two->mode) & S_IFMT)3634goto free_ab_and_return;3635if (complete_rewrite &&3636(textconv_one || !diff_filespec_is_binary(o->repo, one)) &&3637(textconv_two || !diff_filespec_is_binary(o->repo, two))) {3638emit_diff_symbol(o, DIFF_SYMBOL_HEADER,3639header.buf, header.len, 0);3640strbuf_reset(&header);3641emit_rewrite_diff(name_a, name_b, one, two,3642textconv_one, textconv_two, o);3643o->found_changes = 1;3644goto free_ab_and_return;3645}3646}3647}3777{3780if (!is_renamed) {3781if (p->status == DIFF_STATUS_ADDED) {3782if (S_ISLNK(p->two->mode))3783return "new +l";3784else if ((p->two->mode & 0777) == 0755)3785return "new +x";3786else3787return "new";3788} else if (p->status == DIFF_STATUS_DELETED)3789return "gone";3790}3791if (S_ISLNK(p->one->mode) && !S_ISLNK(p->two->mode))3792return "mode -l";3793else if (!S_ISLNK(p->one->mode) && S_ISLNK(p->two->mode))3794return "mode +l";3795else if ((p->one->mode & 0777) == 0644 &&3796(p->two->mode & 0777) == 0755)3797return "mode +x";3798else if ((p->one->mode & 0777) == 0755 &&3799(p->two->mode & 0777) == 0644)3800return "mode -x";3801return NULL;3802}3803{3811mmfile_t mf1, mf2;3812struct diffstat_file *data;3813int may_differ;3814int complete_rewrite = 0;3815* Omit diffstats of modified files where nothing changed.3882* Even if may_differ, this might be the case due to3883* ignoring whitespace changes, etc.3884*3885* But note that we special-case additions, deletions,3886* renames, and mode changes as adding an empty file,3887* for example is still of interest.3888*/3889if ((p->status == DIFF_STATUS_MODIFIED)3890&& !file->added3891&& !file->deleted3892&& one->mode == two->mode) {3893free_diffstat_file(file);3894diffstat->nr--;3895}3896}3897}3898}3902{3909mmfile_t mf1, mf2;3910struct checkdiff_t data;3911* All the other codepaths check both sides, but not checking3928* the "old" side here is deliberate. We are checking the newly3929* introduced changes, and as long as the "new" side is text, we3930* can and should check what it introduces.3931*/3932if (diff_filespec_is_binary(o->repo, two))3933goto free_and_return;3934else {3935/* Crazy xdl interfaces.. */3936xpparam_t xpp;3937xdemitconf_t xecfg;3938}3972{3975struct diff_filespec *spec;3976}3982{3985if (!--spec->count) {3986diff_free_filespec_data(spec);3987free(spec);3988}3989}3990{3994if (mode) {3995spec->mode = canon_mode(mode);3996oidcpy(&spec->oid, oid);3997spec->oid_valid = oid_valid;3998}3999}4000/*4002* Given a name and sha1 pair, if the index tells us the file in4003* the work tree has that object contents, return true, so that4004* prepare_temp_file() does not have to inflate and extract.4005*/4006static int reuse_worktree_file(struct index_state *istate,4007const char *name,4008const struct object_id *oid,4009int want_file)4010{4011const struct cache_entry *ce;4012struct stat st;4013int pos, len;4014* We do not read the cache ourselves here, because the4017* benchmark with my previous version that always reads cache4018* shows that it makes things worse for diff-tree comparing4019* two linux-2.6 kernel trees in an already checked out work4020* tree. This is because most diff-tree comparisons deal with4021* only a small number of files, while reading the cache is4022* expensive for a large project, and its cost outweighs the4023* savings we get by not inflating the object to a temporary4024* file. Practically, this code only helps when we are used4025* by diff-cache --cached, which does read the cache before4026* calling us.4027*/4028if (!istate->cache)4029return 0;4030* doesn't need the data in a normal file, this system4033* is rather slow with its stat/open/mmap/close syscalls,4034* and the object is contained in a pack file. The pack4035* is probably already open and will be faster to obtain4036* the data through than the working directory. Loose4037* objects however would tend to be slower as they need4038* to be individually opened and inflated.4039*/4040if (!FAST_WORKING_DIRECTORY && !want_file && has_object_pack(oid))4041return 0;4042* Similarly, if we'd have to convert the file contents anyway, that4045* makes the optimization not worthwhile.4046*/4047if (!want_file && would_convert_to_git(istate, name))4048return 0;4049* If this path does not match our sparse-checkout definition,4052* then the file will not be in the working directory.4053*/4054if (!path_in_sparse_checkout(name, istate))4055return 0;4056* This is not the sha1 we are looking for, or4065* unreusable because it is not a regular file.4066*/4067if (!oideq(oid, &ce->oid) || !S_ISREG(ce->ce_mode))4068return 0;4069* If ce is marked as "assume unchanged", there is no4072* guarantee that work tree matches what we are looking for.4073*/4074if ((ce->ce_flags & CE_VALID) || ce_skip_worktree(ce))4075return 0;4076* If ce matches the file in the work tree, we can reuse it.4079*/4080if (ce_uptodate(ce) ||4081(!lstat(name, &st) && !ie_match_stat(istate, ce, &st, 0)))4082return 1;4083}4086{4089struct strbuf buf = STRBUF_INIT;4090const char *dirty = "";4091}4108/*4110* While doing rename detection and pickaxe operation, we may need to4111* grab the data for the blob (or file) for our own in-core comparison.4112* diff_filespec has data and size fields for this purpose.4113*/4114int diff_populate_filespec(struct repository *r,4115struct diff_filespec *s,4116const struct diff_populate_filespec_options *options)4117{4118int size_only = options ? options->check_size_only : 0;4119int check_binary = options ? options->check_binary : 0;4120int err = 0;4121int conv_flags = global_conv_flags_eol;4122/*4123* demote FAIL to WARN to allow inspecting the situation4124* instead of refusing.4125*/4126if (conv_flags & CONV_EOL_RNDTRP_DIE)4127conv_flags = CONV_EOL_RNDTRP_WARN;4128* Even if the caller would be happy with getting4173* only the size, we cannot return early at this4174* point if the path requires us to run the content4175* conversion.4176*/4177if (size_only && !would_convert_to_git(r->index, s->path))4178return 0;4179* Note: this check uses xsize_t(st.st_size) that may4182* not be the true size of the blob after it goes4183* through convert_to_git(). This may not strictly be4184* correct, but the whole point of big_file_threshold4185* and is_binary check being that we want to avoid4186* opening the file and inspecting the contents, this4187* is probably fine.4188*/4189if (check_binary &&4190s->size > big_file_threshold && s->is_binary == -1) {4191s->is_binary = 1;4192return 0;4193}4194fd = open(s->path, O_RDONLY);4195if (fd < 0)4196goto err_empty;4197s->data = xmmap(NULL, s->size, PROT_READ, MAP_PRIVATE, fd, 0);4198close(fd);4199s->should_munmap = 1;4200* Convert from working tree format to canonical git format4203*/4204if (convert_to_git(r->index, s->path, s->data, s->size, &buf, conv_flags)) {4205size_t size = 0;4206munmap(s->data, s->size);4207s->should_munmap = 0;4208s->data = strbuf_detach(&buf, &size);4209s->size = size;4210s->should_free = 1;4211}4212}4213else {4214struct object_info info = {4215.sizep = &s->size4216};4217* Set contentp, since there is no chance that merely4221* the size is sufficient.4222*/4223info.contentp = &s->data;4224}4255{4258if (s->should_free)4259free(s->data);4260else if (s->should_munmap)4261munmap(s->data, s->size);4262}4268{4271if (!s)4272return;4273}4277{4285struct strbuf buf = STRBUF_INIT;4286char *path_dup = xstrdup(path);4287const char *base = basename(path_dup);4288struct checkout_metadata meta;4289}4309{4313struct diff_tempfile *temp = claim_diff_tempfile();4314* a '+' entry produces this for file-1.4319*/4320temp->name = "/dev/null";4321xsnprintf(temp->hex, sizeof(temp->hex), ".");4322xsnprintf(temp->mode, sizeof(temp->mode), ".");4323return temp;4324}4325* contents from the work tree, we always want4355* one->mode. mode is trustworthy even when4356* !(one->oid_valid), as long as4357* DIFF_FILE_VALID(one).4358*/4359xsnprintf(temp->mode, sizeof(temp->mode), "%06o", one->mode);4360}4361return temp;4362}4363else {4364if (diff_populate_filespec(r, one, NULL))4365die("cannot read data blob for %s", one->path);4366prep_temp_blob(r->index, one->path, temp,4367one->data, one->size,4368&one->oid, one->mode);4369}4370return temp;4371}4372{4377struct diff_tempfile *temp = prepare_temp_file(r, df);4378strvec_push(argv, temp->name);4379strvec_push(argv, temp->hex);4380strvec_push(argv, temp->mode);4381}4382/* An external diff command takes:4384*4385* diff-cmd name infile1 infile1-sha1 infile1-mode \4386* infile2 infile2-sha1 infile2-mode [ rename-to ]4387*4388*/4389static void run_external_diff(const struct external_diff *pgm,4390const char *name,4391const char *other,4392struct diff_filespec *one,4393struct diff_filespec *two,4394const char *xfrm_msg,4395struct diff_options *o)4396{4397struct child_process cmd = CHILD_PROCESS_INIT;4398struct diff_queue_struct *q = &diff_queued_diff;4399int quiet = !(o->output_format & DIFF_FORMAT_PATCH);4400int rc;4401* Trivial equality is handled by diff_unmodified_pair() before4404* we get here. If we don't need to show the diff and the4405* external diff program lacks the ability to tell us whether4406* it's empty then we consider it non-empty without even asking.4407*/4408if (!pgm->trust_exit_code && quiet) {4409o->found_changes = 1;4410return;4411}4412}4446{4449return p->score * 100 / MAX_SCORE;4450}4451{4454if (startup_info->have_repository)4455return repo_find_unique_abbrev(the_repository, oid, abbrev);4456else {4457char *hex = oid_to_hex(oid);4458if (abbrev < 0)4459abbrev = FALLBACK_DEFAULT_ABBREV;4460if (abbrev > the_hash_algo->hexsz)4461BUG("oid abbreviation out of range: %d", abbrev);4462if (abbrev)4463hex[abbrev] = '\0';4464return hex;4465}4466}4467{4478const char *set = diff_get_color(use_color, DIFF_METAINFO);4479const char *reset = diff_get_color(use_color, DIFF_RESET);4480const char *line_prefix = diff_line_prefix(o);4481struct string_list *more_headers = NULL;4482}4546{4557const char *xfrm_msg = NULL;4558int complete_rewrite = (p->status == DIFF_STATUS_MODIFIED) && p->score;4559int must_show_header = 0;4560struct userdiff_driver *drv = NULL;4561* don't use colors when the header is intended for an4571* external diff driver4572*/4573fill_metainfo(msg, name, other, one, two, o, p,4574&must_show_header,4575want_color(o->use_color) && !pgm);4576xfrm_msg = msg->len ? msg->buf : NULL;4577}4578}4595{4598if (DIFF_FILE_VALID(one)) {4599if (!one->oid_valid) {4600struct stat st;4601if (one->is_stdin) {4602oidclr(&one->oid, the_repository->hash_algo);4603return;4604}4605if (lstat(one->path, &st) < 0)4606die_errno("stat '%s'", one->path);4607if (index_path(istate, &one->oid, one->path, &st, 0))4608die("cannot hash %s", one->path);4609}4610}4611else4612oidclr(&one->oid, the_repository->hash_algo);4613}4614{4617/* Strip the prefix but do not molest /dev/null and absolute paths */4618if (*namep && !is_absolute_path(*namep)) {4619*namep += prefix_length;4620if (**namep == '/')4621++*namep;4622}4623if (*otherp && !is_absolute_path(*otherp)) {4624*otherp += prefix_length;4625if (**otherp == '/')4626++*otherp;4627}4628}4629{4632const struct external_diff *pgm = external_diff();4633struct strbuf msg;4634struct diff_filespec *one = p->one;4635struct diff_filespec *two = p->two;4636const char *name;4637const char *other;4638const char *attr_path;4639* a filepair that changes between file and symlink4663* needs to be split into deletion and creation.4664*/4665struct diff_filespec *null = alloc_filespec(two->path);4666run_diff_cmd(NULL, name, other, attr_path,4667one, null, &msg,4668o, p);4669free(null);4670strbuf_release(&msg);4671}4683{4687const char *name;4688const char *other;4689}4717{4720const char *name;4721const char *other;4722const char *attr_path;4723}4741{4744memcpy(options, &default_diff_options, sizeof(*options));4745}4787{4806int i;4807}4813{4816return opt->filter & filter_bit[(int) status];4817}4818{4821prepare_filter_bits();4822return filter_bit[(int) status];4823}4824{4827unsigned forbidden_magic;4828}4849{4852unsigned check_mask = DIFF_FORMAT_NAME |4853DIFF_FORMAT_NAME_STATUS |4854DIFF_FORMAT_CHECKDIFF |4855DIFF_FORMAT_NO_OUTPUT;4856/*4857* This must be signed because we're comparing against a potentially4858* negative value.4859*/4860const int hexsz = the_hash_algo->hexsz;4861* Most of the time we can say "there are changes"4883* only by checking if there are changed paths, but4884* --ignore-whitespace* options force us to look4885* inside contents.4886*/4887* --name-only, --name-status, --checkdiff, and -s4906* turn other output format off.4907*/4908if (options->output_format & (DIFF_FORMAT_NAME |4909DIFF_FORMAT_NAME_STATUS |4910DIFF_FORMAT_CHECKDIFF |4911DIFF_FORMAT_NO_OUTPUT))4912options->output_format &= ~(DIFF_FORMAT_RAW |4913DIFF_FORMAT_NUMSTAT |4914DIFF_FORMAT_DIFFSTAT |4915DIFF_FORMAT_SHORTSTAT |4916DIFF_FORMAT_DIRSTAT |4917DIFF_FORMAT_SUMMARY |4918DIFF_FORMAT_PATCH);4919* These cases always need recursive; we do not drop caller-supplied4922* recursive bits for other formats here.4923*/4924if (options->output_format & (DIFF_FORMAT_PATCH |4925DIFF_FORMAT_NUMSTAT |4926DIFF_FORMAT_DIFFSTAT |4927DIFF_FORMAT_SHORTSTAT |4928DIFF_FORMAT_DIRSTAT |4929DIFF_FORMAT_SUMMARY |4930DIFF_FORMAT_CHECKDIFF))4931options->flags.recursive = 1;4932/*4933* Also pickaxe would not work very well if you do not say recursive4934*/4935if (options->pickaxe_opts & DIFF_PICKAXE_KINDS_MASK)4936options->flags.recursive = 1;4937/*4938* When patches are generated, submodules diffed against the work tree4939* must be checked for dirtiness too so it can be shown in the output4940*/4941if (options->output_format & DIFF_FORMAT_PATCH)4942options->flags.dirty_submodules = 1;4943* It does not make sense to show the first hit we happened4951* to have found. It does not make sense not to return with4952* exit code in such a case either.4953*/4954if (options->flags.quick) {4955options->output_format = DIFF_FORMAT_NO_OUTPUT;4956options->flags.exit_with_status = 1;4957}4958* External diffs could declare non-identical contents equal4961* (think diff --ignore-space-change).4962*/4963if (options->flags.allow_external && options->flags.exit_with_status)4964options->flags.diff_from_contents = 1;4965}4981{4985const char *arg = argv[0];4986if (!skip_prefix(arg, "--", &arg))4987return 0;4988if (!skip_prefix(arg, opt, &arg))4989return 0;4990if (*arg == '=') { /* stuck form: --option=value */4991*optarg = arg + 1;4992return 1;4993}4994if (*arg != '\0')4995return 0;4996/* separate form: --option value */4997if (!argv[1])4998die("Option '--%s' requires a value", opt);4999*optarg = argv[1];5000return 2;5001}5002{5005struct diff_options *options = opt->value;5006int width = options->stat_width;5007int name_width = options->stat_name_width;5008int graph_width = options->stat_graph_width;5009int count = options->stat_count;5010char *end;5011}5055{5058struct strbuf errmsg = STRBUF_INIT;5059if (parse_dirstat_params(options, params, &errmsg))5060die(_("Failed to parse --dirstat/-X option parameter:\n%s"),5061errmsg.buf);5062strbuf_release(&errmsg);5063/*5064* The caller knows a dirstat-related option is given from the command5065* line; allow it to say "return this_function();"5066*/5067options->output_format &= ~DIFF_FORMAT_NO_OUTPUT;5068options->output_format |= DIFF_FORMAT_DIRSTAT;5069return 1;5070}5071{5075struct diff_options *opt = option->value;5076int i, optch;5077}5103{5106*fmt &= ~DIFF_FORMAT_NO_OUTPUT;5107*fmt |= DIFF_FORMAT_PATCH;5108}5109{5113struct diff_options *opt = option->value;5114int val = parse_ws_error_highlight(arg);5115}5123{5127struct diff_options *opt = option->value;5128struct object_id oid;5129}5143{5147struct diff_options *options = opt->value;5148}5156{5160struct diff_options *options = opt->value;5161}5168{5172int *break_opt = opt->value;5173int opt1, opt2;5174}5192{5196char *value = opt->value;5197}5205{5209struct diff_options *options = opt->value;5210}5226{5230struct diff_options *options = opt->value;5231unsigned cm;5232}5244{5248struct diff_options *options = opt->value;5249}5256{5260struct diff_options *options = opt->value;5261}5272{5276struct diff_options *options = opt->value;5277}5288{5292struct diff_options *options = opt->value;5293}5305{5309struct diff_options *options = opt->value;5310}5321{5325struct diff_options *options = opt->value;5326}5341{5345struct diff_options *options = opt->value;5346}5357{5361struct diff_options *options = opt->value;5362}5372{5376struct diff_options *options = opt->value;5377}5385{5389struct diff_options *options = opt->value;5390}5397{5401struct diff_options *options = opt->value;5402}5408{5412struct diff_options *options = opt->value;5413}5421{5426struct diff_options *options = opt->value;5427char *path;5428}5438{5442struct diff_options *options = opt->value;5443int i;5444* Both --patience and --anchored use PATIENCE_DIFF5449* internally, so remove any anchors previously5450* specified.5451*/5452for (i = 0; i < options->anchors_nr; i++)5453free(options->anchors[i]);5454options->anchors_nr = 0;5455options->ignore_driver_algorithm = 1;5456}5459{5463struct diff_options *options = opt->value;5464regex_t *regex;5465}5479{5483struct diff_options *options = opt->value;5484}5490{5494struct diff_options *options = opt->value;5495}5501{5505struct diff_options *options = opt->value;5506}5512{5516struct diff_options *options = opt->value;5517}5526{5530struct diff_options *options = opt->value;5531}5541{5545struct diff_options *options = opt->value;5546char *s;5547}5559{5563struct diff_options *options = opt->value;5564}5585{5589struct diff_options *options = opt->value;5590}5597{5600struct diff_options *options = opt->value;5601}5610/*5612* Consider adding new flags to __git_diff_common_options5613* in contrib/completion/git-completion.bash5614*/5615struct option *add_diff_options(const struct option *opts,5616struct diff_options *options)5617{5618struct option parseopts[] = {5619OPT_GROUP(N_("Diff output format options")),5620OPT_BITOP('p', "patch", &options->output_format,5621N_("generate patch"),5622DIFF_FORMAT_PATCH, DIFF_FORMAT_NO_OUTPUT),5623OPT_SET_INT('s', "no-patch", &options->output_format,5624N_("suppress diff output"), DIFF_FORMAT_NO_OUTPUT),5625OPT_BITOP('u', NULL, &options->output_format,5626N_("generate patch"),5627DIFF_FORMAT_PATCH, DIFF_FORMAT_NO_OUTPUT),5628OPT_CALLBACK_F('U', "unified", options, N_("<n>"),5629N_("generate diffs with <n> lines context"),5630PARSE_OPT_NONEG | PARSE_OPT_OPTARG, diff_opt_unified),5631OPT_BOOL('W', "function-context", &options->flags.funccontext,5632N_("generate diffs with <n> lines context")),5633OPT_BITOP(0, "raw", &options->output_format,5634N_("generate the diff in raw format"),5635DIFF_FORMAT_RAW, DIFF_FORMAT_NO_OUTPUT),5636OPT_BITOP(0, "patch-with-raw", &options->output_format,5637N_("synonym for '-p --raw'"),5638DIFF_FORMAT_PATCH | DIFF_FORMAT_RAW,5639DIFF_FORMAT_NO_OUTPUT),5640OPT_BITOP(0, "patch-with-stat", &options->output_format,5641N_("synonym for '-p --stat'"),5642DIFF_FORMAT_PATCH | DIFF_FORMAT_DIFFSTAT,5643DIFF_FORMAT_NO_OUTPUT),5644OPT_BITOP(0, "numstat", &options->output_format,5645N_("machine friendly --stat"),5646DIFF_FORMAT_NUMSTAT, DIFF_FORMAT_NO_OUTPUT),5647OPT_BITOP(0, "shortstat", &options->output_format,5648N_("output only the last line of --stat"),5649DIFF_FORMAT_SHORTSTAT, DIFF_FORMAT_NO_OUTPUT),5650OPT_CALLBACK_F('X', "dirstat", options, N_("<param1>,<param2>..."),5651N_("output the distribution of relative amount of changes for each sub-directory"),5652PARSE_OPT_NONEG | PARSE_OPT_OPTARG,5653diff_opt_dirstat),5654OPT_CALLBACK_F(0, "cumulative", options, NULL,5655N_("synonym for --dirstat=cumulative"),5656PARSE_OPT_NONEG | PARSE_OPT_NOARG,5657diff_opt_dirstat),5658OPT_CALLBACK_F(0, "dirstat-by-file", options, N_("<param1>,<param2>..."),5659N_("synonym for --dirstat=files,<param1>,<param2>..."),5660PARSE_OPT_NONEG | PARSE_OPT_OPTARG,5661diff_opt_dirstat),5662OPT_BIT_F(0, "check", &options->output_format,5663N_("warn if changes introduce conflict markers or whitespace errors"),5664DIFF_FORMAT_CHECKDIFF, PARSE_OPT_NONEG),5665OPT_BITOP(0, "summary", &options->output_format,5666N_("condensed summary such as creations, renames and mode changes"),5667DIFF_FORMAT_SUMMARY, DIFF_FORMAT_NO_OUTPUT),5668OPT_BIT_F(0, "name-only", &options->output_format,5669N_("show only names of changed files"),5670DIFF_FORMAT_NAME, PARSE_OPT_NONEG),5671OPT_BIT_F(0, "name-status", &options->output_format,5672N_("show only names and status of changed files"),5673DIFF_FORMAT_NAME_STATUS, PARSE_OPT_NONEG),5674OPT_CALLBACK_F(0, "stat", options, N_("<width>[,<name-width>[,<count>]]"),5675N_("generate diffstat"),5676PARSE_OPT_NONEG | PARSE_OPT_OPTARG, diff_opt_stat),5677OPT_CALLBACK_F(0, "stat-width", options, N_("<width>"),5678N_("generate diffstat with a given width"),5679PARSE_OPT_NONEG, diff_opt_stat),5680OPT_CALLBACK_F(0, "stat-name-width", options, N_("<width>"),5681N_("generate diffstat with a given name width"),5682PARSE_OPT_NONEG, diff_opt_stat),5683OPT_CALLBACK_F(0, "stat-graph-width", options, N_("<width>"),5684N_("generate diffstat with a given graph width"),5685PARSE_OPT_NONEG, diff_opt_stat),5686OPT_CALLBACK_F(0, "stat-count", options, N_("<count>"),5687N_("generate diffstat with limited lines"),5688PARSE_OPT_NONEG, diff_opt_stat),5689OPT_CALLBACK_F(0, "compact-summary", options, NULL,5690N_("generate compact summary in diffstat"),5691PARSE_OPT_NOARG, diff_opt_compact_summary),5692OPT_CALLBACK_F(0, "binary", options, NULL,5693N_("output a binary diff that can be applied"),5694PARSE_OPT_NONEG | PARSE_OPT_NOARG, diff_opt_binary),5695OPT_BOOL(0, "full-index", &options->flags.full_index,5696N_("show full pre- and post-image object names on the \"index\" lines")),5697OPT_COLOR_FLAG(0, "color", &options->use_color,5698N_("show colored diff")),5699OPT_CALLBACK_F(0, "ws-error-highlight", options, N_("<kind>"),5700N_("highlight whitespace errors in the 'context', 'old' or 'new' lines in the diff"),5701PARSE_OPT_NONEG, diff_opt_ws_error_highlight),5702OPT_SET_INT('z', NULL, &options->line_termination,5703N_("do not munge pathnames and use NULs as output field terminators in --raw or --numstat"),57040),5705OPT__ABBREV(&options->abbrev),5706OPT_STRING_F(0, "src-prefix", &options->a_prefix, N_("<prefix>"),5707N_("show the given source prefix instead of \"a/\""),5708PARSE_OPT_NONEG),5709OPT_STRING_F(0, "dst-prefix", &options->b_prefix, N_("<prefix>"),5710N_("show the given destination prefix instead of \"b/\""),5711PARSE_OPT_NONEG),5712OPT_CALLBACK_F(0, "line-prefix", options, N_("<prefix>"),5713N_("prepend an additional prefix to every line of output"),5714PARSE_OPT_NONEG, diff_opt_line_prefix),5715OPT_CALLBACK_F(0, "no-prefix", options, NULL,5716N_("do not show any source or destination prefix"),5717PARSE_OPT_NONEG | PARSE_OPT_NOARG, diff_opt_no_prefix),5718OPT_CALLBACK_F(0, "default-prefix", options, NULL,5719N_("use default prefixes a/ and b/"),5720PARSE_OPT_NONEG | PARSE_OPT_NOARG, diff_opt_default_prefix),5721OPT_INTEGER_F(0, "inter-hunk-context", &options->interhunkcontext,5722N_("show context between diff hunks up to the specified number of lines"),5723PARSE_OPT_NONEG),5724OPT_CALLBACK_F(0, "output-indicator-new",5725&options->output_indicators[OUTPUT_INDICATOR_NEW],5726N_("<char>"),5727N_("specify the character to indicate a new line instead of '+'"),5728PARSE_OPT_NONEG, diff_opt_char),5729OPT_CALLBACK_F(0, "output-indicator-old",5730&options->output_indicators[OUTPUT_INDICATOR_OLD],5731N_("<char>"),5732N_("specify the character to indicate an old line instead of '-'"),5733PARSE_OPT_NONEG, diff_opt_char),5734OPT_CALLBACK_F(0, "output-indicator-context",5735&options->output_indicators[OUTPUT_INDICATOR_CONTEXT],5736N_("<char>"),5737N_("specify the character to indicate a context instead of ' '"),5738PARSE_OPT_NONEG, diff_opt_char),5739}5892{5896struct option no_options[] = { OPT_END() };5897struct option *parseopts = add_diff_options(no_options, options);5898}5912{5915unsigned long num, scale;5916int ch, dot;5917const char *cp = *cp_p;5918* is MAX_SCORE * num / scale.5945*/5946return (int)((num >= scale) ? MAX_SCORE : (MAX_SCORE * num / scale));5947}5948{5953ALLOC_GROW(queue->queue, queue->nr + 1, queue->alloc);5954queue->queue[queue->nr++] = dp;5955}5956{5961struct diff_filepair *dp = xcalloc(1, sizeof(*dp));5962dp->one = one;5963dp->two = two;5964if (queue)5965diff_q(queue, dp);5966return dp;5967}5968{5971free_filespec(p->one);5972free_filespec(p->two);5973free(p);5974}5975{5978for (int i = 0; i < q->nr; i++)5979diff_free_filepair(q->queue[i]);5980free(q->queue);5981}5982{5985int abblen;5986const char *abbrev;5987* In well-behaved cases, where the abbreviated result is the6002* same as the requested length, append three dots after the6003* abbreviation (hence the whole logic is limited to the case6004* where abblen < 37); when the actual abbreviated result is a6005* bit longer than the requested length, we reduce the number6006* of dots so that they match the well-behaved ones. However,6007* if the actual abbreviation is longer than the requested6008* length by more than three, we give up on aligning, and add6009* three dots anyway, to indicate that the output is not the6010* full object name. Yes, this may be suboptimal, but this6011* appears only in "diff --raw --abbrev" output and it is not6012* worth the effort to change it now. Note that this would6013* likely to work fine when the automatic sizing of default6014* abbreviation length is used--we would be fed -1 in "len" in6015* that case, and will end up always appending three-dots, but6016* the automatic sizing is supposed to give abblen that ensures6017* uniqueness across all objects (statistically speaking).6018*/6019if (abblen < the_hash_algo->hexsz - 3) {6020static char hex[GIT_MAX_HEXSZ + 1];6021if (len < abblen && abblen <= len + 2)6022xsnprintf(hex, sizeof(hex), "%s%.*s", abbrev, len+3-abblen, "..");6023else6024xsnprintf(hex, sizeof(hex), "%s...", abbrev);6025return hex;6026}6027}6030{6033int line_termination = opt->line_termination;6034int inter_name_termination = line_termination ? '\t' : '\0';6035}6066{6069/* This function is written stricter than necessary to support6070* the currently implemented transformers, but the idea is to6071* let transformers to produce diff_filepairs any way they want,6072* and filter and clean them up here before producing the output.6073*/6074struct diff_filespec *one = p->one, *two = p->two;6075* and rename are all interesting.6081*/6082if (DIFF_FILE_VALID(one) != DIFF_FILE_VALID(two) ||6083DIFF_PAIR_MODE_CHANGED(p) ||6084strcmp(one->path, two->path))6085return 0;6086* dealing with a change.6089*/6090if (one->oid_valid && two->oid_valid &&6091oideq(&one->oid, &two->oid) &&6092!one->dirty_submodule && !two->dirty_submodule)6093return 1; /* no change */6094if (!one->oid_valid && !two->oid_valid)6095return 1; /* both look at the same file on the filesystem. */6096return 0;6097}6098{6101int include_conflict_headers =6102(additional_headers(o, p->one->path) &&6103!o->pickaxe_opts &&6104(!o->filter || filter_bit_tst(DIFF_STATUS_UNMERGED, o)));6105* Check if we can return early without showing a diff. Note that6108* diff_filepair only stores {oid, path, mode, is_valid}6109* information for each path, and thus diff_unmodified_pair() only6110* considers those bits of info. However, we do not want pairs6111* created by create_filepairs_for_header_only_notifications()6112* (which always look like unmodified pairs) to be ignored, so6113* return early if both p is unmodified AND we don't want to6114* include_conflict_headers.6115*/6116if (diff_unmodified_pair(p) && !include_conflict_headers)6117return;6118}6126{6130if (diff_unmodified_pair(p))6131return;6132}6139{6143if (diff_unmodified_pair(p))6144return;6145}6152{6155struct diff_queue_struct *q = &diff_queued_diff;6156int i;6157int include_conflict_headers =6158(o->additional_path_headers &&6159strmap_get_size(o->additional_path_headers) &&6160!o->pickaxe_opts &&6161(!o->filter || filter_bit_tst(DIFF_STATUS_UNMERGED, o)));6162}6171{6175fprintf(stderr, "queue[%d] %s (%s) %s %06o %s\n",6176x, one ? one : "",6177s->path,6178DIFF_FILE_VALID(s) ? "valid" : "invalid",6179s->mode,6180s->oid_valid ? oid_to_hex(&s->oid) : "");6181fprintf(stderr, "queue[%d] %s size %lu\n",6182x, one ? one : "",6183s->size);6184}6185{6188diff_debug_filespec(p->one, i, "one");6189diff_debug_filespec(p->two, i, "two");6190fprintf(stderr, "score %d, status %c rename_used %d broken %d\n",6191p->score, p->status ? p->status : '?',6192p->one->rename_used, p->broken_pair);6193}6194{6197int i;6198if (msg)6199fprintf(stderr, "%s\n", msg);6200fprintf(stderr, "q->nr = %d\n", q->nr);6201for (i = 0; i < q->nr; i++) {6202struct diff_filepair *p = q->queue[i];6203diff_debug_filepair(p, i);6204}6205}6206#endif6207{6210int i;6211struct diff_filepair *p;6212struct diff_queue_struct *q = &diff_queued_diff;6213* whose both sides are valid and of the same type, i.e.6230* either in-place edit or rename/copy edit.6231*/6232else if (DIFF_PAIR_RENAME(p)) {6233/*6234* A rename might have re-connected a broken6235* pair up, causing the pathnames to be the6236* same again. If so, that's not a rename at6237* all, just a modification..6238*6239* Otherwise, see if this source was used for6240* multiple renames, in which case we decrement6241* the count, and call it a copy.6242*/6243if (!strcmp(p->one->path, p->two->path))6244p->status = DIFF_STATUS_MODIFIED;6245else if (--p->one->rename_used > 0)6246p->status = DIFF_STATUS_COPIED;6247else6248p->status = DIFF_STATUS_RENAMED;6249}6250else if (!oideq(&p->one->oid, &p->two->oid) ||6251p->one->mode != p->two->mode ||6252p->one->dirty_submodule ||6253p->two->dirty_submodule ||6254is_null_oid(&p->one->oid))6255p->status = DIFF_STATUS_MODIFIED;6256else {6257/* This is a "no-change" entry and should not6258* happen anymore, but prepare for broken callers.6259*/6260error("feeding unmodified %s to diffcore",6261p->one->path);6262p->status = DIFF_STATUS_UNKNOWN;6263}6264}6265diff_debug_queue("resolve-rename-copy done", q);6266}6267{6270switch (p->status) {6271case DIFF_STATUS_UNKNOWN:6272return 0;6273case 0:6274die("internal error in diff-resolve-rename-copy");6275default:6276return 1;6277}6278}6279{6282int fmt = opt->output_format;6283}6299{6302struct strbuf sb = STRBUF_INIT;6303if (fs->mode)6304strbuf_addf(&sb, " %s mode %06o ", newdelete, fs->mode);6305else6306strbuf_addf(&sb, " %s ", newdelete);6307}6314{6318if (p->one->mode && p->two->mode && p->one->mode != p->two->mode) {6319struct strbuf sb = STRBUF_INIT;6320strbuf_addf(&sb, " mode change %06o => %06o",6321p->one->mode, p->two->mode);6322if (show_name) {6323strbuf_addch(&sb, ' ');6324quote_c_style(p->two->path, &sb, NULL, 0);6325}6326strbuf_addch(&sb, '\n');6327emit_diff_symbol(opt, DIFF_SYMBOL_SUMMARY,6328sb.buf, sb.len, 0);6329strbuf_release(&sb);6330}6331}6332{6336struct strbuf sb = STRBUF_INIT;6337struct strbuf names = STRBUF_INIT;6338}6348{6351switch(p->status) {6352case DIFF_STATUS_DELETED:6353show_file_mode_name(opt, "delete", p->one);6354break;6355case DIFF_STATUS_ADDED:6356show_file_mode_name(opt, "create", p->two);6357break;6358case DIFF_STATUS_COPIED:6359show_rename_copy(opt, "copy", p);6360break;6361case DIFF_STATUS_RENAMED:6362show_rename_copy(opt, "rename", p);6363break;6364default:6365if (p->score) {6366struct strbuf sb = STRBUF_INIT;6367strbuf_addstr(&sb, " rewrite ");6368quote_c_style(p->two->path, &sb, NULL, 0);6369strbuf_addf(&sb, " (%d%%)\n", similarity_index(p));6370emit_diff_symbol(opt, DIFF_SYMBOL_SUMMARY,6371sb.buf, sb.len, 0);6372strbuf_release(&sb);6373}6374show_mode_change(opt, p, !p->score);6375break;6376}6377}6378{6386int i;6387char *dst = line;6388unsigned char c;6389}6396{6399unsigned char hash[GIT_MAX_RAWSZ];6400unsigned short carry = 0;6401int i;6402}6412{6415struct patch_id_t *data = priv;6416int new_len;6417}6426{6429the_hash_algo->update_fn(ctx, str, strlen(str));6430}6431{6434/* large enough for 2^32 in octal */6435char buf[12];6436int len = xsnprintf(buf, sizeof(buf), "%06o", mode);6437the_hash_algo->update_fn(ctx, buf, len);6438}6439/* returns 0 upon success, and writes result into oid */6441static int diff_get_patch_id(struct diff_options *options, struct object_id *oid, int diff_header_only)6442{6443struct diff_queue_struct *q = &diff_queued_diff;6444int i;6445git_hash_ctx ctx;6446struct patch_id_t data;6447}6538{6541struct diff_queue_struct *q = &diff_queued_diff;6542int result = diff_get_patch_id(options, oid, diff_header_only);6543}6549{6552int i;6553}6574{6587fflush(stdout);6588if (degraded_cc)6589warning(_(degrade_cc_to_c_warning));6590else if (needed)6591warning(_(rename_limit_warning));6592else6593return;6594if (0 < needed)6595warning(_(rename_limit_advice), varname, needed);6596}6597{6600struct strset present;6601struct diff_queue_struct *q = &diff_queued_diff;6602struct hashmap_iter iter;6603struct strmap_entry *e;6604int i;6605* Find out which paths exist in diff_queued_diff, preferring6610* one->path for any pair that has multiple paths.6611*/6612for (i = 0; i < q->nr; i++) {6613struct diff_filepair *p = q->queue[i];6614char *path = p->one->path ? p->one->path : p->two->path;6615* Loop over paths in additional_path_headers; for each NOT already6622* in diff_queued_diff, create a synthetic filepair and insert that6623* into diff_queued_diff.6624*/6625strmap_for_each_entry(o->additional_path_headers, &iter, e) {6626if (!strset_contains(&present, e->key)) {6627struct diff_filespec *one, *two;6628struct diff_filepair *p;6629}6645{6648int i;6649static struct emitted_diff_symbols esm = EMITTED_DIFF_SYMBOLS_INIT;6650struct diff_queue_struct *q = &diff_queued_diff;6651}6693{6696if (options->close_file && options->file) {6697fclose(options->file);6698options->file = NULL;6699}6700}6701{6704int i;6705}6714{6717if (options->no_free)6718return;6719}6734{6737struct diff_queue_struct *q = &diff_queued_diff;6738int i, output_format = options->output_format;6739int separator = 0;6740int dirstat_by_line = 0;6741* Order: raw, stat, summary, patch6744* or: name/name-status/checkdiff (other bits clear)6745*/6746if (!q->nr && !options->additional_path_headers)6747goto free_queue;6748* run diff_flush_patch for the exit status. setting6810* options->file to /dev/null should be safe, because we6811* aren't supposed to produce any output anyway.6812*/6813diff_free_file(options);6814options->file = xfopen("/dev/null", "w");6815options->close_file = 1;6816options->color_moved = 0;6817for (i = 0; i < q->nr; i++) {6818struct diff_filepair *p = q->queue[i];6819if (check_pair_status(p))6820diff_flush_patch(p, options);6821if (options->found_changes)6822break;6823}6824}6825* Report the content-level differences with HAS_CHANGES;6833* diff_addremove/diff_change does not set the bit when6834* DIFF_FROM_CONTENTS is in effect (e.g. with -w).6835*/6836if (options->flags.diff_from_contents) {6837if (options->found_changes)6838options->flags.has_changes = 1;6839else6840options->flags.has_changes = 0;6841}6842}6843{6846return (((p->status == DIFF_STATUS_MODIFIED) &&6847((p->score &&6848filter_bit_tst(DIFF_STATUS_FILTER_BROKEN, options)) ||6849(!p->score &&6850filter_bit_tst(DIFF_STATUS_MODIFIED, options)))) ||6851((p->status != DIFF_STATUS_MODIFIED) &&6852filter_bit_tst(p->status, options)));6853}6854{6857int i;6858struct diff_queue_struct *q = &diff_queued_diff;6859struct diff_queue_struct outq;6860* by copying the empty outq at the end of this6877* function, but first clear the current entries6878* in the queue.6879*/6880for (i = 0; i < q->nr; i++)6881diff_free_filepair(q->queue[i]);6882}6883else {6884/* Only the matching ones */6885for (i = 0; i < q->nr; i++) {6886struct diff_filepair *p = q->queue[i];6887if (match_filter(options, p))6888diff_q(&outq, p);6889else6890diff_free_filepair(p);6891}6892}6893free(q->queue);6894*q = outq;6895}6896/* Check whether two filespecs with the same mode and size are identical */6898static int diff_filespec_is_identical(struct repository *r,6899struct diff_filespec *one,6900struct diff_filespec *two)6901{6902if (S_ISGITLINK(one->mode))6903return 0;6904if (diff_populate_filespec(r, one, NULL))6905return 0;6906if (diff_populate_filespec(r, two, NULL))6907return 0;6908return !memcmp(one->data, two->data, one->size);6909}6910{6914struct diff_populate_filespec_options dpf_options = {6915.check_size_only = 1,6916.missing_object_cb = diff_queued_diff_prefetch,6917.missing_object_data = r,6918};6919* 1. Entries that come from stat info dirtiness6927* always have both sides (iow, not create/delete),6928* one side of the object name is unknown, with6929* the same mode and size. Keep the ones that6930* do not match these criteria. They have real6931* differences.6932*6933* 2. At this point, the file is known to be modified,6934* with the same mode and size, and the object6935* name of one side is unknown. Need to inspect6936* the identical contents.6937*/6938if (!DIFF_FILE_VALID(p->one) || /* (1) */6939!DIFF_FILE_VALID(p->two) ||6940(p->one->oid_valid && p->two->oid_valid) ||6941(p->one->mode != p->two->mode) ||6942diff_populate_filespec(r, p->one, &dpf_options) ||6943diff_populate_filespec(r, p->two, &dpf_options) ||6944(p->one->size != p->two->size) ||6945!diff_filespec_is_identical(r, p->one, p->two)) /* (2) */6946p->skip_stat_unmatch_result = 1;6947return p->skip_stat_unmatch_result;6948}6949{6952int i;6953struct diff_queue_struct *q = &diff_queued_diff;6954struct diff_queue_struct outq;6955DIFF_QUEUE_CLEAR(&outq);6956* The caller can subtract 1 from skip_stat_unmatch6965* to determine how many paths were dirty only6966* due to stat info mismatch.6967*/6968if (!diffopt->flags.no_index)6969diffopt->skip_stat_unmatch++;6970diff_free_filepair(p);6971}6972}6973free(q->queue);6974*q = outq;6975}6976{6979const struct diff_filepair *a = *((const struct diff_filepair **)a_);6980const struct diff_filepair *b = *((const struct diff_filepair **)b_);6981const char *name_a, *name_b;6982}6987{6990struct diff_queue_struct *q = &diff_queued_diff;6991QSORT(q->queue, q->nr, diffnamecmp);6992}6993{6998if (filespec && filespec->oid_valid &&6999!S_ISGITLINK(filespec->mode) &&7000oid_object_info_extended(r, &filespec->oid, NULL,7001OBJECT_INFO_FOR_PREFETCH))7002oid_array_append(to_fetch, &filespec->oid);7003}7004{7007struct repository *repo = repository;7008int i;7009struct diff_queue_struct *q = &diff_queued_diff;7010struct oid_array to_fetch = OID_ARRAY_INIT;7011* NEEDSWORK: Consider deduplicating the OIDs sent.7020*/7021promisor_remote_get_direct(repo, to_fetch.oid, to_fetch.nr);7022}7025{7028options->stat_width = -1; /* use full terminal width */7029options->stat_name_width = -1; /* respect diff.statNameWidth config */7030options->stat_graph_width = -1; /* respect diff.statGraphWidth config */7031}7032{7035int output_formats_to_prefetch = DIFF_FORMAT_DIFFSTAT |7036DIFF_FORMAT_NUMSTAT |7037DIFF_FORMAT_PATCH |7038DIFF_FORMAT_SHORTSTAT |7039DIFF_FORMAT_DIRSTAT;7040* Check if the user requested a blob-data-requiring diff output and/or7043* break-rewrite detection (which requires blob data). If yes, prefetch7044* the diff pairs.7045*7046* If no prefetching occurs, diffcore_rename() will prefetch if it7047* decides that it needs inexact rename detection.7048*/7049if (options->repo == the_repository && repo_has_promisor_remote(the_repository) &&7050(options->output_format & output_formats_to_prefetch ||7051options->pickaxe_opts & DIFF_PICKAXE_KINDS_MASK))7052diff_queued_diff_prefetch(options->repo);7053}7085{7088int result = 0;7089}7102{7105return (opt->flags.quick &&7106!opt->filter &&7107opt->flags.has_changes);7108}7109/*7111* Shall changes to this submodule be ignored?7112*7113* Submodule changes can be configured to be ignored separately for each path,7114* but that configuration can be overridden from the command line.7115*/7116static int is_submodule_ignored(const char *path, struct diff_options *options)7117{7118int ignored = 0;7119struct diff_flags orig_flags = options->flags;7120if (!options->flags.override_submodule_config)7121set_diffopt_flags_from_submodule_config(options, path);7122if (options->flags.ignore_submodules)7123ignored = 1;7124options->flags = orig_flags;7125return ignored;7126}7127{7132int i;7133}7142{7149struct diff_filespec *one, *two;7150* feeding "there are unchanged files which should7156* not produce diffs, but when you are doing copy7157* detection you would need them, so here they are"7158* entries to the diff-core. They will be prefixed7159* with something like '=' or '*' (I haven't decided7160* which but should not make any difference).7161* Feeding the same new and old to diff_change()7162* also has the same effect.7163* Before the final output happens, they are pruned after7164* merged into rename/copy pairs as appropriate.7165*/7166if (options->flags.reverse_diff)7167addremove = (addremove == '+' ? '-' :7168addremove == '-' ? '+' : addremove);7169}7188{7197struct diff_filespec *one, *two;7198struct diff_filepair *p;7199}7235{7238struct diff_filepair *pair;7239struct diff_filespec *one, *two;7240}7251{7257struct diff_tempfile *temp;7258struct child_process child = CHILD_PROCESS_INIT;7259struct strbuf buf = STRBUF_INIT;7260int err = 0;7261}7286{7292size_t size;7293* we could save up changes and flush them all at the end,7326* but we would need an extra call after all diffing is done.7327* Since generating a cache entry is the slow path anyway,7328* this extra overhead probably isn't a big deal.7329*/7330notes_cache_write(driver->textconv_cache);7331}7332}7335{7344struct diff_filespec *df;7345struct userdiff_driver *textconv;7346}7359{7362/*7363* If the user asked for our exit code, then either they want --quiet7364* or --exit-code. We should definitely not bother with a pager in the7365* former case, as we will generate no output. Since we still properly7366* report our exit code even when a pager is run, we _could_ run a7367* pager with --exit-code. But since we have not done so historically,7368* and because it is easy to find people oneline advising "git diff7369* --exit-code" in hooks and other scripts, we do not do so.7370*/7371if (!opt->flags.exit_with_status &&7372check_pager_config("diff") != 0)7373setup_pager();7374}7375