diff3 support, needed for merging files together;

"go for it" niallo@

8 files changed, 994 insertions, 196 deletions

diff --git a/usr.bin/cvs/cvs.h b/usr.bin/cvs/cvs.h
index 74fe7e83baf..f08fb3f7316 100644
--- a/usr.bin/cvs/cvs.h
+++ b/usr.bin/cvs/cvs.h
@@ -1,4 +1,4 @@
-/*	$OpenBSD: cvs.h,v 1.86 2005/10/07 21:47:32 reyk Exp $	*/
+/*	$OpenBSD: cvs.h,v 1.87 2005/10/22 17:32:57 joris Exp $	*/
 /*
  * Copyright (c) 2004 Jean-Francois Brousseau <jfb@openbsd.org>
  * All rights reserved.
@@ -410,6 +410,21 @@ int	 cvs_logmsg_send(struct cvsroot *, const char *);
 time_t	cvs_date_parse(const char *);
 
 /* util.c */
+
+struct cvs_line {
+	char			*l_line;
+	int			 l_lineno;
+	TAILQ_ENTRY(cvs_line)	 l_list;
+};
+
+TAILQ_HEAD(cvs_tqh, cvs_line);
+
+struct cvs_lines {
+	int		l_nblines;
+	char		*l_data;
+	struct cvs_tqh	l_lines;
+};
+
 int	  cvs_readrepo(const char *, char *, size_t);
 int	  cvs_modetostr(mode_t, char *, size_t);
 int	  cvs_strtomode(const char *, mode_t *);
@@ -431,5 +446,12 @@ void	  cvs_write_tagfile(char *, char *, int);
 void	  cvs_parse_tagfile(char **, char **, int *);
 size_t	  cvs_path_cat(const char *, const char *, char *, size_t);
 
+BUF			*cvs_patchfile(const char *, const char *,
+			    int (*p)(struct cvs_lines *, struct cvs_lines *));
+struct cvs_lines	*cvs_splitlines(const char *);
+void			cvs_freelines(struct cvs_lines *);
+
+/* XXX */
+int			rcs_patch_lines(struct cvs_lines *, struct cvs_lines *);
 
 #endif	/* CVS_H */
diff --git a/usr.bin/cvs/diff.c b/usr.bin/cvs/diff.c
index 5b449576485..636d7c2e2ac 100644
--- a/usr.bin/cvs/diff.c
+++ b/usr.bin/cvs/diff.c
@@ -1,4 +1,4 @@
-/*	$OpenBSD: diff.c,v 1.62 2005/10/11 18:01:57 joris Exp $	*/
+/*	$OpenBSD: diff.c,v 1.63 2005/10/22 17:32:57 joris Exp $	*/
 /*
  * Copyright (C) Caldera International Inc.  2001-2002.
  * All rights reserved.
@@ -185,7 +185,6 @@ static int	cvs_diff_pre_exec(struct cvsroot *);
 static int	cvs_diff_cleanup(void);
 #endif
 
-static void	 diff_output(const char *, ...);
 static void	 output(const char *, FILE *, const char *, FILE *);
 static void	 check(FILE *, FILE *);
 static void	 range(int, int, char *);
@@ -250,7 +249,7 @@ static struct context_vec *context_vec_ptr;
 static char lastbuf[FUNCTION_CONTEXT_SIZE];
 static int  lastline;
 static int  lastmatchline;
-static BUF  *diffbuf = NULL;
+BUF  *diffbuf = NULL;
 
 /*
  * chrtran points to one of 2 translation tables: cup2low if folding upper to
@@ -1794,7 +1793,7 @@ dump_unified_vec(FILE *f1, FILE *f2)
 	context_vec_ptr = context_vec_start - 1;
 }
 
-static void
+void
 diff_output(const char *fmt, ...)
 {
 	va_list vap;
diff --git a/usr.bin/cvs/diff.h b/usr.bin/cvs/diff.h
index 41fc542a2ca..cd261370da4 100644
--- a/usr.bin/cvs/diff.h
+++ b/usr.bin/cvs/diff.h
@@ -1,4 +1,4 @@
-/*	$OpenBSD: diff.h,v 1.3 2005/10/11 14:27:27 joris Exp $	*/
+/*	$OpenBSD: diff.h,v 1.4 2005/10/22 17:32:57 joris Exp $	*/
 /*
  * Copyright (C) Caldera International Inc.  2001-2002.
  * All rights reserved.
@@ -93,8 +93,13 @@
 #define	D_SKIPPED2	9	/* path2 was a special file */
 
 
-
+BUF		*cvs_diff3(RCSFILE *, char *, RCSNUM *, RCSNUM *);
+void		diff_output(const char *, ...);
 int		cvs_diffreg(const char *, const char *, BUF *out);
+int		ed_patch_lines(struct cvs_lines *, struct cvs_lines *);
+
 extern int      diff_format;
 extern char	*diff_file;
+extern BUF	*diffbuf;
+
 #endif
