Junio C Hamano | cfc5789 | 2009-12-25 00:30:51 -0800 | [diff] [blame] | 1 | #include "cache.h" |
Junio C Hamano | 4421a82 | 2009-12-25 11:57:11 -0800 | [diff] [blame] | 2 | #include "dir.h" |
Junio C Hamano | cfc5789 | 2009-12-25 00:30:51 -0800 | [diff] [blame] | 3 | #include "resolve-undo.h" |
| 4 | #include "string-list.h" |
| 5 | |
| 6 | /* The only error case is to run out of memory in string-list */ |
| 7 | void record_resolve_undo(struct index_state *istate, struct cache_entry *ce) |
| 8 | { |
| 9 | struct string_list_item *lost; |
| 10 | struct resolve_undo_info *ui; |
| 11 | struct string_list *resolve_undo; |
| 12 | int stage = ce_stage(ce); |
| 13 | |
| 14 | if (!stage) |
| 15 | return; |
| 16 | |
| 17 | if (!istate->resolve_undo) { |
| 18 | resolve_undo = xcalloc(1, sizeof(*resolve_undo)); |
| 19 | resolve_undo->strdup_strings = 1; |
| 20 | istate->resolve_undo = resolve_undo; |
| 21 | } |
| 22 | resolve_undo = istate->resolve_undo; |
Julian Phillips | 78a395d | 2010-06-26 00:41:35 +0100 | [diff] [blame] | 23 | lost = string_list_insert(resolve_undo, ce->name); |
Junio C Hamano | cfc5789 | 2009-12-25 00:30:51 -0800 | [diff] [blame] | 24 | if (!lost->util) |
| 25 | lost->util = xcalloc(1, sizeof(*ui)); |
| 26 | ui = lost->util; |
brian m. carlson | 5ac913c | 2018-03-12 02:27:25 +0000 | [diff] [blame] | 27 | oidcpy(&ui->oid[stage - 1], &ce->oid); |
Junio C Hamano | cfc5789 | 2009-12-25 00:30:51 -0800 | [diff] [blame] | 28 | ui->mode[stage - 1] = ce->ce_mode; |
| 29 | } |
| 30 | |
Junio C Hamano | cfc5789 | 2009-12-25 00:30:51 -0800 | [diff] [blame] | 31 | void resolve_undo_write(struct strbuf *sb, struct string_list *resolve_undo) |
| 32 | { |
Alex Riesen | 8a57c6e | 2010-07-03 14:41:54 +0200 | [diff] [blame] | 33 | struct string_list_item *item; |
| 34 | for_each_string_list_item(item, resolve_undo) { |
| 35 | struct resolve_undo_info *ui = item->util; |
| 36 | int i; |
| 37 | |
| 38 | if (!ui) |
| 39 | continue; |
| 40 | strbuf_addstr(sb, item->string); |
| 41 | strbuf_addch(sb, 0); |
| 42 | for (i = 0; i < 3; i++) |
| 43 | strbuf_addf(sb, "%o%c", ui->mode[i], 0); |
| 44 | for (i = 0; i < 3; i++) { |
| 45 | if (!ui->mode[i]) |
| 46 | continue; |
brian m. carlson | 5ac913c | 2018-03-12 02:27:25 +0000 | [diff] [blame] | 47 | strbuf_add(sb, ui->oid[i].hash, the_hash_algo->rawsz); |
Alex Riesen | 8a57c6e | 2010-07-03 14:41:54 +0200 | [diff] [blame] | 48 | } |
| 49 | } |
Junio C Hamano | cfc5789 | 2009-12-25 00:30:51 -0800 | [diff] [blame] | 50 | } |
| 51 | |
Junio C Hamano | b8bba41 | 2010-02-01 22:04:03 -0800 | [diff] [blame] | 52 | struct string_list *resolve_undo_read(const char *data, unsigned long size) |
Junio C Hamano | cfc5789 | 2009-12-25 00:30:51 -0800 | [diff] [blame] | 53 | { |
| 54 | struct string_list *resolve_undo; |
| 55 | size_t len; |
| 56 | char *endptr; |
| 57 | int i; |
brian m. carlson | 5ac913c | 2018-03-12 02:27:25 +0000 | [diff] [blame] | 58 | const unsigned rawsz = the_hash_algo->rawsz; |
Junio C Hamano | cfc5789 | 2009-12-25 00:30:51 -0800 | [diff] [blame] | 59 | |
| 60 | resolve_undo = xcalloc(1, sizeof(*resolve_undo)); |
| 61 | resolve_undo->strdup_strings = 1; |
| 62 | |
| 63 | while (size) { |
| 64 | struct string_list_item *lost; |
| 65 | struct resolve_undo_info *ui; |
| 66 | |
| 67 | len = strlen(data) + 1; |
| 68 | if (size <= len) |
| 69 | goto error; |
Julian Phillips | 78a395d | 2010-06-26 00:41:35 +0100 | [diff] [blame] | 70 | lost = string_list_insert(resolve_undo, data); |
Junio C Hamano | cfc5789 | 2009-12-25 00:30:51 -0800 | [diff] [blame] | 71 | if (!lost->util) |
| 72 | lost->util = xcalloc(1, sizeof(*ui)); |
| 73 | ui = lost->util; |
| 74 | size -= len; |
| 75 | data += len; |
| 76 | |
| 77 | for (i = 0; i < 3; i++) { |
| 78 | ui->mode[i] = strtoul(data, &endptr, 8); |
| 79 | if (!endptr || endptr == data || *endptr) |
| 80 | goto error; |
| 81 | len = (endptr + 1) - (char*)data; |
| 82 | if (size <= len) |
| 83 | goto error; |
| 84 | size -= len; |
| 85 | data += len; |
| 86 | } |
| 87 | |
| 88 | for (i = 0; i < 3; i++) { |
| 89 | if (!ui->mode[i]) |
| 90 | continue; |
brian m. carlson | 5ac913c | 2018-03-12 02:27:25 +0000 | [diff] [blame] | 91 | if (size < rawsz) |
Junio C Hamano | cfc5789 | 2009-12-25 00:30:51 -0800 | [diff] [blame] | 92 | goto error; |
brian m. carlson | 69d1242 | 2018-05-02 00:25:29 +0000 | [diff] [blame] | 93 | oidread(&ui->oid[i], (const unsigned char *)data); |
brian m. carlson | 5ac913c | 2018-03-12 02:27:25 +0000 | [diff] [blame] | 94 | size -= rawsz; |
| 95 | data += rawsz; |
Junio C Hamano | cfc5789 | 2009-12-25 00:30:51 -0800 | [diff] [blame] | 96 | } |
| 97 | } |
| 98 | return resolve_undo; |
| 99 | |
| 100 | error: |
| 101 | string_list_clear(resolve_undo, 1); |
| 102 | error("Index records invalid resolve-undo information"); |
| 103 | return NULL; |
| 104 | } |
| 105 | |
| 106 | void resolve_undo_clear_index(struct index_state *istate) |
| 107 | { |
| 108 | struct string_list *resolve_undo = istate->resolve_undo; |
| 109 | if (!resolve_undo) |
| 110 | return; |
| 111 | string_list_clear(resolve_undo, 1); |
| 112 | free(resolve_undo); |
| 113 | istate->resolve_undo = NULL; |
Nguyễn Thái Ngọc Duy | 6c306a3 | 2014-06-13 19:19:29 +0700 | [diff] [blame] | 114 | istate->cache_changed |= RESOLVE_UNDO_CHANGED; |
Junio C Hamano | cfc5789 | 2009-12-25 00:30:51 -0800 | [diff] [blame] | 115 | } |
Junio C Hamano | 4421a82 | 2009-12-25 11:57:11 -0800 | [diff] [blame] | 116 | |
| 117 | int unmerge_index_entry_at(struct index_state *istate, int pos) |
| 118 | { |
Nguyễn Thái Ngọc Duy | 9c5e6c8 | 2013-07-09 22:29:00 +0700 | [diff] [blame] | 119 | const struct cache_entry *ce; |
Junio C Hamano | 4421a82 | 2009-12-25 11:57:11 -0800 | [diff] [blame] | 120 | struct string_list_item *item; |
| 121 | struct resolve_undo_info *ru; |
Nguyễn Thái Ngọc Duy | e721c15 | 2013-03-27 12:58:21 +0700 | [diff] [blame] | 122 | int i, err = 0, matched; |
Karsten Blees | 5699d17 | 2013-11-14 20:24:37 +0100 | [diff] [blame] | 123 | char *name; |
Junio C Hamano | 4421a82 | 2009-12-25 11:57:11 -0800 | [diff] [blame] | 124 | |
| 125 | if (!istate->resolve_undo) |
| 126 | return pos; |
| 127 | |
| 128 | ce = istate->cache[pos]; |
| 129 | if (ce_stage(ce)) { |
| 130 | /* already unmerged */ |
| 131 | while ((pos < istate->cache_nr) && |
| 132 | ! strcmp(istate->cache[pos]->name, ce->name)) |
| 133 | pos++; |
| 134 | return pos - 1; /* return the last entry processed */ |
| 135 | } |
Julian Phillips | e8c8b71 | 2010-06-26 00:41:37 +0100 | [diff] [blame] | 136 | item = string_list_lookup(istate->resolve_undo, ce->name); |
Junio C Hamano | 4421a82 | 2009-12-25 11:57:11 -0800 | [diff] [blame] | 137 | if (!item) |
| 138 | return pos; |
| 139 | ru = item->util; |
| 140 | if (!ru) |
| 141 | return pos; |
Nguyễn Thái Ngọc Duy | e721c15 | 2013-03-27 12:58:21 +0700 | [diff] [blame] | 142 | matched = ce->ce_flags & CE_MATCHED; |
Karsten Blees | 5699d17 | 2013-11-14 20:24:37 +0100 | [diff] [blame] | 143 | name = xstrdup(ce->name); |
Junio C Hamano | 4421a82 | 2009-12-25 11:57:11 -0800 | [diff] [blame] | 144 | remove_index_entry_at(istate, pos); |
| 145 | for (i = 0; i < 3; i++) { |
| 146 | struct cache_entry *nce; |
| 147 | if (!ru->mode[i]) |
| 148 | continue; |
Jameson Miller | a849735 | 2018-07-02 19:49:31 +0000 | [diff] [blame] | 149 | nce = make_cache_entry(istate, |
| 150 | ru->mode[i], |
| 151 | &ru->oid[i], |
Karsten Blees | 5699d17 | 2013-11-14 20:24:37 +0100 | [diff] [blame] | 152 | name, i + 1, 0); |
Nguyễn Thái Ngọc Duy | e721c15 | 2013-03-27 12:58:21 +0700 | [diff] [blame] | 153 | if (matched) |
| 154 | nce->ce_flags |= CE_MATCHED; |
Junio C Hamano | 4421a82 | 2009-12-25 11:57:11 -0800 | [diff] [blame] | 155 | if (add_index_entry(istate, nce, ADD_CACHE_OK_TO_ADD)) { |
| 156 | err = 1; |
Karsten Blees | 5699d17 | 2013-11-14 20:24:37 +0100 | [diff] [blame] | 157 | error("cannot unmerge '%s'", name); |
Junio C Hamano | 4421a82 | 2009-12-25 11:57:11 -0800 | [diff] [blame] | 158 | } |
| 159 | } |
Karsten Blees | 5699d17 | 2013-11-14 20:24:37 +0100 | [diff] [blame] | 160 | free(name); |
Junio C Hamano | 4421a82 | 2009-12-25 11:57:11 -0800 | [diff] [blame] | 161 | if (err) |
| 162 | return pos; |
| 163 | free(ru); |
| 164 | item->util = NULL; |
| 165 | return unmerge_index_entry_at(istate, pos); |
| 166 | } |
| 167 | |
Nguyễn Thái Ngọc Duy | e721c15 | 2013-03-27 12:58:21 +0700 | [diff] [blame] | 168 | void unmerge_marked_index(struct index_state *istate) |
| 169 | { |
| 170 | int i; |
| 171 | |
| 172 | if (!istate->resolve_undo) |
| 173 | return; |
| 174 | |
| 175 | for (i = 0; i < istate->cache_nr; i++) { |
Nguyễn Thái Ngọc Duy | 9c5e6c8 | 2013-07-09 22:29:00 +0700 | [diff] [blame] | 176 | const struct cache_entry *ce = istate->cache[i]; |
Nguyễn Thái Ngọc Duy | e721c15 | 2013-03-27 12:58:21 +0700 | [diff] [blame] | 177 | if (ce->ce_flags & CE_MATCHED) |
| 178 | i = unmerge_index_entry_at(istate, i); |
| 179 | } |
| 180 | } |
| 181 | |
Nguyễn Thái Ngọc Duy | 5ab0651 | 2013-07-14 15:35:51 +0700 | [diff] [blame] | 182 | void unmerge_index(struct index_state *istate, const struct pathspec *pathspec) |
Junio C Hamano | 4421a82 | 2009-12-25 11:57:11 -0800 | [diff] [blame] | 183 | { |
| 184 | int i; |
| 185 | |
| 186 | if (!istate->resolve_undo) |
| 187 | return; |
| 188 | |
| 189 | for (i = 0; i < istate->cache_nr; i++) { |
Nguyễn Thái Ngọc Duy | 9c5e6c8 | 2013-07-09 22:29:00 +0700 | [diff] [blame] | 190 | const struct cache_entry *ce = istate->cache[i]; |
Nguyễn Thái Ngọc Duy | ff82d12 | 2018-08-13 18:14:37 +0200 | [diff] [blame] | 191 | if (!ce_path_match(istate, ce, pathspec, NULL)) |
Junio C Hamano | 4421a82 | 2009-12-25 11:57:11 -0800 | [diff] [blame] | 192 | continue; |
| 193 | i = unmerge_index_entry_at(istate, i); |
| 194 | } |
| 195 | } |