Fossil SCM

Improved formatting for command-line side-by-side diff. Extend command-line side-by-side diff to all diff operations, including stash diffs.

drh 2011-10-21 23:44 trunk

Commit ab47cc73d7d95c78cf2e796654e536fbf4790530

Parent 54e730c339278e1…

4 files changed +54 -17 +38 -26 +1 -1 +12 -10

~ src/diff.c ~ src/diffcmd.c ~ src/printf.c ~ src/stash.c

M src/diff.c

+54 -17

		--- src/diff.c
		+++ src/diff.c
		@@ -389,13 +389,11 @@
389	389	/*
390	390	* If the patch changes an empty file or results in an empty file,
391	391	* the block header must use 0,0 as position indicator and not 1,0.
392	392	* Otherwise, patch would be confused and may reject the diff.
393	393	*/
394		- blob_appendf(pOut,"@@ -%d,%d +%d,%d @@\n",
395		- na ? a+skip+1 : 0, na,
396		- nb ? b+skip+1 : 0, nb);
	394	+ if( r>0 ) blob_appendf(pOut,"%.c\n", width2+16, '.');
397	395
398	396	/* Show the initial common area */
399	397	a += skip;
400	398	b += skip;
401	399	m = R[r] - skip;
		@@ -698,10 +696,30 @@
698	696	p->aEdit[p->nEdit++] = 0;
699	697	p->aEdit[p->nEdit++] = 0;
700	698	p->aEdit[p->nEdit++] = 0;
701	699	}
702	700	}
	701	+
	702	+/*
	703	+** Extract the number of lines of context from diffFlags. Supply an
	704	+** appropriate default if no context width is specified.
	705	+*/
	706	+int diff_context_lines(int diffFlags){
	707	+ int n = diffFlags & DIFF_CONTEXT_MASK;
	708	+ if( n==0 ) n = 5;
	709	+ return n;
	710	+}
	711	+
	712	+/*
	713	+** Extract the width of columns for side-by-side diff. Supply an
	714	+** appropriate default if no width is given.
	715	+*/
	716	+int diff_width(int diffFlags){
	717	+ int w = (diffFlags & DIFF_WIDTH_MASK)/(DIFF_CONTEXT_MASK+1);
	718	+ if( w==0 ) w = 80;
	719	+ return w;
	720	+}
703	721
704	722	/*
705	723	** Generate a report of the differences between files pA and pB.
706	724	** If pOut is not NULL then a unified diff is appended there. It
707	725	** is assumed that pOut has already been initialized. If pOut is
		@@ -723,12 +741,11 @@
723	741	){
724	742	int ignoreEolWs; /* Ignore whitespace at the end of lines */
725	743	int nContext; /* Amount of context to display */
726	744	DContext c;
727	745
728		- nContext = diffFlags & DIFF_CONTEXT_MASK;
729		- if( nContext==0 ) nContext = 5;
	746	+ nContext = diff_context_lines(diffFlags);
730	747	ignoreEolWs = (diffFlags & DIFF_IGNORE_EOLWS)!=0;
731	748
732	749	/* Prepare the input files */
733	750	memset(&c, 0, sizeof(c));
734	751	c.aFrom = break_into_lines(blob_str(pA_Blob), blob_size(pA_Blob),
		@@ -748,12 +765,11 @@
748	765	diff_all(&c);
749	766
750	767	if( pOut ){
751	768	/* Compute a context or side-by-side diff into pOut */
752	769	if( diffFlags & DIFF_SIDEBYSIDE ){
753		- int width = (diffFlags & DIFF_WIDTH_MASK)/(DIFF_CONTEXT_MASK+1);
754		- if( width==0 ) width = 80;
	770	+ int width = diff_width(diffFlags);
755	771	sbsDiff(&c, pOut, nContext, width);
756	772	}else{
757	773	contextDiff(&c, pOut, nContext);
758	774	}
759	775	free(c.aFrom);
		@@ -973,29 +989,50 @@
973	989	}
974	990	/* free(R); */
975	991	blob_reset(&b);
976	992	}
977	993	}
	994	+
	995	+/*
	996	+** Process diff-related command-line options and return an appropriate
	997	+** "diffFlags" integer.
	998	+**
	999	+** --side-by-side\|-y Side-by-side diff. DIFF_SIDEBYSIDE
	1000	+** --context\|-c N N lines of context. DIFF_CONTEXT_MASK
	1001	+** --width\|-W N N character lines. DIFF_WIDTH_MASK
	1002	+*/
	1003	+int diff_options(void){
	1004	+ int diffFlags = 0;
	1005	+ const char *z;
	1006	+ int f;
	1007	+ if( find_option("side-by-side","y",0)!=0 ) diffFlags \|= DIFF_SIDEBYSIDE;
	1008	+ if( (z = find_option("context","c",1))!=0 && (f = atoi(z))>0 ){
	1009	+ if( f > DIFF_CONTEXT_MASK ) f = DIFF_CONTEXT_MASK;
	1010	+ diffFlags \|= f;
	1011	+ }
	1012	+ if( (z = find_option("width","W",1))!=0 && (f = atoi(z))>0 ){
	1013	+ f *= DIFF_CONTEXT_MASK+1;
	1014	+ if( f > DIFF_WIDTH_MASK ) f = DIFF_CONTEXT_MASK;
	1015	+ diffFlags \|= f;
	1016	+ }
	1017	+ return diffFlags;
	1018	+}
