[PATCH] getdomainname should be usable on SunOS with -lnsl
[gitweb.git] / diff-tree.c
index b43df18ef5e6f20366e8c5f3ae24b8466edebb8b..e8f5d1b126179c705f6463c25216d90e3e376848 100644 (file)
@@ -1,23 +1,32 @@
 #include <ctype.h>
 #include "cache.h"
 #include "diff.h"
+#include "commit.h"
 
-static int silent = 0;
 static int show_root_diff = 0;
 static int verbose_header = 0;
 static int ignore_merges = 1;
 static int recursive = 0;
+static int show_tree_entry_in_recursive = 0;
 static int read_stdin = 0;
-static int line_termination = '\n';
-static int generate_patch = 0;
+static int diff_output_format = DIFF_FORMAT_RAW;
+static int diff_line_termination = '\n';
 static int detect_rename = 0;
+static int find_copies_harder = 0;
+static int diff_setup_opt = 0;
 static int diff_score_opt = 0;
+static const char *pickaxe = NULL;
+static int pickaxe_opts = 0;
+static int diff_break_opt = -1;
+static const char *orderfile = NULL;
+static const char *diff_filter = NULL;
 static const char *header = NULL;
 static const char *header_prefix = "";
+static enum cmit_fmt commit_format = CMIT_FMT_RAW;
 
 // What paths are we interested in?
 static int nr_paths = 0;
-static char **paths = NULL;
+static const char **paths = NULL;
 static int *pathlens = NULL;
 
 static int diff_tree_sha1(const unsigned char *old, const unsigned char *new, const char *base);
@@ -39,10 +48,12 @@ static const unsigned char *extract(void *tree, unsigned long size, const char *
        int len = strlen(tree)+1;
        const unsigned char *sha1 = tree + len;
        const char *path = strchr(tree, ' ');
+       unsigned int mode;
 
-       if (!path || size < len + 20 || sscanf(tree, "%o", modep) != 1)
+       if (!path || size < len + 20 || sscanf(tree, "%o", &mode) != 1)
                die("corrupt tree file");
        *pathp = path+1;
+       *modep = DIFF_FILE_CANON_MODE(mode);
        return sha1;
 }
 
