[thirdparty/git.git] / builtin-diff.c

/*
 * Builtin "git diff"
 *
 * Copyright (c) 2006 Junio C Hamano
 */
#include "cache.h"
#include "commit.h"
#include "blob.h"
#include "tag.h"
#include "diff.h"
#include "diffcore.h"
#include "revision.h"
#include "log-tree.h"
#include "builtin.h"

/* NEEDSWORK: struct object has place for name but we _do_
 * know mode when we extracted the blob out of a tree, which
 * we currently lose.
 */
struct blobinfo {
	unsigned char sha1[20];
	const char *name;
};

static const char builtin_diff_usage[] =
"git-diff <options> <rev>{0,2} -- <path>*";

static int builtin_diff_files(struct rev_info *revs,
			      int argc, const char **argv)
{
	int silent = 0;
	while (1 < argc) {
		const char *arg = argv[1];
		if (!strcmp(arg, "--base"))
			revs->max_count = 1;
		else if (!strcmp(arg, "--ours"))
			revs->max_count = 2;
		else if (!strcmp(arg, "--theirs"))
			revs->max_count = 3;
		else if (!strcmp(arg, "-q"))
			silent = 1;
		else
			usage(builtin_diff_usage);
		argv++; argc--;
	}
	/*
	 * Make sure there are NO revision (i.e. pending object) parameter,
	 * specified rev.max_count is reasonable (0 <= n <= 3), and
	 * there is no other revision filtering parameter.
	 */
	if (revs->pending.nr ||
	    revs->min_age != -1 ||
	    revs->max_age != -1 ||
	    3 < revs->max_count)
		usage(builtin_diff_usage);
	if (revs->max_count < 0 &&
	    (revs->diffopt.output_format & DIFF_FORMAT_PATCH))
		revs->combine_merges = revs->dense_combined_merges = 1;
	return run_diff_files(revs, silent);
}

static void stuff_change(struct diff_options *opt,
			 unsigned old_mode, unsigned new_mode,
			 const unsigned char *old_sha1,
			 const unsigned char *new_sha1,
			 const char *old_name,
			 const char *new_name)
{
	struct diff_filespec *one, *two;

	if (!is_null_sha1(old_sha1) && !is_null_sha1(new_sha1) &&
	    !hashcmp(old_sha1, new_sha1))
		return;

	if (opt->reverse_diff) {
		unsigned tmp;
		const unsigned char *tmp_u;
		const char *tmp_c;
		tmp = old_mode; old_mode = new_mode; new_mode = tmp;
		tmp_u = old_sha1; old_sha1 = new_sha1; new_sha1 = tmp_u;
		tmp_c = old_name; old_name = new_name; new_name = tmp_c;
	}
	one = alloc_filespec(old_name);
	two = alloc_filespec(new_name);
	fill_filespec(one, old_sha1, old_mode);
	fill_filespec(two, new_sha1, new_mode);

	/* NEEDSWORK: shouldn't this part of diffopt??? */
	diff_queue(&diff_queued_diff, one, two);
}

static int builtin_diff_b_f(struct rev_info *revs,
			    int argc, const char **argv,
			    struct blobinfo *blob,
			    const char *path)
{
	/* Blob vs file in the working tree*/
	struct stat st;

	if (argc > 1)
		usage(builtin_diff_usage);

	if (lstat(path, &st))
		die("'%s': %s", path, strerror(errno));
	if (!(S_ISREG(st.st_mode) || S_ISLNK(st.st_mode)))
		die("'%s': not a regular file or symlink", path);
	stuff_change(&revs->diffopt,
		     canon_mode(st.st_mode), canon_mode(st.st_mode),
		     blob[0].sha1, null_sha1,
		     path, path);
	diffcore_std(&revs->diffopt);
	diff_flush(&revs->diffopt);
	return 0;
}

static int builtin_diff_blobs(struct rev_info *revs,
			      int argc, const char **argv,
			      struct blobinfo *blob)
{
	unsigned mode = canon_mode(S_IFREG | 0644);

	if (argc > 1)
		usage(builtin_diff_usage);

	stuff_change(&revs->diffopt,
		     mode, mode,
		     blob[0].sha1, blob[1].sha1,
		     blob[0].name, blob[1].name);
	diffcore_std(&revs->diffopt);
	diff_flush(&revs->diffopt);
	return 0;
}

