Subversion Repositories planix.SVN

/* Three way file comparison program (diff3) for Project GNU.

   Copyright (C) 1988, 1989, 1992, 1993, 1994 Free Software Foundation, Inc.

   This program is free software; you can redistribute it and/or modify

   it under the terms of the GNU General Public License as published by

   the Free Software Foundation; either version 2, or (at your option)

   any later version.

   This program is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License

   along with this program; if not, write to the Free Software

   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */

/* Written by Randy Smith */

#include "system.h"

#include <stdio.h>

#include <signal.h>

#include "getopt.h"

extern char const version_string[];

/*

 * Internal data structures and macros for the diff3 program; includes

 * data structures for both diff3 diffs and normal diffs.

 */

/* Different files within a three way diff.  */

#define	FILE0	0

#define	FILE1	1

#define	FILE2	2

/*

 * A three way diff is built from two two-way diffs; the file which

 * the two two-way diffs share is:

 */

#define	FILEC	FILE2

/*

 * Different files within a two way diff.

 * FC is the common file, FO the other file.

 */

#define FO 0

#define FC 1

/* The ranges are indexed by */

#define	START	0

#define	END	1

enum diff_type {

  ERROR,			/* Should not be used */

  ADD,				/* Two way diff add */

  CHANGE,			/* Two way diff change */

  DELETE,			/* Two way diff delete */

  DIFF_ALL,			/* All three are different */

  DIFF_1ST,			/* Only the first is different */

  DIFF_2ND,			/* Only the second */

  DIFF_3RD			/* Only the third */

};

/* Two way diff */

struct diff_block {

  int ranges[2][2];		/* Ranges are inclusive */

  char **lines[2];		/* The actual lines (may contain nulls) */

  size_t *lengths[2];		/* Line lengths (including newlines, if any) */

  struct diff_block *next;

};

/* Three way diff */

struct diff3_block {

  enum diff_type correspond;	/* Type of diff */

  int ranges[3][2];		/* Ranges are inclusive */

  char **lines[3];		/* The actual lines (may contain nulls) */

  size_t *lengths[3];		/* Line lengths (including newlines, if any) */

  struct diff3_block *next;

};

/*

 * Access the ranges on a diff block.

 */

#define	D_LOWLINE(diff, filenum)	\

  ((diff)->ranges[filenum][START])

#define	D_HIGHLINE(diff, filenum)	\

  ((diff)->ranges[filenum][END])

#define	D_NUMLINES(diff, filenum)	\

  (D_HIGHLINE (diff, filenum) - D_LOWLINE (diff, filenum) + 1)

/*

 * Access the line numbers in a file in a diff by relative line

 * numbers (i.e. line number within the diff itself).  Note that these

 * are lvalues and can be used for assignment.

 */

#define	D_RELNUM(diff, filenum, linenum)	\

  ((diff)->lines[filenum][linenum])

#define	D_RELLEN(diff, filenum, linenum)	\

  ((diff)->lengths[filenum][linenum])

/*

 * And get at them directly, when that should be necessary.

 */

#define	D_LINEARRAY(diff, filenum)	\

  ((diff)->lines[filenum])

#define	D_LENARRAY(diff, filenum)	\

  ((diff)->lengths[filenum])

/*

 * Next block.

 */

#define	D_NEXT(diff)	((diff)->next)

/*

 * Access the type of a diff3 block.

 */

#define	D3_TYPE(diff)	((diff)->correspond)

/*

 * Line mappings based on diffs.  The first maps off the top of the

 * diff, the second off of the bottom.

 */

#define	D_HIGH_MAPLINE(diff, fromfile, tofile, lineno)	\

  ((lineno)						\

   - D_HIGHLINE ((diff), (fromfile))			\

   + D_HIGHLINE ((diff), (tofile)))

#define	D_LOW_MAPLINE(diff, fromfile, tofile, lineno)	\

  ((lineno)						\

   - D_LOWLINE ((diff), (fromfile))			\

   + D_LOWLINE ((diff), (tofile)))

