Date: Thu, 09 Aug 2012 17:33:03 +0000 From: jhagewood@FreeBSD.org To: svn-soc-all@FreeBSD.org Subject: socsvn commit: r240217 - soc2012/jhagewood/diff3 Message-ID: <20120809173303.759A0106564A@hub.freebsd.org>
next in thread | raw e-mail | index | archive | help
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); +}
Want to link to this message? Use this URL: <https://mail-archive.FreeBSD.org/cgi/mid.cgi?20120809173303.759A0106564A>