]>
Commit | Line | Data |
---|---|---|
ec0cb496 | 1 | #include "cache.h" |
6373cb59 | 2 | #include "argv-array.h" |
ec0cb496 BW |
3 | #include "refs.h" |
4 | #include "refspec.h" | |
5 | ||
0ad4a5ff | 6 | static struct refspec_item s_tag_refspec = { |
ec0cb496 BW |
7 | 0, |
8 | 1, | |
9 | 0, | |
10 | 0, | |
11 | "refs/tags/*", | |
12 | "refs/tags/*" | |
13 | }; | |
14 | ||
15 | /* See TAG_REFSPEC for the string version */ | |
0ad4a5ff | 16 | const struct refspec_item *tag_refspec = &s_tag_refspec; |
ec0cb496 | 17 | |
3eec3700 BW |
18 | /* |
19 | * Parses the provided refspec 'refspec' and populates the refspec_item 'item'. | |
20 | * Returns 1 if successful and 0 if the refspec is invalid. | |
21 | */ | |
22 | static int parse_refspec(struct refspec_item *item, const char *refspec, int fetch) | |
ec0cb496 | 23 | { |
3eec3700 BW |
24 | size_t llen; |
25 | int is_glob; | |
26 | const char *lhs, *rhs; | |
27 | int flags; | |
ec0cb496 | 28 | |
3eec3700 | 29 | is_glob = 0; |
ec0cb496 | 30 | |
3eec3700 BW |
31 | lhs = refspec; |
32 | if (*lhs == '+') { | |
33 | item->force = 1; | |
34 | lhs++; | |
35 | } | |
ec0cb496 | 36 | |
3eec3700 | 37 | rhs = strrchr(lhs, ':'); |
ec0cb496 | 38 | |
3eec3700 BW |
39 | /* |
40 | * Before going on, special case ":" (or "+:") as a refspec | |
41 | * for pushing matching refs. | |
42 | */ | |
43 | if (!fetch && rhs == lhs && rhs[1] == '\0') { | |
44 | item->matching = 1; | |
45 | return 1; | |
46 | } | |
ec0cb496 | 47 | |
3eec3700 BW |
48 | if (rhs) { |
49 | size_t rlen = strlen(++rhs); | |
50 | is_glob = (1 <= rlen && strchr(rhs, '*')); | |
51 | item->dst = xstrndup(rhs, rlen); | |
c3072c6e JH |
52 | } else { |
53 | item->dst = NULL; | |
3eec3700 BW |
54 | } |
55 | ||
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; | |
63 | } | |
64 | ||
65 | item->pattern = is_glob; | |
66 | item->src = xstrndup(lhs, llen); | |
67 | flags = REFNAME_ALLOW_ONELEVEL | (is_glob ? REFNAME_REFSPEC_PATTERN : 0); | |
68 | ||
69 | if (fetch) { | |
70 | struct object_id unused; | |
71 | ||
72 | /* LHS */ | |
73 | if (!*item->src) | |
74 | ; /* empty is ok; it means "HEAD" */ | |
b8d45d03 | 75 | else if (llen == the_hash_algo->hexsz && !get_oid_hex(item->src, &unused)) |
3eec3700 BW |
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 { | |
ec0cb496 | 91 | /* |
3eec3700 BW |
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. | |
ec0cb496 | 97 | */ |
3eec3700 BW |
98 | if (!*item->src) |
99 | ; /* empty is ok */ | |
100 | else if (is_glob) { | |
101 | if (check_refname_format(item->src, flags)) | |
102 | return 0; | |
ec0cb496 | 103 | } |
3eec3700 BW |
104 | else |
105 | ; /* anything goes, for now */ | |
106 | /* | |
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. | |
112 | */ | |
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; | |
ec0cb496 | 121 | } |
3eec3700 | 122 | } |
ec0cb496 | 123 | |
3eec3700 BW |
124 | return 1; |
125 | } | |
ec0cb496 | 126 | |
c495fd3d | 127 | int refspec_item_init(struct refspec_item *item, const char *refspec, int fetch) |
6d4c0578 BW |
128 | { |
129 | memset(item, 0, sizeof(*item)); | |
c495fd3d ÆAB |
130 | return parse_refspec(item, refspec, fetch); |
131 | } | |
6d4c0578 | 132 | |
c495fd3d ÆAB |
133 | void refspec_item_init_or_die(struct refspec_item *item, const char *refspec, |
134 | int fetch) | |
135 | { | |
136 | if (!refspec_item_init(item, refspec, fetch)) | |
1b5e07bb | 137 | die(_("invalid refspec '%s'"), refspec); |
6d4c0578 BW |
138 | } |
139 | ||
140 | void refspec_item_clear(struct refspec_item *item) | |
141 | { | |
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; | |
148 | } | |
149 | ||
150 | void refspec_init(struct refspec *rs, int fetch) | |
151 | { | |
152 | memset(rs, 0, sizeof(*rs)); | |
153 | rs->fetch = fetch; | |
154 | } | |
155 | ||
156 | void refspec_append(struct refspec *rs, const char *refspec) | |
157 | { | |
158 | struct refspec_item item; | |
159 | ||
dc064221 | 160 | refspec_item_init_or_die(&item, refspec, rs->fetch); |
6d4c0578 BW |
161 | |
162 | ALLOC_GROW(rs->items, rs->nr + 1, rs->alloc); | |
163 | rs->items[rs->nr++] = item; | |
164 | ||
165 | ALLOC_GROW(rs->raw, rs->raw_nr + 1, rs->raw_alloc); | |
166 | rs->raw[rs->raw_nr++] = xstrdup(refspec); | |
167 | } | |
168 | ||
169 | void refspec_appendn(struct refspec *rs, const char **refspecs, int nr) | |
170 | { | |
171 | int i; | |
172 | for (i = 0; i < nr; i++) | |
173 | refspec_append(rs, refspecs[i]); | |
174 | } | |
175 | ||
176 | void refspec_clear(struct refspec *rs) | |
177 | { | |
178 | int i; | |
179 | ||
180 | for (i = 0; i < rs->nr; i++) | |
181 | refspec_item_clear(&rs->items[i]); | |
182 | ||
183 | FREE_AND_NULL(rs->items); | |
184 | rs->alloc = 0; | |
185 | rs->nr = 0; | |
186 | ||
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; | |
192 | ||
193 | rs->fetch = 0; | |
194 | } | |
c8fa9efe BW |
195 | |
196 | int valid_fetch_refspec(const char *fetch_refspec_str) | |
197 | { | |
198 | struct refspec_item refspec; | |
7865d157 | 199 | int ret = refspec_item_init(&refspec, fetch_refspec_str, REFSPEC_FETCH); |
c8fa9efe BW |
200 | refspec_item_clear(&refspec); |
201 | return ret; | |
202 | } | |
6373cb59 BW |
203 | |
204 | void refspec_ref_prefixes(const struct refspec *rs, | |
205 | struct argv_array *ref_prefixes) | |
206 | { | |
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; | |
211 | ||
6c301adb JN |
212 | if (item->exact_sha1) |
213 | continue; | |
6373cb59 BW |
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; | |
220 | ||
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); | |
229 | } | |
230 | } | |
231 | } | |
232 | } |