978	1019
979	1020	/*
980	1021	** COMMAND: test-udiff
	1022	+**
	1023	+** Print the difference between two files. The usual diff options apply.
981	1024	*/
982	1025	void test_udiff_cmd(void){
983	1026	Blob a, b, out;
984		- int diffFlag = find_option("sbs",0,0)!=0 ? DIFF_SIDEBYSIDE : 0;
985		- int nContext = 5;
986		- const char *z;
987		- if( (z = find_option("context","c",1))!=0 && atoi(z)>0 ){
988		- nContext = atoi(z);
989		- }
990		- if( nContext<=0 ) nContext = 5;
991		- if( (nContext&DIFF_CONTEXT_MASK)!=nContext ) nContext = DIFF_CONTEXT_MASK;
992		- if( g.argc!=4 ) usage("[--sbs] [--context N] FILE1 FILE2");
	1027	+ int diffFlag = diff_options();
	1028	+
	1029	+ if( g.argc!=4 ) usage("FILE1 FILE2");
993	1030	blob_read_from_file(&a, g.argv[2]);
994	1031	blob_read_from_file(&b, g.argv[3]);
995	1032	blob_zero(&out);
996		- text_diff(&a, &b, &out, nContext \| diffFlag);
	1033	+ text_diff(&a, &b, &out, diffFlag);
997	1034	blob_write_to_file(&out, "-");
998	1035	}
999	1036
1000	1037	/**************************************************************************
1001	1038	** The basic difference engine is above. What follows is the annotation
1002	1039

	--- src/diff.c
	+++ src/diff.c
	@@ -389,13 +389,11 @@
389	/*
390	* If the patch changes an empty file or results in an empty file,
391	* the block header must use 0,0 as position indicator and not 1,0.
392	* Otherwise, patch would be confused and may reject the diff.
393	*/
394	blob_appendf(pOut,"@@ -%d,%d +%d,%d @@\n",
395	na ? a+skip+1 : 0, na,
396	nb ? b+skip+1 : 0, nb);
397
398	/* Show the initial common area */
399	a += skip;
400	b += skip;
401	m = R[r] - skip;
	@@ -698,10 +696,30 @@
698	p->aEdit[p->nEdit++] = 0;
699	p->aEdit[p->nEdit++] = 0;
700	p->aEdit[p->nEdit++] = 0;
701	}
702	}




















703
704	/*
705	** Generate a report of the differences between files pA and pB.
706	** If pOut is not NULL then a unified diff is appended there. It
707	** is assumed that pOut has already been initialized. If pOut is
	@@ -723,12 +741,11 @@
723	){
724	int ignoreEolWs; /* Ignore whitespace at the end of lines */
725	int nContext; /* Amount of context to display */
726	DContext c;
727
728	nContext = diffFlags & DIFF_CONTEXT_MASK;
729	if( nContext==0 ) nContext = 5;
730	ignoreEolWs = (diffFlags & DIFF_IGNORE_EOLWS)!=0;
731
732	/* Prepare the input files */
733	memset(&c, 0, sizeof(c));
734	c.aFrom = break_into_lines(blob_str(pA_Blob), blob_size(pA_Blob),
	@@ -748,12 +765,11 @@
748	diff_all(&c);
749
750	if( pOut ){
751	/* Compute a context or side-by-side diff into pOut */
752	if( diffFlags & DIFF_SIDEBYSIDE ){
753	int width = (diffFlags & DIFF_WIDTH_MASK)/(DIFF_CONTEXT_MASK+1);
754	if( width==0 ) width = 80;
755	sbsDiff(&c, pOut, nContext, width);
756	}else{
757	contextDiff(&c, pOut, nContext);
758	}
759	free(c.aFrom);
	@@ -973,29 +989,50 @@
973	}
974	/* free(R); */
975	blob_reset(&b);
976	}
977	}

























978
979	/*
980	** COMMAND: test-udiff


981	*/
982	void test_udiff_cmd(void){
983	Blob a, b, out;
984	int diffFlag = find_option("sbs",0,0)!=0 ? DIFF_SIDEBYSIDE : 0;
985	int nContext = 5;
986	const char *z;
987	if( (z = find_option("context","c",1))!=0 && atoi(z)>0 ){
988	nContext = atoi(z);
989	}
990	if( nContext<=0 ) nContext = 5;
991	if( (nContext&DIFF_CONTEXT_MASK)!=nContext ) nContext = DIFF_CONTEXT_MASK;
992	if( g.argc!=4 ) usage("[--sbs] [--context N] FILE1 FILE2");
993	blob_read_from_file(&a, g.argv[2]);
994	blob_read_from_file(&b, g.argv[3]);
995	blob_zero(&out);
996	text_diff(&a, &b, &out, nContext \| diffFlag);
997	blob_write_to_file(&out, "-");
998	}
999
1000	/**************************************************************************
1001	** The basic difference engine is above. What follows is the annotation
1002

	--- src/diff.c
	+++ src/diff.c
	@@ -389,13 +389,11 @@
389	/*
390	* If the patch changes an empty file or results in an empty file,
391	* the block header must use 0,0 as position indicator and not 1,0.
392	* Otherwise, patch would be confused and may reject the diff.
393	*/
394	if( r>0 ) blob_appendf(pOut,"%.c\n", width2+16, '.');


395
396	/* Show the initial common area */
397	a += skip;
398	b += skip;
399	m = R[r] - skip;
	@@ -698,10 +696,30 @@
696	p->aEdit[p->nEdit++] = 0;
697	p->aEdit[p->nEdit++] = 0;
698	p->aEdit[p->nEdit++] = 0;
699	}
700	}
701
702	/*
703	** Extract the number of lines of context from diffFlags. Supply an
704	** appropriate default if no context width is specified.
705	*/
706	int diff_context_lines(int diffFlags){
707	int n = diffFlags & DIFF_CONTEXT_MASK;
708	if( n==0 ) n = 5;
709	return n;
710	}
711
712	/*
713	** Extract the width of columns for side-by-side diff. Supply an
714	** appropriate default if no width is given.
715	*/
716	int diff_width(int diffFlags){
717	int w = (diffFlags & DIFF_WIDTH_MASK)/(DIFF_CONTEXT_MASK+1);
718	if( w==0 ) w = 80;
719	return w;
720	}
721
722	/*
723	** Generate a report of the differences between files pA and pB.
724	** If pOut is not NULL then a unified diff is appended there. It
725	** is assumed that pOut has already been initialized. If pOut is
	@@ -723,12 +741,11 @@
741	){
742	int ignoreEolWs; /* Ignore whitespace at the end of lines */
743	int nContext; /* Amount of context to display */
744	DContext c;
745
746	nContext = diff_context_lines(diffFlags);

