home *** CD-ROM | disk | FTP | other *** search
/ Mega CD-ROM 1 / megacd_rom_1.zip / megacd_rom_1 / GNUISH / DIFF115.ZIP / PATCHES < prev   
Text File  |  1991-03-16  |  56KB  |  1,911 lines
  1. *** e:\tmp/RCSt1005321    Tue Mar 12 17:19:54 1991
  2. --- analyze.c    Tue Mar 12 17:18:32 1991
  3. ***************
  4. *** 17,22 ****
  5. --- 17,31 ----
  6.   along with GNU DIFF; see the file COPYING.  If not, write to
  7.   the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  8.   
  9. + /* MS-DOS port (c) 1990 by Thorsten Ohl, td12@ddagsi3.bitnet
  10. + This port is also distributed under the terms of the GNU General
  11. + Public License as published by the Free Software Foundation.
  12. + 
  13. + Please note that this file is not identical to the original GNU release,
  14. + you should have received this code as patch to the official release.
  15. + 
  16. + $Header: e:/gnu/diff/RCS/analyze.c 1.15.0.2 91/03/12 17:05:59 tho Exp $  */
  17. + 
  18.   /* The basic algorithm is described in: 
  19.      "An O(ND) Difference Algorithm and its Variations", Eugene Myers,
  20.      Algorithmica Vol. 1 No. 2, 1986, p 251.  */
  21. ***************
  22. *** 34,39 ****
  23. --- 43,58 ----
  24.   void pr_forward_ed_script ();
  25.   void setup_output ();
  26.   
  27. + #ifdef __STDC__
  28. + static  int diag(int, int, int, int, int *);
  29. + static  void compareseq(int, int, int, int);
  30. + static  void shift_boundaries(struct file_data *);
  31. + static  void discard_confusing_lines(struct file_data *);
  32. + static  struct change *add_change(int, int, int, int, struct change *);
  33. + static  struct change *build_reverse_script(struct file_data *);
  34. + static  struct change *build_script(struct file_data *);
  35. + #endif /* __STDC__ */
  36. + 
  37.   extern int no_discards;
  38.   
  39.   static int *xvec, *yvec;    /* Vectors being compared. */
  40. ***************
  41. *** 729,738 ****
  42. --- 748,759 ----
  43.     /* See if the two named files are actually the same physical file.
  44.        If so, we know they are identical without actually reading them.  */
  45.   
  46. + #ifndef MSDOS
  47.     if (output_style != OUTPUT_IFDEF
  48.         && filevec[0].stat.st_ino == filevec[1].stat.st_ino
  49.         && filevec[0].stat.st_dev == filevec[1].stat.st_dev)
  50.       return 0;
  51. + #endif /* MSDOS */
  52.   
  53.     binary = read_files (filevec);
  54.   
  55. ***************
  56. *** 743,751 ****
  57. --- 764,781 ----
  58.   
  59.     if (binary || no_details_flag)
  60.       {
  61. + #ifdef MSDOS
  62. +       /***********************************************************/
  63. +       /* FIXME: this looses when FILEVEC[1].BUFFERED_CHARS > 64k */
  64. +       /***********************************************************/
  65.         int differs = (filevec[0].buffered_chars != filevec[1].buffered_chars
  66.                || bcmp (filevec[0].buffer, filevec[1].buffer,
  67. +                   (size_t) filevec[1].buffered_chars));
  68. + #else /* not MSDOS */
  69. +       int differs = (filevec[0].buffered_chars != filevec[1].buffered_chars
  70. +              || bcmp (filevec[0].buffer, filevec[1].buffer,
  71.                     filevec[1].buffered_chars));
  72. + #endif /* not MSDOS */
  73.         if (differs) 
  74.       message (binary ? "Binary files %s and %s differ\n"
  75.            : "Files %s and %s differ\n",
  76. ***************
  77. *** 753,759 ****
  78. --- 783,794 ----
  79.   
  80.         for (i = 0; i < 2; ++i)
  81.       if (filevec[i].buffer)
  82. + #ifdef MSDOS
  83. +       hfree (filevec[i].buffer);
  84. + #else /* not MSDOS */
  85.         free (filevec[i].buffer);
  86. + #endif /* not MSDOS */
  87. + 
  88.         return differs;
  89.       }
  90.   
  91. ***************
  92. *** 900,906 ****
  93. --- 935,945 ----
  94.     for (i = 0; i < 2; ++i)
  95.       {
  96.         if (filevec[i].buffer != 0)
  97. + #ifdef MSDOS
  98. +     hfree (filevec[i].buffer);
  99. + #else /* not MSDOS */
  100.       free (filevec[i].buffer);
  101. + #endif /* not MSDOS */
  102.         free (filevec[i].linbuf);
  103.       }
  104.   
  105. *** e:\tmp/RCSt1005321    Tue Mar 12 17:19:56 1991
  106. --- context.c    Tue Mar 12 17:18:34 1991
  107. ***************
  108. *** 17,30 ****
  109. --- 17,52 ----
  110.   along with GNU DIFF; see the file COPYING.  If not, write to
  111.   the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  112.   
  113. + /* MS-DOS port (c) 1990 by Thorsten Ohl, td12@ddagsi3.bitnet
  114. + This port is also distributed under the terms of the GNU General
  115. + Public License as published by the Free Software Foundation.
  116. + 
  117. + Please note that this file is not identical to the original GNU release,
  118. + you should have received this code as patch to the official release.
  119. + 
  120. + $Header: e:/gnu/diff/RCS/context.c 1.15.0.2 91/03/12 17:06:06 tho Exp $  */
  121. + 
  122.   #include "diff.h"
  123.   #include "regex.h"
  124.   
  125. + #ifdef __STDC__
  126. + static void print_context_number_range (struct file_data *file, int a, int b);
  127. + static void pr_context_hunk (struct change *hunk);
  128. + static void pr_unidiff_hunk (struct change *hunk);
  129. + static struct change *find_hunk (struct change *start);
  130. + static void mark_ignorable (struct change *script);
  131. + static void find_function (struct file_data *file, int linenum,
  132. +                char **linep, int *lenp);
  133. + static void print_context_label (const char *mark, struct file_data *inf,
  134. +                  const char *label);
  135. + static void print_unidiff_number_range (struct file_data *file, int a, int b);
  136. + #else /* not __STDC__ */
  137.   static void pr_context_hunk ();
  138.   static void pr_unidiff_hunk ();
  139.   static struct change *find_hunk ();
  140.   static void mark_ignorable ();
  141.   static void find_function ();
  142. + #endif /* not __STDC__ */
  143.   
  144.   /* Last place find_function started searching from.  */
  145.   static int find_function_last_search;
  146. ***************
  147. *** 56,61 ****
  148. --- 78,94 ----
  149.        struct file_data *inf;
  150.        int unidiff_flag;
  151.   {
  152. + #ifdef MSDOS
  153. +   /* If we're dealing with empty files or the standard input,
  154. +      the current time seems to be a reasonable approximation ....
  155. +      MSC's ctime() returns NULL for invalid times, this breaks
  156. +      the context diff format! */
  157. +   if (!inf[0].stat.st_mtime)
  158. +     time (&inf[0].stat.st_mtime);
  159. +   if (!inf[1].stat.st_mtime)
  160. +     time (&inf[1].stat.st_mtime);
  161. + #endif /* MSDOS */
  162. + 
  163.     if (unidiff_flag)
  164.       {
  165.         print_context_label ("---", &inf[0], file_label[0]);
  166. ***************
  167. *** 397,403 ****
  168. --- 430,440 ----
  169.         script->link = next;
  170.   
  171.         /* If the change is ignorable, mark it.  */
  172. + #ifdef MSDOS
  173. +       script->ignore = (char) (!deletes && !inserts);
  174. + #else /* not MSDOS */
  175.         script->ignore = (!deletes && !inserts);
  176. + #endif /* not MSDOS */
  177.   
  178.         /* Advance to the following change.  */
  179.         script = next;
  180. *** e:\tmp/RCSt1005321    Tue Mar 12 17:19:58 1991
  181. --- diff.c    Tue Mar 12 17:18:38 1991
  182. ***************
  183. *** 20,30 ****
  184. --- 20,53 ----
  185.   /* GNU DIFF was written by Mike Haertel, David Hayes,
  186.      Richard Stallman and Len Tower.  */
  187.   
  188. + /* MS-DOS port (c) 1990 by Thorsten Ohl, td12@ddagsi3.bitnet
  189. + This port is also distributed under the terms of the GNU General
  190. + Public License as published by the Free Software Foundation.
  191. + 
  192. + Please note that this file is not identical to the original GNU release,
  193. + you should have received this code as patch to the official release.
  194. + 
  195. + $Header: e:/gnu/diff/RCS/diff.c 1.15.0.2 91/03/12 17:06:09 tho Exp $  */
  196. + 
  197.   #define GDIFF_MAIN
  198.   #include "regex.h"
  199.   #include "diff.h"
  200.   #include "getopt.h"
  201.   
  202. + #ifdef __STDC__
  203. + extern  void main (int argc, char **argv);
  204. + static    void usage(void);
  205. + static    char *option_list(char * *, int);
  206. + static    void specify_style(enum output_style);
  207. + static  int compare_files(char *, char *, char *, char *, int);
  208. + extern  int getopt(int, char * *, char *);
  209. + #else
  210. + static    void usage();
  211. + static    char *option_list();
  212. + static    void specify_style();
  213. + static  int compare_files();
  214. + extern  int getopt();
  215. + #endif /* __STDC__ */
  216.   
  217.   /* Nonzero for -r: if comparing two directories,
  218.      compare their common subdirectories recursively.  */
  219. ***************
  220. *** 106,111 ****
  221. --- 129,137 ----
  222.     {0, 0, 0, 0}
  223.   };
  224.   
  225. + #ifdef __STDC__
  226. + void
  227. + #endif /* __STDC__ */
  228.   main (argc, argv)
  229.        int argc;
  230.        char *argv[];
  231. ***************
  232. *** 399,404 ****
  233. --- 425,431 ----
  234.     exit (val);
  235.   }
  236.   
  237. + void
  238.   usage ()
  239.   {
  240.     fprintf (stderr, "\
  241. ***************
  242. *** 417,422 ****
  243. --- 444,450 ----
  244.     exit (2);
  245.   } 
  246.   
  247. + void
  248.   specify_style (style)
  249.        enum output_style style;
  250.   {
  251. ***************
  252. *** 509,514 ****
  253. --- 537,543 ----
  254.     /* See if the two named files are actually the same physical file.
  255.        If so, we know they are identical without actually reading them.  */
  256.   
  257. + #ifndef MSDOS
  258.     if (output_style != OUTPUT_IFDEF
  259.         && inf[0].stat.st_ino == inf[1].stat.st_ino
  260.         && inf[0].stat.st_dev == inf[1].stat.st_dev
  261. ***************
  262. *** 518,523 ****
  263. --- 547,553 ----
  264.         val = 0;
  265.         goto done;
  266.       }
  267. + #endif /* MSDOS */
  268.   
  269.     if (name0 == 0)
  270.       inf[0].dir_p = inf[1].dir_p;
  271. *** e:\tmp/RCSt1005321    Tue Mar 12 17:20:00 1991
  272. --- diff.h    Tue Mar 12 17:19:06 1991
  273. ***************
  274. *** 17,23 ****
  275. --- 17,32 ----
  276.   along with GNU DIFF; see the file COPYING.  If not, write to
  277.   the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  278.   
  279. + /* MS-DOS port (c) 1990 by Thorsten Ohl, td12@ddagsi3.bitnet
  280. + This port is also distributed under the terms of the GNU General
  281. + Public License as published by the Free Software Foundation.
  282.   
  283. + Please note that this file is not identical to the original GNU release,
  284. + you should have received this code as patch to the official release.
  285. + 
  286. + $Header: e:/gnu/diff/RCS/diff.h 1.15.0.2 91/03/12 17:06:56 tho Exp $  */
  287. + 
  288. + 
  289.   #include <ctype.h>
  290.   #include <stdio.h>
  291.   #include <sys/types.h>
  292. ***************
  293. *** 25,30 ****
  294. --- 34,46 ----
  295.   
  296.   #ifdef USG
  297.   #include <time.h>
  298. + #ifdef MSDOS
  299. + #include <stdlib.h>
  300. + #include <malloc.h>
  301. + #include <string.h>
  302. + #include <process.h>
  303. + #include <io.h>
  304. + #endif /* MSDOS */
  305.   #ifdef HAVE_NDIR
  306.   #ifdef NDIR_IN_SYS
  307.   #include <sys/ndir.h>
  308. ***************
  309. *** 47,57 ****
  310.   #ifdef USG
  311.   /* Define needed BSD functions in terms of sysV library.  */
  312.   
  313.   #define bcopy(s,d,n)    memcpy((d),(s),(n))
  314.   #define bcmp(s1,s2,n)    memcmp((s1),(s2),(n))
  315.   #define bzero(s,n)    memset((s),0,(n))
  316.   
  317. ! #ifndef XENIX
  318.   #define dup2(f,t)    (close(t),fcntl((f),F_DUPFD,(t)))
  319.   #endif
  320.   
  321. --- 63,77 ----
  322.   #ifdef USG
  323.   /* Define needed BSD functions in terms of sysV library.  */
  324.   
  325. + #ifdef MSDOS
  326. + #define bcopy(s,d,n)    memmove((d),(s),(n))    /* more save! */
  327. + #else
  328.   #define bcopy(s,d,n)    memcpy((d),(s),(n))
  329. + #endif
  330.   #define bcmp(s1,s2,n)    memcmp((s1),(s2),(n))
  331.   #define bzero(s,n)    memset((s),0,(n))
  332.   
  333. ! #if !defined (XENIX) && !defined (MSDOS)
  334.   #define dup2(f,t)    (close(t),fcntl((f),F_DUPFD,(t)))
  335.   #endif
  336.   
  337. ***************
  338. *** 66,81 ****
  339. --- 86,105 ----
  340.   #endif
  341.   
  342.   #include <errno.h>
  343. + #ifndef MSDOS            /* have it VOLATILE in <stdlib.h> */
  344.   extern int      errno;
  345.   extern int      sys_nerr;
  346.   extern char    *sys_errlist[];
  347. + #endif /* not MSDOS */
  348.   
  349.   #define    EOS        (0)
  350.   #define    FALSE        (0)
  351.   #define TRUE        1
  352.   
  353. + #ifndef MSDOS                /* have it in <stdlib.h> */
  354.   #define min(a,b) ((a) <= (b) ? (a) : (b))
  355.   #define max(a,b) ((a) >= (b) ? (a) : (b))
  356. + #endif
  357.   
  358.   #ifndef PR_FILE_NAME
  359.   #define PR_FILE_NAME "/bin/pr"
  360. ***************
  361. *** 90,96 ****
  362.   #endif
  363.   
  364.   /* Support old-fashioned C compilers.  */
  365. ! #if !defined (__STDC__) && !defined (__GNUC__)
  366.   #define const
  367.   #endif
  368.   
  369. --- 114,120 ----
  370.   #endif
  371.   
  372.   /* Support old-fashioned C compilers.  */
  373. ! #if !defined (__STDC__) && !defined (__GNUC__) || defined (MSDOS)
  374.   #define const
  375.   #endif
  376.   
  377. ***************
  378. *** 97,102 ****
  379. --- 121,134 ----
  380.   #ifndef O_RDONLY
  381.   #define O_RDONLY 0
  382.   #endif
  383. + 
  384. + #ifdef MSDOS
  385. + #if !defined (_MSC_VER) || (_MSC_VER < 600)
  386. + #define _huge huge
  387. + #endif /* MSC 5.1 */
  388. + #else /* not MSDOS */
  389. + #define _huge
  390. + #endif /* not MSDOS */
  391.   
  392.   /* Variables for command line options */
  393.   
  394. ***************
  395. *** 239,245 ****
  396.   /* Data on one line of text.  */
  397.   
  398.   struct line_def {
  399. !     char        *text;
  400.       int         length;
  401.       unsigned    hash;
  402.   };
  403. --- 271,277 ----
  404.   /* Data on one line of text.  */
  405.   
  406.   struct line_def {
  407. !     char _huge  *text;
  408.       int         length;
  409.       unsigned    hash;
  410.   };
  411. ***************
  412. *** 253,263 ****
  413.       int             dir_p;    /* 1 if file is a directory  */
  414.   
  415.       /* Buffer in which text of file is read.  */
  416. !     char *        buffer;
  417.       /* Allocated size of buffer.  */
  418.       int            bufsize;
  419.       /* Number of valid characters now in the buffer. */
  420.       int            buffered_chars;
  421.   
  422.       /* Array of data on analyzed lines of this chunk of this file.  */
  423.       struct line_def *linbuf;
  424. --- 285,302 ----
  425.       int             dir_p;    /* 1 if file is a directory  */
  426.   
  427.       /* Buffer in which text of file is read.  */
  428. !     char _huge *    buffer;     /* Allocated size of buffer.  */
  429. ! #ifdef MSDOS
  430.       /* Allocated size of buffer.  */
  431. +     long        bufsize;
  432. +     /* Number of valid characters now in the buffer. */
  433. +     long        buffered_chars;
  434. + #else /* not MSDOS */
  435. +     /* Allocated size of buffer.  */
  436.       int            bufsize;
  437.       /* Number of valid characters now in the buffer. */
  438.       int            buffered_chars;
  439. + #endif /* not MSDOS */
  440.   
  441.       /* Array of data on analyzed lines of this chunk of this file.  */
  442.       struct line_def *linbuf;
  443. ***************
  444. *** 269,281 ****
  445.       int            buffered_lines;
  446.   
  447.       /* Pointer to end of prefix of this file to ignore when hashing. */
  448. !     char *prefix_end;
  449.   
  450.       /* Count of lines in the prefix. */
  451.       int prefix_lines;
  452.   
  453.       /* Pointer to start of suffix of this file to ignore when hashing. */
  454. !     char *suffix_begin;
  455.   
  456.       /* Count of lines in the suffix. */
  457.       int suffix_lines;
  458. --- 308,320 ----
  459.       int            buffered_lines;
  460.   
  461.       /* Pointer to end of prefix of this file to ignore when hashing. */
  462. !     char _huge *prefix_end;
  463.   
  464.       /* Count of lines in the prefix. */
  465.       int prefix_lines;
  466.   
  467.       /* Pointer to start of suffix of this file to ignore when hashing. */
  468. !     char _huge *suffix_begin;
  469.   
  470.       /* Count of lines in the suffix. */
  471.       int suffix_lines;
  472. ***************
  473. *** 347,370 ****
  474.   
  475.   #ifdef __STDC__
  476.   #define VOID void
  477.   #else
  478.   #define VOID char
  479. ! #endif
  480. ! VOID *xmalloc ();
  481. ! VOID *xrealloc ();
  482.   char *concat ();
  483.   void free ();
  484.   char *rindex ();
  485.   char *index ();
  486.   
  487. - void analyze_hunk ();
  488. - void error ();
  489. - void fatal ();
  490.   void message ();
  491. - void perror_with_name ();
  492. - void pfatal_with_name ();
  493. - void print_1_line ();
  494.   void print_message_queue ();
  495. ! void print_number_range ();
  496.   void print_script ();
  497.   void translate_range ();
  498. --- 386,447 ----
  499.   
  500.   #ifdef __STDC__
  501.   #define VOID void
  502. + 
  503. + extern int diff_2_files(struct file_data *, int);
  504. + extern void print_context_header (struct file_data *inf, int unidiff_flag);
  505. + extern void print_context_script (struct change *script, int unidiff_flag);
  506. + extern int diff_dirs (char *name1, char *name2,
  507. +               int (*handle_file) (char *, char *, char *, char *, int),
  508. +               int depth, int nonex1, int nonex2);
  509. + extern void print_rcs_script (struct change *);
  510. + extern void print_ed_script (struct change *);
  511. + extern void pr_forward_ed_script (struct change *);
  512. + extern void print_ifdef_script (struct change *);
  513. + extern int read_files (struct file_data *);
  514. + extern void print_normal_script (struct change *);
  515. + extern int line_cmp (struct line_def *, struct line_def *);
  516. + extern  void pfatal_with_name (char *);
  517. + extern void *xcalloc (int, int);
  518. + extern void print_1_line (char *, struct line_def *);
  519. + extern void message (char *,...);
  520. + extern void print_message_queue (void);
  521. + extern struct change *find_change (struct change *);
  522. + extern void error (char *,...);
  523. + extern char *concat (char *, char *, char *);
  524. + extern int change_letter (int, int);
  525. + extern void setup_output (char *, char *, int);
  526. + extern void *xmalloc (unsigned int);
  527. + extern struct change *find_reverse_change (struct change *);
  528. + extern void fatal (char *);
  529. + extern void debug_script (struct change *sp);
  530. + extern int translate_line_number (struct file_data *, int);
  531. + extern void finish_output (void);
  532. + extern void perror_with_name (char *);
  533. + extern void *xrealloc (void *, unsigned int);
  534. + extern void fatal_with_name (char *, char *);
  535. + extern void translate_range (struct file_data *, int, int, int *, int *);
  536. + extern void print_number_range (char, struct file_data *, int, int);
  537. + extern void print_script (struct change *,
  538. +               struct change *(*)(struct change *),
  539. +               void (*)(struct change *));
  540. + extern void analyze_hunk (struct change *, int *, int *, int *, int *, int *, int *);
  541. + extern long hread (int fd, void _huge *buffer, long bytes);
  542. + extern void _huge *xhalloc (long);
  543. + extern void _huge *xhrealloc (void _huge *ptr, long new_size, long old_size);
  544. + 
  545.   #else
  546.   #define VOID char
  547. ! 
  548. ! char *xmalloc ();
  549. ! char *xrealloc ();
  550.   char *concat ();
  551.   void free ();
  552.   char *rindex ();
  553.   char *index ();
  554.   
  555.   void message ();
  556.   void print_message_queue ();
  557. ! 
  558. ! #endif /* __STDC__ */
  559.   void print_script ();
  560.   void translate_range ();
  561. *** e:\tmp/RCSt1005321    Tue Mar 12 17:20:04 1991
  562. --- diff3.c    Tue Mar 12 17:18:46 1991
  563. ***************
  564. *** 15,23 ****
  565.      along with this program; if not, write to the Free Software
  566.      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  567.   
  568. - 
  569.   /* Written by Randy Smith */
  570.   
  571.   #ifdef __STDC__
  572.   #define VOID void
  573.   #else
  574. --- 15,31 ----
  575.      along with this program; if not, write to the Free Software
  576.      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  577.   
  578.   /* Written by Randy Smith */
  579.   
  580. + /* MS-DOS port (c) 1990 by Thorsten Ohl, td12@ddagsi3.bitnet
  581. + This port is also distributed under the terms of the GNU General
  582. + Public License as published by the Free Software Foundation.
  583. + 
  584. + Please note that this file is not identical to the original GNU release,
  585. + you should have received this code as patch to the official release.
  586. + 
  587. + $Header: e:/gnu/diff/RCS/diff3.c 1.15.0.2 91/03/12 17:06:13 tho Exp $  */
  588. + 
  589.   #ifdef __STDC__
  590.   #define VOID void
  591.   #else
  592. ***************
  593. *** 35,46 ****
  594.   #ifdef USG
  595.   #include <fcntl.h>
  596.   
  597.   /* Define needed BSD functions in terms of sysV library.  */
  598.   
  599.   #define bcmp(s1,s2,n)    memcmp((s1),(s2),(n))
  600.   #define bzero(s,n)    memset((s),0,(n))
  601.   
  602. ! #ifndef XENIX
  603.   #define dup2(f,t)    (close(t),fcntl((f),F_DUPFD,(t)))
  604.   #endif
  605.   
  606. --- 43,64 ----
  607.   #ifdef USG
  608.   #include <fcntl.h>
  609.   
  610. + #ifdef MSDOS
  611. + #include <stdlib.h>
  612. + #include <sys/types.h>
  613. + #include <sys/stat.h>
  614. + #include <io.h>
  615. + #include <process.h>
  616. + #include <string.h>
  617. + static char *tmpfilename (char *template);
  618. + #endif /* MSDOS */
  619. + 
  620.   /* Define needed BSD functions in terms of sysV library.  */
  621.   
  622.   #define bcmp(s1,s2,n)    memcmp((s1),(s2),(n))
  623.   #define bzero(s,n)    memset((s),0,(n))
  624.   
  625. ! #if !defined (XENIX) && !defined (MSDOS)
  626.   #define dup2(f,t)    (close(t),fcntl((f),F_DUPFD,(t)))
  627.   #endif
  628.   
  629. ***************
  630. *** 209,214 ****
  631. --- 227,267 ----
  632.   /*
  633.    * Forward function declarations.
  634.    */
  635. + #ifdef __STDC__
  636. + 
  637. + extern void main (int argc, char **argv);
  638. + static int myread (int, char *, int);
  639. + static struct diff_block *process_diff (char *, char *);
  640. + static void perror_with_exit (char *string);
  641. + static void fatal (char *string);
  642. + static void usage (void);
  643. + static void *xmalloc (size_t n);
  644. + static void *xrealloc (void *ptr, size_t n);
  645. + static char *tmpfilename (char *);
  646. + static char *read_diff (char *filea, char *fileb, char **output_placement);
  647. + static enum diff_type process_diff_control (char **, struct diff_block *);
  648. + static int copy_stringlist (char **, int *, char **, int *, int);
  649. + static struct diff3_block *create_diff3_block (int, int, int, int, int, int);
  650. + static struct diff3_block *make_3way_diff (struct diff_block *,
  651. +                        struct diff_block *);
  652. + static int compare_line_list (char **, int *, char **, int *, int);
  653. + static int output_diff3_edscript (FILE *outputfile, struct diff3_block *diff,
  654. +                   int mapping[3], int rev_mapping[3],
  655. +                   char *file0, char *file1, char *file2);
  656. + static int output_diff3_merge (FILE *commonfile, FILE *outputfile,
  657. +                    struct diff3_block *diff,
  658. +                    int mapping[3], int rev_mapping[3],
  659. +                    char *file0, char *file1, char *file2);
  660. + static void output_diff3 (FILE *outputfile, struct diff3_block *diff,
  661. +               int mapping[3], int rev_mapping[3]);
  662. + static char *scan_diff_line (char *, char * *, int *, char *, char);
  663. + static struct diff3_block *reverse_diff3_blocklist (struct diff3_block *);
  664. + static struct diff3_block *using_to_diff3_block (struct diff_block **, struct diff_block * *, int, int, struct diff3_block *);
  665. + 
  666. + extern int getopt (int, char * *, char *);
  667. + 
  668. + #else
  669. + 
  670.   struct diff_block *process_diff ();
  671.   struct diff3_block *make_3way_diff ();
  672.   void output_diff3 ();
  673. ***************
  674. *** 230,235 ****
  675. --- 283,290 ----
  676.   VOID *xmalloc ();
  677.   VOID *xrealloc ();
  678.   
  679. + #endif /* __STDC__ */
  680. + 
  681.   char diff_program[] = DIFF_PROGRAM;
  682.   
  683.   /*
  684. ***************
  685. *** 236,241 ****
  686. --- 291,299 ----
  687.    * Main program.  Calls diff twice on two pairs of input files,
  688.    * combines the two diffs, and outputs them.
  689.    */
  690. + #ifdef __STDC__
  691. + void
  692. + #endif /* __STDC__ */
  693.   main (argc, argv)
  694.        int argc;
  695.        char **argv;
  696. ***************
  697. *** 960,966 ****
  698. --- 1018,1026 ----
  699.    * Routines to input and parse two way diffs.
  700.    */
  701.   
  702. + #ifndef MSDOS
  703.   extern char **environ;
  704. + #endif /* MSDOS */
  705.   
  706.   #define    DIFF_CHUNK_SIZE    10000
  707.   
  708. ***************
  709. *** 1180,1185 ****
  710. --- 1240,1250 ----
  711.     int pid, w;
  712.     int wstatus;
  713.   
  714. + #ifdef MSDOS
  715. +   int save_stdout;
  716. +   char *pipe_file = tmpfilename ("diXXXXXX");
  717. + #endif /* MSDOS */
  718. + 
  719.     ap = argv;
  720.     *ap++ = diff_program;
  721.     if (always_text)
  722. ***************
  723. *** 1189,1194 ****
  724. --- 1254,1274 ----
  725.     *ap++ = fileb;
  726.     *ap = (char *) 0;
  727.   
  728. + 
  729. + #ifdef MSDOS
  730. + 
  731. +   save_stdout = dup (1);
  732. +   fds[0] = open (pipe_file, O_CREAT|O_RDWR|O_TEXT,S_IREAD|S_IWRITE);
  733. +   dup2 (fds[0], 1);
  734. + 
  735. +   if ((spawnvp (P_WAIT, diff_program, argv)) == -1)
  736. +     perror_with_exit ("can't spawn diff");
  737. + 
  738. +   dup2 (save_stdout, 1);
  739. +   lseek (fds[0], 0L, SEEK_SET);
  740. + 
  741. + #else
  742. + 
  743.     if (pipe (fds) < 0)
  744.       perror_with_exit ("Pipe failed");
  745.   
  746. ***************
  747. *** 1213,1218 ****
  748. --- 1293,1301 ----
  749.       perror_with_exit ("Fork failed");
  750.   
  751.     close (fds[1]);        /* Prevent erroneous lack of EOF */
  752. + 
  753. + #endif /* MSDOS */
  754. + 
  755.     current_chunk_size = DIFF_CHUNK_SIZE;
  756.     diff_result = (char *) xmalloc (current_chunk_size);
  757.     total = 0;
  758. ***************
  759. *** 1230,1235 ****
  760. --- 1313,1321 ----
  761.   
  762.     *output_placement = diff_result;
  763.   
  764. + #ifdef MSDOS
  765. +   unlink (pipe_file);
  766. + #else /* not MSDOS */
  767.     do
  768.       if ((w = wait (&wstatus)) == -1)
  769.         perror_with_exit ("Wait failed");
  770. ***************
  771. *** 1237,1242 ****
  772. --- 1323,1329 ----
  773.   
  774.     if (! (WIFEXITED (wstatus) && WEXITSTATUS (wstatus) < 2))
  775.       fatal ("Subsidiary diff failed");
  776. + #endif /* not MSDOS */
  777.   
  778.     return diff_result + total;
  779.   }
  780. ***************
  781. *** 1332,1338 ****
  782.       case DIFF_3RD:
  783.         oddoneout = rev_mapping[(int) ptr->correspond - (int) DIFF_1ST];
  784.           
  785. !       x[0] = oddoneout + '1';
  786.         x[1] = '\0';
  787.         dontprint = oddoneout==0;
  788.         break;
  789. --- 1419,1425 ----
  790.       case DIFF_3RD:
  791.         oddoneout = rev_mapping[(int) ptr->correspond - (int) DIFF_1ST];
  792.           
  793. !       x[0] = (char) oddoneout + '1';
  794.         x[1] = '\0';
  795.         dontprint = oddoneout==0;
  796.         break;
  797. ***************
  798. *** 1400,1406 ****
  799.    *
  800.    * Returns 1 if overlaps were found.
  801.    */
  802. - 
  803.   int
  804.   output_diff3_edscript (outputfile, diff, mapping, rev_mapping,
  805.                  file0, file1, file2)
  806. --- 1487,1492 ----
  807. ***************
  808. *** 1655,1661 ****
  809. --- 1741,1751 ----
  810.   
  811.   VOID *
  812.   xmalloc (size)
  813. + #ifdef __STDC__
  814. +      size_t size;
  815. + #else /* not __STDC__ */
  816.        int size;
  817. + #endif /* not __STDC__ */
  818.   {
  819.     VOID *result = (VOID *) malloc (size ? size : 1);
  820.     if (!result)
  821. ***************
  822. *** 1666,1672 ****
  823. --- 1756,1766 ----
  824.   VOID *
  825.   xrealloc (ptr, size)
  826.        VOID *ptr;
  827. + #ifdef __STDC__
  828. +      size_t size;
  829. + #else /* not __STDC__ */
  830.        int size;
  831. + #endif /* not __STDC__ */
  832.   {
  833.     VOID *result = (VOID *) realloc (ptr, size ? size : 1);
  834.     if (!result)
  835. ***************
  836. *** 1674,1679 ****
  837. --- 1768,1776 ----
  838.     return result;
  839.   }
  840.   
  841. + #ifdef __STDC__
  842. + void
  843. + #endif /* __STDC__ */
  844.   fatal (string)
  845.        char *string;
  846.   {
  847. ***************
  848. *** 1681,1686 ****
  849. --- 1778,1786 ----
  850.     exit (2);
  851.   }
  852.   
  853. + #ifdef __STDC__
  854. + void
  855. + #endif /* __STDC__ */
  856.   perror_with_exit (string)
  857.        char *string;
  858.   {
  859. ***************
  860. *** 1687,1689 ****
  861. --- 1787,1826 ----
  862.     perror (string);
  863.     exit (2);
  864.   }
  865. + 
  866. + #ifdef MSDOS
  867. + /*
  868. +  * Get name of temporary directory from environment entry TMP or TEMP.
  869. +  * if this fails, use current directory.
  870. +  */
  871. + static char *
  872. + tmpfilename (char *template)
  873. + {
  874. +   register int l;
  875. +   register char *p;
  876. +   register char *tmpfile;
  877. + 
  878. +   int lt = strlen (template);
  879. + 
  880. +   if ((p = getenv ("TMP")) || (p = getenv ("TEMP")))
  881. +     {
  882. +       l = strlen(p);
  883. +       tmpfile = xmalloc (l + lt + 2);
  884. +       strcpy (tmpfile, p);
  885. +       if ((tmpfile[l-1] != '/') && (tmpfile[l-1] != '\\'))
  886. +     {
  887. +       tmpfile[l] = '/';        /* append slash */
  888. +       tmpfile[l+1] = '\0';
  889. +     }
  890. +     }
  891. +   else
  892. +     {
  893. +       tmpfile = xmalloc (lt + 3);    /* use current directory */
  894. +       strcpy (tmpfile, "./");
  895. +     }
  896. + 
  897. +   return mktemp (strcat (tmpfile, template));
  898. + }
  899. + 
  900. + #endif /* MSDOS */
  901. + 
  902. *** e:\tmp/RCSt1005321    Tue Mar 12 17:20:08 1991
  903. --- dir.c    Tue Mar 12 17:18:50 1991
  904. ***************
  905. *** 17,25 ****
  906. --- 17,36 ----
  907.   along with GNU DIFF; see the file COPYING.  If not, write to
  908.   the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  909.   
  910. + /* MS-DOS port (c) 1990 by Thorsten Ohl, td12@ddagsi3.bitnet
  911. + This port is also distributed under the terms of the GNU General
  912. + Public License as published by the Free Software Foundation.
  913. + 
  914. + Please note that this file is not identical to the original GNU release,
  915. + you should have received this code as patch to the official release.
  916. + 
  917. + $Header: e:/gnu/diff/RCS/dir.c 1.15.0.2 91/03/12 17:06:27 tho Exp $  */
  918. + 
  919.   #include "diff.h"
  920.   
  921. + #ifndef __STDC__
  922.   static int compare_names ();
  923. + #endif /* !__STDC__ */
  924.   
  925.   /* Read the directory named DIRNAME and return a sorted vector
  926.      of filenames for its contents.  NONEX nonzero means this directory is
  927. ***************
  928. *** 31,36 ****
  929. --- 42,52 ----
  930.     char **files;            /* Sorted names of files in the dir */
  931.   };
  932.   
  933. + #ifdef __STDC__
  934. + static  struct dirdata dir_sort(char *, int);
  935. + static  int compare_names(char * *, char * *);
  936. + #endif /* __STDC__ */
  937. + 
  938.   static struct dirdata
  939.   dir_sort (dirname, nonex)
  940.        char *dirname;
  941. ***************
  942. *** 132,142 ****
  943. --- 148,166 ----
  944.      Returns the maximum of all the values returned by HANDLE_FILE,
  945.      or 2 if trouble is encountered in opening files.  */
  946.   
  947. + #ifdef MSDOS
  948. + int
  949. + diff_dirs (name1, name2, handle_file, depth, nonex1, nonex2)
  950. +      char *name1, *name2;
  951. +      int (*handle_file) (char *, char *, char *, char *, int);
  952. +      int depth, nonex1, nonex2;
  953. + #else
  954.   int
  955.   diff_dirs (name1, name2, handle_file, depth, nonex1, nonex2)
  956.        char *name1, *name2;
  957.        int (*handle_file) ();
  958.        int nonex1, nonex2;
  959. + #endif
  960.   {
  961.     struct dirdata data1, data2;
  962.     register int i1, i2;
  963. *** e:\tmp/RCSt1005321    Tue Mar 12 17:20:12 1991
  964. --- ed.c    Tue Mar 12 17:18:52 1991
  965. ***************
  966. *** 17,24 ****
  967. --- 17,38 ----
  968.   along with GNU DIFF; see the file COPYING.  If not, write to
  969.   the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  970.   
  971. + /* MS-DOS port (c) 1990 by Thorsten Ohl, td12@ddagsi3.bitnet
  972. + This port is also distributed under the terms of the GNU General
  973. + Public License as published by the Free Software Foundation.
  974. + 
  975. + Please note that this file is not identical to the original GNU release,
  976. + you should have received this code as patch to the official release.
  977. + 
  978. + $Header: e:/gnu/diff/RCS/ed.c 1.15.0.1 91/03/11 22:11:02 tho Exp $  */
  979. + 
  980.   #include "diff.h"
  981.   
  982. + #ifdef __STDC__
  983. + static  void print_ed_hunk(struct change *);
  984. + static  void pr_forward_ed_hunk(struct change *);
  985. + static  void print_rcs_hunk(struct change *);
  986. + #else
  987.   static void print_rcs_hunk ();
  988.   static void print_ed_hunk ();
  989.   static void pr_forward_ed_hunk ();
  990. ***************
  991. *** 25,30 ****
  992. --- 39,45 ----
  993.   void translate_range ();
  994.   struct change *find_change ();
  995.   struct change *find_reverse_change ();
  996. + #endif /* __STDC__ */
  997.   
  998.   /* Print our script as ed commands.  */
  999.   
  1000. *** e:\tmp/RCSt1005321    Tue Mar 12 17:20:12 1991
  1001. --- ifdef.c    Tue Mar 12 17:18:54 1991
  1002. ***************
  1003. *** 17,28 ****
  1004. --- 17,39 ----
  1005.   can know your rights and responsibilities.  It should be in a
  1006.   file named COPYING.  Among other things, the copyright notice
  1007.   and this notice must be preserved on all copies.  */
  1008. + /* MS-DOS port (c) 1990 by Thorsten Ohl, td12@ddagsi3.bitnet
  1009. + This port is also distributed under the terms of the GNU General
  1010. + Public License as published by the Free Software Foundation.
  1011.   
  1012. + Please note that this file is not identical to the original GNU release,
  1013. + you should have received this code as patch to the official release.
  1014.   
  1015. + $Header: e:/gnu/diff/RCS/ifdef.c 1.15.0.1 91/03/11 22:12:20 tho Exp $  */
  1016. + 
  1017.   #include "diff.h"
  1018.   
  1019. + #ifdef __STDC__
  1020. + static  void print_ifdef_hunk(struct change *);
  1021. + #else
  1022.   static void print_ifdef_hunk ();
  1023.   struct change *find_change ();
  1024. + #endif /* __STDC__ */
  1025.   
  1026.   static int next_line;
  1027.   
  1028. *** e:\tmp/RCSt1005321    Tue Mar 12 17:20:14 1991
  1029. --- io.c    Tue Mar 12 17:18:56 1991
  1030. ***************
  1031. *** 17,24 ****
  1032. --- 17,41 ----
  1033.   along with GNU DIFF; see the file COPYING.  If not, write to
  1034.   the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  1035.   
  1036. + /* MS-DOS port (c) 1990 by Thorsten Ohl, td12@ddagsi3.bitnet
  1037. + This port is also distributed under the terms of the GNU General
  1038. + Public License as published by the Free Software Foundation.
  1039. + 
  1040. + Please note that this file is not identical to the original GNU release,
  1041. + you should have received this code as patch to the official release.
  1042. + 
  1043. + $Header: e:/gnu/diff/RCS/io.c 1.15.0.2 91/03/12 17:06:38 tho Exp $  */
  1044. + 
  1045.   #include "diff.h"
  1046.   
  1047. + #ifdef __STDC__
  1048. + static  int binary_file_p(char *, int);
  1049. + static  int slurp(void);
  1050. + static  void find_identical_ends(struct file_data *);
  1051. + static  void find_and_hash_each_line(void);
  1052. + static  int find_equiv_class(int);
  1053. + #endif /* __STDC__ */
  1054. + 
  1055.   /* Rotate a value n bits to the left. */
  1056.   #define UINT_BIT (sizeof (unsigned) * CHAR_BIT)
  1057.   #define ROL(v, n) ((v) << (n) | (v) >> UINT_BIT - (n))
  1058. ***************
  1059. *** 104,123 ****
  1060.     else if ((current->stat.st_mode & S_IFMT) == S_IFREG)
  1061.       {
  1062.         current->bufsize = current->stat.st_size;
  1063.         current->buffer = (char *) xmalloc (current->bufsize + 2);
  1064.         current->buffered_chars
  1065.       = read (current->desc, current->buffer, current->bufsize);
  1066.         if (current->buffered_chars < 0)
  1067.       pfatal_with_name (current->name);
  1068.       }
  1069.     else
  1070.       {
  1071.         int cc;
  1072.   
  1073.         current->bufsize = 4096;
  1074.         current->buffer = (char *) xmalloc (current->bufsize + 2);
  1075.         current->buffered_chars = 0;
  1076. !       
  1077.         /* Not a regular file; read it in a little at a time, growing the
  1078.        buffer as necessary. */
  1079.         while ((cc = read (current->desc,
  1080. --- 121,181 ----
  1081.     else if ((current->stat.st_mode & S_IFMT) == S_IFREG)
  1082.       {
  1083.         current->bufsize = current->stat.st_size;
  1084. + 
  1085. + #ifdef MSDOS
  1086. +       current->buffer = (char _huge *) xhalloc (current->bufsize + 2L);
  1087. +       current->buffered_chars
  1088. +     = hread (current->desc, current->buffer, current->bufsize);
  1089. + #else /* not MSDOS */
  1090.         current->buffer = (char *) xmalloc (current->bufsize + 2);
  1091.         current->buffered_chars
  1092.       = read (current->desc, current->buffer, current->bufsize);
  1093. + #endif /* not MSDOS */
  1094.         if (current->buffered_chars < 0)
  1095.       pfatal_with_name (current->name);
  1096.       }
  1097.     else
  1098.       {
  1099. + #ifdef MSDOS
  1100. +       long cc;
  1101. + 
  1102. +       current->bufsize = 0x2000L;
  1103. +       current->buffer = (char _huge *) xhalloc (current->bufsize + 2L);
  1104. +       current->buffered_chars = 0L;
  1105. + 
  1106. +       /* Not a regular file; read it in a little at a time, growing the
  1107. +      buffer as necessary.
  1108. +      MS-DOS: This is really slow size we do not double
  1109. +      the BUFSIZE on each step, we rather increase it linearly.
  1110. +      I think this greatly inproves the changes of managing a 
  1111. +      tight fit.  */
  1112. +       while ((cc = hread (current->desc,
  1113. +                current->buffer + current->buffered_chars,
  1114. +                current->bufsize - current->buffered_chars))
  1115. +           > 0L)
  1116. +     {
  1117. +       current->buffered_chars += cc;
  1118. +       if (current->buffered_chars == current->bufsize)
  1119. +         {
  1120. +           current->buffer
  1121. +         = (char _huge *) xhrealloc (current->buffer,
  1122. +                        current->bufsize + 0x2002L,
  1123. +                        current->bufsize);
  1124. +           current->bufsize = current->bufsize + 0x2000L;
  1125. +         }
  1126. +     }
  1127. + 
  1128. +       if (cc < 0L)
  1129. +     pfatal_with_name (current->name);
  1130. + 
  1131. + #else /* not MSDOS */
  1132. + 
  1133.         int cc;
  1134.   
  1135.         current->bufsize = 4096;
  1136.         current->buffer = (char *) xmalloc (current->bufsize + 2);
  1137.         current->buffered_chars = 0;
  1138. ! 
  1139.         /* Not a regular file; read it in a little at a time, growing the
  1140.        buffer as necessary. */
  1141.         while ((cc = read (current->desc,
  1142. ***************
  1143. *** 133,146 ****
  1144.                              current->bufsize + 2);
  1145.           }
  1146.       }
  1147.         if (cc < 0)
  1148.       pfatal_with_name (current->name);
  1149.       }
  1150. !   
  1151.     /* Check first part of file to see if it's a binary file.  */
  1152.     if (! always_text_flag
  1153.         && binary_file_p (current->buffer,
  1154.               min (current->buffered_chars, binary_file_threshold)))
  1155.       return 1;
  1156.   
  1157.     /* If not binary, make sure text ends in a newline,
  1158. --- 191,211 ----
  1159.                              current->bufsize + 2);
  1160.           }
  1161.       }
  1162. + 
  1163.         if (cc < 0)
  1164.       pfatal_with_name (current->name);
  1165. + 
  1166. + #endif /* not MSDOS */
  1167.       }
  1168. ! 
  1169.     /* Check first part of file to see if it's a binary file.  */
  1170.     if (! always_text_flag
  1171.         && binary_file_p (current->buffer,
  1172. + #ifdef MSDOS
  1173. +        min ((int) current->buffered_chars, binary_file_threshold)))
  1174. + #else
  1175.               min (current->buffered_chars, binary_file_threshold)))
  1176. + #endif
  1177.       return 1;
  1178.   
  1179.     /* If not binary, make sure text ends in a newline,
  1180. ***************
  1181. *** 169,178 ****
  1182.   {
  1183.     unsigned h;
  1184.     int i;
  1185. !   unsigned char *p = (unsigned char *) current->prefix_end, *ip, c;
  1186.   
  1187.     /* Attempt to get a good initial guess as to the number of lines. */
  1188.     current->linbufsize = current->buffered_chars / 50 + 5;
  1189.     current->linbuf
  1190.       = (struct line_def *) xmalloc (current->linbufsize * sizeof (struct line_def));
  1191.   
  1192. --- 234,248 ----
  1193.   {
  1194.     unsigned h;
  1195.     int i;
  1196. !   unsigned char _huge *p = (unsigned char _huge *) current->prefix_end;
  1197. !   unsigned char _huge *ip, c;
  1198.   
  1199.     /* Attempt to get a good initial guess as to the number of lines. */
  1200. + #ifdef MSDOS
  1201. +   current->linbufsize = (int) (current->buffered_chars / 50) + 5;
  1202. + #else
  1203.     current->linbufsize = current->buffered_chars / 50 + 5;
  1204. + #endif
  1205.     current->linbuf
  1206.       = (struct line_def *) xmalloc (current->linbufsize * sizeof (struct line_def));
  1207.   
  1208. ***************
  1209. *** 183,189 ****
  1210.        but since we don't know how many, it's easiest to find them all.
  1211.        If -D is specified, we need all the lines of the first file.  */
  1212.         current->buffered_lines = 0;
  1213. !       p = (unsigned char *) current->buffer;
  1214.       }
  1215.     else
  1216.       {
  1217. --- 253,259 ----
  1218.        but since we don't know how many, it's easiest to find them all.
  1219.        If -D is specified, we need all the lines of the first file.  */
  1220.         current->buffered_lines = 0;
  1221. !       p = (unsigned char _huge *) current->buffer;
  1222.       }
  1223.     else
  1224.       {
  1225. ***************
  1226. *** 195,212 ****
  1227.       current->buffered_lines = 0;
  1228.         for (i = 0; i < context + 1; ++i)
  1229.       /* Unless we are at the beginning, */
  1230. !     if ((char *) p != current->buffer)
  1231.         /* Back up at least 1 char until at the start of a line.  */
  1232. !       while ((char *) --p != current->buffer && p[-1] != '\n')
  1233.           ;
  1234.       }
  1235.   
  1236. !   while ((char *) p < current->suffix_begin)
  1237.       {
  1238.         h = 0;
  1239.         ip = p;
  1240.   
  1241. !       if (current->prefix_end <= (char *) p)
  1242.       {
  1243.         /* Hash this line until we find a newline. */
  1244.         if (ignore_case_flag)
  1245. --- 265,282 ----
  1246.       current->buffered_lines = 0;
  1247.         for (i = 0; i < context + 1; ++i)
  1248.       /* Unless we are at the beginning, */
  1249. !     if ((char _huge *) p != current->buffer)
  1250.         /* Back up at least 1 char until at the start of a line.  */
  1251. !       while ((char _huge *) --p != current->buffer && p[-1] != '\n')
  1252.           ;
  1253.       }
  1254.   
  1255. !   while ((char _huge *) p < current->suffix_begin)
  1256.       {
  1257.         h = 0;
  1258.         ip = p;
  1259.   
  1260. !       if (current->prefix_end <= (char _huge *) p)
  1261.       {
  1262.         /* Hash this line until we find a newline. */
  1263.         if (ignore_case_flag)
  1264. ***************
  1265. *** 292,305 ****
  1266.         if (current->buffered_lines >= current->linbufsize)
  1267.       {
  1268.         while (current->buffered_lines >= current->linbufsize)
  1269.           current->linbufsize *= 2;
  1270.         current->linbuf
  1271.           = (struct line_def *) xrealloc (current->linbuf,
  1272.                           current->linbufsize
  1273.                           * sizeof (struct line_def));
  1274.       }
  1275. !       current->linbuf[current->buffered_lines].text = (char *) ip;
  1276.         current->linbuf[current->buffered_lines].length = p - ip + 1;
  1277.         current->linbuf[current->buffered_lines].hash = h;
  1278.         ++current->buffered_lines;
  1279.         ++p;
  1280. --- 362,388 ----
  1281.         if (current->buffered_lines >= current->linbufsize)
  1282.       {
  1283.         while (current->buffered_lines >= current->linbufsize)
  1284. + #ifdef MSDOS            /* don't be to generous!  */
  1285. +         {
  1286. +           current->linbufsize += 0x0100;
  1287. +           if (current->linbufsize >= 0xffe0 / sizeof (struct line_def))
  1288. +         fatal ("to many lines in input");
  1289. +         }
  1290. + #else /* not MSDOS */
  1291.           current->linbufsize *= 2;
  1292. + #endif /* not MSDOS */
  1293.         current->linbuf
  1294.           = (struct line_def *) xrealloc (current->linbuf,
  1295.                           current->linbufsize
  1296.                           * sizeof (struct line_def));
  1297.       }
  1298. !       current->linbuf[current->buffered_lines].text = (char _huge *) ip;
  1299. ! #ifdef MSDOS            /* Be explicit to the compiler!  */
  1300. !       current->linbuf[current->buffered_lines].length
  1301. !     = (int) ((long) (p - ip) + 1);
  1302. ! #else /* not MSDOS */
  1303.         current->linbuf[current->buffered_lines].length = p - ip + 1;
  1304. + #endif /* not MSDOS */
  1305.         current->linbuf[current->buffered_lines].hash = h;
  1306.         ++current->buffered_lines;
  1307.         ++p;
  1308. ***************
  1309. *** 307,313 ****
  1310.   
  1311.     i = 0;
  1312.     while ((i < context || output_style == OUTPUT_IFDEF)
  1313. !      && (char *) p < current->buffer + current->buffered_chars)
  1314.       {
  1315.         ip = p;
  1316.         while (*p++ != '\n')
  1317. --- 390,396 ----
  1318.   
  1319.     i = 0;
  1320.     while ((i < context || output_style == OUTPUT_IFDEF)
  1321. !      && (char _huge *) p < current->buffer + current->buffered_chars)
  1322.       {
  1323.         ip = p;
  1324.         while (*p++ != '\n')
  1325. ***************
  1326. *** 316,329 ****
  1327.         if (current->buffered_lines >= current->linbufsize)
  1328.       {
  1329.         while (current->buffered_lines >= current->linbufsize)
  1330.           current->linbufsize *= 2;
  1331.         current->linbuf
  1332.           = (struct line_def *) xrealloc (current->linbuf,
  1333.                           current->linbufsize
  1334.                           * sizeof (struct line_def));
  1335.       }
  1336. !       current->linbuf[current->buffered_lines].text = (char *) ip;
  1337.         current->linbuf[current->buffered_lines].length = p - ip;
  1338.         current->linbuf[current->buffered_lines].hash = 0;
  1339.         ++current->buffered_lines;
  1340.         ++i;
  1341. --- 399,425 ----
  1342.         if (current->buffered_lines >= current->linbufsize)
  1343.       {
  1344.         while (current->buffered_lines >= current->linbufsize)
  1345. + #ifdef MSDOS            /* don't be to generous!  */
  1346. +         {
  1347. +           current->linbufsize += 0x0100;
  1348. +           if (current->linbufsize >= 0xffe0 / sizeof (struct line_def))
  1349. +         fatal ("to many lines in input");
  1350. +         }
  1351. + #else /* not MSDOS */
  1352.           current->linbufsize *= 2;
  1353. + #endif /* not MSDOS */
  1354.         current->linbuf
  1355.           = (struct line_def *) xrealloc (current->linbuf,
  1356.                           current->linbufsize
  1357.                           * sizeof (struct line_def));
  1358.       }
  1359. !       current->linbuf[current->buffered_lines].text = (char _huge *) ip;
  1360. ! #ifdef MSDOS        /* Be explicit to the compiler!  */
  1361. !       current->linbuf[current->buffered_lines].length
  1362. !     = (int) ((long) (p - ip));
  1363. ! #else /* not MSDOS */
  1364.         current->linbuf[current->buffered_lines].length = p - ip;
  1365. + #endif /* not MSDOS */
  1366.         current->linbuf[current->buffered_lines].hash = 0;
  1367.         ++current->buffered_lines;
  1368.         ++i;
  1369. ***************
  1370. *** 342,348 ****
  1371.   find_identical_ends (filevec)
  1372.        struct file_data filevec[];
  1373.   {
  1374. !   char *p0, *p1, *end0, *beg0;
  1375.     int lines;
  1376.   
  1377.     if (filevec[0].buffered_chars == 0 || filevec[1].buffered_chars == 0)
  1378. --- 438,444 ----
  1379.   find_identical_ends (filevec)
  1380.        struct file_data filevec[];
  1381.   {
  1382. !   char _huge *p0, _huge *p1, _huge *end0, _huge *beg0;
  1383.     int lines;
  1384.   
  1385.     if (filevec[0].buffered_chars == 0 || filevec[1].buffered_chars == 0)
  1386. ***************
  1387. *** 382,397 ****
  1388. --- 478,507 ----
  1389.   
  1390.     /* Don't count missing newline as part of prefix in RCS mode. */
  1391.     if (ROBUST_OUTPUT_STYLE (output_style)
  1392. + #ifdef MSDOS
  1393. +       && ((filevec[0].missing_newline
  1394. +        && (long) (p0 - filevec[0].buffer)
  1395. +          > (long) filevec[0].buffered_chars)
  1396. +       ||
  1397. +       (filevec[1].missing_newline
  1398. +        && (long) (p1 - filevec[1].buffer)
  1399. +          > (long) filevec[1].buffered_chars)))
  1400. + #else /* not MSDOS */
  1401.         && ((filevec[0].missing_newline
  1402.          && p0 - filevec[0].buffer > filevec[0].buffered_chars)
  1403.         ||
  1404.         (filevec[1].missing_newline
  1405.          && p1 - filevec[1].buffer > filevec[1].buffered_chars)))
  1406. + #endif /* not MSDOS */
  1407.       --p0, --p1, --lines;
  1408.   
  1409.     /* If the sentinel was passed, and lengths are equal, the
  1410.        files are identical.  */
  1411. + #ifdef MSDOS
  1412. +   if ((long) (p0 - filevec[0].buffer) > (long) filevec[0].buffered_chars
  1413. + #else /* not MSDOS */
  1414.     if (p0 - filevec[0].buffer > filevec[0].buffered_chars
  1415. + #endif /* not MSDOS */
  1416.         && filevec[0].buffered_chars == filevec[1].buffered_chars)
  1417.       {
  1418.         filevec[0].prefix_end = p0 - 1;
  1419. ***************
  1420. *** 515,520 ****
  1421. --- 625,631 ----
  1422.     16381,
  1423.     32749,
  1424.     65521,
  1425. + #ifndef MSDOS
  1426.     131071,
  1427.     262139,
  1428.     524287,
  1429. ***************
  1430. *** 525,530 ****
  1431. --- 636,642 ----
  1432.     16777213,
  1433.     33554393,
  1434.     67108859,            /* Preposterously large . . . */
  1435. + #endif /* not MSDOS */
  1436.     -1
  1437.   };
  1438.   
  1439. ***************
  1440. *** 564,569 ****
  1441. --- 676,686 ----
  1442.   
  1443.     /* Create a new equivalence class in this bucket. */
  1444.   
  1445. + #ifdef MSDOS
  1446. +   if (equivs_index >= equivs_alloc)
  1447. +     fatal ("too many differences, hash table overflow");
  1448. + #endif /* MSDOS */
  1449. + 
  1450.     p = &equivs[equivs_index++];
  1451.     p->next = buckets[bucket];
  1452.     buckets[bucket] = p;
  1453. ***************
  1454. *** 600,607 ****
  1455. --- 717,735 ----
  1456.         find_and_hash_each_line ();
  1457.       }
  1458.   
  1459. + #ifdef MSDOS
  1460. +   /* This is NOT guaranteed to be enough space, but we will try anyway and
  1461. +      abort iff the hash table really overflows.  The strategy will help
  1462. +      us A LOT iff there are long matching pre- and suffixes (but the
  1463. +      user will have to wait longer for the bad news if we have to
  1464. +      abort ...).  */
  1465. +   equivs_alloc = min ((int) (0xffe0 / sizeof (struct equivclass)),
  1466. +         filevec[0].buffered_lines + filevec[1].buffered_lines + 1);
  1467. + #else /* not MSDOS */
  1468.     /* This is guaranteed to be enough space.  */
  1469.     equivs_alloc = filevec[0].buffered_lines + filevec[1].buffered_lines + 1;
  1470. + #endif /* not MSDOS */
  1471. + 
  1472.     equivs = (struct equivclass *) xmalloc (equivs_alloc * sizeof (struct equivclass));
  1473.     /* Equivalence class 0 is permanently safe for lines that were not
  1474.        hashed.  Real equivalence classes start at 1. */
  1475. *** e:\tmp/RCSt1005321    Tue Mar 12 17:20:18 1991
  1476. --- limits.h    Tue Mar 12 17:19:06 1991
  1477. ***************
  1478. *** 1,3 ****
  1479. --- 1,31 ----
  1480. + /* limits.h - implementation dependent limits
  1481. +    Copyright (C) 1988, 1989 Free Software Foundation, Inc.
  1482. + 
  1483. + This file is part of GNU DIFF.
  1484. + 
  1485. + GNU DIFF is free software; you can redistribute it and/or modify
  1486. + it under the terms of the GNU General Public License as published by
  1487. + the Free Software Foundation; either version 1, or (at your option)
  1488. + any later version.
  1489. + 
  1490. + GNU DIFF is distributed in the hope that it will be useful,
  1491. + but WITHOUT ANY WARRANTY; without even the implied warranty of
  1492. + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  1493. + GNU General Public License for more details.
  1494. + 
  1495. + You should have received a copy of the GNU General Public License
  1496. + along with GNU DIFF; see the file COPYING.  If not, write to
  1497. + the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  1498. + 
  1499. + /* MS-DOS port (c) 1990 by Thorsten Ohl, td12@ddagsi3.bitnet
  1500. + This port is also distributed under the terms of the GNU General
  1501. + Public License as published by the Free Software Foundation.
  1502. + 
  1503. + Please note that this file is not identical to the original GNU release,
  1504. + you should have received this code as patch to the official release.
  1505. + 
  1506. + $Header: e:/gnu/diff/RCS/limits.h 1.15.0.1 91/03/12 10:58:28 tho Exp $  */
  1507. + 
  1508.   /* Number of bits in a `char'.  */
  1509.   #define CHAR_BIT 8
  1510.   
  1511. ***************
  1512. *** 29,38 ****
  1513. --- 57,75 ----
  1514.   
  1515.   /* Minimum and maximum values a `signed int' can hold.  */
  1516.   #define INT_MIN (-INT_MAX-1)
  1517. + #ifdef MSDOS
  1518. + #define INT_MAX 32767
  1519. + #else
  1520.   #define INT_MAX 2147483647
  1521. + #endif
  1522.   
  1523.   /* Maximum value an `unsigned int' can hold.  (Minimum is 0).  */
  1524. + #ifdef MSDOS
  1525. + #define UINT_MAX 65535U
  1526. + #else
  1527.   #define UINT_MAX 4294967295U
  1528. + #endif
  1529. + 
  1530.   
  1531.   /* Minimum and maximum values a `signed long int' can hold.
  1532.      (Same as `int').  */
  1533. *** e:\tmp/RCSt1005321    Tue Mar 12 17:20:18 1991
  1534. --- normal.c    Tue Mar 12 17:18:58 1991
  1535. ***************
  1536. *** 17,28 ****
  1537.   along with GNU DIFF; see the file COPYING.  If not, write to
  1538.   the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  1539.   
  1540.   
  1541.   #include "diff.h"
  1542.   
  1543. ! void print_normal_hunk ();
  1544.   void print_number_range ();
  1545.   struct change *find_change ();
  1546.   
  1547.   /* Print the edit-script SCRIPT as a normal diff.
  1548.      INF points to an array of descriptions of the two files.  */
  1549. --- 17,41 ----
  1550.   along with GNU DIFF; see the file COPYING.  If not, write to
  1551.   the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  1552.   
  1553. + /* MS-DOS port (c) 1990 by Thorsten Ohl, td12@ddagsi3.bitnet
  1554. + This port is also distributed under the terms of the GNU General
  1555. + Public License as published by the Free Software Foundation.
  1556.   
  1557. + Please note that this file is not identical to the original GNU release,
  1558. + you should have received this code as patch to the official release.
  1559. + 
  1560. + $Header: e:/gnu/diff/RCS/normal.c 1.15.0.1 91/03/12 10:45:17 tho Exp $  */
  1561. + 
  1562.   #include "diff.h"
  1563.   
  1564. ! #ifdef __STDC__
  1565. ! static  void print_normal_hunk(struct change *);
  1566. ! #else
  1567. ! static  void print_normal_hunk ();
  1568.   void print_number_range ();
  1569.   struct change *find_change ();
  1570. + #endif /* __STDC__ */
  1571. + 
  1572.   
  1573.   /* Print the edit-script SCRIPT as a normal diff.
  1574.      INF points to an array of descriptions of the two files.  */
  1575. *** e:\tmp/RCSt1005321    Tue Mar 12 17:20:20 1991
  1576. --- util.c    Tue Mar 12 17:19:02 1991
  1577. ***************
  1578. *** 17,24 ****
  1579. --- 17,40 ----
  1580.   along with GNU DIFF; see the file COPYING.  If not, write to
  1581.   the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  1582.   
  1583. + /* MS-DOS port (c) 1990 by Thorsten Ohl, td12@ddagsi3.bitnet
  1584. + This port is also distributed under the terms of the GNU General
  1585. + Public License as published by the Free Software Foundation.
  1586. + 
  1587. + Please note that this file is not identical to the original GNU release,
  1588. + you should have received this code as patch to the official release.
  1589. + 
  1590. + $Header: e:/gnu/diff/RCS/util.c 1.15.0.2 91/03/12 17:06:46 tho Exp $  */
  1591. + 
  1592.   #include "diff.h"
  1593. + #include "regex.h"            /* was missing [tho] */
  1594.   
  1595. + #ifdef MSDOS
  1596. + #include <conio.h>
  1597. + static char *_pipe_file (void);
  1598. + static void cleanup_pipe (void);
  1599. + #endif /* MSDOS */
  1600. + 
  1601.   /* Use when a system call returns non-zero status.
  1602.      TEXT should normally be the file name.  */
  1603.   
  1604. ***************
  1605. *** 66,71 ****
  1606. --- 82,97 ----
  1607.     error (message, "");
  1608.     exit (2);
  1609.   }
  1610. + 
  1611. + #ifdef MSDOS
  1612. + void
  1613. + fatal_with_name (char *message,char *name)
  1614. + {
  1615. +   print_message_queue ();
  1616. +   error ("%s: %s", name, message);
  1617. +   exit (2);
  1618. + }
  1619. + #endif
  1620.   
  1621.   /* Like printf, except if -l in effect then save the message and print later.
  1622.      This is used for things like "binary files differ" and "Only in ...".  */
  1623. ***************
  1624. *** 131,136 ****
  1625. --- 157,173 ----
  1626.   
  1627.     if (paginate_flag)
  1628.       {
  1629. + 
  1630. + #ifdef MSDOS
  1631. + 
  1632. +       if ( !(outfile = fopen(_pipe_file (), "w")) )
  1633. +         {
  1634. +       error ("can't pipe to more, using stdout instead.");
  1635. +       outfile = stdout;
  1636. +         }
  1637. + 
  1638. + #else
  1639. + 
  1640.         int pipes[2];
  1641.         int desc;
  1642.   
  1643. ***************
  1644. *** 162,167 ****
  1645. --- 199,207 ----
  1646.         close (pipes[0]);
  1647.         outfile = fdopen (pipes[1], "w");
  1648.       } 
  1649. + 
  1650. + #endif /* MSDOS */
  1651. + 
  1652.       }
  1653.     else
  1654.       {
  1655. ***************
  1656. *** 187,194 ****
  1657. --- 227,268 ----
  1658.   {
  1659.     if (outfile != stdout)
  1660.       {
  1661. + #ifdef MSDOS
  1662. + 
  1663. + #ifndef PAGER
  1664. + #define PAGER "more"
  1665. + #endif
  1666. + #ifndef PAGER_ARGS
  1667. + #define PAGER_ARGS NULL
  1668. + #endif
  1669. + 
  1670. +       int diff_stdin;
  1671. +       int pager_stdin;
  1672. + 
  1673. +       fclose (outfile);
  1674. + 
  1675. +       diff_stdin = dup (0);
  1676. +       pager_stdin = open (_pipe_file (), O_RDONLY|O_TEXT);
  1677. +       dup2 (pager_stdin, 0);
  1678. + 
  1679. +       spawnlp (P_WAIT, PAGER, PAGER, PAGER_ARGS, NULL);
  1680. + 
  1681. +       dup2 (diff_stdin, 0);
  1682. +       close (diff_stdin);
  1683. +       close (pager_stdin);
  1684. + 
  1685. +       printf ("hit any key to continue...");
  1686. +       while (!kbhit ())
  1687. +     ;
  1688. + 
  1689. +       printf ("\n");
  1690. + 
  1691. + #else /* not MSDOS */
  1692. + 
  1693.         fclose (outfile);
  1694.         wait (0);
  1695. + 
  1696. + #endif /* not MSDOS */
  1697.       }
  1698.   }
  1699.   
  1700. ***************
  1701. *** 201,209 ****
  1702.   line_cmp (s1, s2)
  1703.        struct line_def *s1, *s2;
  1704.   {
  1705. !   register char *t1, *t2;
  1706.     register char end_char = line_end_char;
  1707.     int savechar;
  1708.   
  1709.     /* Check first for exact identity.
  1710.        If that is true, return 0 immediately.
  1711. --- 275,287 ----
  1712.   line_cmp (s1, s2)
  1713.        struct line_def *s1, *s2;
  1714.   {
  1715. !   register char _huge *t1, _huge *t2;
  1716.     register char end_char = line_end_char;
  1717. + #ifdef MSDOS
  1718. +   char savechar;
  1719. + #else /* not MSDOS */
  1720.     int savechar;
  1721. + #endif /* not MSDOS */
  1722.   
  1723.     /* Check first for exact identity.
  1724.        If that is true, return 0 immediately.
  1725. ***************
  1726. *** 340,350 ****
  1727. --- 418,435 ----
  1728.      PRINTFUN takes a subscript which belongs together (with a null
  1729.      link at the end) and prints it.  */
  1730.   
  1731. + #ifdef MSDOS
  1732. + void
  1733. + print_script (    struct change *script,
  1734. +         struct change * (*hunkfun) (struct change *),
  1735. +         void (*printfun) (struct change *) )
  1736. + #else
  1737.   void
  1738.   print_script (script, hunkfun, printfun)
  1739.        struct change *script;
  1740.        struct change * (*hunkfun) ();
  1741.        void (*printfun) ();
  1742. + #endif /* MSDOS */
  1743.   {
  1744.     struct change *next = script;
  1745.   
  1746. ***************
  1747. *** 566,571 ****
  1748. --- 651,728 ----
  1749.   
  1750.   /* malloc a block of memory, with fatal error message if we can't do it. */
  1751.   
  1752. + #ifdef MSDOS
  1753. + #include <malloc.h>
  1754. + #include <dos.h>
  1755. + 
  1756. + void _huge *
  1757. + xhalloc (long size)
  1758. + {
  1759. +   void _huge *value = (void _huge *) halloc (size, (size_t)1 );
  1760. + 
  1761. +   if (!value)
  1762. +     fatal ("virtual memory exhausted");
  1763. +   return value;
  1764. + }
  1765. + 
  1766. + /* Here we do a huge "realloc" by allocating a new block and
  1767. +    moving the old block afterwards.  This is *slow*, but should
  1768. +    be reliable.  */
  1769. + 
  1770. + void _huge *
  1771. + xhrealloc (void _huge *ptr, long new_size, long old_size)
  1772. + {
  1773. +   void _huge *value = (void _huge *) halloc (new_size, (size_t)1 );
  1774. + 
  1775. +   if (!value)
  1776. +     fatal ("virtual memory exhausted");
  1777. +   else
  1778. +     {
  1779. +       char _huge *dest = value;
  1780. +       char _huge *src = ptr;
  1781. + 
  1782. +       while (old_size > 0L)
  1783. +     {
  1784. +       unsigned int bytes = (unsigned int) min (0x8000L, old_size);
  1785. +       memcpy (dest, src, bytes);
  1786. +       old_size -= (long) bytes;
  1787. +       dest += (long) bytes;
  1788. +       src += (long) bytes;
  1789. +     }
  1790. +     }
  1791. +   hfree (ptr);
  1792. +   return value;
  1793. + }
  1794. + 
  1795. + long        /* doesn't belong here, but is also a 'huge' pointer kludge */
  1796. + hread (int fd, void _huge *buffer, long bytes)
  1797. + {
  1798. +   long bytes_read = 0L;
  1799. + 
  1800. +   while (1)
  1801. +     {
  1802. +       int n = read (fd, buffer, (unsigned int) min (0x4000L, bytes));
  1803. + 
  1804. +       if (n > 0)
  1805. +     {
  1806. +       bytes_read += (long) n;
  1807. +       bytes -= (long) n;
  1808. +       /* we can't say buffer += n here, because we have to make
  1809. +          sure that the offset of BUFFER doesn't overflow during
  1810. +          the read() system call.  Therefore we add what we read
  1811. +          to the segment of BUFFER.  */
  1812. +       FP_SEG(buffer) += (n >> 4);
  1813. +       FP_OFF(buffer) += (n & 0x0F);
  1814. +     }
  1815. +       else if (n == 0)
  1816. +     return bytes_read;    /* done */
  1817. +       else
  1818. +     pfatal_with_name ("error while reading input");
  1819. +     }
  1820. + }
  1821. + 
  1822. + #endif /* MSDOS */
  1823. + 
  1824.   VOID *
  1825.   xmalloc (size)
  1826.        unsigned size;
  1827. ***************
  1828. *** 615,620 ****
  1829. --- 772,780 ----
  1830.     return new;
  1831.   }
  1832.   
  1833. + #ifdef MSDOS
  1834. + void
  1835. + #endif /* MSDOS */
  1836.   debug_script (sp)
  1837.        struct change *sp;
  1838.   {
  1839. ***************
  1840. *** 624,626 ****
  1841. --- 784,839 ----
  1842.            sp->line0, sp->line1, sp->deleted, sp->inserted);
  1843.     fflush (stderr);
  1844.   }
  1845. + 
  1846. + #ifdef MSDOS
  1847. + 
  1848. + static char *pipe_file = NULL;
  1849. + static char *tmpdir = NULL;
  1850. + static int tmpdirlen;
  1851. + 
  1852. + /* Return the name of a temporary file.  */
  1853. + char *
  1854. + _pipe_file (void)
  1855. + {
  1856. +   if (!pipe_file)
  1857. +     {
  1858. +       if (!tmpdir)
  1859. +     {
  1860. +       /* Initialize.  */
  1861. + 
  1862. +       atexit (cleanup_pipe);
  1863. + 
  1864. +       tmpdir = getenv ("TMP");
  1865. + 
  1866. +       if (tmpdir)
  1867. +         {
  1868. +           tmpdirlen = strlen (tmpdir);
  1869. +           if (tmpdir[tmpdirlen - 1] == '/'
  1870. +           || tmpdir[tmpdirlen - 1] == '\\')
  1871. +         tmpdir[tmpdirlen - 1] = '\0';
  1872. +         }
  1873. +       else
  1874. +         {
  1875. +           tmpdir = ".";
  1876. +           tmpdirlen = 1;
  1877. +         }
  1878. +     }
  1879. + 
  1880. +       pipe_file = (char *) xmalloc (tmpdirlen + 14);
  1881. +       sprintf (pipe_file, "%s/diff%04x", tmpdir, getpid ());
  1882. +     }
  1883. + 
  1884. +   return pipe_file;
  1885. + }
  1886. + 
  1887. + 
  1888. + /* Clean up after we are done. */
  1889. + 
  1890. + void
  1891. + cleanup_pipe (void)
  1892. + {
  1893. +   unlink (pipe_file);
  1894. + }
  1895. + 
  1896. + #endif /* MSDOS */
  1897. + 
  1898. *** e:\tmp/RCSt1005321    Tue Mar 12 17:20:22 1991
  1899. --- version.c    Tue Mar 12 17:19:02 1991
  1900. ***************
  1901. *** 1,3 ****
  1902. --- 1,8 ----
  1903.   /* Version number of GNU diff.  */
  1904.   
  1905. + #ifdef MSDOS
  1906. + char *version_string
  1907. +   =  "1.15 (compiled " __DATE__ " " __TIME__ " for MS-DOS)";
  1908. + #else /* not MSDOS */
  1909.   char *version_string = "1.15";
  1910. + #endif /* not MSDOS */
  1911.