/*

 * General memory allocation function.

 */

#define	ALLOCATE(number, type)	\

  (type *) xmalloc ((number) * sizeof (type))

/* Options variables for flags set on command line.  */

/* If nonzero, treat all files as text files, never as binary.  */

static int always_text;

/* If nonzero, write out an ed script instead of the standard diff3 format.  */

static int edscript;

/* If nonzero, in the case of overlapping diffs (type DIFF_ALL),

   preserve the lines which would normally be deleted from

   file 1 with a special flagging mechanism.  */

static int flagging;

/* Number of lines to keep in identical prefix and suffix.  */

static int horizon_lines = 10;

/* Use a tab to align output lines (-T).  */

static int tab_align_flag;

/* If nonzero, do not output information for overlapping diffs.  */

static int simple_only;

/* If nonzero, do not output information for non-overlapping diffs.  */

static int overlap_only;

/* If nonzero, show information for DIFF_2ND diffs.  */

static int show_2nd;

/* If nonzero, include `:wq' at the end of the script

   to write out the file being edited.   */

static int finalwrite;

/* If nonzero, output a merged file.  */

static int merge;

static char *program_name;

static VOID *xmalloc PARAMS((size_t));

static VOID *xrealloc PARAMS((VOID *, size_t));

static char *read_diff PARAMS((char const *, char const *, char **));

static char *scan_diff_line PARAMS((char *, char **, size_t *, char *, int));

static enum diff_type process_diff_control PARAMS((char **, struct diff_block *));

static int compare_line_list PARAMS((char * const[], size_t const[], char * const[], size_t const[], int));

static int copy_stringlist PARAMS((char * const[], size_t const[], char *[], size_t[], int));

static int dotlines PARAMS((FILE *, struct diff3_block *, int));

static int output_diff3_edscript PARAMS((FILE *, struct diff3_block *, int const[3], int const[3], char const *, char const *, char const *));

static int output_diff3_merge PARAMS((FILE *, FILE *, struct diff3_block *, int const[3], int const[3], char const *, char const *, char const *));

static size_t myread PARAMS((int, char *, size_t));

static struct diff3_block *create_diff3_block PARAMS((int, int, int, int, int, int));

static struct diff3_block *make_3way_diff PARAMS((struct diff_block *, struct diff_block *));

static struct diff3_block *reverse_diff3_blocklist PARAMS((struct diff3_block *));

static struct diff3_block *using_to_diff3_block PARAMS((struct diff_block *[2], struct diff_block *[2], int, int, struct diff3_block const *));

static struct diff_block *process_diff PARAMS((char const *, char const *, struct diff_block **));

static void check_stdout PARAMS((void));

static void fatal PARAMS((char const *));

static void output_diff3 PARAMS((FILE *, struct diff3_block *, int const[3], int const[3]));

static void perror_with_exit PARAMS((char const *));

static void try_help PARAMS((char const *));

static void undotlines PARAMS((FILE *, int, int, int));

static void usage PARAMS((void));

static char const diff_program[] = DIFF_PROGRAM;

static struct option const longopts[] =

{

  {"text", 0, 0, 'a'},

  {"show-all", 0, 0, 'A'},

  {"ed", 0, 0, 'e'},

  {"show-overlap", 0, 0, 'E'},

  {"label", 1, 0, 'L'},

  {"merge", 0, 0, 'm'},

  {"initial-tab", 0, 0, 'T'},

  {"overlap-only", 0, 0, 'x'},

  {"easy-only", 0, 0, '3'},

  {"version", 0, 0, 'v'},

  {"help", 0, 0, 129},

  {0, 0, 0, 0}

};

/*

 * Main program.  Calls diff twice on two pairs of input files,

 * combines the two diffs, and outputs them.

 */

int

main (argc, argv)

     int argc;

     char **argv;