747	ignoreEolWs = (diffFlags & DIFF_IGNORE_EOLWS)!=0;
748
749	/* Prepare the input files */
750	memset(&c, 0, sizeof(c));
751	c.aFrom = break_into_lines(blob_str(pA_Blob), blob_size(pA_Blob),
	@@ -748,12 +765,11 @@
765	diff_all(&c);
766
767	if( pOut ){
768	/* Compute a context or side-by-side diff into pOut */
769	if( diffFlags & DIFF_SIDEBYSIDE ){
770	int width = diff_width(diffFlags);

771	sbsDiff(&c, pOut, nContext, width);
772	}else{
773	contextDiff(&c, pOut, nContext);
774	}
775	free(c.aFrom);
	@@ -973,29 +989,50 @@
989	}
990	/* free(R); */
991	blob_reset(&b);
992	}
993	}
994
995	/*
996	** Process diff-related command-line options and return an appropriate
997	** "diffFlags" integer.
998	**
999	** --side-by-side\|-y Side-by-side diff. DIFF_SIDEBYSIDE
1000	** --context\|-c N N lines of context. DIFF_CONTEXT_MASK
1001	** --width\|-W N N character lines. DIFF_WIDTH_MASK
1002	*/
1003	int diff_options(void){
1004	int diffFlags = 0;
1005	const char *z;
1006	int f;
1007	if( find_option("side-by-side","y",0)!=0 ) diffFlags \|= DIFF_SIDEBYSIDE;
1008	if( (z = find_option("context","c",1))!=0 && (f = atoi(z))>0 ){
1009	if( f > DIFF_CONTEXT_MASK ) f = DIFF_CONTEXT_MASK;
1010	diffFlags \|= f;
1011	}
1012	if( (z = find_option("width","W",1))!=0 && (f = atoi(z))>0 ){
1013	f *= DIFF_CONTEXT_MASK+1;
1014	if( f > DIFF_WIDTH_MASK ) f = DIFF_CONTEXT_MASK;
1015	diffFlags \|= f;
1016	}
1017	return diffFlags;
1018	}
1019
1020	/*
1021	** COMMAND: test-udiff
1022	**
1023	** Print the difference between two files. The usual diff options apply.
1024	*/
1025	void test_udiff_cmd(void){
1026	Blob a, b, out;
1027	int diffFlag = diff_options();
1028
1029	if( g.argc!=4 ) usage("FILE1 FILE2");






1030	blob_read_from_file(&a, g.argv[2]);
1031	blob_read_from_file(&b, g.argv[3]);
1032	blob_zero(&out);
1033	text_diff(&a, &b, &out, diffFlag);
1034	blob_write_to_file(&out, "-");
1035	}
1036
1037	/**************************************************************************
1038	** The basic difference engine is above. What follows is the annotation
1039

M src/diffcmd.c

+38 -26

		--- src/diffcmd.c
		+++ src/diffcmd.c
		@@ -35,15 +35,38 @@
35	35	}
36	36	va_end(ap);
37	37	}
38	38
39	39	/*
40		-** Print the "Index:" message that patch wants to see at the top of a diff.
	40	+** Print the "Index:" message that patches wants to see at the top of a diff.
	41	+*/
	42	+void diff_print_index(const char *zFile, int diffFlags){
	43	+ if( (diffFlags & DIFF_SIDEBYSIDE)==0 ){
	44	+ char *z = mprintf("Index: %s\n%.66c\n", zFile, '=');
	45	+ diff_printf("%s", z);
	46	+ fossil_free(z);
	47	+ }
	48	+}
	49	+
	50	+/*
	51	+** Print the +++/--- filename lines for a diff operation.
41	52	*/
42		-void diff_print_index(const char *zFile){
43		- diff_printf("Index: %s\n======================================="
44		- "============================\n", zFile);
	53	+void diff_print_filenames(const char zLeft, const char zRight, int diffFlags){
	54	+ char *z = 0;
	55	+ if( diffFlags & DIFF_SIDEBYSIDE ){
	56	+ int w = diff_width(diffFlags);
	57	+ int n1 = strlen(zLeft);
	58	+ int x;
	59	+ if( n1>w2 ) n1 = w2;
	60	+ x = w*2+17 - (n1+2);
	61	+ z = mprintf("%.c %.s %.*c\n",
	62	+ x/2, '=', n1, zLeft, (x+1)/2, '=');
	63	+ }else{
	64	+ z = mprintf("--- %s\n+++ %s\n", zLeft, zRight);
	65	+ }
	66	+ diff_printf("%s", z);
	67	+ fossil_free(z);
45	68	}
46	69
47	70	/*
48	71	** Show the difference between two files, one in memory and one on disk.
49	72	**
		@@ -80,11 +103,11 @@
80	103
81	104	/* Compute and output the differences */
82	105	blob_zero(&out);
83	106	text_diff(pFile1, &file2, &out, diffFlags);
84	107	if( blob_size(&out) ){
85		- diff_printf("--- %s\n+++ %s\n", zName, zName2);
	108	+ diff_print_filenames(zName, zName2, diffFlags);
86	109	diff_printf("%s\n", blob_str(&out));
87	110	}
88	111
89	112	/* Release memory resources */
90	113	blob_reset(&file2);
		@@ -139,11 +162,11 @@
139	162	if( zDiffCmd==0 ){
140	163	Blob out; /* Diff output text */
141	164
142	165	blob_zero(&out);
143	166	text_diff(pFile1, pFile2, &out, diffFlags);
144		- diff_printf("--- %s\n+++ %s\n", zName, zName);
	167	+ diff_print_filenames(zName, zName, diffFlags);
145	168	diff_printf("%s\n", blob_str(&out));
146	169
147	170	/* Release memory resources */
148	171	blob_reset(&out);
149	172	}else{
		@@ -281,21 +304,21 @@
281	304	if( !asNewFile ){ showDiff = 0; }
282	305	}
283	306	if( showDiff ){
284	307	Blob content;
285	308	if( !isLink != !file_wd_islink(zFullName) ){
286		- diff_print_index(zPathname);
287		- diff_printf("--- %s\n+++ %s\n", zPathname, zPathname);
	309	+ diff_print_index(zPathname, diffFlags);
	310	+ diff_print_filenames(zPathname, zPathname, diffFlags);
288	311	diff_printf("cannot compute difference between symlink and regular file\n");
289	312	continue;
290	313	}
291	314	if( srcid>0 ){
292	315	content_get(srcid, &content);
293	316	}else{
294	317	blob_zero(&content);
295	318	}
296		- diff_print_index(zPathname);
	319	+ diff_print_index(zPathname, diffFlags);
297	320	diff_file(&content, zFullName, zPathname, zDiffCmd, diffFlags);
298	321	blob_reset(&content);
299	322	}
300	323	free(zToFree);
301	324	}
		@@ -321,11 +344,11 @@
