home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 22 gnu / 22-gnu.zip / patch212.zip / patches.os2 < prev    next >
Text File  |  1991-02-18  |  41KB  |  1,616 lines
  1. Only in patch2u: config.h
  2. Only in patch2u: isvalid.c
  3. Only in patch2u: patch.cs
  4. Only in patch2u: patch.def
  5. Only in patch2u: patches.os2
  6. diff -cbBw orig/common.h patch2u/common.h
  7. *** orig/common.h    Mon Feb 18 18:55:30 1991
  8. --- patch2u/common.h    Mon Feb 18 19:46:34 1991
  9. ***************
  10. *** 38,43 ****
  11. --- 38,45 ----
  12.   #include <sys/stat.h>
  13.   #include <ctype.h>
  14.   #include <signal.h>
  15. + #include <io.h>
  16. + #include <fcntl.h>
  17.   
  18.   /* constants */
  19.   
  20. ***************
  21. *** 110,119 ****
  22.   EXT char *origext INIT(Nullch);
  23.   EXT char *origprae INIT(Nullch);
  24.   
  25. ! EXT char TMPOUTNAME[] INIT("/tmp/patchoXXXXXX");
  26. ! EXT char TMPINNAME[] INIT("/tmp/patchiXXXXXX");    /* might want /usr/tmp here */
  27. ! EXT char TMPREJNAME[] INIT("/tmp/patchrXXXXXX");
  28. ! EXT char TMPPATNAME[] INIT("/tmp/patchpXXXXXX");
  29.   EXT bool toutkeep INIT(FALSE);
  30.   EXT bool trejkeep INIT(FALSE);
  31.   
  32. --- 112,122 ----
  33.   EXT char *origext INIT(Nullch);
  34.   EXT char *origprae INIT(Nullch);
  35.   
  36. ! EXT char *TMPOUTNAME;
  37. ! EXT char *TMPINNAME;
  38. ! EXT char *TMPREJNAME;
  39. ! EXT char *TMPPATNAME;
  40. ! 
  41.   EXT bool toutkeep INIT(FALSE);
  42.   EXT bool trejkeep INIT(FALSE);
  43.   
  44. ***************
  45. *** 134,139 ****
  46. --- 137,143 ----
  47.   #define NORMAL_DIFF 2
  48.   #define ED_DIFF 3
  49.   #define NEW_CONTEXT_DIFF 4
  50. + #define UNI_DIFF 5
  51.   EXT int diff_type INIT(0);
  52.   
  53.   EXT bool do_defines INIT(FALSE);    /* patch using ifdef, ifndef, etc. */
  54. ***************
  55. *** 144,158 ****
  56.   
  57.   EXT char *revision INIT(Nullch);    /* prerequisite revision, if any */
  58.   
  59. ! char *malloc();
  60. ! char *realloc();
  61.   char *strcpy();
  62.   char *strcat();
  63.   long atol();
  64.   long lseek();
  65.   char *mktemp();
  66.   #ifdef CHARSPRINTF
  67.   char *sprintf();
  68.   #else
  69.   int sprintf();
  70.   #endif
  71. --- 148,168 ----
  72.   
  73.   EXT char *revision INIT(Nullch);    /* prerequisite revision, if any */
  74.   
  75. ! void *malloc();
  76. ! void *realloc();
  77.   char *strcpy();
  78.   char *strcat();
  79.   long atol();
  80.   long lseek();
  81.   char *mktemp();
  82. + 
  83. + #ifdef MSDOS
  84. + #undef stderr
  85. + FILE *stderr;
  86. + #endif
  87.   #ifdef CHARSPRINTF
  88.   char *sprintf();
  89.   #else
  90.   int sprintf();
  91.   #endif
  92. + char *getenv();
  93. diff -cbBw orig/inp.c patch2u/inp.c
  94. *** orig/inp.c    Mon Feb 18 18:55:34 1991
  95. --- patch2u/inp.c    Mon Feb 18 19:00:46 1991
  96. ***************
  97. *** 79,84 ****
  98. --- 79,87 ----
  99.       int ifd;
  100.       Reg1 char *s;
  101.       Reg2 LINENUM iline;
  102. + #ifdef MSDOS
  103. +     int i_res;
  104. + #endif
  105.   
  106.       if (ok_to_create_file && stat(filename, &filestat) < 0) {
  107.       if (verbose)
  108. ***************
  109. *** 115,120 ****
  110. --- 118,127 ----
  111.       if ((filemode & S_IFMT) & ~S_IFREG)
  112.       fatal2("%s is not a normal file--can't patch.\n", filename);
  113.       i_size = filestat.st_size;
  114. + #ifdef MSDOS
  115. +     if ( i_size > 65500L )
  116. +       return FALSE;
  117. + #endif
  118.       if (out_of_mem) {
  119.       set_hunkmax();        /* make sure dynamic arrays are allocated */
  120.       out_of_mem = FALSE;
  121. ***************
  122. *** 128,136 ****
  123.   #endif
  124.       if (i_womp == Nullch)
  125.       return FALSE;
  126. !     if ((ifd = open(filename, 0)) < 0)
  127.       fatal2("Can't open file %s\n", filename);
  128.   #ifndef lint
  129.       if (read(ifd, i_womp, (int)i_size) != i_size) {
  130.       Close(ifd);    /* probably means i_size > 15 or 16 bits worth */
  131.       free(i_womp);    /* at this point it doesn't matter if i_womp was */
  132. --- 135,154 ----
  133.   #endif
  134.       if (i_womp == Nullch)
  135.       return FALSE;
  136. !     if ((ifd = open(filename, O_BINARY)) < 0)
  137.       fatal2("Can't open file %s\n", filename);
  138.   #ifndef lint
  139. + #ifdef DUMMY_MSDOS
  140. +     /* this hack is now obsolete in binary mode */
  141. +     if ((i_res = read(ifd, i_womp, (int)i_size)) == -1) {
  142. +     Close(ifd);    /* probably means i_size > 15 or 16 bits worth */
  143. +     free(i_womp);    /* at this point it doesn't matter if i_womp was */
  144. +     return FALSE;    /*   undersized. */
  145. +     }
  146. +     else
  147. +       /* cr/lf-translations would bomb here (i_res is != file size)! */
  148. +       i_size = i_res;
  149. + #else
  150.       if (read(ifd, i_womp, (int)i_size) != i_size) {
  151.       Close(ifd);    /* probably means i_size > 15 or 16 bits worth */
  152.       free(i_womp);    /* at this point it doesn't matter if i_womp was */
  153. ***************
  154. *** 137,142 ****
  155. --- 155,161 ----
  156.       return FALSE;    /*   undersized. */
  157.       }
  158.   #endif
  159. + #endif
  160.       Close(ifd);
  161.       if (i_size && i_womp[i_size-1] != '\n')
  162.       i_womp[i_size++] = '\n';
  163. ***************
  164. *** 206,214 ****
  165.       Reg4 bool found_revision = (revision == Nullch);
  166.   
  167.       using_plan_a = FALSE;
  168. !     if ((ifp = fopen(filename, "r")) == Nullfp)
  169.       fatal2("Can't open file %s\n", filename);
  170. !     if ((tifd = creat(TMPINNAME, 0666)) < 0)
  171.       fatal2("Can't open file %s\n", TMPINNAME);
  172.       while (fgets(buf, sizeof buf, ifp) != Nullch) {
  173.       if (revision != Nullch && !found_revision && rev_in_string(buf))
  174. --- 225,234 ----
  175.       Reg4 bool found_revision = (revision == Nullch);
  176.   
  177.       using_plan_a = FALSE;
  178. !     if ((ifp = fopen(filename, "rb")) == Nullfp)
  179.       fatal2("Can't open file %s\n", filename);
  180. !     if ((tifd = open(TMPINNAME, O_WRONLY|O_CREAT|O_TRUNC|O_BINARY,
  181. !                      S_IWRITE|S_IREAD)) < 0)
  182.       fatal2("Can't open file %s\n", TMPINNAME);
  183.       while (fgets(buf, sizeof buf, ifp) != Nullch) {
  184.       if (revision != Nullch && !found_revision && rev_in_string(buf))
  185. ***************
  186. *** 236,242 ****
  187.           say2("Good.  This file appears to be the %s version.\n",
  188.           revision);
  189.       }
  190. !     Fseek(ifp, 0L, 0);        /* rewind file */
  191.       lines_per_buf = BUFFERSIZE / maxlen;
  192.       tireclen = maxlen;
  193.       tibuf[0] = malloc((MEM)(BUFFERSIZE + 1));
  194. --- 256,262 ----
  195.           say2("Good.  This file appears to be the %s version.\n",
  196.           revision);
  197.       }
  198. !     rewind(ifp);          /* rewind file */
  199.       lines_per_buf = BUFFERSIZE / maxlen;
  200.       tireclen = maxlen;
  201.       tibuf[0] = malloc((MEM)(BUFFERSIZE + 1));
  202. ***************
  203. *** 258,264 ****
  204.       }
  205.       Fclose(ifp);
  206.       Close(tifd);
  207. !     if ((tifd = open(TMPINNAME, 0)) < 0) {
  208.       fatal2("Can't reopen file %s\n", TMPINNAME);
  209.       }
  210.   }
  211. --- 278,285 ----
  212.       }
  213.       Fclose(ifp);
  214.       Close(tifd);
  215. ! 
  216. !     if ((tifd = open(TMPINNAME, O_RDONLY|O_BINARY)) < 0) {
  217.       fatal2("Can't reopen file %s\n", TMPINNAME);
  218.       }
  219.   }
  220. ***************
  221. *** 306,312 ****
  222.       if (revision == Nullch)
  223.       return TRUE;
  224.       patlen = strlen(revision);
  225. !     if (strnEQ(string,revision,patlen) && isspace(s[patlen]))
  226.       return TRUE;
  227.       for (s = string; *s; s++) {
  228.       if (isspace(*s) && strnEQ(s+1, revision, patlen) &&
  229. --- 327,333 ----
  230.       if (revision == Nullch)
  231.       return TRUE;
  232.       patlen = strlen(revision);
  233. !     if (strnEQ(string,revision,patlen) && isspace(string[patlen]))
  234.       return TRUE;
  235.       for (s = string; *s; s++) {
  236.       if (isspace(*s) && strnEQ(s+1, revision, patlen) &&
  237. diff -cbBw orig/patch.c patch2u/patch.c
  238. *** orig/patch.c    Mon Feb 18 18:55:38 1991
  239. --- patch2u/patch.c    Mon Feb 18 19:15:32 1991
  240. ***************
  241. *** 1,5 ****
  242.   char rcsid[] =
  243. !     "$Header: patch.c,v 2.0.1.6 88/06/22 20:46:39 lwall Locked $";
  244.   
  245.   /* patch - a program to apply diffs to original files
  246.    *
  247. --- 1,5 ----
  248.   char rcsid[] =
  249. !     "$Header: patch.c,v 2.0.2.0 90/05/01 22:17:50 davison Locked $";
  250.   
  251.   /* patch - a program to apply diffs to original files
  252.    *
  253. ***************
  254. *** 9,14 ****
  255. --- 9,17 ----
  256.    * money off of it, or pretend that you wrote it.
  257.    *
  258.    * $Log:    patch.c,v $
  259. +  * Revision 2.0.2.0  90/05/01  22:17:50  davison
  260. +  * patch12u: unidiff support added
  261. +  *
  262.    * Revision 2.0.1.6  88/06/22  20:46:39  lwall
  263.    * patch12: rindex() wasn't declared
  264.    *
  265. ***************
  266. *** 94,99 ****
  267. --- 97,103 ----
  268.   #include "util.h"
  269.   #include "pch.h"
  270.   #include "inp.h"
  271. + #include "patchlev.h"
  272.   
  273.   /* procedures */
  274.   
  275. ***************
  276. *** 111,116 ****
  277. --- 115,128 ----
  278.   bool similar();
  279.   void re_input();
  280.   void my_exit();
  281. + char *strchr();
  282. + char *strrchr();
  283. + 
  284. + /* Nonzero if -R was specified on command line.  */
  285. + static int reverse_flag_specified = FALSE;
  286. + 
  287. + /* Program name */
  288. + static char *myname;
  289.   
  290.   /* Apply a set of diffs as appropriate. */
  291.   
  292. ***************
  293. *** 126,143 ****
  294. --- 138,194 ----
  295.       int failed = 0;
  296.       int failtotal = 0;
  297.       int i;
  298. +     char *s;
  299.   
  300. + #ifdef MSDOS
  301. +     stderr = fopen("con", "w");
  302. + #endif
  303.       setbuf(stderr, serrbuf);
  304. + 
  305.       for (i = 0; i<MAXFILEC; i++)
  306.       filearg[i] = Nullch;
  307. + 
  308. +     /* Cons up the names of the temporary files.  */
  309. +     {
  310. +       /* Directory for temporary files.  */
  311. +       char *tmpdir;
  312. +       int tmpname_len;
  313. + 
  314. + #ifdef MSDOS
  315. +       tmpdir = getenv ("TMP");
  316. + #else
  317. +       tmpdir = getenv ("TMPDIR");
  318. + #endif
  319. +       if (tmpdir == NULL) {
  320. +     tmpdir = "/tmp";
  321. +       }
  322. +       tmpname_len = strlen (tmpdir) + 20;
  323. + 
  324. +       TMPOUTNAME = (char *) malloc (tmpname_len);
  325. +       strcpy (TMPOUTNAME, tmpdir);
  326. +       strcat (TMPOUTNAME, "/poXXXXXX");
  327.         Mktemp(TMPOUTNAME);
  328. + 
  329. +       TMPINNAME = (char *) malloc (tmpname_len);
  330. +       strcpy (TMPINNAME, tmpdir);
  331. +       strcat (TMPINNAME, "/piXXXXXX");
  332.         Mktemp(TMPINNAME);
  333. + 
  334. +       TMPREJNAME = (char *) malloc (tmpname_len);
  335. +       strcpy (TMPREJNAME, tmpdir);
  336. +       strcat (TMPREJNAME, "/prXXXXXX");
  337.         Mktemp(TMPREJNAME);
  338. + 
  339. +       TMPPATNAME = (char *) malloc (tmpname_len);
  340. +       strcpy (TMPPATNAME, tmpdir);
  341. +       strcat (TMPPATNAME, "/ppXXXXXX");
  342.         Mktemp(TMPPATNAME);
  343. +     }
  344.   
  345.       /* parse switches */
  346.       Argc = argc;
  347.       Argv = argv;
  348. +     myname = argv[0];
  349.       get_some_switches();
  350.    
  351.       /* make sure we clean up /tmp in case of disaster */
  352. ***************
  353. *** 302,308 ****
  354. --- 353,373 ----
  355.               s[13] = '\0';
  356.                   }
  357.   #endif
  358. + #ifdef MSDOS
  359. +                 s = strchr(rejname, 0);
  360. + #endif
  361.           Strcat(rejname, REJEXT);
  362. + #ifdef MSDOS
  363. +                 if ( !IsFileNameValid(rejname) )
  364. +                 {
  365. +                   *s=0;
  366. + 
  367. +                   if ((s=strrchr(rejname,'.'))!=NULL)
  368. +                     *s=0;
  369. + 
  370. +                   strcat(rejname, ".rej");
  371. +                 }
  372. + #endif
  373.           }
  374.           if (skip_rest_of_patch) {
  375.           say4("%d out of %d hunks ignored--saving rejects to %s\n",
  376. ***************
  377. *** 351,357 ****
  378.       revision = Nullch;
  379.       }
  380.   
  381. !     reverse = FALSE;
  382.       skip_rest_of_patch = FALSE;
  383.   
  384.       get_some_switches();
  385. --- 416,422 ----
  386.       revision = Nullch;
  387.       }
  388.   
  389. !     reverse = reverse_flag_specified;
  390.       skip_rest_of_patch = FALSE;
  391.   
  392.       get_some_switches();
  393. ***************
  394. *** 360,365 ****
  395. --- 425,438 ----
  396.       fatal1("You may not change to a different patch file.\n");
  397.   }
  398.   
  399. + static char *
  400. + nextarg()
  401. + {
  402. +     if (!--Argc)
  403. +     fatal2("patch: missing argument after `%s'\n", *Argv);
  404. +     return *++Argv;
  405. + }
  406. + 
  407.   /* Process switches and filenames up to next '+' or end of list. */
  408.   
  409.   void
  410. ***************
  411. *** 379,415 ****
  412.       }
  413.       if (*s != '-' || !s[1]) {
  414.           if (filec == MAXFILEC)
  415. !         fatal1("Too many file arguments.\n");
  416.           filearg[filec++] = savestr(s);
  417.       }
  418.       else {
  419.           switch (*++s) {
  420.           case 'b':
  421. !         origext = savestr(Argv[1]);
  422. !         Argc--,Argv++;
  423.           break;
  424.           case 'B':
  425. !         origprae = savestr(Argv[1]);
  426. !         Argc--,Argv++;
  427.           break;
  428.           case 'c':
  429.           diff_type = CONTEXT_DIFF;
  430.           break;
  431.           case 'd':
  432. !         if (!*++s) {
  433. !             Argc--,Argv++;
  434. !             s = Argv[0];
  435. !         }
  436.           if (chdir(s) < 0)
  437.               fatal2("Can't cd to %s.\n", s);
  438.           break;
  439.           case 'D':
  440.               do_defines = TRUE;
  441. !         if (!*++s) {
  442. !             Argc--,Argv++;
  443. !             s = Argv[0];
  444. !         }
  445. !         if (!isalpha(*s))
  446.               fatal1("Argument to -D not an identifier.\n");
  447.           Sprintf(if_defined, "#ifdef %s\n", s);
  448.           Sprintf(not_defined, "#ifndef %s\n", s);
  449. --- 452,482 ----
  450.       }
  451.       if (*s != '-' || !s[1]) {
  452.           if (filec == MAXFILEC)
  453. !          fatal1("patch: Too many file arguments.\n");
  454.           filearg[filec++] = savestr(s);
  455.       }
  456.       else {
  457.           switch (*++s) {
  458.           case 'b':
  459. !         origext = savestr(nextarg());
  460.           break;
  461.           case 'B':
  462. !         origprae = savestr(nextarg());
  463.           break;
  464.           case 'c':
  465.           diff_type = CONTEXT_DIFF;
  466.           break;
  467.           case 'd':
  468. !         if (!*++s)
  469. !             s = nextarg();
  470.           if (chdir(s) < 0)
  471.               fatal2("Can't cd to %s.\n", s);
  472.           break;
  473.           case 'D':
  474.               do_defines = TRUE;
  475. !         if (!*++s)
  476. !             s = nextarg();
  477. !         if (!isalpha(*s) && '_' != *s)
  478.               fatal1("Argument to -D not an identifier.\n");
  479.           Sprintf(if_defined, "#ifdef %s\n", s);
  480.           Sprintf(not_defined, "#ifndef %s\n", s);
  481. ***************
  482. *** 436,443 ****
  483.           noreverse = TRUE;
  484.           break;
  485.           case 'o':
  486. !         outname = savestr(Argv[1]);
  487. !         Argc--,Argv++;
  488.           break;
  489.           case 'p':
  490.           if (*++s == '=')
  491. --- 503,509 ----
  492.           noreverse = TRUE;
  493.           break;
  494.           case 'o':
  495. !         outname = savestr(nextarg());
  496.           break;
  497.           case 'p':
  498.           if (*++s == '=')
  499. ***************
  500. *** 445,455 ****
  501.           strippath = atoi(s);
  502.           break;
  503.           case 'r':
  504. !         Strcpy(rejname, Argv[1]);
  505. !         Argc--,Argv++;
  506.           break;
  507.           case 'R':
  508.           reverse = TRUE;
  509.           break;
  510.           case 's':
  511.           verbose = FALSE;
  512. --- 511,521 ----
  513.           strippath = atoi(s);
  514.           break;
  515.           case 'r':
  516. !         Strcpy(rejname, nextarg());
  517.           break;
  518.           case 'R':
  519.           reverse = TRUE;
  520. +         reverse_flag_specified = TRUE;
  521.           break;
  522.           case 's':
  523.           verbose = FALSE;
  524. ***************
  525. *** 457,465 ****
  526. --- 523,538 ----
  527.           case 'S':
  528.           skip_rest_of_patch = TRUE;
  529.           break;
  530. +         case 'u':
  531. +         diff_type = UNI_DIFF;
  532. +         break;
  533.           case 'v':
  534.           version();
  535.           break;
  536. +             case 'h':
  537. +                 Usage();
  538. +                 exit(0);
  539. +         break;
  540.   #ifdef DEBUGGING
  541.           case 'x':
  542.           debug = atoi(s+1);
  543. ***************
  544. *** 468,473 ****
  545. --- 541,547 ----
  546.           default:
  547.                   /*fatal2("Unrecognized switch: %s\n", Argv[0]);*/
  548.                   printf("\nUnrecognized switch: %s.\n", Argv[0]);
  549. +                 Usage();
  550.                   exit(1);
  551.                   break;
  552.           }
  553. ***************
  554. *** 475,480 ****
  555. --- 549,582 ----
  556.       }
  557.   }
  558.   
  559. + 
  560. + Usage()
  561. + {
  562. +   printf("\npatch 2.0, patchlevel %d\n", PATCHLEVEL);
  563. + 
  564. +   printf("\nUsage: %s [options] orig patchfile [+ [options] orig]\n\n", myname);
  565. +   printf("  -b   next argument is the extension to be used in place of '.orig'\n");
  566. +   printf("  -c   forces patch to interpret the patch file as a context diff\n");
  567. +   printf("  -d   next argument is a directory, cd to it before doing anything else\n");
  568. +   printf("  -D   next argument is the symbol for '#ifdef...#endif' to mark changes\n");
  569. +   printf("  -e   forces patch to interpret the patch file as an ed script\n");
  570. +   printf("  -f   do not ask any questions\n");
  571. +   printf("  -l   more loosely whitespace matching\n");
  572. +   printf("  -n   forces patch to interpret the patch file as a normal diff\n");
  573. +   printf("  -N   ignore patches that are reversed or already applied, see -R\n");
  574. +   printf("  -o   next argument is the output file name\n");
  575. +   printf("  -r   next argument is the reject file name\n");
  576. +   printf("  -R   patch was created with the old and new files swapped\n");
  577. +   printf("  -s   makes patch do its work silently, unless an error occurs\n");
  578. +   printf("  -S   ignore this patch from the patch file\n");
  579. +   printf("  -u   forces patch to interpret the patch file as a unified context diff\n");
  580. +   printf("  -v   print out revision header and patch level\n\n");
  581. +   printf("  -F<number>    maximum fuzz factor for context diffs (default 2)\n");
  582. +   printf("  -p<number>    sets the pathname strip count\n");
  583. +   printf("  -x<number>    set internal debugging flags\n");
  584. + }
  585. + 
  586. + 
  587.   /* Attempt to find the right place to apply this hunk of patch. */
  588.   
  589.   LINENUM
  590. ***************
  591. *** 532,539 ****
  592.       LINENUM newfirst = pch_newfirst() + last_offset;
  593.       LINENUM oldlast = oldfirst + pch_ptrn_lines() - 1;
  594.       LINENUM newlast = newfirst + pch_repl_lines() - 1;
  595. !     char *stars = (diff_type == NEW_CONTEXT_DIFF ? " ****" : "");
  596. !     char *minuses = (diff_type == NEW_CONTEXT_DIFF ? " ----" : " -----");
  597.   
  598.       fprintf(rejfp, "***************\n");
  599.       for (i=0; i<=pat_end; i++) {
  600. --- 634,641 ----
  601.       LINENUM newfirst = pch_newfirst() + last_offset;
  602.       LINENUM oldlast = oldfirst + pch_ptrn_lines() - 1;
  603.       LINENUM newlast = newfirst + pch_repl_lines() - 1;
  604. !     char *stars = (diff_type >= NEW_CONTEXT_DIFF ? " ****" : "");
  605. !     char *minuses = (diff_type >= NEW_CONTEXT_DIFF ? " ----" : " -----");
  606.   
  607.       fprintf(rejfp, "***************\n");
  608.       for (i=0; i<=pat_end; i++) {
  609. ***************
  610. *** 569,574 ****
  611. --- 671,699 ----
  612.   
  613.   /* We found where to apply it (we hope), so do it. */
  614.   
  615. + #ifdef MSDOS
  616. + static int fputs(const char *buffer, FILE *file)
  617. + {
  618. +   const char *ptr;
  619. + 
  620. +   for ( ptr = buffer; *ptr; ptr++ )
  621. +     if ( *ptr == '\r' )
  622. +     {
  623. +       putc(*ptr, file);
  624. + 
  625. +       if ( *(ptr + 1) == '\n' )
  626. +         putc(*++ptr, file);
  627. +     }
  628. +     else if ( *ptr == '\n' )
  629. +     {
  630. +       putc('\r', file);
  631. +       putc(*ptr, file);
  632. +     }
  633. +     else
  634. +       putc(*ptr, file);
  635. + }
  636. + #endif
  637. + 
  638.   void
  639.   apply_hunk(where)
  640.   LINENUM where;
  641. ***************
  642. *** 605,612 ****
  643.           last_frozen_line++;
  644.           old++;
  645.       }
  646. !     else if (new > pat_end)
  647.           break;
  648.       else if (pch_char(new) == '+') {
  649.           copy_till(where + old - 1);
  650.           if (R_do_defines) {
  651. --- 730,738 ----
  652.           last_frozen_line++;
  653.           old++;
  654.       }
  655. !     else if (new > pat_end) {
  656.           break;
  657. +     }
  658.       else if (pch_char(new) == '+') {
  659.           copy_till(where + old - 1);
  660.           if (R_do_defines) {
  661. ***************
  662. *** 622,629 ****
  663.           fputs(pfetch(new), ofp);
  664.           new++;
  665.       }
  666. !     else {
  667. !         if (pch_char(new) != pch_char(old)) {
  668.           say3("Out-of-sync patch, lines %ld,%ld--mangled text or line numbers, maybe?\n",
  669.           pch_hunk_beg() + old,
  670.           pch_hunk_beg() + new);
  671. --- 748,754 ----
  672.           fputs(pfetch(new), ofp);
  673.           new++;
  674.       }
  675. !     else if (pch_char(new) != pch_char(old)) {
  676.           say3("Out-of-sync patch, lines %ld,%ld--mangled text or line numbers, maybe?\n",
  677.           pch_hunk_beg() + old,
  678.           pch_hunk_beg() + new);
  679. ***************
  680. *** 633,639 ****
  681.   #endif
  682.           my_exit(1);
  683.       }
  684. !         if (pch_char(new) == '!') {
  685.           copy_till(where + old - 1);
  686.           if (R_do_defines) {
  687.              fputs(not_defined, ofp);
  688. --- 758,764 ----
  689.   #endif
  690.           my_exit(1);
  691.       }
  692. !     else if (pch_char(new) == '!') {
  693.           copy_till(where + old - 1);
  694.           if (R_do_defines) {
  695.              fputs(not_defined, ofp);
  696. ***************
  697. *** 654,668 ****
  698.           fputs(pfetch(new), ofp);
  699.           new++;
  700.           }
  701. -         if (R_do_defines) {
  702. -             fputs(end_defined, ofp);
  703. -             def_state = OUTSIDE;
  704. -     }
  705.       }
  706.       else {
  707.           assert(pch_char(new) == ' ');
  708.           old++;
  709.           new++;
  710.           }
  711.       }
  712.       }
  713. --- 779,792 ----
  714.           fputs(pfetch(new), ofp);
  715.           new++;
  716.           }
  717.       }
  718.       else {
  719.           assert(pch_char(new) == ' ');
  720.           old++;
  721.           new++;
  722. +         if (R_do_defines && def_state != OUTSIDE) {
  723. +         fputs(end_defined, ofp);
  724. +         def_state = OUTSIDE;
  725.           }
  726.       }
  727.       }
  728. ***************
  729. *** 694,700 ****
  730.   init_output(name)
  731.   char *name;
  732.   {
  733. !     ofp = fopen(name, "w");
  734.       if (ofp == Nullfp)
  735.       fatal2("patch: can't create %s.\n", name);
  736.   }
  737. --- 818,824 ----
  738.   init_output(name)
  739.   char *name;
  740.   {
  741. !     ofp = fopen(name, "wb");
  742.       if (ofp == Nullfp)
  743.       fatal2("patch: can't create %s.\n", name);
  744.   }
  745. ***************
  746. *** 773,782 ****
  747. --- 897,925 ----
  748.                pch_line_len(pline) ))
  749.           return FALSE;
  750.       }
  751. + #ifdef MSDOS
  752. +     else
  753. +         {
  754. +           char *s1, *s2;
  755. +           int len;
  756. + 
  757. +           s1 = ifetch(iline, (offset >= 0));
  758. +           s2 = pfetch(pline);
  759. +           len = pch_line_len(pline);
  760. + 
  761. +           /* special CR/LF case */
  762. +           if ( s1[len - 1] == '\r' && s1[len] == '\n' && s2[len - 1] == '\n' )
  763. +             len--;
  764. + 
  765. +           if (strnNE(s1, s2, len))
  766. +         return FALSE;
  767. +         }
  768. + #else
  769.       else if (strnNE(ifetch(iline, (offset >= 0)),
  770.              pfetch(pline),
  771.              pch_line_len(pline) ))
  772.           return FALSE;
  773. + #endif
  774.       }
  775.       return TRUE;
  776.   }
  777. ***************
  778. *** 822,827 ****
  779. --- 965,976 ----
  780.       if (!trejkeep) {
  781.       Unlink(TMPREJNAME);
  782.       }
  783. + 
  784. +     if ( pfp != NULL )
  785. +     {
  786. +       Fclose(pfp);
  787.         Unlink(TMPPATNAME);
  788. +     }
  789. + 
  790.       exit(status);
  791.   }
  792. diff -cbBw orig/pch.c patch2u/pch.c
  793. *** orig/pch.c    Mon Feb 18 18:55:42 1991
  794. --- patch2u/pch.c    Mon Feb 18 19:46:32 1991
  795. ***************
  796. *** 1,6 ****
  797. --- 1,9 ----
  798.   /* $Header: pch.c,v 2.0.1.7 88/06/03 15:13:28 lwall Locked $
  799.    *
  800.    * $Log:    pch.c,v $
  801. +  * Revision 2.0.2.0  90/05/01  22:17:51  davison
  802. +  * patch12u: unidiff support added
  803. +  *
  804.    * Revision 2.0.1.7  88/06/03  15:13:28  lwall
  805.    * patch10: Can now find patches in shar scripts.
  806.    * patch10: Hunks that swapped and then swapped back could core dump.
  807. ***************
  808. *** 34,39 ****
  809. --- 37,43 ----
  810.   #include "util.h"
  811.   #include "INTERN.h"
  812.   #include "pch.h"
  813. + #include "version.h"
  814.   
  815.   /* Patch (diff listing) abstract type. */
  816.   
  817. ***************
  818. *** 81,86 ****
  819. --- 85,96 ----
  820.   {
  821.       if (filename == Nullch || !*filename || strEQ(filename, "-"))
  822.       {
  823. +         if ( isatty(fileno(stdin)) )
  824. +         {
  825. +           Usage();
  826. +           exit(1);
  827. +         }
  828. + 
  829.       pfp = fopen(TMPPATNAME, "w");
  830.       if (pfp == Nullfp)
  831.           fatal2("patch: can't create %s.\n", TMPPATNAME);
  832. ***************
  833. *** 163,168 ****
  834. --- 173,179 ----
  835.       if (verbose)
  836.       say3("  %sooks like %s to me...\n",
  837.           (p_base == 0L ? "L" : "The next patch l"),
  838. +         diff_type == UNI_DIFF ? "a unidiff" :
  839.           diff_type == CONTEXT_DIFF ? "a context diff" :
  840.           diff_type == NEW_CONTEXT_DIFF ? "a new-style context diff" :
  841.           diff_type == NORMAL_DIFF ? "a normal diff" :
  842. ***************
  843. *** 266,271 ****
  844. --- 277,284 ----
  845.           oldtmp = savestr(s+4);
  846.       else if (strnEQ(s, "--- ", 4))
  847.           newtmp = savestr(s+4);
  848. +     else if (strnEQ(s, "+++ ", 4))
  849. +         oldtmp = savestr(s+4);    /* pretend it is the old name */
  850.       else if (strnEQ(s, "Index:", 6))
  851.           indtmp = savestr(s+6);
  852.       else if (strnEQ(s, "Prereq:", 7)) {
  853. ***************
  854. *** 287,292 ****
  855. --- 300,314 ----
  856.           retval = ED_DIFF;
  857.           goto scan_exit;
  858.       }
  859. +     if ((!diff_type || diff_type == UNI_DIFF) && strnEQ(s, "@@ -", 4)) {
  860. +         if (!atol(s+3))
  861. +         ok_to_create_file = TRUE;
  862. +         p_indent = indent;
  863. +         p_start = this_line;
  864. +         p_sline = p_input_line;
  865. +         retval = UNI_DIFF;
  866. +         goto scan_exit;
  867. +     }
  868.       stars_this_line = strnEQ(s, "********", 8);
  869.       if ((!diff_type || diff_type == CONTEXT_DIFF) && stars_last_line &&
  870.            strnEQ(s, "*** ", 4)) {
  871. ***************
  872. *** 408,413 ****
  873. --- 430,443 ----
  874.       p_input_line = file_line - 1;
  875.   }
  876.   
  877. + /* Make this a function for better debugging.  */
  878. + static void
  879. + malformed ()
  880. + {
  881. +     fatal3("Malformed patch at line %ld: %s", p_input_line, buf);
  882. +         /* about as informative as "Syntax error" in C */
  883. + }
  884. + 
  885.   /* True if there is more of the current diff listing to process. */
  886.   
  887.   bool
  888. ***************
  889. *** 502,508 ****
  890.           }
  891.           for (s=buf; *s && !isdigit(*s); s++) ;
  892.           if (!*s)
  893. !             goto malformed;
  894.           if (strnEQ(s,"0,0",3))
  895.               strcpy(s,s+2);
  896.           p_first = (LINENUM) atol(s);
  897. --- 532,538 ----
  898.           }
  899.           for (s=buf; *s && !isdigit(*s); s++) ;
  900.           if (!*s)
  901. !             malformed();
  902.           if (strnEQ(s,"0,0",3))
  903.               strcpy(s,s+2);
  904.           p_first = (LINENUM) atol(s);
  905. ***************
  906. *** 510,516 ****
  907.           if (*s == ',') {
  908.               for (; *s && !isdigit(*s); s++) ;
  909.               if (!*s)
  910. !             goto malformed;
  911.               p_ptrn_lines = ((LINENUM)atol(s)) - p_first + 1;
  912.           }
  913.           else if (p_first)
  914. --- 540,546 ----
  915.           if (*s == ',') {
  916.               for (; *s && !isdigit(*s); s++) ;
  917.               if (!*s)
  918. !             malformed();
  919.               p_ptrn_lines = ((LINENUM)atol(s)) - p_first + 1;
  920.           }
  921.           else if (p_first)
  922. ***************
  923. *** 568,580 ****
  924.               p_char[p_end] = '=';
  925.               for (s=buf; *s && !isdigit(*s); s++) ;
  926.               if (!*s)
  927. !             goto malformed;
  928.               p_newfirst = (LINENUM) atol(s);
  929.               while (isdigit(*s)) s++;
  930.               if (*s == ',') {
  931.               for (; *s && !isdigit(*s); s++) ;
  932.               if (!*s)
  933. !                 goto malformed;
  934.               p_repl_lines = ((LINENUM)atol(s)) - p_newfirst + 1;
  935.               }
  936.               else if (p_newfirst)
  937. --- 598,610 ----
  938.               p_char[p_end] = '=';
  939.               for (s=buf; *s && !isdigit(*s); s++) ;
  940.               if (!*s)
  941. !             malformed();
  942.               p_newfirst = (LINENUM) atol(s);
  943.               while (isdigit(*s)) s++;
  944.               if (*s == ',') {
  945.               for (; *s && !isdigit(*s); s++) ;
  946.               if (!*s)
  947. !                 malformed();
  948.               p_repl_lines = ((LINENUM)atol(s)) - p_newfirst + 1;
  949.               }
  950.               else if (p_newfirst)
  951. ***************
  952. *** 654,660 ****
  953.               repl_missing = TRUE;
  954.               goto hunk_done;
  955.           }
  956. !         goto malformed;
  957.           }
  958.           /* set up p_len for strncmp() so we don't have to */
  959.           /* assume null termination */
  960. --- 684,690 ----
  961.               repl_missing = TRUE;
  962.               goto hunk_done;
  963.           }
  964. !         malformed();
  965.           }
  966.           /* set up p_len for strncmp() so we don't have to */
  967.           /* assume null termination */
  968. ***************
  969. *** 721,726 ****
  970. --- 751,900 ----
  971.           assert(filldst==p_end+1 || filldst==repl_beginning);
  972.       }
  973.       }
  974. +     else if (diff_type == UNI_DIFF) {
  975. +     long line_beginning = ftell(pfp);
  976. +                     /* file pos of the current line */
  977. +     Reg4 LINENUM fillsrc;        /* index of old lines */
  978. +     Reg5 LINENUM filldst;        /* index of new lines */
  979. +     char ch;
  980. + 
  981. +     ret = pgets(buf, sizeof buf, pfp);
  982. +     p_input_line++;
  983. +     if (ret == Nullch || strnNE(buf, "@@ -", 4)) {
  984. +         next_intuit_at(line_beginning,p_input_line);
  985. +         return FALSE;
  986. +     }
  987. +     s = buf+4;
  988. +     if (!*s)
  989. +         malformed ();
  990. +     p_first = (LINENUM) atol(s);
  991. +     while (isdigit(*s)) s++;
  992. +     if (*s == ',') {
  993. +         p_ptrn_lines = (LINENUM) atol(++s);
  994. +         while (isdigit(*s)) s++;
  995. +     } else
  996. +         p_ptrn_lines = 1;
  997. +     if (*s == ' ') s++;
  998. +     if (*s != '+' || !*++s)
  999. +         malformed ();
  1000. +     p_newfirst = (LINENUM) atol(s);
  1001. +     while (isdigit(*s)) s++;
  1002. +     if (*s == ',') {
  1003. +         p_repl_lines = (LINENUM) atol(++s);
  1004. +         while (isdigit(*s)) s++;
  1005. +     } else
  1006. +         p_repl_lines = 1;
  1007. +     if (*s == ' ') s++;
  1008. +     if (*s != '@')
  1009. +         malformed ();
  1010. +     if (!p_first && !p_ptrn_lines)
  1011. +         p_first = 1;
  1012. +     p_max = p_ptrn_lines + p_repl_lines + 1;
  1013. +     while (p_max >= hunkmax)
  1014. +         grow_hunkmax();
  1015. +     p_max = hunkmax;
  1016. +     fillsrc = 1;
  1017. +     filldst = fillsrc + p_ptrn_lines;
  1018. +     p_end = filldst + p_repl_lines;
  1019. +     Sprintf(buf,"*** %ld,%ld ****\n",p_first,p_first + p_ptrn_lines - 1);
  1020. +     p_line[0] = savestr(buf);
  1021. +     if (out_of_mem) {
  1022. +         p_end = -1;
  1023. +         return FALSE;
  1024. +     }
  1025. +     p_char[0] = '*';
  1026. +         Sprintf(buf,"--- %ld,%ld ----\n",p_newfirst,p_newfirst+p_repl_lines-1);
  1027. +     p_line[filldst] = savestr(buf);
  1028. +     if (out_of_mem) {
  1029. +         p_end = 0;
  1030. +         return FALSE;
  1031. +     }
  1032. +     p_char[filldst++] = '=';
  1033. +     p_context = 100;
  1034. +     context = 0;
  1035. +     p_hunk_beg = p_input_line + 1;
  1036. +     while (fillsrc <= p_ptrn_lines || filldst <= p_end) {
  1037. +         line_beginning = ftell(pfp);
  1038. +         ret = pgets(buf, sizeof buf, pfp);
  1039. +         p_input_line++;
  1040. +         if (ret == Nullch) {
  1041. +         if (p_max - filldst < 3)
  1042. +             Strcpy(buf, " \n");  /* assume blank lines got chopped */
  1043. +         else {
  1044. +             fatal1("Unexpected end of file in patch.\n");
  1045. +         }
  1046. +         }
  1047. +         if (*buf == '\t' || *buf == '\n') {
  1048. +         ch = ' ';        /* assume the space got eaten */
  1049. +         s = savestr(buf);
  1050. +         }
  1051. +         else {
  1052. +         ch = *buf;
  1053. +         s = savestr(buf+1);
  1054. +         }
  1055. +         if (out_of_mem) {
  1056. +         while (--filldst > p_ptrn_lines)
  1057. +             free(p_line[filldst]);
  1058. +         p_end = fillsrc-1;
  1059. +         return FALSE;
  1060. +         }
  1061. +         switch (ch) {
  1062. +         case '-':
  1063. +         if (fillsrc > p_ptrn_lines) {
  1064. +             free(s);
  1065. +             p_end = filldst-1;
  1066. +             malformed ();
  1067. +         }
  1068. +         p_char[fillsrc] = ch;
  1069. +         p_line[fillsrc] = s;
  1070. +         p_len[fillsrc++] = strlen(s);
  1071. +         break;
  1072. +         case '=':
  1073. +         ch = ' ';
  1074. +         /* FALL THROUGH */
  1075. +         case ' ':
  1076. +         if (fillsrc > p_ptrn_lines) {
  1077. +             free(s);
  1078. +             while (--filldst > p_ptrn_lines)
  1079. +             free(p_line[filldst]);
  1080. +             p_end = fillsrc-1;
  1081. +             malformed ();
  1082. +         }
  1083. +         context++;
  1084. +         p_char[fillsrc] = ch;
  1085. +         p_line[fillsrc] = s;
  1086. +         p_len[fillsrc++] = strlen(s);
  1087. +         s = savestr(s);
  1088. +         if (out_of_mem) {
  1089. +             while (--filldst > p_ptrn_lines)
  1090. +             free(p_line[filldst]);
  1091. +             p_end = fillsrc-1;
  1092. +             return FALSE;
  1093. +         }
  1094. +         /* FALL THROUGH */
  1095. +         case '+':
  1096. +         if (filldst > p_end) {
  1097. +             free(s);
  1098. +             while (--filldst > p_ptrn_lines)
  1099. +             free(p_line[filldst]);
  1100. +             p_end = fillsrc-1;
  1101. +             malformed ();
  1102. +         }
  1103. +         p_char[filldst] = ch;
  1104. +         p_line[filldst] = s;
  1105. +         p_len[filldst++] = strlen(s);
  1106. +         break;
  1107. +         default:
  1108. +         p_end = filldst;
  1109. +         malformed ();
  1110. +         }
  1111. +         if (ch != ' ' && context > 0) {
  1112. +         if (context < p_context)
  1113. +             p_context = context;
  1114. +         context = -1000;
  1115. +         }
  1116. +     }/* while */
  1117. +     }
  1118.       else {                /* normal diff--fake it up */
  1119.       char hunk_type;
  1120.       Reg3 int i;
  1121. ***************
  1122. *** 793,799 ****
  1123.           if (*buf != '-')
  1124.           fatal2("--- expected at line %ld of patch.\n", p_input_line);
  1125.       }
  1126. !         Sprintf(buf, "--- %ld,%ld\n", min, max);
  1127.       p_line[i] = savestr(buf);
  1128.       if (out_of_mem) {
  1129.           p_end = i-1;
  1130. --- 967,973 ----
  1131.           if (*buf != '-')
  1132.           fatal2("--- expected at line %ld of patch.\n", p_input_line);
  1133.       }
  1134. !         Sprintf(buf, "--- %ld,%ld\n", (long) min, (long) max);
  1135.       p_line[i] = savestr(buf);
  1136.       if (out_of_mem) {
  1137.           p_end = i-1;
  1138. ***************
  1139. *** 838,848 ****
  1140.       if (p_end+1 < hunkmax)    /* paranoia reigns supreme... */
  1141.       p_char[p_end+1] = '^';  /* add a stopper for apply_hunk */
  1142.       return TRUE;
  1143. - 
  1144. - malformed:
  1145. -     fatal3("Malformed patch at line %ld: %s", p_input_line, buf);
  1146. -         /* about as informative as "Syntax error" in C */
  1147. -     return FALSE;    /* for lint */
  1148.   }
  1149.   
  1150.   /* Input a line from the patch file, worrying about indentation. */
  1151. --- 1012,1017 ----
  1152. ***************
  1153. *** 1073,1082 ****
  1154. --- 1242,1258 ----
  1155.       if (!skip_rest_of_patch) {
  1156.       Unlink(TMPOUTNAME);
  1157.           copy_file(filearg[0], TMPOUTNAME);
  1158. + #ifdef MSDOS
  1159. +     if (verbose)
  1160. +             Sprintf(buf, "ed %s", TMPOUTNAME);
  1161. +     else
  1162. +             Sprintf(buf, "ed - %s", TMPOUTNAME);
  1163. + #else
  1164.       if (verbose)
  1165.           Sprintf(buf, "/bin/ed %s", TMPOUTNAME);
  1166.       else
  1167.               Sprintf(buf, "/bin/ed - %s", TMPOUTNAME);
  1168. + #endif
  1169.       pipefp = popen(buf, "w");
  1170.       }
  1171.       for (;;) {
  1172. diff -cbBw orig/util.c patch2u/util.c
  1173. *** orig/util.c    Mon Feb 18 18:55:48 1991
  1174. --- patch2u/util.c    Mon Feb 18 19:37:12 1991
  1175. ***************
  1176. *** 5,10 ****
  1177. --- 5,13 ----
  1178.   
  1179.   /* Rename a file, copying it if necessary. */
  1180.   
  1181. + char *strchr();
  1182. + char *strrchr();
  1183. + 
  1184.   int
  1185.   move_file(from,to)
  1186.   char *from, *to;
  1187. ***************
  1188. *** 21,27 ****
  1189.       if (debug & 4)
  1190.           say2("Moving %s to stdout.\n", from);
  1191.   #endif
  1192. !     fromfd = open(from, 0);
  1193.       if (fromfd < 0)
  1194.           fatal2("patch: internal error, can't reopen %s\n", from);
  1195.       while ((i=read(fromfd, buf, sizeof buf)) > 0)
  1196. --- 24,30 ----
  1197.       if (debug & 4)
  1198.           say2("Moving %s to stdout.\n", from);
  1199.   #endif
  1200. !         fromfd = open(from, O_RDONLY|O_BINARY);
  1201.       if (fromfd < 0)
  1202.           fatal2("patch: internal error, can't reopen %s\n", from);
  1203.       while ((i=read(fromfd, buf, sizeof buf)) > 0)
  1204. ***************
  1205. *** 36,43 ****
  1206. --- 39,61 ----
  1207.           Strcat(bakname, to);
  1208.       } else {
  1209.           Strcpy(bakname, to);
  1210. + #ifdef MSDOS
  1211. +         s = strchr(bakname, 0);
  1212. + #endif
  1213.           Strcat(bakname, origext?origext:ORIGEXT);
  1214. + #ifdef MSDOS
  1215. +         if ( !IsFileNameValid(bakname) )
  1216. +         {
  1217. +           *s=0;
  1218. + 
  1219. +           if ((s=strrchr(bakname,'.'))!=NULL)
  1220. +             *s=0;
  1221. + 
  1222. +           strcat(bakname, ".org");
  1223. +         }
  1224. + #endif
  1225.       }
  1226. + 
  1227.       if (stat(to, &filestat) >= 0) {    /* output file exists */
  1228.       dev_t to_device = filestat.st_dev;
  1229.       ino_t to_inode  = filestat.st_ino;
  1230. ***************
  1231. *** 44,50 ****
  1232. --- 62,72 ----
  1233.       char *simplename = bakname;
  1234.       
  1235.           for (s=bakname; *s; s++) {
  1236. + #ifdef MSDOS
  1237. +             if (*s == '/' || *s == '\\')
  1238. + #else
  1239.               if (*s == '/')
  1240. + #endif
  1241.           simplename = s+1;
  1242.       }
  1243.       /* find a backup name that is not the same file */
  1244. ***************
  1245. *** 63,75 ****
  1246. --- 85,106 ----
  1247.       if (debug & 4)
  1248.           say3("Moving %s to %s.\n", to, bakname);
  1249.   #endif
  1250. + 
  1251. + #ifdef MSDOS
  1252. +         if (rename(to, bakname) < 0) {
  1253. + #else
  1254.       if (link(to, bakname) < 0) {
  1255. + #endif
  1256.           say3("patch: can't backup %s, output is in %s\n",
  1257.           to, from);
  1258.           return -1;
  1259.       }
  1260. + 
  1261. + #ifndef MSDOS
  1262.       while (unlink(to) >= 0) ;
  1263. + #endif
  1264.       }
  1265. + 
  1266.   #ifdef DEBUGGING
  1267.       if (debug & 4)
  1268.       say3("Moving %s to %s.\n", from, to);
  1269. ***************
  1270. *** 74,89 ****
  1271.       if (debug & 4)
  1272.       say3("Moving %s to %s.\n", from, to);
  1273.   #endif
  1274.       if (link(from, to) < 0) {        /* different file system? */
  1275.       Reg4 int tofd;
  1276.       
  1277. !     tofd = creat(to, 0666);
  1278.       if (tofd < 0) {
  1279.           say3("patch: can't create %s, output is in %s.\n",
  1280.             to, from);
  1281.           return -1;
  1282.       }
  1283. !     fromfd = open(from, 0);
  1284.       if (fromfd < 0)
  1285.           fatal2("patch: internal error, can't reopen %s\n", from);
  1286.       while ((i=read(fromfd, buf, sizeof buf)) > 0)
  1287. --- 105,126 ----
  1288.       if (debug & 4)
  1289.       say3("Moving %s to %s.\n", from, to);
  1290.   #endif
  1291. + 
  1292. + #ifdef MSDOS
  1293. +     if (rename(from, to) < 0) {           /* different file system? */
  1294. + #else
  1295.       if (link(from, to) < 0) {        /* different file system? */
  1296. + #endif
  1297.       Reg4 int tofd;
  1298.       
  1299. !         tofd = open(to, O_WRONLY|O_CREAT|O_TRUNC|O_BINARY,S_IWRITE|S_IREAD);
  1300.       if (tofd < 0) {
  1301.           say3("patch: can't create %s, output is in %s.\n",
  1302.             to, from);
  1303.           return -1;
  1304.       }
  1305. ! 
  1306. !         fromfd = open(from, O_RDONLY|O_BINARY);
  1307.       if (fromfd < 0)
  1308.           fatal2("patch: internal error, can't reopen %s\n", from);
  1309.       while ((i=read(fromfd, buf, sizeof buf)) > 0)
  1310. ***************
  1311. *** 91,98 ****
  1312. --- 128,140 ----
  1313.           fatal1("patch: write failed\n");
  1314.       Close(fromfd);
  1315.       Close(tofd);
  1316. + #ifdef MSDOS
  1317. +     Unlink(from);
  1318.       }
  1319. + #else
  1320. +     }
  1321.       Unlink(from);
  1322. + #endif
  1323.       return 0;
  1324.   }
  1325.   
  1326. ***************
  1327. *** 106,115 ****
  1328.       Reg2 int fromfd;
  1329.       Reg1 int i;
  1330.    
  1331. !     tofd = creat(to, 0666);
  1332.       if (tofd < 0)
  1333.       fatal2("patch: can't create %s.\n", to);
  1334. !     fromfd = open(from, 0);
  1335.       if (fromfd < 0)
  1336.       fatal2("patch: internal error, can't reopen %s\n", from);
  1337.       while ((i=read(fromfd, buf, sizeof buf)) > 0)
  1338. --- 148,157 ----
  1339.       Reg2 int fromfd;
  1340.       Reg1 int i;
  1341.    
  1342. !     tofd = open(to, O_WRONLY|O_CREAT|O_TRUNC|O_BINARY,S_IWRITE|S_IREAD);
  1343.       if (tofd < 0)
  1344.       fatal2("patch: can't create %s.\n", to);
  1345. !     fromfd = open(from, O_RDONLY|O_BINARY);
  1346.       if (fromfd < 0)
  1347.       fatal2("patch: internal error, can't reopen %s\n", from);
  1348.       while ((i=read(fromfd, buf, sizeof buf)) > 0)
  1349. ***************
  1350. *** 159,164 ****
  1351. --- 201,232 ----
  1352.   
  1353.   /* Vanilla terminal output (buffered). */
  1354.   
  1355. + #ifdef MSDOS
  1356. + #include <stdarg.h>
  1357. + 
  1358. + void say(char *pat,...)
  1359. + {
  1360. +     va_list argptr;
  1361. + 
  1362. +     va_start(argptr, pat);
  1363. +     vfprintf(stderr, pat, argptr);
  1364. +     va_end(argptr);
  1365. +     Fflush(stderr);
  1366. + }
  1367. + 
  1368. + void fatal(char *pat,...)
  1369. + {
  1370. +     void my_exit();
  1371. +     va_list argptr;
  1372. + 
  1373. +     va_start(argptr, pat);
  1374. +     vfprintf(stderr, pat, argptr);
  1375. +     va_end(argptr);
  1376. +     Fflush(stderr);
  1377. +     my_exit(1);
  1378. + }
  1379. + 
  1380. + #else
  1381.   void
  1382.   say(pat,arg1,arg2,arg3)
  1383.   char *pat;
  1384. ***************
  1385. *** 180,188 ****
  1386. --- 248,269 ----
  1387.       say(pat, arg1, arg2, arg3);
  1388.       my_exit(1);
  1389.   }
  1390. + #endif
  1391.   
  1392.   /* Get a response from the user, somehow or other. */
  1393.   
  1394. + #ifdef MSDOS
  1395. + void ask(char *pat,...)
  1396. + {
  1397. +     int ttyfd;
  1398. +     int r;
  1399. +     bool tty2 = isatty(2);
  1400. +     va_list argptr;
  1401. + 
  1402. +     va_start(argptr, pat);
  1403. +     vsprintf(buf, pat, argptr);
  1404. +     va_end(argptr);
  1405. + #else
  1406.   void
  1407.   ask(pat,arg1,arg2,arg3)
  1408.   char *pat;
  1409. ***************
  1410. *** 193,198 ****
  1411. --- 274,280 ----
  1412.       bool tty2 = isatty(2);
  1413.   
  1414.       Sprintf(buf, pat, arg1, arg2, arg3);
  1415. + #endif
  1416.       Fflush(stderr);
  1417.       write(2, buf, strlen(buf));
  1418.       if (tty2) {                /* might be redirected to a file */
  1419. ***************
  1420. *** 203,209 ****
  1421.       write(1, buf, strlen(buf));
  1422.       r = read(1, buf, sizeof buf);
  1423.       }
  1424. !     else if ((ttyfd = open("/dev/tty", 2)) >= 0 && isatty(ttyfd)) {
  1425.                       /* might be deleted or unwriteable */
  1426.       write(ttyfd, buf, strlen(buf));
  1427.       r = read(ttyfd, buf, sizeof buf);
  1428. --- 285,295 ----
  1429.       write(1, buf, strlen(buf));
  1430.       r = read(1, buf, sizeof buf);
  1431.       }
  1432. ! #ifdef MSDOS
  1433. !     else if ((ttyfd = open("con", O_RDWR)) >= 0 && isatty(ttyfd)) {
  1434. ! #else
  1435. !     else if ((ttyfd = open("/dev/tty", O_RDWR)) >= 0 && isatty(ttyfd)) {
  1436. ! #endif
  1437.                       /* might be deleted or unwriteable */
  1438.       write(ttyfd, buf, strlen(buf));
  1439.       r = read(ttyfd, buf, sizeof buf);
  1440. ***************
  1441. *** 242,247 ****
  1442. --- 328,334 ----
  1443.   #endif
  1444.   
  1445.       if (!reset) {
  1446. + #ifndef MSDOS
  1447.       hupval = signal(SIGHUP, SIG_IGN);
  1448.       if (hupval != SIG_IGN)
  1449.   #ifdef VOIDSIG
  1450. ***************
  1451. *** 249,254 ****
  1452. --- 336,342 ----
  1453.   #else
  1454.           hupval = (int(*)())my_exit;
  1455.   #endif
  1456. + #endif
  1457.       intval = signal(SIGINT, SIG_IGN);
  1458.       if (intval != SIG_IGN)
  1459.   #ifdef VOIDSIG
  1460. ***************
  1461. *** 257,263 ****
  1462. --- 345,353 ----
  1463.           intval = (int(*)())my_exit;
  1464.   #endif
  1465.       }
  1466. + #ifndef MSDOS
  1467.       Signal(SIGHUP, hupval);
  1468. + #endif
  1469.       Signal(SIGINT, intval);
  1470.   #endif
  1471.   }
  1472. ***************
  1473. *** 268,274 ****
  1474. --- 358,366 ----
  1475.   ignore_signals()
  1476.   {
  1477.   #ifndef lint
  1478. + #ifndef MSDOS
  1479.       Signal(SIGHUP, SIG_IGN);
  1480. + #endif
  1481.       Signal(SIGINT, SIG_IGN);
  1482.   #endif
  1483.   }
  1484. ***************
  1485. *** 287,293 ****
  1486. --- 379,389 ----
  1487.       Reg4 int dirvp = 0;
  1488.   
  1489.       while (*filename) {
  1490. + #ifdef MSDOS
  1491. +         if (*filename == '/' || *filename == '\\') {
  1492. + #else
  1493.           if (*filename == '/') {
  1494. + #endif
  1495.           filename++;
  1496.           dirv[dirvp++] = s;
  1497.           *s++ = '\0';
  1498. ***************
  1499. *** 338,348 ****
  1500. --- 434,452 ----
  1501.       if (strnEQ(name, "/dev/null", 9))    /* so files can be created by diffing */
  1502.       return Nullch;            /*   against /dev/null. */
  1503.       for (; *t && !isspace(*t); t++)
  1504. + #ifdef MSDOS
  1505. +         if (*t == '/' || *t == '\\')
  1506. + #else
  1507.           if (*t == '/')
  1508. + #endif
  1509.           if (--strip_leading >= 0)
  1510.           name = t+1;
  1511.       *t = '\0';
  1512. + #ifdef MSDOS
  1513. +     if (name != s && *s != '/' && *s != '\\') {
  1514. + #else
  1515.       if (name != s && *s != '/') {
  1516. + #endif
  1517.       name[-1] = '\0';
  1518.       if (stat(s, &filestat) && filestat.st_mode & S_IFDIR) {
  1519.           name[-1] = '/';
  1520. ***************
  1521. *** 364,366 ****
  1522. --- 468,525 ----
  1523.       }
  1524.       return name;
  1525.   }
  1526. + 
  1527. + 
  1528. + #ifdef MSDOS
  1529. + 
  1530. + /* only one pipe can be open at a time */
  1531. + 
  1532. + static char pipename[128], command[128];
  1533. + static int wrpipe;
  1534. + 
  1535. + FILE *popen(char *cmd, char *flags)
  1536. + {
  1537. +   wrpipe = (strchr(flags, 'w') != NULL);
  1538. + 
  1539. +   if ( wrpipe )
  1540. +   {
  1541. +     strcpy(command, cmd);
  1542. +     strcpy(pipename, "~WXXXXXX");
  1543. +     Mktemp(pipename);
  1544. +     return fopen(pipename, flags);  /* ordinary file */
  1545. +   }
  1546. +   else
  1547. +   {
  1548. +     strcpy(pipename, "~RXXXXXX");
  1549. +     Mktemp(pipename);
  1550. +     strcpy(command, cmd);
  1551. +     strcat(command, ">");
  1552. +     strcat(command, pipename);
  1553. +     system(command);
  1554. +     return fopen(pipename, flags);  /* ordinary file */
  1555. +   }
  1556. + }
  1557. + 
  1558. + int pclose(FILE *pipe)
  1559. + {
  1560. +   int rc;
  1561. + 
  1562. +   if ( fclose(pipe) == EOF )
  1563. +     return EOF;
  1564. + 
  1565. +   if ( wrpipe )
  1566. +   {
  1567. +     strcat(command, "<");
  1568. +     strcat(command, pipename);
  1569. +     rc = system(command);
  1570. +     unlink(pipename);
  1571. +     return rc;
  1572. +   }
  1573. +   else
  1574. +   {
  1575. +     unlink(pipename);
  1576. +     return 0;
  1577. +   }
  1578. + }
  1579. + 
  1580. + #endif
  1581. diff -cbBw orig/version.c patch2u/version.c
  1582. *** orig/version.c    Mon Feb 18 18:55:50 1991
  1583. --- patch2u/version.c    Fri Sep 07 21:03:48 1990
  1584. ***************
  1585. *** 10,16 ****
  1586.   #include "common.h"
  1587.   #include "util.h"
  1588.   #include "INTERN.h"
  1589. ! #include "patchlevel.h"
  1590.   #include "version.h"
  1591.   
  1592.   /* Print out the version number and die. */
  1593. --- 10,16 ----
  1594.   #include "common.h"
  1595.   #include "util.h"
  1596.   #include "INTERN.h"
  1597. ! #include "patchlev.h"
  1598.   #include "version.h"
  1599.   
  1600.   /* Print out the version number and die. */
  1601. ***************
  1602. *** 23,28 ****
  1603.   #ifdef lint
  1604.       rcsid[0] = rcsid[0];
  1605.   #else
  1606. !     fatal3("\n%s\nPatch level: %d\n", rcsid, PATCHLEVEL);
  1607.   #endif
  1608.   }
  1609. --- 23,28 ----
  1610.   #ifdef lint
  1611.       rcsid[0] = rcsid[0];
  1612.   #else
  1613. !     fatal3("\n%s\nPatch level: %d, with unidiff support, for DOS and OS/2\n", rcsid, PATCHLEVEL);
  1614.   #endif
  1615.   }
  1616.