1 /* sdiff - side-by-side merge of file differences
2
3 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 2001, 2002, 2004
4 Free Software Foundation, Inc.
5
6 This file is part of GNU DIFF.
7
8 GNU DIFF is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
11 any later version.
12
13 GNU DIFF is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
16 See the GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; see the file COPYING.
20 If not, write to the Free Software Foundation,
21 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
22
23 #include "system.h"
24 #include "paths.h"
25
26 #include <stdio.h>
27 #include <unlocked-io.h>
28
29 #include <c-stack.h>
30 #include <dirname.h>
31 #include <error.h>
32 #include <exit.h>
33 #include <exitfail.h>
34 #include <file-type.h>
35 #include <getopt.h>
36 #include <quotesys.h>
37 #include <version-etc.h>
38 #include <xalloc.h>
39
40 /* Size of chunks read from files which must be parsed into lines. */
41 #define SDIFF_BUFSIZE ((size_t) 65536)
42
43 char *program_name;
44
45 static char const *editor_program = DEFAULT_EDITOR_PROGRAM;
46 static char const **diffargv;
47
48 static char * volatile tmpname;
49 static FILE *tmp;
50
51 #if HAVE_WORKING_FORK || HAVE_WORKING_VFORK
52 static pid_t volatile diffpid;
53 #endif
54
55 struct line_filter;
56
57 static void catchsig (int);
58 static bool edit (struct line_filter *, char const *, lin, lin, struct line_filter *, char const *, lin, lin, FILE *);
59 static bool interact (struct line_filter *, struct line_filter *, char const *, struct line_filter *, char const *, FILE *);
60 static void checksigs (void);
61 static void diffarg (char const *);
62 static void fatal (char const *) __attribute__((noreturn));
63 static void perror_fatal (char const *) __attribute__((noreturn));
64 static void trapsigs (void);
65 static void untrapsig (int);
66
67 #define NUM_SIGS (sizeof sigs / sizeof *sigs)
68 static int const sigs[] = {
69 #ifdef SIGHUP
70 SIGHUP,
71 #endif
72 #ifdef SIGQUIT
73 SIGQUIT,
74 #endif
75 #ifdef SIGTERM
76 SIGTERM,
77 #endif
78 #ifdef SIGXCPU
79 SIGXCPU,
80 #endif
81 #ifdef SIGXFSZ
82 SIGXFSZ,
83 #endif
84 SIGINT,
85 SIGPIPE
86 };
87 #define handler_index_of_SIGINT (NUM_SIGS - 2)
88 #define handler_index_of_SIGPIPE (NUM_SIGS - 1)
89
90 #if HAVE_SIGACTION
91 /* Prefer `sigaction' if available, since `signal' can lose signals. */
92 static struct sigaction initial_action[NUM_SIGS];
93 # define initial_handler(i) (initial_action[i].sa_handler)
94 static void signal_handler (int, void (*) (int));
95 #else
96 static void (*initial_action[NUM_SIGS]) ();
97 # define initial_handler(i) (initial_action[i])
98 # define signal_handler(sig, handler) signal (sig, handler)
99 #endif
100
101 #if ! HAVE_SIGPROCMASK
102 # define sigset_t int
103 # define sigemptyset(s) (*(s) = 0)
104 # ifndef sigmask
105 # define sigmask(sig) (1 << ((sig) - 1))
106 # endif
107 # define sigaddset(s, sig) (*(s) |= sigmask (sig))
108 # ifndef SIG_BLOCK
109 # define SIG_BLOCK 0
110 # endif
111 # ifndef SIG_SETMASK
112 # define SIG_SETMASK (! SIG_BLOCK)
113 # endif
114 # define sigprocmask(how, n, o) \
115 ((how) == SIG_BLOCK ? *(o) = sigblock (*(n)) : sigsetmask (*(n)))
116 #endif
117
118 static bool diraccess (char const *);
119 static int temporary_file (void);
120
121 /* Options: */
122
123 /* Name of output file if -o specified. */
124 static char const *output;
125
126 /* Do not print common lines. */
127 static bool suppress_common_lines;
128
129 /* Value for the long option that does not have single-letter equivalents. */
130 enum
131 {
132 DIFF_PROGRAM_OPTION = CHAR_MAX + 1,
133 HELP_OPTION,
134 STRIP_TRAILING_CR_OPTION,
135 TABSIZE_OPTION
136 };
137
138 static struct option const longopts[] =
139 {
140 {"diff-program", 1, 0, DIFF_PROGRAM_OPTION},
141 {"expand-tabs", 0, 0, 't'},
142 {"help", 0, 0, HELP_OPTION},
143 {"ignore-all-space", 0, 0, 'W'}, /* swap W and w for historical reasons */
144 {"ignore-blank-lines", 0, 0, 'B'},
145 {"ignore-case", 0, 0, 'i'},
146 {"ignore-matching-lines", 1, 0, 'I'},
147 {"ignore-space-change", 0, 0, 'b'},
148 {"ignore-tab-expansion", 0, 0, 'E'},
149 {"left-column", 0, 0, 'l'},
150 {"minimal", 0, 0, 'd'},
151 {"output", 1, 0, 'o'},
152 {"speed-large-files", 0, 0, 'H'},
153 {"strip-trailing-cr", 0, 0, STRIP_TRAILING_CR_OPTION},
154 {"suppress-common-lines", 0, 0, 's'},
155 {"tabsize", 1, 0, TABSIZE_OPTION},
156 {"text", 0, 0, 'a'},
157 {"version", 0, 0, 'v'},
158 {"width", 1, 0, 'w'},
159 {0, 0, 0, 0}
160 };
161
162 static void try_help (char const *, char const *) __attribute__((noreturn));
163 static void
try_help(char const * reason_msgid,char const * operand)164 try_help (char const *reason_msgid, char const *operand)
165 {
166 if (reason_msgid)
167 error (0, 0, _(reason_msgid), operand);
168 error (EXIT_TROUBLE, 0, _("Try `%s --help' for more information."),
169 program_name);
170 abort ();
171 }
172
173 static void
check_stdout(void)174 check_stdout (void)
175 {
176 if (ferror (stdout))
177 fatal ("write failed");
178 else if (fclose (stdout) != 0)
179 perror_fatal (_("standard output"));
180 }
181
182 static char const * const option_help_msgid[] = {
183 N_("-o FILE --output=FILE Operate interactively, sending output to FILE."),
184 "",
185 N_("-i --ignore-case Consider upper- and lower-case to be the same."),
186 N_("-E --ignore-tab-expansion Ignore changes due to tab expansion."),
187 N_("-b --ignore-space-change Ignore changes in the amount of white space."),
188 N_("-W --ignore-all-space Ignore all white space."),
189 N_("-B --ignore-blank-lines Ignore changes whose lines are all blank."),
190 N_("-I RE --ignore-matching-lines=RE Ignore changes whose lines all match RE."),
191 N_("--strip-trailing-cr Strip trailing carriage return on input."),
192 N_("-a --text Treat all files as text."),
193 "",
194 N_("-w NUM --width=NUM Output at most NUM (default 130) print columns."),
195 N_("-l --left-column Output only the left column of common lines."),
196 N_("-s --suppress-common-lines Do not output common lines."),
197 "",
198 N_("-t --expand-tabs Expand tabs to spaces in output."),
199 N_("--tabsize=NUM Tab stops are every NUM (default 8) print columns."),
200 "",
201 N_("-d --minimal Try hard to find a smaller set of changes."),
202 N_("-H --speed-large-files Assume large files and many scattered small changes."),
203 N_("--diff-program=PROGRAM Use PROGRAM to compare files."),
204 "",
205 N_("-v --version Output version info."),
206 N_("--help Output this help."),
207 0
208 };
209
210 static void
usage(void)211 usage (void)
212 {
213 char const * const *p;
214
215 printf (_("Usage: %s [OPTION]... FILE1 FILE2\n"), program_name);
216 printf ("%s\n\n", _("Side-by-side merge of file differences."));
217 for (p = option_help_msgid; *p; p++)
218 if (**p)
219 printf (" %s\n", _(*p));
220 else
221 putchar ('\n');
222 printf ("\n%s\n%s\n\n%s\n",
223 _("If a FILE is `-', read standard input."),
224 _("Exit status is 0 if inputs are the same, 1 if different, 2 if trouble."),
225 _("Report bugs to <bug-gnu-utils@gnu.org>."));
226 }
227
228 /* Clean up after a signal or other failure. This function is
229 async-signal-safe. */
230 static void
cleanup(int signo)231 cleanup (int signo __attribute__((unused)))
232 {
233 #if HAVE_WORKING_FORK || HAVE_WORKING_VFORK
234 if (0 < diffpid)
235 kill (diffpid, SIGPIPE);
236 #endif
237 if (tmpname)
238 unlink (tmpname);
239 }
240
241 static void exiterr (void) __attribute__((noreturn));
242 static void
exiterr(void)243 exiterr (void)
244 {
245 cleanup (0);
246 untrapsig (0);
247 checksigs ();
248 exit (EXIT_TROUBLE);
249 }
250
251 static void
fatal(char const * msgid)252 fatal (char const *msgid)
253 {
254 error (0, 0, "%s", _(msgid));
255 exiterr ();
256 }
257
258 static void
perror_fatal(char const * msg)259 perror_fatal (char const *msg)
260 {
261 int e = errno;
262 checksigs ();
263 error (0, e, "%s", msg);
264 exiterr ();
265 }
266
267 static void
check_child_status(int werrno,int wstatus,int max_ok_status,char const * subsidiary_program)268 check_child_status (int werrno, int wstatus, int max_ok_status,
269 char const *subsidiary_program)
270 {
271 int status = (! werrno && WIFEXITED (wstatus)
272 ? WEXITSTATUS (wstatus)
273 : INT_MAX);
274
275 if (max_ok_status < status)
276 {
277 error (0, werrno,
278 _(status == 126
279 ? "subsidiary program `%s' could not be invoked"
280 : status == 127
281 ? "subsidiary program `%s' not found"
282 : status == INT_MAX
283 ? "subsidiary program `%s' failed"
284 : "subsidiary program `%s' failed (exit status %d)"),
285 subsidiary_program, status);
286 exiterr ();
287 }
288 }
289
290 static FILE *
ck_fopen(char const * fname,char const * type)291 ck_fopen (char const *fname, char const *type)
292 {
293 FILE *r = fopen (fname, type);
294 if (! r)
295 perror_fatal (fname);
296 return r;
297 }
298
299 static void
ck_fclose(FILE * f)300 ck_fclose (FILE *f)
301 {
302 if (fclose (f))
303 perror_fatal ("fclose");
304 }
305
306 static size_t
ck_fread(char * buf,size_t size,FILE * f)307 ck_fread (char *buf, size_t size, FILE *f)
308 {
309 size_t r = fread (buf, sizeof (char), size, f);
310 if (r == 0 && ferror (f))
311 perror_fatal (_("read failed"));
312 return r;
313 }
314
315 static void
ck_fwrite(char const * buf,size_t size,FILE * f)316 ck_fwrite (char const *buf, size_t size, FILE *f)
317 {
318 if (fwrite (buf, sizeof (char), size, f) != size)
319 perror_fatal (_("write failed"));
320 }
321
322 static void
ck_fflush(FILE * f)323 ck_fflush (FILE *f)
324 {
325 if (fflush (f) != 0)
326 perror_fatal (_("write failed"));
327 }
328
329 static char const *
expand_name(char * name,bool is_dir,char const * other_name)330 expand_name (char *name, bool is_dir, char const *other_name)
331 {
332 if (strcmp (name, "-") == 0)
333 fatal ("cannot interactively merge standard input");
334 if (! is_dir)
335 return name;
336 else
337 {
338 /* Yield NAME/BASE, where BASE is OTHER_NAME's basename. */
339 char const *base = base_name (other_name);
340 size_t namelen = strlen (name), baselen = strlen (base);
341 bool insert_slash = *base_name (name) && name[namelen - 1] != '/';
342 char *r = xmalloc (namelen + insert_slash + baselen + 1);
343 memcpy (r, name, namelen);
344 r[namelen] = '/';
345 memcpy (r + namelen + insert_slash, base, baselen + 1);
346 return r;
347 }
348 }
349
350 struct line_filter {
351 FILE *infile;
352 char *bufpos;
353 char *buffer;
354 char *buflim;
355 };
356
357 static void
lf_init(struct line_filter * lf,FILE * infile)358 lf_init (struct line_filter *lf, FILE *infile)
359 {
360 lf->infile = infile;
361 lf->bufpos = lf->buffer = lf->buflim = xmalloc (SDIFF_BUFSIZE + 1);
362 lf->buflim[0] = '\n';
363 }
364
365 /* Fill an exhausted line_filter buffer from its INFILE */
366 static size_t
lf_refill(struct line_filter * lf)367 lf_refill (struct line_filter *lf)
368 {
369 size_t s = ck_fread (lf->buffer, SDIFF_BUFSIZE, lf->infile);
370 lf->bufpos = lf->buffer;
371 lf->buflim = lf->buffer + s;
372 lf->buflim[0] = '\n';
373 checksigs ();
374 return s;
375 }
376
377 /* Advance LINES on LF's infile, copying lines to OUTFILE */
378 static void
lf_copy(struct line_filter * lf,lin lines,FILE * outfile)379 lf_copy (struct line_filter *lf, lin lines, FILE *outfile)
380 {
381 char *start = lf->bufpos;
382
383 while (lines)
384 {
385 lf->bufpos = (char *) memchr (lf->bufpos, '\n', lf->buflim - lf->bufpos);
386 if (! lf->bufpos)
387 {
388 ck_fwrite (start, lf->buflim - start, outfile);
389 if (! lf_refill (lf))
390 return;
391 start = lf->bufpos;
392 }
393 else
394 {
395 --lines;
396 ++lf->bufpos;
397 }
398 }
399
400 ck_fwrite (start, lf->bufpos - start, outfile);
401 }
402
403 /* Advance LINES on LF's infile without doing output */
404 static void
lf_skip(struct line_filter * lf,lin lines)405 lf_skip (struct line_filter *lf, lin lines)
406 {
407 while (lines)
408 {
409 lf->bufpos = (char *) memchr (lf->bufpos, '\n', lf->buflim - lf->bufpos);
410 if (! lf->bufpos)
411 {
412 if (! lf_refill (lf))
413 break;
414 }
415 else
416 {
417 --lines;
418 ++lf->bufpos;
419 }
420 }
421 }
422
423 /* Snarf a line into a buffer. Return EOF if EOF, 0 if error, 1 if OK. */
424 static int
lf_snarf(struct line_filter * lf,char * buffer,size_t bufsize)425 lf_snarf (struct line_filter *lf, char *buffer, size_t bufsize)
426 {
427 for (;;)
428 {
429 char *start = lf->bufpos;
430 char *next = (char *) memchr (start, '\n', lf->buflim + 1 - start);
431 size_t s = next - start;
432 if (bufsize <= s)
433 return 0;
434 memcpy (buffer, start, s);
435 if (next < lf->buflim)
436 {
437 buffer[s] = 0;
438 lf->bufpos = next + 1;
439 return 1;
440 }
441 if (! lf_refill (lf))
442 return s ? 0 : EOF;
443 buffer += s;
444 bufsize -= s;
445 }
446 }
447
448 int
main(int argc,char * argv[])449 main (int argc, char *argv[])
450 {
451 int opt;
452 char const *prog;
453
454 exit_failure = EXIT_TROUBLE;
455 initialize_main (&argc, &argv);
456 program_name = argv[0];
457 setlocale (LC_ALL, "");
458 bindtextdomain (PACKAGE, LOCALEDIR);
459 textdomain (PACKAGE);
460 c_stack_action (cleanup);
461
462 prog = getenv ("EDITOR");
463 if (prog)
464 editor_program = prog;
465
466 diffarg (DEFAULT_DIFF_PROGRAM);
467
468 /* parse command line args */
469 while ((opt = getopt_long (argc, argv, "abBdEHiI:lo:stvw:W", longopts, 0))
470 != -1)
471 {
472 switch (opt)
473 {
474 case 'a':
475 diffarg ("-a");
476 break;
477
478 case 'b':
479 diffarg ("-b");
480 break;
481
482 case 'B':
483 diffarg ("-B");
484 break;
485
486 case 'd':
487 diffarg ("-d");
488 break;
489
490 case 'E':
491 diffarg ("-E");
492 break;
493
494 case 'H':
495 diffarg ("-H");
496 break;
497
498 case 'i':
499 diffarg ("-i");
500 break;
501
502 case 'I':
503 diffarg ("-I");
504 diffarg (optarg);
505 break;
506
507 case 'l':
508 diffarg ("--left-column");
509 break;
510
511 case 'o':
512 output = optarg;
513 break;
514
515 case 's':
516 suppress_common_lines = true;
517 break;
518
519 case 't':
520 diffarg ("-t");
521 break;
522
523 case 'v':
524 version_etc (stdout, "sdiff", PACKAGE_NAME, PACKAGE_VERSION,
525 "Thomas Lord", (char *) 0);
526 check_stdout ();
527 return EXIT_SUCCESS;
528
529 case 'w':
530 diffarg ("-W");
531 diffarg (optarg);
532 break;
533
534 case 'W':
535 diffarg ("-w");
536 break;
537
538 case DIFF_PROGRAM_OPTION:
539 diffargv[0] = optarg;
540 break;
541
542 case HELP_OPTION:
543 usage ();
544 check_stdout ();
545 return EXIT_SUCCESS;
546
547 case STRIP_TRAILING_CR_OPTION:
548 diffarg ("--strip-trailing-cr");
549 break;
550
551 case TABSIZE_OPTION:
552 diffarg ("--tabsize");
553 diffarg (optarg);
554 break;
555
556 default:
557 try_help (0, 0);
558 }
559 }
560
561 if (argc - optind != 2)
562 {
563 if (argc - optind < 2)
564 try_help ("missing operand after `%s'", argv[argc - 1]);
565 else
566 try_help ("extra operand `%s'", argv[optind + 2]);
567 }
568
569 if (! output)
570 {
571 /* easy case: diff does everything for us */
572 if (suppress_common_lines)
573 diffarg ("--suppress-common-lines");
574 diffarg ("-y");
575 diffarg ("--");
576 diffarg (argv[optind]);
577 diffarg (argv[optind + 1]);
578 diffarg (0);
579 execvp (diffargv[0], (char **) diffargv);
580 perror_fatal (diffargv[0]);
581 }
582 else
583 {
584 char const *lname, *rname;
585 FILE *left, *right, *out, *diffout;
586 bool interact_ok;
587 struct line_filter lfilt;
588 struct line_filter rfilt;
589 struct line_filter diff_filt;
590 bool leftdir = diraccess (argv[optind]);
591 bool rightdir = diraccess (argv[optind + 1]);
592
593 if (leftdir & rightdir)
594 fatal ("both files to be compared are directories");
595
596 lname = expand_name (argv[optind], leftdir, argv[optind + 1]);
597 left = ck_fopen (lname, "r");
598 rname = expand_name (argv[optind + 1], rightdir, argv[optind]);
599 right = ck_fopen (rname, "r");
600 out = ck_fopen (output, "w");
601
602 diffarg ("--sdiff-merge-assist");
603 diffarg ("--");
604 diffarg (argv[optind]);
605 diffarg (argv[optind + 1]);
606 diffarg (0);
607
608 trapsigs ();
609
610 #if ! (HAVE_WORKING_FORK || HAVE_WORKING_VFORK)
611 {
612 size_t cmdsize = 1;
613 char *p, *command;
614 int i;
615
616 for (i = 0; diffargv[i]; i++)
617 cmdsize += quote_system_arg (0, diffargv[i]) + 1;
618 command = p = xmalloc (cmdsize);
619 for (i = 0; diffargv[i]; i++)
620 {
621 p += quote_system_arg (p, diffargv[i]);
622 *p++ = ' ';
623 }
624 p[-1] = 0;
625 errno = 0;
626 diffout = popen (command, "r");
627 if (! diffout)
628 perror_fatal (command);
629 free (command);
630 }
631 #else
632 {
633 int diff_fds[2];
634 # if HAVE_WORKING_VFORK
635 sigset_t procmask;
636 sigset_t blocked;
637 # endif
638
639 if (pipe (diff_fds) != 0)
640 perror_fatal ("pipe");
641
642 # if HAVE_WORKING_VFORK
643 /* Block SIGINT and SIGPIPE. */
644 sigemptyset (&blocked);
645 sigaddset (&blocked, SIGINT);
646 sigaddset (&blocked, SIGPIPE);
647 sigprocmask (SIG_BLOCK, &blocked, &procmask);
648 # endif
649 diffpid = vfork ();
650 if (diffpid < 0)
651 perror_fatal ("fork");
652 if (! diffpid)
653 {
654 /* Alter the child's SIGINT and SIGPIPE handlers;
655 this may munge the parent.
656 The child ignores SIGINT in case the user interrupts the editor.
657 The child does not ignore SIGPIPE, even if the parent does. */
658 if (initial_handler (handler_index_of_SIGINT) != SIG_IGN)
659 signal_handler (SIGINT, SIG_IGN);
660 signal_handler (SIGPIPE, SIG_DFL);
661 # if HAVE_WORKING_VFORK
662 /* Stop blocking SIGINT and SIGPIPE in the child. */
663 sigprocmask (SIG_SETMASK, &procmask, 0);
664 # endif
665 close (diff_fds[0]);
666 if (diff_fds[1] != STDOUT_FILENO)
667 {
668 dup2 (diff_fds[1], STDOUT_FILENO);
669 close (diff_fds[1]);
670 }
671
672 execvp (diffargv[0], (char **) diffargv);
673 _exit (errno == ENOENT ? 127 : 126);
674 }
675
676 # if HAVE_WORKING_VFORK
677 /* Restore the parent's SIGINT and SIGPIPE behavior. */
678 if (initial_handler (handler_index_of_SIGINT) != SIG_IGN)
679 signal_handler (SIGINT, catchsig);
680 if (initial_handler (handler_index_of_SIGPIPE) != SIG_IGN)
681 signal_handler (SIGPIPE, catchsig);
682 else
683 signal_handler (SIGPIPE, SIG_IGN);
684
685 /* Stop blocking SIGINT and SIGPIPE in the parent. */
686 sigprocmask (SIG_SETMASK, &procmask, 0);
687 # endif
688
689 close (diff_fds[1]);
690 diffout = fdopen (diff_fds[0], "r");
691 if (! diffout)
692 perror_fatal ("fdopen");
693 }
694 #endif
695
696 lf_init (&diff_filt, diffout);
697 lf_init (&lfilt, left);
698 lf_init (&rfilt, right);
699
700 interact_ok = interact (&diff_filt, &lfilt, lname, &rfilt, rname, out);
701
702 ck_fclose (left);
703 ck_fclose (right);
704 ck_fclose (out);
705
706 {
707 int wstatus;
708 int werrno = 0;
709
710 #if ! (HAVE_WORKING_FORK || HAVE_WORKING_VFORK)
711 wstatus = pclose (diffout);
712 if (wstatus == -1)
713 werrno = errno;
714 #else
715 ck_fclose (diffout);
716 while (waitpid (diffpid, &wstatus, 0) < 0)
717 if (errno == EINTR)
718 checksigs ();
719 else
720 perror_fatal ("waitpid");
721 diffpid = 0;
722 #endif
723
724 if (tmpname)
725 {
726 unlink (tmpname);
727 tmpname = 0;
728 }
729
730 if (! interact_ok)
731 exiterr ();
732
733 check_child_status (werrno, wstatus, EXIT_FAILURE, diffargv[0]);
734 untrapsig (0);
735 checksigs ();
736 exit (WEXITSTATUS (wstatus));
737 }
738 }
739 return EXIT_SUCCESS; /* Fool `-Wall'. */
740 }
741
742 static void
diffarg(char const * a)743 diffarg (char const *a)
744 {
745 static size_t diffargs, diffarglim;
746
747 if (diffargs == diffarglim)
748 {
749 if (! diffarglim)
750 diffarglim = 16;
751 else if (PTRDIFF_MAX / (2 * sizeof *diffargv) <= diffarglim)
752 xalloc_die ();
753 else
754 diffarglim *= 2;
755 diffargv = xrealloc (diffargv, diffarglim * sizeof *diffargv);
756 }
757 diffargv[diffargs++] = a;
758 }
759
760 /* Signal handling */
761
762 static bool volatile ignore_SIGINT;
763 static int volatile signal_received;
764 static bool sigs_trapped;
765
766 static void
catchsig(int s)767 catchsig (int s)
768 {
769 #if ! HAVE_SIGACTION
770 signal (s, SIG_IGN);
771 #endif
772 if (! (s == SIGINT && ignore_SIGINT))
773 signal_received = s;
774 }
775
776 #if HAVE_SIGACTION
777 static struct sigaction catchaction;
778
779 static void
signal_handler(int sig,void (* handler)(int))780 signal_handler (int sig, void (*handler) (int))
781 {
782 catchaction.sa_handler = handler;
783 sigaction (sig, &catchaction, 0);
784 }
785 #endif
786
787 static void
trapsigs(void)788 trapsigs (void)
789 {
790 int i;
791
792 #if HAVE_SIGACTION
793 catchaction.sa_flags = SA_RESTART;
794 sigemptyset (&catchaction.sa_mask);
795 for (i = 0; i < NUM_SIGS; i++)
796 sigaddset (&catchaction.sa_mask, sigs[i]);
797 #endif
798
799 for (i = 0; i < NUM_SIGS; i++)
800 {
801 #if HAVE_SIGACTION
802 sigaction (sigs[i], 0, &initial_action[i]);
803 #else
804 initial_action[i] = signal (sigs[i], SIG_IGN);
805 #endif
806 if (initial_handler (i) != SIG_IGN)
807 signal_handler (sigs[i], catchsig);
808 }
809
810 #ifdef SIGCHLD
811 /* System V fork+wait does not work if SIGCHLD is ignored. */
812 signal (SIGCHLD, SIG_DFL);
813 #endif
814
815 sigs_trapped = true;
816 }
817
818 /* Untrap signal S, or all trapped signals if S is zero. */
819 static void
untrapsig(int s)820 untrapsig (int s)
821 {
822 int i;
823
824 if (sigs_trapped)
825 for (i = 0; i < NUM_SIGS; i++)
826 if ((! s || sigs[i] == s) && initial_handler (i) != SIG_IGN)
827 {
828 #if HAVE_SIGACTION
829 sigaction (sigs[i], &initial_action[i], 0);
830 #else
831 signal (sigs[i], initial_action[i]);
832 #endif
833 }
834 }
835
836 /* Exit if a signal has been received. */
837 static void
checksigs(void)838 checksigs (void)
839 {
840 int s = signal_received;
841 if (s)
842 {
843 cleanup (0);
844
845 /* Yield an exit status indicating that a signal was received. */
846 untrapsig (s);
847 kill (getpid (), s);
848
849 /* That didn't work, so exit with error status. */
850 exit (EXIT_TROUBLE);
851 }
852 }
853
854 static void
give_help(void)855 give_help (void)
856 {
857 fprintf (stderr, "%s", _("\
858 ed:\tEdit then use both versions, each decorated with a header.\n\
859 eb:\tEdit then use both versions.\n\
860 el or e1:\tEdit then use the left version.\n\
861 er or e2:\tEdit then use the right version.\n\
862 e:\tDiscard both versions then edit a new one.\n\
863 l or 1:\tUse the left version.\n\
864 r or 2:\tUse the right version.\n\
865 s:\tSilently include common lines.\n\
866 v:\tVerbosely include common lines.\n\
867 q:\tQuit.\n\
868 "));
869 }
870
871 static int
skip_white(void)872 skip_white (void)
873 {
874 int c;
875 for (;;)
876 {
877 c = getchar ();
878 if (! isspace (c) || c == '\n')
879 break;
880 checksigs ();
881 }
882 if (ferror (stdin))
883 perror_fatal (_("read failed"));
884 return c;
885 }
886
887 static void
flush_line(void)888 flush_line (void)
889 {
890 int c;
891 while ((c = getchar ()) != '\n' && c != EOF)
892 continue;
893 if (ferror (stdin))
894 perror_fatal (_("read failed"));
895 }
896
897
898 /* interpret an edit command */
899 static bool
edit(struct line_filter * left,char const * lname,lin lline,lin llen,struct line_filter * right,char const * rname,lin rline,lin rlen,FILE * outfile)900 edit (struct line_filter *left, char const *lname, lin lline, lin llen,
901 struct line_filter *right, char const *rname, lin rline, lin rlen,
902 FILE *outfile)
903 {
904 for (;;)
905 {
906 int cmd0, cmd1;
907 bool gotcmd = false;
908
909 cmd1 = 0; /* Pacify `gcc -W'. */
910
911 while (! gotcmd)
912 {
913 if (putchar ('%') != '%')
914 perror_fatal (_("write failed"));
915 ck_fflush (stdout);
916
917 cmd0 = skip_white ();
918 switch (cmd0)
919 {
920 case '1': case '2': case 'l': case 'r':
921 case 's': case 'v': case 'q':
922 if (skip_white () != '\n')
923 {
924 give_help ();
925 flush_line ();
926 continue;
927 }
928 gotcmd = true;
929 break;
930
931 case 'e':
932 cmd1 = skip_white ();
933 switch (cmd1)
934 {
935 case '1': case '2': case 'b': case 'd': case 'l': case 'r':
936 if (skip_white () != '\n')
937 {
938 give_help ();
939 flush_line ();
940 continue;
941 }
942 gotcmd = true;
943 break;
944 case '\n':
945 gotcmd = true;
946 break;
947 default:
948 give_help ();
949 flush_line ();
950 continue;
951 }
952 break;
953
954 case EOF:
955 if (feof (stdin))
956 {
957 gotcmd = true;
958 cmd0 = 'q';
959 break;
960 }
961 /* Fall through. */
962 default:
963 flush_line ();
964 /* Fall through. */
965 case '\n':
966 give_help ();
967 continue;
968 }
969 }
970
971 switch (cmd0)
972 {
973 case '1': case 'l':
974 lf_copy (left, llen, outfile);
975 lf_skip (right, rlen);
976 return true;
977 case '2': case 'r':
978 lf_copy (right, rlen, outfile);
979 lf_skip (left, llen);
980 return true;
981 case 's':
982 suppress_common_lines = true;
983 break;
984 case 'v':
985 suppress_common_lines = false;
986 break;
987 case 'q':
988 return false;
989 case 'e':
990 {
991 int fd;
992
993 if (tmpname)
994 tmp = fopen (tmpname, "w");
995 else
996 {
997 if ((fd = temporary_file ()) < 0)
998 perror_fatal ("mkstemp");
999 tmp = fdopen (fd, "w");
1000 }
1001
1002 if (! tmp)
1003 perror_fatal (tmpname);
1004
1005 switch (cmd1)
1006 {
1007 case 'd':
1008 if (llen)
1009 {
1010 if (llen == 1)
1011 fprintf (tmp, "--- %s %ld\n", lname, (long int) lline);
1012 else
1013 fprintf (tmp, "--- %s %ld,%ld\n", lname,
1014 (long int) lline,
1015 (long int) (lline + llen - 1));
1016 }
1017 /* Fall through. */
1018 case '1': case 'b': case 'l':
1019 lf_copy (left, llen, tmp);
1020 break;
1021
1022 default:
1023 lf_skip (left, llen);
1024 break;
1025 }
1026
1027 switch (cmd1)
1028 {
1029 case 'd':
1030 if (rlen)
1031 {
1032 if (rlen == 1)
1033 fprintf (tmp, "+++ %s %ld\n", rname, (long int) rline);
1034 else
1035 fprintf (tmp, "+++ %s %ld,%ld\n", rname,
1036 (long int) rline,
1037 (long int) (rline + rlen - 1));
1038 }
1039 /* Fall through. */
1040 case '2': case 'b': case 'r':
1041 lf_copy (right, rlen, tmp);
1042 break;
1043
1044 default:
1045 lf_skip (right, rlen);
1046 break;
1047 }
1048
1049 ck_fclose (tmp);
1050
1051 {
1052 int wstatus;
1053 int werrno = 0;
1054 ignore_SIGINT = true;
1055 checksigs ();
1056
1057 {
1058 #if ! (HAVE_WORKING_FORK || HAVE_WORKING_VFORK)
1059 char *command =
1060 xmalloc (quote_system_arg (0, editor_program)
1061 + 1 + strlen (tmpname) + 1);
1062 sprintf (command + quote_system_arg (command, editor_program),
1063 " %s", tmpname);
1064 wstatus = system (command);
1065 if (wstatus == -1)
1066 werrno = errno;
1067 free (command);
1068 #else
1069 pid_t pid;
1070
1071 pid = vfork ();
1072 if (pid == 0)
1073 {
1074 char const *argv[3];
1075 int i = 0;
1076
1077 argv[i++] = editor_program;
1078 argv[i++] = tmpname;
1079 argv[i] = 0;
1080
1081 execvp (editor_program, (char **) argv);
1082 _exit (errno == ENOENT ? 127 : 126);
1083 }
1084
1085 if (pid < 0)
1086 perror_fatal ("fork");
1087
1088 while (waitpid (pid, &wstatus, 0) < 0)
1089 if (errno == EINTR)
1090 checksigs ();
1091 else
1092 perror_fatal ("waitpid");
1093 #endif
1094 }
1095
1096 ignore_SIGINT = false;
1097 check_child_status (werrno, wstatus, EXIT_SUCCESS,
1098 editor_program);
1099 }
1100
1101 {
1102 char buf[SDIFF_BUFSIZE];
1103 size_t size;
1104 tmp = ck_fopen (tmpname, "r");
1105 while ((size = ck_fread (buf, SDIFF_BUFSIZE, tmp)) != 0)
1106 {
1107 checksigs ();
1108 ck_fwrite (buf, size, outfile);
1109 }
1110 ck_fclose (tmp);
1111 }
1112 return true;
1113 }
1114 default:
1115 give_help ();
1116 break;
1117 }
1118 }
1119 }
1120
1121 /* Alternately reveal bursts of diff output and handle user commands. */
1122 static bool
interact(struct line_filter * diff,struct line_filter * left,char const * lname,struct line_filter * right,char const * rname,FILE * outfile)1123 interact (struct line_filter *diff,
1124 struct line_filter *left, char const *lname,
1125 struct line_filter *right, char const *rname,
1126 FILE *outfile)
1127 {
1128 lin lline = 1, rline = 1;
1129
1130 for (;;)
1131 {
1132 char diff_help[256];
1133 int snarfed = lf_snarf (diff, diff_help, sizeof diff_help);
1134
1135 if (snarfed <= 0)
1136 return snarfed != 0;
1137
1138 checksigs ();
1139
1140 if (diff_help[0] == ' ')
1141 puts (diff_help + 1);
1142 else
1143 {
1144 char *numend;
1145 uintmax_t val;
1146 lin llen, rlen, lenmax;
1147 errno = 0;
1148 llen = val = strtoumax (diff_help + 1, &numend, 10);
1149 if (llen < 0 || llen != val || errno || *numend != ',')
1150 fatal (diff_help);
1151 rlen = val = strtoumax (numend + 1, &numend, 10);
1152 if (rlen < 0 || rlen != val || errno || *numend)
1153 fatal (diff_help);
1154
1155 lenmax = MAX (llen, rlen);
1156
1157 switch (diff_help[0])
1158 {
1159 case 'i':
1160 if (suppress_common_lines)
1161 lf_skip (diff, lenmax);
1162 else
1163 lf_copy (diff, lenmax, stdout);
1164
1165 lf_copy (left, llen, outfile);
1166 lf_skip (right, rlen);
1167 break;
1168
1169 case 'c':
1170 lf_copy (diff, lenmax, stdout);
1171 if (! edit (left, lname, lline, llen,
1172 right, rname, rline, rlen,
1173 outfile))
1174 return false;
1175 break;
1176
1177 default:
1178 fatal (diff_help);
1179 }
1180
1181 lline += llen;
1182 rline += rlen;
1183 }
1184 }
1185 }
1186
1187 /* Return true if DIR is an existing directory. */
1188 static bool
diraccess(char const * dir)1189 diraccess (char const *dir)
1190 {
1191 struct stat buf;
1192 return stat (dir, &buf) == 0 && S_ISDIR (buf.st_mode);
1193 }
1194
1195 #ifndef P_tmpdir
1196 # define P_tmpdir "/tmp"
1197 #endif
1198 #ifndef TMPDIR_ENV
1199 # define TMPDIR_ENV "TMPDIR"
1200 #endif
1201
1202 /* Open a temporary file and return its file descriptor. Put into
1203 tmpname the address of a newly allocated buffer that holds the
1204 file's name. Use the prefix "sdiff". */
1205 static int
temporary_file(void)1206 temporary_file (void)
1207 {
1208 char const *tmpdir = getenv (TMPDIR_ENV);
1209 char const *dir = tmpdir ? tmpdir : P_tmpdir;
1210 char *buf = xmalloc (strlen (dir) + 1 + 5 + 6 + 1);
1211 int fd;
1212 int e;
1213 sigset_t procmask;
1214 sigset_t blocked;
1215 sprintf (buf, "%s/sdiffXXXXXX", dir);
1216 sigemptyset (&blocked);
1217 sigaddset (&blocked, SIGINT);
1218 sigprocmask (SIG_BLOCK, &blocked, &procmask);
1219 fd = mkstemp (buf);
1220 e = errno;
1221 if (0 <= fd)
1222 tmpname = buf;
1223 sigprocmask (SIG_SETMASK, &procmask, 0);
1224 errno = e;
1225 return fd;
1226 }
1227