321	344	file_tree_name(zFileTreeName, &fname, 1);
322	345	zName = blob_str(&fname);
323	346	historical_version_of_file(zFrom, zName, &v1, &isLink1, 0, 0);
324	347	historical_version_of_file(zTo, zName, &v2, &isLink2, 0, 0);
325	348	if( isLink1 != isLink2 ){
326		- diff_printf("--- %s\n+++ %s\n", zName, zName);
	349	+ diff_print_filenames(zName, zName, diffFlags);
327	350	diff_printf("cannot compute difference between symlink and regular file\n");
328	351	}else{
329	352	diff_file_mem(&v1, &v2, zName, zDiffCmd, diffFlags);
330	353	}
331	354	blob_reset(&v1);
		@@ -344,11 +367,11 @@
344	367	int diffFlags
345	368	){
346	369	Blob f1, f2;
347	370	int rid;
348	371	const char *zName = pFrom ? pFrom->zName : pTo->zName;
349		- diff_print_index(zName);
	372	+ diff_print_index(zName, diffFlags);
350	373	if( pFrom ){
351	374	rid = uuid_to_rid(pFrom->zUuid, 0);
352	375	content_get(rid, &f1);
353	376	}else{
354	377	blob_zero(&f1);
		@@ -463,40 +486,29 @@
463	486	int hasNFlag; /* True if -N or --new-file flag is used */
464	487	const char zFrom; / Source version number */
465	488	const char zTo; / Target version number */
466	489	const char zDiffCmd = 0; / External diff command. NULL for internal diff */
467	490	int diffFlags = 0; /* Flags to control the DIFF */
468		- const char *z;
469	491	int f;
470	492
471	493	isGDiff = g.argv[1][0]=='g';
472	494	isInternDiff = find_option("internal","i",0)!=0;
473	495	zFrom = find_option("from", "r", 1);
474	496	zTo = find_option("to", 0, 1);
	497	+ diffFlags = diff_options();
475	498	hasNFlag = find_option("new-file","N",0)!=0;
476		- if( find_option("side-by-side","y",0)!=0 ) diffFlags \|= DIFF_SIDEBYSIDE;
477		- if( (z = find_option("context","c",1))!=0 && (f = atoi(z))>0 ){
478		- if( f > DIFF_CONTEXT_MASK ) f = DIFF_CONTEXT_MASK;
479		- diffFlags \|= f;
480		- }
481		- if( (z = find_option("width","W",1))!=0 && (f = atoi(z))>0 ){
482		- f *= DIFF_CONTEXT_MASK+1;
483		- if( f > DIFF_WIDTH_MASK ) f = DIFF_CONTEXT_MASK;
484		- diffFlags \|= f;
485		- }
486		-
487		-
488	499	if( hasNFlag ) diffFlags \|= DIFF_NEWFILE;
	500	+
489	501	if( zTo==0 ){
490	502	db_must_be_within_tree();
491	503	verify_all_options();
492	504	if( !isInternDiff ){
493	505	zDiffCmd = db_get(isGDiff ? "gdiff-command" : "diff-command", 0);
494	506	}
495	507	if( g.argc>=3 ){
496	508	for(f=2; f<g.argc; ++f){
497		- diff_one_against_disk(zFrom, zDiffCmd, 0, g.argv[f]);
	509	+ diff_one_against_disk(zFrom, zDiffCmd, diffFlags, g.argv[f]);
498	510	}
499	511	}else{
500	512	diff_all_against_disk(zFrom, zDiffCmd, diffFlags);
501	513	}
502	514	}else if( zFrom==0 ){
		@@ -507,11 +519,11 @@
507	519	if( !isInternDiff ){
508	520	zDiffCmd = db_get(isGDiff ? "gdiff-command" : "diff-command", 0);
509	521	}
510	522	if( g.argc>=3 ){
511	523	for(f=2; f<g.argc; ++f){
512		- diff_one_two_versions(zFrom, zTo, zDiffCmd, 0, g.argv[f]);
	524	+ diff_one_two_versions(zFrom, zTo, zDiffCmd, diffFlags, g.argv[f]);
513	525	}
514	526	}else{
515	527	diff_all_two_versions(zFrom, zTo, zDiffCmd, diffFlags);
516	528	}
517	529	}
518	530

	--- src/diffcmd.c
	+++ src/diffcmd.c
	@@ -35,15 +35,38 @@
35	}
36	va_end(ap);
37	}
38
39	/*
40	** Print the "Index:" message that patch wants to see at the top of a diff.











41	*/
42	void diff_print_index(const char *zFile){
43	diff_printf("Index: %s\n======================================="
44	"============================\n", zFile);












45	}
46
47	/*
48	** Show the difference between two files, one in memory and one on disk.
49	**
	@@ -80,11 +103,11 @@
80
81	/* Compute and output the differences */
82	blob_zero(&out);
83	text_diff(pFile1, &file2, &out, diffFlags);
84	if( blob_size(&out) ){
85	diff_printf("--- %s\n+++ %s\n", zName, zName2);
86	diff_printf("%s\n", blob_str(&out));
87	}
88
89	/* Release memory resources */
90	blob_reset(&file2);
	@@ -139,11 +162,11 @@