static int builtin_diff_index(struct rev_info *revs,
			      int argc, const char **argv)
{
	int cached = 0;
	while (1 < argc) {
		const char *arg = argv[1];
		if (!strcmp(arg, "--cached"))
			cached = 1;
		else
			usage(builtin_diff_usage);
		argv++; argc--;
	}
	/*
	 * Make sure there is one revision (i.e. pending object),
	 * and there is no revision filtering parameters.
	 */
	if (revs->pending.nr != 1 ||
	    revs->max_count != -1 || revs->min_age != -1 ||
	    revs->max_age != -1)
		usage(builtin_diff_usage);
	return run_diff_index(revs, cached);
}

static int builtin_diff_tree(struct rev_info *revs,
			     int argc, const char **argv,
			     struct object_array_entry *ent)
{
	const unsigned char *(sha1[2]);
	int swap = 0;

	if (argc > 1)
		usage(builtin_diff_usage);

	/* We saw two trees, ent[0] and ent[1].
	 * if ent[1] is uninteresting, they are swapped
	 */
	if (ent[1].item->flags & UNINTERESTING)
		swap = 1;
	sha1[swap] = ent[0].item->sha1;
	sha1[1-swap] = ent[1].item->sha1;
	diff_tree_sha1(sha1[0], sha1[1], "", &revs->diffopt);
	log_tree_diff_flush(revs);
	return 0;
}

static int builtin_diff_combined(struct rev_info *revs,
				 int argc, const char **argv,
				 struct object_array_entry *ent,
				 int ents)
{
	const unsigned char (*parent)[20];
	int i;

	if (argc > 1)
		usage(builtin_diff_usage);

	if (!revs->dense_combined_merges && !revs->combine_merges)
		revs->dense_combined_merges = revs->combine_merges = 1;
	parent = xmalloc(ents * sizeof(*parent));
	/* Again, the revs are all reverse */
	for (i = 0; i < ents; i++)
		hashcpy((unsigned char *)(parent + i),
			ent[ents - 1 - i].item->sha1);
	diff_tree_combined(parent[0], parent + 1, ents - 1,
			   revs->dense_combined_merges, revs);
	return 0;
}

void add_head(struct rev_info *revs)
{
	unsigned char sha1[20];
	struct object *obj;
	if (get_sha1("HEAD", sha1))
		return;
	obj = parse_object(sha1);
	if (!obj)
		return;
	add_pending_object(revs, obj, "HEAD");
}

