Testsuite: fakens/inet_pton on solaris again
[exim.git] / test / src / cf.c
1 /************************************************
2 * PH-Compare *
3 ************************************************/
4
5 /* A program to compare two files line by line.
6
7 History:
8
9 It was originally written in C, but the C under
10 Panos is still a shambles (1986). Translated therefore
11 to BCPL -- this explains some of the odd style.
12
13 Modified to run on Archimedes, August 1987.
14 Modified to run under MSDOS, March 1989.
15 Modified to run under CINTERP interpreter, July 1989.
16 Modified to run under Unix, October 1989.
17
18 Translated back into C, March 1990! */
19
20 /* Copyright (c) 1986, 1987, 1989, 1990, 1994, 2001 by Philip Hazel */
21
22 /* Previously modified: October 1994*/
23 /* Last modified: September 2001 - a long-lived bug fixed! */
24
25
26 #include <stdio.h>
27 #include <errno.h>
28
29 #ifdef __STDC__
30 #include <string.h>
31 #include <stdlib.h>
32 #include <stdint.h>
33 #endif
34
35 #ifndef intptr_t
36 # define intptr_t long long int
37 #endif
38
39 /* ----- parameters ----- */
40
41 #define version 8
42 #define defaultstore 100000 /* default recovery buffer size */
43 #define minstore 500 /* minimum recovery buffer size */
44
45 /* ----- misc defines ----- */
46
47 #define FALSE 0
48 #define TRUE 1
49
50 #ifdef __STDC__
51 #define pvoid void
52 #else
53 #define pvoid
54 #endif
55
56 #define EqString(s, t) (strcmp(s, t) == 0)
57
58 /* ----- line structure ----- */
59
60 typedef struct line {
61 struct line *next;
62 int number;
63 char text[999999];
64 } line;
65
66
67 /* ----- global variables ----- */
68
69 FILE *f_one; /* files */
70 FILE *f_two;
71 FILE *f_out;
72
73 int lines_one = 0; /* line counts */
74 int lines_two = 0;
75 int return_code = 0;
76 int eof_one = FALSE; /* eof flags */
77 int eof_two = FALSE;
78 int exact = FALSE; /* TRUE => no strip spaces */
79 int echo = TRUE; /* TRUE => show mismatched lines */
80 int sync_count = 3; /* resync count */
81 int storesize = defaultstore; /* size of each buffer */
82
83 char *name_one = NULL; /* file names */
84 char *name_two = NULL;
85 char *to_name = NULL;
86
87 char *bufbase_one; /* start buffer */
88 char *bufbase_two;
89 char *bufnext_one; /* next free byte */
90 char *bufnext_two;
91 char *buftop_one; /* end buffer */
92 char *buftop_two;
93
94 line *rootline_one; /* mis-match point */
95 line *rootline_two;
96 line *lastline_one; /* last in store */
97 line *lastline_two;
98 line *pline_one; /* working line */
99 line *pline_two;
100
101
102 /*************************************************
103 * Help Information *
104 *************************************************/
105
106 void givehelp(pvoid)
107 {
108 printf("PH's CMP v%d\n", version);
109 printf("Keywords:\n");
110 printf(" <file> ) files to compare\n");
111 printf(" <file> ) no keywords used\n");
112 printf("-to <file> output destination\n");
113 printf("-exact include trailing spaces & match tabs\n");
114 printf("-noecho don't echo differences (just give line numbers)\n");
115 printf("-s, -sync <n> set re-sync count, default 3\n");
116 printf("-buffer <n> buffer size (for each file) default 100000\n");
117 printf("-id give program version id\n");
118 printf("-h, -help give this help\n");
119 printf("\nExamples:\n");
120 printf("cmp old.f77 new.f77\n");
121 printf("cmp first second -noecho -sync 1\n");
122 printf("cmp large1 large2 -buffer 200000 -noecho -to diffs\n");
123 }
124
125
126
127 /************************************************
128 * Errors -- all serious *
129 ************************************************/
130
131 void moan(code, text)
132 int code;
133 char *text;
134 {
135 fprintf(stderr, "\n** ");
136 switch (code)
137 {
138 case 1:
139 fprintf(stderr, "Unable to open file \"%s\"", text);
140 if (errno)
141 {
142 fprintf(stderr, " - ");
143 perror(NULL);
144 }
145 else fprintf(stderr, "\n");
146 break;
147
148 case 2:
149 fprintf(stderr, "Buffer overflow for file \"%s\"\n", text);
150 break;
151
152 case 3:
153 fprintf(stderr, "Two file names must be given\n");
154 break;
155
156 default:
157 fprintf(stderr, "Unknown error %d\n", code);
158 break;
159 }
160
161 fprintf(stderr, "** CMP abandoned\n");
162 exit(99);
163 }
164
165
166
167 /*************************************************
168 * Write line identification *
169 *************************************************/
170
171 void write_id(n1, n2, c, name, p1, p2)
172 int n1, n2, c;
173 char *name, *p1, *p2;
174 {
175 if (n2 < 0) n2 = -n2;
176 n2 -= 1;
177 fprintf(f_out, "%cine", c);
178 if (n1 == n2) fprintf(f_out, " %d of \"%s\"%s", n1, name, p1);
179 else fprintf(f_out, "s %d-%d of \"%s\"%s", n1, n2, name, p2);
180 }
181
182
183 /*************************************************
184 * Write sequence of lines *
185 *************************************************/
186
187 void write_lines(s, t)
188 line *s, *t;
189 {
190 while (s != t)
191 {
192 char *p = s->text;
193 while (*p != '\n') fputc(*p++, f_out);
194 fputc('\n', f_out);
195 s = s->next;
196 }
197 }
198
199
200
201 /*************************************************
202 * Write separator rule *
203 *************************************************/
204
205 void rule(s, l)
206 int s, l;
207 {
208 while (l-- > 0) fprintf(f_out, "%c", s);
209 fprintf(f_out, "\n");
210 }
211
212
213
214 /*************************************************
215 * Write message on re-sync or eof *
216 *************************************************/
217
218 void write_message(tline_one, tline_two)
219 line *tline_one, *tline_two;
220 {
221 int s1 = rootline_one->number;
222 int t1 = tline_one->number;
223 int s2 = rootline_two->number;
224 int t2 = tline_two->number;
225 if (echo) rule('=', 15);
226
227 if (s1 == t1)
228 {
229 write_id(s2, t2, 'L', name_two, " occurs ", " occur ");
230 if (s1 < 0) fprintf(f_out, "at the end");
231 else fprintf(f_out, "before line %d", s1);
232 fprintf(f_out, " of \"%s\".\n", name_one);
233 if (echo)
234 {
235 rule('-', 10);
236 write_lines(rootline_two, tline_two);
237 }
238 }
239
240 else if (s2 == t2)
241 {
242 write_id(s1, t1, 'L', name_one, " occurs ", " occur ");
243 if (s2 < 0) fprintf(f_out, "at the end");
244 else fprintf(f_out, "before line %d", s2);
245 fprintf(f_out, " of \"%s\".\n", name_two);
246 if (echo)
247 {
248 rule('-', 10);
249 write_lines(rootline_one, tline_one);
250 }
251 }
252
253 else if (t1 < 0 && t2 < 0)
254 {
255 fprintf(f_out, "From line %d of \"%s\" and line %d of \"%s\" ",
256 rootline_one->number, name_one, rootline_two->number, name_two);
257 fprintf(f_out, "the files are different.\n");
258 if (echo)
259 {
260 rule('-', 10);
261 if (-t1-s1 < 21) write_lines(rootline_one, tline_one);
262 else fprintf(f_out, "... <more than 20 lines> ...\n");
263 rule('-', 10);
264 if (-t2-s2 < 21) write_lines(rootline_two, tline_two);
265 else fprintf(f_out, "... <more than 20 lines> ...\n");
266 }
267 }
268
269 else
270 {
271 write_id(s1, t1, 'L', name_one, " does ", " do ");
272 fprintf(f_out, "not match ");
273 write_id(s2, t2, 'l', name_two, ".\n", ".\n");
274 if (echo)
275 {
276 rule('-', 10);
277 write_lines(rootline_one, tline_one);
278 rule('-', 10);
279 write_lines(rootline_two, tline_two);
280 }
281 }
282 }
283
284
285
286
287 /*************************************************
288 * Advance to next line in store *
289 *************************************************/
290
291 /* A separate procedure exists for each file, for
292 simplicity and efficiency. */
293
294 int nextline_one(pvoid)
295 {
296 if (pline_one == NULL || pline_one->next == NULL) return FALSE;
297 pline_one = pline_one->next;
298 return TRUE;
299 }
300
301 int nextline_two(pvoid)
302 {
303 if (pline_two == NULL || pline_two->next == NULL) return FALSE;
304 pline_two = pline_two->next;
305 return TRUE;
306 }
307
308
309 /*************************************************
310 * Read a line into store *
311 *************************************************/
312
313 /* A separate procedure exists for each file, for
314 simplicity and efficiency. */
315
316 void readline_one(pvoid)
317 {
318 int count = 0;
319 int c = fgetc(f_one);
320 line *nextline = (line *)bufnext_one;
321
322 bufnext_one = nextline->text;
323 if (bufnext_one >= buftop_one) moan(2, name_one);
324
325 nextline->next = NULL;
326
327 lines_one ++;
328 if (c == EOF)
329 {
330 eof_one = TRUE;
331 nextline->number = -lines_one;
332 }
333 else
334 {
335 nextline->number = lines_one;
336 for (;;)
337 {
338 if (c == EOF) c = '\n';
339 if (c == '\n')
340 {
341 if (!exact)
342 while (bufnext_one > nextline->text)
343 { if (bufnext_one[-1] == ' ') bufnext_one--; else break; }
344 *(bufnext_one++) = '\n';
345 if (bufnext_one >= buftop_one) moan(2, name_one);
346 break;
347 }
348 if (c == '\t' && !exact)
349 do { *(bufnext_one++) = ' '; count++; } while ((count & 7) != 0);
350 else { *(bufnext_one++) = c; count++; }
351 if (bufnext_one >= buftop_one) moan(2, name_one);
352 c = fgetc(f_one);
353 }
354 }
355
356 if (lastline_one != NULL) lastline_one->next = nextline;
357 lastline_one = nextline;
358 pline_one = nextline;
359
360 bufnext_one = (char *) (((intptr_t)bufnext_one+ sizeof (intptr_t) - 1) & (-(sizeof (intptr_t))));
361 }
362
363
364
365 void readline_two(pvoid)
366 {
367 int count = 0;
368 int c = fgetc(f_two);
369 line *nextline = (line *)bufnext_two;
370
371 bufnext_two = nextline->text;
372 if (bufnext_two >= buftop_two) moan(2, name_two);
373
374 nextline->next = NULL;
375
376 lines_two ++;
377 if (c == EOF)
378 {
379 eof_two = TRUE;
380 nextline->number = -lines_two;
381 }
382 else
383 {
384 nextline->number = lines_two;
385 for (;;)
386 {
387 if (c == EOF) c = '\n';
388 if (c == '\n')
389 {
390 if (!exact)
391 while (bufnext_two > nextline->text)
392 { if (bufnext_two[-1] == ' ') bufnext_two--; else break; }
393 *(bufnext_two++) = '\n';
394 if (bufnext_two >= buftop_two) moan(2, name_two);
395 break;
396 }
397 if (c == '\t' && !exact)
398 do { *(bufnext_two++) = ' '; count++; } while ((count & 7) != 0);
399 else { *(bufnext_two++) = c; count++; }
400 if (bufnext_two >= buftop_two) moan(2, name_two);
401 c = fgetc(f_two);
402 }
403 }
404
405 if (lastline_two != NULL) lastline_two->next = nextline;
406 lastline_two = nextline;
407 pline_two = nextline;
408
409 bufnext_two = (char *) (((intptr_t)bufnext_two+ sizeof (intptr_t) - 1) & (-(sizeof (intptr_t))));
410 }
411
412
413
414 /**************************************************
415 * Compare two lines *
416 **************************************************/
417
418 int compare_lines(a, b)
419 line *a, *b;
420 {
421 int n1 = a->number;
422 int n2 = b->number;
423 char *s = a->text;
424 char *t = b->text;
425
426 if (n1 < 0 && n2 < 0) return TRUE;
427 if (n1 < 0 || n2 < 0) return FALSE;
428
429 while (*s == *t)
430 {
431 if (*s == '\n') return TRUE;
432 s++; t++;
433 }
434
435 return FALSE;
436 }
437
438
439 /*************************************************
440 * Re-synchronizing code *
441 *************************************************/
442
443 int resync(pvoid)
444 {
445 int i;
446 int matched = TRUE;
447 line *tline_one = pline_one;
448 line *tline_two = pline_two;
449
450 if (eof_one || eof_two) matched = FALSE; else
451 {
452 for (i = 1; i < sync_count; i++)
453 {
454 if (!nextline_one()) readline_one();
455 if (!nextline_two()) readline_two();
456 if (!compare_lines(pline_one, pline_two)) { matched = FALSE; break; }
457 if (eof_one || eof_two) { matched = FALSE; break; }
458 }
459 }
460
461 if (matched) write_message(tline_one, tline_two); else
462 {
463 pline_one = tline_one;
464 pline_two = tline_two;
465 }
466
467 return matched;
468 }
469
470
471
472 /*************************************************
473 * Main compare code *
474 *************************************************/
475
476 void compare(pvoid)
477 {
478 int matched = TRUE;
479
480 /* Big main loop - exit by return or unmatched at eof */
481
482 while (matched)
483 {
484 /* First minor loop, while in step */
485
486 while (matched && !eof_one && !eof_two)
487 {
488 /* Advance or read next lines */
489
490 if (!nextline_one())
491 {
492 bufnext_one = bufbase_one;
493 lastline_one = NULL;
494 readline_one();
495 }
496
497 if (!nextline_two())
498 {
499 bufnext_two = bufbase_two;
500 lastline_two = NULL;
501 readline_two();
502 }
503
504 /* Compare and check for end of file */
505
506 matched = compare_lines(pline_one, pline_two);
507
508 } /* End first minor loop */
509
510 if (matched) return; /* successful end of file */
511
512 /* There has been a mis-match */
513
514 return_code++;
515 rootline_one = pline_one; /* Fail point */
516 rootline_two = pline_two;
517
518 /* Second minor loop, trying to regain sync */
519
520 while (!eof_one || !eof_two)
521 {
522 /* Advance one and scan all of two */
523
524 if (!eof_one)
525 {
526 line *zline = pline_two;
527 if (!nextline_one()) readline_one();
528 pline_two = rootline_two;
529 for (;;)
530 {
531 if (compare_lines(pline_one, pline_two))
532 {
533 matched = resync();
534 if (matched) break;
535 }
536 if (pline_two == zline) break;
537 pline_two = pline_two->next;
538 }
539 if (matched) break;
540 }
541
542 /* Advance two and scan all of one */
543
544 if (!eof_two)
545 {
546 line *zline = pline_one;
547 if (!nextline_two()) readline_two();
548 pline_one = rootline_one;
549 for (;;)
550 {
551 if (compare_lines(pline_one, pline_two))
552 {
553 matched = resync();
554 if (matched) break;
555 }
556 if (pline_one == zline) break;
557 pline_one = pline_one->next;
558 }
559 if (matched) break;
560 }
561
562 } /* End second minor loop */
563
564 } /* End of major loop */
565
566 write_message(lastline_one, lastline_two);
567 }
568
569
570
571
572 /*************************************************
573 * Entry Point *
574 *************************************************/
575
576 int main(argc, argv)
577 int argc;
578 char **argv;
579 {
580 int argp = 1;
581 int arg_id = FALSE;
582 int arg_help = FALSE;
583
584 f_out = stdout;
585
586 /* Scan argument strings */
587
588 while (argp < argc)
589 {
590 char *arg = argv[argp];
591 char **lv_name = (name_one == NULL)? &name_one:&name_two; /* default for positional */
592 int *lv_value = NULL;
593 int value = TRUE;
594
595 if (arg[0] == '-')
596 { /* keyed argument */
597 if (EqString(arg,"-help") || EqString(arg, "-h"))
598 { arg_help = TRUE; value = FALSE; }
599 else if (EqString(arg, "-id"))
600 { arg_id = TRUE; value = FALSE; }
601 else if (EqString(arg, "-exact"))
602 { exact = TRUE; value = FALSE; }
603 else if (EqString(arg, "-noecho"))
604 { echo = FALSE; value = FALSE; }
605 else if (EqString(arg, "-to")) lv_name = &to_name;
606 else if (EqString(arg, "-sync") || EqString(arg, "-s"))
607 lv_value = &sync_count;
608 else if (EqString(arg, "-buffer")) lv_value = &storesize;
609 else { printf("Unknown keyword %s\n", arg); exit(99); }
610
611 if (++argp >= argc && value)
612 { printf("Value for keyword %s missing\n", arg); exit(99); }
613 }
614
615 /* Deal with keys that take values */
616
617 if (value)
618 {
619 if (lv_value == &sync_count || lv_value == &storesize)
620 {
621 int ch;
622 int i = 0;
623 char *argval = argv[argp++];
624 *lv_value = 0;
625 while ((ch = argval[i++]) != 0)
626 {
627 if ('0' <= ch && ch <= '9') *lv_value = 10*(*lv_value) + ch - '0'; else
628 {
629 printf("Number expected after \"%s\" but \"%s\" read\n",
630 arg, argval);
631 exit(99);
632 }
633 }
634 }
635
636 else if (*lv_name != NULL)
637 {
638 printf("Keyword expected but \"%s\" read", arg);
639 printf(" - use \"cmp -h\" for help\n");
640 exit(99);
641 }
642 else *lv_name = argv[argp++];
643 }
644 }
645
646 /* Deal with help and id */
647
648 if (arg_id && !arg_help)
649 {
650 printf("PH's CMP v%d\n", version);
651 exit(0);
652 }
653
654 if (arg_help)
655 {
656 givehelp();
657 exit(0);
658 }
659
660 /* Deal with file names */
661
662 if (name_one == NULL || name_two == NULL) moan(3, "");
663
664 if (to_name != NULL)
665 {
666 f_out = fopen(to_name, "w");
667 if (f_out == NULL) moan(1, to_name);
668 }
669
670 /* Further general initialization */
671
672 if (storesize < minstore) storesize = defaultstore;
673 f_one = fopen(name_one, "r");
674 if (f_one == NULL) moan(1, name_one);
675 f_two = fopen(name_two, "r");
676 if (f_two == NULL) moan(1, name_two);
677
678 bufbase_one = (char *)malloc(storesize);
679 buftop_one = bufbase_one + storesize;
680 bufbase_two = (char *)malloc(storesize);
681 buftop_two = bufbase_two + storesize;
682
683 /* Do the job */
684
685 compare();
686
687 /* Final messages */
688
689 if (return_code == 0)
690 fprintf(f_out, "\"%s\" and \"%s\" are identical.\n", name_one, name_two);
691 else
692 {
693 if (echo) rule('=', 15);
694 fprintf(f_out, "%d difference", return_code);
695 if (return_code != 1) fprintf(f_out, "s");
696 fprintf(f_out, " found.\n");
697
698 lines_one -= 1;
699 fprintf(f_out, "\"%s\" contains %d line", name_one, lines_one);
700 if (lines_one != 1) fprintf(f_out, "s");
701
702 lines_two -= 1;
703 fprintf(f_out, "; \"%s\" contains %d line", name_two, lines_two);
704 if (lines_two != 1) fprintf(f_out, "s");
705 fprintf(f_out, ".\n");
706 }
707
708 free(bufbase_one);
709 free(bufbase_two);
710
711 fclose(f_one);
712 fclose(f_two);
713 if (f_out != stdout) fclose(f_out);
714
715 return return_code;
716 }
717
718 /* End of PH-Compare. */