139	if( zDiffCmd==0 ){
140	Blob out; /* Diff output text */
141
142	blob_zero(&out);
143	text_diff(pFile1, pFile2, &out, diffFlags);
144	diff_printf("--- %s\n+++ %s\n", zName, zName);
145	diff_printf("%s\n", blob_str(&out));
146
147	/* Release memory resources */
148	blob_reset(&out);
149	}else{
	@@ -281,21 +304,21 @@
281	if( !asNewFile ){ showDiff = 0; }
282	}
283	if( showDiff ){
284	Blob content;
285	if( !isLink != !file_wd_islink(zFullName) ){
286	diff_print_index(zPathname);
287	diff_printf("--- %s\n+++ %s\n", zPathname, zPathname);
288	diff_printf("cannot compute difference between symlink and regular file\n");
289	continue;
290	}
291	if( srcid>0 ){
292	content_get(srcid, &content);
293	}else{
294	blob_zero(&content);
295	}
296	diff_print_index(zPathname);
297	diff_file(&content, zFullName, zPathname, zDiffCmd, diffFlags);
298	blob_reset(&content);
299	}
300	free(zToFree);
301	}
	@@ -321,11 +344,11 @@
321	file_tree_name(zFileTreeName, &fname, 1);
322	zName = blob_str(&fname);
323	historical_version_of_file(zFrom, zName, &v1, &isLink1, 0, 0);
324	historical_version_of_file(zTo, zName, &v2, &isLink2, 0, 0);
325	if( isLink1 != isLink2 ){
326	diff_printf("--- %s\n+++ %s\n", zName, zName);
327	diff_printf("cannot compute difference between symlink and regular file\n");
328	}else{
329	diff_file_mem(&v1, &v2, zName, zDiffCmd, diffFlags);
330	}
331	blob_reset(&v1);
	@@ -344,11 +367,11 @@
344	int diffFlags
345	){
346	Blob f1, f2;
347	int rid;
348	const char *zName = pFrom ? pFrom->zName : pTo->zName;
349	diff_print_index(zName);
350	if( pFrom ){
351	rid = uuid_to_rid(pFrom->zUuid, 0);
352	content_get(rid, &f1);
353	}else{
354	blob_zero(&f1);
	@@ -463,40 +486,29 @@
463	int hasNFlag; /* True if -N or --new-file flag is used */
464	const char zFrom; / Source version number */
465	const char zTo; / Target version number */
466	const char zDiffCmd = 0; / External diff command. NULL for internal diff */
467	int diffFlags = 0; /* Flags to control the DIFF */
468	const char *z;
469	int f;
470
471	isGDiff = g.argv[1][0]=='g';
472	isInternDiff = find_option("internal","i",0)!=0;
473	zFrom = find_option("from", "r", 1);
474	zTo = find_option("to", 0, 1);

475	hasNFlag = find_option("new-file","N",0)!=0;
476	if( find_option("side-by-side","y",0)!=0 ) diffFlags \|= DIFF_SIDEBYSIDE;
477	if( (z = find_option("context","c",1))!=0 && (f = atoi(z))>0 ){
478	if( f > DIFF_CONTEXT_MASK ) f = DIFF_CONTEXT_MASK;
479	diffFlags \|= f;
480	}
481	if( (z = find_option("width","W",1))!=0 && (f = atoi(z))>0 ){
482	f *= DIFF_CONTEXT_MASK+1;
483	if( f > DIFF_WIDTH_MASK ) f = DIFF_CONTEXT_MASK;
484	diffFlags \|= f;
485	}
486
487
488	if( hasNFlag ) diffFlags \|= DIFF_NEWFILE;

489	if( zTo==0 ){
490	db_must_be_within_tree();
491	verify_all_options();
492	if( !isInternDiff ){
493	zDiffCmd = db_get(isGDiff ? "gdiff-command" : "diff-command", 0);
494	}
495	if( g.argc>=3 ){
496	for(f=2; f<g.argc; ++f){
497	diff_one_against_disk(zFrom, zDiffCmd, 0, g.argv[f]);
498	}
499	}else{
500	diff_all_against_disk(zFrom, zDiffCmd, diffFlags);
501	}
502	}else if( zFrom==0 ){
	@@ -507,11 +519,11 @@
507	if( !isInternDiff ){
508	zDiffCmd = db_get(isGDiff ? "gdiff-command" : "diff-command", 0);
509	}
510	if( g.argc>=3 ){
511	for(f=2; f<g.argc; ++f){
512	diff_one_two_versions(zFrom, zTo, zDiffCmd, 0, g.argv[f]);
513	}
514	}else{
515	diff_all_two_versions(zFrom, zTo, zDiffCmd, diffFlags);
516	}
517	}
518

	--- src/diffcmd.c
	+++ src/diffcmd.c
	@@ -35,15 +35,38 @@
35	}
36	va_end(ap);
37	}
38
39	/*
40	** Print the "Index:" message that patches wants to see at the top of a diff.
41	*/
42	void diff_print_index(const char *zFile, int diffFlags){
43	if( (diffFlags & DIFF_SIDEBYSIDE)==0 ){
44	char *z = mprintf("Index: %s\n%.66c\n", zFile, '=');
45	diff_printf("%s", z);
46	fossil_free(z);
47	}
48	}
49
50	/*
51	** Print the +++/--- filename lines for a diff operation.
52	*/
53	void diff_print_filenames(const char zLeft, const char zRight, int diffFlags){
54	char *z = 0;
55	if( diffFlags & DIFF_SIDEBYSIDE ){
56	int w = diff_width(diffFlags);
57	int n1 = strlen(zLeft);
58	int x;
59	if( n1>w2 ) n1 = w2;
60	x = w*2+17 - (n1+2);
61	z = mprintf("%.c %.s %.*c\n",
62	x/2, '=', n1, zLeft, (x+1)/2, '=');
63	}else{
64	z = mprintf("--- %s\n+++ %s\n", zLeft, zRight);
65	}
66	diff_printf("%s", z);
67	fossil_free(z);
68	}
69
70	/*
71	** Show the difference between two files, one in memory and one on disk.
72	**
	@@ -80,11 +103,11 @@
103
104	/* Compute and output the differences */
105	blob_zero(&out);
106	text_diff(pFile1, &file2, &out, diffFlags);
107	if( blob_size(&out) ){
108	diff_print_filenames(zName, zName2, diffFlags);
109	diff_printf("%s\n", blob_str(&out));
110	}
111
112	/* Release memory resources */
113	blob_reset(&file2);
	@@ -139,11 +162,11 @@