int cmd_diff(int argc, const char **argv, const char *prefix)
{
	int i;
	struct rev_info rev;
	struct object_array_entry ent[100];
	int ents = 0, blobs = 0, paths = 0;
	const char *path = NULL;
	struct blobinfo blob[2];

	/*
	 * We could get N tree-ish in the rev.pending_objects list.
	 * Also there could be M blobs there, and P pathspecs.
	 *
	 * N=0, M=0:
	 *	cache vs files (diff-files)
	 * N=0, M=2:
	 *      compare two random blobs.  P must be zero.
	 * N=0, M=1, P=1:
	 *	compare a blob with a working tree file.
	 *
	 * N=1, M=0:
	 *      tree vs cache (diff-index --cached)
	 *
	 * N=2, M=0:
	 *      tree vs tree (diff-tree)
	 *
	 * Other cases are errors.
	 */

	git_config(git_diff_ui_config);
	init_revisions(&rev, prefix);

	argc = setup_revisions(argc, argv, &rev, NULL);
	if (!rev.diffopt.output_format) {
		rev.diffopt.output_format = DIFF_FORMAT_PATCH;
		if (diff_setup_done(&rev.diffopt) < 0)
			die("diff_setup_done failed");
	}

	/* Do we have --cached and not have a pending object, then
	 * default to HEAD by hand.  Eek.
	 */
	if (!rev.pending.nr) {
		int i;
		for (i = 1; i < argc; i++) {
			const char *arg = argv[i];
			if (!strcmp(arg, "--"))
				break;
			else if (!strcmp(arg, "--cached")) {
				add_head(&rev);
				break;
			}
		}
	}

	for (i = 0; i < rev.pending.nr; i++) {
		struct object_array_entry *list = rev.pending.objects+i;
		struct object *obj = list->item;
		const char *name = list->name;
		int flags = (obj->flags & UNINTERESTING);
		if (!obj->parsed)
			obj = parse_object(obj->sha1);
		obj = deref_tag(obj, NULL, 0);
		if (!obj)
			die("invalid object '%s' given.", name);
		if (obj->type == OBJ_COMMIT)
			obj = &((struct commit *)obj)->tree->object;
		if (obj->type == OBJ_TREE) {
			if (ARRAY_SIZE(ent) <= ents)
				die("more than %d trees given: '%s'",
				    (int) ARRAY_SIZE(ent), name);
			obj->flags |= flags;
			ent[ents].item = obj;
			ent[ents].name = name;
			ents++;
			continue;
		}
		if (obj->type == OBJ_BLOB) {
			if (2 <= blobs)
				die("more than two blobs given: '%s'", name);
			hashcpy(blob[blobs].sha1, obj->sha1);
			blob[blobs].name = name;
			blobs++;
			continue;

		}
		die("unhandled object '%s' given.", name);
	}
	if (rev.prune_data) {
		const char **pathspec = rev.prune_data;
		while (*pathspec) {
			if (!path)
				path = *pathspec;
			paths++;
			pathspec++;
		}
	}

	/*
	 * Now, do the arguments look reasonable?
	 */
	if (!ents) {
		switch (blobs) {
		case 0:
			return builtin_diff_files(&rev, argc, argv);
			break;
		case 1:
			if (paths != 1)
				usage(builtin_diff_usage);
			return builtin_diff_b_f(&rev, argc, argv, blob, path);
			break;
		case 2:
			if (paths)
				usage(builtin_diff_usage);
			return builtin_diff_blobs(&rev, argc, argv, blob);
			break;
		default:
			usage(builtin_diff_usage);
		}
	}
	else if (blobs)
		usage(builtin_diff_usage);
	else if (ents == 1)
		return builtin_diff_index(&rev, argc, argv);
	else if (ents == 2)
		return builtin_diff_tree(&rev, argc, argv, ent);
	else if ((ents == 3) && (ent[0].item->flags & UNINTERESTING)) {
		/* diff A...B where there is one sane merge base between
		 * A and B.  We have ent[0] == merge-base, ent[1] == A,
		 * and ent[2] == B.  Show diff between the base and B.
		 */
		ent[1] = ent[2];
		return builtin_diff_tree(&rev, argc, argv, ent);
	}
	else
		return builtin_diff_combined(&rev, argc, argv,
					     ent, ents);
	usage(builtin_diff_usage);
}
Commit	Line	Data
65056021 JH	1	/*
	2	* Builtin "git diff"
	3	*
	4	* Copyright (c) 2006 Junio C Hamano
	5	*/
	6	#include "cache.h"
	7	#include "commit.h"
	8	#include "blob.h"
	9	#include "tag.h"
	10	#include "diff.h"
	11	#include "diffcore.h"
	12	#include "revision.h"
	13	#include "log-tree.h"
	14	#include "builtin.h"
	15
	16	/* NEEDSWORK: struct object has place for name but we _do_
	17	* know mode when we extracted the blob out of a tree, which
	18	* we currently lose.
	19	*/
	20	struct blobinfo {
	21	unsigned char sha1[20];
	22	const char *name;
	23	};
	24
	25	static const char builtin_diff_usage[] =