@@ -66,14 +77,6 @@ static void show_file(const char *prefix, void *tree, unsigned long size, const
        const char *path;
        const unsigned char *sha1 = extract(tree, size, &path, &mode);
 
-       if (header) {
-               printf("%s", header);
-               header = NULL;
-       }
-
-       if (silent)
-               return;
-
        if (recursive && S_ISDIR(mode)) {
                char type[20];
                unsigned long size;
@@ -106,7 +109,7 @@ static int compare_tree_entry(void *tree1, unsigned long size1, void *tree2, uns
 
        pathlen1 = strlen(path1);
        pathlen2 = strlen(path2);
-       cmp = cache_name_compare(path1, pathlen1, path2, pathlen2);
+       cmp = base_name_compare(path1, pathlen1, mode1, path2, pathlen2, mode2);
        if (cmp < 0) {
                show_file("-", tree1, size1, base);
                return -1;
@@ -115,7 +118,7 @@ static int compare_tree_entry(void *tree1, unsigned long size1, void *tree2, uns
                show_file("+", tree2, size2, base);
                return 1;
        }
-       if (!memcmp(sha1, sha2, 20) && mode1 == mode2)
+       if (!find_copies_harder && !memcmp(sha1, sha2, 20) && mode1 == mode2)
                return 0;
 
        /*
@@ -131,18 +134,13 @@ static int compare_tree_entry(void *tree1, unsigned long size1, void *tree2, uns
        if (recursive && S_ISDIR(mode1)) {
                int retval;
                char *newbase = malloc_base(base, path1, pathlen1);
+               if (show_tree_entry_in_recursive)
+                       diff_change(mode1, mode2, sha1, sha2, base, path1);
                retval = diff_tree_sha1(sha1, sha2, newbase);
                free(newbase);
                return retval;
        }
 
-       if (header) {
-               printf("%s", header);
-               header = NULL;
-       }
-       if (silent)
-               return 0;
-
        diff_change(mode1, mode2, sha1, sha2, base, path1);
        return 0;
 }
@@ -253,10 +251,10 @@ static int diff_tree_sha1(const unsigned char *old, const unsigned char *new, co
        unsigned long size1, size2;
        int retval;
 
-       tree1 = read_object_with_reference(old, "tree", &size1, 0);
+       tree1 = read_object_with_reference(old, "tree", &size1, NULL);
        if (!tree1)
                die("unable to read source tree (%s)", sha1_to_hex(old));
-       tree2 = read_object_with_reference(new, "tree", &size2, 0);
+       tree2 = read_object_with_reference(new, "tree", &size2, NULL);
        if (!tree2)
                die("unable to read destination tree (%s)", sha1_to_hex(new));
        retval = diff_tree(tree1, size1, tree2, size2, base);
@@ -265,16 +263,39 @@ static int diff_tree_sha1(const unsigned char *old, const unsigned char *new, co
        return retval;
 }
 
+static void call_diff_setup(void)
+{
+       diff_setup(diff_setup_opt);
+}
+
+static int call_diff_flush(void)
+{
+       diffcore_std(NULL,
+                    detect_rename, diff_score_opt,
+                    pickaxe, pickaxe_opts,
+                    diff_break_opt,
+                    orderfile,
+                    diff_filter);
+       if (diff_queue_is_empty()) {
+               diff_flush(DIFF_FORMAT_NO_OUTPUT, diff_line_termination);
+               return 0;
+       }
+       if (header) {
+               printf("%s%c", header, diff_line_termination);
+               header = NULL;
+       }
+       diff_flush(diff_output_format, diff_line_termination);
+       return 1;
+}
+
 static int diff_tree_sha1_top(const unsigned char *old,
                              const unsigned char *new, const char *base)
 {
        int ret;
 
-       diff_setup(detect_rename, diff_score_opt, 0,
-                  (generate_patch ? -1 : line_termination),
-                  0, 0);
+       call_diff_setup();
        ret = diff_tree_sha1(old, new, base);
-       diff_flush();
+       call_diff_flush();
        return ret;
 }
 
@@ -284,85 +305,26 @@ static int diff_root_tree(const unsigned char *new, const char *base)
        void *tree;
        unsigned long size;
 
-       diff_setup(detect_rename, diff_score_opt, 0,
-                  (generate_patch ? -1 : line_termination),
-                  0, 0);
-       tree = read_object_with_reference(new, "tree", &size, 0);
+       call_diff_setup();
+       tree = read_object_with_reference(new, "tree", &size, NULL);
        if (!tree)
                die("unable to read root tree (%s)", sha1_to_hex(new));
        retval = diff_tree("", 0, tree, size, base);
        free(tree);
-       diff_flush();
+       call_diff_flush();
        return retval;
 }
 
-static int get_one_line(const char *msg, unsigned long len)
-{
-       int ret = 0;
-
-       while (len--) {
-               ret++;
-               if (*msg++ == '\n')
-                       break;
-       }
-       return ret;
-}
-
-static int add_author_info(char *buf, const char *line, int len)
+static const char *generate_header(const char *commit, const char *parent, const char *msg, unsigned long len)
 {
-       char *date;
-       unsigned int namelen;
-       unsigned long time;
-       int tz;
-
-       line += strlen("author ");
-       date = strchr(line, '>');
-       if (!date)
-               return 0;
-       namelen = ++date - line;
-       time = strtoul(date, &date, 10);
-       tz = strtol(date, NULL, 10);
-
-       return sprintf(buf, "Author: %.*s\nDate:   %s\n",
-               namelen, line,
-               show_date(time, tz));
-}
-
-static char *generate_header(const char *commit, const char *parent, const char *msg, unsigned long len)
-{
-       static char this_header[1000];
+       static char this_header[16384];
        int offset;
 
-       offset = sprintf(this_header, "%s%s (from %s)\n", header_prefix, commit, parent);
-       if (verbose_header) {
-               int hdr = 1;
-
-               for (;;) {
-                       const char *line = msg;
-                       int linelen = get_one_line(msg, len);
-
-                       if (!linelen)
-                               break;
-                       if (offset + linelen + 10 > sizeof(this_header))
-                               break;
-
-                       msg += linelen;
-                       len -= linelen;
-                       if (linelen == 1)
-                               hdr = 0;
-                       if (hdr) {
-                               if (!memcmp(line, "author ", 7))
-                                       offset += add_author_info(this_header + offset, line, linelen);
-                               continue;
-                       }
-                       memset(this_header + offset, ' ', 4);
-                       memcpy(this_header + offset + 4, line, linelen);
-                       offset += linelen + 4;
-               }
-               this_header[offset++] = '\n';
-               this_header[offset] = 0;
-       }
+       if (!verbose_header)
+               return commit;
 
+       offset = sprintf(this_header, "%s%s (from %s)\n", header_prefix, commit, parent);
+       offset += pretty_print_commit(commit_format, msg, len, this_header + offset, sizeof(this_header) - offset);
        return this_header;
 }
 
@@ -399,10 +361,16 @@ static int diff_tree_commit(const unsigned char *commit, const char *name)
                        return -1;
                header = generate_header(name, sha1_to_hex(parent), buf, size);
                diff_tree_sha1_top(parent, commit, "");
-               if (!header && verbose_header)
+               if (!header && verbose_header) {
                        header_prefix = "\ndiff-tree ";
+                       /*
+                        * Don't print multiple merge entries if we
+                        * don't print the diffs.
+                        */
+               }
                offset += 48;
        }
+       free(buf);
        return 0;
 }
 
@@ -428,18 +396,29 @@ static int diff_tree_stdin(char *line)
        return diff_tree_commit(commit, line);
 }
 
