X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=rev-parse.c;h=4bd58ebb67358b5640a7c89a24477c80c84ae7f4;hb=429a9358763dfb98cd063e40dc49cbc049e2a268;hp=c096dc45ee7606c2b2947400f66c350f5801cb06;hpb=960bba0d8c14c9eb76bbb42eebc39eff58fc452b;p=git.git

diff --git a/rev-parse.c b/rev-parse.c
index c096dc45..4bd58ebb 100644
--- a/rev-parse.c
+++ b/rev-parse.c
@@ -13,6 +13,9 @@ static int single_rev = 0;
 static int revs_only = 0;
 static int do_rev_argument = 1;
 static int output_revs = 0;
+static int flags_only = 0;
+static int no_flags = 0;
+static int output_sq = 0;
 
 #define NORMAL 0
 #define REVERSED 1
@@ -47,30 +50,57 @@ static int is_rev_argument(const char *arg)
 	}
 }
 
+static void show(const char *arg)
+{
+	if (output_sq) {
+		int sq = '\'', ch;
+
+		putchar(sq);
+		while ((ch = *arg++)) {
+			if (ch == sq)
+				fputs("'\\'", stdout);
+			putchar(ch);
+		}
+		putchar(sq);
+		putchar(' ');
+	}
+	else
+		puts(arg);
+}
+
 static void show_rev(int type, const unsigned char *sha1)
 {
 	if (no_revs)
 		return;
 	output_revs++;
-	printf("%s%s\n", type == show_type ? "" : "^", sha1_to_hex(sha1));
+
+	/* Hexadecimal string plus possibly a carret;
+	 * this does not have to be quoted even under output_sq.
+	 */
+	printf("%s%s%c", type == show_type ? "" : "^", sha1_to_hex(sha1),
+	       output_sq ? ' ' : '\n');
 }
 
 static void show_rev_arg(char *rev)
 {
 	if (no_revs)
 		return;
-	puts(rev);
+	show(rev);
 }
 
 static void show_norev(char *norev)
 {
+	if (flags_only)
+		return;
 	if (revs_only)
 		return;
-	puts(norev);
+	show(norev);
 }
 
 static void show_arg(char *arg)
 {
+	if (no_flags)
+		return;
 	if (do_rev_argument && is_rev_argument(arg))
 		show_rev_arg(arg);
 	else
@@ -91,6 +121,10 @@ static int get_parent(char *name, unsigned char *result, int idx)
 		return -1;
 	if (parse_commit(commit))
 		return -1;
+	if (!idx) {
+		memcpy(result, commit->object.sha1, 20);
+		return 0;
+	}
 	p = commit->parents;
 	while (p) {
 		if (!--idx) {
@@ -102,29 +136,151 @@ static int get_parent(char *name, unsigned char *result, int idx)
 	return -1;
 }
 
+static int find_short_object_filename(int len, const char *name, unsigned char *sha1)
+{
+	static char dirname[PATH_MAX];
+	char hex[40];
+	DIR *dir;
+	int found;
+
+	snprintf(dirname, sizeof(dirname), "%s/%.2s", get_object_directory(), name);
+	dir = opendir(dirname);
+	sprintf(hex, "%.2s", name);
+	found = 0;
+	if (dir) {
+		struct dirent *de;
+		while ((de = readdir(dir)) != NULL) {
+			if (strlen(de->d_name) != 38)
+				continue;
+			if (memcmp(de->d_name, name + 2, len-2))
+				continue;
+			memcpy(hex + 2, de->d_name, 38);
+			if (++found > 1)
+				break;
+		}
+		closedir(dir);
+	}
+	if (found == 1)
+		return get_sha1_hex(hex, sha1) == 0;
+	return 0;
+}
+
+static int match_sha(unsigned len, const unsigned char *a, const unsigned char *b)
+{
+	do {
+		if (*a != *b)
+			return 0;
+		a++;
+		b++;
+		len -= 2;
+	} while (len > 1);
+	if (len)
+		if ((*a ^ *b) & 0xf0)
+			return 0;
+	return 1;
+}
+
+static int find_short_packed_object(int len, const unsigned char *match, unsigned char *sha1)
+{
+	struct packed_git *p;
+
+	prepare_packed_git();
+	for (p = packed_git; p; p = p->next) {
+		unsigned num = num_packed_objects(p);
+		unsigned first = 0, last = num;
+		while (first < last) {
+			unsigned mid = (first + last) / 2;
+			unsigned char now[20];
+			int cmp;
+
+			nth_packed_object_sha1(p, mid, now);
+			cmp = memcmp(match, now, 20);
+			if (!cmp) {
+				first = mid;
+				break;
+			}
+			if (cmp > 0) {
+				first = mid+1;
+				continue;
+			}
+			last = mid;
+		}
+		if (first < num) {
+			unsigned char now[20], next[20];
+			nth_packed_object_sha1(p, first, now);
+			if (match_sha(len, match, now)) {
+				if (nth_packed_object_sha1(p, first+1, next) || !match_sha(len, match, next)) {
+					memcpy(sha1, now, 20);
+					return 1;
+				}
+			}
+		}	
+	}
+	return 0;
+}
+
+static int get_short_sha1(char *name, unsigned char *sha1)
+{
+	int i;
+	char canonical[40];
+	unsigned char res[20];
+
+	memset(res, 0, 20);
+	memset(canonical, 'x', 40);
+	for (i = 0;;i++) {
+		unsigned char c = name[i];
+		unsigned char val;
+		if (!c || i > 40)
+			break;
+		if (c >= '0' && c <= '9')
+			val = c - '0';
+		else if (c >= 'a' && c <= 'f')
+			val = c - 'a' + 10;
+		else if (c >= 'A' && c <='F') {
+			val = c - 'A' + 10;
+			c -= 'A' - 'a';
+		}
+		else
+			return -1;
+		canonical[i] = c;
+		if (!(i & 1))
+			val <<= 4;
+		res[i >> 1] |= val;
+	}
+	if (i < 4)
+		return -1;
+	if (find_short_object_filename(i, canonical, sha1))
+		return 0;
+	if (find_short_packed_object(i, res, sha1))
+		return 0;
+	return -1;
+}
+
 /*
  * This is like "get_sha1()", except it allows "sha1 expressions",
  * notably "xyz^" for "parent of xyz"
  */
 static int get_extended_sha1(char *name, unsigned char *sha1)
 {
-	int parent;
+	int parent, ret;
 	int len = strlen(name);
 
 	parent = 1;
-	if (len > 2 && name[len-1] >= '1' && name[len-1] <= '9') {
+	if (len > 2 && name[len-1] >= '0' && name[len-1] <= '9') {
 		parent = name[len-1] - '0';
 		len--;
 	}
 	if (len > 1 && name[len-1] == '^') {
-		int ret;
 		name[len-1] = 0;
 		ret = get_parent(name, sha1, parent);
 		name[len-1] = '^';
 		if (!ret)
 			return 0;
 	}
-	return get_sha1(name, sha1);
+	ret = get_sha1(name, sha1);
+	if (!ret)
+		return 0;
+	return get_short_sha1(name, sha1);
 }
 
 static void show_default(void)
@@ -182,12 +338,24 @@ int main(int argc, char **argv)
 				no_revs = 1;
 				continue;
 			}
+			if (!strcmp(arg, "--flags")) {
+				flags_only = 1;
+				continue;
+			}
+			if (!strcmp(arg, "--no-flags")) {
+				no_flags = 1;
+				continue;
+			}
 			if (!strcmp(arg, "--verify")) {
 				revs_only = 1;
 				do_rev_argument = 0;
 				single_rev = 1;
 				continue;
 			}
+			if (!strcmp(arg, "--sq")) {
+				output_sq = 1;
+				continue;
+			}
 			if (!strcmp(arg, "--not")) {
 				show_type ^= REVERSED;
 				continue;