15e593e4	26	"git-diff <options> <rev>{0,2} -- <path>*";
65056021 JH	27
	28	static int builtin_diff_files(struct rev_info *revs,
	29	int argc, const char **argv)
	30	{
	31	int silent = 0;
	32	while (1 < argc) {
	33	const char *arg = argv[1];
	34	if (!strcmp(arg, "--base"))
	35	revs->max_count = 1;
	36	else if (!strcmp(arg, "--ours"))
	37	revs->max_count = 2;
	38	else if (!strcmp(arg, "--theirs"))
	39	revs->max_count = 3;
	40	else if (!strcmp(arg, "-q"))
	41	silent = 1;
65056021 JH	42	else
	43	usage(builtin_diff_usage);
	44	argv++; argc--;
	45	}
	46	/*
	47	* Make sure there are NO revision (i.e. pending object) parameter,
0fe7c1de JH	48	* specified rev.max_count is reasonable (0 <= n <= 3), and
0fe7c1de JH	49	* there is no other revision filtering parameter.
65056021	50	*/
1f1e895f	51	if (revs->pending.nr \|\|
65056021	52	revs->min_age != -1 \|\|
0fe7c1de JH	53	revs->max_age != -1 \|\|
0fe7c1de JH	54	3 < revs->max_count)
65056021	55	usage(builtin_diff_usage);
0fe7c1de	56	if (revs->max_count < 0 &&
c6744349	57	(revs->diffopt.output_format & DIFF_FORMAT_PATCH))
0fe7c1de	58	revs->combine_merges = revs->dense_combined_merges = 1;
65056021 JH	59	return run_diff_files(revs, silent);
	60	}
	61
	62	static void stuff_change(struct diff_options *opt,
	63	unsigned old_mode, unsigned new_mode,
	64	const unsigned char *old_sha1,
	65	const unsigned char *new_sha1,
	66	const char *old_name,
	67	const char *new_name)
	68	{
	69	struct diff_filespec one, two;
	70
0bef57ee	71	if (!is_null_sha1(old_sha1) && !is_null_sha1(new_sha1) &&
a89fccd2	72	!hashcmp(old_sha1, new_sha1))
65056021 JH	73	return;
	74
	75	if (opt->reverse_diff) {
	76	unsigned tmp;
d92f1dc6	77	const unsigned char *tmp_u;
65056021 JH	78	const char *tmp_c;
	79	tmp = old_mode; old_mode = new_mode; new_mode = tmp;
	80	tmp_u = old_sha1; old_sha1 = new_sha1; new_sha1 = tmp_u;
	81	tmp_c = old_name; old_name = new_name; new_name = tmp_c;
	82	}
	83	one = alloc_filespec(old_name);
	84	two = alloc_filespec(new_name);
	85	fill_filespec(one, old_sha1, old_mode);
	86	fill_filespec(two, new_sha1, new_mode);
	87
	88	/* NEEDSWORK: shouldn't this part of diffopt??? */
	89	diff_queue(&diff_queued_diff, one, two);
	90	}
	91
	92	static int builtin_diff_b_f(struct rev_info *revs,
	93	int argc, const char **argv,
	94	struct blobinfo *blob,
	95	const char *path)
	96	{
	97	/* Blob vs file in the working tree*/
	98	struct stat st;
	99
a610786f TH	100	if (argc > 1)
	101	usage(builtin_diff_usage);
	102
65056021 JH	103	if (lstat(path, &st))
	104	die("'%s': %s", path, strerror(errno));
	105	if (!(S_ISREG(st.st_mode) \|\| S_ISLNK(st.st_mode)))
	106	die("'%s': not a regular file or symlink", path);
	107	stuff_change(&revs->diffopt,
	108	canon_mode(st.st_mode), canon_mode(st.st_mode),
	109	blob[0].sha1, null_sha1,
065e0b12	110	path, path);
65056021 JH	111	diffcore_std(&revs->diffopt);
	112	diff_flush(&revs->diffopt);
	113	return 0;
	114	}
	115
	116	static int builtin_diff_blobs(struct rev_info *revs,
	117	int argc, const char **argv,
	118	struct blobinfo *blob)
	119	{
65056021 JH	120	unsigned mode = canon_mode(S_IFREG \| 0644);
65056021 JH	121
a610786f TH	122	if (argc > 1)
	123	usage(builtin_diff_usage);
	124
65056021 JH	125	stuff_change(&revs->diffopt,
65056021 JH	126	mode, mode,
f82cd3c6	127	blob[0].sha1, blob[1].sha1,
53dd8a9c	128	blob[0].name, blob[1].name);
65056021 JH	129	diffcore_std(&revs->diffopt);
	130	diff_flush(&revs->diffopt);
	131	return 0;
	132	}
	133
	134	static int builtin_diff_index(struct rev_info *revs,
	135	int argc, const char **argv)
	136	{
	137	int cached = 0;
	138	while (1 < argc) {
	139	const char *arg = argv[1];
f2dd1c9a	140	if (!strcmp(arg, "--cached"))
65056021	141	cached = 1;
65056021 JH	142	else
	143	usage(builtin_diff_usage);
	144	argv++; argc--;
	145	}
	146	/*
	147	* Make sure there is one revision (i.e. pending object),
	148	* and there is no revision filtering parameters.
	149	*/
1f1e895f	150	if (revs->pending.nr != 1 \|\|
65056021 JH	151	revs->max_count != -1 \|\| revs->min_age != -1 \|\|
	152	revs->max_age != -1)
	153	usage(builtin_diff_usage);
	154	return run_diff_index(revs, cached);
	155	}
	156
	157	static int builtin_diff_tree(struct rev_info *revs,
	158	int argc, const char **argv,
1f1e895f	159	struct object_array_entry *ent)
65056021	160	{
65056021	161	const unsigned char *(sha1[2]);
1f1e895f	162	int swap = 0;
a610786f TH	163
	164	if (argc > 1)
	165	usage(builtin_diff_usage);
0fe7c1de JH	166
0fe7c1de JH	167	/* We saw two trees, ent[0] and ent[1].
82e5a82f	168	* if ent[1] is uninteresting, they are swapped
0fe7c1de	169	*/
1f1e895f LT	170	if (ent[1].item->flags & UNINTERESTING)
1f1e895f LT	171	swap = 1;
65056021 JH	172	sha1[swap] = ent[0].item->sha1;
	173	sha1[1-swap] = ent[1].item->sha1;
	174	diff_tree_sha1(sha1[0], sha1[1], "", &revs->diffopt);
	175	log_tree_diff_flush(revs);
	176	return 0;
	177	}
	178
