]>
git.ipfire.org Git - thirdparty/git.git/blob - quote.c
3 #include "argv-array.h"
5 int quote_path_fully
= 1;
7 static inline int need_bs_quote(char c
)
9 return (c
== '\'' || c
== '!');
12 /* Help to copy the thing properly quoted for the shell safety.
13 * any single quote is replaced with '\'', any exclamation point
14 * is replaced with '\!', and the whole thing is enclosed in a
18 * original sq_quote result
19 * name ==> name ==> 'name'
20 * a b ==> a b ==> 'a b'
21 * a'b ==> a'\''b ==> 'a'\''b'
22 * a!b ==> a'\!'b ==> 'a'\!'b'
24 void sq_quote_buf(struct strbuf
*dst
, const char *src
)
29 to_free
= strbuf_detach(dst
, NULL
);
31 strbuf_addch(dst
, '\'');
33 size_t len
= strcspn(src
, "'!");
34 strbuf_add(dst
, src
, len
);
36 while (need_bs_quote(*src
)) {
37 strbuf_addstr(dst
, "'\\");
38 strbuf_addch(dst
, *src
++);
39 strbuf_addch(dst
, '\'');
42 strbuf_addch(dst
, '\'');
46 void sq_quote_buf_pretty(struct strbuf
*dst
, const char *src
)
48 static const char ok_punct
[] = "+,-./:=@_^";
51 for (p
= src
; *p
; p
++) {
52 if (!isalpha(*p
) && !isdigit(*p
) && !strchr(ok_punct
, *p
)) {
53 sq_quote_buf(dst
, src
);
58 /* if we get here, we did not need quoting */
59 strbuf_addstr(dst
, src
);
62 void sq_quotef(struct strbuf
*dst
, const char *fmt
, ...)
64 struct strbuf src
= STRBUF_INIT
;
68 strbuf_vaddf(&src
, fmt
, ap
);
71 sq_quote_buf(dst
, src
.buf
);
75 void sq_quote_argv(struct strbuf
*dst
, const char **argv
)
79 /* Copy into destination buffer. */
80 strbuf_grow(dst
, 255);
81 for (i
= 0; argv
[i
]; ++i
) {
82 strbuf_addch(dst
, ' ');
83 sq_quote_buf(dst
, argv
[i
]);
87 void sq_quote_argv_pretty(struct strbuf
*dst
, const char **argv
)
91 for (i
= 0; argv
[i
]; i
++) {
92 strbuf_addch(dst
, ' ');
93 sq_quote_buf_pretty(dst
, argv
[i
]);
97 static char *sq_dequote_step(char *arg
, char **next
)
113 /* We stepped out of sq */
122 * Allow backslashed characters outside of
123 * single-quotes only if they need escaping,
124 * and only if we resume the single-quoted part
127 if (need_bs_quote(src
[1]) && src
[2] == '\'') {
134 if (!next
|| !isspace(*src
))
138 } while (isspace(c
));
146 char *sq_dequote(char *arg
)
148 return sq_dequote_step(arg
, NULL
);
151 static int sq_dequote_to_argv_internal(char *arg
,
152 const char ***argv
, int *nr
, int *alloc
,
153 struct argv_array
*array
)
160 char *dequoted
= sq_dequote_step(next
, &next
);
164 ALLOC_GROW(*argv
, *nr
+ 1, *alloc
);
165 (*argv
)[(*nr
)++] = dequoted
;
168 argv_array_push(array
, dequoted
);
174 int sq_dequote_to_argv(char *arg
, const char ***argv
, int *nr
, int *alloc
)
176 return sq_dequote_to_argv_internal(arg
, argv
, nr
, alloc
, NULL
);
179 int sq_dequote_to_argv_array(char *arg
, struct argv_array
*array
)
181 return sq_dequote_to_argv_internal(arg
, NULL
, NULL
, NULL
, array
);
184 /* 1 means: quote as octal
185 * 0 means: quote as octal if (quote_path_fully)
186 * -1 means: never quote
189 #define X8(x) x, x, x, x, x, x, x, x
190 #define X16(x) X8(x), X8(x)
191 static signed char const sq_lookup
[256] = {
192 /* 0 1 2 3 4 5 6 7 */
193 /* 0x00 */ 1, 1, 1, 1, 1, 1, 1, 'a',
194 /* 0x08 */ 'b', 't', 'n', 'v', 'f', 'r', 1, 1,
196 /* 0x20 */ -1, -1, '"', -1, -1, -1, -1, -1,
197 /* 0x28 */ X16(-1), X16(-1), X16(-1),
198 /* 0x58 */ -1, -1, -1, -1,'\\', -1, -1, -1,
199 /* 0x60 */ X16(-1), X8(-1),
200 /* 0x78 */ -1, -1, -1, -1, -1, -1, -1, 1,
201 /* 0x80 */ /* set to 0 */
204 static inline int sq_must_quote(char c
)
206 return sq_lookup
[(unsigned char)c
] + quote_path_fully
> 0;
209 /* returns the longest prefix not needing a quote up to maxlen if positive.
210 This stops at the first \0 because it's marked as a character needing an
212 static size_t next_quote_pos(const char *s
, ssize_t maxlen
)
216 for (len
= 0; !sq_must_quote(s
[len
]); len
++);
218 for (len
= 0; len
< maxlen
&& !sq_must_quote(s
[len
]); len
++);
224 * C-style name quoting.
226 * (1) if sb and fp are both NULL, inspect the input name and counts the
227 * number of bytes that are needed to hold c_style quoted version of name,
228 * counting the double quotes around it but not terminating NUL, and
230 * However, if name does not need c_style quoting, it returns 0.
232 * (2) if sb or fp are not NULL, it emits the c_style quoted version
233 * of name, enclosed with double quotes if asked and needed only.
234 * Return value is the same as in (1).
236 static size_t quote_c_style_counted(const char *name
, ssize_t maxlen
,
237 struct strbuf
*sb
, FILE *fp
, int no_dq
)
242 if (sb) strbuf_addch(sb, (c)); \
243 if (fp) fputc((c), fp); \
246 #define EMITBUF(s, l) \
248 if (sb) strbuf_add(sb, (s), (l)); \
249 if (fp) fwrite((s), (l), 1, fp); \
253 size_t len
, count
= 0;
254 const char *p
= name
;
259 len
= next_quote_pos(p
, maxlen
);
260 if (len
== maxlen
|| (maxlen
< 0 && !p
[len
]))
263 if (!no_dq
&& p
== name
)
269 ch
= (unsigned char)*p
++;
272 if (sq_lookup
[ch
] >= ' ') {
275 EMIT(((ch
>> 6) & 03) + '0');
276 EMIT(((ch
>> 3) & 07) + '0');
277 EMIT(((ch
>> 0) & 07) + '0');
282 if (p
== name
) /* no ending quote needed */
290 size_t quote_c_style(const char *name
, struct strbuf
*sb
, FILE *fp
, int nodq
)
292 return quote_c_style_counted(name
, -1, sb
, fp
, nodq
);
295 void quote_two_c_style(struct strbuf
*sb
, const char *prefix
, const char *path
, int nodq
)
297 if (quote_c_style(prefix
, NULL
, NULL
, 0) ||
298 quote_c_style(path
, NULL
, NULL
, 0)) {
300 strbuf_addch(sb
, '"');
301 quote_c_style(prefix
, sb
, NULL
, 1);
302 quote_c_style(path
, sb
, NULL
, 1);
304 strbuf_addch(sb
, '"');
306 strbuf_addstr(sb
, prefix
);
307 strbuf_addstr(sb
, path
);
311 void write_name_quoted(const char *name
, FILE *fp
, int terminator
)
314 quote_c_style(name
, NULL
, fp
, 0);
318 fputc(terminator
, fp
);
321 void write_name_quoted_relative(const char *name
, const char *prefix
,
322 FILE *fp
, int terminator
)
324 struct strbuf sb
= STRBUF_INIT
;
326 name
= relative_path(name
, prefix
, &sb
);
327 write_name_quoted(name
, fp
, terminator
);
332 /* quote path as relative to the given prefix */
333 char *quote_path_relative(const char *in
, const char *prefix
,
336 struct strbuf sb
= STRBUF_INIT
;
337 const char *rel
= relative_path(in
, prefix
, &sb
);
339 quote_c_style_counted(rel
, strlen(rel
), out
, NULL
, 0);
346 * C-style name unquoting.
348 * Quoted should point at the opening double quote.
349 * + Returns 0 if it was able to unquote the string properly, and appends the
350 * result in the strbuf `sb'.
351 * + Returns -1 in case of error, and doesn't touch the strbuf. Though note
352 * that this function will allocate memory in the strbuf, so calling
353 * strbuf_release is mandatory whichever result unquote_c_style returns.
355 * Updates endp pointer to point at one past the ending double quote if given.
357 int unquote_c_style(struct strbuf
*sb
, const char *quoted
, const char **endp
)
359 size_t oldlen
= sb
->len
, len
;
362 if (*quoted
++ != '"')
366 len
= strcspn(quoted
, "\"\\");
367 strbuf_add(sb
, quoted
, len
);
381 switch ((ch
= *quoted
++)) {
382 case 'a': ch
= '\a'; break;
383 case 'b': ch
= '\b'; break;
384 case 'f': ch
= '\f'; break;
385 case 'n': ch
= '\n'; break;
386 case 'r': ch
= '\r'; break;
387 case 't': ch
= '\t'; break;
388 case 'v': ch
= '\v'; break;
391 break; /* verbatim */
393 /* octal values with first digit over 4 overflow */
394 case '0': case '1': case '2': case '3':
395 ac
= ((ch
- '0') << 6);
396 if ((ch
= *quoted
++) < '0' || '7' < ch
)
398 ac
|= ((ch
- '0') << 3);
399 if ((ch
= *quoted
++) < '0' || '7' < ch
)
407 strbuf_addch(sb
, ch
);
411 strbuf_setlen(sb
, oldlen
);
415 /* quoting as a string literal for other languages */
417 void perl_quote_buf(struct strbuf
*sb
, const char *src
)
419 const char sq
= '\'';
420 const char bq
= '\\';
423 strbuf_addch(sb
, sq
);
424 while ((c
= *src
++)) {
425 if (c
== sq
|| c
== bq
)
426 strbuf_addch(sb
, bq
);
429 strbuf_addch(sb
, sq
);
432 void python_quote_buf(struct strbuf
*sb
, const char *src
)
434 const char sq
= '\'';
435 const char bq
= '\\';
436 const char nl
= '\n';
439 strbuf_addch(sb
, sq
);
440 while ((c
= *src
++)) {
442 strbuf_addch(sb
, bq
);
443 strbuf_addch(sb
, 'n');
446 if (c
== sq
|| c
== bq
)
447 strbuf_addch(sb
, bq
);
450 strbuf_addch(sb
, sq
);
453 void tcl_quote_buf(struct strbuf
*sb
, const char *src
)
457 strbuf_addch(sb
, '"');
458 while ((c
= *src
++)) {
462 case '$': case '\\': case '"':
463 strbuf_addch(sb
, '\\');
469 strbuf_addstr(sb
, "\\f");
472 strbuf_addstr(sb
, "\\r");
475 strbuf_addstr(sb
, "\\n");
478 strbuf_addstr(sb
, "\\t");
481 strbuf_addstr(sb
, "\\v");
485 strbuf_addch(sb
, '"');
488 void basic_regex_quote_buf(struct strbuf
*sb
, const char *src
)
493 /* only beginning '^' is special and needs quoting */
494 strbuf_addch(sb
, '\\');
495 strbuf_addch(sb
, *src
++);
498 /* beginning '*' is not special, no quoting */
499 strbuf_addch(sb
, *src
++);
501 while ((c
= *src
++)) {
507 strbuf_addch(sb
, '\\');
512 /* only the end '$' is special and needs quoting */
514 strbuf_addch(sb
, '\\');