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