0fe7c1de JH	179	static int builtin_diff_combined(struct rev_info *revs,
0fe7c1de JH	180	int argc, const char **argv,
1f1e895f	181	struct object_array_entry *ent,
0fe7c1de JH	182	int ents)
	183	{
	184	const unsigned char (*parent)[20];
	185	int i;
	186
a610786f TH	187	if (argc > 1)
	188	usage(builtin_diff_usage);
	189
0fe7c1de JH	190	if (!revs->dense_combined_merges && !revs->combine_merges)
	191	revs->dense_combined_merges = revs->combine_merges = 1;
	192	parent = xmalloc(ents * sizeof(*parent));
	193	/* Again, the revs are all reverse */
	194	for (i = 0; i < ents; i++)
75b62b48 JS	195	hashcpy((unsigned char *)(parent + i),
75b62b48 JS	196	ent[ents - 1 - i].item->sha1);
0fe7c1de JH	197	diff_tree_combined(parent[0], parent + 1, ents - 1,
	198	revs->dense_combined_merges, revs);
	199	return 0;
	200	}
	201
e686eb98	202	void add_head(struct rev_info *revs)
65056021 JH	203	{
	204	unsigned char sha1[20];
	205	struct object *obj;
	206	if (get_sha1("HEAD", sha1))
	207	return;
	208	obj = parse_object(sha1);
	209	if (!obj)
	210	return;
1f1e895f	211	add_pending_object(revs, obj, "HEAD");
65056021 JH	212	}
65056021 JH	213
a633fca0	214	int cmd_diff(int argc, const char *argv, const char prefix)
65056021	215	{
1f1e895f	216	int i;
65056021	217	struct rev_info rev;
1f1e895f	218	struct object_array_entry ent[100];
65056021	219	int ents = 0, blobs = 0, paths = 0;
a633fca0	220	const char *path = NULL;
65056021 JH	221	struct blobinfo blob[2];
	222
	223	/*
	224	* We could get N tree-ish in the rev.pending_objects list.
	225	* Also there could be M blobs there, and P pathspecs.
	226	*
	227	* N=0, M=0:
	228	* cache vs files (diff-files)
	229	* N=0, M=2:
	230	* compare two random blobs. P must be zero.
	231	* N=0, M=1, P=1:
	232	* compare a blob with a working tree file.
	233	*
	234	* N=1, M=0:
	235	* tree vs cache (diff-index --cached)
	236	*
	237	* N=2, M=0:
	238	* tree vs tree (diff-tree)
	239	*
	240	* Other cases are errors.
	241	*/
230f544e	242
ef1d9c5a	243	git_config(git_diff_ui_config);
db6296a5	244	init_revisions(&rev, prefix);
65056021 JH	245
65056021 JH	246	argc = setup_revisions(argc, argv, &rev, NULL);
047fbe90	247	if (!rev.diffopt.output_format) {
c9b5ef99	248	rev.diffopt.output_format = DIFF_FORMAT_PATCH;
72ee96c0 JH	249	if (diff_setup_done(&rev.diffopt) < 0)
72ee96c0 JH	250	die("diff_setup_done failed");
047fbe90	251	}
c9b5ef99	252
65056021 JH	253	/* Do we have --cached and not have a pending object, then
	254	* default to HEAD by hand. Eek.
	255	*/
1f1e895f	256	if (!rev.pending.nr) {
65056021 JH	257	int i;
	258	for (i = 1; i < argc; i++) {
	259	const char *arg = argv[i];
	260	if (!strcmp(arg, "--"))
	261	break;
	262	else if (!strcmp(arg, "--cached")) {
	263	add_head(&rev);
	264	break;
	265	}
	266	}
	267	}
	268
1f1e895f LT	269	for (i = 0; i < rev.pending.nr; i++) {
1f1e895f LT	270	struct object_array_entry *list = rev.pending.objects+i;
65056021 JH	271	struct object *obj = list->item;
	272	const char *name = list->name;
	273	int flags = (obj->flags & UNINTERESTING);
	274	if (!obj->parsed)
	275	obj = parse_object(obj->sha1);
	276	obj = deref_tag(obj, NULL, 0);
	277	if (!obj)
	278	die("invalid object '%s' given.", name);
1974632c	279	if (obj->type == OBJ_COMMIT)
65056021	280	obj = &((struct commit *)obj)->tree->object;
1974632c	281	if (obj->type == OBJ_TREE) {
0fe7c1de JH	282	if (ARRAY_SIZE(ent) <= ents)
0fe7c1de JH	283	die("more than %d trees given: '%s'",
334b506a	284	(int) ARRAY_SIZE(ent), name);
65056021 JH	285	obj->flags \|= flags;
	286	ent[ents].item = obj;
	287	ent[ents].name = name;
	288	ents++;
	289	continue;
	290	}
1974632c	291	if (obj->type == OBJ_BLOB) {
65056021 JH	292	if (2 <= blobs)
65056021 JH	293	die("more than two blobs given: '%s'", name);
e702496e	294	hashcpy(blob[blobs].sha1, obj->sha1);
65056021 JH	295	blob[blobs].name = name;
	296	blobs++;
	297	continue;
230f544e	298
65056021 JH	299	}
	300	die("unhandled object '%s' given.", name);
	301	}
	302	if (rev.prune_data) {
	303	const char **pathspec = rev.prune_data;
	304	while (*pathspec) {
	305	if (!path)
	306	path = *pathspec;
	307	paths++;
	308	pathspec++;
	309	}
	310	}
	311
	312	/*
	313	* Now, do the arguments look reasonable?
	314	*/
	315	if (!ents) {
	316	switch (blobs) {
	317	case 0:
	318	return builtin_diff_files(&rev, argc, argv);
	319	break;
	320	case 1:
	321	if (paths != 1)
	322	usage(builtin_diff_usage);
	323	return builtin_diff_b_f(&rev, argc, argv, blob, path);
	324	break;
	325	case 2:
0fe7c1de JH	326	if (paths)
0fe7c1de JH	327	usage(builtin_diff_usage);
65056021 JH	328	return builtin_diff_blobs(&rev, argc, argv, blob);
	329	break;
	330	default:
	331	usage(builtin_diff_usage);
	332	}
	333	}
	334	else if (blobs)
	335	usage(builtin_diff_usage);
	336	else if (ents == 1)
	337	return builtin_diff_index(&rev, argc, argv);
	338	else if (ents == 2)
	339	return builtin_diff_tree(&rev, argc, argv, ent);
9919f41c JH	340	else if ((ents == 3) && (ent[0].item->flags & UNINTERESTING)) {
	341	/* diff A...B where there is one sane merge base between
	342	* A and B. We have ent[0] == merge-base, ent[1] == A,
	343	* and ent[2] == B. Show diff between the base and B.
	344	*/
306ea2df	345	ent[1] = ent[2];
9919f41c JH	346	return builtin_diff_tree(&rev, argc, argv, ent);
9919f41c JH	347	}
0fe7c1de	348	else
9919f41c JH	349	return builtin_diff_combined(&rev, argc, argv,
9919f41c JH	350	ent, ents);
65056021 JH	351	usage(builtin_diff_usage);
65056021 JH	352	}