home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / misc / volume13 / gdiff-tc / part01 next >
Text File  |  1990-06-02  |  20KB  |  790 lines
  1. Newsgroups: comp.sources.misc
  2. organization: U of Wisconsin CS Dept
  3. subject: v13i024: GNU diff 1.14 patches for MSDOS Turbo C 2.0
  4. from: ward@sneezy.cs.wisc.edu (Michael Ward)
  5. Sender: allbery@uunet.UU.NET (Brandon S. Allbery - comp.sources.misc)
  6.  
  7. Posting-number: Volume 13, Issue 24
  8. Submitted-by: ward@sneezy.cs.wisc.edu (Michael Ward)
  9. Archive-name: gdiff-tc/part01
  10.  
  11. The following patches will allow GNU diff v1.14 to compile with Turbo C 2.0
  12. and run under MSDOS. I have only checked a couple of context and normal diffs,
  13. but it seems to work fine. One major restriction is that the files to be
  14. compared must both be less than 64K in size. Hope this is useful anyway.
  15.  
  16. Mike Ward
  17. ward@sneezy.cs.wisc.edu
  18.  
  19.     remove this header and then use patch to apply the diffs
  20.     if you don't have patch, there are not that many changes ...
  21.  
  22.  
  23. ---------- cut here --------------------------------------------------
  24. *** ../gnudiff/diff.h    Fri Feb 23 07:55:14 1990
  25. --- diff.h    Sat Jun 02 07:53:46 1990
  26. ***************
  27. *** 23,28 ****
  28. --- 23,43 ----
  29.   #include <sys/types.h>
  30.   #include <sys/stat.h>
  31.   
  32. + #ifdef TURBOC20
  33. + #define MEMSZ unsigned
  34. + #define MAXMEMBLK 65530L
  35. + #else
  36. + #define MEMSZ int
  37. + #endif
  38. + 
  39. + 
  40. + #ifdef TURBOC20
  41. + #include <stdlib.h>
  42. + #include <string.h>
  43. + #include <time.h>
  44. + #include <dir.h>
  45. + #include <fcntl.h>
  46. + #else
  47.   #ifdef USG
  48.   #include <time.h>
  49.   #ifdef HAVE_NDIR
  50. ***************
  51. *** 39,45 ****
  52. --- 54,69 ----
  53.   #include <sys/dir.h>
  54.   #include <sys/file.h>
  55.   #endif
  56. + #endif
  57.   
  58. + #ifdef TURBOC20
  59. + #define bcopy(s,d,n)    memcpy((d),(s),(n))
  60. + #define bcmp(s1,s2,n)    memcmp((s1),(s2),(n))
  61. + #define bzero(s,n)    memset((s),0,(n))
  62. + 
  63. + #define index    strchr
  64. + #define rindex    strrchr
  65. + #else
  66.   #ifdef USG
  67.   /* Define needed BSD functions in terms of sysV library.  */
  68.   
  69. ***************
  70. *** 53,58 ****
  71. --- 77,83 ----
  72.   #define index    strchr
  73.   #define rindex    strrchr
  74.   #endif
  75. + #endif
  76.   
  77.   #include <errno.h>
  78.   extern int      errno;
  79. ***************
  80. *** 229,237 ****
  81.       /* Buffer in which text of file is read.  */
  82.       char *        buffer;
  83.       /* Allocated size of buffer.  */
  84. !     int            bufsize;
  85.       /* Number of valid characters now in the buffer. */
  86. !     int            buffered_chars;
  87.   
  88.       /* Array of data on analyzed lines of this chunk of this file.  */
  89.       struct line_def *linbuf;
  90. --- 254,262 ----
  91.       /* Buffer in which text of file is read.  */
  92.       char *        buffer;
  93.       /* Allocated size of buffer.  */
  94. !     MEMSZ            bufsize;
  95.       /* Number of valid characters now in the buffer. */
  96. !     MEMSZ            buffered_chars;
  97.   
  98.       /* Array of data on analyzed lines of this chunk of this file.  */
  99.       struct line_def *linbuf;
  100. ***************
  101. *** 292,298 ****
  102.   
  103.   /* Describe the two files currently being compared.  */
  104.   
  105. ! struct file_data files[2];
  106.   
  107.   /* Queue up one-line messages to be printed at the end,
  108.      when -l is specified.  Each message is recorded with a `struct msg'.  */
  109. --- 317,323 ----
  110.   
  111.   /* Describe the two files currently being compared.  */
  112.   
  113. ! EXTERN struct file_data files[2];
  114.   
  115.   /* Queue up one-line messages to be printed at the end,
  116.      when -l is specified.  Each message is recorded with a `struct msg'.  */
  117. *** ../gnudiff/limits.h    Thu Mar 01 14:31:40 1990
  118. --- limits.h    Sat Jun 02 07:53:48 1990
  119. ***************
  120. *** 28,38 ****
  121.   #define USHRT_MAX 65535U
  122.   
  123.   /* Minimum and maximum values a `signed int' can hold.  */
  124. ! #define INT_MIN (-INT_MAX-1)
  125. ! #define INT_MAX 2147483647
  126.   
  127.   /* Maximum value an `unsigned int' can hold.  (Minimum is 0).  */
  128. ! #define UINT_MAX 4294967295U
  129.   
  130.   /* Minimum and maximum values a `signed long int' can hold.
  131.      (Same as `int').  */
  132. --- 28,38 ----
  133.   #define USHRT_MAX 65535U
  134.   
  135.   /* Minimum and maximum values a `signed int' can hold.  */
  136. ! #define INT_MIN (-32768)
  137. ! #define INT_MAX 32767
  138.   
  139.   /* Maximum value an `unsigned int' can hold.  (Minimum is 0).  */
  140. ! #define UINT_MAX 65535U
  141.   
  142.   /* Minimum and maximum values a `signed long int' can hold.
  143.      (Same as `int').  */
  144. *** ../gnudiff/analyze.c    Thu Mar 01 14:20:26 1990
  145. --- analyze.c    Sat Jun 02 07:53:56 1990
  146. ***************
  147. *** 655,660 ****
  148. --- 655,661 ----
  149.     int binary;
  150.     int changes;
  151.   
  152. + #ifndef TURBOC20
  153.     /* See if the two named files are actually the same physical file.
  154.        If so, we know they are identical without actually reading them.  */
  155.   
  156. ***************
  157. *** 661,666 ****
  158. --- 662,668 ----
  159.     if (filevec[0].stat.st_ino == filevec[1].stat.st_ino
  160.         && filevec[0].stat.st_dev == filevec[1].stat.st_dev)
  161.       return 0;
  162. + #endif
  163.   
  164.     binary = read_files (filevec);
  165.   
  166. *** ../gnudiff/diff.c    Sun Feb 18 17:29:34 1990
  167. --- diff.c    Sat Jun 02 07:53:56 1990
  168. ***************
  169. *** 260,269 ****
  170. --- 260,271 ----
  171.         ignore_regexp = optarg;
  172.         break;
  173.   
  174. + #ifndef TURBOC20
  175.       case 'l':
  176.         /* Pass the output through `pr' to paginate it.  */
  177.         paginate_flag = 1;
  178.         break;
  179. + #endif
  180.   
  181.       case 'n':
  182.         /* Output RCS-style diffs, like `-f' except that each command
  183. ***************
  184. *** 366,372 ****
  185.   
  186.     switch_string = option_list (argv + 1, optind - 1);
  187.   
  188. !   val = compare_files (0, argv[optind], 0, argv[optind + 1], 0);
  189.   
  190.     /* Print any messages that were saved up for last.  */
  191.     print_message_queue ();
  192. --- 368,374 ----
  193.   
  194.     switch_string = option_list (argv + 1, optind - 1);
  195.   
  196. !   val = compare_files (NULL, argv[optind], NULL, argv[optind + 1], 0);
  197.   
  198.     /* Print any messages that were saved up for last.  */
  199.     print_message_queue ();
  200. ***************
  201. *** 426,433 ****
  202.   
  203.     if (! entire_new_file_flag && (name0 == 0 || name1 == 0))
  204.       {
  205. !       char *name = name0 == 0 ? name1 : name0;
  206. !       char *dir = name0 == 0 ? dir1 : dir0;
  207.         message ("Only in %s: %s\n", dir, name);
  208.         /* Return 1 so that diff_dirs will return 1 ("some files differ").  */
  209.         return 1;
  210. --- 428,435 ----
  211.   
  212.     if (! entire_new_file_flag && (name0 == 0 || name1 == 0))
  213.       {
  214. !       char *name = name0 == NULL ? name1 : name0;
  215. !       char *dir = name0 == NULL ? dir1 : dir0;
  216.         message ("Only in %s: %s\n", dir, name);
  217.         /* Return 1 so that diff_dirs will return 1 ("some files differ").  */
  218.         return 1;
  219. ***************
  220. *** 435,452 ****
  221.   
  222.     /* Mark any nonexistent file with -1 in the desc field.  */
  223.   
  224. !   inf[0].desc = name0 == 0 ? -1 : 0;
  225. !   inf[1].desc = name1 == 0 ? -1 : 0;
  226.   
  227.     /* Now record the full name of each file, including nonexistent ones.  */
  228.   
  229. !   if (name0 == 0)
  230.       name0 = name1;
  231. !   if (name1 == 0)
  232.       name1 = name0;
  233.   
  234. !   inf[0].name = dir0 == 0 ? name0 : concat (dir0, "/", name0);
  235. !   inf[1].name = dir1 == 0 ? name1 : concat (dir1, "/", name1);
  236.   
  237.     /* Stat the files.  Record whether they are directories.
  238.        Record in stat_result whether stat fails.  */
  239. --- 437,454 ----
  240.   
  241.     /* Mark any nonexistent file with -1 in the desc field.  */
  242.   
  243. !   inf[0].desc = name0 == NULL ? -1 : 0;
  244. !   inf[1].desc = name1 == NULL ? -1 : 0;
  245.   
  246.     /* Now record the full name of each file, including nonexistent ones.  */
  247.   
  248. !   if (name0 == NULL)
  249.       name0 = name1;
  250. !   if (name1 == NULL)
  251.       name1 = name0;
  252.   
  253. !   inf[0].name = dir0 == NULL ? name0 : concat (dir0, "/", name0);
  254. !   inf[1].name = dir1 == NULL ? name1 : concat (dir1, "/", name1);
  255.   
  256.     /* Stat the files.  Record whether they are directories.
  257.        Record in stat_result whether stat fails.  */
  258. ***************
  259. *** 473,478 ****
  260. --- 475,481 ----
  261.       }
  262.       }
  263.   
  264. + #ifndef TURBOC20
  265.     /* See if the two named files are actually the same physical file.
  266.        If so, we know they are identical without actually reading them.  */
  267.   
  268. ***************
  269. *** 484,493 ****
  270.         val = 0;
  271.         goto done;
  272.       }
  273.   
  274. !   if (name0 == 0)
  275.       inf[0].dir_p = inf[1].dir_p;
  276. !   if (name1 == 0)
  277.       inf[1].dir_p = inf[0].dir_p;
  278.   
  279.     /* Open the files and record their descriptors.  */
  280. --- 487,497 ----
  281.         val = 0;
  282.         goto done;
  283.       }
  284. + #endif
  285.   
  286. !   if (name0 == NULL)
  287.       inf[0].dir_p = inf[1].dir_p;
  288. !   if (name1 == NULL)
  289.       inf[1].dir_p = inf[0].dir_p;
  290.   
  291.     /* Open the files and record their descriptors.  */
  292. ***************
  293. *** 646,654 ****
  294.     else
  295.       fflush (stdout);
  296.   
  297. !   if (dir0 != 0)
  298.       free (inf[0].name);
  299. !   if (dir1 != 0)
  300.       free (inf[1].name);
  301.   
  302.     return val;
  303. --- 650,658 ----
  304.     else
  305.       fflush (stdout);
  306.   
  307. !   if (dir0 != NULL)
  308.       free (inf[0].name);
  309. !   if (dir1 != NULL)
  310.       free (inf[1].name);
  311.   
  312.     return val;
  313. *** ../gnudiff/diff3.c    Fri Feb 23 07:57:34 1990
  314. --- diff3.c    Sat Jun 02 07:54:14 1990
  315. ***************
  316. *** 30,35 ****
  317. --- 30,43 ----
  318.   #include <stdio.h>
  319.   #include <ctype.h>
  320.   
  321. + #ifdef TURBOC20
  322. + #define bcopy(s,d,n)    memcpy((d),(s),(n))
  323. + #define bcmp(s1,s2,n)    memcmp((s1),(s2),(n))
  324. + #define bzero(s,n)    memset((s),0,(n))
  325. + 
  326. + #define index    strchr
  327. + #define rindex    strrchr
  328. + #else
  329.   #ifdef USG
  330.   #include <fcntl.h>
  331.   
  332. ***************
  333. *** 44,49 ****
  334. --- 52,58 ----
  335.   #define vfork    fork
  336.   #define index    strchr
  337.   #define rindex    strrchr
  338. + #endif
  339.   #endif
  340.   /*
  341.    * Internal data structures and macros for the diff3 program; includes
  342. *** ../gnudiff/dir.c    Thu Nov 16 11:10:46 1989
  343. --- dir.c    Sat Jun 02 07:54:18 1990
  344. ***************
  345. *** 36,43 ****
  346. --- 36,51 ----
  347.        char *dirname;
  348.        int nonex;
  349.   {
  350. + #ifdef TURBOC20
  351. +   int err;
  352. +   char *name;
  353. +   struct ffblk info;
  354. +   struct ffblk *next = &info;
  355. + #else
  356.     register DIR *reading;
  357.     register struct direct *next;
  358. + #endif
  359. + 
  360.     struct dirdata dirdata;
  361.   
  362.     /* Address of block containing the files that are described.  */
  363. ***************
  364. *** 49,54 ****
  365. --- 57,63 ----
  366.     /* Index of first unused in `files'.  */
  367.     int files_index;
  368.   
  369. + 
  370.     if (nonex)
  371.       {
  372.         dirdata.length = 0;
  373. ***************
  374. *** 56,61 ****
  375. --- 65,78 ----
  376.         return dirdata;
  377.       }
  378.   
  379. + #ifdef TURBOC20
  380. +   name = (char *) xmalloc (strlen (dirname) + 4);
  381. +   strcpy(name,dirname);
  382. +   if (strlen(name) && name[strlen(name)-1]!='/') strcat(name,"/");
  383. +   strcat(name,"*.*");
  384. +   err = findfirst(name,next,0x3f);
  385. +   free(name);
  386. + #else
  387.     /* Open the directory and check for errors.  */
  388.     reading = opendir (dirname);
  389.     if (!reading)
  390. ***************
  391. *** 64,69 ****
  392. --- 81,87 ----
  393.         dirdata.length = -1;
  394.         return dirdata;
  395.       }
  396. + #endif
  397.   
  398.     /* Initialize the table of filenames.  */
  399.   
  400. ***************
  401. *** 74,79 ****
  402. --- 92,118 ----
  403.     /* Read the directory entries, and insert the subfiles
  404.        into the `files' table.  */
  405.   
  406. + #ifdef TURBOC20
  407. +   while (!err)
  408. +     {
  409. +       /* Ignore the files `.' and `..' */
  410. +       if (next->ff_name[0] == '.'
  411. +       && (next->ff_name[1] == 0
  412. +           || (next->ff_name[1] == '.'
  413. +           && next->ff_name[2] == 0)))
  414. +     continue;
  415. + 
  416. +       if (files_index == nfiles)
  417. +     {
  418. +       nfiles *= 2;
  419. +       files
  420. +         = (char **) xrealloc (files, sizeof (char *) * nfiles);
  421. +     }
  422. +       strlwr(next->ff_name);
  423. +       files[files_index++] = concat (next->ff_name, "", "");
  424. +       err = findnext(next);
  425. +     }
  426. + #else
  427.     while (next = readdir (reading))
  428.       {
  429.         /* Ignore the files `.' and `..' */
  430. ***************
  431. *** 93,98 ****
  432. --- 132,138 ----
  433.       }
  434.   
  435.     closedir (reading);
  436. + #endif
  437.   
  438.     /* Sort the table.  */
  439.     qsort (files, files_index, sizeof (char *), compare_names);
  440. *** ../gnudiff/getopt.c    Thu Mar 01 10:53:00 1990
  441. --- getopt.c    Sat Jun 02 07:54:24 1990
  442. ***************
  443. *** 32,37 ****
  444. --- 32,41 ----
  445.   #include <stdio.h>
  446.   
  447.   /* If compiled with GNU C, use the built-in alloca */
  448. + #ifdef TURBOC20
  449. + char *xmalloc ();
  450. + #define alloca(x) xmalloc(x)
  451. + #else
  452.   #ifdef __GNUC__
  453.   #define alloca __builtin_alloca
  454.   #else /* not __GNUC__ */
  455. ***************
  456. *** 41,50 ****
  457. --- 45,60 ----
  458.   char *alloca ();
  459.   #endif
  460.   #endif /* not __GNUC__ */
  461. + #endif
  462.   
  463. + #ifdef TURBOC20
  464. + #define bcopy(s, d, l) memcpy((d), (s), (l))
  465. + #define index strchr
  466. + #else
  467.   #ifdef USG
  468.   #define bcopy(s, d, l) memcpy((d), (s), (l))
  469.   #define index strchr
  470. + #endif
  471.   #endif
  472.   
  473.   char *getenv ();
  474. *** ../gnudiff/io.c    Sun Dec 24 08:03:12 1989
  475. --- io.c    Sat Jun 02 07:54:30 1990
  476. ***************
  477. *** 68,83 ****
  478.        and one for a sentinel in find_identical_ends.  */
  479.     else if ((current->stat.st_mode & S_IFMT) == S_IFREG)
  480.       {
  481.         current->bufsize = current->stat.st_size;
  482.         current->buffer = (char *) xmalloc (current->bufsize + 2);
  483.         current->buffered_chars
  484.       = read (current->desc, current->buffer, current->bufsize);
  485. !       if (current->buffered_chars < 0)
  486.       pfatal_with_name (current->name);
  487.       }
  488.     else
  489.       {
  490. !       int cc;
  491.   
  492.         current->bufsize = 4096;
  493.         current->buffer = (char *) xmalloc (current->bufsize + 2);
  494. --- 68,87 ----
  495.        and one for a sentinel in find_identical_ends.  */
  496.     else if ((current->stat.st_mode & S_IFMT) == S_IFREG)
  497.       {
  498. + #ifdef TURBOC20
  499. +       if (current->stat.st_size > MAXMEMBLK)
  500. +         pfatal_with_name("file too large!");
  501. + #endif
  502.         current->bufsize = current->stat.st_size;
  503.         current->buffer = (char *) xmalloc (current->bufsize + 2);
  504.         current->buffered_chars
  505.       = read (current->desc, current->buffer, current->bufsize);
  506. !       if (current->buffered_chars == (MEMSZ)-1)
  507.       pfatal_with_name (current->name);
  508.       }
  509.     else
  510.       {
  511. !       MEMSZ cc;
  512.   
  513.         current->bufsize = 4096;
  514.         current->buffer = (char *) xmalloc (current->bufsize + 2);
  515. ***************
  516. *** 88,104 ****
  517.         while ((cc = read (current->desc,
  518.                current->buffer + current->buffered_chars,
  519.                current->bufsize - current->buffered_chars))
  520. !          > 0)
  521.       {
  522.         current->buffered_chars += cc;
  523.         if (current->buffered_chars == current->bufsize)
  524.           {
  525.             current->bufsize = current->bufsize * 2;
  526.             current->buffer = (char *) xrealloc (current->buffer,
  527.                              current->bufsize + 2);
  528.           }
  529.       }
  530. !       if (cc < 0)
  531.       pfatal_with_name (current->name);
  532.       }
  533.     
  534. --- 92,112 ----
  535.         while ((cc = read (current->desc,
  536.                current->buffer + current->buffered_chars,
  537.                current->bufsize - current->buffered_chars))
  538. !          != (MEMSZ)-1 && cc != 0)
  539.       {
  540.         current->buffered_chars += cc;
  541.         if (current->buffered_chars == current->bufsize)
  542.           {
  543. + #ifdef TURBOC20
  544. +               if (2L * (long)(current->bufsize) > MAXMEMBLK)
  545. +                 pfatal_with_name("file too large!");
  546. + #endif
  547.             current->bufsize = current->bufsize * 2;
  548.             current->buffer = (char *) xrealloc (current->buffer,
  549.                              current->bufsize + 2);
  550.           }
  551.       }
  552. !       if (cc == (MEMSZ)-1)
  553.       pfatal_with_name (current->name);
  554.       }
  555.     
  556. *** ../gnudiff/regex.c    Mon Jan 08 09:33:40 1990
  557. --- regex.c    Sat Jun 02 07:54:46 1990
  558. ***************
  559. *** 32,37 ****
  560. --- 32,42 ----
  561.   
  562.   #else  /* not emacs */
  563.   
  564. + #ifdef TURBOC20
  565. + #define bcopy(s,d,n)    memcpy((d),(s),(n))
  566. + #define bcmp(s1,s2,n)    memcmp((s1),(s2),(n))
  567. + #define bzero(s,n)    memset((s),0,(n))
  568. + #else
  569.   #ifdef USG
  570.   #ifndef BSTRING
  571.   #define bcopy(s,d,n)    memcpy((d),(s),(n))
  572. ***************
  573. *** 39,49 ****
  574. --- 44,59 ----
  575.   #define bzero(s,n)    memset((s),0,(n))
  576.   #endif
  577.   #endif
  578. + #endif
  579.   
  580.   char *malloc ();
  581.   char *realloc ();
  582.   
  583.   /* Make alloca work the best possible way.  */
  584. + #ifdef TURBOC20
  585. + char *xmalloc ();
  586. + #define alloca(x) xmalloc(x)
  587. + #else
  588.   #ifdef __GNUC__
  589.   #define alloca __builtin_alloca
  590.   #else
  591. ***************
  592. *** 51,56 ****
  593. --- 61,67 ----
  594.   #include <alloca.h>
  595.   #else
  596.   char *alloca ();
  597. + #endif
  598.   #endif
  599.   #endif
  600.   
  601. *** ../gnudiff/util.c    Fri Feb 23 07:56:12 1990
  602. --- util.c    Sat Jun 02 07:54:52 1990
  603. ***************
  604. *** 129,134 ****
  605. --- 129,135 ----
  606.     strcat (name, " ");
  607.     strcat (name, name1);
  608.   
  609. + #ifndef TURBOC20  
  610.     if (paginate_flag)
  611.       {
  612.         int pipes[2];
  613. ***************
  614. *** 161,166 ****
  615. --- 162,168 ----
  616.       } 
  617.       }
  618.     else
  619. + #endif
  620.       {
  621.   
  622.         /* If -l was not specified, output the diff straight to `stdout'.  */
  623. ***************
  624. *** 182,192 ****
  625. --- 184,196 ----
  626.   void
  627.   finish_output ()
  628.   {
  629. + #ifndef TURBOC20
  630.     if (outfile != stdout)
  631.       {
  632.         fclose (outfile);
  633.         wait (0);
  634.       }
  635. + #endif
  636.   }
  637.   
  638.   /* Compare two lines (typically one from each input file)
  639. *** ../gnudiff/makefile    Sun Feb 18 19:11:30 1990
  640. --- makefile    Sat Jun 02 07:54:56 1990
  641. ***************
  642. *** 1,4 ****
  643. ! # Makefile for GNU DIFF
  644.   # Copyright (C) 1988, 1989 Free Software Foundation, Inc.
  645.   
  646.   # This file is part of GNU DIFF.
  647. --- 1,4 ----
  648. ! # Turbo C Makefile for GNU DIFF
  649.   # Copyright (C) 1988, 1989 Free Software Foundation, Inc.
  650.   
  651.   # This file is part of GNU DIFF.
  652. ***************
  653. *** 21,29 ****
  654.   # You can compile this with ordinary cc as well,
  655.   # but gcc makes it faster.
  656.   # Also, gcc supports -O and -g together.
  657. ! CC=gcc -O
  658. ! CFLAGS = -g
  659. ! INSTALL = install
  660.   
  661.   # On system V, enable these three lines:
  662.   # CFLAGS = -g -DUSG
  663. --- 21,28 ----
  664.   # You can compile this with ordinary cc as well,
  665.   # but gcc makes it faster.
  666.   # Also, gcc supports -O and -g together.
  667. ! CC=tcc
  668. ! CFLAGS = -A -N -v -1 -ml -DTURBOC20
  669.   
  670.   # On system V, enable these three lines:
  671.   # CFLAGS = -g -DUSG
  672. ***************
  673. *** 36,95 ****
  674.   # Add -DHAVE_DIRECT to CFLAGS if your system uses 'struct direct' instead of
  675.   # 'struct dirent' (this is the case at least with one add-on ndir library).
  676.   
  677. - bindir=/usr/local/bin
  678. - prefix=
  679. - 
  680. - # All source files
  681.   srcs=diff.c analyze.c io.c context.c ed.c normal.c ifdef.c util.c dir.c \
  682. !     version.c diff.h regex.c regex.h limits.h diff3.c \
  683. !     getopt.c getopt1.c getopt.h
  684. ! # Object files for diff only.
  685. ! objs=$(archpfx)diff.o $(archpfx)analyze.o $(archpfx)io.o $(archpfx)context.o \
  686. !      $(archpfx)ed.o $(archpfx)normal.o $(archpfx)util.o $(archpfx)dir.o \
  687. !      $(archpfx)regex.o $(archpfx)ifdef.o $(archpfx)version.o \
  688. !      $(archpfx)getopt.o $(archpfx)getopt1.o
  689. ! tapefiles = $(srcs) README diagmeet.note Makefile COPYING ChangeLog
  690. ! 
  691. ! all: $(archpfx)diff $(archpfx)diff3
  692. ! 
  693. ! $(archpfx)diff3: $(archpfx)diff3.o
  694. !     $(CC) -o $(archpfx)diff3 $(CFLAGS) $(LDFLAGS) $(archpfx)diff3.o $(LIBS)
  695. ! 
  696. ! $(archpfx)diff: $(objs)
  697. !     $(CC) -o $(archpfx)diff $(CFLAGS) $(LDFLAGS) $(objs) $(LIBS)
  698. ! 
  699. ! $(objs): diff.h
  700. ! 
  701. ! $(archpfx)context.o $(archpfx)diff.o: regex.h
  702. ! 
  703. ! $(archpfx)diff3.o: diff3.c
  704. !     $(CC) -c $(CFLAGS) -DDIFF_PROGRAM=\"$(bindir)/diff\" diff3.c \
  705. !  $(OUTPUT_OPTION)
  706. ! 
  707. ! clean:
  708. !     rm -f *.o $(archpfx)diff $(archpfx)diff3 diff.tar diff.tar.Z
  709. ! 
  710. ! install: install-diff install-diff3
  711. ! 
  712. ! install-diff: $(prefix)$(bindir)/diff
  713. ! 
  714. ! $(prefix)$(bindir)/diff: $(archpfx)diff
  715. !     $(INSTALL) $(archpfx)diff $(prefix)$(bindir)/diff
  716. ! 
  717. ! install-diff3: $(prefix)$(bindir)/diff3
  718. ! 
  719. ! $(prefix)$(bindir)/diff3: $(archpfx)diff3
  720. !     $(INSTALL) $(archpfx)diff3 $(prefix)$(bindir)/diff3
  721. ! 
  722. ! diff.tar: $(tapefiles)
  723. !     mkdir tmp
  724. !     mkdir tmp/diff
  725. !     -ln $(tapefiles) tmp/diff
  726. !     for file in $(tapefiles); do \
  727. !         if [ ! -r tmp/diff/$$file ]; then cp $$file tmp/diff; fi \
  728. !     done
  729. !     cd tmp; tar cf ../diff.tar diff
  730. !     rm -rf tmp
  731.   
  732. ! diff.tar.Z: diff.tar
  733. !     compress < diff.tar > diff.tar.Z
  734. --- 35,88 ----
  735.   # Add -DHAVE_DIRECT to CFLAGS if your system uses 'struct direct' instead of
  736.   # 'struct dirent' (this is the case at least with one add-on ndir library).
  737.   
  738.   srcs=diff.c analyze.c io.c context.c ed.c normal.c ifdef.c util.c dir.c \
  739. !     version.c diff.h regex.c regex.h limits.h diff3.c getopt.c \
  740. !     getopt1.c getopt.h
  741. ! allobj=analyze.obj io.obj ed.obj normal.obj util.obj dir.obj regex.obj \
  742. !     ifdef.obj version.obj getopt.obj getopt1.obj context.obj diff.obj
  743. ! 
  744. ! 
  745. ! .h.obj:
  746. !     $(CC) -c $(CFLAGS) $(LDFLAGS) $*
  747. ! 
  748. ! .c.obj:
  749. !     $(CC) -c $(CFLAGS) $(LDFLAGS) $*
  750. ! 
  751. ! 
  752. ! # all: diff.exe diff3.exe
  753. ! all: diff.exe
  754. ! 
  755. ! diff3.exe: diff3.obj getopt.obj
  756. !     $(CC) -ediff3 $(CFLAGS) $(LDFLAGS) diff3.obj getopt.obj
  757. ! 
  758. ! diff.exe: $(allobj)
  759. !     $(CC) -ediff $(CFLAGS) $(LDFLAGS) *.obj
  760. ! 
  761. ! analyze.obj: diff.h analyze.c
  762. ! 
  763. ! io.obj: diff.h io.c
  764. ! 
  765. ! ed.obj: diff.h ed.c
  766. ! 
  767. ! normal.obj: diff.h normal.c
  768. ! 
  769. ! util.obj: diff.h util.c
  770. ! 
  771. ! dir.obj: diff.h dir.c
  772. ! 
  773. ! regex.obj: diff.h regex.c
  774. ! 
  775. ! ifdef.obj: diff.h ifdef.c
  776. ! 
  777. ! version.obj: diff.h version.c
  778. ! 
  779. ! getopt.obj: diff.h getopt.c
  780. ! 
  781. ! getopt1.obj: diff.h getopt1.c
  782. ! 
  783. ! context.obj: regex.h diff.h context.c
  784. ! 
  785. ! diff.obj: regex.h diff.h diff.c
  786.   
  787. ! diff3.obj: diff3.c
  788. !     $(CC) -c $(CFLAGS) -DDIFF_PROGRAM="\"diff\"" diff3.c
  789.  
  790.