/contrib/cvs/diff/util.c

  1/* Support routines for GNU DIFF.
  2   Copyright (C) 1988, 1989, 1992, 1993, 1994, 1997, 1998 Free Software Foundation, Inc.
  3
  4This file is part of GNU DIFF.
  5
  6GNU DIFF is free software; you can redistribute it and/or modify
  7it under the terms of the GNU General Public License as published by
  8the Free Software Foundation; either version 2, or (at your option)
  9any later version.
 10
 11GNU DIFF is distributed in the hope that it will be useful,
 12but WITHOUT ANY WARRANTY; without even the implied warranty of
 13MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 14GNU General Public License for more details.
 15
 16*/
 17
 18#include "diff.h"
 19
 20#if __STDC__
 21#include <stdarg.h>
 22#else
 23#include <varargs.h>
 24#endif
 25
 26#ifndef strerror
 27extern char *strerror ();
 28#endif
 29
 30/* Queue up one-line messages to be printed at the end,
 31   when -l is specified.  Each message is recorded with a `struct msg'.  */
 32
 33struct msg
 34{
 35  struct msg *next;
 36  char const *format;
 37  char const *arg1;
 38  char const *arg2;
 39  char const *arg3;
 40  char const *arg4;
 41};
 42
 43/* Head of the chain of queues messages.  */
 44
 45static struct msg *msg_chain;
 46
 47/* Tail of the chain of queues messages.  */
 48
 49static struct msg **msg_chain_end = &msg_chain;
 50
 51/* Use when a system call returns non-zero status.
 52   TEXT should normally be the file name.  */
 53
 54void
 55perror_with_name (text)
 56     char const *text;
 57{
 58  int e = errno;
 59
 60  if (callbacks && callbacks->error)
 61    (*callbacks->error) ("%s: %s", text, strerror (e));
 62  else
 63    {
 64      fprintf (stderr, "%s: ", diff_program_name);
 65      errno = e;
 66      perror (text);
 67    }
 68}
 69
 70/* Use when a system call returns non-zero status and that is fatal.  */
 71
 72void
 73pfatal_with_name (text)
 74     char const *text;
 75{
 76  int e = errno;
 77  print_message_queue ();
 78  if (callbacks && callbacks->error)
 79    (*callbacks->error) ("%s: %s", text, strerror (e));
 80  else
 81    {
 82      fprintf (stderr, "%s: ", diff_program_name);
 83      errno = e;
 84      perror (text);
 85    }
 86  DIFF_ABORT (2);
 87}
 88
 89/* Print an error message from the format-string FORMAT
 90   with args ARG1 and ARG2.  */
 91
 92void
 93diff_error (format, arg, arg1)
 94     char const *format, *arg, *arg1;
 95{
 96  if (callbacks && callbacks->error)
 97    (*callbacks->error) (format, arg, arg1);
 98  else
 99    {
100      fprintf (stderr, "%s: ", diff_program_name);
101      fprintf (stderr, format, arg, arg1);
102      fprintf (stderr, "\n");
103    }
104}
105
106/* Print an error message containing the string TEXT, then exit.  */
107
108void
109fatal (m)
110     char const *m;
111{
112  print_message_queue ();
113  diff_error ("%s", m, 0);
114  DIFF_ABORT (2);
115}
116
117/* Like printf, except if -l in effect then save the message and print later.
118   This is used for things like "binary files differ" and "Only in ...".  */
119
120void
121message (format, arg1, arg2)
122     char const *format, *arg1, *arg2;
123{
124  message5 (format, arg1, arg2, 0, 0);
125}
126
127void
128message5 (format, arg1, arg2, arg3, arg4)
129     char const *format, *arg1, *arg2, *arg3, *arg4;
130{
131  if (paginate_flag)
132    {
133      struct msg *new = (struct msg *) xmalloc (sizeof (struct msg));
134      new->format = format;
135      new->arg1 = concat (arg1, "", "");
136      new->arg2 = concat (arg2, "", "");
137      new->arg3 = arg3 ? concat (arg3, "", "") : 0;
138      new->arg4 = arg4 ? concat (arg4, "", "") : 0;
139      new->next = 0;
140      *msg_chain_end = new;
141      msg_chain_end = &new->next;
142    }
143  else
144    {
145      if (sdiff_help_sdiff)
146	write_output (" ", 1);
147      printf_output (format, arg1, arg2, arg3, arg4);
148    }
149}
150
151/* Output all the messages that were saved up by calls to `message'.  */
152
153void
154print_message_queue ()
155{
156  struct msg *m;
157
158  for (m = msg_chain; m; m = m->next)
159    printf_output (m->format, m->arg1, m->arg2, m->arg3, m->arg4);
160}
161
162/* Call before outputting the results of comparing files NAME0 and NAME1
163   to set up OUTFILE, the stdio stream for the output to go to.
164
165   Usually, OUTFILE is just stdout.  But when -l was specified
166   we fork off a `pr' and make OUTFILE a pipe to it.
167   `pr' then outputs to our stdout.  */
168
169static char const *current_name0;
170static char const *current_name1;
171static int current_depth;
172
173static int output_in_progress = 0;
174
175void
176setup_output (name0, name1, depth)
177     char const *name0, *name1;
178     int depth;
179{
180  current_name0 = name0;
181  current_name1 = name1;
182  current_depth = depth;
183}
184
185#if HAVE_FORK && defined (PR_PROGRAM)
186static pid_t pr_pid;
187#endif
188
189void
190begin_output ()
191{
192  char *name;
193
194  if (output_in_progress)
195    return;
196  output_in_progress = 1;
197
198  /* Construct the header of this piece of diff.  */
199  name = xmalloc (strlen (current_name0) + strlen (current_name1)
200		  + strlen (switch_string) + 7);
201  /* Posix.2 section 4.17.6.1.1 specifies this format.  But there is a
202     bug in the first printing (IEEE Std 1003.2-1992 p 251 l 3304):
203     it says that we must print only the last component of the pathnames.
204     This requirement is silly and does not match historical practice.  */
205  sprintf (name, "diff%s %s %s", switch_string, current_name0, current_name1);
206
207  if (paginate_flag && callbacks && callbacks->write_output)
208    fatal ("can't paginate when using library callbacks");
209
210  if (paginate_flag)
211    {
212      /* Make OUTFILE a pipe to a subsidiary `pr'.  */
213
214#ifdef PR_PROGRAM
215
216# if HAVE_FORK
217      int pipes[2];
218
219      if (pipe (pipes) != 0)
220	pfatal_with_name ("pipe");
221
222      fflush (stdout);
223
224      pr_pid = vfork ();
225      if (pr_pid < 0)
226	pfatal_with_name ("vfork");
227
228      if (pr_pid == 0)
229	{
230	  close (pipes[1]);
231	  if (pipes[0] != STDIN_FILENO)
232	    {
233	      if (dup2 (pipes[0], STDIN_FILENO) < 0)
234		pfatal_with_name ("dup2");
235	      close (pipes[0]);
236	    }
237
238	  execl (PR_PROGRAM, PR_PROGRAM, "-f", "-h", name, 0);
239	  pfatal_with_name (PR_PROGRAM);
240	}
241      else
242	{
243	  close (pipes[0]);
244	  outfile = fdopen (pipes[1], "w");
245	  if (!outfile)
246	    pfatal_with_name ("fdopen");
247	}
248# else /* ! HAVE_FORK */
249      char *command = xmalloc (4 * strlen (name) + strlen (PR_PROGRAM) + 10);
250      char *p;
251      char const *a = name;
252      sprintf (command, "%s -f -h ", PR_PROGRAM);
253      p = command + strlen (command);
254      SYSTEM_QUOTE_ARG (p, a);
255      *p = 0;
256      outfile = popen (command, "w");
257      if (!outfile)
258	pfatal_with_name (command);
259      free (command);
260# endif /* ! HAVE_FORK */
261#else
262      fatal ("This port does not support the --paginate option to diff.");
263#endif
264    }
265  else
266    {
267
268      /* If -l was not specified, output the diff straight to `stdout'.  */
269
270      /* If handling multiple files (because scanning a directory),
271	 print which files the following output is about.  */
272      if (current_depth > 0)
273	printf_output ("%s\n", name);
274    }
275
276  free (name);
277
278  /* A special header is needed at the beginning of context output.  */
279  switch (output_style)
280    {
281    case OUTPUT_CONTEXT:
282      print_context_header (files, 0);
283      break;
284
285    case OUTPUT_UNIFIED:
286      print_context_header (files, 1);
287      break;
288
289    default:
290      break;
291    }
292}
293
294/* Call after the end of output of diffs for one file.
295   If -l was given, close OUTFILE and get rid of the `pr' subfork.  */
296
297void
298finish_output ()
299{
300  if (paginate_flag && outfile != 0 && outfile != stdout)
301    {
302#ifdef PR_PROGRAM
303      int wstatus, w;
304      if (ferror (outfile))
305	fatal ("write error");
306# if ! HAVE_FORK
307      wstatus = pclose (outfile);
308# else /* HAVE_FORK */
309      if (fclose (outfile) != 0)
310	pfatal_with_name ("write error");
311      while ((w = waitpid (pr_pid, &wstatus, 0)) < 0 && errno == EINTR)
312	;
313      if (w < 0)
314	pfatal_with_name ("waitpid");
315# endif /* HAVE_FORK */
316      if (wstatus != 0)
317	fatal ("subsidiary pr failed");
318#else
319      fatal ("internal error in finish_output");
320#endif
321    }
322
323  output_in_progress = 0;
324}
325
326/* Write something to the output file.  */
327
328void
329write_output (text, len)
330     char const *text;
331     size_t len;
332{
333  if (callbacks && callbacks->write_output)
334    (*callbacks->write_output) (text, len);
335  else if (len == 1)
336    putc (*text, outfile);
337  else
338    fwrite (text, sizeof (char), len, outfile);
339}
340
341/* Printf something to the output file.  */
342
343#if __STDC__
344#define VA_START(args, lastarg) va_start(args, lastarg)
345#else /* ! __STDC__ */
346#define VA_START(args, lastarg) va_start(args)
347#endif /* __STDC__ */
348
349void
350#if __STDC__
351printf_output (const char *format, ...)
352#else
353printf_output (format, va_alist)
354     char const *format;
355     va_dcl
356#endif
357{
358  va_list args;
359
360  VA_START (args, format);
361  if (callbacks && callbacks->write_output)
362    {
363      /* We implement our own limited printf-like functionality (%s, %d,
364	 and %c only).  Callers who want something fancier can use
365	 sprintf.  */
366      const char *p = format;
367      char *q;
368      char *str;
369      int num;
370      int ch;
371      char buf[100];
372
373      while ((q = strchr (p, '%')) != NULL)
374	{
375	  static const char msg[] =
376	    "\ninternal error: bad % in printf_output\n";
377	  (*callbacks->write_output) (p, q - p);
378
379	  switch (q[1])
380	    {
381	    case 's':
382	      str = va_arg (args, char *);
383	      (*callbacks->write_output) (str, strlen (str));
384	      break;
385	    case 'd':
386	      num = va_arg (args, int);
387	      sprintf (buf, "%d", num);
388	      (*callbacks->write_output) (buf, strlen (buf));
389	      break;
390	    case 'c':
391	      ch = va_arg (args, int);
392	      buf[0] = ch;
393	      (*callbacks->write_output) (buf, 1);
394	      break;
395	    default:
396	      (*callbacks->write_output) (msg, sizeof (msg) - 1);
397	      /* Don't just keep going, because q + 1 might point to the
398		 terminating '\0'.  */
399	      goto out;
400	    }
401	  p = q + 2;
402	}
403      (*callbacks->write_output) (p, strlen (p));
404    }
405  else
406    vfprintf (outfile, format, args);
407 out:
408  va_end (args);
409}
410
411/* Flush the output file.  */
412
413void
414flush_output ()
415{
416  if (callbacks && callbacks->flush_output)
417    (*callbacks->flush_output) ();
418  else
419    fflush (outfile);
420}
421
422/* Compare two lines (typically one from each input file)
423   according to the command line options.
424   For efficiency, this is invoked only when the lines do not match exactly
425   but an option like -i might cause us to ignore the difference.
426   Return nonzero if the lines differ.  */
427
428int
429line_cmp (s1, s2)
430     char const *s1, *s2;
431{
432  register unsigned char const *t1 = (unsigned char const *) s1;
433  register unsigned char const *t2 = (unsigned char const *) s2;
434
435  while (1)
436    {
437      register unsigned char c1 = *t1++;
438      register unsigned char c2 = *t2++;
439
440      /* Test for exact char equality first, since it's a common case.  */
441      if (c1 != c2)
442	{
443	  /* Ignore horizontal white space if -b or -w is specified.  */
444
445	  if (ignore_all_space_flag)
446	    {
447	      /* For -w, just skip past any white space.  */
448	      while (ISSPACE (c1) && c1 != '\n') c1 = *t1++;
449	      while (ISSPACE (c2) && c2 != '\n') c2 = *t2++;
450	    }
451	  else if (ignore_space_change_flag)
452	    {
453	      /* For -b, advance past any sequence of white space in line 1
454		 and consider it just one Space, or nothing at all
455		 if it is at the end of the line.  */
456	      if (ISSPACE (c1))
457		{
458		  while (c1 != '\n')
459		    {
460		      c1 = *t1++;
461		      if (! ISSPACE (c1))
462			{
463			  --t1;
464			  c1 = ' ';
465			  break;
466			}
467		    }
468		}
469
470	      /* Likewise for line 2.  */
471	      if (ISSPACE (c2))
472		{
473		  while (c2 != '\n')
474		    {
475		      c2 = *t2++;
476		      if (! ISSPACE (c2))
477			{
478			  --t2;
479			  c2 = ' ';
480			  break;
481			}
482		    }
483		}
484
485	      if (c1 != c2)
486		{
487		  /* If we went too far when doing the simple test
488		     for equality, go back to the first non-white-space
489		     character in both sides and try again.  */
490		  if (c2 == ' ' && c1 != '\n'
491		      && (unsigned char const *) s1 + 1 < t1
492		      && ISSPACE(t1[-2]))
493		    {
494		      --t1;
495		      continue;
496		    }
497		  if (c1 == ' ' && c2 != '\n'
498		      && (unsigned char const *) s2 + 1 < t2
499		      && ISSPACE(t2[-2]))
500		    {
501		      --t2;
502		      continue;
503		    }
504		}
505	    }
506
507	  /* Lowercase all letters if -i is specified.  */
508
509	  if (ignore_case_flag)
510	    {
511	      if (ISUPPER (c1))
512		c1 = tolower (c1);
513	      if (ISUPPER (c2))
514		c2 = tolower (c2);
515	    }
516
517	  if (c1 != c2)
518	    break;
519	}
520      if (c1 == '\n')
521	return 0;
522    }
523
524  return (1);
525}
526
527/* Find the consecutive changes at the start of the script START.
528   Return the last link before the first gap.  */
529
530struct change *
531find_change (start)
532     struct change *start;
533{
534  return start;
535}
536
537struct change *
538find_reverse_change (start)
539     struct change *start;
540{
541  return start;
542}
543
544/* Divide SCRIPT into pieces by calling HUNKFUN and
545   print each piece with PRINTFUN.
546   Both functions take one arg, an edit script.
547
548   HUNKFUN is called with the tail of the script
549   and returns the last link that belongs together with the start
550   of the tail.
551
552   PRINTFUN takes a subscript which belongs together (with a null
553   link at the end) and prints it.  */
554
555void
556print_script (script, hunkfun, printfun)
557     struct change *script;
558     struct change * (*hunkfun) PARAMS((struct change *));
559     void (*printfun) PARAMS((struct change *));
560{
561  struct change *next = script;
562
563  while (next)
564    {
565      struct change *this, *end;
566
567      /* Find a set of changes that belong together.  */
568      this = next;
569      end = (*hunkfun) (next);
570
571      /* Disconnect them from the rest of the changes,
572	 making them a hunk, and remember the rest for next iteration.  */
573      next = end->link;
574      end->link = 0;
575#ifdef DEBUG
576      debug_script (this);
577#endif
578
579      /* Print this hunk.  */
580      (*printfun) (this);
581
582      /* Reconnect the script so it will all be freed properly.  */
583      end->link = next;
584    }
585}
586
587/* Print the text of a single line LINE,
588   flagging it with the characters in LINE_FLAG (which say whether
589   the line is inserted, deleted, changed, etc.).  */
590
591void
592print_1_line (line_flag, line)
593     char const *line_flag;
594     char const * const *line;
595{
596  char const *text = line[0], *limit = line[1]; /* Help the compiler.  */
597  char const *flag_format = 0;
598
599  /* If -T was specified, use a Tab between the line-flag and the text.
600     Otherwise use a Space (as Unix diff does).
601     Print neither space nor tab if line-flags are empty.  */
602
603  if (line_flag && *line_flag)
604    {
605      flag_format = tab_align_flag ? "%s\t" : "%s ";
606      printf_output (flag_format, line_flag);
607    }
608
609  output_1_line (text, limit, flag_format, line_flag);
610
611  if ((!line_flag || line_flag[0]) && limit[-1] != '\n')
612    printf_output ("\n\\ No newline at end of file\n");
613}
614
615/* Output a line from TEXT up to LIMIT.  Without -t, output verbatim.
616   With -t, expand white space characters to spaces, and if FLAG_FORMAT
617   is nonzero, output it with argument LINE_FLAG after every
618   internal carriage return, so that tab stops continue to line up.  */
619
620void
621output_1_line (text, limit, flag_format, line_flag)
622     char const *text, *limit, *flag_format, *line_flag;
623{
624  if (!tab_expand_flag)
625    write_output (text, limit - text);
626  else
627    {
628      register unsigned char c;
629      register char const *t = text;
630      register unsigned column = 0;
631      /* CC is used to avoid taking the address of the register
632         variable C.  */
633      char cc;
634
635      while (t < limit)
636	switch ((c = *t++))
637	  {
638	  case '\t':
639	    {
640	      unsigned spaces = TAB_WIDTH - column % TAB_WIDTH;
641	      column += spaces;
642	      do
643		write_output (" ", 1);
644	      while (--spaces);
645	    }
646	    break;
647
648	  case '\r':
649	    write_output ("\r", 1);
650	    if (flag_format && t < limit && *t != '\n')
651	      printf_output (flag_format, line_flag);
652	    column = 0;
653	    break;
654
655	  case '\b':
656	    if (column == 0)
657	      continue;
658	    column--;
659	    write_output ("\b", 1);
660	    break;
661
662	  default:
663	    if (ISPRINT (c))
664	      column++;
665	    cc = c;
666	    write_output (&cc, 1);
667	    break;
668	  }
669    }
670}
671
672int
673change_letter (inserts, deletes)
674     int inserts, deletes;
675{
676  if (!inserts)
677    return 'd';
678  else if (!deletes)
679    return 'a';
680  else
681    return 'c';
682}
683
684/* Translate an internal line number (an index into diff's table of lines)
685   into an actual line number in the input file.
686   The internal line number is LNUM.  FILE points to the data on the file.
687
688   Internal line numbers count from 0 starting after the prefix.
689   Actual line numbers count from 1 within the entire file.  */
690
691int
692translate_line_number (file, lnum)
693     struct file_data const *file;
694     int lnum;
695{
696  return lnum + file->prefix_lines + 1;
697}
698
699void
700translate_range (file, a, b, aptr, bptr)
701     struct file_data const *file;
702     int a, b;
703     int *aptr, *bptr;
704{
705  *aptr = translate_line_number (file, a - 1) + 1;
706  *bptr = translate_line_number (file, b + 1) - 1;
707}
708
709/* Print a pair of line numbers with SEPCHAR, translated for file FILE.
710   If the two numbers are identical, print just one number.
711
712   Args A and B are internal line numbers.
713   We print the translated (real) line numbers.  */
714
715void
716print_number_range (sepchar, file, a, b)
717     int sepchar;
718     struct file_data *file;
719     int a, b;
720{
721  int trans_a, trans_b;
722  translate_range (file, a, b, &trans_a, &trans_b);
723
724  /* Note: we can have B < A in the case of a range of no lines.
725     In this case, we should print the line number before the range,
726     which is B.  */
727  if (trans_b > trans_a)
728    printf_output ("%d%c%d", trans_a, sepchar, trans_b);
729  else
730    printf_output ("%d", trans_b);
731}
732
733/* Look at a hunk of edit script and report the range of lines in each file
734   that it applies to.  HUNK is the start of the hunk, which is a chain
735   of `struct change'.  The first and last line numbers of file 0 are stored in
736   *FIRST0 and *LAST0, and likewise for file 1 in *FIRST1 and *LAST1.
737   Note that these are internal line numbers that count from 0.
738
739   If no lines from file 0 are deleted, then FIRST0 is LAST0+1.
740
741   Also set *DELETES nonzero if any lines of file 0 are deleted
742   and set *INSERTS nonzero if any lines of file 1 are inserted.
743   If only ignorable lines are inserted or deleted, both are
744   set to 0.  */
745
746void
747analyze_hunk (hunk, first0, last0, first1, last1, deletes, inserts)
748     struct change *hunk;
749     int *first0, *last0, *first1, *last1;
750     int *deletes, *inserts;
751{
752  int l0, l1, show_from, show_to;
753  int i;
754  int trivial = ignore_blank_lines_flag || ignore_regexp_list;
755  struct change *next;
756
757  show_from = show_to = 0;
758
759  *first0 = hunk->line0;
760  *first1 = hunk->line1;
761
762  next = hunk;
763  do
764    {
765      l0 = next->line0 + next->deleted - 1;
766      l1 = next->line1 + next->inserted - 1;
767      show_from += next->deleted;
768      show_to += next->inserted;
769
770      for (i = next->line0; i <= l0 && trivial; i++)
771	if (!ignore_blank_lines_flag || files[0].linbuf[i][0] != '\n')
772	  {
773	    struct regexp_list *r;
774	    char const *line = files[0].linbuf[i];
775	    int len = files[0].linbuf[i + 1] - line;
776
777	    for (r = ignore_regexp_list; r; r = r->next)
778	      if (0 <= re_search (&r->buf, line, len, 0, len, 0))
779		break;	/* Found a match.  Ignore this line.  */
780	    /* If we got all the way through the regexp list without
781	       finding a match, then it's nontrivial.  */
782	    if (!r)
783	      trivial = 0;
784	  }
785
786      for (i = next->line1; i <= l1 && trivial; i++)
787	if (!ignore_blank_lines_flag || files[1].linbuf[i][0] != '\n')
788	  {
789	    struct regexp_list *r;
790	    char const *line = files[1].linbuf[i];
791	    int len = files[1].linbuf[i + 1] - line;
792
793	    for (r = ignore_regexp_list; r; r = r->next)
794	      if (0 <= re_search (&r->buf, line, len, 0, len, 0))
795		break;	/* Found a match.  Ignore this line.  */
796	    /* If we got all the way through the regexp list without
797	       finding a match, then it's nontrivial.  */
798	    if (!r)
799	      trivial = 0;
800	  }
801    }
802  while ((next = next->link) != 0);
803
804  *last0 = l0;
805  *last1 = l1;
806
807  /* If all inserted or deleted lines are ignorable,
808     tell the caller to ignore this hunk.  */
809
810  if (trivial)
811    show_from = show_to = 0;
812
813  *deletes = show_from;
814  *inserts = show_to;
815}
816
817/* Concatenate three strings, returning a newly malloc'd string.  */
818
819char *
820concat (s1, s2, s3)
821     char const *s1, *s2, *s3;
822{
823  size_t len = strlen (s1) + strlen (s2) + strlen (s3);
824  char *new = xmalloc (len + 1);
825  sprintf (new, "%s%s%s", s1, s2, s3);
826  return new;
827}
828
829/* Yield the newly malloc'd pathname
830   of the file in DIR whose filename is FILE.  */
831
832char *
833dir_file_pathname (dir, file)
834     char const *dir, *file;
835{
836  char const *p = filename_lastdirchar (dir);
837  return concat (dir, "/" + (p && !p[1]), file);
838}
839
840void
841debug_script (sp)
842     struct change *sp;
843{
844  fflush (stdout);
845  for (; sp; sp = sp->link)
846    fprintf (stderr, "%3d %3d delete %d insert %d\n",
847	     sp->line0, sp->line1, sp->deleted, sp->inserted);
848  fflush (stderr);
849}