{

  int c, i;

  int mapping[3];

  int rev_mapping[3];

  int incompat = 0;

  int conflicts_found;

  struct diff_block *thread0, *thread1, *last_block;

  struct diff3_block *diff3;

  int tag_count = 0;

  char *tag_strings[3];

  char *commonname;

  char **file;

  struct stat statb;

  initialize_main (&argc, &argv);

  program_name = argv[0];

  while ((c = getopt_long (argc, argv, "aeimvx3AEL:TX", longopts, 0)) != EOF)

    {

      switch (c)

	{

	case 'a':

	  always_text = 1;

	  break;

	case 'A':

	  show_2nd = 1;

	  flagging = 1;

	  incompat++;

	  break;

	case 'x':

	  overlap_only = 1;

	  incompat++;

	  break;

	case '3':

	  simple_only = 1;

	  incompat++;

	  break;

	case 'i':

	  finalwrite = 1;

	  break;

	case 'm':

	  merge = 1;

	  break;

	case 'X':

	  overlap_only = 1;

	  /* Falls through */

	case 'E':

	  flagging = 1;

	  /* Falls through */

	case 'e':

	  incompat++;

	  break;

	case 'T':

	  tab_align_flag = 1;

	  break;

	case 'v':

	  printf ("diff3 - GNU diffutils version %s\n", version_string);

	  exit (0);

	case 129:

	  usage ();

	  check_stdout ();

	  exit (0);

	case 'L':

	  /* Handle up to three -L options.  */

	  if (tag_count < 3)

	    {

	      tag_strings[tag_count++] = optarg;

	      break;

	    }

	  try_help ("Too many labels were given.  The limit is 3.");

	default:

	  try_help (0);

	}

    }

  edscript = incompat & ~merge;  /* -AeExX3 without -m implies ed script.  */

  show_2nd |= ~incompat & merge;  /* -m without -AeExX3 implies -A.  */

  flagging |= ~incompat & merge;

  if (incompat > 1  /* Ensure at most one of -AeExX3.  */

      || finalwrite & merge /* -i -m would rewrite input file.  */

      || (tag_count && ! flagging)) /* -L requires one of -AEX.  */

    try_help ("incompatible options");

  if (argc - optind != 3)

    try_help (argc - optind < 3 ? "missing operand" : "extra operand");

  file = &argv[optind];

  for (i = tag_count; i < 3; i++)

    tag_strings[i] = file[i];

  /* Always compare file1 to file2, even if file2 is "-".

     This is needed for -mAeExX3.  Using the file0 as

     the common file would produce wrong results, because if the

     file0-file1 diffs didn't line up with the file0-file2 diffs

     (which is entirely possible since we don't use diff's -n option),

     diff3 might report phantom changes from file1 to file2.  */

  if (strcmp (file[2], "-") == 0)

    {

      /* Sigh.  We've got standard input as the last arg.  We can't

	 call diff twice on stdin.  Use the middle arg as the common

	 file instead.  */

      if (strcmp (file[0], "-") == 0 || strcmp (file[1], "-") == 0)

	fatal ("`-' specified for more than one input file");

      mapping[0] = 0;

      mapping[1] = 2;

      mapping[2] = 1;

    }

  else

    {

      /* Normal, what you'd expect */

      mapping[0] = 0;

      mapping[1] = 1;

      mapping[2] = 2;

    }

  for (i = 0; i < 3; i++)

    rev_mapping[mapping[i]] = i;

  for (i = 0; i < 3; i++)

    if (strcmp (file[i], "-") != 0)

      {

	if (stat (file[i], &statb) < 0)

	  perror_with_exit (file[i]);

	else if (S_ISDIR(statb.st_mode))

	  {

	    fprintf (stderr, "%s: %s: Is a directory\n",

		     program_name, file[i]);

	    exit (2);

	  }

      }

#if !defined(SIGCHLD) && defined(SIGCLD)

#define SIGCHLD SIGCLD

#endif

#ifdef SIGCHLD

  /* System V fork+wait does not work if SIGCHLD is ignored.  */

  signal (SIGCHLD, SIG_DFL);

#endif

  commonname = file[rev_mapping[FILEC]];

  thread1 = process_diff (file[rev_mapping[FILE1]], commonname, &last_block);

  if (thread1)

    for (i = 0; i < 2; i++)

      {

	horizon_lines = max (horizon_lines, D_NUMLINES (thread1, i));

	horizon_lines = max (horizon_lines, D_NUMLINES (last_block, i));

      }

  thread0 = process_diff (file[rev_mapping[FILE0]], commonname, &last_block);

  diff3 = make_3way_diff (thread0, thread1);

  if (edscript)

    conflicts_found

      = output_diff3_edscript (stdout, diff3, mapping, rev_mapping,

			       tag_strings[0], tag_strings[1], tag_strings[2]);

  else if (merge)

    {

      if (! freopen (file[rev_mapping[FILE0]], "r", stdin))

	perror_with_exit (file[rev_mapping[FILE0]]);

      conflicts_found

	= output_diff3_merge (stdin, stdout, diff3, mapping, rev_mapping,

			      tag_strings[0], tag_strings[1], tag_strings[2]);

      if (ferror (stdin))

	fatal ("read error");

    }

  else

    {

      output_diff3 (stdout, diff3, mapping, rev_mapping);

      conflicts_found = 0;

    }

  check_stdout ();

  exit (conflicts_found);

  return conflicts_found;

}