diff --git a/usr.bin/cvs/diff3.c b/usr.bin/cvs/diff3.c
new file mode 100644
index 00000000000..645be253d2e
--- /dev/null
+++ b/usr.bin/cvs/diff3.c
@@ -0,0 +1,808 @@
+/*	$OpenBSD: diff3.c,v 1.1 2005/10/22 17:32:57 joris Exp $	*/
+
+/*
+ * Copyright (C) Caldera International Inc.  2001-2002.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code and documentation must retain the above
+ *    copyright notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed or owned by Caldera
+ *	International, Inc.
+ * 4. Neither the name of Caldera International, Inc. nor the names of other
+ *    contributors may be used to endorse or promote products derived from
+ *    this software without specific prior written permission.
+ *
+ * USE OF THE SOFTWARE PROVIDED FOR UNDER THIS LICENSE BY CALDERA
+ * INTERNATIONAL, INC. AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL CALDERA INTERNATIONAL, INC. BE LIABLE FOR ANY DIRECT,
+ * INDIRECT INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+/*-
+ * Copyright (c) 1991, 1993
+ *	The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *	@(#)diff3.c	8.1 (Berkeley) 6/6/93
+ */
+
+#ifndef lint
+static const char copyright[] =
+"@(#) Copyright (c) 1991, 1993\n\
+	The Regents of the University of California.  All rights reserved.\n";
+#endif /* not lint */
+
+#ifndef lint
+static const char rcsid[] = "$OpenBSD: diff3.c,v 1.1 2005/10/22 17:32:57 joris Exp $";
+#endif /* not lint */
+
+#include <sys/queue.h>
+
+#include <err.h>
+#include <ctype.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "cvs.h"
+#include "log.h"
+#include "diff.h"
+
+/* diff3 - 3-way differential file comparison */
+
+/* diff3 [-ex3EX] d13 d23 f1 f2 f3 [m1 m3]
+ *
+ * d13 = diff report on f1 vs f3
+ * d23 = diff report on f2 vs f3
+ * f1, f2, f3 the 3 files
+ * if changes in f1 overlap with changes in f3, m1 and m3 are used
+ * to mark the overlaps; otherwise, the file names f1 and f3 are used
+ * (only for options E and X).
+ */
+
+/*
+ * "from" is first in range of changed lines; "to" is last+1
+ * from=to=line after point of insertion for added lines.
+ */
+struct range {
+	int from;
+	int to;
+};
+
+struct diff {
+	struct range old;
+	struct range new;
+};
+
+static size_t szchanges;
+
+static struct diff *d13;
+static struct diff *d23;
+
+/*
+ * "de" is used to gather editing scripts.  These are later spewed out in
+ * reverse order.  Its first element must be all zero, the "new" component
+ * of "de" contains line positions or byte positions depending on when you
+ * look (!?).  Array overlap indicates which sections in "de" correspond to
+ * lines that are different in all three files.
+ */
+static struct diff *de;
+static char *overlap;
+static int overlapcnt;
+static FILE *fp[3];
+static int cline[3];		/* # of the last-read line in each file (0-2) */
+
+/*
+ * the latest known correspondence between line numbers of the 3 files
+ * is stored in last[1-3];
+ */
+static int last[4];
+static int eflag;
+static int oflag;		/* indicates whether to mark overlaps (-E or -X)*/
+static int debug  = 0;
+static char f1mark[40], f3mark[40];	/* markers for -E and -X */
+
+static int duplicate(struct range *, struct range *);
+static int edit(struct diff *, int, int);
+static char *getchange(FILE *);
+static char *getline(FILE *, size_t *);
+static int number(char **);
+static int readin(char *, struct diff **);
+static int skip(int, int, char *);
+static int edscript(int);
+static int merge(int, int);
+static void change(int, struct range *, int);
+static void keep(int, struct range *);
+static void prange(struct range *);
+static void repos(int);
+static void separate(const char *);
+static void increase(void);
+static int diff3_internal(int, char **, const char *, const char *);
+
+BUF *
+cvs_diff3(RCSFILE *rf, char *workfile, RCSNUM *rev1, RCSNUM *rev2)
+{
+	int ret, argc;
+	char *data, *patch;
+	char *argv[5], r1[16], r2[16];
+	char path1[MAXPATHLEN], path2[MAXPATHLEN], path3[MAXPATHLEN];
+	char dp13[MAXPATHLEN], dp23[MAXPATHLEN];
+	BUF *b1, *b2, *b3, *d1, *d2, *diffb;
+
+	ret = -1;
+	b1 = b2 = b3 = d1 = d2 = diffb = NULL;
+
+	rcsnum_tostr(rev1, r1, sizeof(r1));
+	rcsnum_tostr(rev2, r2, sizeof(r2));
+
+	cvs_printf("merging changes between '%s' and '%s'", r1, r2);
+	cvs_printf(" into '%s'\n", workfile);
+
+	if ((b1 = cvs_buf_load(workfile, BUF_AUTOEXT)) == NULL)
+		goto out;
+
+	if ((b2 = rcs_getrev(rf, rev1)) == NULL)
+		goto out;
+
+	if ((b3 = rcs_getrev(rf, rev2)) == NULL)
+		goto out;
+
+	if ((d1 = cvs_buf_alloc(128, BUF_AUTOEXT)) == NULL)
+		goto out;
+
+	if ((d2 = cvs_buf_alloc(128, BUF_AUTOEXT)) == NULL)
+		goto out;
+
+	if ((diffb = cvs_buf_alloc(128, BUF_AUTOEXT)) == NULL)
+		goto out;
+
+	strlcpy(path1, "/tmp/diff1.XXXXXXXXXX", sizeof(path1));
+	if (cvs_buf_write_stmp(b1, path1, 0600) == -1)
+		goto out;
+
+	strlcpy(path2, "/tmp/diff2.XXXXXXXXXX", sizeof(path2));
+	if (cvs_buf_write_stmp(b2, path2, 0600) == -1)
+		goto out;
+
+	strlcpy(path3, "/tmp/diff3.XXXXXXXXXX", sizeof(path3));
+	if (cvs_buf_write_stmp(b3, path3, 0600) == -1)
+		goto out;
+
+	cvs_buf_free(b2);
+	b2 = NULL;
+
+	cvs_diffreg(path1, path3, d1);
+	cvs_diffreg(path2, path3, d2);
+
+	strlcpy(dp13, "/tmp/d13.XXXXXXXXXX", sizeof(dp13));
+	if (cvs_buf_write_stmp(d1, dp13, 0600) < 0)
+		goto out;
+
+	cvs_buf_free(d1);
+	d1 = NULL;
+
+	strlcpy(dp23, "/tmp/d23.XXXXXXXXXX", sizeof(dp23));
+	if (cvs_buf_write_stmp(d2, dp23, 0600) < 0)
+		goto out;
+
+	cvs_buf_free(d2);
+	d2 = NULL;
+
+	argc = 0;
+	diffbuf = diffb;
+	argv[argc++] = dp13;
+	argv[argc++] = dp23;
+	argv[argc++] = path1;
+	argv[argc++] = path2;
+	argv[argc++] = path3;
+	if ((ret = diff3_internal(argc, argv, workfile, r2)) < 0)
+		goto out;
+
+	if (cvs_buf_putc(diffb, '\0') < 0) {
+		cvs_buf_free(diffb);
+		goto out;
+	}
+
+	if (cvs_buf_putc(b1, '\0') < 0) {
+		cvs_buf_free(diffb);
+		goto out;
+	}
+
+	patch = cvs_buf_release(diffb);
+	data = cvs_buf_release(b1);
+	diffb = b1 = NULL;
+
+	if ((diffb = cvs_patchfile(data, patch, ed_patch_lines)) == NULL)
+		goto out;
+
+	free(data);
+	free(patch);
+
+out:
+	if (b1 != NULL)
+		cvs_buf_free(b1);
+	if (b2 != NULL)
+		cvs_buf_free(b2);
+	if (b3 != NULL)
+		cvs_buf_free(b3);
+	if (d1 != NULL)
+		cvs_buf_free(d1);
+	if (d2 != NULL)
+		cvs_buf_free(d2);
+
+	(void)unlink(path1);
+	(void)unlink(path2);
+	(void)unlink(path3);
+	(void)unlink(dp13);
+	(void)unlink(dp23);
+
+	return (diffb);
+}
+
+static int
+diff3_internal(int argc, char **argv, const char *fmark, const char *rmark)
+{
+	int i, m, n;
+
+	/* XXX */
+	eflag = 3;
+	oflag = 1;
+
+	if (argc < 5)
+		return (-1);
+
+	snprintf(f1mark, sizeof(f1mark), "<<<<<<< %s", fmark);
+	snprintf(f3mark, sizeof(f3mark), ">>>>>>> %s", rmark);
+
+	increase();
+	m = readin(argv[0], &d13);
+	n = readin(argv[1], &d23);
+
+	for (i = 0; i <= 2; i++) {
+		if ((fp[i] = fopen(argv[i + 2], "r")) == NULL) {
+			cvs_log(LP_ERRNO, "%s", argv[i + 2]);
+			return (-1);
+		}
+	}
+
+	return (merge(m, n));
+}
+
+int
+ed_patch_lines(struct cvs_lines *dlines, struct cvs_lines *plines)
+{
+	char op, *ep;
+	struct cvs_line *sort, *lp, *dlp, *ndlp;
+	int start, end, busy, i, lineno;
+
+	dlp = TAILQ_FIRST(&(dlines->l_lines));
+	lp = TAILQ_FIRST(&(plines->l_lines));
+
+	busy = 0;
+	for (lp = TAILQ_NEXT(lp, l_list); lp != NULL;
+	    lp = TAILQ_NEXT(lp, l_list)) {
+		op = lp->l_line[strlen(lp->l_line) - 1];
+		start = (int)strtol(lp->l_line, &ep, 10);
+		if (op == 'a') {
+			if ((start > dlines->l_nblines) ||
+			    (start < 0) || (*ep != 'a'))
+				return (-1);
+		} else if (op == 'c') {
+			if ((start > dlines->l_nblines) ||
+			    (start < 0) || (*ep != ','))
+				return (-1);
+
+			ep++;
+			end = (int)strtol(ep, &ep, 10);
+			if ((end < 0) || (*ep != 'c'))
+				return (-1);
+		}
+
+		for (;;) {
+			if (dlp == NULL)
+				break;
+			if (dlp->l_lineno == start)
+				break;
+			if (dlp->l_lineno > start) {
+				dlp = TAILQ_PREV(dlp, cvs_tqh, l_list);
+			} else if (dlp->l_lineno < start) {
+				ndlp = TAILQ_NEXT(dlp, l_list);
+				if (ndlp->l_lineno > start)
+					break;
+				dlp = ndlp;
+			}
+		}
+
+		if (dlp == NULL)
+			return (-1);
+
+		if (op == 'c') {
+			for (i = start; i <= end; i++) {
+				ndlp = TAILQ_NEXT(dlp, l_list);
+				TAILQ_REMOVE(&(dlines->l_lines), dlp, l_list);
+				dlp = ndlp;
+			}
+		}
+
+		if (op == 'a' || op == 'c') {
+			for (;;) {
+				ndlp = lp;
+				lp = TAILQ_NEXT(lp, l_list);
+				if (lp == NULL)
+					return (-1);
+
+				if (!strcmp(lp->l_line, "."))
+					break;
+
+				TAILQ_REMOVE(&(plines->l_lines), lp, l_list);
+				TAILQ_INSERT_AFTER(&(dlines->l_lines), dlp,
+				    lp, l_list);
+				dlp = lp;
+
+				lp->l_lineno = start;
+				lp = ndlp;
+			}
+		}
+
+		/*
+		 * always resort lines as the markers might be put at the
+		 * same line as we first started editing.
+		 */
+		lineno = 0;
+		TAILQ_FOREACH(sort, &(dlines->l_lines), l_list)
+			sort->l_lineno = lineno++;
+		dlines->l_nblines = lineno - 1;
+	}
+
+	return (0);
+}
+
+/*
+ * Pick up the line numbers of all changes from one change file.
+ * (This puts the numbers in a vector, which is not strictly necessary,
+ * since the vector is processed in one sequential pass.
+ * The vector could be optimized out of existence)
+ */
+static int
+readin(char *name, struct diff **dd)
+{
+	int a, b, c, d;
+	char kind, *p;
+	size_t i;
+
+	fp[0] = fopen(name, "r");
+	for (i = 0; (p = getchange(fp[0])); i++) {
+		if (i >= szchanges - 1)
+			increase();
+		a = b = number(&p);
+		if (*p == ',') {
+			p++;
+			b = number(&p);
+		}
+		kind = *p++;
+		c = d = number(&p);
+		if (*p==',') {
+			p++;
+			d = number(&p);
+		}
+		if (kind == 'a')
+			a++;
+		if (kind == 'd')
+			c++;
+		b++;
+		d++;
+		(*dd)[i].old.from = a;
+		(*dd)[i].old.to = b;
+		(*dd)[i].new.from = c;
+		(*dd)[i].new.to = d;
+	}
+
+	(*dd)[i].old.from = (*dd)[i-1].old.to;
+	(*dd)[i].new.from = (*dd)[i-1].new.to;
+	(void)fclose(fp[0]);
+
+	return (i);
+}
+
+static int
+number(char **lc)
+{
+	int nn;
+
+	nn = 0;
+	while (isdigit((unsigned char)(**lc)))
+		nn = nn*10 + *(*lc)++ - '0';
+
+	return (nn);
+}
+
+static char *
+getchange(FILE *b)
+{
+	char *line;
+
+	while ((line = getline(b, NULL))) {
+		if (isdigit((unsigned char)line[0]))
+			return (line);
+	}
+
+	return (NULL);
+}
+
+static char *
+getline(FILE *b, size_t *n)
+{
+	char *cp;
+	size_t len;
+	static char *buf;
+	static size_t bufsize;
+
+	if ((cp = fgetln(b, &len)) == NULL)
+		return (NULL);
+
+	if (cp[len - 1] != '\n')
+		len++;
+	if (len + 1 > bufsize) {
+		do {
+			bufsize += 1024;
+		} while (len + 1 > bufsize);
+		if ((buf = realloc(buf, bufsize)) == NULL)
+			err(EXIT_FAILURE, NULL);
+	}
+	memcpy(buf, cp, len - 1);
+	buf[len - 1] = '\n';
+	buf[len] = '\0';
+	if (n != NULL)
+		*n = len;
+
+	return (buf);
+}
+
+static int
+merge(int m1, int m2)
+{
+	struct diff *d1, *d2, *d3;
+	int dpl, j, t1, t2;
+
+	d1 = d13;
+	d2 = d23;
+	j = 0;
+	while ((t1 = d1 < d13 + m1) | (t2 = d2 < d23 + m2)) {
+		if (debug) {
+			printf("%d,%d=%d,%d %d,%d=%d,%d\n",
+			d1->old.from,d1->old.to,
+			d1->new.from,d1->new.to,
+			d2->old.from,d2->old.to,
+			d2->new.from,d2->new.to);
+		}
+
+		/* first file is different from others */
+		if (!t2 || (t1 && d1->new.to < d2->new.from)) {
+			/* stuff peculiar to 1st file */
+			if (eflag==0) {
+				separate("1");
+				change(1, &d1->old, 0);
+				keep(2, &d1->new);
+				change(3, &d1->new, 0);
+			}
+			d1++;
+			continue;
+		}
+
+		/* second file is different from others */
+		if (!t1 || (t2 && d2->new.to < d1->new.from)) {
+			if (eflag==0) {
+				separate("2");
+				keep(1, &d2->new);
+				change(2, &d2->old, 0);
+				change(3, &d2->new, 0);
+			}
+			d2++;
+			continue;
+		}
+
+		/*
+		 * Merge overlapping changes in first file
+		 * this happens after extension (see below).
+		 */
+		if (d1 + 1 < d13 + m1 && d1->new.to >= d1[1].new.from) {
+			d1[1].old.from = d1->old.from;
+			d1[1].new.from = d1->new.from;
+			d1++;
+			continue;
+		}
+
+		/* merge overlapping changes in second */
+		if (d2 + 1 < d23 + m2 && d2->new.to >= d2[1].new.from) {
+			d2[1].old.from = d2->old.from;
+			d2[1].new.from = d2->new.from;
+			d2++;
+			continue;
+		}
+		/* stuff peculiar to third file or different in all */
+		if (d1->new.from == d2->new.from && d1->new.to == d2->new.to) {
+			dpl = duplicate(&d1->old,&d2->old);
+			if (dpl == -1)
+				return (-1);
+
+			/*
+			 * dpl = 0 means all files differ
+			 * dpl = 1 means files 1 and 2 identical
+			 */
+			if (eflag==0) {
+				separate(dpl ? "3" : "");
+				change(1, &d1->old, dpl);
+				change(2, &d2->old, 0);
+				d3 = d1->old.to > d1->old.from ? d1 : d2;
+				change(3, &d3->new, 0);
+			} else
+				j = edit(d1, dpl, j);
+			d1++;
+			d2++;
+			continue;
+		}
+
+		/*
+		 * Overlapping changes from file 1 and 2; extend changes
+		 * appropriately to make them coincide.
+		 */
+		if (d1->new.from < d2->new.from) {
+			d2->old.from -= d2->new.from-d1->new.from;
+			d2->new.from = d1->new.from;
+		} else if (d2->new.from < d1->new.from) {
+			d1->old.from -= d1->new.from-d2->new.from;
+			d1->new.from = d2->new.from;
+		}
+		if (d1->new.to > d2->new.to) {
+			d2->old.to += d1->new.to - d2->new.to;
+			d2->new.to = d1->new.to;
+		} else if (d2->new.to > d1->new.to) {
+			d1->old.to += d2->new.to - d1->new.to;
+			d1->new.to = d2->new.to;
+		}
+	}
+
+	return (edscript(j));
+}
+
+static void
+separate(const char *s)
+{
+	diff_output("====%s\n", s);
+}
+
+/*
+ * The range of lines rold.from thru rold.to in file i is to be changed.
+ * It is to be printed only if it does not duplicate something to be
+ * printed later.
+ */
+static void
+change(int i, struct range *rold, int fdup)
+{
+	diff_output("%d:", i);
+	last[i] = rold->to;
+	prange(rold);
+	if (fdup || debug)
+		return;
+	i--;
+	(void)skip(i, rold->from, NULL);
+	(void)skip(i, rold->to, "  ");
+}
+
+/*
+ * print the range of line numbers, rold.from thru rold.to, as n1,n2 or n1
+ */
+static void
+prange(struct range *rold)
+{
+	if (rold->to <= rold->from)
+		diff_output("%da\n", rold->from - 1);
+	else {
+		diff_output("%d", rold->from);
+		if (rold->to > rold->from+1)
+			diff_output(",%d", rold->to - 1);
+		diff_output("c\n");
+	}
+}
+
+/*
+ * No difference was reported by diff between file 1 (or 2) and file 3,
+ * and an artificial dummy difference (trange) must be ginned up to
+ * correspond to the change reported in the other file.
+ */
+static void
+keep(int i, struct range *rnew)
+{
+	int delta;
+	struct range trange;
+
+	delta = last[3] - last[i];
+	trange.from = rnew->from - delta;
+	trange.to = rnew->to - delta;
+	change(i, &trange, 1);
+}
+
+/*
+ * skip to just before line number from in file "i".  If "pr" is non-NULL,
+ * print all skipped stuff with string pr as a prefix.
+ */
+static int
+skip(int i, int from, char *pr)
+{
+	size_t j, n;
+	char *line;
+
+	for (n = 0; cline[i] < from - 1; n += j) {
+		if ((line = getline(fp[i], &j)) == NULL)
+			return (-1);
+		if (pr != NULL)
+			diff_output("%s%s", pr, line);
+		cline[i]++;
+	}
+	return ((int) n);
+}
+
+/*
+ * Return 1 or 0 according as the old range (in file 1) contains exactly
+ * the same data as the new range (in file 2).
+ */
+static int
+duplicate(struct range *r1, struct range *r2)
+{
+	int c,d;
+	int nchar;
+	int nline;
+
+	if (r1->to-r1->from != r2->to-r2->from)
+		return (0);
+	(void)skip(0, r1->from, NULL);
+	(void)skip(1, r2->from, NULL);
+	nchar = 0;
+	for (nline=0; nline < r1->to - r1->from; nline++) {
+		do {
+			c = getc(fp[0]);
+			d = getc(fp[1]);
+			if (c == -1 || d== -1)
+				return (-1);
+			nchar++;
+			if (c != d) {
+				repos(nchar);
+				return (0);
+			}
+		} while (c != '\n');
+	}
+	repos(nchar);
+	return (1);
+}
+
+static void
+repos(int nchar)
+{
+	int i;
+
+	for (i = 0; i < 2; i++)
+		(void)fseek(fp[i], (long)-nchar, 1);
+}
+
+/*
+ * collect an editing script for later regurgitation
+ */
+static int
+edit(struct diff *diff, int fdup, int j)
+{
+	if (((fdup + 1) & eflag) == 0)
+		return (j);
+	j++;
+	overlap[j] = !fdup;
+	if (!fdup)
+		overlapcnt++;
+	de[j].old.from = diff->old.from;
+	de[j].old.to = diff->old.to;
+	de[j].new.from = de[j-1].new.to + skip(2, diff->new.from, NULL);
+	de[j].new.to = de[j].new.from + skip(2, diff->new.to, NULL);
+	return (j);
+}
+
+/* regurgitate */
+static int
+edscript(int n)
+{
+	int j, k;
+	char block[BUFSIZ];
+
+	for (n = n; n > 0; n--) {
+		if (!oflag || !overlap[n])
+			prange(&de[n].old);
+		else
+			diff_output("%da\n=======\n", de[n].old.to -1);
+		(void)fseek(fp[2], (long)de[n].new.from, 0);
+		for (k = de[n].new.to-de[n].new.from; k > 0; k-= j) {
+			j = k > BUFSIZ ? BUFSIZ : k;
+			if (fread(block, 1, j, fp[2]) != (size_t)j)
+				return (-1);
+			block[j] = '\0';
+			diff_output("%s", block);
+		}
+		if (!oflag || !overlap[n])
+			diff_output(".\n");
+		else {
+			diff_output("%s\n.\n", f3mark);
+			diff_output("%da\n%s\n.\n", de[n].old.from - 1, f1mark);
+		}
+	}
+
+	return (overlapcnt);
+}
+
+static void
+increase(void)
+{
+	struct diff *p;
+	char *q;
+	size_t newsz, incr;
+
+	/* are the memset(3) calls needed? */
+	newsz = szchanges == 0 ? 64 : 2 * szchanges;
+	incr = newsz - szchanges;
+
+	p = realloc(d13, newsz * sizeof(struct diff));
+	if (p == NULL)
+		err(1, NULL);
+	memset(p + szchanges, 0, incr * sizeof(struct diff));
+	d13 = p;
+	p = realloc(d23, newsz * sizeof(struct diff));
+	if (p == NULL)
+		err(1, NULL);
+	memset(p + szchanges, 0, incr * sizeof(struct diff));
+	d23 = p;
+	p = realloc(de, newsz * sizeof(struct diff));
+	if (p == NULL)
+		err(1, NULL);
+	memset(p + szchanges, 0, incr * sizeof(struct diff));
+	de = p;
+	q = realloc(overlap, newsz * sizeof(char));
+	if (q == NULL)
+		err(1, NULL);
+	memset(q + szchanges, 0, incr * sizeof(char));
+	overlap = q;
+	szchanges = newsz;
+}
diff --git a/usr.bin/cvs/rcs.c b/usr.bin/cvs/rcs.c
index b9c6d59c078..b801a316539 100644
--- a/usr.bin/cvs/rcs.c
+++ b/usr.bin/cvs/rcs.c
@@ -1,4 +1,4 @@
-/*	$OpenBSD: rcs.c,v 1.93 2005/10/22 17:23:21 joris Exp $	*/
+/*	$OpenBSD: rcs.c,v 1.94 2005/10/22 17:32:57 joris Exp $	*/
 /*
  * Copyright (c) 2004 Jean-Francois Brousseau <jfb@openbsd.org>
  * All rights reserved.
@@ -38,6 +38,7 @@
 #include <string.h>
 #include <unistd.h>
 
+#include "cvs.h"
 #include "log.h"
 #include "rcs.h"
 #include "diff.h"
@@ -98,24 +99,10 @@ struct rcs_pdata {
 };
 
 
-struct rcs_line {
-	char			*rl_line;
-	int			 rl_lineno;
-	TAILQ_ENTRY(rcs_line)	 rl_list;
-};
-TAILQ_HEAD(rcs_tqh, rcs_line);
-
-struct rcs_foo {
-	int		 rl_nblines;
-	char		*rl_data;
-	struct rcs_tqh	 rl_lines;
-};
-
 #define RCS_TOKSTR(rfp)	((struct rcs_pdata *)rfp->rf_pdata)->rp_buf
 #define RCS_TOKLEN(rfp)	((struct rcs_pdata *)rfp->rf_pdata)->rp_tlen
 
 
-
 /* invalid characters in RCS symbol names */
 static const char rcs_sym_invch[] = RCS_SYM_INVALCHAR;
 
