alias.c

   1 #include "git-compat-util.h"
   2 #include "alias.h"
   3 #include "alloc.h"
   4 #include "config.h"
   5 #include "gettext.h"
   6 #include "strbuf.h"
   7 #include "string-list.h"
   8
   9 struct config_alias_data {
  10         const char *alias;
  11         char *v;
  12         struct string_list *list;
  13 };
  14
  15 static int config_alias_cb(const char *key, const char *value,
  16                            const struct config_context *ctx UNUSED, void *d)
  17 {
  18         struct config_alias_data *data = d;
  19         const char *p;
  20
  21         if (!skip_prefix(key, "alias.", &p))
  22                 return 0;
  23
  24         if (data->alias) {
  25                 if (!strcasecmp(p, data->alias))
  26                         return git_config_string((const char **)&data->v,
  27                                                  key, value);
  28         } else if (data->list) {
  29                 string_list_append(data->list, p);
  30         }
  31
  32         return 0;
  33 }
  34
  35 char *alias_lookup(const char *alias)
  36 {
  37         struct config_alias_data data = { alias, NULL };
  38
  39         read_early_config(config_alias_cb, &data);
  40
  41         return data.v;
  42 }
  43
  44 void list_aliases(struct string_list *list)
  45 {
  46         struct config_alias_data data = { NULL, NULL, list };
  47
  48         read_early_config(config_alias_cb, &data);
  49 }
  50
  51 void quote_cmdline(struct strbuf *buf, const char **argv)
  52 {
  53         for (const char **argp = argv; *argp; argp++) {
  54                 if (argp != argv)
  55                         strbuf_addch(buf, ' ');
  56                 strbuf_addch(buf, '"');
  57                 for (const char *p = *argp; *p; p++) {
  58                         const char c = *p;
  59
  60                         if (c == '"' || c =='\\')
  61                                 strbuf_addch(buf, '\\');
  62                         strbuf_addch(buf, c);
  63                 }
  64                 strbuf_addch(buf, '"');
  65         }
  66 }
  67
  68 #define SPLIT_CMDLINE_BAD_ENDING 1
  69 #define SPLIT_CMDLINE_UNCLOSED_QUOTE 2
  70 #define SPLIT_CMDLINE_ARGC_OVERFLOW 3
  71 static const char *split_cmdline_errors[] = {
  72         N_("cmdline ends with \\"),
  73         N_("unclosed quote"),
  74         N_("too many arguments"),
  75 };
  76
  77 int split_cmdline(char *cmdline, const char ***argv)
  78 {
  79         size_t src, dst, count = 0, size = 16;
  80         char quoted = 0;
  81
  82         ALLOC_ARRAY(*argv, size);
  83
  84         /* split alias_string */
  85         (*argv)[count++] = cmdline;
  86         for (src = dst = 0; cmdline[src];) {
  87                 char c = cmdline[src];
  88                 if (!quoted && isspace(c)) {
  89                         cmdline[dst++] = 0;
  90                         while (cmdline[++src]
  91                                         && isspace(cmdline[src]))
  92                                 ; /* skip */
  93                         ALLOC_GROW(*argv, count + 1, size);
  94                         (*argv)[count++] = cmdline + dst;
  95                 } else if (!quoted && (c == '\'' || c == '"')) {
  96                         quoted = c;
  97                         src++;
  98                 } else if (c == quoted) {
  99                         quoted = 0;
 100                         src++;
 101                 } else {
 102                         if (c == '\\' && quoted != '\'') {
 103                                 src++;
 104                                 c = cmdline[src];
 105                                 if (!c) {
 106                                         FREE_AND_NULL(*argv);
 107                                         return -SPLIT_CMDLINE_BAD_ENDING;
 108                                 }
 109                         }
 110                         cmdline[dst++] = c;
 111                         src++;
 112                 }
 113         }
 114
 115         cmdline[dst] = 0;
 116
 117         if (quoted) {
 118                 FREE_AND_NULL(*argv);
 119                 return -SPLIT_CMDLINE_UNCLOSED_QUOTE;
 120         }
 121
 122         if (count >= INT_MAX) {
 123                 FREE_AND_NULL(*argv);
 124                 return -SPLIT_CMDLINE_ARGC_OVERFLOW;
 125         }
 126
 127         ALLOC_GROW(*argv, count + 1, size);
 128         (*argv)[count] = NULL;
 129
 130         return count;
 131 }
 132
 133 const char *split_cmdline_strerror(int split_cmdline_errno)
 134 {
 135         return split_cmdline_errors[-split_cmdline_errno - 1];
 136 }