refspec: introduce struct refspec
[git/git.git] / refspec.c
1 #include "cache.h"
2 #include "refs.h"
3 #include "refspec.h"
4
5 static struct refspec_item s_tag_refspec = {
6 0,
7 1,
8 0,
9 0,
10 "refs/tags/*",
11 "refs/tags/*"
12 };
13
14 /* See TAG_REFSPEC for the string version */
15 const struct refspec_item *tag_refspec = &s_tag_refspec;
16
17 /*
18 * Parses the provided refspec 'refspec' and populates the refspec_item 'item'.
19 * Returns 1 if successful and 0 if the refspec is invalid.
20 */
21 static int parse_refspec(struct refspec_item *item, const char *refspec, int fetch)
22 {
23 size_t llen;
24 int is_glob;
25 const char *lhs, *rhs;
26 int flags;
27
28 is_glob = 0;
29
30 lhs = refspec;
31 if (*lhs == '+') {
32 item->force = 1;
33 lhs++;
34 }
35
36 rhs = strrchr(lhs, ':');
37
38 /*
39 * Before going on, special case ":" (or "+:") as a refspec
40 * for pushing matching refs.
41 */
42 if (!fetch && rhs == lhs && rhs[1] == '\0') {
43 item->matching = 1;
44 return 1;
45 }
46
47 if (rhs) {
48 size_t rlen = strlen(++rhs);
49 is_glob = (1 <= rlen && strchr(rhs, '*'));
50 item->dst = xstrndup(rhs, rlen);
51 }
52
53 llen = (rhs ? (rhs - lhs - 1) : strlen(lhs));
54 if (1 <= llen && memchr(lhs, '*', llen)) {
55 if ((rhs && !is_glob) || (!rhs && fetch))
56 return 0;
57 is_glob = 1;
58 } else if (rhs && is_glob) {
59 return 0;
60 }
61
62 item->pattern = is_glob;
63 item->src = xstrndup(lhs, llen);
64 flags = REFNAME_ALLOW_ONELEVEL | (is_glob ? REFNAME_REFSPEC_PATTERN : 0);
65
66 if (fetch) {
67 struct object_id unused;
68
69 /* LHS */
70 if (!*item->src)
71 ; /* empty is ok; it means "HEAD" */
72 else if (llen == GIT_SHA1_HEXSZ && !get_oid_hex(item->src, &unused))
73 item->exact_sha1 = 1; /* ok */
74 else if (!check_refname_format(item->src, flags))
75 ; /* valid looking ref is ok */
76 else
77 return 0;
78 /* RHS */
79 if (!item->dst)
80 ; /* missing is ok; it is the same as empty */
81 else if (!*item->dst)
82 ; /* empty is ok; it means "do not store" */
83 else if (!check_refname_format(item->dst, flags))
84 ; /* valid looking ref is ok */
85 else
86 return 0;
87 } else {
88 /*
89 * LHS
90 * - empty is allowed; it means delete.
91 * - when wildcarded, it must be a valid looking ref.
92 * - otherwise, it must be an extended SHA-1, but
93 * there is no existing way to validate this.
94 */
95 if (!*item->src)
96 ; /* empty is ok */
97 else if (is_glob) {
98 if (check_refname_format(item->src, flags))
99 return 0;
100 }
101 else
102 ; /* anything goes, for now */
103 /*
104 * RHS
105 * - missing is allowed, but LHS then must be a
106 * valid looking ref.
107 * - empty is not allowed.
108 * - otherwise it must be a valid looking ref.
109 */
110 if (!item->dst) {
111 if (check_refname_format(item->src, flags))
112 return 0;
113 } else if (!*item->dst) {
114 return 0;
115 } else {
116 if (check_refname_format(item->dst, flags))
117 return 0;
118 }
119 }
120
121 return 1;
122 }
123
124 static struct refspec_item *parse_refspec_internal(int nr_refspec, const char **refspec, int fetch, int verify)
125 {
126 int i;
127 struct refspec_item *rs = xcalloc(nr_refspec, sizeof(*rs));
128
129 for (i = 0; i < nr_refspec; i++) {
130 if (!parse_refspec(&rs[i], refspec[i], fetch))
131 goto invalid;
132 }
133
134 return rs;
135
136 invalid:
137 if (verify) {
138 /*
139 * nr_refspec must be greater than zero and i must be valid
140 * since it is only possible to reach this point from within
141 * the for loop above.
142 */
143 free_refspec(i+1, rs);
144 return NULL;
145 }
146 die("Invalid refspec '%s'", refspec[i]);
147 }
148
149 int valid_fetch_refspec(const char *fetch_refspec_str)
150 {
151 struct refspec_item *refspec;
152
153 refspec = parse_refspec_internal(1, &fetch_refspec_str, 1, 1);
154 free_refspec(1, refspec);
155 return !!refspec;
156 }
157
158 struct refspec_item *parse_fetch_refspec(int nr_refspec, const char **refspec)
159 {
160 return parse_refspec_internal(nr_refspec, refspec, 1, 0);
161 }
162
163 struct refspec_item *parse_push_refspec(int nr_refspec, const char **refspec)
164 {
165 return parse_refspec_internal(nr_refspec, refspec, 0, 0);
166 }
167
168 void free_refspec(int nr_refspec, struct refspec_item *refspec)
169 {
170 int i;
171
172 if (!refspec)
173 return;
174
175 for (i = 0; i < nr_refspec; i++) {
176 free(refspec[i].src);
177 free(refspec[i].dst);
178 }
179 free(refspec);
180 }
181
182 void refspec_item_init(struct refspec_item *item, const char *refspec, int fetch)
183 {
184 memset(item, 0, sizeof(*item));
185
186 if (!parse_refspec(item, refspec, fetch))
187 die("Invalid refspec '%s'", refspec);
188 }
189
190 void refspec_item_clear(struct refspec_item *item)
191 {
192 FREE_AND_NULL(item->src);
193 FREE_AND_NULL(item->dst);
194 item->force = 0;
195 item->pattern = 0;
196 item->matching = 0;
197 item->exact_sha1 = 0;
198 }
199
200 void refspec_init(struct refspec *rs, int fetch)
201 {
202 memset(rs, 0, sizeof(*rs));
203 rs->fetch = fetch;
204 }
205
206 void refspec_append(struct refspec *rs, const char *refspec)
207 {
208 struct refspec_item item;
209
210 refspec_item_init(&item, refspec, rs->fetch);
211
212 ALLOC_GROW(rs->items, rs->nr + 1, rs->alloc);
213 rs->items[rs->nr++] = item;
214
215 ALLOC_GROW(rs->raw, rs->raw_nr + 1, rs->raw_alloc);
216 rs->raw[rs->raw_nr++] = xstrdup(refspec);
217 }
218
219 void refspec_appendn(struct refspec *rs, const char **refspecs, int nr)
220 {
221 int i;
222 for (i = 0; i < nr; i++)
223 refspec_append(rs, refspecs[i]);
224 }
225
226 void refspec_clear(struct refspec *rs)
227 {
228 int i;
229
230 for (i = 0; i < rs->nr; i++)
231 refspec_item_clear(&rs->items[i]);
232
233 FREE_AND_NULL(rs->items);
234 rs->alloc = 0;
235 rs->nr = 0;
236
237 for (i = 0; i < rs->raw_nr; i++)
238 free((char *)rs->raw[i]);
239 FREE_AND_NULL(rs->raw);
240 rs->raw_alloc = 0;
241 rs->raw_nr = 0;
242
243 rs->fetch = 0;
244 }