162	if( zDiffCmd==0 ){
163	Blob out; /* Diff output text */
164
165	blob_zero(&out);
166	text_diff(pFile1, pFile2, &out, diffFlags);
167	diff_print_filenames(zName, zName, diffFlags);
168	diff_printf("%s\n", blob_str(&out));
169
170	/* Release memory resources */
171	blob_reset(&out);
172	}else{
	@@ -281,21 +304,21 @@
304	if( !asNewFile ){ showDiff = 0; }
305	}
306	if( showDiff ){
307	Blob content;
308	if( !isLink != !file_wd_islink(zFullName) ){
309	diff_print_index(zPathname, diffFlags);
310	diff_print_filenames(zPathname, zPathname, diffFlags);
311	diff_printf("cannot compute difference between symlink and regular file\n");
312	continue;
313	}
314	if( srcid>0 ){
315	content_get(srcid, &content);
316	}else{
317	blob_zero(&content);
318	}
319	diff_print_index(zPathname, diffFlags);
320	diff_file(&content, zFullName, zPathname, zDiffCmd, diffFlags);
321	blob_reset(&content);
322	}
323	free(zToFree);
324	}
	@@ -321,11 +344,11 @@
344	file_tree_name(zFileTreeName, &fname, 1);
345	zName = blob_str(&fname);
346	historical_version_of_file(zFrom, zName, &v1, &isLink1, 0, 0);
347	historical_version_of_file(zTo, zName, &v2, &isLink2, 0, 0);
348	if( isLink1 != isLink2 ){
349	diff_print_filenames(zName, zName, diffFlags);
350	diff_printf("cannot compute difference between symlink and regular file\n");
351	}else{
352	diff_file_mem(&v1, &v2, zName, zDiffCmd, diffFlags);
353	}
354	blob_reset(&v1);
	@@ -344,11 +367,11 @@
