home *** CD-ROM | disk | FTP | other *** search
/ Garbo / Garbo.cdr / pc / unix / diff32.zoo / patches.dif < prev    next >
Encoding:
Text File  |  1991-03-13  |  21.8 KB  |  915 lines
  1. diff +context=2 +new-file diff/analyze.c diff.new/analyze.c
  2. *** diff/analyze.c    Sun Jan  6 10:05:10 1991
  3. --- diff.new/analyze.c    Sat Jan 26 07:08:54 1991
  4. ***************
  5. *** 23,26 ****
  6. --- 23,32 ----
  7.   
  8.   #include "diff.h"
  9. + #if defined(DEBUG)
  10. + #undef DEBUG
  11. + #define DEBUG(x) x
  12. + #else
  13. + #define DEBUG(x)
  14. + #endif
  15.   
  16.   struct change *find_change ();
  17. ***************
  18. *** 729,733 ****
  19.     /* See if the two named files are actually the same physical file.
  20.        If so, we know they are identical without actually reading them.  */
  21. ! 
  22.     if (output_style != OUTPUT_IFDEF
  23.         && filevec[0].stat.st_ino == filevec[1].stat.st_ino
  24. --- 735,739 ----
  25.     /* See if the two named files are actually the same physical file.
  26.        If so, we know they are identical without actually reading them.  */
  27. ! #if !defined(MSDOS)
  28.     if (output_style != OUTPUT_IFDEF
  29.         && filevec[0].stat.st_ino == filevec[1].stat.st_ino
  30. ***************
  31. *** 734,738 ****
  32.         && filevec[0].stat.st_dev == filevec[1].stat.st_dev)
  33.       return 0;
  34. ! 
  35.     binary = read_files (filevec);
  36.   
  37. --- 740,744 ----
  38.         && filevec[0].stat.st_dev == filevec[1].stat.st_dev)
  39.       return 0;
  40. ! #endif /* MSDOS */
  41.     binary = read_files (filevec);
  42.   
  43. diff +context=2 +new-file diff/diff.c diff.new/diff.c
  44. *** diff/diff.c    Sun Jan  6 10:53:24 1991
  45. --- diff.new/diff.c    Sat Jan 26 07:08:54 1991
  46. ***************
  47. *** 26,30 ****
  48. --- 26,37 ----
  49.   #include "getopt.h"
  50.   
  51. + #if defined(DEBUG)
  52. + #undef DEBUG
  53. + #define DEBUG(x) x
  54. + #else
  55. + #define DEBUG(x)
  56. + #endif
  57.   
  58. + 
  59.   /* Nonzero for -r: if comparing two directories,
  60.      compare their common subdirectories recursively.  */
  61. ***************
  62. *** 447,451 ****
  63.     int errorcount = 0;
  64.     int stat_result[2];
  65. ! 
  66.     /* If this is directory comparison, perhaps we have a file
  67.        that exists only in one of the directories.
  68. --- 454,459 ----
  69.     int errorcount = 0;
  70.     int stat_result[2];
  71. !   DEBUG(fprintf(stderr,"compare_files(%s,%s,%s,%s,%d)\n",
  72. !       dir0,name0,dir1,name1,depth);fflush(stderr);)
  73.     /* If this is directory comparison, perhaps we have a file
  74.        that exists only in one of the directories.
  75. ***************
  76. *** 506,510 ****
  77.       }
  78.       }
  79. ! 
  80.     /* See if the two named files are actually the same physical file.
  81.        If so, we know they are identical without actually reading them.  */
  82. --- 514,518 ----
  83.       }
  84.       }
  85. ! #if !defined(MSDOS)
  86.     /* See if the two named files are actually the same physical file.
  87.        If so, we know they are identical without actually reading them.  */
  88. ***************
  89. *** 519,523 ****
  90.         goto done;
  91.       }
  92. ! 
  93.     if (name0 == 0)
  94.       inf[0].dir_p = inf[1].dir_p;
  95. --- 527,531 ----
  96.         goto done;
  97.       }
  98. ! #endif
  99.     if (name0 == 0)
  100.       inf[0].dir_p = inf[1].dir_p;
  101. diff +context=2 +new-file diff/diff3.c diff.new/diff3.c
  102. *** diff/diff3.c    Sun Jan  6 10:58:12 1991
  103. --- diff.new/diff3.c    Wed Mar 13 04:00:46 1991
  104. ***************
  105. *** 48,52 ****
  106. --- 48,57 ----
  107.   
  108.   #else /* not USG */
  109. + #ifndef MSDOS
  110.   #include <sys/wait.h>
  111. + #else
  112. + #include <fcntl.h>
  113. + #include <std.h>
  114. + #endif
  115.   #endif /* not USG */
  116.   
  117. ***************
  118. *** 231,235 ****
  119. --- 236,244 ----
  120.   VOID *xrealloc ();
  121.   
  122. + #ifndef MSDOS
  123.   char diff_program[] = DIFF_PROGRAM;
  124. + #else
  125. + #define diff_program "diff"
  126. + #endif
  127.   
  128.   /*
  129. ***************
  130. *** 1166,1169 ****
  131. --- 1175,1179 ----
  132.   }
  133.   
  134. + #ifndef MSDOS
  135.   char *
  136.   read_diff (filea, fileb, output_placement)
  137. ***************
  138. *** 1241,1245 ****
  139. --- 1251,1319 ----
  140.     return diff_result + total;
  141.   }
  142. + #else
  143. + char *
  144. + addstr(char *oldstr,char *newstr) {
  145. +     int oldlen;
  146. +     if(oldstr == NULL) {
  147. +         oldstr = xmalloc(strlen(newstr)+1);
  148. +         strcpy(oldstr,newstr);
  149. +     } else {
  150. +         oldlen = strlen(oldstr);
  151. +         oldstr = xrealloc(oldstr,oldlen+strlen(newstr)+2);
  152. +         strcat(oldstr," ");
  153. +         strcat(oldstr,newstr);
  154. +     }
  155. +     return oldstr;
  156. + }
  157. + 
  158. + char *
  159. + read_diff (filea, fileb, output_placement)
  160. +      char *filea, *fileb;
  161. +      char **output_placement;
  162. + {
  163. +   char *diff_result;
  164. +   int current_chunk_size;
  165. +   int bytes;
  166. +   int total;
  167. +   char *buf = NULL;
  168. +   char *tmpname,tmpbuf[16];
  169. +   int diff_output;
  170. +   strcpy(tmpbuf,"XXXXXX");
  171. +   tmpname = mktemp(tmpbuf);
  172. +   buf = addstr(buf,diff_program);
  173. +   if (always_text)
  174. +     buf = addstr(buf,"-a");
  175. +   buf = addstr(buf,"--");
  176. +   buf = addstr(buf,filea);
  177. +   buf = addstr(buf,fileb);
  178. +   buf = addstr(buf,">");
  179. +   buf = addstr(buf,tmpname);
  180. +   system(buf);
  181. +   free(buf);
  182. +   if((diff_output = open(tmpname,O_RDONLY)) == -1)
  183. +     fatal ("Subsidiary diff failed");
  184. + 
  185. +   current_chunk_size = DIFF_CHUNK_SIZE;
  186. +   diff_result = (char *) xmalloc (current_chunk_size);
  187. +   total = 0;
  188. +   do {
  189. +     bytes = myread (diff_output,
  190. +             diff_result + total,
  191. +             current_chunk_size - total);
  192. +     total += bytes;
  193. +     if (total == current_chunk_size)
  194. +       diff_result = (char *) xrealloc (diff_result, (current_chunk_size *= 2));
  195. +   } while (bytes);
  196. + 
  197. +   if (total != 0 && diff_result[total-1] != '\n')
  198. +     fatal ("bad diff format; incomplete last line");
  199. + 
  200. +   *output_placement = diff_result;
  201.   
  202. +   close(diff_output);
  203. +   unlink(tmpname);
  204. +   return diff_result + total;
  205. + }
  206. + #endif
  207.   
  208.   /*
  209. diff +context=2 +new-file diff/dir.h diff.new/dir.h
  210. *** diff/dir.h
  211. --- diff.new/dir.h    Sat Mar  9 09:20:32 1991
  212. ***************
  213. *** 0 ****
  214. --- 1,36 ----
  215. + /*
  216. +  * @(#)msd_dir.h 1.4 87/11/06    Public Domain.
  217. +  *
  218. +  *  A public domain implementation of BSD directory routines for
  219. +  *  MS-DOS.  Written by Michael Rendell ({uunet,utai}michael@garfield),
  220. +  *  August 1897
  221. +  */
  222. + 
  223. + #define    rewinddir(dirp)    seekdir(dirp, 0L)
  224. + 
  225. + #define    MAXNAMLEN    12
  226. + 
  227. + struct direct {
  228. +     int    d_ino;            /* a bit of a farce */
  229. +     int    d_reclen;        /* more farce */
  230. +     int    d_namlen;        /* length of d_name */
  231. +     char    d_name[MAXNAMLEN + 1];        /* guarentee null termination */
  232. + };
  233. + 
  234. + struct _dircontents {
  235. +     char    *_d_entry;
  236. +     struct _dircontents    *_d_next;
  237. + };
  238. + 
  239. + typedef struct _dirdesc {
  240. +     int        dd_id;    /* uniquely identify each open directory */
  241. +     long        dd_loc;    /* where we are in directory entry is this */
  242. +     struct _dircontents    *dd_contents;    /* pointer to contents of dir */
  243. +     struct _dircontents    *dd_cp;    /* pointer to current position */
  244. + } DIR;
  245. + 
  246. + extern    DIR        *opendir(const char *name);
  247. + extern    struct direct    *readdir(DIR *dirp);
  248. + extern    void        seekdir(DIR *dirp,long off);
  249. + extern    long        telldir(DIR *dirp);
  250. + extern    void        closedir(DIR *dirp);
  251. diff +context=2 +new-file diff/getopt.c diff.new/getopt.c
  252. *** diff/getopt.c    Thu Nov 29 08:21:40 1990
  253. --- diff.new/getopt.c    Sat Jan 26 07:08:56 1991
  254. ***************
  255. *** 70,74 ****
  256.   
  257.   char *getenv ();
  258. - char *malloc ();
  259.   #endif
  260.   
  261. --- 70,73 ----
  262. ***************
  263. *** 249,253 ****
  264.   getopt (argc, argv, optstring)
  265.        int argc;
  266. !      char **argv;
  267.        CONST char *optstring;
  268.   {
  269. --- 248,252 ----
  270.   getopt (argc, argv, optstring)
  271.        int argc;
  272. !      CONST char **argv;
  273.        CONST char *optstring;
  274.   {
  275. diff +context=2 +new-file diff/getopt.h diff.new/getopt.h
  276. *** diff/getopt.h    Thu Nov 29 08:21:40 1990
  277. --- diff.new/getopt.h    Sat Jan 26 07:09:06 1991
  278. ***************
  279. *** 89,93 ****
  280.   
  281.   #ifdef __STDC__
  282. ! int getopt (int argc, char **argv, const char *shortopts);
  283.   int getopt_long (int argc, char **argv, const char *shortopts,
  284.            const struct option *longopts, int *longind);
  285. --- 89,93 ----
  286.   
  287.   #ifdef __STDC__
  288. ! int getopt (int argc, const char **argv, const char *shortopts);
  289.   int getopt_long (int argc, char **argv, const char *shortopts,
  290.            const struct option *longopts, int *longind);
  291. diff +context=2 +new-file diff/io.c diff.new/io.c
  292. *** diff/io.c    Thu Nov 29 08:15:42 1990
  293. --- diff.new/io.c    Sun Jan 27 06:13:22 1991
  294. ***************
  295. *** 20,23 ****
  296. --- 20,30 ----
  297.   #include "diff.h"
  298.   
  299. + #if defined(DEBUG)
  300. + #undef DEBUG
  301. + #define DEBUG(x) x
  302. + #else
  303. + #define DEBUG(x)
  304. + #endif
  305. + 
  306.   /* Rotate a value n bits to the left. */
  307.   #define UINT_BIT (sizeof (unsigned) * CHAR_BIT)
  308. ***************
  309. *** 89,92 ****
  310. --- 96,100 ----
  311.   slurp ()
  312.   {
  313. +   DEBUG(fprintf(stderr,"slurp(%s) ",current->name);fflush(stderr);)
  314.     /* If we have a nonexistent file at this stage, treat it as empty.  */
  315.     if (current->desc < 0)
  316. ***************
  317. *** 105,111 ****
  318.       {
  319.         current->bufsize = current->stat.st_size;
  320.         current->buffer = (char *) xmalloc (current->bufsize + 2);
  321.         current->buffered_chars
  322. !     = read (current->desc, current->buffer, current->bufsize);
  323.         if (current->buffered_chars < 0)
  324.       pfatal_with_name (current->name);
  325. --- 113,122 ----
  326.       {
  327.         current->bufsize = current->stat.st_size;
  328. +       DEBUG(fprintf(stderr," Regular file %ld bytes ",
  329. +           current->stat.st_size);)
  330.         current->buffer = (char *) xmalloc (current->bufsize + 2);
  331.         current->buffered_chars
  332. !     = readcr (current->desc, current->buffer, current->bufsize);
  333. !       DEBUG(fprintf(stderr," -- %ld bytes read\n",current->buffered_chars);)
  334.         if (current->buffered_chars < 0)
  335.       pfatal_with_name (current->name);
  336. ***************
  337. *** 114,118 ****
  338.       {
  339.         int cc;
  340. ! 
  341.         current->bufsize = 4096;
  342.         current->buffer = (char *) xmalloc (current->bufsize + 2);
  343. --- 125,129 ----
  344.       {
  345.         int cc;
  346. !       DEBUG(fprintf(stderr,"Not a regular file -- reading in chunks ");)
  347.         current->bufsize = 4096;
  348.         current->buffer = (char *) xmalloc (current->bufsize + 2);
  349. ***************
  350. *** 121,125 ****
  351.         /* Not a regular file; read it in a little at a time, growing the
  352.        buffer as necessary. */
  353. !       while ((cc = read (current->desc,
  354.                current->buffer + current->buffered_chars,
  355.                current->bufsize - current->buffered_chars))
  356. --- 132,136 ----
  357.         /* Not a regular file; read it in a little at a time, growing the
  358.        buffer as necessary. */
  359. !       while ((cc = readcr (current->desc,
  360.                current->buffer + current->buffered_chars,
  361.                current->bufsize - current->buffered_chars))
  362. ***************
  363. *** 134,137 ****
  364. --- 145,149 ----
  365.           }
  366.       }
  367. +     DEBUG(fprintf(stderr,"read %d bytes\n",current->buffered_chars);)
  368.         if (cc < 0)
  369.       pfatal_with_name (current->name);
  370. diff +context=2 +new-file diff/makefile.pc diff.new/makefile.pc
  371. *** diff/makefile.pc
  372. --- diff.new/makefile.pc    Wed Mar 13 03:45:02 1991
  373. ***************
  374. *** 0 ****
  375. --- 1,47 ----
  376. + CC=gcc
  377. + CFLAGS = -DMSDOS -v -O -g
  378. + prefix=
  379. + 
  380. + .SUFFIXES: .od .o .c
  381. + .c.o:
  382. +     $(CC) $(CFLAGS) -c $< -o $*.o
  383. + .c.od:
  384. +     $(CC) $(CFLAGS) -c -g $< -o $*.od
  385. + 
  386. + # All source files
  387. + srcs=diff.c analyze.c io.c context.c ed.c normal.c ifdef.c util.c dir.c \
  388. +     version.c diff.h regex.c regex.h limits.h diff3.c \
  389. +     getopt.c getopt1.c getopt.h alloca.c
  390. + # Object files for diff only.
  391. + O1=diff.od analyze.o io.o context.o \
  392. +      ed.o normal.o util.o dir.o
  393. + 
  394. + O2=regex.o ifdef.o version.o \
  395. +      getopt.o getopt1.o
  396. + 
  397. + MSOBJ = msd_dir.o strlwr.o stat.o
  398. + 
  399. + objs = $(O1) $(O2) $(MSOBJ)
  400. + 
  401. + all: diff diff3
  402. + 
  403. + diff3: diff3.o
  404. +     $(CC) -o diff3  $(CFLAGS) $(LDFLAGS) diff3.o $(LIBS)
  405. + 
  406. + 
  407. + diff : $(objs) _obj
  408. +     $(CC) $(CFLAGS) -o $@ @_obj
  409. + 
  410. + 
  411. + _obj : makefile
  412. +     echo $(O1) > $@
  413. +     echo $(O2) >> $@
  414. +     echo $(MSOBJ) >> $@
  415. + 
  416. + $(objs): diff.h
  417. + 
  418. + context.o diff.o: regex.h
  419. + 
  420. + clean:
  421. +     rm -f *.o diff diff3 diff.tar diff.tar.Z
  422. + 
  423. diff +context=2 +new-file diff/msd_dir.c diff.new/msd_dir.c
  424. *** diff/msd_dir.c
  425. --- diff.new/msd_dir.c    Sat Mar  9 09:17:14 1991
  426. ***************
  427. *** 0 ****
  428. --- 1,167 ----
  429. + /*
  430. +  * @(#)msd_dir.c 1.4 87/11/06    Public Domain.
  431. +  *
  432. +  *  A public domain implementation of BSD directory routines for
  433. +  *  MS-DOS.  Written by Michael Rendell ({uunet,utai}michael@garfield),
  434. +  *  August 1897
  435. +  *
  436. +  * modified for use with GCC for DOS December 1990
  437. +  * williams@umaxc.weeg.uiowa.edu
  438. +  */
  439. + 
  440. + #include    <stdlib.h>
  441. + #include    <sys/types.h>
  442. + #include    <sys/stat.h>
  443. + #include     <sys/file.h>
  444. + #include    <sys/dir.h>
  445. + #include     <fcntl.h>
  446. + #include     <errno.h>
  447. + #include     <time.h>
  448. + #include    <dir.h>
  449. + #include    <string.h>
  450. + 
  451. + #ifndef    NULL
  452. + # define    NULL    0
  453. + #endif    /* NULL */
  454. + 
  455. + #ifndef    MAXPATHLEN
  456. + # define    MAXPATHLEN    255
  457. + #endif    /* MAXPATHLEN */
  458. + 
  459. + /* attribute stuff */
  460. + #define    A_RONLY        0x01
  461. + #define    A_HIDDEN    0x02
  462. + #define    A_SYSTEM    0x04
  463. + #define    A_LABEL        0x08
  464. + #define    A_DIR        0x10
  465. + #define    A_ARCHIVE    0x20
  466. + 
  467. + #define    Newisnull(a, t)        ((a = (t *) malloc(sizeof(t))) == (t *) NULL)
  468. + /* #define    ATTRIBUTES        (A_DIR | A_HIDDEN | A_SYSTEM) */
  469. + #define ATTRIBUTES    (A_RONLY | A_SYSTEM | A_DIR)
  470. + 
  471. + static    char    *getdirent();
  472. + static    void    free_dircontents();
  473. + 
  474. + static    struct ffblk        dtabuf;
  475. + static    struct ffblk        *dtapnt = &dtabuf;
  476. + 
  477. + static int _dos_errno;
  478. + 
  479. + 
  480. + DIR    *
  481. + opendir(const char *name)
  482. + {
  483. +     struct    stat        statb;
  484. +     DIR            *dirp;
  485. +     char            c;
  486. +     char            *s;
  487. +     struct _dircontents    *dp;
  488. +     char            nbuf[MAXPATHLEN + 1];
  489. +     
  490. +     if (stat(name, &statb) < 0 || (statb.st_mode & S_IFMT) != S_IFDIR)
  491. +         return (DIR *) NULL;
  492. +     if (Newisnull(dirp, DIR))
  493. +         return (DIR *) NULL;
  494. +     if (*name && (c = name[strlen(name) - 1]) != '\\' && c != '/')
  495. +         (void) strcat(strcpy(nbuf, name), "\\*.*");
  496. +     else
  497. +         (void) strcat(strcpy(nbuf, name), "*.*");
  498. +     dirp->dd_loc = 0;
  499. + 
  500. +     dirp->dd_contents = dirp->dd_cp = (struct _dircontents *) NULL;
  501. +     if ((s = getdirent(nbuf)) == (char *) NULL)
  502. +         return dirp;
  503. +     do {
  504. +         if (Newisnull(dp, struct _dircontents) || (dp->_d_entry =
  505. +             malloc((unsigned) (strlen(s) + 1))) == (char *) NULL)
  506. +         {
  507. +             if (dp)
  508. +                 free((char *) dp);
  509. +             free_dircontents(dirp->dd_contents);
  510. +             return (DIR *) NULL;
  511. +         }
  512. +         if (dirp->dd_contents)
  513. +             dirp->dd_cp = dirp->dd_cp->_d_next = dp;
  514. +         else
  515. +             dirp->dd_contents = dirp->dd_cp = dp;
  516. +         (void) strcpy(dp->_d_entry, s);
  517. +         dp->_d_next = (struct _dircontents *) NULL;
  518. +     } while ((s = getdirent((char *) NULL)) != (char *) NULL);
  519. +     dirp->dd_cp = dirp->dd_contents;
  520. + 
  521. +     return dirp;
  522. + }
  523. + 
  524. + void
  525. + closedir(DIR *dirp)
  526. + {
  527. +     free_dircontents(dirp->dd_contents);
  528. +     free((char *) dirp);
  529. + }
  530. + 
  531. + struct direct    *
  532. + readdir(DIR *dirp)
  533. + {
  534. +     static    struct direct    dp;
  535. +     
  536. +     if (dirp->dd_cp == (struct _dircontents *) NULL)
  537. +         return (struct direct *) NULL;
  538. +     dp.d_namlen = dp.d_reclen =
  539. +         strlen(strcpy(dp.d_name, dirp->dd_cp->_d_entry));
  540. +     strlwr(dp.d_name);        /* JF */
  541. +     dp.d_ino = 0;
  542. +     dirp->dd_cp = dirp->dd_cp->_d_next;
  543. +     dirp->dd_loc++;
  544. + 
  545. +     return &dp;
  546. + }
  547. + 
  548. + void
  549. + seekdir(DIR *dirp, long off)
  550. + {
  551. +     long            i = off;
  552. +     struct _dircontents    *dp;
  553. + 
  554. +     if (off < 0)
  555. +         return;
  556. +     for (dp = dirp->dd_contents ; --i >= 0 && dp ; dp = dp->_d_next)
  557. +         ;
  558. +     dirp->dd_loc = off - (i + 1);
  559. +     dirp->dd_cp = dp;
  560. + }
  561. + 
  562. + long
  563. + telldir(DIR    *dirp)
  564. + {
  565. +     return dirp->dd_loc;
  566. + }
  567. + 
  568. + static    void
  569. + free_dircontents(struct    _dircontents    *dp)
  570. + {
  571. +     struct _dircontents    *odp;
  572. + 
  573. +     while (dp) {
  574. +         if (dp->_d_entry)
  575. +             free(dp->_d_entry);
  576. +         dp = (odp = dp)->_d_next;
  577. +         free((char *) odp);
  578. +     }
  579. + }
  580. + 
  581. + static    char    *
  582. + getdirent(char *dir)
  583. + {
  584. +     int rval;
  585. +     if (dir != (char *) NULL) {        /* get first entry */
  586. +         rval = findfirst(dir,dtapnt,ATTRIBUTES);
  587. +     } else {                /* get next entry */
  588. +         rval = findnext(dtapnt);
  589. +     }
  590. +     if(rval != 0)
  591. +         return (char *) NULL;
  592. + 
  593. +     return dtabuf.ff_name;
  594. + }
  595. + 
  596. diff +context=2 +new-file diff/stat.c diff.new/stat.c
  597. *** diff/stat.c
  598. --- diff.new/stat.c    Fri Feb  8 06:19:12 1991
  599. ***************
  600. *** 0 ****
  601. --- 1,248 ----
  602. + #include <sys/types.h>
  603. + #include <sys/stat.h>
  604. + #include <sys/file.h>
  605. + #include <sys/dir.h>
  606. + #include <stdlib.h>
  607. + #include <fcntl.h>
  608. + #include <errno.h>
  609. + #include <time.h>
  610. + #include <dir.h>
  611. + 
  612. + #if defined(DEBUG)
  613. + #undef DEBUG
  614. + #define DEBUG(x) x
  615. + #else
  616. + #define DEBUG(x)
  617. + #endif
  618. + 
  619. + /* attribute stuff */
  620. + #define    A_RONLY        0x01
  621. + #define    A_HIDDEN    0x02
  622. + #define    A_SYSTEM    0x04
  623. + #define    A_LABEL        0x08
  624. + #define    A_DIR        0x10
  625. + #define    A_ARCHIVE    0x20
  626. + #define A_ALL        (A_HIDDEN|A_SYSTEM|A_DIR)
  627. + 
  628. + int
  629. + _mjd(int year, int month, int day)
  630. + {
  631. +   unsigned long int today;
  632. + 
  633. +   if ((month == 1) || (month == 2)) {
  634. +     month += 12;
  635. +     year  -= 1;
  636. +   }
  637. + 
  638. +   today    = (unsigned) ((36525 * year) / 100)
  639. +     + (unsigned) (year / 400)
  640. +     - (unsigned) (year / 100)
  641. +     + (unsigned) ((3059 * (month - 2)) / 100)
  642. +     + day
  643. +     - 678912;
  644. + 
  645. +   return today;
  646. + }
  647. + 
  648. + static time_t
  649. + _get_ftime(struct ffblk *f) {
  650. +     union {
  651. +         short time;
  652. +         struct _file_time {
  653. +             unsigned int seconds : 5;
  654. +             unsigned int minutes : 6;
  655. +             unsigned int hours   : 5;
  656. +         } ftime_parts;
  657. +     } ftime;
  658. +     union {
  659. +         short date;
  660. +         struct _file_date {
  661. +             unsigned int day : 5;
  662. +             unsigned int month : 4;
  663. +             unsigned int year : 7;
  664. +         } fdate_parts;
  665. +     } fdate;
  666. +     unsigned long int today;
  667. + 
  668. +     ftime.time = f->ff_ftime;
  669. +     fdate.date = f->ff_fdate;
  670. + 
  671. + #define    year    (fdate.fdate_parts.year + 1980)
  672. + #define    month    (fdate.fdate_parts.month)
  673. + #define    day        (fdate.fdate_parts.day)
  674. + #define    hour    (ftime.ftime_parts.hours)
  675. + #define    minute    (ftime.ftime_parts.minutes)
  676. + #define    second    (ftime.ftime_parts.seconds * 2)
  677. + 
  678. +   today = _mjd(year, month, day) - _mjd(1970, 1, 1);
  679. + 
  680. +   return ((today * 24 + hour) * 60 + minute)  * 60 + second;
  681. + }
  682. + 
  683. + static __inline__ int
  684. + _dos_get_device_information(int handle)
  685. + {
  686. +     int  result;
  687. + 
  688. +     asm volatile("
  689. +     movw %1,%%bx
  690. +     movw %2,%%ax
  691. +     int $0x21
  692. +     jnc 0f
  693. +     movl $-1,%0
  694. +     jmp 1f
  695. + 0:
  696. +     movl %%edx,%0
  697. + 1:"
  698. +     : "=r"(result)
  699. +     : "g"((unsigned short) handle), "i"(0x4400)
  700. +     : "ax", "bx", "dx");
  701. + 
  702. +     return  result;
  703. + }
  704. + 
  705. + static __inline__ int
  706. + _dos_open(char *path, int attributes)
  707. + {
  708. +     int  result;
  709. + 
  710. +     asm volatile("
  711. +     movl %1,%%edx
  712. +     movb %2,%%al
  713. +     movb %3,%%ah
  714. +     int $0x21
  715. +     jnc 0f
  716. +     movl $-1,%0
  717. +     jmp 1f
  718. + 0:
  719. +     movzwl %%ax,%0
  720. + 1:"
  721. +     : "=r"(result)
  722. +     : "g"(path), "g"((unsigned char) attributes), "i"(0x3d)
  723. +     : "ax", "dx");
  724. + 
  725. +     return  result;
  726. + }
  727. + 
  728. + static __inline__ int
  729. + _dos_close(int handle)
  730. + {
  731. +     register int  result;
  732. + 
  733. +     asm volatile("
  734. +     movw %1,%%bx
  735. +     movb %2,%%ah
  736. +     int $0x21
  737. +     jnc 0f
  738. +     movl $-1,%0
  739. +     jmp 1f
  740. + 0:
  741. +     movl $0,%1
  742. + 1:"
  743. +     : "=r"(result)
  744. +     : "g"((unsigned short) handle), "i"(0x3e)
  745. +     : "ax", "bx");
  746. + 
  747. +     return  result;
  748. + }
  749. + 
  750. + int
  751. + stat(const char *name,struct stat *sbuf) {
  752. +     int result;
  753. +     int fd,dos_att;
  754. +     struct ffblk dos_info;
  755. +     DEBUG(fprintf(stderr,"stat(%s)\n",name); fflush(stderr);)
  756. +     /*
  757. +     ** find out file information
  758. +     */
  759. +     result = findfirst(name,&dos_info,A_ALL);
  760. +     DEBUG(fprintf(stderr,"findfirst(%s,%p,%02x) = %d\n",
  761. +         name,&dos_info,A_ALL);)
  762. +     if(result == -1)
  763. +         return -1;
  764. +     DEBUG(fprintf(stderr,"%02x %04x %04x %08ld %s\n",
  765. +         dos_info.ff_attrib,dos_info.ff_ftime,dos_info.ff_fdate,
  766. +         dos_info.ff_fsize,dos_info.ff_name);)
  767. + 
  768. +     /*
  769. +     ** fill in fields that don't mean anything under DOS
  770. +     */
  771. +     sbuf->st_dev = sbuf->st_ino = sbuf->st_uid = 
  772. +         sbuf->st_gid = sbuf->st_rdev = 0;
  773. +     sbuf->st_nlink = 1;
  774. +     
  775. +     /*
  776. +     ** fill in size
  777. +     */
  778. +     sbuf->st_size = *((long *)&dos_info.ff_fsize);
  779. + 
  780. +     /*
  781. +     ** fill in mod time
  782. +     */
  783. +     sbuf->st_atime    =
  784. +     sbuf->st_mtime    =
  785. +     sbuf->st_ctime    = _get_ftime(&dos_info);
  786. + 
  787. +     sbuf->st_mode = 0;
  788. + 
  789. +     if((dos_info.ff_attrib & A_DIR) != 0)
  790. +         sbuf->st_mode |= S_IFDIR;
  791. +     else {
  792. +         /*
  793. +         ** if not a directory, then either a device or a real file.
  794. +         */
  795. +         fd = _dos_open(name,0);
  796. +         if(fd == -1)
  797. +             return -1;
  798. + 
  799. +         dos_att = _dos_get_device_information(fd);
  800. + 
  801. +         _dos_close(fd);
  802. +         if((dos_att & 0x80) == 0)
  803. +             sbuf->st_mode |= S_IFREG;
  804. +         else
  805. +             sbuf->st_mode |= S_IFCHR;
  806. +     }
  807. + 
  808. +     /*
  809. +     ** set access rights
  810. +     */
  811. +     if((dos_info.ff_attrib & A_RONLY) != 0)
  812. +         sbuf->st_mode |= 0444;
  813. +     else
  814. +         sbuf->st_mode |= 0666;
  815. + 
  816. +     return 0;
  817. + }
  818. + 
  819. + #if defined(TEST)
  820. + void
  821. + info(char *name) {
  822. +     struct stat statbuf;
  823. +     if(stat(name,&statbuf) == -1) {
  824. +         perror(name);
  825. +         return;
  826. +     }
  827. +     printf("%s : %ld bytes %s ",name,statbuf.st_size,
  828. +         asctime(localtime(&statbuf.st_mtime)));
  829. +     switch((statbuf.st_mode & S_IFMT)) {
  830. +     case S_IFDIR:
  831. +             printf("S_IFDIR\n"); break;
  832. +     case S_IFCHR:
  833. +             printf("S_IFCHR\n"); break;
  834. +     case S_IFBLK:
  835. +             printf("S_IFBLK\n"); break;
  836. +     case S_IFREG:
  837. +             printf("S_IFREG\n"); break;
  838. +     }
  839. +     
  840. + }
  841. + 
  842. + 
  843. + int
  844. + main(int argc,char **argv) {
  845. +     while(--argc)
  846. +         info(*++argv);
  847. +     return 0;
  848. + }
  849. + #endif
  850. diff +context=2 +new-file diff/strlwr.c diff.new/strlwr.c
  851. *** diff/strlwr.c
  852. --- diff.new/strlwr.c    Sat Jan 26 07:09:04 1991
  853. ***************
  854. *** 0 ****
  855. --- 1,17 ----
  856. + /*   Library program for GCC on DOS-Extender        
  857. + 
  858. +     (c) Copyright by Keisuke Yoshida, 1989, 1990  ver 1.00
  859. + 
  860. + */ 
  861. + 
  862. + #include <ctype.h>
  863. + #include <string.h>
  864. + 
  865. + char *
  866. + strlwr(char *d)
  867. + {
  868. +     char *s;
  869. +     for (s=d; *s; s++)
  870. +         *s = tolower(*s);
  871. +    return d;
  872. + }
  873. diff +context=2 +new-file diff/util.c diff.new/util.c
  874. *** diff/util.c    Sun Jan  6 10:14:14 1991
  875. --- diff.new/util.c    Sat Jan 26 07:09:04 1991
  876. ***************
  877. *** 129,133 ****
  878.     strcat (name, " ");
  879.     strcat (name, name1);
  880. ! 
  881.     if (paginate_flag)
  882.       {
  883. --- 129,133 ----
  884.     strcat (name, " ");
  885.     strcat (name, name1);
  886. ! #if !defined(MSDOS)
  887.     if (paginate_flag)
  888.       {
  889. ***************
  890. *** 165,168 ****
  891. --- 165,169 ----
  892.       }
  893.     else
  894. + #endif /* MSDOS */      
  895.       {
  896.   
  897. ***************
  898. *** 189,193 ****
  899. --- 190,196 ----
  900.       {
  901.         fclose (outfile);
  902. + #if    !defined(MSDOS)
  903.         wait (0);
  904. + #endif /* MSDOS */
  905.       }
  906.   }
  907. ***************
  908. *** 205,209 ****
  909.     register char end_char = line_end_char;
  910.     int savechar;
  911. - 
  912.     /* Check first for exact identity.
  913.        If that is true, return 0 immediately.
  914. --- 208,211 ----
  915.