source: trunk/minix/commands/simple/diff.c@ 10

Last change on this file since 10 was 9, checked in by Mattia Monga, 13 years ago

Minix 3.1.2a

File size: 30.5 KB
Line 
1/* diff - print differences between 2 files Author: Erik Baalbergen */
2
3/* Poor man's implementation of diff(1) - no options available
4* - may give more output than other diffs,
5* due to the straight-forward algorithm
6* - runs out of memory if the differing chunks become too large
7* - input line length should not exceed LINELEN; longer lines are
8* truncated, while only the first LINELEN characters are compared
9*
10* - Bug fixes by Rick Thomas Sept. 1989
11*
12* Please report bugs and suggestions to erikb@cs.vu.nl
13*------------------------------------------------------------------------------
14* Changed diff to conform to POSIX 1003.2 ( Draft 11) by Thomas Brupbacher
15* ( tobr@mw.lpc.ethz.ch).
16*
17* To incorporate the context diff option -c in the program, the source code
18* for the program cdiff has been copied to the end of this program. Only
19* slight modifications for the cdiff code to work within the program diff
20* were made( e.g. main() -> context_diff()).
21*
22* New options:
23* -c, -C n where n=0,1,...:
24* produces a context diff as the program cdiff. The default is to
25* print 3 lines of context, this value can be changed with -C
26* ( e.g. -C 5 prints five lines of context.)
27* -e : Prints an ed script, so you can convert <file1> to <file2> with
28* the command ed <file1> < `diff -e <file1> <file2>`.
29* -b : Causes trailing blanks to be ignored and spaces of multiple blanks
30* to be reduced to one blank before comparison.
31*-----------------------------------------------------------------------------
32*/
33
34#include <errno.h>
35#include <stdlib.h>
36#include <limits.h> /* NAME_MAX for maximal filename length */
37#include <string.h> /* string manipulation */
38#include <sys/types.h>
39#include <sys/stat.h>
40#include <sys/wait.h>
41#include <ctype.h>
42#include <time.h>
43#include <dirent.h>
44#include <unistd.h>
45#include <stdio.h>
46
47/* These definitions are needed only to suppress warning messages. */
48#define Nullfp ((FILE*)0)
49#define Nullch ((char*)0)
50#define NullStructLine ((struct line *)0)
51
52#define LINELEN 128 /* max line length included in diff */
53
54
55#define NOT_SET 0 /* Defines to characterise if a flag */
56#define SET 1 /* is set */
57
58 /* Indexes of the warning-message array */
59#define EXCLUSIVE_OPTIONS 0
60#define CANNOT_OPEN_FILE 1
61
62 /* Used to define the mode */
63typedef enum {
64 undefined, context, ed_mode
65} MODE;
66
67 /* Global variables for the 'normal' diff part */
68char *progname; /* program name (on command line) */
69int diffs = 0; /* number of differences */
70MODE mode; /* which mode is used */
71int severe_error; /* nonzero after severe, non-fatal error */
72
73/* The following global variables are used with the -r option:
74 * for every pair of files that are different, a "command line" of the
75 * form "diff <options> <oldfile> <newfile>" is printed before the real
76 * output starts. */
77int firstoutput = 1; /* flag to print one time */
78char options_string[10]; /* string to hold command line options */
79char oldfile[PATH_MAX]; /* first file */
80char newfile[PATH_MAX]; /* second file */
81
82
83 /* Global variables for the command-line options */
84int trim_blanks = NOT_SET; /* SET if -b specified */
85int recursive_dir = NOT_SET; /* SET if -r specified */
86int context_lines = 3; /* numbers of lines in a context */
87static int offset; /* offset of the actual line number for -e */
88
89 /* Function prototypes for the functions in this file */
90struct f;
91_PROTOTYPE(int main, (int argc, char **argv ));
92_PROTOTYPE(void process_command_line, (int argc, char **argv ));
93_PROTOTYPE(void analyse_input_files, (char *arg1, char *arg2, char *input1,
94 char *input2 ));
95_PROTOTYPE(void diff, (char *filename1, char *filename2 ));
96_PROTOTYPE(FILE *check_file, (char *name ));
97_PROTOTYPE(void build_option_string, (void ));
98_PROTOTYPE(void fatal_error, (char *fmt, char *s ));
99_PROTOTYPE(void warn, (int number, char *string ));
100_PROTOTYPE(void trimming_blanks, (char *l_text ));
101_PROTOTYPE(char *filename, (char *path_string));
102_PROTOTYPE(struct line *new_line, (int size ));
103_PROTOTYPE(void free_line, (struct line *l ));
104_PROTOTYPE(int equal_line, (struct line *l1, struct line *l2 ));
105_PROTOTYPE(int equal_3, (struct line *l1, struct line *l2 ));
106_PROTOTYPE(struct line *read_line, (FILE *fp ));
107_PROTOTYPE(void advance, (struct f *f ));
108_PROTOTYPE(void aside, (struct f *f, struct line *l ));
109_PROTOTYPE(struct line *next, (struct f *f ));
110_PROTOTYPE(void init_f, (struct f *f, FILE *fp ));
111_PROTOTYPE(void update, (struct f *f, char *s ));
112_PROTOTYPE(void __diff, (FILE *fp1, FILE *fp2 ));
113_PROTOTYPE(void differ, (struct f *f1, struct f *f2 ));
114_PROTOTYPE(int wlen, (struct f *f ));
115_PROTOTYPE(void range, (int a, int b ));
116_PROTOTYPE(void cdiff, (char *old, char *new, FILE *file1, FILE *file2 ));
117_PROTOTYPE(void dumphunk, (void ));
118_PROTOTYPE(char *getold, (int targ ));
119_PROTOTYPE(char *getnew, (int targ ));
120_PROTOTYPE(int isdir, (char *path ));
121_PROTOTYPE(void diff_recursive, (char *dir1, char *dir2 ));
122_PROTOTYPE(void file_type_error, (char *filename1, char *filename2,
123 struct stat *statbuf1, struct stat *statbuf2 ));
124_PROTOTYPE(void *xmalloc, (size_t size));
125_PROTOTYPE(void *xrealloc, (void *ptr, size_t size));
126
127int main(argc, argv)
128int argc;
129char **argv;
130{
131 char file1[PATH_MAX], file2[PATH_MAX];
132 extern int optind; /* index of the current string in argv */
133
134 progname = argv[0];
135 process_command_line(argc, argv);
136
137 analyse_input_files(argv[optind], argv[optind + 1], file1, file2);
138 optind++;
139
140 if (recursive_dir == SET) {
141 build_option_string();
142 diff_recursive(file1, file2);
143 } else {
144 diff(file1, file2);
145 }
146
147 return(severe_error ? 2 : diffs > 0 ? 1 : 0);
148}
149
150/* Process the command line and set the flags for the different
151 * options. the processing of the command line is done with the
152 * getopt() library function. a minimal error processing is done
153 * for the number of command line arguments. */
154void process_command_line(argc, argv)
155int argc; /* number of arguments on command line */
156char **argv; /* ** to arguments on command line */
157{
158 int c;
159 extern char *optarg; /* points to string with options */
160 extern int optind; /* index of the current string in argv */
161
162 /* Are there enough arguments? */
163 if (argc < 3) {
164 fatal_error("Usage: %s [-c|-e|-C n][-br] file1 file2\n", progname);
165 }
166
167 /* Process all options using getopt() */
168 while ((c = getopt(argc, argv, "ceC:br")) != -1) {
169 switch (c) {
170 case 'c':
171 if (mode != undefined) warn(EXCLUSIVE_OPTIONS, "c");
172 mode = context;
173 context_lines = 3;
174 break;
175 case 'e':
176 if (mode != undefined) warn(EXCLUSIVE_OPTIONS, "e");
177 mode = ed_mode;
178 break;
179 case 'C':
180 if (mode != undefined) warn(EXCLUSIVE_OPTIONS, "C");
181 mode = context;
182 context_lines = atoi(optarg);
183 break;
184 case 'b': trim_blanks = SET; break;
185 case 'r': recursive_dir = SET; break;
186 case '?':
187 exit(2);
188 }
189 }
190
191 /* We should have two arguments left */
192 if ((argc - optind) != 2)
193 fatal_error("Need exactly two input file-names!\n", "");
194}
195
196/* Analyse_input_files takes the two input files on the command line
197 * and decides what to do. returns the (corrected) filenames that
198 * can be used to call diff().
199 * if two directories are given, then a recursive diff is done.
200 * one directory and one filename compares the file with <filename>
201 * in the directory <directory> with <filename>.
202 * if two filenames are specified, no special action takes place.
203 */
204void analyse_input_files(arg1, arg2, input1, input2)
205char *arg1, *arg2; /* filenames on the command line */
206char *input1, *input2; /* filenames to be used with diff() */
207{
208 int stat1 = 0, stat2 = 0;
209
210 if (strcmp(arg1, "-") != 0)
211 stat1 = isdir(arg1); /* != 0 <-> arg1 is directory */
212 if (strcmp(arg2, "-") != 0) stat2 = isdir(arg2);
213#ifdef DEBUG
214 fprintf(stderr, "%s, stat = %d\n", arg1, stat1);
215 fprintf(stderr, "%s, stat = %d\n", arg2, stat2);
216#endif
217 if (stat1 && stat2) { /* both arg1 and arg2 are directories */
218 recursive_dir = SET;
219 strcpy(input1, arg1);
220 strcpy(input2, arg2);
221 return;
222 }
223 if (stat1 != 0) { /* arg1 is a dir, arg2 not */
224 if (strcmp(arg2, "-") != 0) { /* arg2 != stdin */
225 strcpy(input1, arg1);
226 strcat(input1, "/");
227 strcat(input1, arg2);
228 strcpy(input2, arg2);
229 return;
230 } else {
231 fatal_error("cannot compare stdin (-) with a directory!", "");
232 }
233 }
234 if (stat2 != 0) { /* arg2 is a dir, arg1 not */
235 if (strcmp(arg1, "-") != 0) { /* arg1 != stdin */
236 strcpy(input1, arg1);
237 strcpy(input2, arg2);
238 strcat(input2, "/");
239 strcat(input2, arg1);
240 return;
241 } else { /* arg1 == stdin */
242 fatal_error("cannot compare stdin (-) with a directory!", "");
243 }
244 }
245
246 /* Both arg1 and arg2 are normal files */
247 strcpy(input1, arg1);
248 strcpy(input2, arg2);
249}
250
251/* Diff() is the front end for all modes of the program diff, execpt
252 * the recursive_dir option.
253 * diff() expects the filenames of the two files to be compared as
254 * arguments. the mode is determined from the global variable mode.
255 */
256void diff(filename1, filename2)
257char *filename1, *filename2;
258{
259 FILE *file1 = check_file(filename1);
260 FILE *file2 = check_file(filename2);
261 struct stat statbuf1, statbuf2;
262
263 if ((file1 != Nullfp) && (file2 != Nullfp)) {
264 /* If we do a recursive diff, then we don't compare block
265 * special, character special or FIFO special files to any
266 * file. */
267 fstat(fileno(file1), &statbuf1);
268 fstat(fileno(file2), &statbuf2);
269 if ((((statbuf1.st_mode & S_IFREG) != S_IFREG) ||
270 ((statbuf2.st_mode & S_IFREG) != S_IFREG)) &&
271 (recursive_dir == SET)) {
272 file_type_error(filename1, filename2, &statbuf1, &statbuf2);
273 } else {
274 switch (mode) {
275 case context:
276 cdiff(filename1, filename2, file1, file2);
277 break;
278 case ed_mode:
279 case undefined:
280 __diff(file1, file2);
281 if (mode == ed_mode) printf("w\n");
282 break;
283 }
284 }
285 } else
286 severe_error = 1;
287 if (file1 != Nullfp) fclose(file1);
288 if (file2 != Nullfp) fclose(file2);
289}
290
291/* Check_file() opens the fileptr with name <filename>. if <filename>
292 * equals "-" stdin is associated with the return value.
293 */
294FILE *check_file(name)
295char *name;
296{
297 FILE *temp;
298
299 if (strcmp(name, "-") == 0) {
300 return(stdin);
301 } else {
302 temp = fopen(name, "r");
303 if (temp == Nullfp) warn(CANNOT_OPEN_FILE, name);
304 return(temp);
305 }
306}
307
308/* Build_option_string() is called before recursive_dir() is called
309 * from the main() function. its purpose is to build the string that
310 * is used on the command line to get the current operation mode.
311 * e.g. "-C 6 -b".
312 */
313void build_option_string()
314{
315 switch (mode) {
316 case ed_mode:sprintf(options_string, "-e");
317 break;
318 case context:
319 if (context_lines == 3)
320 sprintf(options_string, "-c");
321 else
322 sprintf(options_string, "-C %d", context_lines);
323 break;
324 }
325
326}
327
328
329/* The fatal error handler.
330 * Expects a format string and a string as arguments. The arguments
331 * are printed to stderr and the program exits with an error code 2.
332 */
333void fatal_error(fmt, s)
334char *fmt; /* the format sttring to be printed */
335char *s; /* string to be inserted into the format
336 * string */
337{
338 fprintf(stderr, "%s: ", progname);
339 fprintf(stderr, fmt, s);
340 fprintf(stderr, "\n");
341 exit(2);
342}
343
344/* This function prints non fatal error messages to stderr.
345 * Expects the index of the message to be printed and a pointer
346 * to the (optional) string to be printed.
347 * Returns no value.
348 */
349void warn(number, string)
350int number; /* index of the warning */
351char *string; /* string to be inserted to the warning */
352{
353 static char *warning[] = {
354 "%s: The options -c, -e, -C n are mutually exclusive! Assuming -%c\n",
355 "%s: cannot open file %s for reading\n",
356 };
357 fprintf(stderr, warning[number], progname, string);
358}
359
360/* Function used with the optione -b, trims the blanks in a input line:
361 * - blanks between words are reduced to one
362 * - trailing blanks are eliminated.
363 */
364void trimming_blanks(l_text)
365char *l_text; /* begin of the char array */
366{
367 char *line = l_text;
368 char *copy_to, *copy_from;
369
370 do {
371 if (*line == ' ') {
372 copy_from = line;
373 copy_to = line;
374 while (*(++copy_from) == ' ');
375 if (*copy_from != '\n') copy_to++;
376 while (*copy_from != '\0') *(copy_to++) = *(copy_from++);
377 *copy_to = '\0';
378 }
379 } while (*(++line) != '\0');
380}
381
382
383/* Filename separates the filename and the relative path in path_string.
384 * Returns the filename with a leading /
385 */
386char *filename(path_string)
387char *path_string;
388{
389 char name[NAME_MAX + 2]; /* filename plus / */
390 char *ptr;
391
392 name[0] = '/';
393 ptr = strrchr(path_string, '/');
394
395 if (ptr == 0) { /* no / in path_string, only a filename */
396 strcat(name, path_string);
397 } else {
398 strcat(name, ptr);
399 }
400
401 return(name);
402}
403
404/* The line module: one member in a linked list of lines. */
405struct line {
406 struct line *l_next; /* pointer to the next line */
407 char l_eof; /* == 0 if last line in file */
408 char *l_text; /* array with the text */
409};
410
411struct line *freelist = 0;
412#define stepup(ll) ( ((ll) && ((ll)->l_eof==0)) ? (ll)->l_next : (ll) )
413
414/* Function to allocate space for a new line containing SIZE chars */
415struct line *new_line(size)
416int size;
417{
418 register struct line *l;
419
420 if ((l = freelist) != NullStructLine)
421 freelist = freelist->l_next;
422 else {
423 l = (struct line *) xmalloc(3 * sizeof(void *));
424 l->l_text = (char *) xmalloc((size + 2) * sizeof(char));
425 if ((l == 0) || (l->l_text == 0)) fatal_error("Out of memory", "");
426 }
427 return l;
428}
429
430
431/* Free_line() releases storage allocated for <l>. */
432void free_line(l)
433register struct line *l;
434{
435 l->l_next = freelist;
436 freelist = l;
437}
438
439/* Equal_line() compares two lines, <l1> and <l2>.
440 * the returned value is the result of the strcmp() function.
441 */
442int equal_line(l1, l2)
443struct line *l1, *l2;
444{
445 if (l1 == 0 || l2 == 0)
446 return(0);
447 else if (l1->l_eof || l2->l_eof)
448 return(l1->l_eof == l2->l_eof);
449 else
450 return(strcmp(l1->l_text, l2->l_text) == 0);
451}
452
453int equal_3(l1, l2)
454struct line *l1, *l2;
455{
456 register int i, ansr;
457
458 ansr = 1;
459#ifdef DEBUG
460 if (l1 == 0)
461 fprintf(stderr, "\t(null)\n");
462 else if (l1->l_eof)
463 fprintf(stderr, "\t(eof)\n");
464 else
465 fprintf(stderr, "\t%s", l1->l_text);
466 if (l2 == 0)
467 fprintf(stderr, "\t(null)\n");
468 else if (l2->l_eof)
469 fprintf(stderr, "\t(eof)\n");
470 else
471 fprintf(stderr, "\t%s", l2->l_text);
472#endif
473 for (i = 0; i < 3; ++i) {
474 if (!equal_line(l1, l2)) {
475 ansr = 0;
476 break;
477 }
478 l1 = stepup(l1);
479 l2 = stepup(l2);
480 }
481#ifdef DEBUG
482 fprintf(stderr, "\t%d\n", ansr);
483#endif
484 return(ansr);
485}
486
487struct line *
488 read_line(fp)
489FILE *fp;
490{
491 register struct line *l = new_line(LINELEN);
492 register char *p;
493 register int c;
494
495 (p = &(l->l_text[LINELEN]))[1] = '\377';
496 l->l_eof = 0;
497 if (fgets(l->l_text, LINELEN + 2, fp) == 0) {
498 l->l_eof = 1;
499 l->l_text[0] = 0;
500 } else if ((p[1] & 0377) != 0377 && *p != '\n') {
501 while ((c = fgetc(fp)) != '\n' && c != EOF) {
502 }
503 *p++ = '\n';
504 *p = '\0';
505 }
506 l->l_next = 0;
507 if (trim_blanks == SET) {
508#ifdef DEBUG
509 printf("xxx %s xxx\n", l->l_text);
510#endif
511 trimming_blanks(l->l_text);
512#ifdef DEBUG
513 printf("xxx %s xxx\n", l->l_text);
514#endif
515 }
516 return l;
517}
518
519/* File window handler */
520struct f {
521 struct line *f_bwin, *f_ewin;
522 struct line *f_aside;
523 int f_linecnt; /* line number in file of last advanced line */
524 FILE *f_fp;
525};
526
527void advance(f)
528register struct f *f;
529{
530 register struct line *l;
531
532 if ((l = f->f_bwin) != NullStructLine) {
533 if (f->f_ewin == l)
534 f->f_bwin = f->f_ewin = 0;
535 else
536 f->f_bwin = l->l_next;
537 free_line(l);
538 (f->f_linecnt)++;
539 }
540}
541
542void aside(f, l)
543struct f *f;
544struct line *l;
545{
546 register struct line *ll;
547
548 if (l == 0) return;
549 if ((ll = l->l_next) != NullStructLine) {
550 while (ll->l_next) ll = ll->l_next;
551 ll->l_next = f->f_aside;
552 f->f_aside = l->l_next;
553 l->l_next = 0;
554 f->f_ewin = l;
555 }
556}
557
558
559struct line *next(f)
560register struct f *f;
561{
562 register struct line *l;
563
564 if ((l = f->f_aside) != NullStructLine) {
565 f->f_aside = l->l_next;
566 l->l_next = 0;
567 } else
568 l = read_line(f->f_fp);
569 if (l) {
570 if (f->f_bwin == 0)
571 f->f_bwin = f->f_ewin = l;
572 else {
573 if (f->f_ewin->l_eof && l->l_eof) {
574 free_line(l);
575 return(f->f_ewin);
576 }
577 f->f_ewin->l_next = l;
578 f->f_ewin = l;
579 }
580 }
581 return l;
582}
583
584
585/* Init_f() initialises a window structure (struct f). <fp> is the
586 * file associated with <f>.
587 */
588void init_f(f, fp)
589register struct f *f;
590FILE *fp;
591{
592 f->f_bwin = f->f_ewin = f->f_aside = 0;
593 f->f_linecnt = 0;
594 f->f_fp = fp;
595}
596
597
598/* Update() prints a window. <f> is a pointer to the window, <s> is the
599 * string containing the "prefix" to the printout( either "<" or ">").
600 * after completion of update(), the window is empty.
601 */
602void update(f, s)
603register struct f *f;
604char *s;
605{
606 char *help;
607 int only_dot = 0;
608
609 if (firstoutput && (recursive_dir == SET)) {
610 printf("diff %s %s %s\n", options_string, oldfile, newfile);
611 firstoutput = 0;
612 }
613 while (f->f_bwin && f->f_bwin != f->f_ewin) {
614 if (mode != ed_mode) {
615 printf("%s%s", s, f->f_bwin->l_text);
616 } else {
617#ifdef DEBUG
618 printf("ed_mode: test for only dot");
619 printf("%s", f->f_bwin->l_text);
620#endif
621 help = f->f_bwin->l_text;
622 while ((*help == ' ') ||
623 (*help == '.') ||
624 (*help == '\t')) {
625 if (*(help++) == '.') only_dot++;
626 if (only_dot > 1) break;
627 }
628
629 /* If only_dot is equal 1, there is only one dot on
630 * the line, so we have to take special actions.
631 * f the line with only one dot is found, we output
632 * two dots (".."), terminate the append modus and
633 * substitute "." for "..". Afterwards we restart
634 * with the append command. */
635 if (*help == '\n' && only_dot == 1) {
636 help = f->f_bwin->l_text;
637 while (*help != '\0') {
638 if (*help == '.') printf(".");
639 putchar((int) *(help++));
640 }
641 printf(".\n");
642 printf(".s/\\.\\././\n");
643 printf("a\n");
644 } else {
645 printf("%s%s", s, f->f_bwin->l_text);
646 }
647 }
648 advance(f);
649 }
650}
651
652/* __Diff(), performs the "core operation" of the program.
653 * Expects two file-pointers as arguments. This functions does
654 * *not* check if the file-pointers are valid.
655 */
656
657void __diff(fp1, fp2)
658FILE *fp1, *fp2;
659{
660 struct f f1, f2;
661 struct line *l1, *s1, *b1, *l2, *s2, *b2;
662 register struct line *ll;
663
664 init_f(&f1, fp1);
665 init_f(&f2, fp2);
666 l1 = next(&f1);
667 l2 = next(&f2);
668 while ((l1->l_eof == 0) || (l2->l_eof == 0)) {
669 if (equal_line(l1, l2)) {
670 equal:
671 advance(&f1);
672 advance(&f2);
673 l1 = next(&f1);
674 l2 = next(&f2);
675 continue;
676 }
677 s1 = b1 = l1;
678 s2 = b2 = l2;
679 /* Read several more lines */
680 next(&f1);
681 next(&f1);
682 next(&f2);
683 next(&f2);
684 /* Start searching */
685search:
686 next(&f2);
687 ll = s1;
688 do {
689 if (equal_3(ll, b2)) {
690 l1 = ll;
691 l2 = b2;
692 aside(&f1, ll);
693 aside(&f2, b2);
694 differ(&f1, &f2);
695 goto equal;
696 }
697 if (ll->l_eof) break;
698 ll = stepup(ll);
699 } while (ll);
700 b2 = stepup(b2);
701
702 next(&f1);
703 ll = s2;
704 do {
705 if (equal_3(b1, ll)) {
706 l1 = b1;
707 l2 = ll;
708 aside(&f2, ll);
709 aside(&f1, b1);
710 differ(&f1, &f2);
711 goto equal;
712 }
713 if (ll->l_eof != 0) break;
714 ll = stepup(ll);
715 } while (ll);
716 b1 = stepup(b1);
717
718 goto search;
719 }
720
721 /* Both of the files reached EOF */
722}
723
724/* Differ() prints the differences between files. the arguments <f1> and
725 * <f2> are pointers to the two windows, where the differences are.
726 */
727void differ(f1, f2)
728register struct f *f1, *f2;
729{
730 int cnt1 = f1->f_linecnt, len1 = wlen(f1);
731 int cnt2 = f2->f_linecnt, len2 = wlen(f2);
732 if ((len1 != 0) || (len2 != 0)) {
733 if (len1 == 0) {
734 if (mode == ed_mode) {
735 cnt1 += offset;
736 printf("%d a\n", cnt1);
737 update(f2, "");
738 printf(".\n");
739 offset += len2;
740 } else {
741 printf("%da", cnt1);
742 range(cnt2 + 1, cnt2 + len2);
743 }
744 } else if (len2 == 0) {
745 if (mode == ed_mode) {
746 cnt1 += offset;
747 range(cnt1 + 1, cnt1 + len1);
748 printf("d\n");
749 offset -= len1;
750 while (f1->f_bwin && f1->f_bwin != f1->f_ewin)
751 advance(f1);
752 } else {
753 range(cnt1 + 1, cnt1 + len1);
754 printf("d%d", cnt2);
755 }
756 } else {
757 if (mode != ed_mode) {
758 range(cnt1 + 1, cnt1 + len1);
759 putchar('c');
760 range(cnt2 + 1, cnt2 + len2);
761 } else {
762 cnt1 += offset;
763 if (len1 == len2) {
764 range(cnt1 + 1, cnt1 + len1);
765 printf("c\n");
766 update(f2, "");
767 printf(".\n");
768 } else {
769 range(cnt1 + 1, cnt1 + len1);
770 printf("d\n");
771 printf("%d a\n", cnt1);
772 update(f2, "");
773 printf(".\n");
774 offset -= len1 - len2;
775 }
776 while (f1->f_bwin && f1->f_bwin != f1->f_ewin)
777 advance(f1);
778 }
779 }
780 if (mode != ed_mode) {
781 putchar('\n');
782 if (len1 != 0) update(f1, "< ");
783 if ((len1 != 0) && (len2 != 0)) printf("---\n");
784 if (len2 != 0) update(f2, "> ");
785 }
786 diffs++;
787 }
788}
789
790
791/* Function wlen() calculates the number of lines in a window. */
792int wlen(f)
793struct f *f;
794{
795 register cnt = 0;
796 register struct line *l = f->f_bwin, *e = f->f_ewin;
797
798 while (l && l != e) {
799 cnt++;
800 l = l->l_next;
801 }
802 return cnt;
803}
804
805
806/* Range() prints the line numbers of a range. the arguments <a> and <b>
807 * are the beginning and the ending line number of the range. if
808 * <a> == <b>, only one line number is printed. otherwise <a> and <b> are
809 * separated by a ",".
810 */
811void range(a, b)
812int a, b;
813{
814 printf(((a == b) ? "%d" : "%d,%d"), a, b);
815}
816
817/* Here follows the code for option -c.
818 * This code is from the cdiff program by Larry Wall. I changed it only
819 * slightly to reflect the POSIX standard and to call the main routine
820 * as function context_diff().
821 */
822
823/* Cdiff - context diff Author: Larry Wall */
824
825/* These global variables are still here from the original cdiff program...
826 * I was to lazy just to sort them out...
827 */
828char buff[512];
829FILE *oldfp, *newfp;
830
831int oldmin, oldmax, newmin, newmax;
832int oldbeg, oldend, newbeg, newend;
833int preoldmax, prenewmax;
834int preoldbeg, preoldend, prenewbeg, prenewend;
835int oldwanted, newwanted;
836
837char *oldhunk, *newhunk;
838size_t oldsize, oldalloc, newsize, newalloc;
839
840int oldline, newline; /* Jose */
841
842void cdiff(old, new, file1, file2)
843char *old, *new; /* The names of the two files to be compared */
844FILE *file1, *file2; /* The corresponding file-pointers */
845{
846 FILE *inputfp;
847 struct stat statbuf;
848 register char *s;
849 char op;
850 char *newmark, *oldmark;
851 int len;
852 char *line;
853 int i, status;
854
855 oldfp = file1;
856 newfp = file2;
857
858 oldalloc = 512;
859 oldhunk = (char *) xmalloc(oldalloc);
860 newalloc = 512;
861 newhunk = (char *) xmalloc(newalloc);
862
863
864/* The context diff spawns a new process that executes a normal diff
865 * and parses the output.
866 */
867 if (trim_blanks == SET)
868 sprintf(buff, "diff -b %s %s", old, new);
869 else
870 sprintf(buff, "diff %s %s", old, new);
871
872 inputfp = popen(buff, "r");
873 if (!inputfp) {
874 fprintf(stderr, "Can't execute diff %s %s, popen failed with %s\n",
875 old, new, strerror(errno));
876 exit(2);
877 }
878 preoldend = -1000;
879 firstoutput = 1;
880 oldline = newline = 0;
881 while (fgets(buff, sizeof buff, inputfp) != Nullch) {
882 if (firstoutput) {
883 if (recursive_dir == SET) {
884 printf("diff %s %s %s\n", options_string,
885 oldfile, newfile);
886 }
887 fstat(fileno(oldfp), &statbuf);
888 printf("*** %s %s", old, ctime(&statbuf.st_mtime));
889 fstat(fileno(newfp), &statbuf);
890 printf("--- %s %s", new, ctime(&statbuf.st_mtime));
891 firstoutput = 0;
892 }
893 if (isdigit(*buff)) {
894 oldmin = atoi(buff);
895 for (s = buff; isdigit(*s); s++);
896 if (*s == ',') {
897 s++;
898 oldmax = atoi(s);
899 for (; isdigit(*s); s++);
900 } else {
901 oldmax = oldmin;
902 }
903 if (*s != 'a' && *s != 'd' && *s != 'c') {
904 fprintf(stderr, "Unparseable input: %s", s);
905 exit(2);
906 }
907 op = *s;
908 s++;
909 newmin = atoi(s);
910 for (; isdigit(*s); s++);
911 if (*s == ',') {
912 s++;
913 newmax = atoi(s);
914 for (; isdigit(*s); s++);
915 } else {
916 newmax = newmin;
917 }
918 if (*s != '\n' && *s != ' ') {
919 fprintf(stderr, "Unparseable input: %s", s);
920 exit(2);
921 }
922 newmark = oldmark = "! ";
923 if (op == 'a') {
924 oldmin++;
925 newmark = "+ ";
926 }
927 if (op == 'd') {
928 newmin++;
929 oldmark = "- ";
930 }
931 oldbeg = oldmin - context_lines;
932 oldend = oldmax + context_lines;
933 if (oldbeg < 1) oldbeg = 1;
934 newbeg = newmin - context_lines;
935 newend = newmax + context_lines;
936 if (newbeg < 1) newbeg = 1;
937
938 if (preoldend < oldbeg - 1) {
939 if (preoldend >= 0) {
940 dumphunk();
941 }
942 preoldbeg = oldbeg;
943 prenewbeg = newbeg;
944 oldwanted = newwanted = 0;
945 oldsize = newsize = 0;
946 } else { /* we want to append to previous hunk */
947 oldbeg = preoldmax + 1;
948 newbeg = prenewmax + 1;
949 }
950
951 for (i = oldbeg; i <= oldmax; i++) {
952 line = getold(i);
953 if (!line) {
954 oldend = oldmax = i - 1;
955 break;
956 }
957 len = strlen(line) + 2;
958 if (oldsize + len + 1 >= oldalloc) {
959 oldalloc *= 2;
960 oldhunk = (char *) xrealloc(oldhunk, oldalloc);
961 }
962 if (i >= oldmin) {
963 strcpy(oldhunk + oldsize, oldmark);
964 oldwanted++;
965 } else {
966 strcpy(oldhunk + oldsize, " ");
967 }
968 strcpy(oldhunk + oldsize + 2, line);
969 oldsize += len;
970 }
971 preoldmax = oldmax;
972 preoldend = oldend;
973
974 for (i = newbeg; i <= newmax; i++) {
975 line = getnew(i);
976 if (!line) {
977 newend = newmax = i - 1;
978 break;
979 }
980 len = strlen(line) + 2;
981 if (newsize + len + 1 >= newalloc) {
982 newalloc *= 2;
983 newhunk = (char *) xrealloc(newhunk, newalloc);
984 }
985 if (i >= newmin) {
986 strcpy(newhunk + newsize, newmark);
987 newwanted++;
988 } else {
989 strcpy(newhunk + newsize, " ");
990 }
991 strcpy(newhunk + newsize + 2, line);
992 newsize += len;
993 }
994 prenewmax = newmax;
995 prenewend = newend;
996 }
997 }
998 status = pclose(inputfp);
999 if (status != 0) diffs++;
1000 if (!WIFEXITED(status) || WEXITSTATUS(status) > 1) severe_error = 1;
1001
1002 if (preoldend >= 0) {
1003 dumphunk();
1004 }
1005}
1006
1007void dumphunk()
1008{
1009 int i;
1010 char *line;
1011 int len;
1012
1013 for (i = preoldmax + 1; i <= preoldend; i++) {
1014 line = getold(i);
1015 if (!line) {
1016 preoldend = i - 1;
1017 break;
1018 }
1019 len = strlen(line) + 2;
1020 if (oldsize + len + 1 >= oldalloc) {
1021 oldalloc *= 2;
1022 oldhunk = (char *) xrealloc(oldhunk, oldalloc);
1023 }
1024 strcpy(oldhunk + oldsize, " ");
1025 strcpy(oldhunk + oldsize + 2, line);
1026 oldsize += len;
1027 }
1028 for (i = prenewmax + 1; i <= prenewend; i++) {
1029 line = getnew(i);
1030 if (!line) {
1031 prenewend = i - 1;
1032 break;
1033 }
1034 len = strlen(line) + 2;
1035 if (newsize + len + 1 >= newalloc) {
1036 newalloc *= 2;
1037 newhunk = (char *) xrealloc(newhunk, newalloc);
1038 }
1039 strcpy(newhunk + newsize, " ");
1040 strcpy(newhunk + newsize + 2, line);
1041 newsize += len;
1042 }
1043 fputs("***************\n", stdout);
1044 if (preoldbeg >= preoldend) {
1045 printf("*** %d ****\n", preoldend);
1046 } else {
1047 printf("*** %d,%d ****\n", preoldbeg, preoldend);
1048 }
1049 if (oldwanted) {
1050 fputs(oldhunk, stdout);
1051 }
1052 oldsize = 0;
1053 *oldhunk = '\0';
1054 if (prenewbeg >= prenewend) {
1055 printf("--- %d ----\n", prenewend);
1056 } else {
1057 printf("--- %d,%d ----\n", prenewbeg, prenewend);
1058 }
1059 if (newwanted) {
1060 fputs(newhunk, stdout);
1061 }
1062 newsize = 0;
1063 *newhunk = '\0';
1064}
1065
1066char *getold(targ)
1067int targ;
1068{
1069 while (fgets(buff, sizeof buff, oldfp) != Nullch) {
1070 oldline++;
1071 if (oldline == targ) return buff;
1072 }
1073 return Nullch;
1074}
1075
1076char *getnew(targ)
1077int targ;
1078{
1079 while (fgets(buff, sizeof buff, newfp) != Nullch) {
1080 newline++;
1081 if (newline == targ) return buff;
1082 }
1083 return Nullch;
1084}
1085
1086
1087/* Isdir() checks, if <path> is the name of a directory. a return value
1088 * is 0, <path> is a normal file. otherwise the <path> is a directory.
1089 */
1090int isdir(path)
1091char *path;
1092{
1093 struct stat buf;
1094 stat(path, &buf);
1095 if (buf.st_mode & S_IFDIR) { /* path is a directory */
1096 return(~0);
1097 } else {
1098 return(0);
1099 }
1100}
1101
1102
1103
1104/* This is the "main" function if a diff of two directories has to be
1105 * done. diff_recursive() expects the names of the two directories to
1106 * be compared. */
1107void diff_recursive(dir1, dir2)
1108char *dir1, *dir2;
1109{
1110 FILE *ls1, *ls2;
1111 char file1[PATH_MAX], file2[PATH_MAX];
1112 char jointfile1[PATH_MAX], jointfile2[PATH_MAX];
1113 char command[PATH_MAX];
1114 int difference, eof1, eof2;
1115
1116 sprintf(command, "ls %s", dir1);
1117 ls1 = popen(command, "r");
1118 sprintf(command, "ls %s", dir2);
1119 ls2 = popen(command, "r");
1120
1121 if ((ls1 == NULL) || (ls2 == NULL))
1122 fatal_error("cannot execute ls!", "");
1123
1124 file1[0] = '\0';
1125 eof1 = fscanf(ls1, "%s\n", file1);
1126 file2[0] = '\0';
1127 eof2 = fscanf(ls2, "%s\n", file2);
1128
1129 while ((file1[0] != '\0') && (file2[0] != '\0')) {
1130 difference = strcmp(file1, file2);
1131 while (difference != 0) {
1132 if (difference < 0) {
1133 printf("Only in %s: %s\n", dir1, file1);
1134 file1[0] = '\0';
1135 eof1 = fscanf(ls1, "%s\n", file1);
1136 if (file1[0] == '\0') break;
1137 } else {
1138 printf("Only in %s: %s\n", dir2, file2);
1139 file2[0] = '\0';
1140 eof2 = fscanf(ls2, "%s\n", file2);
1141 if (file2[0] == '\0') break;
1142 }
1143 difference = strcmp(file1, file2);
1144 }
1145 if (eof1 != EOF && eof2 != EOF) {
1146 strcpy(jointfile1, dir1);
1147 strcat(jointfile1, "/");
1148 strcat(jointfile1, file1);
1149 strcpy(jointfile2, dir2);
1150 strcat(jointfile2, "/");
1151 strcat(jointfile2, file2);
1152
1153 if ((isdir(jointfile1) != 0) && (isdir(jointfile2) != 0)) {
1154 printf("Common subdirectories: %s and %s\n",
1155 jointfile1, jointfile2);
1156 diff_recursive(jointfile1, jointfile2);
1157 } else {
1158 firstoutput = 1;
1159 strcpy(oldfile, jointfile1);
1160 strcpy(newfile, jointfile2);
1161 diff(jointfile1, jointfile2);
1162 }
1163 file1[0] = '\0';
1164 eof1 = fscanf(ls1, "%s\n", file1);
1165 file2[0] = '\0';
1166 eof2 = fscanf(ls2, "%s\n", file2);
1167 }
1168 }
1169
1170 if (file1[0] != '\0') { /* first arg still has files */
1171 do {
1172 printf("Only in %s: %s\n", dir1, file1);
1173 eof1 = fscanf(ls1, " %s\n", file1);
1174 } while (eof1 != EOF);
1175 }
1176 if (file2[0] != '\0') {
1177 do {
1178 printf("Only in %s: %s\n", dir2, file2);
1179 eof2 = fscanf(ls2, " %s\n", file2);
1180 } while (eof2 != EOF);
1181 }
1182 if (pclose(ls1) != 0) severe_error = 1;
1183 if (pclose(ls2) != 0) severe_error = 1;
1184}
1185
1186
1187/* File_type_error is called, if in a recursive diff ( -r) one of the two
1188 * files a block special, a character special or a FIFO special file is.
1189 * The corresponding error message is printed here. */
1190void file_type_error(filename1, filename2, statbuf1, statbuf2)
1191char *filename1, *filename2;
1192struct stat *statbuf1, *statbuf2;
1193{
1194 char type1[25], type2[25];
1195
1196 switch (statbuf1->st_mode & S_IFMT) { /* select only file mode */
1197 case S_IFREG:
1198 sprintf(type1, "regular file ");
1199 break;
1200 case S_IFBLK:
1201 sprintf(type1, "block special file ");
1202 break;
1203 case S_IFDIR: sprintf(type1, "directory "); break;
1204 case S_IFCHR:
1205 sprintf(type1, "character special file ");
1206 break;
1207 case S_IFIFO:
1208 sprintf(type1, "FIFO special file ");
1209 break;
1210 }
1211
1212 switch (statbuf2->st_mode & S_IFMT) { /* select only file mode */
1213 case S_IFREG:
1214 sprintf(type2, "regular file ");
1215 break;
1216 case S_IFBLK:
1217 sprintf(type2, "block special file ");
1218 break;
1219 case S_IFDIR: sprintf(type2, "directory "); break;
1220 case S_IFCHR:
1221 sprintf(type2, "character special file ");
1222 break;
1223 case S_IFIFO:
1224 sprintf(type2, "FIFO special file ");
1225 break;
1226 }
1227 printf("File %s is a %s while file %s is a %s\n",
1228 filename1, type1, filename2, type2);
1229}
1230
1231void *xmalloc(size)
1232size_t size;
1233{
1234 void *ptr;
1235
1236 ptr = malloc(size);
1237 if (ptr == NULL) {
1238 fprintf(stderr, "%s: out of memory\n", progname);
1239 exit(2);
1240 }
1241 return(ptr);
1242}
1243
1244void *xrealloc(ptr, size)
1245void *ptr;
1246size_t size;
1247{
1248 ptr = realloc(ptr, size);
1249 if (ptr == NULL) {
1250 fprintf(stderr, "%s: out of memory\n", progname);
1251 exit(2);
1252 }
1253 return(ptr);
1254}
Note: See TracBrowser for help on using the repository browser.