userdiff.c

   1 #include "userdiff.h"
   2 #include "cache.h"
   3 #include "attr.h"
   4
   5 static struct userdiff_driver *drivers;
   6 static int ndrivers;
   7 static int drivers_alloc;
   8
   9 #define FUNCNAME(name, pattern) \
  10         { name, NULL, -1, { pattern, REG_EXTENDED } }
  11 static struct userdiff_driver builtin_drivers[] = {
  12 FUNCNAME("html", "^[ \t]*(<[Hh][1-6][ \t].*>.*)$"),
  13 FUNCNAME("java",
  14          "!^[ \t]*(catch|do|for|if|instanceof|new|return|switch|throw|while)\n"
  15          "^[ \t]*(([ \t]*[A-Za-z_][A-Za-z_0-9]*){2,}[ \t]*\\([^;]*)$"),
  16 FUNCNAME("objc",
  17          /* Negate C statements that can look like functions */
  18          "!^[ \t]*(do|for|if|else|return|switch|while)\n"
  19          /* Objective-C methods */
  20          "^[ \t]*([-+][ \t]*\\([ \t]*[A-Za-z_][A-Za-z_0-9* \t]*\\)[ \t]*[A-Za-z_].*)$\n"
  21          /* C functions */
  22          "^[ \t]*(([ \t]*[A-Za-z_][A-Za-z_0-9]*){2,}[ \t]*\\([^;]*)$\n"
  23          /* Objective-C class/protocol definitions */
  24          "^(@(implementation|interface|protocol)[ \t].*)$"),
  25 FUNCNAME("pascal",
  26          "^((procedure|function|constructor|destructor|interface|"
  27                 "implementation|initialization|finalization)[ \t]*.*)$"
  28          "\n"
  29          "^(.*=[ \t]*(class|record).*)$"),
  30 FUNCNAME("php", "^[\t ]*((function|class).*)"),
  31 FUNCNAME("python", "^[ \t]*((class|def)[ \t].*)$"),
  32 FUNCNAME("ruby", "^[ \t]*((class|module|def)[ \t].*)$"),
  33 FUNCNAME("bibtex", "(@[a-zA-Z]{1,}[ \t]*\\{{0,1}[ \t]*[^ \t\"@',\\#}{~%]*).*$"),
  34 FUNCNAME("tex", "^(\\\\((sub)*section|chapter|part)\\*{0,1}\\{.*)$"),
  35 { "default", NULL, -1, { NULL, 0 } },
  36 };
  37 #undef FUNCNAME
  38
  39 static struct userdiff_driver driver_true = {
  40         "diff=true",
  41         NULL,
  42         0,
  43         { NULL, 0 }
  44 };
  45
  46 static struct userdiff_driver driver_false = {
  47         "!diff",
  48         NULL,
  49         1,
  50         { NULL, 0 }
  51 };
  52
  53 static struct userdiff_driver *userdiff_find_by_namelen(const char *k, int len)
  54 {
  55         int i;
  56         for (i = 0; i < ndrivers; i++) {
  57                 struct userdiff_driver *drv = drivers + i;
  58                 if (!strncmp(drv->name, k, len) && !drv->name[len])
  59                         return drv;
  60         }
  61         for (i = 0; i < ARRAY_SIZE(builtin_drivers); i++) {
  62                 struct userdiff_driver *drv = builtin_drivers + i;
  63                 if (!strncmp(drv->name, k, len) && !drv->name[len])
  64                         return drv;
  65         }
  66         return NULL;
  67 }
  68
  69 static struct userdiff_driver *parse_driver(const char *var,
  70                 const char *value, const char *type)
  71 {
  72         struct userdiff_driver *drv;
  73         const char *dot;
  74         const char *name;
  75         int namelen;
  76
  77         if (prefixcmp(var, "diff."))
  78                 return NULL;
  79         dot = strrchr(var, '.');
  80         if (dot == var + 4)
  81                 return NULL;
  82         if (strcmp(type, dot+1))
  83                 return NULL;
  84
  85         name = var + 5;
  86         namelen = dot - name;
  87         drv = userdiff_find_by_namelen(name, namelen);
  88         if (!drv) {
  89                 ALLOC_GROW(drivers, ndrivers+1, drivers_alloc);
  90                 drv = &drivers[ndrivers++];
  91                 memset(drv, 0, sizeof(*drv));
  92                 drv->name = xmemdupz(name, namelen);
  93                 drv->binary = -1;
  94         }
  95         return drv;
  96 }
  97
  98 static int parse_funcname(struct userdiff_funcname *f, const char *k,
  99                 const char *v, int cflags)
 100 {
 101         if (git_config_string(&f->pattern, k, v) < 0)
 102                 return -1;
 103         f->cflags = cflags;
 104         return 1;
 105 }
 106
 107 static int parse_string(const char **d, const char *k, const char *v)
 108 {
 109         if (git_config_string(d, k, v) < 0)
 110                 return -1;
 111         return 1;
 112 }
 113
 114 static int parse_tristate(int *b, const char *k, const char *v)
 115 {
 116         if (v && !strcasecmp(v, "auto"))
 117                 *b = -1;
 118         else
 119                 *b = git_config_bool(k, v);
 120         return 1;
 121 }
 122
 123 int userdiff_config(const char *k, const char *v)
 124 {
 125         struct userdiff_driver *drv;
 126
 127         if ((drv = parse_driver(k, v, "funcname")))
 128                 return parse_funcname(&drv->funcname, k, v, 0);
 129         if ((drv = parse_driver(k, v, "xfuncname")))
 130                 return parse_funcname(&drv->funcname, k, v, REG_EXTENDED);
 131         if ((drv = parse_driver(k, v, "binary")))
 132                 return parse_tristate(&drv->binary, k, v);
 133         if ((drv = parse_driver(k, v, "command")))
 134                 return parse_string(&drv->external, k, v);
 135         if ((drv = parse_driver(k, v, "textconv")))
 136                 return parse_string(&drv->textconv, k, v);
 137
 138         return 0;
 139 }
 140
 141 struct userdiff_driver *userdiff_find_by_name(const char *name) {
 142         int len = strlen(name);
 143         return userdiff_find_by_namelen(name, len);
 144 }
 145
 146 struct userdiff_driver *userdiff_find_by_path(const char *path)
 147 {
 148         static struct git_attr *attr;
 149         struct git_attr_check check;
 150
 151         if (!attr)
 152                 attr = git_attr("diff", 4);
 153         check.attr = attr;
 154
 155         if (!path)
 156                 return NULL;
 157         if (git_checkattr(path, 1, &check))
 158                 return NULL;
 159
 160         if (ATTR_TRUE(check.value))
 161                 return &driver_true;
 162         if (ATTR_FALSE(check.value))
 163                 return &driver_false;
 164         if (ATTR_UNSET(check.value))
 165                 return NULL;
 166         return userdiff_find_by_name(check.value);
 167 }