 @@ -507,1427 +507,1427 @@ diff3_run (argc, argv, out, callbacks_ar
   if (opened_file)
     if (fclose (outfile) != 0)
 	perror_with_name ("close error on output file");
   return conflicts_found;
+}
 static int
 try_help (reason)
      char const *reason;
+{
   if (reason)
     diff_error ("%s", reason, 0);
   diff_error ("Try `%s --help' for more information.", diff_program_name, 0);
   return 2;
+}
 static void
 check_output (stream)
      FILE *stream;
+{
   if (ferror (stream) || fflush (stream) != 0)
     diff3_fatal ("write error");
+}
 /*
  * Explain, patiently and kindly, how to use this program.
  */
 static void
 usage ()
+{
   if (callbacks && callbacks->write_stdout)
+    {
       (*callbacks->write_stdout) ("Usage: ");
       (*callbacks->write_stdout) (diff_program_name);
       (*callbacks->write_stdout) (" [OPTION]... MYFILE OLDFILE YOURFILE\n\n");
       (*callbacks->write_stdout) ("\
   -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");
       (*callbacks->write_stdout) ("\
   -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");
       (*callbacks->write_stdout) ("\
   -v  --version  Output version info.\n\
   --help  Output this help.\n\n");
       (*callbacks->write_stdout) ("If a FILE is `-', read standard input.\n");
+    }
   else
+    {
       printf ("Usage: %s [OPTION]... MYFILE OLDFILE YOURFILE\n\n", diff_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 = { 0 };
   /* 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);
       free_diff_blocks(using[0]);
       free_diff_blocks(using[1]);
       if (!tmpblock)
 	diff3_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;
+{
   register char * const *f = fromptrs;
   register char **t = toptrs;
   register size_t const *fl = fromlengths;
   register size_t *tl = tolengths;
   while (copynum--)
+    {
       if (*t)
 	{ if (*fl != *tl || memcmp (*f, *t, *fl)) return 0; }
       else
 	{ *t = *f ; *tl = *fl; }
       t++; f++; tl++; fl++;
+    }
   return 1;
+}
 /*
  * Create a diff3_block, with ranges as specified in the arguments.
  * Allocate the arrays for the various pointers (and zero them) based
  * on the arguments passed.  Return the block as a result.
  */
 static struct diff3_block *
 create_diff3_block (low0, high0, low1, high1, low2, high2)
      register int low0, high0, low1, high1, low2, high2;
+{
   struct diff3_block *result = ALLOCATE (1, struct diff3_block);
   int numlines;
   D3_TYPE (result) = ERROR;
   D_NEXT (result) = 0;
   /* Assign ranges */
   D_LOWLINE (result, FILE0) = low0;
   D_HIGHLINE (result, FILE0) = high0;
   D_LOWLINE (result, FILE1) = low1;
   D_HIGHLINE (result, FILE1) = high1;
   D_LOWLINE (result, FILE2) = low2;
   D_HIGHLINE (result, FILE2) = high2;
   /* Allocate and zero space */
   numlines = D_NUMLINES (result, FILE0);
   if (numlines)
+    {
       D_LINEARRAY (result, FILE0) = ALLOCATE (numlines, char *);
       D_LENARRAY (result, FILE0) = ALLOCATE (numlines, size_t);
       bzero (D_LINEARRAY (result, FILE0), (numlines * sizeof (char *)));
       bzero (D_LENARRAY (result, FILE0), (numlines * sizeof (size_t)));
+    }
   else
+    {
       D_LINEARRAY (result, FILE0) = 0;
       D_LENARRAY (result, FILE0) = 0;
+    }
   numlines = D_NUMLINES (result, FILE1);
   if (numlines)
+    {
       D_LINEARRAY (result, FILE1) = ALLOCATE (numlines, char *);
       D_LENARRAY (result, FILE1) = ALLOCATE (numlines, size_t);
       bzero (D_LINEARRAY (result, FILE1), (numlines * sizeof (char *)));
       bzero (D_LENARRAY (result, FILE1), (numlines * sizeof (size_t)));
+    }
   else
+    {
       D_LINEARRAY (result, FILE1) = 0;
       D_LENARRAY (result, FILE1) = 0;
+    }
   numlines = D_NUMLINES (result, FILE2);
   if (numlines)
+    {
       D_LINEARRAY (result, FILE2) = ALLOCATE (numlines, char *);
       D_LENARRAY (result, FILE2) = ALLOCATE (numlines, size_t);
       bzero (D_LINEARRAY (result, FILE2), (numlines * sizeof (char *)));
       bzero (D_LENARRAY (result, FILE2), (numlines * sizeof (size_t)));
+    }
   else
+    {
       D_LINEARRAY (result, FILE2) = 0;
       D_LENARRAY (result, FILE2) = 0;
+    }
   /* Return */
   return result;
+}
 /*
  * Compare two lists of lines of text.
  * Return 1 if they are equivalent, 0 if not.
  */
 static int
 compare_line_list (list1, lengths1, list2, lengths2, nl)
      char * const list1[], * const list2[];
      size_t const lengths1[], lengths2[];
      int nl;
+{
   char
     * const *l1 = list1,
     * const *l2 = list2;
   size_t const
     *lgths1 = lengths1,
     *lgths2 = lengths2;
   while (nl--)
     if (!*l1 || !*l2 || *lgths1 != *lgths2++
 	|| memcmp (*l1++, *l2++, *lgths1++))
       return 0;
   return 1;
+}
 /*
  * Routines to input and parse two way diffs.
  */
 extern char **environ;
 static struct diff_block *
 process_diff (filea, fileb, last_block, diff_contents)
      char const *filea, *fileb;
      struct diff_block **last_block;
      char **diff_contents;
+{
   char *diff_limit;
   char *scan_diff;
   enum diff_type dt;
   int i;
   struct diff_block *block_list, **block_list_end, *bptr;
   diff_limit = read_diff (filea, fileb, diff_contents);
   scan_diff = *diff_contents;
   block_list_end = &block_list;
   bptr = 0; /* Pacify `gcc -W'.  */
   while (scan_diff < diff_limit)
+    {
       bptr = ALLOCATE (1, struct diff_block);
       bptr->lines[0] = bptr->lines[1] = 0;
       bptr->lengths[0] = bptr->lengths[1] = 0;
       dt = process_diff_control (&scan_diff, bptr);
       if (dt == ERROR || *scan_diff != '\n')
+	{
 	  char *serr;
 	  for (serr = scan_diff; *serr != '\n'; serr++)
+	    ;
 	  *serr = '\0';
 	  diff_error ("diff error: %s", scan_diff, 0);
 	  *serr = '\n';
 	  DIFF3_ABORT (2);
+	}
       scan_diff++;
       /* Force appropriate ranges to be null, if necessary */
       switch (dt)
+	{
 	case ADD:
 	  bptr->ranges[0][0]++;
 	  break;
 	case DELETE:
 	  bptr->ranges[1][0]++;
 	  break;
 	case CHANGE:
 	  break;
 	default:
 	  diff3_fatal ("internal error: invalid diff type in process_diff");
 	  break;
+	}
       /* Allocate space for the pointers for the lines from filea, and
 	 parcel them out among these pointers */
       if (dt != ADD)
+	{
 	  int numlines = D_NUMLINES (bptr, 0);
 	  bptr->lines[0] = ALLOCATE (numlines, char *);
 	  bptr->lengths[0] = ALLOCATE (numlines, size_t);
 	  for (i = 0; i < numlines; i++)
 	    scan_diff = scan_diff_line (scan_diff,
 					&(bptr->lines[0][i]),
 					&(bptr->lengths[0][i]),
 					diff_limit,
 					'<');
+	}
       /* Get past the separator for changes */
       if (dt == CHANGE)
+	{
 	  if (strncmp (scan_diff, "---\n", 4))
 	    diff3_fatal ("invalid diff format; invalid change separator");
 	  scan_diff += 4;
+	}
       /* Allocate space for the pointers for the lines from fileb, and
 	 parcel them out among these pointers */
       if (dt != DELETE)
+	{
 	  int numlines = D_NUMLINES (bptr, 1);
 	  bptr->lines[1] = ALLOCATE (numlines, char *);
 	  bptr->lengths[1] = ALLOCATE (numlines, size_t);
 	  for (i = 0; i < numlines; i++)
 	    scan_diff = scan_diff_line (scan_diff,
 					&(bptr->lines[1][i]),
 					&(bptr->lengths[1][i]),
 					diff_limit,
 					'>');
+	}
       /* Place this block on the blocklist.  */
       *block_list_end = bptr;
       block_list_end = &bptr->next;
+    }
   *block_list_end = 0;
   *last_block = bptr;
   return block_list;
+}
 /*
  * This routine will parse a normal format diff control string.  It
  * returns the type of the diff (ERROR if the format is bad).  All of
  * the other important information is filled into to the structure
  * pointed to by db, and the string pointer (whose location is passed
  * to this routine) is updated to point beyond the end of the string
  * parsed.  Note that only the ranges in the diff_block will be set by
  * this routine.
+ *
  * If some specific pair of numbers has been reduced to a single
  * number, then both corresponding numbers in the diff block are set
  * to that number.  In general these numbers are interpetted as ranges
  * inclusive, unless being used by the ADD or DELETE commands.  It is
  * assumed that these will be special cased in a superior routine.
  */
 static enum diff_type
 process_diff_control (string, db)
      char **string;
      struct diff_block *db;
+{
   char *s = *string;
   int holdnum;
   enum diff_type type;
 /* These macros are defined here because they can use variables
    defined in this function.  Don't try this at home kids, we're
    trained professionals!
    Also note that SKIPWHITE only recognizes tabs and spaces, and
    that READNUM can only read positive, integral numbers */
 #define	SKIPWHITE(s)	{ while (*s == ' ' || *s == '\t') s++; }
 #define	READNUM(s, num)	\
 	{ unsigned char c = *s; if (!ISDIGIT (c)) return ERROR; holdnum = 0; \
 	  do { holdnum = (c - '0' + holdnum * 10); }	\
 	  while (ISDIGIT (c = *++s)); (num) = holdnum; }
   /* Read first set of digits */
   SKIPWHITE (s);
   READNUM (s, db->ranges[0][START]);
   /* Was that the only digit? */
   SKIPWHITE (s);
   if (*s == ',')
+    {
       /* Get the next digit */
       s++;
       READNUM (s, db->ranges[0][END]);
+    }
   else
     db->ranges[0][END] = db->ranges[0][START];
   /* Get the letter */
   SKIPWHITE (s);
   switch (*s)
+    {
     case 'a':
       type = ADD;
       break;
     case 'c':
       type = CHANGE;
       break;
     case 'd':
       type = DELETE;
       break;
     default:
       return ERROR;			/* Bad format */
+    }
   s++;				/* Past letter */
   /* Read second set of digits */
   SKIPWHITE (s);
   READNUM (s, db->ranges[1][START]);
   /* Was that the only digit? */
   SKIPWHITE (s);
   if (*s == ',')
+    {
       /* Get the next digit */
       s++;
       READNUM (s, db->ranges[1][END]);
       SKIPWHITE (s);		/* To move to end */
+    }
   else
     db->ranges[1][END] = db->ranges[1][START];
   *string = s;
   return type;
+}
 static char *
 read_diff (filea, fileb, output_placement)
      char const *filea, *fileb;
      char **output_placement;
+{
   char *diff_result;
   size_t bytes, current_chunk_size, total;
   int fd, wstatus;
   struct stat pipestat;
   FILE *outfile_hold;
   const struct diff_callbacks *callbacks_hold;
   struct diff_callbacks my_callbacks;
   struct diff_callbacks *my_callbacks_arg;
   /* 302 / 1000 is log10(2.0) rounded up.  Subtract 1 for the sign bit;
      add 1 for integer division truncation; add 1 more for a minus sign.  */
 #define INT_STRLEN_BOUND(type) ((sizeof(type)*CHAR_BIT - 1) * 302 / 1000 + 2)
   char const *argv[7];
   char horizon_arg[17 + INT_STRLEN_BOUND (int)];
   char const **ap;
   char *diffout;
   ap = argv;
   *ap++ = "diff";
   if (always_text)
     *ap++ = "-a";
   sprintf (horizon_arg, "--horizon-lines=%d", horizon_lines);
   *ap++ = horizon_arg;
   *ap++ = "--";
   *ap++ = filea;
   *ap++ = fileb;
   *ap = 0;
   diffout = cvs_temp_name ();
   outfile_hold = outfile;
   callbacks_hold = callbacks;
   /* We want to call diff_run preserving any stdout and stderr
      callbacks, but discarding any callbacks to handle file output,
      since we want the file output to go to our temporary file.
      FIXME: We should use callbacks to just read it into a memory
      buffer; that's we do with the temporary file just below anyhow.  */
   if (callbacks == NULL)
     my_callbacks_arg = NULL;
   else
+    {
       my_callbacks = *callbacks;
       my_callbacks.write_output = NULL;
       my_callbacks.flush_output = NULL;
       my_callbacks_arg = &my_callbacks;
+    }
   wstatus = diff_run (ap - argv, (char **) argv, diffout, my_callbacks_arg);
   outfile = outfile_hold;
   callbacks = callbacks_hold;
   if (wstatus == 2)
     diff3_fatal ("subsidiary diff failed");
   if (-1 == (fd = open (diffout, O_RDONLY)))
     diff3_fatal ("could not open temporary diff file");
   current_chunk_size = 8 * 1024;
   if (fstat (fd, &pipestat) == 0)
     current_chunk_size = max (current_chunk_size, STAT_BLOCKSIZE (pipestat));
   diff_result = xmalloc (current_chunk_size);
   total = 0;
   do {
     bytes = myread (fd,
 		    diff_result + total,
 		    current_chunk_size - total);
     total += bytes;
     if (total == current_chunk_size)
+      {
 	if (current_chunk_size < 2 * current_chunk_size)
 	  current_chunk_size = 2 * current_chunk_size;
 	else if (current_chunk_size < (size_t) -1)
 	  current_chunk_size = (size_t) -1;
 	else
 	  diff3_fatal ("files are too large to fit into memory");
 	diff_result = xrealloc (diff_result, (current_chunk_size *= 2));
+      }
   } while (bytes);
   if (total != 0 && diff_result[total-1] != '\n')
     diff3_fatal ("invalid diff format; incomplete last line");
   *output_placement = diff_result;
   if (close (fd) != 0)
     diff3_perror_with_exit ("pipe close");
   unlink (diffout);
   free( diffout );
   return diff_result + total;
+}
 /*
  * Scan a regular diff line (consisting of > or <, followed by a
  * space, followed by text (including nulls) up to a newline.
+ *
  * This next routine began life as a macro and many parameters in it
  * are used as call-by-reference values.
  */
 static char *
 scan_diff_line (scan_ptr, set_start, set_length, limit, leadingchar)
      char *scan_ptr, **set_start;
      size_t *set_length;
      char *limit;
      int leadingchar;
+{
   char *line_ptr;
   if (!(scan_ptr[0] == leadingchar
 	&& scan_ptr[1] == ' '))
     diff3_fatal ("invalid diff format; incorrect leading line chars");
   *set_start = line_ptr = scan_ptr + 2;
   while (*line_ptr++ != '\n')
+    ;
   /* Include newline if the original line ended in a newline,
      or if an edit script is being generated.
      Copy any missing newline message to stderr if an edit script is being
      generated, because edit scripts cannot handle missing newlines.
      Return the beginning of the next line.  */
   *set_length = line_ptr - *set_start;
   if (line_ptr < limit && *line_ptr == '\\')
+    {
       if (! edscript)
+	{
 	  --*set_length;
 	  line_ptr++;
 	  while (*line_ptr++ != '\n')
+	    ;
+	}
       else
+	{
 	  char *serr;
 	  line_ptr++;
 	  serr = line_ptr;
 	  while (*line_ptr++ != '\n')
+	    ;
 	  line_ptr[-1] = '\0';
 	  diff_error ("%s", serr, 0);
 	  line_ptr[-1] = '\n';
+	}
+    }
   return line_ptr;
+}
 /*
  * This routine outputs a three way diff passed as a list of
  * diff3_block's.
  * The argument MAPPING is indexed by external file number (in the
  * argument list) and contains the internal file number (from the
  * diff passed).  This is important because the user expects his
  * outputs in terms of the argument list number, and the diff passed
  * may have been done slightly differently (if the last argument
  * was "-", for example).
  * REV_MAPPING is the inverse of MAPPING.
  */
 static void
 output_diff3 (diff, mapping, rev_mapping)
      struct diff3_block *diff;
      int const mapping[3], rev_mapping[3];
+{
   int i;
   int oddoneout;
   char *cp;
   struct diff3_block *ptr;
   int line;
   size_t length;
   int dontprint;
   static int skew_increment[3] = { 2, 3, 1 }; /* 0==>2==>1==>3 */
   char const *line_prefix = tab_align_flag ? "\t" : "  ";
   for (ptr = diff; ptr; ptr = D_NEXT (ptr))
+    {
       char x[2];
       switch (ptr->correspond)
+	{
 	case DIFF_ALL:
 	  x[0] = '\0';
 	  dontprint = 3;	/* Print them all */
 	  oddoneout = 3;	/* Nobody's odder than anyone else */
 	  break;
 	case DIFF_1ST:
 	case DIFF_2ND:
 	case DIFF_3RD:
 	  oddoneout = rev_mapping[(int) ptr->correspond - (int) DIFF_1ST];
 	  x[0] = oddoneout + '1';
 	  x[1] = '\0';
 	  dontprint = oddoneout==0;
 	  break;
 	default:
 	  diff3_fatal ("internal error: invalid diff type passed to output");
+	}
       printf_output ("====%s\n", x);
       /* Go 0, 2, 1 if the first and third outputs are equivalent.  */
       for (i = 0; i < 3;
 	   i = (oddoneout == 1 ? skew_increment[i] : i + 1))
+	{
 	  int realfile = mapping[i];
 	  int
 	    lowt = D_LOWLINE (ptr, realfile),
 	    hight = D_HIGHLINE (ptr, realfile);
 	  printf_output ("%d:", i + 1);
 	  switch (lowt - hight)
+	    {
 	    case 1:
 	      printf_output ("%da\n", lowt - 1);
 	      break;
 	    case 0:
 	      printf_output ("%dc\n", lowt);
 	      break;
 	    default:
 	      printf_output ("%d,%dc\n", lowt, hight);
 	      break;
+	    }
 	  if (i == dontprint) continue;
 	  if (lowt <= hight)
+	    {
 	      line = 0;
 	      do
+		{
-		  printf_output (line_prefix);
+		  printf_output ("%s", line_prefix);
 		  cp = D_RELNUM (ptr, realfile, line);
 		  length = D_RELLEN (ptr, realfile, line);
 		  write_output (cp, length);
+		}
 	      while (++line < hight - lowt + 1);
 	      if (cp[length - 1] != '\n')
 		printf_output ("\n\\ No newline at end of file\n");
+	    }
+	}
+    }
+}
 /*
  * Output the lines of B taken from FILENUM.
  * Double any initial '.'s; yield nonzero if any initial '.'s were doubled.
  */
 static int
 dotlines (b, filenum)
      struct diff3_block *b;
      int filenum;
+{
   int i;
   int leading_dot = 0;
   for (i = 0;
        i < D_NUMLINES (b, filenum);
        i++)
+    {
       char *line = D_RELNUM (b, filenum, i);
       if (line[0] == '.')
+	{
 	  leading_dot = 1;
 	  write_output (".", 1);
+	}
       write_output (line, D_RELLEN (b, filenum, i));
+    }
   return leading_dot;
+}
 /*
  * Output to OUTPUTFILE a '.' line.  If LEADING_DOT is nonzero,
  * also output a command that removes initial '.'s
  * starting with line START and continuing for NUM lines.
  */
 static void
 undotlines (leading_dot, start, num)
      int leading_dot, start, num;
+{
   write_output (".\n", 2);
   if (leading_dot)
+  {
     if (num == 1)
       printf_output ("%ds/^\\.//\n", start);
     else
       printf_output ("%d,%ds/^\\.//\n", start, start + num - 1);
+  }
+}
 /*
  * This routine outputs a diff3 set of blocks as an ed script.  This
  * script applies the changes between file's 2 & 3 to file 1.  It
  * takes the precise format of the ed script to be output from global
  * variables set during options processing.  Note that it does
  * destructive things to the set of diff3 blocks it is passed; it
  * reverses their order (this gets around the problems involved with
  * changing line numbers in an ed script).
+ *
  * Note that this routine has the same problem of mapping as the last
  * one did; the variable MAPPING maps from file number according to
  * the argument list to file number according to the diff passed.  All
  * files listed below are in terms of the argument list.
  * REV_MAPPING is the inverse of MAPPING.
+ *
  * The arguments FILE0, FILE1 and FILE2 are the strings to print
  * as the names of the three files.  These may be the actual names,
  * or may be the arguments specified with -L.
+ *
  * Returns 1 if conflicts were found.
  */
 static int
 output_diff3_edscript (diff, mapping, rev_mapping, file0, file1, file2)
      struct diff3_block *diff;
      int const mapping[3], rev_mapping[3];
      char const *file0, *file1, *file2;
+{
   int leading_dot;
   int conflicts_found = 0, conflict;
   struct diff3_block *b;
   for (b = reverse_diff3_blocklist (diff); b; b = b->next)
+    {
       /* Must do mapping correctly.  */
       enum diff_type type
 	= ((b->correspond == DIFF_ALL) ?
 	   DIFF_ALL :
 	   ((enum diff_type)
 	    (((int) DIFF_1ST)
 	     + rev_mapping[(int) b->correspond - (int) DIFF_1ST])));
       /* If we aren't supposed to do this output block, skip it.  */
       switch (type)
+	{
 	default: continue;
 	case DIFF_2ND: if (!show_2nd) continue; conflict = 1; break;
 	case DIFF_3RD: if (overlap_only) continue; conflict = 0; break;
 	case DIFF_ALL: if (simple_only) continue; conflict = flagging; break;
+	}
       if (conflict)
+	{
 	  conflicts_found = 1;
 	  /* Mark end of conflict.  */
 	  printf_output ("%da\n", D_HIGHLINE (b, mapping[FILE0]));
 	  leading_dot = 0;
 	  if (type == DIFF_ALL)
+	    {
 	      if (show_2nd)
+		{
 		  /* Append lines from FILE1.  */
 		  printf_output ("||||||| %s\n", file1);
 		  leading_dot = dotlines (b, mapping[FILE1]);
+		}
 	      /* Append lines from FILE2.  */
 	      printf_output ("=======\n");
 	      leading_dot |= dotlines (b, mapping[FILE2]);
+	    }
 	  printf_output (">>>>>>> %s\n", file2);
 	  undotlines (leading_dot,
 		      D_HIGHLINE (b, mapping[FILE0]) + 2,
 		      (D_NUMLINES (b, mapping[FILE1])
 		       + D_NUMLINES (b, mapping[FILE2]) + 1));
 	  /* Mark start of conflict.  */
 	  printf_output ("%da\n<<<<<<< %s\n",
 			 D_LOWLINE (b, mapping[FILE0]) - 1,
 			 type == DIFF_ALL ? file0 : file1);
 	  leading_dot = 0;
 	  if (type == DIFF_2ND)
+	    {
 	      /* Prepend lines from FILE1.  */
 	      leading_dot = dotlines (b, mapping[FILE1]);
 	      printf_output ("=======\n");
+	    }
 	  undotlines (leading_dot,
 		      D_LOWLINE (b, mapping[FILE0]) + 1,
 		      D_NUMLINES (b, mapping[FILE1]));
+	}
       else if (D_NUMLINES (b, mapping[FILE2]) == 0)
 	/* Write out a delete */
+	{
 	  if (D_NUMLINES (b, mapping[FILE0]) == 1)
 	    printf_output ("%dd\n", D_LOWLINE (b, mapping[FILE0]));
 	  else
 	    printf_output ("%d,%dd\n",
 			   D_LOWLINE (b, mapping[FILE0]),
 			   D_HIGHLINE (b, mapping[FILE0]));
+	}
       else
 	/* Write out an add or change */
+	{
 	  switch (D_NUMLINES (b, mapping[FILE0]))
+	    {
 	    case 0:
 	      printf_output ("%da\n", D_HIGHLINE (b, mapping[FILE0]));
 	      break;
 	    case 1:
 	      printf_output ("%dc\n", D_HIGHLINE (b, mapping[FILE0]));
 	      break;
 	    default:
 	      printf_output ("%d,%dc\n",
 			     D_LOWLINE (b, mapping[FILE0]),
 			     D_HIGHLINE (b, mapping[FILE0]));
 	      break;
+	    }
 	  undotlines (dotlines (b, mapping[FILE2]),
 		      D_LOWLINE (b, mapping[FILE0]),
 		      D_NUMLINES (b, mapping[FILE2]));
+	}
+    }
   if (finalwrite) printf_output ("w\nq\n");
   return conflicts_found;
+}
 /*
  * Read from INFILE and output to the standard output file a set of
  * diff3_ blocks DIFF as a merged file.  This acts like 'ed file0
  * <[output_diff3_edscript]', except that it works even for binary
  * data or incomplete lines.
+ *
  * As before, MAPPING maps from arg list file number to diff file number,
  * REV_MAPPING is its inverse,
  * and FILE0, FILE1, and FILE2 are the names of the files.
+ *
  * Returns 1 if conflicts were found.
  */
 static int
 output_diff3_merge (infile, diff, mapping, rev_mapping,
 		    file0, file1, file2)
      FILE *infile;
      struct diff3_block *diff;
      int const mapping[3], rev_mapping[3];
      char const *file0, *file1, *file2;
+{
   int c, i;
   char cc;
   int conflicts_found = 0, conflict;
   struct diff3_block *b;
   int linesread = 0;
   for (b = diff; b; b = b->next)
+    {
       /* Must do mapping correctly.  */
       enum diff_type type
 	= ((b->correspond == DIFF_ALL) ?
 	   DIFF_ALL :
 	   ((enum diff_type)
 	    (((int) DIFF_1ST)
 	     + rev_mapping[(int) b->correspond - (int) DIFF_1ST])));
       char const *format_2nd = "<<<<<<< %s\n";
       /* If we aren't supposed to do this output block, skip it.  */
       switch (type)
+	{
 	default: continue;
 	case DIFF_2ND: if (!show_2nd) continue; conflict = 1; break;
 	case DIFF_3RD: if (overlap_only) continue; conflict = 0; break;
 	case DIFF_ALL: if (simple_only) continue; conflict = flagging;
 	  format_2nd = "||||||| %s\n";
 	  break;
+	}
       /* Copy I lines from file 0.  */
       i = D_LOWLINE (b, FILE0) - linesread - 1;
       linesread += i;
       while (0 <= --i)
 	do
+	  {
 	    c = getc (infile);
 	    if (c == EOF)
+	    {
 	      if (ferror (infile))
 		diff3_perror_with_exit ("input file");
 	      else if (feof (infile))
 		diff3_fatal ("input file shrank");
+	    }
 	    cc = c;
 	    write_output (&cc, 1);
+	  }
 	while (c != '\n');
       if (conflict)
+	{
 	  conflicts_found = 1;
 	  if (type == DIFF_ALL)
+	    {
 	      /* Put in lines from FILE0 with bracket.  */
 	      printf_output ("<<<<<<< %s\n", file0);
 	      for (i = 0;
 		   i < D_NUMLINES (b, mapping[FILE0]);
 		   i++)
 		write_output (D_RELNUM (b, mapping[FILE0], i),
 			      D_RELLEN (b, mapping[FILE0], i));
+	    }
 	  if (show_2nd)
+	    {
 	      /* Put in lines from FILE1 with bracket.  */
 	      printf_output (format_2nd, file1);
 	      for (i = 0;
 		   i < D_NUMLINES (b, mapping[FILE1]);
 		   i++)
 		write_output (D_RELNUM (b, mapping[FILE1], i),
 			      D_RELLEN (b, mapping[FILE1], i));
+	    }
 	  printf_output ("=======\n");
+	}
       /* Put in lines from FILE2.  */
       for (i = 0;
 	   i < D_NUMLINES (b, mapping[FILE2]);
 	   i++)
 	write_output (D_RELNUM (b, mapping[FILE2], i),
 		      D_RELLEN (b, mapping[FILE2], i));
       if (conflict)
 	printf_output (">>>>>>> %s\n", file2);
       /* Skip I lines in file 0.  */
       i = D_NUMLINES (b, FILE0);
       linesread += i;
       while (0 <= --i)
 	while ((c = getc (infile)) != '\n')
 	  if (c == EOF)
+	  {
 	    if (ferror (infile))
 	      diff3_perror_with_exit ("input file");
 	    else if (feof (infile))
+	      {
 		if (i || b->next)
 		  diff3_fatal ("input file shrank");
 		return conflicts_found;
+	      }
+	  }
+    }
   /* Copy rest of common file.  */
   while ((c = getc (infile)) != EOF || !(ferror (infile) | feof (infile)))
+    {
       cc = c;
       write_output (&cc, 1);
+    }
   return conflicts_found;
+}
 /*
  * Reverse the order of the list of diff3 blocks.
  */
 static struct diff3_block *
 reverse_diff3_blocklist (diff)
      struct diff3_block *diff;
+{
   register struct diff3_block *tmp, *next, *prev;
   for (tmp = diff, prev = 0;  tmp;  tmp = next)
+    {
       next = tmp->next;
       tmp->next = prev;
       prev = tmp;
+    }
   return prev;
+}
 static size_t
 myread (fd, ptr, size)
      int fd;
      char *ptr;
      size_t size;
+{
   ssize_t result = read (fd, ptr, size);
   if (result == -1)
     diff3_perror_with_exit ("read failed");
   return (size_t)result;
+}
 static void
 diff3_fatal (string)
      char const *string;
+{
   diff_error ("%s", string, 0);
   DIFF3_ABORT (2);
+}
 static void
 diff3_perror_with_exit (string)
      char const *string;
+{
   perror_with_name (string);
   DIFF3_ABORT (2);
+}
 static void
 initialize_main (argcp, argvp)
     int *argcp;
     char ***argvp;
+{
   always_text = 0;
   edscript = 0;
   flagging = 0;
   tab_align_flag = 0;
   simple_only = 0;
   overlap_only = 0;
   show_2nd = 0;
   finalwrite = 0;
   merge = 0;
   diff_program_name = (*argvp)[0];
   outfile = NULL;
+}
 static void
 free_diff_blocks(p)
     struct diff_block *p;
+{
   register struct diff_block *next;
   while (p)
+    {
       next = p->next;
       if (p->lines[0]) free(p->lines[0]);
       if (p->lines[1]) free(p->lines[1]);
       if (p->lengths[0]) free(p->lengths[0]);
       if (p->lengths[1]) free(p->lengths[1]);
       free(p);
       p = next;
+    }
+}
 static void
 free_diff3_blocks(p)
     struct diff3_block *p;
+{
   register struct diff3_block *next;
   while (p)
+    {
       next = p->next;
       if (p->lines[0]) free(p->lines[0]);
       if (p->lines[1]) free(p->lines[1]);
       if (p->lines[2]) free(p->lines[2]);
       if (p->lengths[0]) free(p->lengths[0]);
       if (p->lengths[1]) free(p->lengths[1]);
       if (p->lengths[2]) free(p->lengths[2]);
       free(p);
       p = next;
+    }
+}