-static char *diff_tree_usage =
-"git-diff-tree [-p] [-r] [-z] [--stdin] [-M] [-m] [-s] [-v] <tree-ish> <tree-ish>";
+static int count_paths(const char **paths)
+{
+       int i = 0;
+       while (*paths++)
+               i++;
+       return i;
+}
+
+static const char diff_tree_usage[] =
+"git-diff-tree [--stdin] [-m] [-s] [-v] [--pretty] [-t] "
+"[<common diff options>] <tree-ish> <tree-ish>"
+COMMON_DIFF_OPTIONS_HELP;
 
 int main(int argc, char **argv)
 {
        int nr_sha1;
        char line[1000];
        unsigned char sha1[2][20];
+       const char *prefix = setup_git_directory();
 
        nr_sha1 = 0;
        for (;;) {
-               char *arg;
+               const char *arg;
 
                argv++;
                argc--;
@@ -464,17 +443,62 @@ int main(int argc, char **argv)
                        recursive = 1;
                        continue;
                }
-               if (!strcmp(arg, "-p")) {
-                       recursive = generate_patch = 1;
+               if (!strcmp(arg, "-t")) {
+                       recursive = show_tree_entry_in_recursive = 1;
+                       continue;
+               }
+               if (!strcmp(arg, "-R")) {
+                       diff_setup_opt |= DIFF_SETUP_REVERSE;
+                       continue;
+               }
+               if (!strcmp(arg, "-p") || !strcmp(arg, "-u")) {
+                       diff_output_format = DIFF_FORMAT_PATCH;
+                       recursive = 1;
+                       continue;
+               }
+               if (!strncmp(arg, "-S", 2)) {
+                       pickaxe = arg + 2;
+                       continue;
+               }
+               if (!strncmp(arg, "-O", 2)) {
+                       orderfile = arg + 2;
+                       continue;
+               }
+               if (!strncmp(arg, "--diff-filter=", 14)) {
+                       diff_filter = arg + 14;
+                       continue;
+               }
+               if (!strcmp(arg, "--pickaxe-all")) {
+                       pickaxe_opts = DIFF_PICKAXE_ALL;
                        continue;
                }
                if (!strncmp(arg, "-M", 2)) {
-                       detect_rename = recursive = generate_patch = 1;
-                       diff_score_opt = diff_scoreopt_parse(arg);
+                       detect_rename = DIFF_DETECT_RENAME;
+                       if ((diff_score_opt = diff_scoreopt_parse(arg)) == -1)
+                               usage(diff_tree_usage);
+                       continue;
+               }
+               if (!strncmp(arg, "-C", 2)) {
+                       detect_rename = DIFF_DETECT_COPY;
+                       if ((diff_score_opt = diff_scoreopt_parse(arg)) == -1)
+                               usage(diff_tree_usage);
+                       continue;
+               }
+               if (!strncmp(arg, "-B", 2)) {
+                       if ((diff_break_opt = diff_scoreopt_parse(arg)) == -1)
+                               usage(diff_tree_usage);
+                       continue;
+               }
+               if (!strcmp(arg, "--find-copies-harder")) {
+                       find_copies_harder = 1;
+                       continue;
+               }
+               if (!strcmp(arg, "--name-only")) {
+                       diff_output_format = DIFF_FORMAT_NAME;
                        continue;
                }
                if (!strcmp(arg, "-z")) {
-                       line_termination = '\0';
+                       diff_line_termination = 0;
                        continue;
                }
                if (!strcmp(arg, "-m")) {
@@ -482,7 +506,7 @@ int main(int argc, char **argv)
                        continue;
                }
                if (!strcmp(arg, "-s")) {
-                       silent = 1;
+                       diff_output_format = DIFF_FORMAT_NO_OUTPUT;
                        continue;
                }
                if (!strcmp(arg, "-v")) {
@@ -490,6 +514,12 @@ int main(int argc, char **argv)
                        header_prefix = "diff-tree ";
                        continue;
                }
+               if (!strncmp(arg, "--pretty", 8)) {
+                       verbose_header = 1;
+                       header_prefix = "diff-tree ";
+                       commit_format = get_commit_format(arg+8);
+                       continue;
+               }
                if (!strcmp(arg, "--stdin")) {
                        read_stdin = 1;
                        continue;
@@ -500,12 +530,14 @@ int main(int argc, char **argv)
                }
                usage(diff_tree_usage);
        }
+       if (find_copies_harder && detect_rename != DIFF_DETECT_COPY)
+               usage(diff_tree_usage);
 
-       if (argc > 0) {
+       paths = get_pathspec(prefix, argv);
+       if (paths) {
                int i;
 
-               paths = argv;
-               nr_paths = argc;
+               nr_paths = count_paths(paths);
                pathlens = xmalloc(nr_paths * sizeof(int));
                for (i=0; i<nr_paths; i++)
                        pathlens[i] = strlen(paths[i]);
@@ -527,6 +559,9 @@ int main(int argc, char **argv)
        if (!read_stdin)
                return 0;
 
+       if (detect_rename)
+               diff_setup_opt |= (DIFF_SETUP_USE_SIZE_CACHE |
+                                  DIFF_SETUP_USE_CACHE);
        while (fgets(line, sizeof(line), stdin))
                diff_tree_stdin(line);