home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / c / library / os2 / rcs / rcs56src / source / patch / pc-files / patches.os2 < prev   
Encoding:
Text File  |  1991-12-24  |  22.5 KB  |  917 lines
  1. Only in new: patch.cs
  2. Only in new: patch.def
  3. Only in new: patches.os2
  4. Only in new: isvalid.c
  5. diff -cbBw orig/common.h new/common.h
  6. *** orig/common.h    Tue Dec 24 18:13:12 1991
  7. --- new/common.h    Tue Dec 24 18:17:02 1991
  8. ***************
  9. *** 39,44 ****
  10. --- 39,46 ----
  11.   #include <sys/stat.h>
  12.   #include <ctype.h>
  13.   #include <signal.h>
  14. + #include <io.h>
  15. + #include <fcntl.h>
  16.   
  17.   /* constants */
  18.   
  19. ***************
  20. *** 146,153 ****
  21.   
  22.   EXT char *revision INIT(Nullch);    /* prerequisite revision, if any */
  23.   
  24. ! char *malloc();
  25. ! char *realloc();
  26.   char *strcpy();
  27.   char *strcat();
  28.   long atol();
  29. --- 148,155 ----
  30.   
  31.   EXT char *revision INIT(Nullch);    /* prerequisite revision, if any */
  32.   
  33. ! void *malloc();
  34. ! void *realloc();
  35.   char *strcpy();
  36.   char *strcat();
  37.   long atol();
  38. diff -cbBw orig/inp.c new/inp.c
  39. *** orig/inp.c    Tue Dec 24 18:10:30 1991
  40. --- new/inp.c    Tue Dec 24 18:25:40 1991
  41. ***************
  42. *** 115,120 ****
  43. --- 115,124 ----
  44.       if ((filemode & S_IFMT) & ~S_IFREG)
  45.       fatal2("%s is not a normal file--can't patch.\n", filename);
  46.       i_size = filestat.st_size;
  47. + #ifdef OS2
  48. +     if ( i_size > 65500L )
  49. +       return FALSE;
  50. + #endif
  51.       if (out_of_mem) {
  52.       set_hunkmax();        /* make sure dynamic arrays are allocated */
  53.       out_of_mem = FALSE;
  54. ***************
  55. *** 128,134 ****
  56.   #endif
  57.       if (i_womp == Nullch)
  58.       return FALSE;
  59. !     if ((ifd = open(filename, 0)) < 0)
  60.       fatal2("Can't open file %s\n", filename);
  61.   #ifndef lint
  62.       if (read(ifd, i_womp, (int)i_size) != i_size) {
  63. --- 132,138 ----
  64.   #endif
  65.       if (i_womp == Nullch)
  66.       return FALSE;
  67. !     if ((ifd = open(filename, O_BINARY)) < 0)
  68.       fatal2("Can't open file %s\n", filename);
  69.   #ifndef lint
  70.       if (read(ifd, i_womp, (int)i_size) != i_size) {
  71. ***************
  72. *** 206,214 ****
  73.       Reg4 bool found_revision = (revision == Nullch);
  74.   
  75.       using_plan_a = FALSE;
  76. !     if ((ifp = fopen(filename, "r")) == Nullfp)
  77.       fatal2("Can't open file %s\n", filename);
  78. !     if ((tifd = creat(TMPINNAME, 0666)) < 0)
  79.       fatal2("Can't open file %s\n", TMPINNAME);
  80.       while (fgets(buf, sizeof buf, ifp) != Nullch) {
  81.       if (revision != Nullch && !found_revision && rev_in_string(buf))
  82. --- 210,219 ----
  83.       Reg4 bool found_revision = (revision == Nullch);
  84.   
  85.       using_plan_a = FALSE;
  86. !     if ((ifp = fopen(filename, "rb")) == Nullfp)
  87.       fatal2("Can't open file %s\n", filename);
  88. !     if ((tifd = open(TMPINNAME, O_WRONLY|O_CREAT|O_TRUNC|O_BINARY,
  89. !                      S_IWRITE|S_IREAD)) < 0)
  90.       fatal2("Can't open file %s\n", TMPINNAME);
  91.       while (fgets(buf, sizeof buf, ifp) != Nullch) {
  92.       if (revision != Nullch && !found_revision && rev_in_string(buf))
  93. ***************
  94. *** 236,242 ****
  95.           say2("Good.  This file appears to be the %s version.\n",
  96.           revision);
  97.       }
  98. !     Fseek(ifp, 0L, 0);        /* rewind file */
  99.       lines_per_buf = BUFFERSIZE / maxlen;
  100.       tireclen = maxlen;
  101.       tibuf[0] = malloc((MEM)(BUFFERSIZE + 1));
  102. --- 241,247 ----
  103.           say2("Good.  This file appears to be the %s version.\n",
  104.           revision);
  105.       }
  106. !     rewind(ifp);          /* rewind file */
  107.       lines_per_buf = BUFFERSIZE / maxlen;
  108.       tireclen = maxlen;
  109.       tibuf[0] = malloc((MEM)(BUFFERSIZE + 1));
  110. ***************
  111. *** 258,264 ****
  112.       }
  113.       Fclose(ifp);
  114.       Close(tifd);
  115. !     if ((tifd = open(TMPINNAME, 0)) < 0) {
  116.       fatal2("Can't reopen file %s\n", TMPINNAME);
  117.       }
  118.   }
  119. --- 263,270 ----
  120.       }
  121.       Fclose(ifp);
  122.       Close(tifd);
  123. ! 
  124. !     if ((tifd = open(TMPINNAME, O_RDONLY|O_BINARY)) < 0) {
  125.       fatal2("Can't reopen file %s\n", TMPINNAME);
  126.       }
  127.   }
  128. diff -cbBw orig/patch.c new/patch.c
  129. *** orig/patch.c    Tue Dec 24 18:10:32 1991
  130. --- new/patch.c    Tue Dec 24 18:25:40 1991
  131. ***************
  132. *** 97,102 ****
  133. --- 97,103 ----
  134.   #include "util.h"
  135.   #include "pch.h"
  136.   #include "inp.h"
  137. + #include "patchlevel.h"
  138.   
  139.   /* procedures */
  140.   
  141. ***************
  142. *** 114,120 ****
  143. --- 115,126 ----
  144.   bool similar();
  145.   void re_input();
  146.   void my_exit();
  147. + char *strchr();
  148. + char *strrchr();
  149.   
  150. + /* Program name */
  151. + static char *myname;
  152. + 
  153.   /* Nonzero if -R was specified on command line.  */
  154.   static int reverse_flag_specified = FALSE;
  155.   
  156. ***************
  157. *** 132,137 ****
  158. --- 138,144 ----
  159.       int failed = 0;
  160.       int failtotal = 0;
  161.       int i;
  162. +     char *s;
  163.   
  164.       setbuf(stderr, serrbuf);
  165.       for (i = 0; i<MAXFILEC; i++)
  166. ***************
  167. *** 143,172 ****
  168.         char *tmpdir;
  169.         int tmpname_len;
  170.   
  171.         tmpdir = getenv ("TMPDIR");
  172.         if (tmpdir == NULL) {
  173.       tmpdir = "/tmp";
  174.         }
  175.         tmpname_len = strlen (tmpdir) + 20;
  176.   
  177.         TMPOUTNAME = (char *) malloc (tmpname_len);
  178.         strcpy (TMPOUTNAME, tmpdir);
  179. !       strcat (TMPOUTNAME, "/patchoXXXXXX");
  180.         Mktemp(TMPOUTNAME);
  181.   
  182.         TMPINNAME = (char *) malloc (tmpname_len);
  183.         strcpy (TMPINNAME, tmpdir);
  184. !       strcat (TMPINNAME, "/patchiXXXXXX");
  185.         Mktemp(TMPINNAME);
  186.   
  187.         TMPREJNAME = (char *) malloc (tmpname_len);
  188.         strcpy (TMPREJNAME, tmpdir);
  189. !       strcat (TMPREJNAME, "/patchrXXXXXX");
  190.         Mktemp(TMPREJNAME);
  191.   
  192.         TMPPATNAME = (char *) malloc (tmpname_len);
  193.         strcpy (TMPPATNAME, tmpdir);
  194. !       strcat (TMPPATNAME, "/patchpXXXXXX");
  195.         Mktemp(TMPPATNAME);
  196.       }
  197.   
  198. --- 150,185 ----
  199.         char *tmpdir;
  200.         int tmpname_len;
  201.   
  202. + #ifdef OS2
  203. +       tmpdir = getenv ("TMP");
  204. +       if (tmpdir == NULL) {
  205. +     tmpdir = "";
  206. + #else
  207.         tmpdir = getenv ("TMPDIR");
  208.         if (tmpdir == NULL) {
  209.       tmpdir = "/tmp";
  210. + #endif
  211.         }
  212.         tmpname_len = strlen (tmpdir) + 20;
  213.   
  214.         TMPOUTNAME = (char *) malloc (tmpname_len);
  215.         strcpy (TMPOUTNAME, tmpdir);
  216. !       strcat (TMPOUTNAME, "/poXXXXXX");
  217.         Mktemp(TMPOUTNAME);
  218.   
  219.         TMPINNAME = (char *) malloc (tmpname_len);
  220.         strcpy (TMPINNAME, tmpdir);
  221. !       strcat (TMPINNAME, "/piXXXXXX");
  222.         Mktemp(TMPINNAME);
  223.   
  224.         TMPREJNAME = (char *) malloc (tmpname_len);
  225.         strcpy (TMPREJNAME, tmpdir);
  226. !       strcat (TMPREJNAME, "/prXXXXXX");
  227.         Mktemp(TMPREJNAME);
  228.   
  229.         TMPPATNAME = (char *) malloc (tmpname_len);
  230.         strcpy (TMPPATNAME, tmpdir);
  231. !       strcat (TMPPATNAME, "/ppXXXXXX");
  232.         Mktemp(TMPPATNAME);
  233.       }
  234.   
  235. ***************
  236. *** 173,178 ****
  237. --- 186,192 ----
  238.       /* parse switches */
  239.       Argc = argc;
  240.       Argv = argv;
  241. +     myname = argv[0];
  242.       get_some_switches();
  243.   
  244.       /* make sure we clean up /tmp in case of disaster */
  245. ***************
  246. *** 337,343 ****
  247. --- 351,371 ----
  248.               s[13] = '\0';
  249.           }
  250.   #endif
  251. + #ifdef OS2
  252. +                 s = strchr(rejname, 0);
  253. + #endif
  254.           Strcat(rejname, REJEXT);
  255. + #ifdef OS2
  256. +                 if ( !IsFileNameValid(rejname) )
  257. +                 {
  258. +                   *s=0;
  259. + 
  260. +                   if ((s=strrchr(rejname,'.'))!=NULL)
  261. +                     *s=0;
  262. + 
  263. +                   strcat(rejname, ".rej");
  264. +                 }
  265. + #endif
  266.           }
  267.           if (skip_rest_of_patch) {
  268.           say4("%d out of %d hunks ignored--saving rejects to %s\n",
  269. ***************
  270. *** 499,504 ****
  271. --- 527,536 ----
  272.           case 'v':
  273.           version();
  274.           break;
  275. +             case 'h':
  276. +                 Usage();
  277. +                 exit(0);
  278. +         break;
  279.   #ifdef DEBUGGING
  280.           case 'x':
  281.           debug = atoi(s+1);
  282. ***************
  283. *** 506,516 ****
  284. --- 538,552 ----
  285.   #endif
  286.           default:
  287.           fprintf(stderr, "patch: unrecognized option `%s'\n", Argv[0]);
  288. + #ifdef OS2
  289. +                 Usage();
  290. + #else
  291.           fprintf(stderr, "\
  292.   Usage: patch [-ceflnNRsSuv] [-b backup-ext] [-B backup-prefix] [-d directory]\n\
  293.          [-D symbol] [-Fmax-fuzz] [-o out-file] [-p[strip-count]]\n\
  294.          [-r rej-name] [origfile] [patchfile] [[+] [options] [origfile]...]\n\
  295.   ");
  296. + #endif
  297.           my_exit(1);
  298.           }
  299.       }
  300. ***************
  301. *** 517,522 ****
  302. --- 553,586 ----
  303.       }
  304.   }
  305.   
  306. + 
  307. + Usage()
  308. + {
  309. +   printf("\npatch 2.0, patchlevel %s\n", PATCHLEVEL);
  310. + 
  311. +   printf("\nUsage: %s [options] orig patchfile [+ [options] orig]\n\n", myname);
  312. +   printf("  -b   next argument is the extension to be used in place of '.orig'\n");
  313. +   printf("  -c   forces patch to interpret the patch file as a context diff\n");
  314. +   printf("  -d   next argument is a directory, cd to it before doing anything else\n");
  315. +   printf("  -D   next argument is the symbol for '#ifdef...#endif' to mark changes\n");
  316. +   printf("  -e   forces patch to interpret the patch file as an ed script\n");
  317. +   printf("  -f   do not ask any questions\n");
  318. +   printf("  -l   more loosely whitespace matching\n");
  319. +   printf("  -n   forces patch to interpret the patch file as a normal diff\n");
  320. +   printf("  -N   ignore patches that are reversed or already applied, see -R\n");
  321. +   printf("  -o   next argument is the output file name\n");
  322. +   printf("  -r   next argument is the reject file name\n");
  323. +   printf("  -R   patch was created with the old and new files swapped\n");
  324. +   printf("  -s   makes patch do its work silently, unless an error occurs\n");
  325. +   printf("  -S   ignore this patch from the patch file\n");
  326. +   printf("  -u   forces patch to interpret the patch file as a unified context diff\n");
  327. +   printf("  -v   print out revision header and patch level\n\n");
  328. +   printf("  -F<number>    maximum fuzz factor for context diffs (default 2)\n");
  329. +   printf("  -p<number>    sets the pathname strip count\n");
  330. +   printf("  -x<number>    set internal debugging flags\n");
  331. + }
  332. + 
  333. + 
  334.   /* Attempt to find the right place to apply this hunk of patch. */
  335.   
  336.   LINENUM
  337. ***************
  338. *** 611,616 ****
  339. --- 675,703 ----
  340.   
  341.   /* We found where to apply it (we hope), so do it. */
  342.   
  343. + #ifdef OS2
  344. + static int fputs(const char *buffer, FILE *file)
  345. + {
  346. +   const char *ptr;
  347. + 
  348. +   for ( ptr = buffer; *ptr; ptr++ )
  349. +     if ( *ptr == '\r' )
  350. +     {
  351. +       putc(*ptr, file);
  352. + 
  353. +       if ( *(ptr + 1) == '\n' )
  354. +         putc(*++ptr, file);
  355. +     }
  356. +     else if ( *ptr == '\n' )
  357. +     {
  358. +       putc('\r', file);
  359. +       putc(*ptr, file);
  360. +     }
  361. +     else
  362. +       putc(*ptr, file);
  363. + }
  364. + #endif
  365. + 
  366.   void
  367.   apply_hunk(where)
  368.   LINENUM where;
  369. ***************
  370. *** 735,741 ****
  371.   init_output(name)
  372.   char *name;
  373.   {
  374. !     ofp = fopen(name, "w");
  375.       if (ofp == Nullfp)
  376.       fatal2("patch: can't create %s.\n", name);
  377.   }
  378. --- 822,828 ----
  379.   init_output(name)
  380.   char *name;
  381.   {
  382. !     ofp = fopen(name, "wb");
  383.       if (ofp == Nullfp)
  384.       fatal2("patch: can't create %s.\n", name);
  385.   }
  386. ***************
  387. *** 814,823 ****
  388. --- 901,929 ----
  389.                pch_line_len(pline) ))
  390.           return FALSE;
  391.       }
  392. + #ifdef OS2
  393. +     else
  394. +         {
  395. +           char *s1, *s2;
  396. +           int len;
  397. + 
  398. +           s1 = ifetch(iline, (offset >= 0));
  399. +           s2 = pfetch(pline);
  400. +           len = pch_line_len(pline);
  401. + 
  402. +           /* special CR/LF case */
  403. +           if ( s1[len - 1] == '\r' && s1[len] == '\n' && s2[len - 1] == '\n' )
  404. +             len--;
  405. + 
  406. +           if (strnNE(s1, s2, len))
  407. +         return FALSE;
  408. +         }
  409. + #else
  410.       else if (strnNE(ifetch(iline, (offset >= 0)),
  411.              pfetch(pline),
  412.              pch_line_len(pline) ))
  413.           return FALSE;
  414. + #endif
  415.       }
  416.       return TRUE;
  417.   }
  418. ***************
  419. *** 863,868 ****
  420. --- 969,978 ----
  421.       if (!trejkeep) {
  422.       Unlink(TMPREJNAME);
  423.       }
  424. +     if ( pfp != NULL )
  425. +     {
  426. +       Fclose(pfp);
  427.         Unlink(TMPPATNAME);
  428. +     }
  429.       exit(status);
  430.   }
  431. diff -cbBw orig/pch.c new/pch.c
  432. *** orig/pch.c    Tue Dec 24 18:11:18 1991
  433. --- new/pch.c    Tue Dec 24 18:25:40 1991
  434. ***************
  435. *** 37,43 ****
  436. --- 37,50 ----
  437.   #include "util.h"
  438.   #include "INTERN.h"
  439.   #include "pch.h"
  440. + #include "version.h"
  441.   
  442. + #ifdef OS2
  443. + #define EDPATH "ed"
  444. + #else
  445. + #define EDPATH "/bin/ed"
  446. + #endif
  447. + 
  448.   /* Patch (diff listing) abstract type. */
  449.   
  450.   static long p_filesize;            /* size of the patch file */
  451. ***************
  452. *** 83,88 ****
  453. --- 90,101 ----
  454.   char *filename;
  455.   {
  456.       if (filename == Nullch || !*filename || strEQ(filename, "-")) {
  457. +         if ( isatty(fileno(stdin)) )
  458. +         {
  459. +           Usage();
  460. +           exit(1);
  461. +         }
  462. + 
  463.       pfp = fopen(TMPPATNAME, "w");
  464.       if (pfp == Nullfp)
  465.           fatal2("patch: can't create %s.\n", TMPPATNAME);
  466. ***************
  467. *** 978,984 ****
  468.           if (*buf != '-')
  469.           fatal2("--- expected at line %ld of patch.\n", p_input_line);
  470.       }
  471. !     Sprintf(buf, "--- %ld,%ld\n", min, max);
  472.       p_line[i] = savestr(buf);
  473.       if (out_of_mem) {
  474.           p_end = i-1;
  475. --- 991,997 ----
  476.           if (*buf != '-')
  477.           fatal2("--- expected at line %ld of patch.\n", p_input_line);
  478.       }
  479. !     Sprintf(buf, "--- %ld,%ld\n", (long) min, (long) max);
  480.       p_line[i] = savestr(buf);
  481.       if (out_of_mem) {
  482.           p_end = i-1;
  483. ***************
  484. *** 1254,1262 ****
  485.       Unlink(TMPOUTNAME);
  486.       copy_file(filearg[0], TMPOUTNAME);
  487.       if (verbose)
  488. !         Sprintf(buf, "/bin/ed %s", TMPOUTNAME);
  489.       else
  490. !         Sprintf(buf, "/bin/ed - %s", TMPOUTNAME);
  491.       pipefp = popen(buf, "w");
  492.       }
  493.       for (;;) {
  494. --- 1267,1275 ----
  495.       Unlink(TMPOUTNAME);
  496.       copy_file(filearg[0], TMPOUTNAME);
  497.       if (verbose)
  498. !         Sprintf(buf, "%s %s", EDPATH, TMPOUTNAME);
  499.       else
  500. !         Sprintf(buf, "%s - %s", EDPATH, TMPOUTNAME);
  501.       pipefp = popen(buf, "w");
  502.       }
  503.       for (;;) {
  504. diff -cbBw orig/util.c new/util.c
  505. *** orig/util.c    Tue Dec 24 18:10:38 1991
  506. --- new/util.c    Tue Dec 24 18:25:40 1991
  507. ***************
  508. *** 5,10 ****
  509. --- 5,13 ----
  510.   
  511.   /* Rename a file, copying it if necessary. */
  512.   
  513. + char *strchr();
  514. + char *strrchr();
  515. + 
  516.   int
  517.   move_file(from,to)
  518.   char *from, *to;
  519. ***************
  520. *** 21,27 ****
  521.       if (debug & 4)
  522.           say2("Moving %s to stdout.\n", from);
  523.   #endif
  524. !     fromfd = open(from, 0);
  525.       if (fromfd < 0)
  526.           fatal2("patch: internal error, can't reopen %s\n", from);
  527.       while ((i=read(fromfd, buf, sizeof buf)) > 0)
  528. --- 24,30 ----
  529.       if (debug & 4)
  530.           say2("Moving %s to stdout.\n", from);
  531.   #endif
  532. !         fromfd = open(from, O_RDONLY|O_BINARY);
  533.       if (fromfd < 0)
  534.           fatal2("patch: internal error, can't reopen %s\n", from);
  535.       while ((i=read(fromfd, buf, sizeof buf)) > 0)
  536. ***************
  537. *** 36,43 ****
  538. --- 39,61 ----
  539.           Strcat(bakname, to);
  540.       } else {
  541.              Strcpy(bakname, to);
  542. + #ifdef OS2
  543. +         s = strchr(bakname, 0);
  544. + #endif
  545.           Strcat(bakname, origext?origext:ORIGEXT);
  546. + #ifdef OS2
  547. +         if ( !IsFileNameValid(bakname) )
  548. +         {
  549. +           *s=0;
  550. + 
  551. +           if ((s=strrchr(bakname,'.'))!=NULL)
  552. +             *s=0;
  553. + 
  554. +           strcat(bakname, ".org");
  555. +         }
  556. + #endif
  557.       }
  558. + 
  559.       if (stat(to, &filestat) >= 0) {    /* output file exists */
  560.       dev_t to_device = filestat.st_dev;
  561.       ino_t to_inode  = filestat.st_ino;
  562. ***************
  563. *** 44,50 ****
  564. --- 62,72 ----
  565.       char *simplename = bakname;
  566.   
  567.       for (s=bakname; *s; s++) {
  568. + #ifdef OS2
  569. +             if (*s == '/' || *s == '\\')
  570. + #else
  571.           if (*s == '/')
  572. + #endif
  573.           simplename = s+1;
  574.       }
  575.       /* find a backup name that is not the same file */
  576. ***************
  577. *** 61,73 ****
  578. --- 83,104 ----
  579.       if (debug & 4)
  580.           say3("Moving %s to %s.\n", to, bakname);
  581.   #endif
  582. + 
  583. + #ifdef OS2
  584. +         if (rename(to, bakname) < 0) {
  585. + #else
  586.       if (link(to, bakname) < 0) {
  587. + #endif
  588.           say3("patch: can't backup %s, output is in %s\n",
  589.           to, from);
  590.           return -1;
  591.       }
  592. + 
  593. + #ifndef OS2
  594.       while (unlink(to) >= 0) ;
  595. + #endif
  596.       }
  597. + 
  598.   #ifdef DEBUGGING
  599.       if (debug & 4)
  600.       say3("Moving %s to %s.\n", from, to);
  601. ***************
  602. *** 72,87 ****
  603.       if (debug & 4)
  604.       say3("Moving %s to %s.\n", from, to);
  605.   #endif
  606.       if (link(from, to) < 0) {        /* different file system? */
  607.       Reg4 int tofd;
  608.   
  609. !     tofd = creat(to, 0666);
  610.       if (tofd < 0) {
  611.           say3("patch: can't create %s, output is in %s.\n",
  612.             to, from);
  613.           return -1;
  614.       }
  615. !     fromfd = open(from, 0);
  616.       if (fromfd < 0)
  617.           fatal2("patch: internal error, can't reopen %s\n", from);
  618.       while ((i=read(fromfd, buf, sizeof buf)) > 0)
  619. --- 103,124 ----
  620.       if (debug & 4)
  621.       say3("Moving %s to %s.\n", from, to);
  622.   #endif
  623. + 
  624. + #ifdef OS2
  625. +     if (rename(from, to) < 0) {           /* different file system? */
  626. + #else
  627.       if (link(from, to) < 0) {        /* different file system? */
  628. + #endif
  629.       Reg4 int tofd;
  630.   
  631. !         tofd = open(to, O_WRONLY|O_CREAT|O_TRUNC|O_BINARY,S_IWRITE|S_IREAD);
  632.       if (tofd < 0) {
  633.           say3("patch: can't create %s, output is in %s.\n",
  634.             to, from);
  635.           return -1;
  636.       }
  637. ! 
  638. !         fromfd = open(from, O_RDONLY|O_BINARY);
  639.       if (fromfd < 0)
  640.           fatal2("patch: internal error, can't reopen %s\n", from);
  641.       while ((i=read(fromfd, buf, sizeof buf)) > 0)
  642. ***************
  643. *** 89,96 ****
  644. --- 126,138 ----
  645.           fatal1("patch: write failed\n");
  646.       Close(fromfd);
  647.       Close(tofd);
  648. + #ifdef OS2
  649. +     Unlink(from);
  650.       }
  651. + #else
  652. +     }
  653.       Unlink(from);
  654. + #endif
  655.       return 0;
  656.   }
  657.   
  658. ***************
  659. *** 104,113 ****
  660.       Reg2 int fromfd;
  661.       Reg1 int i;
  662.   
  663. !     tofd = creat(to, 0666);
  664.       if (tofd < 0)
  665.       fatal2("patch: can't create %s.\n", to);
  666. !     fromfd = open(from, 0);
  667.       if (fromfd < 0)
  668.       fatal2("patch: internal error, can't reopen %s\n", from);
  669.       while ((i=read(fromfd, buf, sizeof buf)) > 0)
  670. --- 146,155 ----
  671.       Reg2 int fromfd;
  672.       Reg1 int i;
  673.   
  674. !     tofd = open(to, O_WRONLY|O_CREAT|O_TRUNC|O_BINARY,S_IWRITE|S_IREAD);
  675.       if (tofd < 0)
  676.       fatal2("patch: can't create %s.\n", to);
  677. !     fromfd = open(from, O_RDONLY|O_BINARY);
  678.       if (fromfd < 0)
  679.       fatal2("patch: internal error, can't reopen %s\n", from);
  680.       while ((i=read(fromfd, buf, sizeof buf)) > 0)
  681. ***************
  682. *** 157,162 ****
  683. --- 199,230 ----
  684.   
  685.   /* Vanilla terminal output (buffered). */
  686.   
  687. + #ifdef OS2
  688. + #include <stdarg.h>
  689. + 
  690. + void say(char *pat,...)
  691. + {
  692. +     va_list argptr;
  693. + 
  694. +     va_start(argptr, pat);
  695. +     vfprintf(stderr, pat, argptr);
  696. +     va_end(argptr);
  697. +     Fflush(stderr);
  698. + }
  699. + 
  700. + void fatal(char *pat,...)
  701. + {
  702. +     void my_exit();
  703. +     va_list argptr;
  704. + 
  705. +     va_start(argptr, pat);
  706. +     vfprintf(stderr, pat, argptr);
  707. +     va_end(argptr);
  708. +     Fflush(stderr);
  709. +     my_exit(1);
  710. + }
  711. + 
  712. + #else
  713.   void
  714.   say(pat,arg1,arg2,arg3)
  715.   char *pat;
  716. ***************
  717. *** 178,186 ****
  718. --- 246,267 ----
  719.       say(pat, arg1, arg2, arg3);
  720.       my_exit(1);
  721.   }
  722. + #endif
  723.   
  724.   /* Get a response from the user, somehow or other. */
  725.   
  726. + #ifdef OS2
  727. + void ask(char *pat,...)
  728. + {
  729. +     int ttyfd;
  730. +     int r;
  731. +     bool tty2 = isatty(2);
  732. +     va_list argptr;
  733. + 
  734. +     va_start(argptr, pat);
  735. +     vsprintf(buf, pat, argptr);
  736. +     va_end(argptr);
  737. + #else
  738.   void
  739.   ask(pat,arg1,arg2,arg3)
  740.   char *pat;
  741. ***************
  742. *** 191,196 ****
  743. --- 272,278 ----
  744.       bool tty2 = isatty(2);
  745.   
  746.       Sprintf(buf, pat, arg1, arg2, arg3);
  747. + #endif
  748.       Fflush(stderr);
  749.       write(2, buf, strlen(buf));
  750.       if (tty2) {                /* might be redirected to a file */
  751. ***************
  752. *** 201,207 ****
  753.       write(1, buf, strlen(buf));
  754.       r = read(1, buf, sizeof buf);
  755.       }
  756. !     else if ((ttyfd = open("/dev/tty", 2)) >= 0 && isatty(ttyfd)) {
  757.                       /* might be deleted or unwriteable */
  758.       write(ttyfd, buf, strlen(buf));
  759.       r = read(ttyfd, buf, sizeof buf);
  760. --- 283,293 ----
  761.       write(1, buf, strlen(buf));
  762.       r = read(1, buf, sizeof buf);
  763.       }
  764. ! #ifdef OS2
  765. !     else if ((ttyfd = open("con", O_RDWR)) >= 0 && isatty(ttyfd)) {
  766. ! #else
  767. !     else if ((ttyfd = open("/dev/tty", O_RDWR)) >= 0 && isatty(ttyfd)) {
  768. ! #endif
  769.                       /* might be deleted or unwriteable */
  770.       write(ttyfd, buf, strlen(buf));
  771.       r = read(ttyfd, buf, sizeof buf);
  772. ***************
  773. *** 240,245 ****
  774. --- 326,332 ----
  775.   #endif
  776.   
  777.       if (!reset) {
  778. + #ifndef OS2
  779.       hupval = signal(SIGHUP, SIG_IGN);
  780.       if (hupval != SIG_IGN)
  781.   #ifdef VOIDSIG
  782. ***************
  783. *** 247,252 ****
  784. --- 334,340 ----
  785.   #else
  786.           hupval = (int(*)())my_exit;
  787.   #endif
  788. + #endif
  789.       intval = signal(SIGINT, SIG_IGN);
  790.       if (intval != SIG_IGN)
  791.   #ifdef VOIDSIG
  792. ***************
  793. *** 255,261 ****
  794. --- 343,351 ----
  795.           intval = (int(*)())my_exit;
  796.   #endif
  797.       }
  798. + #ifndef OS2
  799.       Signal(SIGHUP, hupval);
  800. + #endif
  801.       Signal(SIGINT, intval);
  802.   #endif
  803.   }
  804. ***************
  805. *** 266,272 ****
  806. --- 356,364 ----
  807.   ignore_signals()
  808.   {
  809.   #ifndef lint
  810. + #ifndef OS2
  811.       Signal(SIGHUP, SIG_IGN);
  812. + #endif
  813.       Signal(SIGINT, SIG_IGN);
  814.   #endif
  815.   }
  816. ***************
  817. *** 285,291 ****
  818. --- 377,387 ----
  819.       Reg4 int dirvp = 0;
  820.   
  821.       while (*filename) {
  822. + #ifdef OS2
  823. +         if (*filename == '/' || *filename == '\\') {
  824. + #else
  825.       if (*filename == '/') {
  826. + #endif
  827.           filename++;
  828.           dirv[dirvp++] = s;
  829.           *s++ = '\0';
  830. ***************
  831. *** 336,346 ****
  832. --- 432,450 ----
  833.       if (strnEQ(name, "/dev/null", 9))    /* so files can be created by diffing */
  834.       return Nullch;            /*   against /dev/null. */
  835.       for (; *t && !isspace(*t); t++)
  836. + #ifdef OS2
  837. +         if (*t == '/' || *t == '\\')
  838. + #else
  839.       if (*t == '/')
  840. + #endif
  841.           if (--strip_leading >= 0)
  842.           name = t+1;
  843.       *t = '\0';
  844. + #ifdef OS2
  845. +     if (name != s && *s != '/' && *s != '\\') {
  846. + #else
  847.       if (name != s && *s != '/') {
  848. + #endif
  849.       name[-1] = '\0';
  850.       if (stat(s, &filestat) && filestat.st_mode & S_IFDIR) {
  851.           name[-1] = '/';
  852. ***************
  853. *** 362,364 ****
  854. --- 466,527 ----
  855.       }
  856.       return name;
  857.   }
  858. + 
  859. + 
  860. + #ifdef OS2
  861. + 
  862. + /* only one pipe can be open at a time */
  863. + 
  864. + /* In fact, this is a pipe simulation for the dumb MS-DOS */
  865. + /* but it works good enough for the situation where it is */
  866. + /* needed in patch, even if OS/2 has real pipes. */
  867. + 
  868. + static char pipename[128], command[128];
  869. + static int wrpipe;
  870. + 
  871. + FILE *popen(char *cmd, char *flags)
  872. + {
  873. +   wrpipe = (strchr(flags, 'w') != NULL);
  874. + 
  875. +   if ( wrpipe )
  876. +   {
  877. +     strcpy(command, cmd);
  878. +     strcpy(pipename, "~WXXXXXX");
  879. +     Mktemp(pipename);
  880. +     return fopen(pipename, flags);  /* ordinary file */
  881. +   }
  882. +   else
  883. +   {
  884. +     strcpy(pipename, "~RXXXXXX");
  885. +     Mktemp(pipename);
  886. +     strcpy(command, cmd);
  887. +     strcat(command, ">");
  888. +     strcat(command, pipename);
  889. +     system(command);
  890. +     return fopen(pipename, flags);  /* ordinary file */
  891. +   }
  892. + }
  893. + 
  894. + int pclose(FILE *pipe)
  895. + {
  896. +   int rc;
  897. + 
  898. +   if ( fclose(pipe) == EOF )
  899. +     return EOF;
  900. + 
  901. +   if ( wrpipe )
  902. +   {
  903. +     strcat(command, "<");
  904. +     strcat(command, pipename);
  905. +     rc = system(command);
  906. +     unlink(pipename);
  907. +     return rc;
  908. +   }
  909. +   else
  910. +   {
  911. +     unlink(pipename);
  912. +     return 0;
  913. +   }
  914. + }
  915. + 
  916. + #endif
  917.