enums: omit trailing comma for portability
[git] / resolve-undo.c
1 #include "cache.h"
2 #include "dir.h"
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;
23         lost = string_list_insert(ce->name, resolve_undo);
24         if (!lost->util)
25                 lost->util = xcalloc(1, sizeof(*ui));
26         ui = lost->util;
27         hashcpy(ui->sha1[stage - 1], ce->sha1);
28         ui->mode[stage - 1] = ce->ce_mode;
29 }
30
31 static int write_one(struct string_list_item *item, void *cbdata)
32 {
33         struct strbuf *sb = cbdata;
34         struct resolve_undo_info *ui = item->util;
35         int i;
36
37         if (!ui)
38                 return 0;
39         strbuf_addstr(sb, item->string);
40         strbuf_addch(sb, 0);
41         for (i = 0; i < 3; i++)
42                 strbuf_addf(sb, "%o%c", ui->mode[i], 0);
43         for (i = 0; i < 3; i++) {
44                 if (!ui->mode[i])
45                         continue;
46                 strbuf_add(sb, ui->sha1[i], 20);
47         }
48         return 0;
49 }
50
51 void resolve_undo_write(struct strbuf *sb, struct string_list *resolve_undo)
52 {
53         for_each_string_list(write_one, resolve_undo, sb);
54 }
55
56 struct string_list *resolve_undo_read(const char *data, unsigned long size)
57 {
58         struct string_list *resolve_undo;
59         size_t len;
60         char *endptr;
61         int i;
62
63         resolve_undo = xcalloc(1, sizeof(*resolve_undo));
64         resolve_undo->strdup_strings = 1;
65
66         while (size) {
67                 struct string_list_item *lost;
68                 struct resolve_undo_info *ui;
69
70                 len = strlen(data) + 1;
71                 if (size <= len)
72                         goto error;
73                 lost = string_list_insert(data, resolve_undo);
74                 if (!lost->util)
75                         lost->util = xcalloc(1, sizeof(*ui));
76                 ui = lost->util;
77                 size -= len;
78                 data += len;
79
80                 for (i = 0; i < 3; i++) {
81                         ui->mode[i] = strtoul(data, &endptr, 8);
82                         if (!endptr || endptr == data || *endptr)
83                                 goto error;
84                         len = (endptr + 1) - (char*)data;
85                         if (size <= len)
86                                 goto error;
87                         size -= len;
88                         data += len;
89                 }
90
91                 for (i = 0; i < 3; i++) {
92                         if (!ui->mode[i])
93                                 continue;
94                         if (size < 20)
95                                 goto error;
96                         hashcpy(ui->sha1[i], (const unsigned char *)data);
97                         size -= 20;
98                         data += 20;
99                 }
100         }
101         return resolve_undo;
102
103 error:
104         string_list_clear(resolve_undo, 1);
105         error("Index records invalid resolve-undo information");
106         return NULL;
107 }
108
109 void resolve_undo_clear_index(struct index_state *istate)
110 {
111         struct string_list *resolve_undo = istate->resolve_undo;
112         if (!resolve_undo)
113                 return;
114         string_list_clear(resolve_undo, 1);
115         free(resolve_undo);
116         istate->resolve_undo = NULL;
117         istate->cache_changed = 1;
118 }
119
120 int unmerge_index_entry_at(struct index_state *istate, int pos)
121 {
122         struct cache_entry *ce;
123         struct string_list_item *item;
124         struct resolve_undo_info *ru;
125         int i, err = 0;
126
127         if (!istate->resolve_undo)
128                 return pos;
129
130         ce = istate->cache[pos];
131         if (ce_stage(ce)) {
132                 /* already unmerged */
133                 while ((pos < istate->cache_nr) &&
134                        ! strcmp(istate->cache[pos]->name, ce->name))
135                         pos++;
136                 return pos - 1; /* return the last entry processed */
137         }
138         item = string_list_lookup(ce->name, istate->resolve_undo);
139         if (!item)
140                 return pos;
141         ru = item->util;
142         if (!ru)
143                 return pos;
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;
149                 nce = make_cache_entry(ru->mode[i], ru->sha1[i],
150                                        ce->name, i + 1, 0);
151                 if (add_index_entry(istate, nce, ADD_CACHE_OK_TO_ADD)) {
152                         err = 1;
153                         error("cannot unmerge '%s'", ce->name);
154                 }
155         }
156         if (err)
157                 return pos;
158         free(ru);
159         item->util = NULL;
160         return unmerge_index_entry_at(istate, pos);
161 }
162
163 void unmerge_index(struct index_state *istate, const char **pathspec)
164 {
165         int i;
166
167         if (!istate->resolve_undo)
168                 return;
169
170         for (i = 0; i < istate->cache_nr; i++) {
171                 struct cache_entry *ce = istate->cache[i];
172                 if (!match_pathspec(pathspec, ce->name, ce_namelen(ce), 0, NULL))
173                         continue;
174                 i = unmerge_index_entry_at(istate, i);
175         }
176 }