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