home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 11 Util / 11-Util.zip / DIFFPT.ZIP / PATCHES.OS2 < prev    next >
Text File  |  1991-07-01  |  60KB  |  2,090 lines
  1. Only in diff: patches.os2
  2. Only in diff: patchfmt.dif
  3. Only in diff: merged.dif
  4. Only in diff: diff.bad
  5. Only in diff: diff.cs
  6. Only in diff: diff.def
  7. Only in diff: diff.man
  8. Only in diff: diff3.bad
  9. Only in diff: diff3.cs
  10. Only in diff: diff3.def
  11. Only in diff: diff3.man
  12. Only in diff: hrealloc.c
  13. Only in diff: merged.c
  14. Only in diff: mktemp.c
  15. Only in diff: pipe.c
  16. Only in diff: proto.h
  17. diff -cbBw orig/analyze.c diff/analyze.c
  18. *** orig/analyze.c    Mon Jan 28 20:17:44 1991
  19. --- diff/analyze.c    Mon Jan 28 20:22:04 1991
  20. ***************
  21. *** 32,42 ****
  22. --- 32,47 ----
  23.   void print_normal_script ();
  24.   void print_rcs_script ();
  25.   void pr_forward_ed_script ();
  26. + void print_merged_script ();
  27.   void setup_output ();
  28.   
  29.   extern int no_discards;
  30.   
  31.   static int *xvec, *yvec;    /* Vectors being compared. */
  32. + #ifdef MSDOS
  33. + static int _huge *fdiag;
  34. + static int _huge *bdiag;
  35. + #else
  36.   static int *fdiag;        /* Vector, indexed by diagonal, containing
  37.                      the X coordinate of the point furthest
  38.                      along the given diagonal in the forward
  39. ***************
  40. *** 45,50 ****
  41. --- 50,56 ----
  42.                      the X coordinate of the point furthest
  43.                      along the given diagonal in the backward
  44.                      search of the edit matrix. */
  45. + #endif
  46.   
  47.   /* Find the midpoint of the shortest edit script for a specified
  48.      portion of the two files.
  49. ***************
  50. *** 75,84 ****
  51. --- 81,97 ----
  52.        int xoff, xlim, yoff, ylim;
  53.        int *cost;
  54.   {
  55. + #ifdef MSDOS
  56. +   int _huge *const fd = fdiag;
  57. +   int _huge *const bd = bdiag;
  58. +   int _huge *const xv = xvec;
  59. +   int _huge *const yv = yvec;
  60. + #else
  61.     int *const fd = fdiag;    /* Give the compiler a chance. */
  62.     int *const bd = bdiag;    /* Additional help for the compiler. */
  63.     int *const xv = xvec;        /* Still more help for the compiler. */
  64.     int *const yv = yvec;        /* And more and more . . . */
  65. + #endif
  66.     const int dmin = xoff - ylim;    /* Minimum valid diagonal. */
  67.     const int dmax = xlim - yoff;    /* Maximum valid diagonal. */
  68.     const int fmid = xoff - yoff;    /* Center diagonal of top-down search. */
  69. ***************
  70. *** 719,725 ****
  71.        struct file_data filevec[];
  72.        int depth;
  73.   {
  74. !   int diags;
  75.     int i;
  76.     struct change *e, *p;
  77.     struct change *script;
  78. --- 732,738 ----
  79.        struct file_data filevec[];
  80.        int depth;
  81.   {
  82. !   long diags;
  83.     int i;
  84.     struct change *e, *p;
  85.     struct change *script;
  86. ***************
  87. *** 729,738 ****
  88. --- 742,766 ----
  89.     /* See if the two named files are actually the same physical file.
  90.        If so, we know they are identical without actually reading them.  */
  91.   
  92. + #if !defined(MSDOS)
  93. +       /*
  94. +       ** since MSC always sets the inode and dev fields to zero under DOS
  95. +       ** this test will always think two files are the same.
  96. +       */
  97.     if (output_style != OUTPUT_IFDEF
  98.         && filevec[0].stat.st_ino == filevec[1].stat.st_ino
  99.         && filevec[0].stat.st_dev == filevec[1].stat.st_dev)
  100.       return 0;
  101. + #endif /* MSDOS */
  102. + 
  103. +   if (no_details_flag
  104. +       && (filevec[0].stat.st_mode & S_IFMT) == S_IFREG
  105. +       && (filevec[1].stat.st_mode & S_IFMT) == S_IFREG
  106. +       && filevec[0].stat.st_size != filevec[1].stat.st_size)
  107. +     {
  108. +       message ("Files %s and %s differ\n", filevec[0].name, filevec[1].name);
  109. +       return 1;
  110. +     }
  111.   
  112.     binary = read_files (filevec);
  113.   
  114. ***************
  115. *** 743,759 ****
  116.   
  117.     if (binary || no_details_flag)
  118.       {
  119.         int differs = (filevec[0].buffered_chars != filevec[1].buffered_chars
  120.                || bcmp (filevec[0].buffer, filevec[1].buffer,
  121.                     filevec[1].buffered_chars));
  122.         if (differs)
  123. !     message (binary ? "Binary files %s and %s differ\n"
  124. !          : "Files %s and %s differ\n",
  125.            filevec[0].name, filevec[1].name);
  126.   
  127.         for (i = 0; i < 2; ++i)
  128.       if (filevec[i].buffer)
  129.         free (filevec[i].buffer);
  130.         return differs;
  131.       }
  132.   
  133. --- 771,817 ----
  134.   
  135.     if (binary || no_details_flag)
  136.       {
  137. + #if !defined(MSDOS)
  138.         int differs = (filevec[0].buffered_chars != filevec[1].buffered_chars
  139.                || bcmp (filevec[0].buffer, filevec[1].buffer,
  140.                     filevec[1].buffered_chars));
  141. + #else
  142. +       int differs;
  143. +       if(filevec[0].buffered_chars != filevec[1].buffered_chars)
  144. +               differs = 1;
  145. +       else {
  146. +               /*
  147. +               ** we've got to do it in chunks because of our
  148. +               ** poor 16 bit processor
  149. +               */
  150. +               char _huge *b0 = filevec[0].buffer;
  151. +               char _huge *b1 = filevec[1].buffer;
  152. +               long int count;
  153. +               unsigned int delta;
  154. +               count = filevec[0].buffered_chars;
  155. +               while(count > 0) {
  156. +                       delta = (unsigned)(count > 65000 ? 65000 : count);
  157. +                       if(bcmp(b0,b1,delta) != 0)
  158. +                               break;
  159. +                       count -= delta;
  160. +                       b0 += delta;
  161. +                       b1 += delta;
  162. +               }
  163. +               differs = count != 0;
  164. +       }
  165. + #endif
  166.         if (differs)
  167. !     message (no_details_flag ? "Files %s and %s differ\n"
  168. !          : "Binary files %s and %s differ\n",
  169.            filevec[0].name, filevec[1].name);
  170.   
  171.         for (i = 0; i < 2; ++i)
  172.       if (filevec[i].buffer)
  173. + #ifndef MSDOS
  174.         free (filevec[i].buffer);
  175. + #else
  176. +           hfree (filevec[i].buffer);
  177. + #endif
  178.         return differs;
  179.       }
  180.   
  181. ***************
  182. *** 780,789 ****
  183.   
  184.     xvec = filevec[0].undiscarded;
  185.     yvec = filevec[1].undiscarded;
  186. !   diags = filevec[0].nondiscarded_lines + filevec[1].nondiscarded_lines + 3;
  187.     fdiag = (int *) xmalloc (diags * sizeof (int));
  188. -   fdiag += filevec[1].nondiscarded_lines + 1;
  189.     bdiag = (int *) xmalloc (diags * sizeof (int));
  190.     bdiag += filevec[1].nondiscarded_lines + 1;
  191.   
  192.     files[0] = filevec[0];
  193. --- 838,854 ----
  194.   
  195.     xvec = filevec[0].undiscarded;
  196.     yvec = filevec[1].undiscarded;
  197. !   diags = (long) filevec[0].nondiscarded_lines + filevec[1].nondiscarded_lines + 3;
  198. ! #ifdef MSDOS
  199. !   fdiag = halloc (diags, sizeof (int));
  200. !   bdiag = halloc (diags, sizeof (int));
  201. !   if ( fdiag == NULL || bdiag == NULL )
  202. !     fatal("virtual memory exhausted");
  203. ! #else
  204.     fdiag = (int *) xmalloc (diags * sizeof (int));
  205.     bdiag = (int *) xmalloc (diags * sizeof (int));
  206. + #endif
  207. +   fdiag += filevec[1].nondiscarded_lines + 1;
  208.     bdiag += filevec[1].nondiscarded_lines + 1;
  209.   
  210.     files[0] = filevec[0];
  211. ***************
  212. *** 793,801 ****
  213.             0, filevec[1].nondiscarded_lines);
  214.   
  215.     bdiag -= filevec[1].nondiscarded_lines + 1;
  216. -   free (bdiag);
  217.     fdiag -= filevec[1].nondiscarded_lines + 1;
  218.     free (fdiag);
  219.   
  220.     /* Modify the results slightly to make them prettier
  221.        in cases where that can validly be done.  */
  222. --- 858,871 ----
  223.             0, filevec[1].nondiscarded_lines);
  224.   
  225.     bdiag -= filevec[1].nondiscarded_lines + 1;
  226.     fdiag -= filevec[1].nondiscarded_lines + 1;
  227. + #ifdef MSDOS
  228. +   hfree (bdiag);
  229. +   hfree (fdiag);
  230. + #else
  231. +   free (bdiag);
  232.     free (fdiag);
  233. + #endif
  234.   
  235.     /* Modify the results slightly to make them prettier
  236.        in cases where that can validly be done.  */
  237. ***************
  238. *** 814,828 ****
  239.       {
  240.         setup_output (files[0].name, files[1].name, depth);
  241.   
  242.         switch (output_style)
  243.       {
  244.       case OUTPUT_CONTEXT:
  245. !       print_context_header (files, 0);
  246.         print_context_script (script, 0);
  247.         break;
  248.   
  249.       case OUTPUT_UNIFIED:
  250. !       print_context_header (files, 1);
  251.         print_context_script (script, 1);
  252.         break;
  253.   
  254. --- 884,903 ----
  255.       {
  256.         setup_output (files[0].name, files[1].name, depth);
  257.   
  258. +       if (output_style == OUTPUT_CONTEXT ||
  259. +           output_style == OUTPUT_UNIFIED ||
  260. +           output_patch_flag)
  261. +       print_context_header (files, output_style == OUTPUT_UNIFIED);
  262. + 
  263.         switch (output_style)
  264.       {
  265.       case OUTPUT_CONTEXT:
  266. !       /* print_context_header (files, 0); */
  267.         print_context_script (script, 0);
  268.         break;
  269.   
  270.       case OUTPUT_UNIFIED:
  271. !       /* print_context_header (files, 1); */
  272.         print_context_script (script, 1);
  273.         break;
  274.   
  275. ***************
  276. *** 845,850 ****
  277. --- 920,929 ----
  278.       case OUTPUT_IFDEF:
  279.         print_ifdef_script (script);
  280.         break;
  281. + 
  282. +     case OUTPUT_MERGED:
  283. +       print_merged_script (script);
  284. +       break;
  285.       }
  286.   
  287.         finish_output ();
  288. ***************
  289. *** 899,907 ****
  290. --- 978,994 ----
  291.   
  292.     for (i = 0; i < 2; ++i)
  293.       {
  294. + #if !defined(MSDOS)
  295.         if (filevec[i].buffer != 0)
  296.       free (filevec[i].buffer);
  297. + 
  298.         free (filevec[i].linbuf);
  299. + #else /* MSDOS */
  300. +       if (filevec[i].buffer != 0)
  301. +         hfree (filevec[i].buffer);
  302. + 
  303. +       hfree (filevec[i].linbuf);
  304. + #endif
  305.       }
  306.   
  307.     for (e = script; e; e = p)
  308. diff -cbBw orig/context.c diff/context.c
  309. *** orig/context.c    Mon Jan 28 20:17:46 1991
  310. --- diff/context.c    Thu Jan 17 23:07:24 1991
  311. ***************
  312. *** 43,49 ****
  313.     if (label)
  314.       fprintf (outfile, "%s %s\n", mark, label);
  315.     else if (inf->stat.st_mtime)
  316. !     fprintf (outfile, "%s %s\t%s", mark, inf->name, ctime(&inf->stat.st_mtime));
  317.     else
  318.       /* Don't pretend that standard input is ancient.  */
  319.       fprintf (outfile, "%s %s\n", mark, inf->name);
  320. --- 43,54 ----
  321.     if (label)
  322.       fprintf (outfile, "%s %s\n", mark, label);
  323.     else if (inf->stat.st_mtime)
  324. !   {
  325. !     char *ct = ctime(&inf->stat.st_mtime);
  326. !     /* some ctime()'s return NULL on illegal times
  327. !        which may occur sometimes under DOS ... */
  328. !     fprintf (outfile, "%s %s\t%s", mark, inf->name, ct ? ct : "\n");
  329. !   }
  330.     else
  331.       /* Don't pretend that standard input is ancient.  */
  332.       fprintf (outfile, "%s %s\n", mark, inf->name);
  333. ***************
  334. *** 51,61 ****
  335. --- 56,90 ----
  336.   
  337.   /* Print a header for a context diff, with the file names and dates.  */
  338.   
  339. + #ifdef MSDOS
  340. + void dosname(char *ptr)
  341. + {
  342. +   for ( ; *ptr; ptr++ )
  343. +     if ( *ptr == '\\' )
  344. +       *ptr = '/';
  345. +     /* else
  346. +       *ptr = tolower(*ptr); */
  347. + }
  348. + #endif
  349. + 
  350.   void
  351.   print_context_header (inf, unidiff_flag)
  352.        struct file_data *inf;
  353.        int unidiff_flag;
  354.   {
  355. + #ifdef MSDOS
  356. +   dosname(inf[0].name);
  357. +   dosname(inf[1].name);
  358. + #endif
  359. +   if (output_patch_flag)
  360. +     {
  361. +       char *cp = strlen (inf[0].name) <= strlen (inf[1].name)
  362. +         ? inf[0].name : inf[1].name;
  363. +       if (cp[0] == '.' && cp[1] == '/')
  364. +     cp += 2;
  365. +       fprintf (outfile, "Index: %s\n", cp);
  366. +       return;
  367. +     }
  368.     if (unidiff_flag)
  369.       {
  370.         print_context_label ("---", &inf[0], file_label[0]);
  371. ***************
  372. *** 397,403 ****
  373.         script->link = next;
  374.   
  375.         /* If the change is ignorable, mark it.  */
  376. !       script->ignore = (!deletes && !inserts);
  377.   
  378.         /* Advance to the following change.  */
  379.         script = next;
  380. --- 426,432 ----
  381.         script->link = next;
  382.   
  383.         /* If the change is ignorable, mark it.  */
  384. !       script->ignore = (char) (!deletes && !inserts);
  385.   
  386.         /* Advance to the following change.  */
  387.         script = next;
  388. diff -cbBw orig/diff.c diff/diff.c
  389. *** orig/diff.c    Mon Jan 28 20:19:56 1991
  390. --- diff/diff.c    Thu Jan 17 23:47:22 1991
  391. ***************
  392. *** 95,100 ****
  393. --- 95,101 ----
  394.     {"print", 0, 0, 'l'},
  395.     {"rcs", 0, 0, 'n'},
  396.     {"show-c-function", 0, 0, 'p'},
  397. +   {"patch", 0, 0, 'P'},
  398.     {"binary", 0, 0, 'q'},
  399.     {"brief", 0, 0, 'q'},
  400.     {"recursive", 0, 0, 'r'},
  401. ***************
  402. *** 139,153 ****
  403.     paginate_flag = FALSE;
  404.     ifdef_string = NULL;
  405.     heuristic = FALSE;
  406.     dir_start_file = NULL;
  407.     msg_chain = NULL;
  408.     msg_chain_end = NULL;
  409.     no_discards = 0;
  410.   
  411.     /* Decode the options.  */
  412.   
  413.     while ((c = getopt_long (argc, argv,
  414. !                "0123456789abBcC:dD:efF:hHiI:lL:nNpqrsS:tTuvw",
  415.                  longopts, &longind)) != EOF)
  416.       {
  417.         if (c == 0)        /* Long option. */
  418. --- 140,156 ----
  419.     paginate_flag = FALSE;
  420.     ifdef_string = NULL;
  421.     heuristic = FALSE;
  422. +   output_patch_flag = 0;
  423.     dir_start_file = NULL;
  424.     msg_chain = NULL;
  425.     msg_chain_end = NULL;
  426.     no_discards = 0;
  427. +   line_width = 0;
  428.   
  429.     /* Decode the options.  */
  430.   
  431.     while ((c = getopt_long (argc, argv,
  432. !                "0123456789abBcC:dD:efF:hHiI:lL:mM:nNpPqrsS:tTuvw",
  433.                  longopts, &longind)) != EOF)
  434.       {
  435.         if (c == 0)        /* Long option. */
  436. ***************
  437. *** 283,288 ****
  438. --- 286,303 ----
  439.           fatal ("too many file label options");
  440.         break;
  441.   
  442. +     case 'm':
  443. +       /* Make output merged in side-by-side display. */
  444. +       specify_style (OUTPUT_MERGED);
  445. +       line_width = 80;
  446. +       break;
  447. + 
  448. +     case 'M':
  449. +       /* Make output merged in side-by-side display. */
  450. +       specify_style (OUTPUT_MERGED);
  451. +       line_width = atoi(optarg);
  452. +       break;
  453. + 
  454.       case 'n':
  455.         /* Output RCS-style diffs, like `-f' except that each command
  456.            specifies the number of lines affected.  */
  457. ***************
  458. *** 301,306 ****
  459. --- 316,325 ----
  460.         function_regexp = "^[_a-zA-Z]";
  461.         break;
  462.   
  463. +     case 'P':
  464. +       output_patch_flag = 1;
  465. +       break;
  466. + 
  467.       case 'q':
  468.         no_details_flag = 1;
  469.         break;
  470. ***************
  471. *** 399,411 ****
  472.     exit (val);
  473.   }
  474.   
  475.   usage ()
  476.   {
  477.     fprintf (stderr, "\
  478. ! Usage: diff [-#] [-abBcdefhHilnNprstTuvw] [-C lines] [-F regexp] [-I regexp]\n\
  479.          [-L label [-L label]] [-S file] [-D symbol] [+ignore-blank-lines]\n\
  480.          [+context[=lines]] [+unified[=lines]] [+ifdef=symbol]\n\
  481. !        [+show-function-line=regexp]\n");
  482.     fprintf (stderr, "\
  483.          [+speed-large-files] [+ignore-matching-lines=regexp] [+new-file]\n\
  484.          [+initial-tab] [+starting-file=file] [+text] [+all-text] [+ascii]\n\
  485. --- 418,495 ----
  486.     exit (val);
  487.   }
  488.   
  489. + #ifdef MSDOS
  490. + extern char *version_string;
  491. + 
  492. + usage()
  493. + {
  494. +   printf("\nGNU diff, version %s\n", version_string);
  495. + 
  496. +   printf("\nUsage: %s [-options] file1 file2\n\n", program);
  497. +   printf(
  498. +   "  -c      Make context-style output.\n"
  499. +   "  -p      Make context-style output and show name of last C function.\n"
  500. +   "  -C n    Make context-style output and define context size to be n lines.\n"
  501. +   "  -u      Make unified-context-style output.\n"
  502. +   "  -D      Make merged #ifdef output.\n"
  503. +   "  -e      Make output that is a valid `ed' script.\n"
  504. +   "  -f      Make output that looks vaguely like an `ed' script\n"
  505. +   "          but has changes in the order they appear in the file.\n"
  506. +   "  -n      Make RCS-style output, like `-f' except that each command\n"
  507. +   "          specifies the number of lines affected.\n"
  508. +   "  -m      Make side-by-side merged output.\n"
  509. +   "  -M n    Make side-by-side merged output and specify page-width.\n\n"
  510. +   );
  511. +   printf(
  512. +   "  -[0-9]  digits combined into decimal to specify the context-size.\n"
  513. +   "  -a      Treat all files as text files; never treat as binary.\n"
  514. +   "  -b      Ignore changes in amount of whitespace.\n"
  515. +   "  -B      Ignore changes affecting only blank lines.\n"
  516. +   "  -d      Don't discard lines. This makes things slower (sometimes much\n"
  517. +   "          slower) but will find a guaranteed minimal set of changes.\n"
  518. +   );
  519. +   printf(
  520. +   "  -F re   Show, for each set of changes, the previous line that matches the\n"
  521. +   "          specified regexp. Currently affects only context-style output.\n"
  522. +   "  -h      Split the files into chunks of around 1500 lines\n"
  523. +   "          for faster processing. Usually does not change the result.\n"
  524. +   "  -H      Use heuristic.\n"
  525. +   "  -i      Ignore changes in case.\n"
  526. +   "  -I re   Ignore changes affecting only lines that match the specified regexp.\n"
  527. +   "  -l      Pass the output through `pr' to paginate it.\n"
  528. +   "  -L label [-L label]\n"
  529. +   "          Use the specified label in file header lines output by the -c option.\n"
  530. +   );
  531. +   printf(
  532. +   "  -N      When comparing directories, if a file appears only in one\n"
  533. +   "          directory, treat it as present but empty in the other.\n"
  534. +   "  -P      Create patch headers (Index: ...).\n"
  535. +   "  -q      Treat all files as binaries.\n"
  536. +   "  -r      When comparing directories, recursively compare subdir's found.\n"
  537. +   "  -s      Print a message if the files are the same.\n"
  538. +   );
  539. +   printf(
  540. +   "  -S file When comparing directories, start with the specified\n"
  541. +   "          file name. This is used for resuming an aborted comparison.\n"
  542. +   "  -t      Expand tabs to spaces in the output so that it preserves\n"
  543. +   "          the alignment of the input files.\n"
  544. +   "  -T      Use a tab in the output, rather than a space, before the\n"
  545. +   "          text of an input line, so as to keep the proper alignment\n"
  546. +   "          in the input line without changing the characters in it.\n"
  547. +   "  -v      Print version number.\n"
  548. +   "  -w      Ignore horizontal whitespace when comparing lines.\n"
  549. +   );
  550. + 
  551. +   exit(2);
  552. + }
  553. + #else
  554.   usage ()
  555.   {
  556.     fprintf (stderr, "\
  557. ! Usage: diff [-#] [-abBcdefhHilnNpPrstTuvw] [-C lines] [-F regexp] [-I regexp]\n\
  558.          [-L label [-L label]] [-S file] [-D symbol] [+ignore-blank-lines]\n\
  559.          [+context[=lines]] [+unified[=lines]] [+ifdef=symbol]\n\
  560. !        [+show-function-line=regexp] [+patch]\n");
  561.     fprintf (stderr, "\
  562.          [+speed-large-files] [+ignore-matching-lines=regexp] [+new-file]\n\
  563.          [+initial-tab] [+starting-file=file] [+text] [+all-text] [+ascii]\n\
  564. ***************
  565. *** 416,421 ****
  566. --- 500,506 ----
  567.          [+file-label=label [+file-label=label]] [+version] path1 path2\n");
  568.     exit (2);
  569.   }
  570. + #endif
  571.   
  572.   specify_style (style)
  573.        enum output_style style;
  574. ***************
  575. *** 455,460 ****
  576. --- 540,546 ----
  577.       {
  578.         char *name = name0 == 0 ? name1 : name0;
  579.         char *dir = name0 == 0 ? dir1 : dir0;
  580. +       if (!output_patch_flag)
  581.       message ("Only in %s: %s\n", dir, name);
  582.         /* Return 1 so that diff_dirs will return 1 ("some files differ").  */
  583.         return 1;
  584. ***************
  585. *** 506,511 ****
  586. --- 592,604 ----
  587.       }
  588.       }
  589.   
  590. + #if !defined(MSDOS)
  591. +       /*
  592. +       ** this stuff is real bad idea under MSDOS, at least for MSC 5.1
  593. +       ** because the st_ino and st_dev fields are not supported by
  594. +       ** MSDOS, and so stat sets them to zero; therefore
  595. +       ** this test always succeeds.
  596. +       */
  597.     /* See if the two named files are actually the same physical file.
  598.        If so, we know they are identical without actually reading them.  */
  599.   
  600. ***************
  601. *** 518,523 ****
  602. --- 611,617 ----
  603.         val = 0;
  604.         goto done;
  605.       }
  606. + #endif        /* MSDOS */
  607.   
  608.     if (name0 == 0)
  609.       inf[0].dir_p = inf[1].dir_p;
  610. ***************
  611. *** 536,545 ****
  612.         inf[i].name = Standard_Input;
  613.       }
  614.         /* Don't bother opening if stat already failed.  */
  615. !       else if (stat_result[i] == 0 && ! inf[i].dir_p)
  616.       {
  617.         char *filename = inf[i].name;
  618. ! 
  619.         inf[i].desc = open (filename, O_RDONLY, 0);
  620.         if (0 > inf[i].desc)
  621.           {
  622. --- 630,648 ----
  623.         inf[i].name = Standard_Input;
  624.       }
  625.         /* Don't bother opening if stat already failed.  */
  626. !       else if (stat_result[i] == 0)
  627.       {
  628.         char *filename = inf[i].name;
  629. ! #if !defined(MSDOS)
  630. !       inf[i].desc = open (filename, O_RDONLY, 0);
  631. !       if (0 > inf[i].desc)
  632. !         {
  633. !           perror_with_name (filename);
  634. !           errorcount = 1;
  635. !         }
  636. ! #else
  637. !           if(inf[i].dir_p == 0)
  638. !           {
  639.         inf[i].desc = open (filename, O_RDONLY, 0);
  640.         if (0 > inf[i].desc)
  641.           {
  642. ***************
  643. *** 546,554 ****
  644. --- 649,665 ----
  645.             perror_with_name (filename);
  646.             errorcount = 1;
  647.           }
  648. +           } else
  649. +                 inf[i].desc = 0;
  650. + #endif    /* MSDOS */
  651.       }
  652.       }
  653.   
  654. +   if (name0 == 0)
  655. +     inf[0].dir_p = inf[1].dir_p;
  656. +   if (name1 == 0)
  657. +     inf[1].dir_p = inf[0].dir_p;
  658. + 
  659.     if (errorcount)
  660.       {
  661.   
  662. ***************
  663. *** 568,573 ****
  664. --- 679,685 ----
  665.       {
  666.         /* But don't compare dir contents one level down
  667.            unless -r was specified.  */
  668. +       if (!output_patch_flag)
  669.           message ("Common subdirectories: %s and %s\n",
  670.              inf[0].name, inf[1].name);
  671.         val = 0;
  672. ***************
  673. *** 637,642 ****
  674. --- 749,755 ----
  675.         else
  676.           {
  677.             char *dir = (inf[0].desc == -1) ? dir1 : dir0;
  678. +           if (!output_patch_flag)
  679.           message ("Only in %s: %s\n", dir, name0);
  680.             val = 1;
  681.           }
  682. diff -cbBw orig/diff.h diff/diff.h
  683. *** orig/diff.h    Mon Jan 28 20:17:56 1991
  684. --- diff/diff.h    Thu Jan 17 23:26:02 1991
  685. ***************
  686. *** 23,28 ****
  687. --- 23,30 ----
  688.   #include <sys/types.h>
  689.   #include <sys/stat.h>
  690.   
  691. + #include <string.h>
  692. + 
  693.   #ifdef USG
  694.   #include <time.h>
  695.   #ifdef HAVE_NDIR
  696. ***************
  697. *** 32,38 ****
  698. --- 34,42 ----
  699.   #include <ndir.h>
  700.   #endif /* not NDIR_IN_SYS */
  701.   #else
  702. + #ifndef MSDOS
  703.   #include <dirent.h>
  704. + #endif
  705.   #endif /* not HAVE_NDIR */
  706.   #include <fcntl.h>
  707.   #ifndef HAVE_DIRECT
  708. ***************
  709. *** 47,59 ****
  710. --- 51,69 ----
  711.   #ifdef USG
  712.   /* Define needed BSD functions in terms of sysV library.  */
  713.   
  714. + #ifdef MSDOS
  715. + #define bcopy(s,d,n)    memmove((d),(s),(n))
  716. + #else
  717.   #define bcopy(s,d,n)    memcpy((d),(s),(n))
  718. + #endif
  719.   #define bcmp(s1,s2,n)    memcmp((s1),(s2),(n))
  720.   #define bzero(s,n)    memset((s),0,(n))
  721.   
  722.   #ifndef XENIX
  723. + #ifndef MSDOS
  724.   #define dup2(f,t)    (close(t),fcntl((f),F_DUPFD,(t)))
  725.   #endif
  726. + #endif
  727.   
  728.   #define vfork    fork
  729.   #define index    strchr
  730. ***************
  731. *** 65,81 ****
  732. --- 75,100 ----
  733.   #define vfork fork
  734.   #endif
  735.   
  736. + #ifdef MSDOS
  737. + #include <process.h>
  738. + #include <stdlib.h>
  739. + #endif /* MSDOS */
  740. + 
  741.   #include <errno.h>
  742. + #if !defined(MSDOS)
  743.   extern int      errno;
  744.   extern int      sys_nerr;
  745.   extern char    *sys_errlist[];
  746. + #endif
  747.   
  748.   #define    EOS        (0)
  749.   #define    FALSE        (0)
  750.   #define TRUE        1
  751.   
  752. + #if !defined(min)
  753.   #define min(a,b) ((a) <= (b) ? (a) : (b))
  754.   #define max(a,b) ((a) >= (b) ? (a) : (b))
  755. + #endif /* MSDOS */
  756.   
  757.   #ifndef PR_FILE_NAME
  758.   #define PR_FILE_NAME "/bin/pr"
  759. ***************
  760. *** 83,96 ****
  761.   
  762.   /* Support old-fashioned C compilers.  */
  763.   #if defined (__STDC__) || defined (__GNUC__)
  764.   #include "limits.h"
  765.   #else
  766.   #define INT_MAX 2147483647
  767.   #define CHAR_BIT 8
  768.   #endif
  769.   
  770.   /* Support old-fashioned C compilers.  */
  771. ! #if !defined (__STDC__) && !defined (__GNUC__)
  772.   #define const
  773.   #endif
  774.   
  775. --- 102,130 ----
  776.   
  777.   /* Support old-fashioned C compilers.  */
  778.   #if defined (__STDC__) || defined (__GNUC__)
  779. + #if !defined(MSDOS)
  780.   #include "limits.h"
  781.   #else
  782. + #include <limits.h>
  783. + #endif        /* MSDOS */
  784. + #else
  785.   #define INT_MAX 2147483647
  786.   #define CHAR_BIT 8
  787.   #endif
  788.   
  789. + #if defined(MSDOS)
  790. + #ifdef INT_MAX
  791. + #undef INT_MAX
  792. + #include <limits.h>
  793. + #endif
  794. + #include <malloc.h>
  795. + #include <io.h>
  796. + #include <memory.h>
  797. + extern int getopt(int nargc,char **nargv,char *ostr);
  798. + #endif
  799. + 
  800.   /* Support old-fashioned C compilers.  */
  801. ! #if !defined (__STDC__) && !defined (__GNUC__) || defined(MSDOS)
  802.   #define const
  803.   #endif
  804.   
  805. ***************
  806. *** 120,126 ****
  807.     /* Like -f, but output a count of changed lines in each "command" (-n). */
  808.     OUTPUT_RCS,
  809.     /* Output merged #ifdef'd file (-D).  */
  810. !   OUTPUT_IFDEF };
  811.   
  812.   /* True for output styles that are robust,
  813.      i.e. can handle a file that ends in a non-newline.  */
  814. --- 154,163 ----
  815.     /* Like -f, but output a count of changed lines in each "command" (-n). */
  816.     OUTPUT_RCS,
  817.     /* Output merged #ifdef'd file (-D).  */
  818. !   OUTPUT_IFDEF,
  819. !   /* Output merged in side-by-side display (-m). */
  820. !   OUTPUT_MERGED
  821. ! };
  822.   
  823.   /* True for output styles that are robust,
  824.      i.e. can handle a file that ends in a non-newline.  */
  825. ***************
  826. *** 199,204 ****
  827. --- 236,244 ----
  828.   /* Pipe each file's output through pr (-l).  */
  829.   EXTERN int    paginate_flag;
  830.   
  831. + /* Line width for the merged display (-m,-M).  */
  832. + EXTERN int    line_width;
  833. + 
  834.   /* String to use for #ifdef (-D).  */
  835.   EXTERN char *    ifdef_string;
  836.   
  837. ***************
  838. *** 210,215 ****
  839. --- 250,258 ----
  840.   /* Nonzero means use heuristics for better speed.  */
  841.   EXTERN int    heuristic;
  842.   
  843. + /* Reduce extraneous output when they're outputting a patch. */
  844. + EXTERN int    output_patch_flag;
  845. + 
  846.   /* Name of program the user invoked (for error messages).  */
  847.   EXTERN char *    program;
  848.   
  849. ***************
  850. *** 239,245 ****
  851. --- 282,292 ----
  852.   /* Data on one line of text.  */
  853.   
  854.   struct line_def {
  855. + #ifdef MSDOS
  856. +     char _huge  *text;
  857. + #else
  858.       char        *text;
  859. + #endif
  860.       int         length;
  861.       unsigned    hash;
  862.   };
  863. ***************
  864. *** 252,257 ****
  865. --- 299,305 ----
  866.       struct stat     stat;    /* File status from fstat()  */
  867.       int             dir_p;    /* 1 if file is a directory  */
  868.   
  869. + #if !defined(MSDOS)
  870.       /* Buffer in which text of file is read.  */
  871.       char *        buffer;
  872.       /* Allocated size of buffer.  */
  873. ***************
  874. *** 279,284 ****
  875. --- 327,361 ----
  876.   
  877.       /* Count of lines in the suffix. */
  878.       int suffix_lines;
  879. + #else /* MSDOS */
  880. +     /* Buffer in which text of file is read.  */
  881. +     char _huge *buffer;
  882. +     /* Allocated size of buffer.  */
  883. +     long int        bufsize;
  884. +     /* Number of valid characters now in the buffer. */
  885. +     long int        buffered_chars;
  886. + 
  887. +     /* Array of data on analyzed lines of this chunk of this file.  */
  888. +     struct line_def _huge *linbuf;
  889. + 
  890. +     /* Allocated size of linbuf array (# of elements).  */
  891. +     int            linbufsize;
  892. + 
  893. +     /* Number of elements of linbuf containing valid data. */
  894. +     int            buffered_lines;
  895. + 
  896. +     /* Pointer to end of prefix of this file to ignore when hashing. */
  897. +     char _huge *prefix_end;
  898. + 
  899. +     /* Count of lines in the prefix. */
  900. +     int prefix_lines;
  901. + 
  902. +     /* Pointer to start of suffix of this file to ignore when hashing. */
  903. +     char _huge *suffix_begin;
  904. + 
  905. +     /* Count of lines in the suffix. */
  906. +     int suffix_lines;
  907. + #endif        /* MSDOS */
  908.   
  909.       /* Vector, indexed by line number, containing an equivalence code for
  910.          each line.  It is this vector that is actually compared with that
  911. ***************
  912. *** 366,370 ****
  913. --- 443,456 ----
  914.   void print_1_line ();
  915.   void print_message_queue ();
  916.   void print_number_range ();
  917. + 
  918. + #ifdef MSDOS
  919. + void _huge *hrealloc(void _huge *, long, long);
  920. + #endif
  921.   void print_script ();
  922.   void translate_range ();
  923. + 
  924. + 
  925. + #ifdef PROTO
  926. + #include "proto.h"
  927. + #endif
  928. diff -cbBw orig/diff3.c diff/diff3.c
  929. *** orig/diff3.c    Mon Jan 28 20:18:04 1991
  930. --- diff/diff3.c    Thu Jan 17 23:07:26 1991
  931. ***************
  932. *** 32,37 ****
  933. --- 32,61 ----
  934.   #include <sys/types.h>
  935.   #include <sys/stat.h>
  936.   
  937. + #include <getopt.h>
  938. + 
  939. + #ifdef OS2
  940. + 
  941. + #include <stdlib.h>
  942. + 
  943. + extern FILE *popen(char *, char *);
  944. + extern int pclose(FILE *);
  945. + 
  946. + #define WEXITSTATUS(stat_val)  (stat_val & 255)
  947. + #define WIFEXITED(stat_val)    (((unsigned)stat_val >> 8) == 0)
  948. + /* pclose() returns status in inverse byte order than wait() does */
  949. + 
  950. + #define bcopy(s,d,n)    memmove((d),(s),(n))
  951. + #define bcmp(s1,s2,n)    memcmp((s1),(s2),(n))
  952. + #define bzero(s,n)    memset((s),0,(n))
  953. + 
  954. + #define index    strchr
  955. + #define rindex    strrchr
  956. + 
  957. + #else  /* OS2 */
  958. + 
  959. + extern char **environ;
  960. + 
  961.   #ifdef USG
  962.   #include <fcntl.h>
  963.   
  964. ***************
  965. *** 58,63 ****
  966. --- 82,89 ----
  967.   #define WIFEXITED(stat_val) (((stat_val) & 255) == 0)
  968.   #endif
  969.   
  970. + #endif /* OS2 */
  971. + 
  972.   #ifdef sparc
  973.   /* vfork clobbers registers on the Sparc, so don't use it.  */
  974.   #define vfork fork
  975. ***************
  976. *** 390,398 ****
  977.   void
  978.   usage ()
  979.   {
  980. !   fprintf (stderr, "Usage:\t%s [-exEX3 [-i | -m] [-L label1 -L label3]] file1 file2 file3\n",
  981.          argv0);
  982. !   fprintf (stderr, "\tOnly one of [exEX3] allowed\n");
  983.     exit (2);
  984.   }
  985.   
  986. --- 416,438 ----
  987.   void
  988.   usage ()
  989.   {
  990. !   extern char *version_string;
  991. ! 
  992. !   printf ("\nGNU diff3, version %s\n", version_string);
  993. !   printf ("\nUsage:\t%s [-exEX3 [-a] [-i | -m] [-L label1 -L label3]] file1 file2 file3\n",
  994.          argv0);
  995. ! 
  996. !   printf ("\n  -e   Create ed script."
  997. !           "\n  -x   ED script, write only overlapping diffs."
  998. !           "\n  -E   ED script, flag overlapping diffs."
  999. !           "\n  -X   ED script, write and flag only overlapping diffs."
  1000. !           "\n  -3   ED script, write only non-overlapping diffs."
  1001. !           "\n  -a   Treat all files as text, never as binary."
  1002. !           "\n  -i   Like -e, but append final :wq commands."
  1003. !           "\n  -m   Output a merged file."
  1004. !           "\n  -L label   use the specified label for lines output by the -E and -X options.\n");
  1005. ! 
  1006. !   printf ("\nOnly one of [exEX3] is allowed.\n");
  1007.     exit (2);
  1008.   }
  1009.   
  1010. ***************
  1011. *** 960,967 ****
  1012.    * Routines to input and parse two way diffs.
  1013.    */
  1014.   
  1015. - extern char **environ;
  1016. - 
  1017.   #define    DIFF_CHUNK_SIZE    10000
  1018.   
  1019.   struct diff_block *
  1020. --- 1000,1005 ----
  1021. ***************
  1022. *** 1170,1182 ****
  1023. --- 1208,1227 ----
  1024.        char *filea, *fileb;
  1025.        char **output_placement;
  1026.   {
  1027. + #ifndef OS2
  1028.     char *argv[6];
  1029.     char **ap;
  1030. + #endif
  1031.     int fds[2];
  1032.     char *diff_result;
  1033.     int current_chunk_size;
  1034.     int bytes;
  1035.     int total;
  1036. + #ifdef OS2
  1037. +   FILE *pipe;
  1038. +   char buffer[256];
  1039. +   int wstatus;
  1040. + #else
  1041.     int pid, w;
  1042.     int wstatus;
  1043.   
  1044. ***************
  1045. *** 1188,1194 ****
  1046. --- 1233,1245 ----
  1047.     *ap++ = filea;
  1048.     *ap++ = fileb;
  1049.     *ap = (char *) 0;
  1050. + #endif
  1051.   
  1052. + #ifdef OS2
  1053. +   sprintf(buffer, "%s -a -- %s %s", diff_program, filea, fileb);
  1054. +   pipe = popen(buffer, "r");
  1055. +   fds[0] = fileno(pipe);
  1056. + #else
  1057.     if (pipe (fds) < 0)
  1058.       perror_with_exit ("Pipe failed");
  1059.   
  1060. ***************
  1061. *** 1213,1218 ****
  1062. --- 1264,1270 ----
  1063.       perror_with_exit ("Fork failed");
  1064.   
  1065.     close (fds[1]);        /* Prevent erroneous lack of EOF */
  1066. + #endif
  1067.     current_chunk_size = DIFF_CHUNK_SIZE;
  1068.     diff_result = (char *) xmalloc (current_chunk_size);
  1069.     total = 0;
  1070. ***************
  1071. *** 1222,1228 ****
  1072. --- 1274,1285 ----
  1073.               current_chunk_size - total);
  1074.       total += bytes;
  1075.       if (total == current_chunk_size)
  1076. + #ifdef OS2
  1077. +       diff_result = (char *) xrealloc (diff_result,
  1078. +         (current_chunk_size += DIFF_CHUNK_SIZE));
  1079. + #else
  1080.         diff_result = (char *) xrealloc (diff_result, (current_chunk_size *= 2));
  1081. + #endif
  1082.     } while (bytes);
  1083.   
  1084.     if (total != 0 && diff_result[total-1] != '\n')
  1085. ***************
  1086. *** 1230,1239 ****
  1087. --- 1287,1300 ----
  1088.   
  1089.     *output_placement = diff_result;
  1090.   
  1091. + #ifdef OS2
  1092. +   wstatus = pclose(pipe);
  1093. + #else
  1094.     do
  1095.       if ((w = wait (&wstatus)) == -1)
  1096.         perror_with_exit ("Wait failed");
  1097.     while (w != pid);
  1098. + #endif
  1099.   
  1100.     if (! (WIFEXITED (wstatus) && WEXITSTATUS (wstatus) < 2))
  1101.       fatal ("Subsidiary diff failed");
  1102. ***************
  1103. *** 1332,1338 ****
  1104.       case DIFF_3RD:
  1105.         oddoneout = rev_mapping[(int) ptr->correspond - (int) DIFF_1ST];
  1106.   
  1107. !       x[0] = oddoneout + '1';
  1108.         x[1] = '\0';
  1109.         dontprint = oddoneout==0;
  1110.         break;
  1111. --- 1393,1399 ----
  1112.       case DIFF_3RD:
  1113.         oddoneout = rev_mapping[(int) ptr->correspond - (int) DIFF_1ST];
  1114.   
  1115. !       x[0] = (char) (oddoneout + '1');
  1116.         x[1] = '\0';
  1117.         dontprint = oddoneout==0;
  1118.         break;
  1119. diff -cbBw orig/dir.c diff/dir.c
  1120. *** orig/dir.c    Mon Jan 28 20:18:06 1991
  1121. --- diff/dir.c    Thu Jan 17 23:07:26 1991
  1122. ***************
  1123. *** 31,36 ****
  1124. --- 31,176 ----
  1125.     char **files;            /* Sorted names of files in the dir */
  1126.   };
  1127.   
  1128. + #if defined(MSDOS)
  1129. + /*
  1130. + ** due to difference of opinion btw gnu and microsoft about what
  1131. + ** const means, const is defined away in diff.h, which causes warnings
  1132. + ** when compiling the headers.  This ugliness is avoided here.
  1133. + */
  1134. + #ifdef const
  1135. + #undef const
  1136. + #endif
  1137. + #include <string.h>
  1138. + #include <ctype.h>
  1139. + #ifdef OS2
  1140. + #define strcmp stricmp
  1141. +   /* stricmp() this is important for the HPFS because it is
  1142. +   /* case-preserving but NOT case-sensitive */
  1143. + #include <stdlib.h>
  1144. + #define INCL_NOPM
  1145. + #include <os2.h>
  1146. + #define _A_NORMAL        0x00
  1147. + #define _A_SUBDIR        0x10
  1148. + #define _MAX_NAME        256
  1149. + #else
  1150. + #include <dos.h>
  1151. + #define _MAX_NAME        13
  1152. + #endif
  1153. + 
  1154. + struct direct {
  1155. +     char d_name[_MAX_NAME];
  1156. + };
  1157. + 
  1158. + typedef struct _dir {
  1159. +         int first;
  1160. + #ifdef OS2
  1161. +         FILEFINDBUF find;
  1162. + #else
  1163. +         struct find_t dta;
  1164. + #endif
  1165. +     struct direct current;
  1166. + } DIR;
  1167. + 
  1168. + #ifdef OS2
  1169. + static HDIR hdir;
  1170. + static USHORT count;
  1171. + static BOOL lower;
  1172. + #endif
  1173. + 
  1174. + #ifdef OS2
  1175. + int IsFileSystemFAT(char *dir)
  1176. + {
  1177. +   USHORT nDrive;
  1178. +   ULONG lMap;
  1179. +   BYTE bData[64], bName[3];
  1180. +   USHORT cbData;
  1181. + 
  1182. +   if ( _osmode == DOS_MODE )
  1183. +     return TRUE;
  1184. +   else
  1185. +   {
  1186. +     /* We separate FAT and HPFS file systems here.
  1187. +      * Filenames read from a FAT system are converted to lower case
  1188. +      * while the case of filenames read from a HPFS (and other future
  1189. +      * file systems, like Unix-compatibles) is preserved.
  1190. +      */
  1191. + 
  1192. +     if ( isalpha(dir[0]) && (dir[1] == ':') )
  1193. +       nDrive = toupper(dir[0]) - '@';
  1194. +     else
  1195. +       DosQCurDisk(&nDrive, &lMap);
  1196. + 
  1197. +     bName[0] = (char) (nDrive + '@');
  1198. +     bName[1] = ':';
  1199. +     bName[2] = 0;
  1200. + 
  1201. +     cbData = sizeof(bData);
  1202. + 
  1203. +     if ( !DosQFSAttach(bName, 0U, 1U, bData, &cbData, 0L) )
  1204. +       return !strcmp(bData + (*(USHORT *) (bData + 2) + 7), "FAT");
  1205. +     else
  1206. +       return FALSE;
  1207. + 
  1208. +     /* End of this ugly code */
  1209. +   }
  1210. + }
  1211. + #endif
  1212. + 
  1213. + DIR *
  1214. + opendir(char *name) {
  1215. +     char localname[_MAX_NAME];
  1216. +     DIR *rval = malloc(sizeof(DIR));
  1217. +     strcpy(localname,name);
  1218. +         strcat(localname,"/*.*");
  1219. + #ifdef OS2
  1220. +         lower = IsFileSystemFAT(name);
  1221. +         hdir = count = 1;
  1222. + #endif
  1223. +     if(rval == NULL ||
  1224. + #ifdef OS2
  1225. +            DosFindFirst(localname, &hdir, _A_NORMAL|_A_SUBDIR, &rval->find,
  1226. +                         sizeof(FILEFINDBUF), &count, 0L) != 0)
  1227. + #else
  1228. +           _dos_findfirst(localname,_A_NORMAL|_A_SUBDIR,&rval->dta) != 0)
  1229. + #endif
  1230. +                 return NULL;
  1231. +     rval->first = 1;
  1232. +     return rval;
  1233. + }
  1234. + 
  1235. + void
  1236. + closedir(DIR *x) {
  1237. +     free(x);
  1238. + }
  1239. + 
  1240. + struct direct *
  1241. + readdir(DIR *thisdir) {
  1242. +     /*
  1243. +     ** first time through, we don't need to look for a file
  1244. +     */
  1245. +         if(!thisdir->first) {
  1246. + #ifdef OS2
  1247. +                 if(DosFindNext(hdir, &thisdir->find, sizeof(FILEFINDBUF),
  1248. +                                &count) != 0)
  1249. + #else
  1250. +                 if(_dos_findnext(&thisdir->dta) != 0)
  1251. + #endif
  1252. +             return NULL;
  1253. +     } else
  1254. +                 thisdir->first = 0;
  1255. + #ifdef OS2
  1256. +         strcpy(thisdir->current.d_name,thisdir->find.achName);
  1257. + #else
  1258. +         strcpy(thisdir->current.d_name,thisdir->dta.name);
  1259. + #endif
  1260. +     /* thisdir->current.d_name[13] = '\0'; */
  1261. +         if ( lower )
  1262. +       strlwr(thisdir->current.d_name);
  1263. +     return &thisdir->current;
  1264. + }
  1265. + 
  1266. + #endif /* MSDOS */
  1267. + 
  1268.   static struct dirdata
  1269.   dir_sort (dirname, nonex)
  1270.        char *dirname;
  1271. ***************
  1272. *** 135,142 ****
  1273.   int
  1274.   diff_dirs (name1, name2, handle_file, depth, nonex1, nonex2)
  1275.        char *name1, *name2;
  1276.        int (*handle_file) ();
  1277. !      int nonex1, nonex2;
  1278.   {
  1279.     struct dirdata data1, data2;
  1280.     register int i1, i2;
  1281. --- 275,290 ----
  1282.   int
  1283.   diff_dirs (name1, name2, handle_file, depth, nonex1, nonex2)
  1284.        char *name1, *name2;
  1285. + #if !defined(MSDOS)
  1286.        int (*handle_file) ();
  1287. ! #else
  1288. !       /* sorry, rms, I can't live with the assumption that
  1289. !       ** sizeof(char *) == sizeof(int)
  1290. !       */
  1291. !       int (*handle_file)(char *dir0,char *name0,
  1292. !               char *dir1,char *name1,int depth);
  1293. ! #endif
  1294. !      int depth, nonex1, nonex2;
  1295.   {
  1296.     struct dirdata data1, data2;
  1297.     register int i1, i2;
  1298. diff -cbBw orig/getopt.c diff/getopt.c
  1299. *** orig/getopt.c    Mon Jan 28 20:18:10 1991
  1300. --- diff/getopt.c    Thu Jan 17 23:07:26 1991
  1301. ***************
  1302. *** 15,25 ****
  1303.      along with this program; if not, write to the Free Software
  1304.      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  1305.   
  1306. ! #ifdef __STDC__
  1307.   #define CONST const
  1308.   #else
  1309.   #define CONST
  1310.   #endif
  1311.   
  1312.   /* This version of `getopt' appears to the caller like standard Unix `getopt'
  1313.      but it behaves differently for the user, since it allows the user
  1314. --- 15,28 ----
  1315.      along with this program; if not, write to the Free Software
  1316.      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  1317.   
  1318. ! #if defined(__STDC__) || defined(MSDOS)
  1319.   #define CONST const
  1320.   #else
  1321.   #define CONST
  1322.   #endif
  1323. + #ifdef MSDOS
  1324. + #define STDC_HEADERS
  1325. + #endif
  1326.   
  1327.   /* This version of `getopt' appears to the caller like standard Unix `getopt'
  1328.      but it behaves differently for the user, since it allows the user
  1329. ***************
  1330. *** 44,51 ****
  1331. --- 47,58 ----
  1332.   #ifdef sparc
  1333.   #include <alloca.h>
  1334.   #else
  1335. + #ifdef MSDOS
  1336. + #include <malloc.h>
  1337. + #else
  1338.   char *alloca ();
  1339.   #endif
  1340. + #endif
  1341.   #endif /* not __GNUC__ */
  1342.   
  1343.   #if defined(STDC_HEADERS) || defined(__GNU_LIBRARY__)
  1344. ***************
  1345. *** 72,77 ****
  1346. --- 79,86 ----
  1347.   char *malloc ();
  1348.   #endif
  1349.   
  1350. + static void exchange (char **);
  1351. + 
  1352.   /* For communication from `getopt' to the caller.
  1353.      When `getopt' finds an option that takes an argument,
  1354.      the argument value is returned here.
  1355. ***************
  1356. *** 376,382 ****
  1357.          p++, option_index++)
  1358.       if (!strncmp (p->name, nextchar, s - nextchar))
  1359.         {
  1360. !         if (s - nextchar == strlen (p->name))
  1361.             {
  1362.           /* Exact match found.  */
  1363.           pfound = p;
  1364. --- 385,391 ----
  1365.          p++, option_index++)
  1366.       if (!strncmp (p->name, nextchar, s - nextchar))
  1367.         {
  1368. !         if (s - nextchar == (int) strlen (p->name))
  1369.             {
  1370.           /* Exact match found.  */
  1371.           pfound = p;
  1372. diff -cbBw orig/getopt.h diff/getopt.h
  1373. *** orig/getopt.h    Mon Jan 28 20:18:12 1991
  1374. --- diff/getopt.h    Thu Jan 17 23:07:26 1991
  1375. ***************
  1376. *** 70,76 ****
  1377.     int val;
  1378.   };
  1379.   
  1380. ! #ifdef __STDC__
  1381.   extern const struct option *_getopt_long_options;
  1382.   #else
  1383.   extern struct option *_getopt_long_options;
  1384. --- 70,76 ----
  1385.     int val;
  1386.   };
  1387.   
  1388. ! #if defined(__STDC__) || defined(MSDOS)
  1389.   extern const struct option *_getopt_long_options;
  1390.   #else
  1391.   extern struct option *_getopt_long_options;
  1392. ***************
  1393. *** 87,93 ****
  1394.   
  1395.   extern int option_index;
  1396.   
  1397. ! #ifdef __STDC__
  1398.   int getopt (int argc, char **argv, const char *shortopts);
  1399.   int getopt_long (int argc, char **argv, const char *shortopts,
  1400.            const struct option *longopts, int *longind);
  1401. --- 87,93 ----
  1402.   
  1403.   extern int option_index;
  1404.   
  1405. ! #if defined(__STDC__) || defined(MSDOS)
  1406.   int getopt (int argc, char **argv, const char *shortopts);
  1407.   int getopt_long (int argc, char **argv, const char *shortopts,
  1408.            const struct option *longopts, int *longind);
  1409. diff -cbBw orig/getopt1.c diff/getopt1.c
  1410. *** orig/getopt1.c    Mon Jan 28 20:18:14 1991
  1411. --- diff/getopt1.c    Thu Jan 17 23:07:26 1991
  1412. ***************
  1413. *** 17,23 ****
  1414.   
  1415.   #include "getopt.h"
  1416.   
  1417. ! #ifdef __STDC__
  1418.   #define CONST const
  1419.   #else
  1420.   #define CONST
  1421. --- 17,23 ----
  1422.   
  1423.   #include "getopt.h"
  1424.   
  1425. ! #if defined(__STDC__) || defined(MSDOS)
  1426.   #define CONST const
  1427.   #else
  1428.   #define CONST
  1429. ***************
  1430. *** 38,43 ****
  1431. --- 38,44 ----
  1432.     int val;
  1433.   
  1434.     _getopt_long_options = long_options;
  1435. +   _getopt_long_only = 0;
  1436.     val = getopt (argc, argv, options);
  1437.     if (val == 0 && opt_index != NULL)
  1438.       *opt_index = option_index;
  1439. diff -cbBw orig/io.c diff/io.c
  1440. *** orig/io.c    Mon Jan 28 20:18:20 1991
  1441. --- diff/io.c    Thu Jan 17 23:07:26 1991
  1442. ***************
  1443. *** 20,27 ****
  1444. --- 20,31 ----
  1445.   #include "diff.h"
  1446.   
  1447.   /* Rotate a value n bits to the left. */
  1448. + #if !defined(MSDOS)
  1449.   #define UINT_BIT (sizeof (unsigned) * CHAR_BIT)
  1450.   #define ROL(v, n) ((v) << (n) | (v) >> UINT_BIT - (n))
  1451. + #else
  1452. + #define ROL(v,n)  ((v) << (n) | (v) >> (sizeof(v) * CHAR_BIT) - (n))
  1453. + #endif
  1454.   
  1455.   /* Given a hash value and a new character, return a new hash value. */
  1456.   #define HASH(h, c) ((c) + ROL (h, 7))
  1457. ***************
  1458. *** 57,66 ****
  1459. --- 61,77 ----
  1460.       1, 1, 1, 1, 1, 1, 1, 1,
  1461.       1, 1, 1, 1, 1, 1, 1, 1,
  1462.       1, 1, 1, 1, 1, 1, 1, 0,
  1463. + #ifdef MSDOS
  1464. +     1, 1, 1, 1, 1, 1, 1, 1,
  1465. +     1, 1, 1, 1, 1, 1, 1, 1,
  1466. +     1, 1, 1, 1, 1, 1, 1, 1,
  1467. +     1, 1, 1, 1, 1, 1, 1, 1,
  1468. + #else
  1469.       0, 0, 0, 0, 0, 0, 0, 0,
  1470.       0, 0, 0, 0, 0, 0, 0, 0,
  1471.       0, 0, 0, 0, 0, 0, 0, 0,
  1472.       0, 0, 0, 0, 0, 0, 0, 0,
  1473. + #endif
  1474.       1, 1, 1, 1, 1, 1, 1, 1,
  1475.       1, 1, 1, 1, 1, 1, 1, 1,
  1476.       1, 1, 1, 1, 1, 1, 1, 1,
  1477. ***************
  1478. *** 101,106 ****
  1479. --- 112,118 ----
  1480.        beyond those that current->bufsize describes:
  1481.        one for a newline (in case the text does not end with one)
  1482.        and one for a sentinel in find_identical_ends.  */
  1483. + #if !defined(MSDOS)
  1484.     else if ((current->stat.st_mode & S_IFMT) == S_IFREG)
  1485.       {
  1486.         current->bufsize = current->stat.st_size;
  1487. ***************
  1488. *** 136,146 ****
  1489.         if (cc < 0)
  1490.       pfatal_with_name (current->name);
  1491.       }
  1492.   
  1493.     /* Check first part of file to see if it's a binary file.  */
  1494.     if (! always_text_flag
  1495.         && binary_file_p (current->buffer,
  1496. !             min (current->buffered_chars, binary_file_threshold)))
  1497.       return 1;
  1498.   
  1499.     /* If not binary, make sure text ends in a newline,
  1500. --- 148,191 ----
  1501.         if (cc < 0)
  1502.       pfatal_with_name (current->name);
  1503.       }
  1504. + #else /* MSDOS */
  1505. +   else {
  1506. +       int count;
  1507. +       char _huge *ptr;
  1508. +       char *buf;
  1509. + 
  1510. +       current->bufsize = current->stat.st_size + 1;
  1511. +       if((current->buffer = halloc(current->bufsize + 2,sizeof(char))) == NULL)
  1512. +              fatal("virtual memory exhausted");
  1513. + 
  1514. +       current->buffered_chars = 0;
  1515. +       ptr = current->buffer;
  1516. + 
  1517. +      /* this kludge is the only way to prevent read() from segment
  1518. +       * wraparounds in real mode in a OS/2 family mode application  :-( :-(
  1519. +       */
  1520. + 
  1521. +       if((buf = malloc(16384)) == NULL)
  1522. +              fatal("virtual memory exhausted");
  1523. + 
  1524. +       while((count = read(current->desc, buf, 16384)) > 0)
  1525. +       {
  1526. +              memcpy(ptr, buf, count); /* memcpy is aware of huge pointers */
  1527. +              current->buffered_chars += count;
  1528. +              ptr += count;
  1529. +       }
  1530. + 
  1531. +       free(buf);
  1532. + 
  1533. +       if (count < 0)
  1534. +     pfatal_with_name (current->name);
  1535. +     }
  1536. + #endif        /* MSDOS */
  1537.   
  1538.     /* Check first part of file to see if it's a binary file.  */
  1539.     if (! always_text_flag
  1540.         && binary_file_p (current->buffer,
  1541. !             (int) min (current->buffered_chars, binary_file_threshold)))
  1542.       return 1;
  1543.   
  1544.     /* If not binary, make sure text ends in a newline,
  1545. ***************
  1546. *** 169,180 ****
  1547.   {
  1548.     unsigned h;
  1549.     int i;
  1550. !   unsigned char *p = (unsigned char *) current->prefix_end, *ip, c;
  1551.   
  1552.     /* Attempt to get a good initial guess as to the number of lines. */
  1553.     current->linbufsize = current->buffered_chars / 50 + 5;
  1554.     current->linbuf
  1555.       = (struct line_def *) xmalloc (current->linbufsize * sizeof (struct line_def));
  1556.   
  1557.     if (function_regexp || output_style == OUTPUT_IFDEF)
  1558.       {
  1559. --- 214,238 ----
  1560.   {
  1561.     unsigned h;
  1562.     int i;
  1563. ! #if !defined(MSDOS)
  1564. !   char *p = current->prefix_end, *ip, c;
  1565. ! #else
  1566. !   char _huge *p = (char _huge *) current->prefix_end;
  1567. !   char _huge *ip, c;
  1568. !   int old;
  1569. ! #endif
  1570.   
  1571.     /* Attempt to get a good initial guess as to the number of lines. */
  1572.     current->linbufsize = current->buffered_chars / 50 + 5;
  1573. + #if !defined(MSDOS)
  1574.     current->linbuf
  1575.       = (struct line_def *) xmalloc (current->linbufsize * sizeof (struct line_def));
  1576. + #else
  1577. +   current->linbuf
  1578. +     = halloc(current->linbufsize, sizeof(struct line_def));
  1579. +   if ( current->linbuf == NULL )
  1580. +     fatal("virtual memory exhausted");
  1581. + #endif
  1582.   
  1583.     if (function_regexp || output_style == OUTPUT_IFDEF)
  1584.       {
  1585. ***************
  1586. *** 183,189 ****
  1587.        but since we don't know how many, it's easiest to find them all.
  1588.        If -D is specified, we need all the lines of the first file.  */
  1589.         current->buffered_lines = 0;
  1590. !       p = (unsigned char *) current->buffer;
  1591.       }
  1592.     else
  1593.       {
  1594. --- 241,247 ----
  1595.        but since we don't know how many, it's easiest to find them all.
  1596.        If -D is specified, we need all the lines of the first file.  */
  1597.         current->buffered_lines = 0;
  1598. !       p = current->buffer;
  1599.       }
  1600.     else
  1601.       {
  1602. ***************
  1603. *** 195,212 ****
  1604.       current->buffered_lines = 0;
  1605.         for (i = 0; i < context + 1; ++i)
  1606.       /* Unless we are at the beginning, */
  1607. !     if ((char *) p != current->buffer)
  1608.         /* Back up at least 1 char until at the start of a line.  */
  1609. !       while ((char *) --p != current->buffer && p[-1] != '\n')
  1610.           ;
  1611.       }
  1612.   
  1613. !   while ((char *) p < current->suffix_begin)
  1614.       {
  1615.         h = 0;
  1616.         ip = p;
  1617.   
  1618. !       if (current->prefix_end <= (char *) p)
  1619.       {
  1620.         /* Hash this line until we find a newline. */
  1621.         if (ignore_case_flag)
  1622. --- 253,270 ----
  1623.       current->buffered_lines = 0;
  1624.         for (i = 0; i < context + 1; ++i)
  1625.       /* Unless we are at the beginning, */
  1626. !     if (p != current->buffer)
  1627.         /* Back up at least 1 char until at the start of a line.  */
  1628. !       while ( --p != current->buffer && p[-1] != '\n')
  1629.           ;
  1630.       }
  1631.   
  1632. !   while (p < current->suffix_begin)
  1633.       {
  1634.         h = 0;
  1635.         ip = p;
  1636.   
  1637. !       if (current->prefix_end <= p)
  1638.       {
  1639.         /* Hash this line until we find a newline. */
  1640.         if (ignore_case_flag)
  1641. ***************
  1642. *** 291,298 ****
  1643. --- 349,358 ----
  1644.         /* Maybe increase the size of the line table. */
  1645.         if (current->buffered_lines >= current->linbufsize)
  1646.       {
  1647. + #ifndef MSDOS
  1648.         while (current->buffered_lines >= current->linbufsize)
  1649.           current->linbufsize *= 2;
  1650. + 
  1651.         current->linbuf
  1652.           = (struct line_def *) xrealloc (current->linbuf,
  1653.                           current->linbufsize
  1654. ***************
  1655. *** 297,304 ****
  1656.           = (struct line_def *) xrealloc (current->linbuf,
  1657.                           current->linbufsize
  1658.                           * sizeof (struct line_def));
  1659.       }
  1660. !       current->linbuf[current->buffered_lines].text = (char *) ip;
  1661.         current->linbuf[current->buffered_lines].length = p - ip + 1;
  1662.         current->linbuf[current->buffered_lines].hash = h;
  1663.         ++current->buffered_lines;
  1664. --- 357,377 ----
  1665.           = (struct line_def *) xrealloc (current->linbuf,
  1666.                           current->linbufsize
  1667.                           * sizeof (struct line_def));
  1668. + #else
  1669. +           old = current->linbufsize;
  1670. + 
  1671. +       while (current->buffered_lines >= current->linbufsize)
  1672. +         current->linbufsize += 2048;
  1673. + 
  1674. +       current->linbuf = hrealloc(current->linbuf,
  1675. +             (long) current->linbufsize * sizeof (struct line_def),
  1676. +             (long) old * sizeof (struct line_def));
  1677. + 
  1678. +           if ( current->linbuf == NULL )
  1679. +              fatal("too many lines");
  1680. + #endif
  1681.       }
  1682. !       current->linbuf[current->buffered_lines].text = ip;
  1683.         current->linbuf[current->buffered_lines].length = p - ip + 1;
  1684.         current->linbuf[current->buffered_lines].hash = h;
  1685.         ++current->buffered_lines;
  1686. ***************
  1687. *** 307,313 ****
  1688. --- 380,390 ----
  1689.   
  1690.     i = 0;
  1691.     while ((i < context || output_style == OUTPUT_IFDEF)
  1692. + #ifndef MSDOS
  1693.        && (char *) p < current->buffer + current->buffered_chars)
  1694. + #else
  1695. +      && p < (char _huge *) current->buffer + current->buffered_chars)
  1696. + #endif
  1697.       {
  1698.         ip = p;
  1699.         while (*p++ != '\n')
  1700. ***************
  1701. *** 315,322 ****
  1702. --- 392,401 ----
  1703.         /* Maybe increase the size of the line table. */
  1704.         if (current->buffered_lines >= current->linbufsize)
  1705.       {
  1706. + #ifndef MSDOS
  1707.         while (current->buffered_lines >= current->linbufsize)
  1708.           current->linbufsize *= 2;
  1709. + 
  1710.         current->linbuf
  1711.           = (struct line_def *) xrealloc (current->linbuf,
  1712.                           current->linbufsize
  1713. ***************
  1714. *** 321,328 ****
  1715.           = (struct line_def *) xrealloc (current->linbuf,
  1716.                           current->linbufsize
  1717.                           * sizeof (struct line_def));
  1718.       }
  1719. !       current->linbuf[current->buffered_lines].text = (char *) ip;
  1720.         current->linbuf[current->buffered_lines].length = p - ip;
  1721.         current->linbuf[current->buffered_lines].hash = 0;
  1722.         ++current->buffered_lines;
  1723. --- 400,420 ----
  1724.           = (struct line_def *) xrealloc (current->linbuf,
  1725.                           current->linbufsize
  1726.                           * sizeof (struct line_def));
  1727. + #else
  1728. +           old = current->linbufsize;
  1729. + 
  1730. +       while (current->buffered_lines >= current->linbufsize)
  1731. +         current->linbufsize += 2048;
  1732. + 
  1733. +       current->linbuf = hrealloc(current->linbuf,
  1734. +             (long) current->linbufsize * sizeof (struct line_def),
  1735. +             (long) old * sizeof (struct line_def));
  1736. + 
  1737. +           if ( current->linbuf == NULL )
  1738. +              fatal("too many lines");
  1739. + #endif
  1740.       }
  1741. !       current->linbuf[current->buffered_lines].text = ip;
  1742.         current->linbuf[current->buffered_lines].length = p - ip;
  1743.         current->linbuf[current->buffered_lines].hash = 0;
  1744.         ++current->buffered_lines;
  1745. ***************
  1746. *** 342,348 ****
  1747. --- 434,444 ----
  1748.   find_identical_ends (filevec)
  1749.        struct file_data filevec[];
  1750.   {
  1751. + #ifndef MSDOS
  1752.     char *p0, *p1, *end0, *beg0;
  1753. + #else
  1754. +   char _huge *p0, _huge *p1, _huge *end0, _huge *beg0;
  1755. + #endif
  1756.     int lines;
  1757.   
  1758.     if (filevec[0].buffered_chars == 0 || filevec[1].buffered_chars == 0)
  1759. ***************
  1760. *** 383,397 ****
  1761.     /* Don't count missing newline as part of prefix in RCS mode. */
  1762.     if (ROBUST_OUTPUT_STYLE (output_style)
  1763.         && ((filevec[0].missing_newline
  1764. !        && p0 - filevec[0].buffer > filevec[0].buffered_chars)
  1765.         ||
  1766.         (filevec[1].missing_newline
  1767. !        && p1 - filevec[1].buffer > filevec[1].buffered_chars)))
  1768.       --p0, --p1, --lines;
  1769.   
  1770.     /* If the sentinel was passed, and lengths are equal, the
  1771.        files are identical.  */
  1772. !   if (p0 - filevec[0].buffer > filevec[0].buffered_chars
  1773.         && filevec[0].buffered_chars == filevec[1].buffered_chars)
  1774.       {
  1775.         filevec[0].prefix_end = p0 - 1;
  1776. --- 479,493 ----
  1777.     /* Don't count missing newline as part of prefix in RCS mode. */
  1778.     if (ROBUST_OUTPUT_STYLE (output_style)
  1779.         && ((filevec[0].missing_newline
  1780. !        && (p0 - filevec[0].buffer) > filevec[0].buffered_chars)
  1781.         ||
  1782.         (filevec[1].missing_newline
  1783. !        && (p1 - filevec[1].buffer) > filevec[1].buffered_chars)))
  1784.       --p0, --p1, --lines;
  1785.   
  1786.     /* If the sentinel was passed, and lengths are equal, the
  1787.        files are identical.  */
  1788. !   if ((p0 - filevec[0].buffer) > filevec[0].buffered_chars
  1789.         && filevec[0].buffered_chars == filevec[1].buffered_chars)
  1790.       {
  1791.         filevec[0].prefix_end = p0 - 1;
  1792. ***************
  1793. *** 435,445 ****
  1794.         else
  1795.       /* Figure out where P0 will be when P1 is at the end of the prefix.
  1796.          Thus we only need to test P0.  */
  1797. !     beg0 = (filevec[0].prefix_end
  1798. !         + filevec[0].buffered_chars - filevec[1].buffered_chars);
  1799.   
  1800.         /* Scan back until chars don't match or we reach that point.  */
  1801. !       while (p0 != beg0)
  1802.       {
  1803.         char c = *--p0;
  1804.         if (c != *--p1)
  1805. --- 531,541 ----
  1806.         else
  1807.       /* Figure out where P0 will be when P1 is at the end of the prefix.
  1808.          Thus we only need to test P0.  */
  1809. !     beg0 = filevec[0].prefix_end
  1810. !         + (filevec[0].buffered_chars - filevec[1].buffered_chars);
  1811.   
  1812.         /* Scan back until chars don't match or we reach that point.  */
  1813. !       while (p0 > beg0)
  1814.       {
  1815.         char c = *--p0;
  1816.         if (c != *--p1)
  1817. ***************
  1818. *** 483,488 ****
  1819. --- 579,587 ----
  1820.   {
  1821.     struct equivclass *next;    /* Next item in this bucket. */
  1822.     struct line_def line;    /* A line that fits this class. */
  1823. + #ifdef MSDOS
  1824. +   long dummy; /* to pad struct size to a power of two, 16 */
  1825. + #endif
  1826.   };
  1827.   
  1828.   /* Hash-table: array of buckets, each being a chain of equivalence classes.  */
  1829. ***************
  1830. *** 494,511 ****
  1831.   /* Array in which the equivalence classes are allocated.
  1832.      The bucket-chains go through the elements in this array.
  1833.      The number of an equivalence class is its index in this array.  */
  1834. ! static struct equivclass *equivs;
  1835.   
  1836.   /* Index of first free element in the array `equivs'.  */
  1837. ! static int equivs_index;
  1838.   
  1839.   /* Size allocated to the array `equivs'.  */
  1840. ! static int equivs_alloc;
  1841.   
  1842.   /* Largest primes less than some power of two, for nbuckets.  Values range
  1843.      from useful to preposterous.  If one of these numbers isn't prime
  1844.      after all, don't blame it on me, blame it on primes (6) . . . */
  1845. ! static int primes[] =
  1846.   {
  1847.     509,
  1848.     1021,
  1849. --- 593,610 ----
  1850.   /* Array in which the equivalence classes are allocated.
  1851.      The bucket-chains go through the elements in this array.
  1852.      The number of an equivalence class is its index in this array.  */
  1853. ! static struct equivclass _huge *equivs;
  1854.   
  1855.   /* Index of first free element in the array `equivs'.  */
  1856. ! static long equivs_index;
  1857.   
  1858.   /* Size allocated to the array `equivs'.  */
  1859. ! static long equivs_alloc;
  1860.   
  1861.   /* Largest primes less than some power of two, for nbuckets.  Values range
  1862.      from useful to preposterous.  If one of these numbers isn't prime
  1863.      after all, don't blame it on me, blame it on primes (6) . . . */
  1864. ! static long primes[] =
  1865.   {
  1866.     509,
  1867.     1021,
  1868. ***************
  1869. *** 538,544 ****
  1870.        int n;
  1871.   {
  1872.     int bucket;
  1873. !   struct equivclass *b, *p = NULL;
  1874.   
  1875.     /* Equivalence class 0 is permanently allocated to lines that were
  1876.        not hashed because they were parts of identical prefixes or
  1877. --- 637,643 ----
  1878.        int n;
  1879.   {
  1880.     int bucket;
  1881. !   struct equivclass _huge *b, _huge *p = NULL;
  1882.   
  1883.     /* Equivalence class 0 is permanently allocated to lines that were
  1884.        not hashed because they were parts of identical prefixes or
  1885. ***************
  1886. *** 564,569 ****
  1887. --- 663,671 ----
  1888.   
  1889.     /* Create a new equivalence class in this bucket. */
  1890.   
  1891. +   if (equivs_index >= equivs_alloc)
  1892. +     fatal ("too many differences, hash table overflow");
  1893. + 
  1894.     p = &equivs[equivs_index++];
  1895.     p->next = buckets[bucket];
  1896.     buckets[bucket] = p;
  1897. ***************
  1898. *** 601,608 ****
  1899.       }
  1900.   
  1901.     /* This is guaranteed to be enough space.  */
  1902. !   equivs_alloc = filevec[0].buffered_lines + filevec[1].buffered_lines + 1;
  1903.     equivs = (struct equivclass *) xmalloc (equivs_alloc * sizeof (struct equivclass));
  1904.     /* Equivalence class 0 is permanently safe for lines that were not
  1905.        hashed.  Real equivalence classes start at 1. */
  1906.     equivs_index = 1;
  1907. --- 703,716 ----
  1908.       }
  1909.   
  1910.     /* This is guaranteed to be enough space.  */
  1911. !   equivs_alloc = (long) filevec[0].buffered_lines + filevec[1].buffered_lines + 1L;
  1912. ! #ifndef MSDOS
  1913.     equivs = (struct equivclass *) xmalloc (equivs_alloc * sizeof (struct equivclass));
  1914. + #else
  1915. +   equivs = halloc (equivs_alloc, sizeof (struct equivclass));
  1916. +   if ( equivs == NULL )
  1917. +     fatal("virtual memory exhausted");
  1918. + #endif
  1919.     /* Equivalence class 0 is permanently safe for lines that were not
  1920.        hashed.  Real equivalence classes start at 1. */
  1921.     equivs_index = 1;
  1922. ***************
  1923. *** 611,618 ****
  1924. --- 719,730 ----
  1925.     while (primes[primes_index] < equivs_alloc / 3)
  1926.       primes_index++;
  1927.   
  1928. + #ifndef MSDOS
  1929.     buckets = (struct equivclass **) xmalloc (primes[primes_index] * sizeof (struct equivclass *));
  1930.     bzero (buckets, primes[primes_index] * sizeof (struct equivclass *));
  1931. + #else
  1932. +   buckets = halloc (primes[primes_index], sizeof (struct equivclass *));
  1933. + #endif
  1934.     nbuckets = primes[primes_index];
  1935.   
  1936.     for (i = 0; i < 2; ++i)
  1937. ***************
  1938. *** 626,633 ****
  1939. --- 738,750 ----
  1940.   
  1941.     filevec[0].equiv_max = filevec[1].equiv_max = equivs_index;
  1942.   
  1943. + #ifndef MSDOS
  1944.     free (equivs);
  1945.     free (buckets);
  1946. + #else
  1947. +   hfree (equivs);
  1948. +   hfree (buckets);
  1949. + #endif
  1950.   
  1951.     return 0;
  1952.   }
  1953. diff -cbBw orig/limits.h diff/limits.h
  1954. *** orig/limits.h    Mon Jan 28 20:18:22 1991
  1955. --- diff/limits.h    Thu Jan 17 23:07:26 1991
  1956. ***************
  1957. *** 28,38 ****
  1958. --- 28,46 ----
  1959.   #define USHRT_MAX 65535U
  1960.   
  1961.   /* Minimum and maximum values a `signed int' can hold.  */
  1962. + #ifdef MSDOS
  1963. + #define INT_MIN (-32768)
  1964. + #define INT_MAX 32767
  1965. + 
  1966. + /* Maximum value an `unsigned int' can hold.  (Minimum is 0).  */
  1967. + #define UINT_MAX 65535U
  1968. + #else
  1969.   #define INT_MIN (-INT_MAX-1)
  1970.   #define INT_MAX 2147483647
  1971.   
  1972.   /* Maximum value an `unsigned int' can hold.  (Minimum is 0).  */
  1973.   #define UINT_MAX 4294967295U
  1974. + #endif
  1975.   
  1976.   /* Minimum and maximum values a `signed long int' can hold.
  1977.      (Same as `int').  */
  1978. diff -cbBw orig/util.c diff/util.c
  1979. *** orig/util.c    Mon Jan 28 20:18:26 1991
  1980. --- diff/util.c    Thu Jan 17 23:07:28 1991
  1981. ***************
  1982. *** 51,57 ****
  1983.        char *arg;
  1984.        char *arg1;
  1985.   {
  1986. !   fprintf (stderr, "%s: ", program);
  1987.     fprintf (stderr, format, arg, arg1);
  1988.     fprintf (stderr, "\n");
  1989.   }
  1990. --- 51,57 ----
  1991.        char *arg;
  1992.        char *arg1;
  1993.   {
  1994. !   fprintf (stderr, "\n%s: ", program);
  1995.     fprintf (stderr, format, arg, arg1);
  1996.     fprintf (stderr, "\n");
  1997.   }
  1998. ***************
  1999. *** 129,136 ****
  2000. --- 129,147 ----
  2001.     strcat (name, " ");
  2002.     strcat (name, name1);
  2003.   
  2004. + #if defined(MSDOS)
  2005.     if (paginate_flag)
  2006.       {
  2007. +       extern FILE *popen();
  2008. + 
  2009. +       /* Fork a `pr' and make OUTFILE a pipe to it.  */
  2010. +       outfile = popen("pr -o -", "w");
  2011. +       fprintf (outfile, "%s\n", name);
  2012. +     }
  2013. +   else
  2014. + #else
  2015. +   if (paginate_flag)
  2016. +     {
  2017.         int pipes[2];
  2018.         int desc;
  2019.   
  2020. ***************
  2021. *** 164,169 ****
  2022. --- 175,181 ----
  2023.       }
  2024.       }
  2025.     else
  2026. + #endif
  2027.       {
  2028.   
  2029.         /* If -l was not specified, output the diff straight to `stdout'.  */
  2030. ***************
  2031. *** 172,178 ****
  2032.   
  2033.         /* If handling multiple files (because scanning a directory),
  2034.        print which files the following output is about.  */
  2035. !       if (depth > 0)
  2036.       printf ("%s\n", name);
  2037.       }
  2038.   
  2039. --- 184,190 ----
  2040.   
  2041.         /* If handling multiple files (because scanning a directory),
  2042.        print which files the following output is about.  */
  2043. !       if (depth > 0 && !output_patch_flag)
  2044.       printf ("%s\n", name);
  2045.       }
  2046.   
  2047. ***************
  2048. *** 187,194 ****
  2049. --- 199,210 ----
  2050.   {
  2051.     if (outfile != stdout)
  2052.       {
  2053. + #if defined(MSDOS)
  2054. +       pclose (outfile);
  2055. + #else
  2056.         fclose (outfile);
  2057.         wait (0);
  2058. + #endif
  2059.       }
  2060.   }
  2061.   
  2062. ***************
  2063. *** 201,207 ****
  2064. --- 217,227 ----
  2065.   line_cmp (s1, s2)
  2066.        struct line_def *s1, *s2;
  2067.   {
  2068. + #ifdef MSDOS
  2069. +   char _huge *t1, _huge *t2;
  2070. + #else
  2071.     register char *t1, *t2;
  2072. + #endif
  2073.     register char end_char = line_end_char;
  2074.     int savechar;
  2075.   
  2076. ***************
  2077. *** 382,388 ****
  2078. --- 402,412 ----
  2079.        struct line_def *line;
  2080.   {
  2081.     int length = line->length; /* must be nonzero */
  2082. + #ifdef MSDOS
  2083. +   const char _huge *text = line->text; /* Help the compiler.  */
  2084. + #else
  2085.     const char *text = line->text; /* Help the compiler.  */
  2086. + #endif
  2087.     FILE *out = outfile; /* Help the compiler some more.  */
  2088.   
  2089.     /* If -T was specified, use a Tab between the line-flag and the text.
  2090.