@@ -297,14 +284,11 @@ static void	rcs_freepdata(struct rcs_pdata *);
 static int	rcs_gettok(RCSFILE *);
 static int	rcs_pushtok(RCSFILE *, const char *, int);
 static int	rcs_growbuf(RCSFILE *);
-static int	rcs_patch_lines(struct rcs_foo *, struct rcs_foo *);
 static int	rcs_strprint(const u_char *, size_t, FILE *);
 
 static int	rcs_expand_keywords(char *, struct rcs_delta *, char *, char *,
 		    size_t, int);
 static struct rcs_delta	*rcs_findrev(RCSFILE *, const RCSNUM *);
-static struct rcs_foo	*rcs_splitlines(const char *);
-static void		 rcs_freefoo(struct rcs_foo *);
 
 /*
  * rcs_open()
@@ -1168,76 +1152,22 @@ rcs_tag_resolve(RCSFILE *file, const char *tag)
 	return (num);
 }
 
-
-/*
- * rcs_patch()
- *
- * Apply an RCS-format patch pointed to by <patch> to the file contents
- * found in <data>.
- * Returns 0 on success, or -1 on failure.
- */
-BUF*
-rcs_patch(const char *data, const char *patch)
-{
-	struct rcs_foo *dlines, *plines;
-	struct rcs_line *lp;
-	size_t len;
-	int lineno;
-	BUF *res;
-
-	len = strlen(data);
-	res = cvs_buf_alloc(len, BUF_AUTOEXT);
-	if (res == NULL)
-		return (NULL);
-
-	dlines = rcs_splitlines(data);
-	if (dlines == NULL) {
-		cvs_buf_free(res);
-		return (NULL);
-	}
-
-	plines = rcs_splitlines(patch);
-	if (plines == NULL) {
-		cvs_buf_free(res);
-		rcs_freefoo(dlines);
-		return (NULL);
-	}
-
-	if (rcs_patch_lines(dlines, plines) < 0) {
-		cvs_buf_free(res);
-		rcs_freefoo(plines);
-		rcs_freefoo(dlines);
-		return (NULL);
-	}
-
-	lineno = 0;
-	TAILQ_FOREACH(lp, &dlines->rl_lines, rl_list) {
-		if (lineno != 0)
-			cvs_buf_fappend(res, "%s\n", lp->rl_line);
-		lineno++;
-	}
-
-	rcs_freefoo(dlines);
-	rcs_freefoo(plines);
-	return (res);
-}
-
-static int
-rcs_patch_lines(struct rcs_foo *dlines, struct rcs_foo *plines)
+int
+rcs_patch_lines(struct cvs_lines *dlines, struct cvs_lines *plines)
 {
 	char op, *ep;
-	struct rcs_line *lp, *dlp, *ndlp;
+	struct cvs_line *lp, *dlp, *ndlp;
 	int i, lineno, nbln;
 
-	dlp = TAILQ_FIRST(&(dlines->rl_lines));
-	lp = TAILQ_FIRST(&(plines->rl_lines));
+	dlp = TAILQ_FIRST(&(dlines->l_lines));
+	lp = TAILQ_FIRST(&(plines->l_lines));
 
 	/* skip first bogus line */
-	for (lp = TAILQ_NEXT(lp, rl_list); lp != NULL;
-	    lp = TAILQ_NEXT(lp, rl_list)) {
-		op = *(lp->rl_line);
-		lineno = (int)strtol((lp->rl_line + 1), &ep, 10);
-		if ((lineno > dlines->rl_nblines) || (lineno < 0) ||
+	for (lp = TAILQ_NEXT(lp, l_list); lp != NULL;
+	    lp = TAILQ_NEXT(lp, l_list)) {
+		op = *(lp->l_line);
+		lineno = (int)strtol((lp->l_line + 1), &ep, 10);
+		if ((lineno > dlines->l_nblines) || (lineno < 0) ||
 		    (*ep != ' ')) {
 			cvs_log(LP_ERR,
 			    "invalid line specification in RCS patch");
@@ -1255,13 +1185,13 @@ rcs_patch_lines(struct rcs_foo *dlines, struct rcs_foo *plines)
 		for (;;) {
 			if (dlp == NULL)
 				break;
-			if (dlp->rl_lineno == lineno)
+			if (dlp->l_lineno == lineno)
 				break;
-			if (dlp->rl_lineno > lineno) {
-				dlp = TAILQ_PREV(dlp, rcs_tqh, rl_list);
-			} else if (dlp->rl_lineno < lineno) {
-				ndlp = TAILQ_NEXT(dlp, rl_list);
-				if (ndlp->rl_lineno > lineno)
+			if (dlp->l_lineno > lineno) {
+				dlp = TAILQ_PREV(dlp, cvs_tqh, l_list);
+			} else if (dlp->l_lineno < lineno) {
+				ndlp = TAILQ_NEXT(dlp, l_list);
+				if (ndlp->l_lineno > lineno)
 					break;
 				dlp = ndlp;
 			}
@@ -1274,25 +1204,25 @@ rcs_patch_lines(struct rcs_foo *dlines, struct rcs_foo *plines)
 
 		if (op == 'd') {
 			for (i = 0; (i < nbln) && (dlp != NULL); i++) {
-				ndlp = TAILQ_NEXT(dlp, rl_list);
-				TAILQ_REMOVE(&(dlines->rl_lines), dlp, rl_list);
+				ndlp = TAILQ_NEXT(dlp, l_list);
+				TAILQ_REMOVE(&(dlines->l_lines), dlp, l_list);
 				dlp = ndlp;
 			}
 		} else if (op == 'a') {
 			for (i = 0; i < nbln; i++) {
 				ndlp = lp;
-				lp = TAILQ_NEXT(lp, rl_list);
+				lp = TAILQ_NEXT(lp, l_list);
 				if (lp == NULL) {
 					cvs_log(LP_ERR, "truncated RCS patch");
 					return (-1);
 				}
-				TAILQ_REMOVE(&(plines->rl_lines), lp, rl_list);
-				TAILQ_INSERT_AFTER(&(dlines->rl_lines), dlp,
-				    lp, rl_list);
+				TAILQ_REMOVE(&(plines->l_lines), lp, l_list);
+				TAILQ_INSERT_AFTER(&(dlines->l_lines), dlp,
+				    lp, l_list);
 				dlp = lp;
 
 				/* we don't want lookup to block on those */
-				lp->rl_lineno = lineno;
+				lp->l_lineno = lineno;
 
 				lp = ndlp;
 			}
@@ -1302,15 +1232,15 @@ rcs_patch_lines(struct rcs_foo *dlines, struct rcs_foo *plines)
 		}
 
 		/* last line of the patch, done */
-		if (lp->rl_lineno == plines->rl_nblines)
+		if (lp->l_lineno == plines->l_nblines)
 			break;
 	}
 
 	/* once we're done patching, rebuild the line numbers */
 	lineno = 0;
-	TAILQ_FOREACH(lp, &(dlines->rl_lines), rl_list)
-		lp->rl_lineno = lineno++;
-	dlines->rl_nblines = lineno - 1;
+	TAILQ_FOREACH(lp, &(dlines->l_lines), l_list)
+		lp->l_lineno = lineno++;
+	dlines->l_nblines = lineno - 1;
 
 	return (0);
 }
@@ -1331,8 +1261,8 @@ rcs_getrev(RCSFILE *rfp, RCSNUM *frev)
 	RCSNUM *crev, *rev;
 	BUF *rbuf, *dbuf = NULL;
 	struct rcs_delta *rdp = NULL;
-	struct rcs_foo *lines;
-	struct rcs_line *lp;
+	struct cvs_lines *lines;
+	struct cvs_line *lp;
 	char out[1024];				/* XXX */
 
 	if (rfp->rf_head == NULL)
@@ -1378,7 +1308,8 @@ rcs_getrev(RCSFILE *rfp, RCSNUM *frev)
 				return (NULL);
 			}
 			bp = cvs_buf_release(rbuf);
-			rbuf = rcs_patch((char *)bp, (char *)rdp->rd_text);
+			rbuf = cvs_patchfile((char *)bp, (char *)rdp->rd_text,
+			    rcs_patch_lines);
 			free(bp);
 			if (rbuf == NULL)
 				break;
@@ -1405,16 +1336,16 @@ rcs_getrev(RCSFILE *rfp, RCSNUM *frev)
 		}
 
 		bp = cvs_buf_release(rbuf);
-		if ((lines = rcs_splitlines((char *)bp)) != NULL) {
+		if ((lines = cvs_splitlines((char *)bp)) != NULL) {
 			res = 0;
-			TAILQ_FOREACH(lp, &lines->rl_lines, rl_list) {
+			TAILQ_FOREACH(lp, &lines->l_lines, l_list) {
 				if (res++ == 0)
 					continue;
 				rcs_expand_keywords(rfp->rf_path, rdp,
-				    lp->rl_line, out, sizeof(out), expmode);
+				    lp->l_line, out, sizeof(out), expmode);
 				cvs_buf_fappend(dbuf, "%s\n", out);
 			}
-			rcs_freefoo(lines);
+			cvs_freelines(lines);
 		}
 		free(bp);
 	}
@@ -2689,83 +2620,6 @@ rcs_pushtok(RCSFILE *rfp, const char *tok, int type)
 
 
 /*
- * rcs_splitlines()
- *
- * Split the contents of a file into a list of lines.
- */
-static struct rcs_foo*
-rcs_splitlines(const char *fcont)
-{
-	char *dcp;
-	struct rcs_foo *foo;
-	struct rcs_line *lp;
-
-	foo = (struct rcs_foo *)malloc(sizeof(*foo));
-	if (foo == NULL) {
-		cvs_log(LP_ERR, "failed to allocate line structure");
-		return (NULL);
-	}
-	TAILQ_INIT(&(foo->rl_lines));
-	foo->rl_nblines = 0;
-	foo->rl_data = strdup(fcont);
-	if (foo->rl_data == NULL) {
-		cvs_log(LP_ERRNO, "failed to copy file contents");
-		free(foo);
-		return (NULL);
-	}
-
-	/*
-	 * Add a first bogus line with line number 0.  This is used so we
-	 * can position the line pointer before 1 when changing the first line
-	 * in rcs_patch().
-	 */
-	lp = (struct rcs_line *)malloc(sizeof(*lp));
-	if (lp == NULL) {
-		rcs_freefoo(foo);
-		return (NULL);
-	}
-
-	lp->rl_line = NULL;
-	lp->rl_lineno = 0;
-	TAILQ_INSERT_TAIL(&(foo->rl_lines), lp, rl_list);
-
-
-	for (dcp = foo->rl_data; *dcp != '\0';) {
-		lp = (struct rcs_line *)malloc(sizeof(*lp));
-		if (lp == NULL) {
-			rcs_freefoo(foo);
-			cvs_log(LP_ERR, "failed to allocate line entry");
-			return (NULL);
-		}
-
-		lp->rl_line = dcp;
-		lp->rl_lineno = ++(foo->rl_nblines);
-		TAILQ_INSERT_TAIL(&(foo->rl_lines), lp, rl_list);
-
-		dcp = strchr(dcp, '\n');
-		if (dcp == NULL) {
-			break;
-		}
-		*(dcp++) = '\0';
-	}
-
-	return (foo);
-}
-
-static void
-rcs_freefoo(struct rcs_foo *fp)
-{
-	struct rcs_line *lp;
-
-	while ((lp = TAILQ_FIRST(&fp->rl_lines)) != NULL) {
-		TAILQ_REMOVE(&fp->rl_lines, lp, rl_list);
-		free(lp);
-	}
-	free(fp->rl_data);
-	free(fp);
-}
-
-/*
  * rcs_growbuf()
  *
  * Attempt to grow the internal parse buffer for the RCS file <rf> by
diff --git a/usr.bin/cvs/rcs.h b/usr.bin/cvs/rcs.h
index 8ebf55ba010..326e5bd83b1 100644
--- a/usr.bin/cvs/rcs.h
+++ b/usr.bin/cvs/rcs.h
@@ -1,4 +1,4 @@
-/*	$OpenBSD: rcs.h,v 1.35 2005/10/15 22:56:03 niallo Exp $	*/
+/*	$OpenBSD: rcs.h,v 1.36 2005/10/22 17:32:57 joris Exp $	*/
 /*
  * Copyright (c) 2004 Jean-Francois Brousseau <jfb@openbsd.org>
  * All rights reserved.
@@ -221,8 +221,6 @@ int	rcs_kflag_get(const char *);
 void	rcs_kflag_usage(void);
 int	rcs_kw_expand(RCSFILE *, u_char *, size_t, size_t *);
 
-BUF	*rcs_patch(const char *, const char *);
-
 RCSNUM	*rcsnum_alloc(void);
 RCSNUM	*rcsnum_parse(const char *);
 RCSNUM	*rcsnum_brtorev(const RCSNUM *);
diff --git a/usr.bin/cvs/resp.c b/usr.bin/cvs/resp.c
index 5c3df305d6a..06fabf277ce 100644
--- a/usr.bin/cvs/resp.c
+++ b/usr.bin/cvs/resp.c
@@ -1,4 +1,4 @@
-/*	$OpenBSD: resp.c,v 1.60 2005/10/07 21:47:32 reyk Exp $	*/
+/*	$OpenBSD: resp.c,v 1.61 2005/10/22 17:32:57 joris Exp $	*/
 /*
  * Copyright (c) 2004 Jean-Francois Brousseau <jfb@openbsd.org>
  * All rights reserved.
@@ -838,7 +838,7 @@ cvs_resp_rcsdiff(struct cvsroot *root, int type, char *line)
 	orig = cvs_buf_release(fcont);
 	patch = cvs_buf_release(patchbuf);
 
-	res = rcs_patch(orig, patch);
+	res = cvs_patchfile(orig, patch, rcs_patch_lines);
 	if (res == NULL)
 		return (-1);
 
diff --git a/usr.bin/cvs/util.c b/usr.bin/cvs/util.c
index 4ba6ef57263..edf65d8059d 100644
--- a/usr.bin/cvs/util.c
+++ b/usr.bin/cvs/util.c
@@ -1,4 +1,4 @@
-/*	$OpenBSD: util.c,v 1.53 2005/10/07 21:47:32 reyk Exp $	*/
+/*	$OpenBSD: util.c,v 1.54 2005/10/22 17:32:57 joris Exp $	*/
 /*
  * Copyright (c) 2004 Jean-Francois Brousseau <jfb@openbsd.org>
  * All rights reserved.
@@ -39,6 +39,8 @@
 #include "cvs.h"
 #include "log.h"
 
+#if !defined(RCSPROG)
+
 /* letter -> mode type map */
 static const int cvs_modetypes[26] = {
 	-1, -1, -1, -1, -1, -1,  1, -1, -1, -1, -1, -1, -1,
@@ -914,3 +916,113 @@ cvs_parse_tagfile(char **tagp, char **datep, int *nbp)
 
 	(void)fclose(fp);
 }
+
+#endif	/* !RCSPROG */
+
+/*
+ * Split the contents of a file into a list of lines.
+ */
+struct cvs_lines *
+cvs_splitlines(const char *fcont)
+{
+	char *dcp;
+	struct cvs_lines *lines;
+	struct cvs_line *lp;
+
+	lines = (struct cvs_lines *)malloc(sizeof(*lines));
+	if (lines == NULL)
+		return (NULL);
+
+	TAILQ_INIT(&(lines->l_lines));
+	lines->l_nblines = 0;
+	lines->l_data = strdup(fcont);
+	if (lines->l_data == NULL) {
+		free(lines);
+		return (NULL);
+	}
+
+	lp = (struct cvs_line *)malloc(sizeof(*lp));
+	if (lp == NULL) {
+		cvs_freelines(lines);
+		return (NULL);
+	}
+
+	lp->l_line = NULL;
+	lp->l_lineno = 0;
+	TAILQ_INSERT_TAIL(&(lines->l_lines), lp, l_list);
+
+	for (dcp = lines->l_data; *dcp != '\0';) {
+		lp = (struct cvs_line *)malloc(sizeof(*lp));
+		if (lp == NULL) {
+			cvs_freelines(lines);
+			return (NULL);
+		}
+
+		lp->l_line = dcp;
+		lp->l_lineno = ++(lines->l_nblines);
+		TAILQ_INSERT_TAIL(&(lines->l_lines), lp, l_list);
+
+		dcp = strchr(dcp, '\n');
+		if (dcp == NULL)
+			break;
+		*(dcp++) = '\0';
+	}
+
+	return (lines);
+}
+
+void
+cvs_freelines(struct cvs_lines *lines)
+{
+	struct cvs_line *lp;
+
+	while ((lp = TAILQ_FIRST(&(lines->l_lines))) != NULL) {
+		TAILQ_REMOVE(&(lines->l_lines), lp, l_list);
+		free(lp);
+	}
+
+	free(lines->l_data);
+	free(lines);
+}
+
+BUF *
+cvs_patchfile(const char *data, const char *patch,
+    int (*p)(struct cvs_lines *, struct cvs_lines *))
+{
+	struct cvs_lines *dlines, *plines;
+	struct cvs_line *lp;
+	size_t len;
+	int lineno;
+	BUF *res;
+
+	len = strlen(data);
+
+	if ((dlines = cvs_splitlines(data)) == NULL)
+		return (NULL);
+
+	if ((plines = cvs_splitlines(patch)) == NULL)
+		return (NULL);
+
+	if (p(dlines, plines) < 0) {
+		cvs_freelines(dlines);
+		cvs_freelines(plines);
+		return (NULL);
+	}
+
+	if ((res = cvs_buf_alloc(len, BUF_AUTOEXT)) == NULL) {
+		cvs_freelines(dlines);
+		cvs_freelines(plines);
+		return (NULL);
+	}
+
+	lineno = 0;
+	TAILQ_FOREACH(lp, &dlines->l_lines, l_list) {
+		if (lineno != 0)
+			cvs_buf_fappend(res, "%s\n", lp->l_line);
+		lineno++;
+	}
+
+	cvs_freelines(dlines);
+	cvs_freelines(plines);
+	return (res);
+}