Merge branch 'sg/test-bash-version-fix'
[git.git] / refspec.c
blobf529092fd6d9ba0474fd21b31d72c117794e640d
1 #include "cache.h"
2 #include "argv-array.h"
3 #include "refs.h"
4 #include "refspec.h"
6 static struct refspec_item s_tag_refspec = {
7 0,
8 1,
9 0,
11 "refs/tags/*",
12 "refs/tags/*"
15 /* See TAG_REFSPEC for the string version */
16 const struct refspec_item *tag_refspec = &s_tag_refspec;
19 * Parses the provided refspec 'refspec' and populates the refspec_item 'item'.
20 * Returns 1 if successful and 0 if the refspec is invalid.
22 static int parse_refspec(struct refspec_item *item, const char *refspec, int fetch)
24 size_t llen;
25 int is_glob;
26 const char *lhs, *rhs;
27 int flags;
29 is_glob = 0;
31 lhs = refspec;
32 if (*lhs == '+') {
33 item->force = 1;
34 lhs++;
37 rhs = strrchr(lhs, ':');
40 * Before going on, special case ":" (or "+:") as a refspec
41 * for pushing matching refs.
43 if (!fetch && rhs == lhs && rhs[1] == '\0') {
44 item->matching = 1;
45 return 1;
48 if (rhs) {
49 size_t rlen = strlen(++rhs);
50 is_glob = (1 <= rlen && strchr(rhs, '*'));
51 item->dst = xstrndup(rhs, rlen);
52 } else {
53 item->dst = NULL;
56 llen = (rhs ? (rhs - lhs - 1) : strlen(lhs));
57 if (1 <= llen && memchr(lhs, '*', llen)) {
58 if ((rhs && !is_glob) || (!rhs && fetch))
59 return 0;
60 is_glob = 1;
61 } else if (rhs && is_glob) {
62 return 0;
65 item->pattern = is_glob;
66 item->src = xstrndup(lhs, llen);
67 flags = REFNAME_ALLOW_ONELEVEL | (is_glob ? REFNAME_REFSPEC_PATTERN : 0);
69 if (fetch) {
70 struct object_id unused;
72 /* LHS */
73 if (!*item->src)
74 ; /* empty is ok; it means "HEAD" */
75 else if (llen == GIT_SHA1_HEXSZ && !get_oid_hex(item->src, &unused))
76 item->exact_sha1 = 1; /* ok */
77 else if (!check_refname_format(item->src, flags))
78 ; /* valid looking ref is ok */
79 else
80 return 0;
81 /* RHS */
82 if (!item->dst)
83 ; /* missing is ok; it is the same as empty */
84 else if (!*item->dst)
85 ; /* empty is ok; it means "do not store" */
86 else if (!check_refname_format(item->dst, flags))
87 ; /* valid looking ref is ok */
88 else
89 return 0;
90 } else {
92 * LHS
93 * - empty is allowed; it means delete.
94 * - when wildcarded, it must be a valid looking ref.
95 * - otherwise, it must be an extended SHA-1, but
96 * there is no existing way to validate this.
98 if (!*item->src)
99 ; /* empty is ok */
100 else if (is_glob) {
101 if (check_refname_format(item->src, flags))
102 return 0;
104 else
105 ; /* anything goes, for now */
107 * RHS
108 * - missing is allowed, but LHS then must be a
109 * valid looking ref.
110 * - empty is not allowed.
111 * - otherwise it must be a valid looking ref.
113 if (!item->dst) {
114 if (check_refname_format(item->src, flags))
115 return 0;
116 } else if (!*item->dst) {
117 return 0;
118 } else {
119 if (check_refname_format(item->dst, flags))
120 return 0;
124 return 1;
127 int refspec_item_init(struct refspec_item *item, const char *refspec, int fetch)
129 memset(item, 0, sizeof(*item));
130 return parse_refspec(item, refspec, fetch);
133 void refspec_item_init_or_die(struct refspec_item *item, const char *refspec,
134 int fetch)
136 if (!refspec_item_init(item, refspec, fetch))
137 die(_("invalid refspec '%s'"), refspec);
140 void refspec_item_clear(struct refspec_item *item)
142 FREE_AND_NULL(item->src);
143 FREE_AND_NULL(item->dst);
144 item->force = 0;
145 item->pattern = 0;
146 item->matching = 0;
147 item->exact_sha1 = 0;
150 void refspec_init(struct refspec *rs, int fetch)
152 memset(rs, 0, sizeof(*rs));
153 rs->fetch = fetch;
156 void refspec_append(struct refspec *rs, const char *refspec)
158 struct refspec_item item;
160 refspec_item_init_or_die(&item, refspec, rs->fetch);
162 ALLOC_GROW(rs->items, rs->nr + 1, rs->alloc);
163 rs->items[rs->nr++] = item;
165 ALLOC_GROW(rs->raw, rs->raw_nr + 1, rs->raw_alloc);
166 rs->raw[rs->raw_nr++] = xstrdup(refspec);
169 void refspec_appendn(struct refspec *rs, const char **refspecs, int nr)
171 int i;
172 for (i = 0; i < nr; i++)
173 refspec_append(rs, refspecs[i]);
176 void refspec_clear(struct refspec *rs)
178 int i;
180 for (i = 0; i < rs->nr; i++)
181 refspec_item_clear(&rs->items[i]);
183 FREE_AND_NULL(rs->items);
184 rs->alloc = 0;
185 rs->nr = 0;
187 for (i = 0; i < rs->raw_nr; i++)
188 free((char *)rs->raw[i]);
189 FREE_AND_NULL(rs->raw);
190 rs->raw_alloc = 0;
191 rs->raw_nr = 0;
193 rs->fetch = 0;
196 int valid_fetch_refspec(const char *fetch_refspec_str)
198 struct refspec_item refspec;
199 int ret = refspec_item_init(&refspec, fetch_refspec_str, REFSPEC_FETCH);
200 refspec_item_clear(&refspec);
201 return ret;
204 void refspec_ref_prefixes(const struct refspec *rs,
205 struct argv_array *ref_prefixes)
207 int i;
208 for (i = 0; i < rs->nr; i++) {
209 const struct refspec_item *item = &rs->items[i];
210 const char *prefix = NULL;
212 if (item->exact_sha1)
213 continue;
214 if (rs->fetch == REFSPEC_FETCH)
215 prefix = item->src;
216 else if (item->dst)
217 prefix = item->dst;
218 else if (item->src && !item->exact_sha1)
219 prefix = item->src;
221 if (prefix) {
222 if (item->pattern) {
223 const char *glob = strchr(prefix, '*');
224 argv_array_pushf(ref_prefixes, "%.*s",
225 (int)(glob - prefix),
226 prefix);
227 } else {
228 expand_ref_prefix(ref_prefixes, prefix);