resolve-undo.c

   1 #define DISABLE_SIGN_COMPARE_WARNINGS
   2
   3 #include "git-compat-util.h"
   4 #include "dir.h"
   5 #include "hash.h"
   6 #include "read-cache.h"
   7 #include "resolve-undo.h"
   8 #include "sparse-index.h"
   9 #include "string-list.h"
  10
  11 /* The only error case is to run out of memory in string-list */
  12 void record_resolve_undo(struct index_state *istate, struct cache_entry *ce)
  13 {
  14         struct string_list_item *lost;
  15         struct resolve_undo_info *ui;
  16         struct string_list *resolve_undo;
  17         int stage = ce_stage(ce);
  18
  19         if (!stage)
  20                 return;
  21
  22         if (!istate->resolve_undo) {
  23                 CALLOC_ARRAY(resolve_undo, 1);
  24                 resolve_undo->strdup_strings = 1;
  25                 istate->resolve_undo = resolve_undo;
  26         }
  27         resolve_undo = istate->resolve_undo;
  28         lost = string_list_insert(resolve_undo, ce->name);
  29         if (!lost->util)
  30                 lost->util = xcalloc(1, sizeof(*ui));
  31         ui = lost->util;
  32         oidcpy(&ui->oid[stage - 1], &ce->oid);
  33         ui->mode[stage - 1] = ce->ce_mode;
  34 }
  35
  36 void resolve_undo_write(struct strbuf *sb, struct string_list *resolve_undo,
  37                         const struct git_hash_algo *algop)
  38 {
  39         struct string_list_item *item;
  40         for_each_string_list_item(item, resolve_undo) {
  41                 struct resolve_undo_info *ui = item->util;
  42                 int i;
  43
  44                 if (!ui)
  45                         continue;
  46                 strbuf_addstr(sb, item->string);
  47                 strbuf_addch(sb, 0);
  48                 for (i = 0; i < 3; i++)
  49                         strbuf_addf(sb, "%o%c", ui->mode[i], 0);
  50                 for (i = 0; i < 3; i++) {
  51                         if (!ui->mode[i])
  52                                 continue;
  53                         strbuf_add(sb, ui->oid[i].hash, algop->rawsz);
  54                 }
  55         }
  56 }
  57
  58 struct string_list *resolve_undo_read(const char *data, unsigned long size,
  59                                       const struct git_hash_algo *algop)
  60 {
  61         struct string_list *resolve_undo;
  62         size_t len;
  63         char *endptr;
  64         int i;
  65         const unsigned rawsz = algop->rawsz;
  66
  67         CALLOC_ARRAY(resolve_undo, 1);
  68         resolve_undo->strdup_strings = 1;
  69
  70         while (size) {
  71                 struct string_list_item *lost;
  72                 struct resolve_undo_info *ui;
  73
  74                 len = strlen(data) + 1;
  75                 if (size <= len)
  76                         goto error;
  77                 lost = string_list_insert(resolve_undo, data);
  78                 if (!lost->util)
  79                         lost->util = xcalloc(1, sizeof(*ui));
  80                 ui = lost->util;
  81                 size -= len;
  82                 data += len;
  83
  84                 for (i = 0; i < 3; i++) {
  85                         ui->mode[i] = strtoul(data, &endptr, 8);
  86                         if (!endptr || endptr == data || *endptr)
  87                                 goto error;
  88                         len = (endptr + 1) - (char*)data;
  89                         if (size <= len)
  90                                 goto error;
  91                         size -= len;
  92                         data += len;
  93                 }
  94
  95                 for (i = 0; i < 3; i++) {
  96                         if (!ui->mode[i])
  97                                 continue;
  98                         if (size < rawsz)
  99                                 goto error;
 100                         oidread(&ui->oid[i], (const unsigned char *)data, algop);
 101                         size -= rawsz;
 102                         data += rawsz;
 103                 }
 104         }
 105         return resolve_undo;
 106
 107 error:
 108         string_list_clear(resolve_undo, 1);
 109         error("Index records invalid resolve-undo information");
 110         return NULL;
 111 }
 112
 113 void resolve_undo_clear_index(struct index_state *istate)
 114 {
 115         struct string_list *resolve_undo = istate->resolve_undo;
 116         if (!resolve_undo)
 117                 return;
 118         string_list_clear(resolve_undo, 1);
 119         free(resolve_undo);
 120         istate->resolve_undo = NULL;
 121         istate->cache_changed |= RESOLVE_UNDO_CHANGED;
 122 }
 123
 124 int unmerge_index_entry(struct index_state *istate, const char *path,
 125                         struct resolve_undo_info *ru, unsigned ce_flags)
 126 {
 127         int i = index_name_pos(istate, path, strlen(path));
 128
 129         if (i < 0) {
 130                 /* unmerged? */
 131                 i = -i - 1;
 132                 if (i < istate->cache_nr &&
 133                     !strcmp(istate->cache[i]->name, path))
 134                         /* yes, it is already unmerged */
 135                         return 0;
 136                 /* fallthru: resolved to removal */
 137         } else {
 138                 /* merged - remove it to replace it with unmerged entries */
 139                 remove_index_entry_at(istate, i);
 140         }
 141
 142         for (i = 0; i < 3; i++) {
 143                 struct cache_entry *ce;
 144                 if (!ru->mode[i])
 145                         continue;
 146                 ce = make_cache_entry(istate, ru->mode[i], &ru->oid[i],
 147                                       path, i + 1, 0);
 148                 ce->ce_flags |= ce_flags;
 149                 if (add_index_entry(istate, ce, ADD_CACHE_OK_TO_ADD))
 150                         return error("cannot unmerge '%s'", path);
 151         }
 152         return 0;
 153 }
 154
 155 void unmerge_index(struct index_state *istate, const struct pathspec *pathspec,
 156                    unsigned ce_flags)
 157 {
 158         struct string_list_item *item;
 159
 160         if (!istate->resolve_undo)
 161                 return;
 162
 163         /* TODO: audit for interaction with sparse-index. */
 164         ensure_full_index(istate);
 165
 166         for_each_string_list_item(item, istate->resolve_undo) {
 167                 const char *path = item->string;
 168                 struct resolve_undo_info *ru = item->util;
 169                 if (!item->util)
 170                         continue;
 171                 if (!match_pathspec(istate, pathspec,
 172                                     item->string, strlen(item->string),
 173                                     0, NULL, 0))
 174                         continue;
 175                 unmerge_index_entry(istate, path, ru, ce_flags);
 176                 free(ru);
 177                 item->util = NULL;
 178         }
 179 }