socsvn commit: r240217 - soc2012/jhagewood/diff3
jhagewood at FreeBSD.org
jhagewood at FreeBSD.org
Thu Aug 9 17:33:05 UTC 2012
Author: jhagewood
Date: Thu Aug 9 17:33:03 2012
New Revision: 240217
URL: http://svnweb.FreeBSD.org/socsvn/?view=rev&rev=240217
Log:
diff3prog.c to diff3.c
Added:
soc2012/jhagewood/diff3/diff3.c
- copied unchanged from r240216, soc2012/jhagewood/diff3/diff3prog.c
Deleted:
soc2012/jhagewood/diff3/diff3prog.c
Copied: soc2012/jhagewood/diff3/diff3.c (from r240216, soc2012/jhagewood/diff3/diff3prog.c)
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ soc2012/jhagewood/diff3/diff3.c Thu Aug 9 17:33:03 2012 (r240217, copy of r240216, soc2012/jhagewood/diff3/diff3prog.c)
@@ -0,0 +1,771 @@
+/* $OpenBSD: diff3prog.c,v 1.11 2009/10/27 23:59:37 deraadt 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
+ */
+
+#if 0
+#ifndef lint
+static char sccsid[] = "@(#)diff3.c 8.1 (Berkeley) 6/6/93";
+#endif
+#endif /* not lint */
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD: soc2012/jhagewood/diff3/diff3/diff3prog.c 237773 2012-06-15 18:23:01Z jhagewood $");
+
+#include <ctype.h>
+#include <err.h>
+#include <errno.h>
+#include <getopt.h>
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <wchar.h>
+#include <wctype.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;
+};
+
+size_t szchanges;
+
+struct diff *d13;
+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.
+ */
+struct diff *de;
+char *overlap;
+int overlapcnt;
+FILE *fp[3];
+int cline[3]; /* # of the last-read line in each file (0-2) */
+char *diff_prog = "/usr/bin/diff";
+char *labels[3] = {NULL};
+/*
+ * The latest known correspondence between line numbers of the 3 files
+ * is stored in last[1-3];
+ */
+int last[4];
+int aflag, Aflag, eflag, iflag, mflag, Tflag;
+int oflag; /* indicates whether to mark overlaps (-E or -X)*/
+int strip_cr;
+int debug = 0;
+char f1mark[40], f2mark[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 void change(int, struct range *, int);
+static void keep(int, struct range *);
+static void merge(int, int);
+static int istextfile(FILE *);
+static void prange(struct range *);
+static void repos(int);
+static void separate(const char *);
+static void edscript(int) __dead2;
+static void remove_cr(FILE *);
+static void trouble(void) __dead2;
+static void increase(void);
+static void help(void);
+static void usage(void) __dead2;
+
+enum {
+ HELP_OPT = CHAR_MAX + 1,
+ STRIPCR_OPT,
+ DIFFPROG_OPT,
+};
+
+#define MAX_CHECK 768 /* 3 kilobytes of chars. */
+
+#define OPTIONS "3aAeEiL:mTvxX"
+static struct option longopts[] = {
+ { "ed", no_argument, NULL, 'e' },
+ { "show-overlap", no_argument, NULL, 'E' },
+ { "overlap-only", no_argument, NULL, 'x' },
+ { "initial-tab", no_argument, NULL, 'T' },
+ { "text", no_argument, NULL, 'a' },
+ { "version", no_argument, NULL, 'v' },
+ { "help", no_argument, NULL, HELP_OPT },
+ { "strip-trailing-cr", no_argument, NULL, STRIPCR_OPT },
+
+ /* features to implement */
+ { "show-all", no_argument, NULL, 'A' },
+ { "easy-only", no_argument, NULL, '3' },
+ { "merge", no_argument, NULL, 'm' },
+ { "label", required_argument, NULL, 'L' },
+ { "diff-program", required_argument, NULL, DIFFPROG_OPT },
+
+
+};
+
+int
+main(int argc, char **argv)
+{
+ int ch, i, j, m, n;
+
+ eflag = 0;
+ oflag = 0;
+ while ((ch = getopt_long(argc, argv, OPTIONS, longopts, NULL)) != -1) {
+ switch (ch) {
+ case 'A':
+ Aflag = 1;
+ break;
+ case 'a':
+ aflag = 1;
+ break;
+ case 'E':
+ eflag = 3;
+ oflag = 1;
+ break;
+ case 'e':
+ eflag = 3;
+ break;
+ case 'i':
+ iflag = 1;
+ break;
+ case 'L':
+ oflag = 1;
+ for(i=0; i<3 && labels[i] != NULL; i++);
+ i = i <= 2 ? i : 2 ;
+ labels[i] = optarg;
+ break;
+ case 'm':
+ Aflag = 1;
+ eflag = 0;
+ mflag = 1;
+ break;
+ case 'T':
+ Tflag = 1;
+ break;
+ case 'X':
+ oflag = eflag = 1;
+ break;
+ case 'v':
+ /* To do. */
+ exit(0);
+ case 'x':
+ eflag = 1;
+ break;
+ case '3':
+ eflag = 2;
+ break;
+ case HELP_OPT:
+ help();
+ exit(0);
+ case STRIPCR_OPT:
+ strip_cr = 1;
+ break;
+ case DIFFPROG_OPT:
+ diff_prog = optarg;
+ break;
+ }
+ }
+ argc -= optind;
+ argv += optind;
+ if (argc < 3)
+ usage();
+ if (oflag) {
+ (void)snprintf(f1mark, sizeof(f1mark), "<<<<<<< %s",
+ labels[0] != NULL ? labels[0] :
+ argc >= 6 ? argv[5] : argv[2]);
+ (void)snprintf(f2mark, sizeof(f2mark), "||||||| %s",
+ labels[1] != NULL ? labels[1] :
+ argc >= 6 ? argv[4] : argv[3]);
+ (void)snprintf(f3mark, sizeof(f3mark), ">>>>>>> %s",
+ labels[2] != NULL ? labels[2] :
+ argc >= 7 ? argv[6] : argv[4]);
+ }
+ increase();
+ m = readin(argv[0], &d13);
+ n = readin(argv[1], &d23);
+ j = 0;
+ for (i = 2; i >= 0; i--) {
+ if ((fp[j] = fopen(argv[(argc-1)-i], "r")) == NULL)
+ err(EXIT_FAILURE, "Can't open %s", argv[(argc-1)-i]);
+ if (strip_cr)
+ remove_cr(fp[j]);
+ j++;
+ }
+ merge(m, n);
+ exit(EXIT_SUCCESS);
+}
+
+/*
+ * 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, i;
+ char kind, *p;
+
+ fp[0] = fopen(name, "r");
+ if (fp[0] == NULL)
+ err(EXIT_FAILURE, "Can't open %s", name);
+ 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;
+ }
+ if (i) {
+ (*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 void
+merge(int m1, int m2)
+{
+ struct diff *d1, *d2, *d3;
+ int dup, j, t1, t2;
+
+ d1 = d13;
+ d2 = d23;
+ j = 0;
+
+ if ((istextfile(fp[0]) && istextfile(fp[1]) && istextfile(fp[2])) == 0) {
+ printf("Binary file detected; comparison failed\n");
+ exit(EXIT_FAILURE);
+ }
+ 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) {
+ dup = duplicate(&d1->old,&d2->old);
+ /*
+ * dup = 0 means all files differ
+ * dup = 1 means files 1 and 2 identical
+ */
+ if (eflag == 0) {
+ separate(dup ? "3" : "");
+ change(1, &d1->old, dup);
+ change(2, &d2->old, 0);
+ d3 = d1->old.to > d1->old.from ? d1 : d2;
+ change(3, &d3->new, 0);
+ } else
+ j = edit(d1, dup, 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;
+ }
+ }
+ if (eflag)
+ edscript(j);
+}
+
+static int
+istextfile(FILE *f)
+{
+ int i, check_size;
+ char ch;
+
+ if (aflag || f == NULL)
+ return (1);
+ rewind(f);
+ for (i = 0; i <= MAX_CHECK || ch != EOF; i++) {
+ ch = fgetc(f);
+ if (ch == '\0') {
+ rewind(f);
+ return (0);
+ }
+ }
+ rewind(f);
+ return (1);
+}
+
+static void
+separate(const char *s)
+{
+
+ printf("====%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 dup)
+{
+
+ printf("%d:", i);
+ last[i] = rold->to;
+ prange(rold);
+ if (dup || 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)
+ printf("%da\n", rold->from - 1);
+ else {
+ printf("%d", rold->from);
+ if (rold->to > rold->from+1)
+ printf(",%d", rold->to - 1);
+ printf("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)
+ trouble();
+ if (pr != NULL)
+ printf("%s%s", Tflag == 1? "\t" : 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)
+ trouble();
+ 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, SEEK_CUR);
+}
+
+/* If file has trailing carriage return, remove it. */
+static void
+remove_cr(FILE *f)
+{
+ char ch;
+ fpos_t position;
+ fpos_t tcr_pos;
+
+ while (ch != EOF) {
+ fgetpos(f, &position);
+ ch = fgetc(f);
+ if ((ch == '\r' || ch == '\n') && fgetc(f) == EOF) {
+ tcr_pos = position;
+ break;
+ }
+ }
+ if (&tcr_pos != NULL) {
+ fsetpos(f, &tcr_pos);
+ fputc((int)'\0', f);
+ }
+ rewind(f);
+}
+
+static void
+trouble(void)
+{
+
+ errx(EXIT_FAILURE, "logic error");
+}
+
+/*
+ * collect an editing script for later regurgitation
+ */
+static int
+edit(struct diff *diff, int dup, int j)
+{
+
+ if (((dup + 1) & eflag) == 0)
+ return (j);
+ j++;
+ overlap[j] = !dup;
+ if (!dup)
+ 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 void
+edscript(int n)
+{
+ int j, k;
+ char block[BUFSIZ];
+
+ for (n = n; n > 0; n--) {
+ if (!oflag || !overlap[n])
+ prange(&de[n].old);
+ else
+ printf("%da\n=======\n", de[n].old.to -1);
+ (void)fseek(fp[2], (long)de[n].new.from, SEEK_SET);
+ 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]) != j)
+ trouble();
+ (void)fwrite(block, 1, j, stdout);
+ }
+ if (!oflag || !overlap[n])
+ printf(".\n");
+ else {
+ printf("%s\n.\n", f3mark);
+ printf("%da\n%s\n.\n", de[n].old.from - 1, f1mark);
+ }
+ }
+ if (iflag)
+ printf("w\nq\n");
+
+ exit(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;
+}
+
+static void
+help(void)
+{
+
+ printf("%s",
+ "\t-e --ed Output unmerged changes from OLDFILE to YOURFILE into MYFILE.\n"
+ "\t-A --show-all Output all changes, bracketing conflicts.\n"
+ "\t-x --overlap-only Output overlapping changes.\n"
+ "\t-3 --easy-only Output unmerged nonoverlapping changes.\n\n");
+ printf("%s",
+ "\t-m --merge Output merged file instead of ed script (default -A).\n"
+ "\t-L LABEL --label=LABEL Use LABEL instead of file name.\n"
+ "\t-a --text Treat all files as text.\n"
+ "\t-T --initial-tab Make tabs line up by prepending a tab.\n\n");
+ printf("%s",
+ "\t-v --version Output version info.\n"
+ "\t--help Output this help.\n\n");
+}
+
+static void
+usage(void)
+{
+
+ fprintf(stderr, "usage: diff3 %s file1 file2 file3\n", OPTIONS);
+ exit(EXIT_FAILURE);
+}
More information about the svn-soc-all
mailing list