367	int diffFlags
368	){
369	Blob f1, f2;
370	int rid;
371	const char *zName = pFrom ? pFrom->zName : pTo->zName;
372	diff_print_index(zName, diffFlags);
373	if( pFrom ){
374	rid = uuid_to_rid(pFrom->zUuid, 0);
375	content_get(rid, &f1);
376	}else{
377	blob_zero(&f1);
	@@ -463,40 +486,29 @@
486	int hasNFlag; /* True if -N or --new-file flag is used */
487	const char zFrom; / Source version number */
488	const char zTo; / Target version number */
489	const char zDiffCmd = 0; / External diff command. NULL for internal diff */
490	int diffFlags = 0; /* Flags to control the DIFF */

491	int f;
492
493	isGDiff = g.argv[1][0]=='g';
494	isInternDiff = find_option("internal","i",0)!=0;
495	zFrom = find_option("from", "r", 1);
496	zTo = find_option("to", 0, 1);
497	diffFlags = diff_options();
498	hasNFlag = find_option("new-file","N",0)!=0;












499	if( hasNFlag ) diffFlags \|= DIFF_NEWFILE;
500
501	if( zTo==0 ){
502	db_must_be_within_tree();
503	verify_all_options();
504	if( !isInternDiff ){
505	zDiffCmd = db_get(isGDiff ? "gdiff-command" : "diff-command", 0);
506	}
507	if( g.argc>=3 ){
508	for(f=2; f<g.argc; ++f){
509	diff_one_against_disk(zFrom, zDiffCmd, diffFlags, g.argv[f]);
510	}
511	}else{
512	diff_all_against_disk(zFrom, zDiffCmd, diffFlags);
513	}
514	}else if( zFrom==0 ){
	@@ -507,11 +519,11 @@
519	if( !isInternDiff ){
520	zDiffCmd = db_get(isGDiff ? "gdiff-command" : "diff-command", 0);
521	}
522	if( g.argc>=3 ){
523	for(f=2; f<g.argc; ++f){
524	diff_one_two_versions(zFrom, zTo, zDiffCmd, diffFlags, g.argv[f]);
525	}
526	}else{
527	diff_all_two_versions(zFrom, zTo, zDiffCmd, diffFlags);
528	}
529	}
530

M src/printf.c

+1 -1

		--- src/printf.c
		+++ src/printf.c
		@@ -545,11 +545,11 @@
545	545	buf[0] = '%';
546	546	bufpt = buf;
547	547	length = 1;
548	548	break;
549	549	case etCHARX:
550		- c = buf[0] = (xtype==etCHARX ? va_arg(ap,int) : *++fmt);
	550	+ c = buf[0] = va_arg(ap,int);
551	551	if( precision>=0 ){
552	552	for(idx=1; idx<precision; idx++) buf[idx] = c;
553	553	length = precision;
554	554	}else{
555	555	length =1;
556	556

	--- src/printf.c
	+++ src/printf.c
	@@ -545,11 +545,11 @@
545	buf[0] = '%';
546	bufpt = buf;
547	length = 1;
548	break;
549	case etCHARX:
550	c = buf[0] = (xtype==etCHARX ? va_arg(ap,int) : *++fmt);
551	if( precision>=0 ){
552	for(idx=1; idx<precision; idx++) buf[idx] = c;
553	length = precision;
554	}else{
555	length =1;
556

	--- src/printf.c
	+++ src/printf.c
	@@ -545,11 +545,11 @@
545	buf[0] = '%';
546	bufpt = buf;
547	length = 1;
548	break;
549	case etCHARX:
550	c = buf[0] = va_arg(ap,int);
551	if( precision>=0 ){
552	for(idx=1; idx<precision; idx++) buf[idx] = c;
553	length = precision;
554	}else{
555	length =1;
556

M src/stash.c

+12 -10

		--- src/stash.c
		+++ src/stash.c
		@@ -266,11 +266,11 @@
266	266	}
267	267
268	268	/*
269	269	** Show the diffs associate with a single stash.
270	270	*/
271		-static void stash_diff(int stashid, const char *zDiffCmd){
	271	+static void stash_diff(int stashid, const char *zDiffCmd, int diffFlags){
272	272	Stmt q;
273	273	Blob empty;
274	274	blob_zero(&empty);
275	275	db_prepare(&q,
276	276	"SELECT rid, isRemoved, isExec, isLink, origname, newname, delta"
		@@ -286,21 +286,21 @@
286	286	char *zOPath = mprintf("%s%s", g.zLocalRoot, zOrig);
287	287	Blob delta;
288	288	if( rid==0 ){
289	289	db_ephemeral_blob(&q, 6, &delta);
290	290	fossil_print("ADDED %s\n", zNew);
291		- diff_print_index(zNew);
292		- diff_file_mem(&empty, &delta, zNew, zDiffCmd, 0);
	291	+ diff_print_index(zNew, diffFlags);
	292	+ diff_file_mem(&empty, &delta, zNew, zDiffCmd, diffFlags);
293	293	}else if( isRemoved ){
294	294	fossil_print("DELETE %s\n", zOrig);
295	295	if( file_wd_islink(zOPath) ){
296	296	blob_read_link(&delta, zOPath);
297	297	}else{
298	298	blob_read_from_file(&delta, zOPath);
299	299	}
300		- diff_print_index(zNew);
301		- diff_file_mem(&delta, &empty, zOrig, zDiffCmd, 0);
	300	+ diff_print_index(zNew, diffFlags);
	301	+ diff_file_mem(&delta, &empty, zOrig, zDiffCmd, diffFlags);
302	302	}else{
303	303	Blob a, b, disk;
304	304	int isOrigLink = file_wd_islink(zOPath);
305	305	db_ephemeral_blob(&q, 6, &delta);
306	306	if( isOrigLink ){
		@@ -308,17 +308,17 @@
308	308	}else{
309	309	blob_read_from_file(&disk, zOPath);
310	310	}
311	311	fossil_print("CHANGED %s\n", zNew);
312	312	if( !isOrigLink != !isLink ){
313		- diff_print_index(zNew);
314		- printf("--- %s\n+++ %s\n", zOrig, zNew);
	313	+ diff_print_index(zNew, diffFlags);
	314	+ diff_print_filenames(zOrig, zNew, diffFlags);
315	315	printf("cannot compute difference between symlink and regular file\n");
316	316	}else{
317	317	content_get(rid, &a);
318	318	blob_delta_apply(&a, &delta, &b);
319		- diff_file_mem(&disk, &b, zNew, zDiffCmd, 0);
	319	+ diff_file_mem(&disk, &b, zNew, zDiffCmd, diffFlags);
320	320	blob_reset(&a);
321	321	blob_reset(&b);
322	322	}
323	323	blob_reset(&disk);
324	324	}
		@@ -526,20 +526,22 @@
526	526	stashid);
527	527	undo_finish();
528	528	}else
529	529	if( memcmp(zCmd, "diff", nCmd)==0 ){
530	530	const char *zDiffCmd = db_get("diff-command", 0);
	531	+ int diffFlags = diff_options();
531	532	if( g.argc>4 ) usage("diff STASHID");
532	533	stashid = stash_get_id(g.argc==4 ? g.argv[3] : 0);
533		- stash_diff(stashid, zDiffCmd);
	534	+ stash_diff(stashid, zDiffCmd, diffFlags);
534	535	}else
535	536	if( memcmp(zCmd, "gdiff", nCmd)==0 ){
536	537	const char *zDiffCmd = db_get("gdiff-command", 0);
	538	+ int diffFlags = diff_options();
537	539	if( g.argc>4 ) usage("diff STASHID");
538	540	stashid = stash_get_id(g.argc==4 ? g.argv[3] : 0);
539		- stash_diff(stashid, zDiffCmd);
	541	+ stash_diff(stashid, zDiffCmd, diffFlags);
540	542	}else
541	543	{
542	544	usage("SUBCOMMAND ARGS...");
543	545	}
544	546	db_end_transaction(0);
545	547	}
546	548

	--- src/stash.c
	+++ src/stash.c
	@@ -266,11 +266,11 @@
266	}
267
268	/*
269	** Show the diffs associate with a single stash.
270	*/
271	static void stash_diff(int stashid, const char *zDiffCmd){
272	Stmt q;
273	Blob empty;
274	blob_zero(&empty);
275	db_prepare(&q,
276	"SELECT rid, isRemoved, isExec, isLink, origname, newname, delta"
	@@ -286,21 +286,21 @@
286	char *zOPath = mprintf("%s%s", g.zLocalRoot, zOrig);
287	Blob delta;
288	if( rid==0 ){
289	db_ephemeral_blob(&q, 6, &delta);
290	fossil_print("ADDED %s\n", zNew);
291	diff_print_index(zNew);
292	diff_file_mem(&empty, &delta, zNew, zDiffCmd, 0);
293	}else if( isRemoved ){
294	fossil_print("DELETE %s\n", zOrig);
295	if( file_wd_islink(zOPath) ){
296	blob_read_link(&delta, zOPath);
297	}else{
298	blob_read_from_file(&delta, zOPath);
299	}
300	diff_print_index(zNew);
301	diff_file_mem(&delta, &empty, zOrig, zDiffCmd, 0);
302	}else{
303	Blob a, b, disk;
304	int isOrigLink = file_wd_islink(zOPath);
305	db_ephemeral_blob(&q, 6, &delta);
306	if( isOrigLink ){
	@@ -308,17 +308,17 @@
308	}else{
309	blob_read_from_file(&disk, zOPath);
310	}
311	fossil_print("CHANGED %s\n", zNew);
312	if( !isOrigLink != !isLink ){
313	diff_print_index(zNew);
314	printf("--- %s\n+++ %s\n", zOrig, zNew);
315	printf("cannot compute difference between symlink and regular file\n");
316	}else{
317	content_get(rid, &a);
318	blob_delta_apply(&a, &delta, &b);
319	diff_file_mem(&disk, &b, zNew, zDiffCmd, 0);
320	blob_reset(&a);
321	blob_reset(&b);
322	}
323	blob_reset(&disk);
324	}
	@@ -526,20 +526,22 @@
526	stashid);
527	undo_finish();
528	}else
529	if( memcmp(zCmd, "diff", nCmd)==0 ){
530	const char *zDiffCmd = db_get("diff-command", 0);

531	if( g.argc>4 ) usage("diff STASHID");
532	stashid = stash_get_id(g.argc==4 ? g.argv[3] : 0);
533	stash_diff(stashid, zDiffCmd);
534	}else
535	if( memcmp(zCmd, "gdiff", nCmd)==0 ){
536	const char *zDiffCmd = db_get("gdiff-command", 0);

537	if( g.argc>4 ) usage("diff STASHID");
538	stashid = stash_get_id(g.argc==4 ? g.argv[3] : 0);
539	stash_diff(stashid, zDiffCmd);
540	}else
541	{
542	usage("SUBCOMMAND ARGS...");
543	}
544	db_end_transaction(0);
545	}
546

	--- src/stash.c
	+++ src/stash.c
	@@ -266,11 +266,11 @@
266	}
267
268	/*
269	** Show the diffs associate with a single stash.
270	*/
271	static void stash_diff(int stashid, const char *zDiffCmd, int diffFlags){
272	Stmt q;
273	Blob empty;
274	blob_zero(&empty);
275	db_prepare(&q,
276	"SELECT rid, isRemoved, isExec, isLink, origname, newname, delta"
	@@ -286,21 +286,21 @@
286	char *zOPath = mprintf("%s%s", g.zLocalRoot, zOrig);
287	Blob delta;
288	if( rid==0 ){
289	db_ephemeral_blob(&q, 6, &delta);
290	fossil_print("ADDED %s\n", zNew);
291	diff_print_index(zNew, diffFlags);
292	diff_file_mem(&empty, &delta, zNew, zDiffCmd, diffFlags);
293	}else if( isRemoved ){
294	fossil_print("DELETE %s\n", zOrig);
295	if( file_wd_islink(zOPath) ){
296	blob_read_link(&delta, zOPath);
297	}else{
298	blob_read_from_file(&delta, zOPath);
299	}
300	diff_print_index(zNew, diffFlags);
301	diff_file_mem(&delta, &empty, zOrig, zDiffCmd, diffFlags);
302	}else{
303	Blob a, b, disk;
304	int isOrigLink = file_wd_islink(zOPath);
305	db_ephemeral_blob(&q, 6, &delta);
306	if( isOrigLink ){
	@@ -308,17 +308,17 @@
308	}else{
309	blob_read_from_file(&disk, zOPath);
310	}
311	fossil_print("CHANGED %s\n", zNew);
312	if( !isOrigLink != !isLink ){
313	diff_print_index(zNew, diffFlags);
314	diff_print_filenames(zOrig, zNew, diffFlags);
315	printf("cannot compute difference between symlink and regular file\n");
316	}else{
317	content_get(rid, &a);
318	blob_delta_apply(&a, &delta, &b);
319	diff_file_mem(&disk, &b, zNew, zDiffCmd, diffFlags);
320	blob_reset(&a);
321	blob_reset(&b);
322	}
323	blob_reset(&disk);
324	}
	@@ -526,20 +526,22 @@
526	stashid);
527	undo_finish();
528	}else
529	if( memcmp(zCmd, "diff", nCmd)==0 ){
530	const char *zDiffCmd = db_get("diff-command", 0);
531	int diffFlags = diff_options();
532	if( g.argc>4 ) usage("diff STASHID");
533	stashid = stash_get_id(g.argc==4 ? g.argv[3] : 0);
534	stash_diff(stashid, zDiffCmd, diffFlags);
535	}else
536	if( memcmp(zCmd, "gdiff", nCmd)==0 ){
537	const char *zDiffCmd = db_get("gdiff-command", 0);
538	int diffFlags = diff_options();
539	if( g.argc>4 ) usage("diff STASHID");
540	stashid = stash_get_id(g.argc==4 ? g.argv[3] : 0);
541	stash_diff(stashid, zDiffCmd, diffFlags);
542	}else
543	{
544	usage("SUBCOMMAND ARGS...");
545	}
546	db_end_transaction(0);
547	}
548

Fossil SCM

Keyboard Shortcuts