static void

try_help (reason)

     char const *reason;

{

  if (reason)

    fprintf (stderr, "%s: %s\n", program_name, reason);

  fprintf (stderr, "%s: Try `%s --help' for more information.\n",

	   program_name, program_name);

  exit (2);

}

static void

check_stdout ()

{

  if (ferror (stdout) || fclose (stdout) != 0)

    fatal ("write error");

}

/*

 * Explain, patiently and kindly, how to use this program.

 */

static void

usage ()

{

  printf ("Usage: %s [OPTION]... MYFILE OLDFILE YOURFILE\n\n", program_name);

  printf ("%s", "\

  -e  --ed  Output unmerged changes from OLDFILE to YOURFILE into MYFILE.\n\

  -E  --show-overlap  Output unmerged changes, bracketing conflicts.\n\

  -A  --show-all  Output all changes, bracketing conflicts.\n\

  -x  --overlap-only  Output overlapping changes.\n\

  -X  Output overlapping changes, bracketing them.\n\

  -3  --easy-only  Output unmerged nonoverlapping changes.\n\n");

  printf ("%s", "\

  -m  --merge  Output merged file instead of ed script (default -A).\n\

  -L LABEL  --label=LABEL  Use LABEL instead of file name.\n\

  -i  Append `w' and `q' commands to ed scripts.\n\

  -a  --text  Treat all files as text.\n\

  -T  --initial-tab  Make tabs line up by prepending a tab.\n\n");

  printf ("%s", "\

  -v  --version  Output version info.\n\

  --help  Output this help.\n\n");

  printf ("If a FILE is `-', read standard input.\n");

}

/*

 * Routines that combine the two diffs together into one.  The

 * algorithm used follows:

 *

 *   File2 is shared in common between the two diffs.

 *   Diff02 is the diff between 0 and 2.

 *   Diff12 is the diff between 1 and 2.

 *

 *	1) Find the range for the first block in File2.

 *	    a) Take the lowest of the two ranges (in File2) in the two

 *	       current blocks (one from each diff) as being the low

 *	       water mark.  Assign the upper end of this block as

 *	       being the high water mark and move the current block up

 *	       one.  Mark the block just moved over as to be used.

 *	    b) Check the next block in the diff that the high water

 *	       mark is *not* from.

 *

 *	       *If* the high water mark is above

 *	       the low end of the range in that block,

 *

 *		   mark that block as to be used and move the current

 *		   block up.  Set the high water mark to the max of

 *		   the high end of this block and the current.  Repeat b.

 *

 *	 2) Find the corresponding ranges in File0 (from the blocks

 *	    in diff02; line per line outside of diffs) and in File1.

 *	    Create a diff3_block, reserving space as indicated by the ranges.

 *

 *	 3) Copy all of the pointers for file2 in.  At least for now,

 *	    do memcmp's between corresponding strings in the two diffs.

 *

 *	 4) Copy all of the pointers for file0 and 1 in.  Get what you

 *	    need from file2 (when there isn't a diff block, it's

 *	    identical to file2 within the range between diff blocks).

 *

 *	 5) If the diff blocks you used came from only one of the two

 *	    strings of diffs, then that file (i.e. the one other than

 *	    the common file in that diff) is the odd person out.  If you used

 *	    diff blocks from both sets, check to see if files 0 and 1 match:

 *

 *		Same number of lines?  If so, do a set of memcmp's (if a

 *	    memcmp matches; copy the pointer over; it'll be easier later

 *	    if you have to do any compares).  If they match, 0 & 1 are

 *	    the same.  If not, all three different.

 *

 *   Then you do it again, until you run out of blocks.

 *

 */

/*

 * This routine makes a three way diff (chain of diff3_block's) from two

 * two way diffs (chains of diff_block's).  It is assumed that each of

 * the two diffs passed are onto the same file (i.e. that each of the

 * diffs were made "to" the same file).  The three way diff pointer

 * returned will have numbering FILE0--the other file in diff02,

 * FILE1--the other file in diff12, and FILEC--the common file.

 */

static struct diff3_block *

make_3way_diff (thread0, thread1)

     struct diff_block *thread0, *thread1;

{

/*

 * This routine works on the two diffs passed to it as threads.

 * Thread number 0 is diff02, thread number 1 is diff12.  The USING

 * array is set to the base of the list of blocks to be used to

 * construct each block of the three way diff; if no blocks from a

 * particular thread are to be used, that element of the using array

 * is set to 0.  The elements LAST_USING array are set to the last

 * elements on each of the using lists.

 *

 * The HIGH_WATER_MARK is set to the highest line number in the common file

 * described in any of the diffs in either of the USING lists.  The

 * HIGH_WATER_THREAD names the thread.  Similarly the BASE_WATER_MARK

 * and BASE_WATER_THREAD describe the lowest line number in the common file

 * described in any of the diffs in either of the USING lists.  The

 * HIGH_WATER_DIFF is the diff from which the HIGH_WATER_MARK was

 * taken.

 *

 * The HIGH_WATER_DIFF should always be equal to LAST_USING

 * [HIGH_WATER_THREAD].  The OTHER_DIFF is the next diff to check for

 * higher water, and should always be equal to

 * CURRENT[HIGH_WATER_THREAD ^ 0x1].  The OTHER_THREAD is the thread

 * in which the OTHER_DIFF is, and hence should always be equal to

 * HIGH_WATER_THREAD ^ 0x1.

 *

 * The variable LAST_DIFF is kept set to the last diff block produced

 * by this routine, for line correspondence purposes between that diff

 * and the one currently being worked on.  It is initialized to

 * ZERO_DIFF before any blocks have been created.

 */

  struct diff_block

    *using[2],

    *last_using[2],

    *current[2];

  int

    high_water_mark;

  int

    high_water_thread,

    base_water_thread,

    other_thread;

  struct diff_block

    *high_water_diff,

    *other_diff;

  struct diff3_block

    *result,

    *tmpblock,

    **result_end;

  struct diff3_block const *last_diff3;

  static struct diff3_block const zero_diff3;

  /* Initialization */

  result = 0;

  result_end = &result;

  current[0] = thread0; current[1] = thread1;

  last_diff3 = &zero_diff3;

  /* Sniff up the threads until we reach the end */

  while (current[0] || current[1])

    {

      using[0] = using[1] = last_using[0] = last_using[1] = 0;

      /* Setup low and high water threads, diffs, and marks.  */

      if (!current[0])

	base_water_thread = 1;

      else if (!current[1])

	base_water_thread = 0;

      else

	base_water_thread =

	  (D_LOWLINE (current[0], FC) > D_LOWLINE (current[1], FC));

      high_water_thread = base_water_thread;

      high_water_diff = current[high_water_thread];

#if 0

      /* low and high waters start off same diff */

      base_water_mark = D_LOWLINE (high_water_diff, FC);

#endif

      high_water_mark = D_HIGHLINE (high_water_diff, FC);

      /* Make the diff you just got info from into the using class */

      using[high_water_thread]

	= last_using[high_water_thread]

	= high_water_diff;

      current[high_water_thread] = high_water_diff->next;

      last_using[high_water_thread]->next = 0;

      /* And mark the other diff */

      other_thread = high_water_thread ^ 0x1;

      other_diff = current[other_thread];

      /* Shuffle up the ladder, checking the other diff to see if it

	 needs to be incorporated.  */

      while (other_diff

	     && D_LOWLINE (other_diff, FC) <= high_water_mark + 1)

	{

	  /* Incorporate this diff into the using list.  Note that

	     this doesn't take it off the current list */

	  if (using[other_thread])

	    last_using[other_thread]->next = other_diff;

	  else

	    using[other_thread] = other_diff;

	  last_using[other_thread] = other_diff;

	  /* Take it off the current list.  Note that this following

	     code assumes that other_diff enters it equal to

	     current[high_water_thread ^ 0x1] */

	  current[other_thread] = current[other_thread]->next;

	  other_diff->next = 0;

	  /* Set the high_water stuff

	     If this comparison is equal, then this is the last pass

	     through this loop; since diff blocks within a given

	     thread cannot overlap, the high_water_mark will be

	     *below* the range_start of either of the next diffs.  */

	  if (high_water_mark < D_HIGHLINE (other_diff, FC))

	    {

	      high_water_thread ^= 1;

	      high_water_diff = other_diff;

	      high_water_mark = D_HIGHLINE (other_diff, FC);

	    }

	  /* Set the other diff */

	  other_thread = high_water_thread ^ 0x1;

	  other_diff = current[other_thread];

	}

      /* The using lists contain a list of all of the blocks to be

	 included in this diff3_block.  Create it.  */

      tmpblock = using_to_diff3_block (using, last_using,

				       base_water_thread, high_water_thread,

				       last_diff3);

      if (!tmpblock)

	fatal ("internal error: screwup in format of diff blocks");

      /* Put it on the list.  */

      *result_end = tmpblock;

      result_end = &tmpblock->next;

      /* Set up corresponding lines correctly.  */

      last_diff3 = tmpblock;

    }

  return result;

}

/*

 * using_to_diff3_block:

 *   This routine takes two lists of blocks (from two separate diff

 * threads) and puts them together into one diff3 block.

 * It then returns a pointer to this diff3 block or 0 for failure.

 *

 * All arguments besides using are for the convenience of the routine;

 * they could be derived from the using array.

 * LAST_USING is a pair of pointers to the last blocks in the using

 * structure.

 * LOW_THREAD and HIGH_THREAD tell which threads contain the lowest

 * and highest line numbers for File0.

 * last_diff3 contains the last diff produced in the calling routine.

 * This is used for lines mappings which would still be identical to

 * the state that diff ended in.

 *

 * A distinction should be made in this routine between the two diffs

 * that are part of a normal two diff block, and the three diffs that

 * are part of a diff3_block.

 */

static struct diff3_block *

using_to_diff3_block (using, last_using, low_thread, high_thread, last_diff3)

     struct diff_block

       *using[2],

       *last_using[2];

     int low_thread, high_thread;

     struct diff3_block const *last_diff3;

{

  int low[2], high[2];

  struct diff3_block *result;

  struct diff_block *ptr;

  int d, i;

  /* Find the range in the common file.  */

  int lowc = D_LOWLINE (using[low_thread], FC);

  int highc = D_HIGHLINE (last_using[high_thread], FC);

  /* Find the ranges in the other files.

     If using[d] is null, that means that the file to which that diff

     refers is equivalent to the common file over this range.  */

  for (d = 0; d < 2; d++)

    if (using[d])

      {

	low[d] = D_LOW_MAPLINE (using[d], FC, FO, lowc);

	high[d] = D_HIGH_MAPLINE (last_using[d], FC, FO, highc);

      }

    else

      {

	low[d] = D_HIGH_MAPLINE (last_diff3, FILEC, FILE0 + d, lowc);

	high[d] = D_HIGH_MAPLINE (last_diff3, FILEC, FILE0 + d, highc);

      }

  /* Create a block with the appropriate sizes */

  result = create_diff3_block (low[0], high[0], low[1], high[1], lowc, highc);

  /* Copy information for the common file.

     Return with a zero if any of the compares failed.  */

  for (d = 0; d < 2; d++)

    for (ptr = using[d]; ptr; ptr = D_NEXT (ptr))

      {

	int result_offset = D_LOWLINE (ptr, FC) - lowc;

	if (!copy_stringlist (D_LINEARRAY (ptr, FC),

			      D_LENARRAY (ptr, FC),

			      D_LINEARRAY (result, FILEC) + result_offset,

			      D_LENARRAY (result, FILEC) + result_offset,

			      D_NUMLINES (ptr, FC)))

	  return 0;

      }

  /* Copy information for file d.  First deal with anything that might be

     before the first diff.  */

  for (d = 0; d < 2; d++)

    {

      struct diff_block *u = using[d];

      int lo = low[d], hi = high[d];

      for (i = 0;

	   i + lo < (u ? D_LOWLINE (u, FO) : hi + 1);

	   i++)

	{

	  D_RELNUM (result, FILE0 + d, i) = D_RELNUM (result, FILEC, i);

	  D_RELLEN (result, FILE0 + d, i) = D_RELLEN (result, FILEC, i);

	}

      for (ptr = u; ptr; ptr = D_NEXT (ptr))

	{

	  int result_offset = D_LOWLINE (ptr, FO) - lo;

	  int linec;

	  if (!copy_stringlist (D_LINEARRAY (ptr, FO),

				D_LENARRAY (ptr, FO),

				D_LINEARRAY (result, FILE0 + d) + result_offset,

				D_LENARRAY (result, FILE0 + d) + result_offset,

				D_NUMLINES (ptr, FO)))

	    return 0;

	  /* Catch the lines between here and the next diff */

	  linec = D_HIGHLINE (ptr, FC) + 1 - lowc;

	  for (i = D_HIGHLINE (ptr, FO) + 1 - lo;

	       i < (D_NEXT (ptr) ? D_LOWLINE (D_NEXT (ptr), FO) : hi + 1) - lo;

	       i++)

	    {

	      D_RELNUM (result, FILE0 + d, i) = D_RELNUM (result, FILEC, linec);

	      D_RELLEN (result, FILE0 + d, i) = D_RELLEN (result, FILEC, linec);

	      linec++;

	    }

	}

    }

  /* Set correspond */

  if (!using[0])

    D3_TYPE (result) = DIFF_2ND;

  else if (!using[1])

    D3_TYPE (result) = DIFF_1ST;

  else

    {

      int nl0 = D_NUMLINES (result, FILE0);

      int nl1 = D_NUMLINES (result, FILE1);

      if (nl0 != nl1

	  || !compare_line_list (D_LINEARRAY (result, FILE0),

				 D_LENARRAY (result, FILE0),

				 D_LINEARRAY (result, FILE1),

				 D_LENARRAY (result, FILE1),

				 nl0))

	D3_TYPE (result) = DIFF_ALL;

      else

	D3_TYPE (result) = DIFF_3RD;

    }

  return result;

}

/*

 * This routine copies pointers from a list of strings to a different list

 * of strings.  If a spot in the second list is already filled, it

 * makes sure that it is filled with the same string; if not it

 * returns 0, the copy incomplete.

 * Upon successful completion of the copy, it returns 1.

 */

static int

copy_stringlist (fromptrs, fromlengths, toptrs, tolengths, copynum)

     char * const fromptrs[];

     char *toptrs[];

     size_t const fromlengths[];

     size_t tolengths[];

     int copynum;

{