home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / unix / volume1 / patch1.3 < prev    next >
Internet Message Format  |  1986-11-30  |  51KB
  1. Date: Tue, 7 May 85 13:35:36 pdt
  2. From: allegra!sdcrdcf!RDCF.SDC.UUCP!lwall (Larry Wall)
  3. Newsgroups: mod.sources
  4. Subject: patch version 1.3
  5. Reply-To: lwall@sdcrdcf.UUCP
  6. Organization: System Development Corporation R&D, Santa Monica
  7.  
  8. #!/bin/sh
  9. : make a subdirectory, cd to it, and run this through sh.
  10. echo 'If this kit is complete, "End of kit" will echo at the end'
  11. echo Extracting patch.man
  12. cat >patch.man <<'!STUFFY!FUNK!'
  13. ''' $Header: patch.man,v 1.3 85/03/26 15:11:06 lwall Exp $
  14. ''' 
  15. ''' $Log:    patch.man,v $
  16. ''' Revision 1.3  85/03/26  15:11:06  lwall
  17. ''' Frozen.
  18. ''' 
  19. ''' Revision 1.2.1.4  85/03/12  16:14:27  lwall
  20. ''' Documented -p.
  21. ''' 
  22. ''' Revision 1.2.1.3  85/03/12  16:09:41  lwall
  23. ''' Documented -D.
  24. ''' 
  25. ''' Revision 1.2.1.2  84/12/05  11:06:55  lwall
  26. ''' Added -l switch, and noted bistability bug.
  27. ''' 
  28. ''' Revision 1.2.1.1  84/12/04  17:23:39  lwall
  29. ''' Branch for sdcrdcf changes.
  30. ''' 
  31. ''' Revision 1.2  84/12/04  17:22:02  lwall
  32. ''' Baseline version.
  33. ''' 
  34. .de Sh
  35. .br
  36. .ne 5
  37. .PP
  38. \fB\\$1\fR
  39. .PP
  40. ..
  41. .de Sp
  42. .if t .sp .5v
  43. .if n .sp
  44. ..
  45. '''
  46. '''     Set up \*(-- to give an unbreakable dash;
  47. '''     string Tr holds user defined translation string.
  48. '''     Bell System Logo is used as a dummy character.
  49. '''
  50. .ie n \{\
  51. .tr \(bs-\*(Tr
  52. .ds -- \(bs-
  53. .if (\n(.H=4u)&(1m=24u) .ds -- \(bs\h'-12u'\(bs\h'-12u'-\" diablo 10 pitch
  54. .if (\n(.H=4u)&(1m=20u) .ds -- \(bs\h'-12u'\(bs\h'-8u'-\" diablo 12 pitch
  55. .ds L" ""
  56. .ds R" ""
  57. .ds L' '
  58. .ds R' '
  59. 'br\}
  60. .el\{\
  61. .ds -- \(em\|
  62. .tr \*(Tr
  63. .ds L" ``
  64. .ds R" ''
  65. .ds L' `
  66. .ds R' '
  67. 'br\}
  68. .TH PATCH 1 LOCAL
  69. .SH NAME
  70. patch - a program for applying a diff file to an original
  71. .SH SYNOPSIS
  72. .B patch
  73. [options] orig diff [+ [options] orig]
  74. .SH DESCRIPTION
  75. .I Patch
  76. will take a patch file containing any of the three forms of difference
  77. listing produced by the
  78. .I diff
  79. program and apply those differences to an original file, producing a patched
  80. version.
  81. By default, the patched version is put in place of the original, with
  82. the original file backed up to the same name with the
  83. extension \*(L".orig\*(R", or as specified by the
  84. .B -b
  85. switch.
  86. You may also specify where you want the output to go with a
  87. .B -o
  88. switch.
  89. If
  90. .I diff
  91. is omitted, or is a hyphen, the patch will be read from standard input.
  92. .PP
  93. Upon startup, patch will attempt to determine the type of the diff file,
  94. unless over-ruled by a
  95. .BR -c ,
  96. .BR -e ,
  97. or
  98. .B -n
  99. switch.
  100. Context diffs and normal diffs are applied by the
  101. .I patch
  102. program itself, while ed diffs are simply fed to the
  103. .I ed
  104. editor via a pipe.
  105. .PP
  106. .I Patch
  107. will try to skip any leading garbage, apply the diff,
  108. and then skip any trailing garbage.
  109. Thus you could feed an article or message containing a context or normal
  110. diff to
  111. .IR patch ,
  112. and it should work.
  113. If the entire diff is indented by a consistent amount,
  114. this will be taken into account.
  115. .PP
  116. With context diffs, and to a lesser extent with normal diffs,
  117. .I patch
  118. can detect when the line numbers mentioned in the patch are incorrect,
  119. and will attempt to find the correct place to apply each hunk of the patch.
  120. As a first guess, it takes the line number mentioned for the hunk, plus or
  121. minus any offset used in applying the previous hunk.
  122. If that is not the correct place,
  123. .I patch
  124. will scan both forwards and backwards for a set of lines matching the context
  125. given in the hunk.
  126. All lines of the context must match.
  127. If
  128. .I patch
  129. cannot find a place to install that hunk of the patch, it will put the
  130. hunk out to a reject file, which normally is the name of the output file
  131. plus \*(L".rej\*(R".
  132. (Note that the rejected hunk will come out in context diff form whether the
  133. input patch was a context diff or a normal diff.
  134. If the input was a normal diff, many of the contexts will simply be null.)
  135. .PP
  136. If no original file is specified on the command line,
  137. .I patch
  138. will try to figure out from the leading garbage what the name of the file
  139. to edit is.
  140. In the header of a context diff, the filename is found from lines beginning
  141. with \*(L"***\*(R" or \*(L"---\*(R", with the shortest name of an existing
  142. file winning.
  143. Only context diffs have lines like that, but if there is an \*(L"Index:\*(R"
  144. line in the leading garbage,
  145. .I patch
  146. will try to use the filename from that line.
  147. The context diff header takes precedence over an Index line.
  148. If no filename can be intuited from the leading garbage, you will be asked
  149. for the name of the file to patch.
  150. .PP
  151. (If the original file cannot be found, but a suitable SCCS or RCS file is
  152. handy,
  153. .I patch
  154. will attempt to get or check out the file.)
  155. .PP
  156. Additionally, if the leading garbage contains a \*(L"Prereq: \*(R" line,
  157. .I patch
  158. will take the first word from the prerequisites line (normally a version
  159. number) and check the input file to see if that word can be found.
  160. If not,
  161. .I patch
  162. will ask for confirmation before proceeding.
  163. .PP
  164. The upshot of all this is that you should be able to say, while in a news
  165. interface, the following:
  166. .Sp
  167.     | patch -d /usr/src/local/blurfl
  168. .Sp
  169. and patch a file in the blurfl directory directly from the article containing
  170. the patch.
  171. .PP
  172. If the patch file contains more than one patch,
  173. .I patch
  174. will try to apply each of them as if they came from separate patch files.
  175. This means, among other things, that it is assumed that separate patches
  176. will apply to separate files, and that the garbage before each patch will
  177. be examined for interesting things such as filenames and revision level, as
  178. mentioned previously.
  179. You can give switches (and another original file name) for the second and
  180. subsequent patches by separating the corresponding argument lists
  181. by a \*(L'+\*(R'.
  182. The argument list for a second or subsequent patch may not specify a new
  183. patch file, however.
  184. .PP
  185. .I Patch
  186. recognizes the following switches:
  187. .TP 5
  188. .B \-b
  189. causes the next argument to be interpreted as the backup extension, to be
  190. used in place of \*(L".orig\*(R".
  191. .TP 5
  192. .B \-c
  193. forces
  194. .I patch
  195. to interpret the patch file as a context diff.
  196. .TP 5
  197. .B \-d
  198. causes
  199. .I patch
  200. to interpret the next argument as a directory, and cd to it before doing
  201. anything else.
  202. .TP 5
  203. .B \-D
  204. causes
  205. .I patch
  206. to use the "#ifdef...#endif" construct to mark changes.
  207. The argument following will be used as the differentiating symbol.
  208. Note that, unlike the C compiler, there must be a space between the
  209. .B \-D
  210. and the argument.
  211. .TP 5
  212. .B \-e
  213. forces
  214. .I patch
  215. to interpret the patch file as an ed script.
  216. .TP 5
  217. .B \-l
  218. causes the pattern matching to be done loosely, in case the tabs and
  219. spaces have been munged in you input file.
  220. Any sequence of whitespace in the pattern line will match any sequence
  221. in the input file.
  222. Normal characters must still match exactly.
  223. Each line of the context must still match a line in the input file.
  224. .TP 5
  225. .B \-n
  226. forces
  227. .I patch
  228. to interpret the patch file as a normal diff.
  229. .TP 5
  230. .B \-o
  231. causes the next argument to be interpreted as the output file name.
  232. .TP 5
  233. .B \-p
  234. causes leading pathnames to be kept.
  235. If the diff is of the file \*(lqb/a.c\*(rq, patch will look for \*(lqa.c\*(rq
  236. in the \*(lqb\*(rq directory, instead of the current directory.
  237. This probably won't work if the diff has rooted pathnames.
  238. .TP 5
  239. .B \-r
  240. causes the next argument to be interpreted as the reject file name.
  241. .TP 5
  242. .B \-R
  243. tells
  244. .I patch
  245. that this patch was created with the old and new files swapped.
  246. (Yes, I'm afraid that does happen occasionally, human nature being what it
  247. is.)
  248. .I Patch
  249. will attempt to swap each hunk around before applying it.
  250. Rejects will come out in the swapped format.
  251. The
  252. .B \-R
  253. switch will not work with ed diff scripts because there is too little
  254. information to reconstruct the reverse operation.
  255. .Sp
  256. If the first hunk of a patch fails,
  257. .I patch
  258. will reverse the hunk to see if it can be applied that way.
  259. If it can, the
  260. .B \-R
  261. switch will be set automatically.
  262. If it can't, the patch will continue to be applied normally.
  263. (Note: this method cannot detect a reversed patch if it is a normal diff
  264. and if the first command is an append (i.e. it should have been a delete)
  265. since appends always succeed.
  266. Luckily, most patches add lines rather than delete them, so most reversed
  267. normal diffs will begin with a delete, which will fail, triggering the
  268. heuristic.)
  269. .TP 5
  270. .B \-s
  271. makes
  272. .I patch
  273. do its work silently, unless an error occurs.
  274. .TP 5
  275. .B \-x<number>
  276. sets internal debugging flags, and is of interest only to
  277. .I patch
  278. patchers.
  279. .SH ENVIRONMENT
  280. No environment variables are used by
  281. .IR patch .
  282. .SH FILES
  283. /tmp/patch*
  284. .SH SEE ALSO
  285. diff(1)
  286. .SH DIAGNOSTICS
  287. Too many to list here, but generally indicative that
  288. .I patch
  289. couldn't parse your patch file.
  290. .PP
  291. The message \*(L"Hmm...\*(R" indicates that there is unprocessed text in
  292. the patch file and that
  293. .I patch
  294. is attempting to intuit whether there is a patch in that text and, if so,
  295. what kind of patch it is.
  296. .SH CAVEATS
  297. .I Patch
  298. cannot tell if the line numbers are off in an ed script, and can only detect
  299. bad line numbers in a normal diff when it finds a \*(L"change\*(R" command.
  300. Until a suitable interactive interface is added, you should probably do
  301. a context diff in these cases to see if the changes made sense.
  302. Of course, compiling without errors is a pretty good indication that it
  303. worked, but not always.
  304. .PP
  305. .I Patch
  306. usually produces the correct results, even when it has to do a lot of
  307. guessing.
  308. However, the results are guaranteed to be correct only when the patch is
  309. applied to exactly the same version of the file that the patch was
  310. generated from.
  311. .SH BUGS
  312. Could be smarter about partial matches, excessively \&deviant offsets and
  313. swapped code, but that would take an extra pass.
  314. .PP
  315. If code has been duplicated (for instance with #ifdef OLDCODE ... #else ...
  316. #endif),
  317. .I patch
  318. is incapable of patching both versions, and, if it works at all, will likely
  319. patch the wrong one, and tell you it succeeded to boot.
  320. .PP
  321. If you apply a patch you've already applied,
  322. .I patch
  323. will think it is a reversed patch, and un-apply the patch.
  324. This could be construed as a feature.
  325. !STUFFY!FUNK!
  326. echo Extracting patch.c
  327. cat >patch.c <<'!STUFFY!FUNK!'
  328. /* patch - a program to apply diffs to original files
  329.  *
  330.  * $Header: patch.c,v 1.3 85/03/26 15:07:43 lwall Exp $
  331.  *
  332.  * Copyright 1984, Larry Wall
  333.  *
  334.  * This program may be copied as long as you don't try to make any
  335.  * money off of it, or pretend that you wrote it.
  336.  *
  337.  * $Log:    patch.c,v $
  338.  * Revision 1.3  85/03/26  15:07:43  lwall
  339.  * Frozen.
  340.  * 
  341.  * Revision 1.2.1.9  85/03/12  17:03:35  lwall
  342.  * Changed pfp->_file to fileno(pfp).
  343.  * 
  344.  * Revision 1.2.1.8  85/03/12  16:30:43  lwall
  345.  * Check i_ptr and i_womp to make sure they aren't null before freeing.
  346.  * Also allow ed output to be suppressed.
  347.  * 
  348.  * Revision 1.2.1.7  85/03/12  15:56:13  lwall
  349.  * Added -p option from jromine@uci-750a.
  350.  * 
  351.  * Revision 1.2.1.6  85/03/12  12:12:51  lwall
  352.  * Now checks for normalness of file to patch.
  353.  * 
  354.  * Revision 1.2.1.5  85/03/12  11:52:12  lwall
  355.  * Added -D (#ifdef) option from joe@fluke.
  356.  * 
  357.  * Revision 1.2.1.4  84/12/06  11:14:15  lwall
  358.  * Made smarter about SCCS subdirectories.
  359.  * 
  360.  * Revision 1.2.1.3  84/12/05  11:18:43  lwall
  361.  * Added -l switch to do loose string comparison.
  362.  * 
  363.  * Revision 1.2.1.2  84/12/04  09:47:13  lwall
  364.  * Failed hunk count not reset on multiple patch file.
  365.  * 
  366.  * Revision 1.2.1.1  84/12/04  09:42:37  lwall
  367.  * Branch for sdcrdcf changes.
  368.  * 
  369.  * Revision 1.2  84/11/29  13:29:51  lwall
  370.  * Linted.  Identifiers uniqified.  Fixed i_ptr malloc() bug.  Fixed
  371.  * multiple calls to mktemp().  Will now work on machines that can only
  372.  * read 32767 chars.  Added -R option for diffs with new and old swapped.
  373.  * Various cosmetic changes.
  374.  * 
  375.  * Revision 1.1  84/11/09  17:03:58  lwall
  376.  * Initial revision
  377.  * 
  378.  */
  379.  
  380. #define DEBUGGING
  381.  
  382. /* shut lint up about the following when return value ignored */
  383.  
  384. #define Signal (void)signal
  385. #define Unlink (void)unlink
  386. #define Lseek (void)lseek
  387. #define Fseek (void)fseek
  388. #define Fstat (void)fstat
  389. #define Pclose (void)pclose
  390. #define Close (void)close
  391. #define Fclose (void)fclose
  392. #define Fflush (void)fflush
  393. #define Sprintf (void)sprintf
  394. #define Mktemp (void)mktemp
  395. #define Strcpy (void)strcpy
  396. #define Strcat (void)strcat
  397.  
  398. #include <stdio.h>
  399. #include <assert.h>
  400. #include <sys/types.h>
  401. #include <sys/stat.h>
  402. #include <ctype.h>
  403. #include <signal.h>
  404.  
  405. /* constants */
  406.  
  407. #define TRUE (1)
  408. #define FALSE (0)
  409.  
  410. #define MAXHUNKSIZE 500
  411. #define MAXLINELEN 1024
  412. #define BUFFERSIZE 1024
  413. #define ORIGEXT ".orig"
  414. #define SCCSPREFIX "s."
  415. #define GET "get -e %s"
  416. #define RCSSUFFIX ",v"
  417. #define CHECKOUT "co -l %s"
  418.  
  419. /* handy definitions */
  420.  
  421. #define Null(t) ((t)0)
  422. #define Nullch Null(char *)
  423. #define Nullfp Null(FILE *)
  424.  
  425. #define Ctl(ch) (ch & 037)
  426.  
  427. #define strNE(s1,s2) (strcmp(s1,s2))
  428. #define strEQ(s1,s2) (!strcmp(s1,s2))
  429. #define strnNE(s1,s2,l) (strncmp(s1,s2,l))
  430. #define strnEQ(s1,s2,l) (!strncmp(s1,s2,l))
  431.  
  432. /* typedefs */
  433.  
  434. typedef char bool;
  435. typedef long LINENUM;            /* must be signed */
  436. typedef unsigned MEM;            /* what to feed malloc */
  437.  
  438. /* globals */
  439.  
  440. int Argc;                /* guess */
  441. char **Argv;
  442.  
  443. struct stat filestat;            /* file statistics area */
  444.  
  445. char serrbuf[BUFSIZ];            /* buffer for stderr */
  446. char buf[MAXLINELEN];            /* general purpose buffer */
  447. FILE *pfp = Nullfp;            /* patch file pointer */
  448. FILE *ofp = Nullfp;            /* output file pointer */
  449. FILE *rejfp = Nullfp;            /* reject file pointer */
  450.  
  451. LINENUM input_lines = 0;        /* how long is input file in lines */
  452. LINENUM last_frozen_line = 0;        /* how many input lines have been */
  453.                     /* irretractibly output */
  454.  
  455. #define MAXFILEC 2
  456. int filec = 0;                /* how many file arguments? */
  457. char *filearg[MAXFILEC];
  458.  
  459. char *outname = Nullch;
  460. char rejname[128];
  461.  
  462. char *origext = Nullch;
  463.  
  464. char TMPOUTNAME[] = "/tmp/patchoXXXXXX";
  465. char TMPINNAME[] = "/tmp/patchiXXXXXX";    /* you might want /usr/tmp here */
  466. char TMPREJNAME[] = "/tmp/patchrXXXXXX";
  467. char TMPPATNAME[] = "/tmp/patchpXXXXXX";
  468.  
  469. LINENUM last_offset = 0;
  470. #ifdef DEBUGGING
  471. int debug = 0;
  472. #endif
  473. bool verbose = TRUE;
  474. bool reverse = FALSE;
  475. bool usepath = FALSE;
  476. bool canonicalize = FALSE;
  477.  
  478. #define CONTEXT_DIFF 1
  479. #define NORMAL_DIFF 2
  480. #define ED_DIFF 3
  481. int diff_type = 0;
  482.  
  483. int do_defines = 0;            /* patch using ifdef, ifndef, etc. */
  484. char if_defined[128];            /* #ifdef xyzzy */
  485. char not_defined[128];            /* #ifndef xyzzy */
  486. char else_defined[] = "#else\n";    /* #else */
  487. char end_defined[128];            /* #endif xyzzy */
  488.  
  489. char *revision = Nullch;        /* prerequisite revision, if any */
  490.  
  491. /* procedures */
  492.  
  493. LINENUM locate_hunk();
  494. bool patch_match();
  495. bool similar();
  496. char *malloc();
  497. char *savestr();
  498. char *strcpy();
  499. char *strcat();
  500. char *sprintf();        /* usually */
  501. int my_exit();
  502. bool rev_in_string();
  503. char *fetchname();
  504. long atol();
  505. long lseek();
  506. char *mktemp();
  507.  
  508. /* patch type */
  509.  
  510. bool there_is_another_patch();
  511. bool another_hunk();
  512. char *pfetch();
  513. int pch_line_len();
  514. LINENUM pch_first();
  515. LINENUM pch_ptrn_lines();
  516. LINENUM pch_newfirst();
  517. LINENUM pch_repl_lines();
  518. LINENUM pch_end();
  519. LINENUM pch_context();
  520. LINENUM pch_hunk_beg();
  521. char pch_char();
  522. char *pfetch();
  523. char *pgets();
  524.  
  525. /* input file type */
  526.  
  527. char *ifetch();
  528.  
  529. /* apply a context patch to a named file */
  530.  
  531. main(argc,argv)
  532. int argc;
  533. char **argv;
  534. {
  535.     LINENUM where;
  536.     int hunk = 0;
  537.     int failed = 0;
  538.     int i;
  539.  
  540.     setbuf(stderr,serrbuf);
  541.     for (i = 0; i<MAXFILEC; i++)
  542.     filearg[i] = Nullch;
  543.     Mktemp(TMPOUTNAME);
  544.     Mktemp(TMPINNAME);
  545.     Mktemp(TMPREJNAME);
  546.     Mktemp(TMPPATNAME);
  547.  
  548.     /* parse switches */
  549.     Argc = argc;
  550.     Argv = argv;
  551.     get_some_switches();
  552.     
  553.     /* make sure we clean up /tmp in case of disaster */
  554.     set_signals();
  555.  
  556.     for (
  557.     open_patch_file(filearg[1]);
  558.     there_is_another_patch();
  559.     reinitialize_almost_everything()
  560.     ) {                    /* for each patch in patch file */
  561.  
  562.     if (outname == Nullch)
  563.         outname = savestr(filearg[0]);
  564.     
  565.     /* initialize the patched file */
  566.     init_output(TMPOUTNAME);
  567.     
  568.     /* for ed script just up and do it and exit */
  569.     if (diff_type == ED_DIFF) {
  570.         do_ed_script();
  571.         continue;
  572.     }
  573.     
  574.     /* initialize reject file */
  575.     init_reject(TMPREJNAME);
  576.     
  577.     /* find out where all the lines are */
  578.     scan_input(filearg[0]);
  579.     
  580.     /* from here on, open no standard i/o files, because malloc */
  581.     /* might misfire */
  582.     
  583.     /* apply each hunk of patch */
  584.     hunk = 0;
  585.     failed = 0;
  586.     while (another_hunk()) {
  587.         hunk++;
  588.         where = locate_hunk();
  589.         if (hunk == 1 && where == Null(LINENUM)) {
  590.                     /* dwim for reversed patch? */
  591.         pch_swap();
  592.         reverse = !reverse;
  593.         where = locate_hunk();    /* try again */
  594.         if (where == Null(LINENUM)) {
  595.             pch_swap();        /* no, put it back to normal */
  596.             reverse = !reverse;
  597.         }
  598.         else {
  599.             say("%seversed (or previously applied) patch detected!  %s -R.\n",
  600.             reverse ? "R" : "Unr",
  601.             reverse ? "Assuming" : "Ignoring");
  602.         }
  603.         }
  604.         if (where == Null(LINENUM)) {
  605.         abort_hunk();
  606.         failed++;
  607.         if (verbose)
  608.             say("Hunk #%d failed.\n",hunk);
  609.         }
  610.         else {
  611.         apply_hunk(where);
  612.         if (verbose)
  613.             if (last_offset)
  614.             say("Hunk #%d succeeded (offset %d line%s).\n",
  615.               hunk,last_offset,last_offset==1?"":"s");
  616.             else
  617.             say("Hunk #%d succeeded.\n", hunk);
  618.         }
  619.     }
  620.     
  621.     assert(hunk);
  622.     
  623.     /* finish spewing out the new file */
  624.     spew_output();
  625.     
  626.     /* and put the output where desired */
  627.     ignore_signals();
  628.     move_file(TMPOUTNAME,outname);
  629.     Fclose(rejfp);
  630.     rejfp = Nullfp;
  631.     if (failed) {
  632.         if (!*rejname) {
  633.         Strcpy(rejname, outname);
  634.         Strcat(rejname, ".rej");
  635.         }
  636.         say("%d out of %d hunks failed--saving rejects to %s\n",
  637.         failed, hunk, rejname);
  638.         move_file(TMPREJNAME,rejname);
  639.     }
  640.     set_signals();
  641.     }
  642.     my_exit(0);
  643. }
  644.  
  645. reinitialize_almost_everything()
  646. {
  647.     re_patch();
  648.     re_input();
  649.  
  650.     input_lines = 0;
  651.     last_frozen_line = 0;
  652.  
  653.     filec = 0;
  654.     if (filearg[0] != Nullch) {
  655.     free(filearg[0]);
  656.     filearg[0] = Nullch;
  657.     }
  658.  
  659.     if (outname != Nullch) {
  660.     free(outname);
  661.     outname = Nullch;
  662.     }
  663.  
  664.     last_offset = 0;
  665.  
  666.     diff_type = 0;
  667.  
  668.     if (revision != Nullch) {
  669.     free(revision);
  670.     revision = Nullch;
  671.     }
  672.  
  673.     reverse = FALSE;
  674.  
  675.     get_some_switches();
  676.  
  677.     if (filec >= 2)
  678.     fatal("You may not change to a different patch file.\n");
  679. }
  680.  
  681. get_some_switches()
  682. {
  683.     register char *s;
  684.  
  685.     rejname[0] = '\0';
  686.     if (!Argc)
  687.     return;
  688.     for (Argc--,Argv++; Argc; Argc--,Argv++) {
  689.     s = Argv[0];
  690.     if (strEQ(s,"+")) {
  691.         return;            /* + will be skipped by for loop */
  692.     }
  693.     if (*s != '-' || !s[1]) {
  694.         if (filec == MAXFILEC)
  695.         fatal("Too many file arguments.\n");
  696.         filearg[filec++] = savestr(s);
  697.     }
  698.     else {
  699.         switch (*++s) {
  700.         case 'b':
  701.         origext = savestr(Argv[1]);
  702.         Argc--,Argv++;
  703.         break;
  704.         case 'c':
  705.         diff_type = CONTEXT_DIFF;
  706.         break;
  707.         case 'd':
  708.         if (chdir(Argv[1]) < 0)
  709.             fatal("Can't cd to %s.\n",Argv[1]);
  710.         Argc--,Argv++;
  711.         break;
  712.         case 'D':
  713.             do_defines++;
  714.         Sprintf(if_defined, "#ifdef %s\n", Argv[1]);
  715.         Sprintf(not_defined, "#ifndef %s\n", Argv[1]);
  716.         Sprintf(end_defined, "#endif %s\n", Argv[1]);
  717.         Argc--,Argv++;
  718.         break;
  719.         case 'e':
  720.         diff_type = ED_DIFF;
  721.         break;
  722.         case 'l':
  723.         canonicalize = TRUE;
  724.         break;
  725.         case 'n':
  726.         diff_type = NORMAL_DIFF;
  727.         break;
  728.         case 'o':
  729.         outname = savestr(Argv[1]);
  730.         Argc--,Argv++;
  731.         break;
  732.         case 'p':
  733.         usepath = TRUE;    /* do not strip path names */
  734.         break;
  735.         case 'r':
  736.         Strcpy(rejname,Argv[1]);
  737.         Argc--,Argv++;
  738.         break;
  739.         case 'R':
  740.         reverse = TRUE;
  741.         break;
  742.         case 's':
  743.         verbose = FALSE;
  744.         break;
  745. #ifdef DEBUGGING
  746.         case 'x':
  747.         debug = atoi(s+1);
  748.         break;
  749. #endif
  750.         default:
  751.         fatal("Unrecognized switch: %s\n",Argv[0]);
  752.         }
  753.     }
  754.     }
  755. }
  756.  
  757. LINENUM
  758. locate_hunk()
  759. {
  760.     register LINENUM first_guess = pch_first() + last_offset;
  761.     register LINENUM offset;
  762.     LINENUM pat_lines = pch_ptrn_lines();
  763.     register LINENUM max_pos_offset = input_lines - first_guess
  764.                 - pat_lines + 1; 
  765.     register LINENUM max_neg_offset = first_guess - last_frozen_line - 1
  766.                 - pch_context();
  767.  
  768.     if (!pat_lines)            /* null range matches always */
  769.     return first_guess;
  770.     if (max_neg_offset >= first_guess)    /* do not try lines < 0 */
  771.     max_neg_offset = first_guess - 1;
  772.     if (first_guess <= input_lines && patch_match(first_guess,(LINENUM)0))
  773.     return first_guess;
  774.     for (offset = 1; ; offset++) {
  775.     bool check_after = (offset <= max_pos_offset);
  776.     bool check_before = (offset <= max_pos_offset);
  777.  
  778.     if (check_after && patch_match(first_guess,offset)) {
  779. #ifdef DEBUGGING
  780.         if (debug & 1)
  781.         printf("Offset changing from %d to %d\n",last_offset,offset);
  782. #endif
  783.         last_offset = offset;
  784.         return first_guess+offset;
  785.     }
  786.     else if (check_before && patch_match(first_guess,-offset)) {
  787. #ifdef DEBUGGING
  788.         if (debug & 1)
  789.         printf("Offset changing from %d to %d\n",last_offset,-offset);
  790. #endif
  791.         last_offset = -offset;
  792.         return first_guess-offset;
  793.     }
  794.     else if (!check_before && !check_after)
  795.         return Null(LINENUM);
  796.     }
  797. }
  798.  
  799. /* we did not find the pattern, dump out the hunk so they can handle it */
  800.  
  801. abort_hunk()
  802. {
  803.     register LINENUM i;
  804.     register LINENUM pat_end = pch_end();
  805.     /* add in last_offset to guess the same as the previous successful hunk */
  806.     int oldfirst = pch_first() + last_offset;
  807.     int newfirst = pch_newfirst() + last_offset;
  808.     int oldlast = oldfirst + pch_ptrn_lines() - 1;
  809.     int newlast = newfirst + pch_repl_lines() - 1;
  810.  
  811.     fprintf(rejfp,"***************\n");
  812.     for (i=0; i<=pat_end; i++) {
  813.     switch (pch_char(i)) {
  814.     case '*':
  815.         fprintf(rejfp,"*** %d,%d\n", oldfirst, oldlast);
  816.         break;
  817.     case '=':
  818.         fprintf(rejfp,"--- %d,%d -----\n", newfirst, newlast);
  819.         break;
  820.     case '\n':
  821.         fprintf(rejfp,"%s", pfetch(i));
  822.         break;
  823.     case ' ': case '-': case '+': case '!':
  824.         fprintf(rejfp,"%c %s", pch_char(i), pfetch(i));
  825.         break;
  826.     default:
  827.         say("Fatal internal error in abort_hunk().\n"); 
  828.         abort();
  829.     }
  830.     }
  831. }
  832.  
  833. /* we found where to apply it (we hope), so do it */
  834.  
  835. apply_hunk(where)
  836. LINENUM where;
  837. {
  838.     register LINENUM old = 1;
  839.     register LINENUM lastline = pch_ptrn_lines();
  840.     register LINENUM new = lastline+1;
  841.     register int def_state = 0;    /* -1 = ifndef, 1 = ifdef */
  842.  
  843.     where--;
  844.     while (pch_char(new) == '=' || pch_char(new) == '\n')
  845.     new++;
  846.     
  847.     while (old <= lastline) {
  848.     if (pch_char(old) == '-') {
  849.         copy_till(where + old - 1);
  850.         if (do_defines) {
  851.         if (def_state == 0) {
  852.             fputs(not_defined, ofp);
  853.             def_state = -1;
  854.         } else
  855.         if (def_state == 1) {
  856.             fputs(else_defined, ofp);
  857.             def_state = 2;
  858.         }
  859.         fputs(pfetch(old), ofp);
  860.         }
  861.         last_frozen_line++;
  862.         old++;
  863.     }
  864.     else if (pch_char(new) == '+') {
  865.         copy_till(where + old - 1);
  866.         if (do_defines) {
  867.         if (def_state == -1) {
  868.             fputs(else_defined, ofp);
  869.             def_state = 2;
  870.         } else
  871.         if (def_state == 0) {
  872.             fputs(if_defined, ofp);
  873.             def_state = 1;
  874.         }
  875.         }
  876.         fputs(pfetch(new),ofp);
  877.         new++;
  878.     }
  879.     else {
  880.         if (pch_char(new) != pch_char(old)) {
  881.         say("Out-of-sync patch, lines %d,%d\n",
  882.             pch_hunk_beg() + old - 1,
  883.             pch_hunk_beg() + new - 1);
  884. #ifdef DEBUGGING
  885.         printf("oldchar = '%c', newchar = '%c'\n",
  886.             pch_char(old), pch_char(new));
  887. #endif
  888.         my_exit(1);
  889.         }
  890.         if (pch_char(new) == '!') {
  891.         copy_till(where + old - 1);
  892.         if (do_defines) {
  893.            fputs(not_defined,ofp);
  894.            def_state = -1;
  895.         }
  896.         while (pch_char(old) == '!') {
  897.             if (do_defines) {
  898.             fputs(pfetch(old),ofp);
  899.             }
  900.             last_frozen_line++;
  901.             old++;
  902.         }
  903.         if (do_defines) {
  904.             fputs(else_defined, ofp);
  905.             def_state = 2;
  906.         }
  907.         while (pch_char(new) == '!') {
  908.             fputs(pfetch(new),ofp);
  909.             new++;
  910.         }
  911.         if (do_defines) {
  912.             fputs(end_defined, ofp);
  913.             def_state = 0;
  914.         }
  915.         }
  916.         else {
  917.         assert(pch_char(new) == ' ');
  918.         old++;
  919.         new++;
  920.         }
  921.     }
  922.     }
  923.     if (new <= pch_end() && pch_char(new) == '+') {
  924.     copy_till(where + old - 1);
  925.     if (do_defines) {
  926.         if (def_state == 0) {
  927.             fputs(if_defined, ofp);
  928.         def_state = 1;
  929.         } else
  930.         if (def_state == -1) {
  931.         fputs(else_defined, ofp);
  932.         def_state = 2;
  933.         }
  934.     }
  935.     while (new <= pch_end() && pch_char(new) == '+') {
  936.         fputs(pfetch(new),ofp);
  937.         new++;
  938.     }
  939.     }
  940.     if (do_defines && def_state) {
  941.     fputs(end_defined, ofp);
  942.     }
  943. }
  944.  
  945. do_ed_script()
  946. {
  947.     FILE *pipefp, *popen();
  948.     bool this_line_is_command = FALSE;
  949.     register char *t;
  950.     long beginning_of_this_line;
  951.  
  952.     Unlink(TMPOUTNAME);
  953.     copy_file(filearg[0],TMPOUTNAME);
  954.     if (verbose)
  955.     Sprintf(buf,"/bin/ed %s",TMPOUTNAME);
  956.     else
  957.     Sprintf(buf,"/bin/ed - %s",TMPOUTNAME);
  958.     pipefp = popen(buf,"w");
  959.     for (;;) {
  960.     beginning_of_this_line = ftell(pfp);
  961.     if (pgets(buf,sizeof buf,pfp) == Nullch) {
  962.         next_intuit_at(beginning_of_this_line);
  963.         break;
  964.     }
  965.     for (t=buf; isdigit(*t) || *t == ','; t++) ;
  966.     this_line_is_command = (isdigit(*buf) &&
  967.       (*t == 'd' || *t == 'c' || *t == 'a') );
  968.     if (this_line_is_command) {
  969.         fputs(buf,pipefp);
  970.         if (*t != 'd') {
  971.         while (pgets(buf,sizeof buf,pfp) != Nullch) {
  972.             fputs(buf,pipefp);
  973.             if (strEQ(buf,".\n"))
  974.             break;
  975.         }
  976.         }
  977.     }
  978.     else {
  979.         next_intuit_at(beginning_of_this_line);
  980.         break;
  981.     }
  982.     }
  983.     fprintf(pipefp,"w\n");
  984.     fprintf(pipefp,"q\n");
  985.     Fflush(pipefp);
  986.     Pclose(pipefp);
  987.     ignore_signals();
  988.     move_file(TMPOUTNAME,outname);
  989.     set_signals();
  990. }
  991.  
  992. init_output(name)
  993. char *name;
  994. {
  995.     ofp = fopen(name,"w");
  996.     if (ofp == Nullfp)
  997.     fatal("patch: can't create %s.\n",name);
  998. }
  999.  
  1000. init_reject(name)
  1001. char *name;
  1002. {
  1003.     rejfp = fopen(name,"w");
  1004.     if (rejfp == Nullfp)
  1005.     fatal("patch: can't create %s.\n",name);
  1006. }
  1007.  
  1008. move_file(from,to)
  1009. char *from, *to;
  1010. {
  1011.     char bakname[512];
  1012.     register char *s;
  1013.     int fromfd;
  1014.     register int i;
  1015.  
  1016.     /* to stdout? */
  1017.  
  1018.     if (strEQ(to,"-")) {
  1019. #ifdef DEBUGGING
  1020.     if (debug & 4)
  1021.         say("Moving %s to stdout.\n",from);
  1022. #endif
  1023.     fromfd = open(from,0);
  1024.     if (fromfd < 0)
  1025.         fatal("patch: internal error, can't reopen %s\n",from);
  1026.     while ((i=read(fromfd,buf,sizeof buf)) > 0)
  1027.         if (write(1,buf,i) != 1)
  1028.         fatal("patch: write failed\n");
  1029.     Close(fromfd);
  1030.     return;
  1031.     }
  1032.  
  1033.     Strcpy(bakname,to);
  1034.     Strcat(bakname,origext?origext:ORIGEXT);
  1035.     if (stat(to,&filestat) >= 0) {    /* output file exists */
  1036.     dev_t to_device = filestat.st_dev;
  1037.     ino_t to_inode  = filestat.st_ino;
  1038.     char *simplename = bakname;
  1039.     
  1040.     for (s=bakname; *s; s++) {
  1041.         if (*s == '/')
  1042.         simplename = s+1;
  1043.     }
  1044.     /* find a backup name that is not the same file */
  1045.     while (stat(bakname,&filestat) >= 0 &&
  1046.         to_device == filestat.st_dev && to_inode == filestat.st_ino) {
  1047.         for (s=simplename; *s && !islower(*s); s++) ;
  1048.         if (*s)
  1049.         *s = toupper(*s);
  1050.         else
  1051.         Strcpy(simplename, simplename+1);
  1052.     }
  1053.     while (unlink(bakname) >= 0) ;    /* while() is for benefit of Eunice */
  1054. #ifdef DEBUGGING
  1055.     if (debug & 4)
  1056.         say("Moving %s to %s.\n",to,bakname);
  1057. #endif
  1058.     if (link(to,bakname) < 0) {
  1059.         say("patch: can't backup %s, output is in %s\n",
  1060.         to,from);
  1061.         return;
  1062.     }
  1063.     while (unlink(to) >= 0) ;
  1064.     }
  1065. #ifdef DEBUGGING
  1066.     if (debug & 4)
  1067.     say("Moving %s to %s.\n",from,to);
  1068. #endif
  1069.     if (link(from,to) < 0) {        /* different file system? */
  1070.     int tofd;
  1071.     
  1072.     tofd = creat(to,0666);
  1073.     if (tofd < 0) {
  1074.         say("patch: can't create %s, output is in %s.\n",
  1075.           to, from);
  1076.         return;
  1077.     }
  1078.     fromfd = open(from,0);
  1079.     if (fromfd < 0)
  1080.         fatal("patch: internal error, can't reopen %s\n",from);
  1081.     while ((i=read(fromfd,buf,sizeof buf)) > 0)
  1082.         if (write(tofd,buf,i) != i)
  1083.         fatal("patch: write failed\n");
  1084.     Close(fromfd);
  1085.     Close(tofd);
  1086.     }
  1087.     Unlink(from);
  1088. }
  1089.  
  1090. copy_file(from,to)
  1091. char *from, *to;
  1092. {
  1093.     int tofd;
  1094.     int fromfd;
  1095.     register int i;
  1096.     
  1097.     tofd = creat(to,0666);
  1098.     if (tofd < 0)
  1099.     fatal("patch: can't create %s.\n", to);
  1100.     fromfd = open(from,0);
  1101.     if (fromfd < 0)
  1102.     fatal("patch: internal error, can't reopen %s\n",from);
  1103.     while ((i=read(fromfd,buf,sizeof buf)) > 0)
  1104.     if (write(tofd,buf,i) != i)
  1105.         fatal("patch: write (%s) failed\n", to);
  1106.     Close(fromfd);
  1107.     Close(tofd);
  1108. }
  1109.  
  1110. copy_till(lastline)
  1111. register LINENUM lastline;
  1112. {
  1113.     if (last_frozen_line > lastline)
  1114.     say("patch: misordered hunks! output will be garbled.\n");
  1115.     while (last_frozen_line < lastline) {
  1116.     dump_line(++last_frozen_line);
  1117.     }
  1118. }
  1119.  
  1120. spew_output()
  1121. {
  1122.     copy_till(input_lines);        /* dump remainder of file */
  1123.     Fclose(ofp);
  1124.     ofp = Nullfp;
  1125. }
  1126.  
  1127. dump_line(line)
  1128. LINENUM line;
  1129. {
  1130.     register char *s;
  1131.  
  1132.     for (s=ifetch(line,0); putc(*s,ofp) != '\n'; s++) ;
  1133. }
  1134.  
  1135. /* does the patch pattern match at line base+offset? */
  1136.  
  1137. bool
  1138. patch_match(base,offset)
  1139. LINENUM base;
  1140. LINENUM offset;
  1141. {
  1142.     register LINENUM pline;
  1143.     register LINENUM iline;
  1144.     register LINENUM pat_lines = pch_ptrn_lines();
  1145.  
  1146.     for (pline = 1, iline=base+offset; pline <= pat_lines; pline++,iline++) {
  1147.     if (canonicalize) {
  1148.         if (!similar(ifetch(iline,(offset >= 0)),
  1149.              pfetch(pline),
  1150.              pch_line_len(pline) ))
  1151.         return FALSE;
  1152.     }
  1153.     else if (strnNE(ifetch(iline,(offset >= 0)),
  1154.            pfetch(pline),
  1155.            pch_line_len(pline) ))
  1156.         return FALSE;
  1157.     }
  1158.     return TRUE;
  1159. }
  1160.  
  1161. /* match two lines with canonicalized white space */
  1162.  
  1163. bool
  1164. similar(a,b,len)
  1165. register char *a, *b;
  1166. register int len;
  1167. {
  1168.     while (len) {
  1169.     if (isspace(*b)) {        /* whitespace (or \n) to match? */
  1170.         if (!isspace(*a))        /* no corresponding whitespace? */
  1171.         return FALSE;
  1172.         while (len && isspace(*b) && *b != '\n')
  1173.         b++,len--;        /* skip pattern whitespace */
  1174.         while (isspace(*a) && *a != '\n')
  1175.         a++;            /* skip target whitespace */
  1176.         if (*a == '\n' || *b == '\n')
  1177.         return (*a == *b);    /* should end in sync */
  1178.     }
  1179.     else if (*a++ != *b++)        /* match non-whitespace chars */
  1180.         return FALSE;
  1181.     else
  1182.         len--;            /* probably not necessary */
  1183.     }
  1184.     return TRUE;            /* actually, this is not reached */
  1185.                     /* since there is always a \n */
  1186. }
  1187.  
  1188. /* input file with indexable lines abstract type */
  1189.  
  1190. bool using_plan_a = TRUE;
  1191. static long i_size;            /* size of the input file */
  1192. static char *i_womp;            /* plan a buffer for entire file */
  1193. static char **i_ptr;            /* pointers to lines in i_womp */
  1194.  
  1195. static int tifd = -1;            /* plan b virtual string array */
  1196. static char *tibuf[2];            /* plan b buffers */
  1197. static LINENUM tiline[2] = {-1,-1};    /* 1st line in each buffer */
  1198. static LINENUM lines_per_buf;        /* how many lines per buffer */
  1199. static int tireclen;            /* length of records in tmp file */
  1200.  
  1201. re_input()
  1202. {
  1203.     if (using_plan_a) {
  1204.     i_size = 0;
  1205.     /*NOSTRICT*/
  1206.     if (i_ptr != Null(char**))
  1207.         free((char *)i_ptr);
  1208.     if (i_womp != Nullch)
  1209.         free(i_womp);
  1210.     i_womp = Nullch;
  1211.     i_ptr = Null(char **);
  1212.     }
  1213.     else {
  1214.     using_plan_a = TRUE;        /* maybe the next one is smaller */
  1215.     Close(tifd);
  1216.     tifd = -1;
  1217.     free(tibuf[0]);
  1218.     free(tibuf[1]);
  1219.     tibuf[0] = tibuf[1] = Nullch;
  1220.     tiline[0] = tiline[1] = -1;
  1221.     tireclen = 0;
  1222.     }
  1223. }
  1224.  
  1225. scan_input(filename)
  1226. char *filename;
  1227. {
  1228.     bool plan_a();
  1229.  
  1230.     if (!plan_a(filename))
  1231.     plan_b(filename);
  1232. }
  1233.  
  1234. /* try keeping everything in memory */
  1235.  
  1236. bool
  1237. plan_a(filename)
  1238. char *filename;
  1239. {
  1240.     int ifd;
  1241.     register char *s;
  1242.     register LINENUM iline;
  1243.  
  1244.     if (stat(filename,&filestat) < 0) {
  1245.     Sprintf(buf,"RCS/%s%s",filename,RCSSUFFIX);
  1246.     if (stat(buf,&filestat) >= 0 || stat(buf+4,&filestat) >= 0) {
  1247.         Sprintf(buf,CHECKOUT,filename);
  1248.         if (verbose)
  1249.         say("Can't find %s--attempting to check it out from RCS.\n",
  1250.             filename);
  1251.         if (system(buf) || stat(filename,&filestat))
  1252.         fatal("Can't check out %s.\n",filename);
  1253.     }
  1254.     else {
  1255.         Sprintf(buf,"SCCS/%s%s",SCCSPREFIX,filename);
  1256.         if (stat(buf,&filestat) >= 0 || stat(buf+5,&filestat) >= 0) {
  1257.         Sprintf(buf,GET,filename);
  1258.         if (verbose)
  1259.             say("Can't find %s--attempting to get it from SCCS.\n",
  1260.             filename);
  1261.         if (system(buf) || stat(filename,&filestat))
  1262.             fatal("Can't get %s.\n",filename);
  1263.         }
  1264.         else
  1265.         fatal("Can't find %s.\n",filename);
  1266.     }
  1267.     }
  1268.     if ((filestat.st_mode & S_IFMT) & ~S_IFREG)
  1269.     fatal("%s is not a normal file--can't patch.\n",filename);
  1270.     i_size = filestat.st_size;
  1271.     /*NOSTRICT*/
  1272.     i_womp = malloc((MEM)(i_size+2));
  1273.     if (i_womp == Nullch)
  1274.     return FALSE;
  1275.     if ((ifd = open(filename,0)) < 0)
  1276.     fatal("Can't open file %s\n",filename);
  1277.     /*NOSTRICT*/
  1278.     if (read(ifd,i_womp,(int)i_size) != i_size) {
  1279.     Close(ifd);
  1280.     free(i_womp);
  1281.     return FALSE;
  1282.     }
  1283.     Close(ifd);
  1284.     if (i_womp[i_size-1] != '\n')
  1285.     i_womp[i_size++] = '\n';
  1286.     i_womp[i_size] = '\0';
  1287.  
  1288.     /* count the lines in the buffer so we know how many pointers we need */
  1289.  
  1290.     iline = 0;
  1291.     for (s=i_womp; *s; s++) {
  1292.     if (*s == '\n')
  1293.         iline++;
  1294.     }
  1295.     /*NOSTRICT*/
  1296.     i_ptr = (char **)malloc((MEM)((iline + 2) * sizeof(char *)));
  1297.     if (i_ptr == Null(char **)) {    /* shucks, it was a near thing */
  1298.     free((char *)i_womp);
  1299.     return FALSE;
  1300.     }
  1301.     
  1302.     /* now scan the buffer and build pointer array */
  1303.  
  1304.     iline = 1;
  1305.     i_ptr[iline] = i_womp;
  1306.     for (s=i_womp; *s; s++) {
  1307.     if (*s == '\n')
  1308.         i_ptr[++iline] = s+1;    /* these are NOT null terminated */
  1309.     }
  1310.     input_lines = iline - 1;
  1311.  
  1312.     /* now check for revision, if any */
  1313.  
  1314.     if (revision != Nullch) { 
  1315.     if (!rev_in_string(i_womp)) {
  1316.         ask("This file doesn't appear to be the %s version--patch anyway? [n] ",
  1317.         revision);
  1318.         if (*buf != 'y')
  1319.         fatal("Aborted.\n");
  1320.     }
  1321.     else if (verbose)
  1322.         say("Good.  This file appears to be the %s version.\n",
  1323.         revision);
  1324.     }
  1325.     return TRUE;            /* plan a will work */
  1326. }
  1327.  
  1328. /* keep (virtually) nothing in memory */
  1329.  
  1330. plan_b(filename)
  1331. char *filename;
  1332. {
  1333.     FILE *ifp;
  1334.     register int i = 0;
  1335.     register int maxlen = 1;
  1336.     bool found_revision = (revision == Nullch);
  1337.  
  1338.     using_plan_a = FALSE;
  1339.     if ((ifp = fopen(filename,"r")) == Nullfp)
  1340.     fatal("Can't open file %s\n",filename);
  1341.     if ((tifd = creat(TMPINNAME,0666)) < 0)
  1342.     fatal("Can't open file %s\n",TMPINNAME);
  1343.     while (fgets(buf,sizeof buf, ifp) != Nullch) {
  1344.     if (revision != Nullch && !found_revision && rev_in_string(buf))
  1345.         found_revision = TRUE;
  1346.     if ((i = strlen(buf)) > maxlen)
  1347.         maxlen = i;            /* find longest line */
  1348.     }
  1349.     if (revision != Nullch) {
  1350.     if (!found_revision) {
  1351.         ask("This file doesn't appear to be the %s version--patch anyway? [n] ",
  1352.         revision);
  1353.         if (*buf != 'y')
  1354.         fatal("Aborted.\n");
  1355.     }
  1356.     else if (verbose)
  1357.         say("Good.  This file appears to be the %s version.\n",
  1358.         revision);
  1359.     }
  1360.     Fseek(ifp,0L,0);        /* rewind file */
  1361.     lines_per_buf = BUFFERSIZE / maxlen;
  1362.     tireclen = maxlen;
  1363.     tibuf[0] = malloc((MEM)(BUFFERSIZE + 1));
  1364.     tibuf[1] = malloc((MEM)(BUFFERSIZE + 1));
  1365.     if (tibuf[1] == Nullch)
  1366.     fatal("Can't seem to get enough memory.\n");
  1367.     for (i=1; ; i++) {
  1368.     if (! (i % lines_per_buf))    /* new block */
  1369.         if (write(tifd,tibuf[0],BUFFERSIZE) < BUFFERSIZE)
  1370.         fatal("patch: can't write temp file.\n");
  1371.     if (fgets(tibuf[0] + maxlen * (i%lines_per_buf), maxlen + 1, ifp)
  1372.       == Nullch) {
  1373.         input_lines = i - 1;
  1374.         if (i % lines_per_buf)
  1375.         if (write(tifd,tibuf[0],BUFFERSIZE) < BUFFERSIZE)
  1376.             fatal("patch: can't write temp file.\n");
  1377.         break;
  1378.     }
  1379.     }
  1380.     Fclose(ifp);
  1381.     Close(tifd);
  1382.     if ((tifd = open(TMPINNAME,0)) < 0) {
  1383.     fatal("Can't reopen file %s\n",TMPINNAME);
  1384.     }
  1385. }
  1386.  
  1387. /* fetch a line from the input file, \n terminated, not necessarily \0 */
  1388. char *
  1389. ifetch(line,whichbuf)
  1390. register LINENUM line;
  1391. int whichbuf;                /* ignored when file in memory */
  1392. {
  1393.     if (line < 1 || line > input_lines)
  1394.     return "";
  1395.     if (using_plan_a)
  1396.     return i_ptr[line];
  1397.     else {
  1398.     LINENUM offline = line % lines_per_buf;
  1399.     LINENUM baseline = line - offline;
  1400.  
  1401.     if (tiline[0] == baseline)
  1402.         whichbuf = 0;
  1403.     else if (tiline[1] == baseline)
  1404.         whichbuf = 1;
  1405.     else {
  1406.         tiline[whichbuf] = baseline;
  1407.         Lseek(tifd,(long)baseline / lines_per_buf * BUFFERSIZE,0);
  1408.         if (read(tifd,tibuf[whichbuf],BUFFERSIZE) < 0)
  1409.         fatal("Error reading tmp file %s.\n",TMPINNAME);
  1410.     }
  1411.     return tibuf[whichbuf] + (tireclen*offline);
  1412.     }
  1413. }
  1414.  
  1415. /* patch abstract type */
  1416.  
  1417. static long p_filesize;            /* size of the patch file */
  1418. static LINENUM p_first;            /* 1st line number */
  1419. static LINENUM p_newfirst;        /* 1st line number of replacement */
  1420. static LINENUM p_ptrn_lines;        /* # lines in pattern */
  1421. static LINENUM p_repl_lines;        /* # lines in replacement text */
  1422. static LINENUM p_end = -1;        /* last line in hunk */
  1423. static LINENUM p_max;            /* max allowed value of p_end */
  1424. static LINENUM p_context = 3;        /* # of context lines */
  1425. static LINENUM p_input_line = 0;    /* current line # from patch file */
  1426. static char *p_line[MAXHUNKSIZE];    /* the text of the hunk */
  1427. static char p_char[MAXHUNKSIZE];    /* +, -, and ! */
  1428. static int p_len[MAXHUNKSIZE];        /* length of each line */
  1429. static int p_indent;            /* indent to patch */
  1430. static long p_base;            /* where to intuit this time */
  1431. static long p_start;            /* where intuit found a patch */
  1432.  
  1433. re_patch()
  1434. {
  1435.     p_first = (LINENUM)0;
  1436.     p_newfirst = (LINENUM)0;
  1437.     p_ptrn_lines = (LINENUM)0;
  1438.     p_repl_lines = (LINENUM)0;
  1439.     p_end = (LINENUM)-1;
  1440.     p_max = (LINENUM)0;
  1441.     p_indent = 0;
  1442. }
  1443.  
  1444. open_patch_file(filename)
  1445. char *filename;
  1446. {
  1447.     if (filename == Nullch || !*filename || strEQ(filename,"-")) {
  1448.     pfp = fopen(TMPPATNAME,"w");
  1449.     if (pfp == Nullfp)
  1450.         fatal("patch: can't create %s.\n",TMPPATNAME);
  1451.     while (fgets(buf,sizeof buf,stdin) != NULL)
  1452.         fputs(buf,pfp);
  1453.     Fclose(pfp);
  1454.     filename = TMPPATNAME;
  1455.     }
  1456.     pfp = fopen(filename,"r");
  1457.     if (pfp == Nullfp)
  1458.     fatal("patch file %s not found\n",filename);
  1459.     Fstat(fileno(pfp), &filestat);
  1460.     p_filesize = filestat.st_size;
  1461.     next_intuit_at(0L);            /* start at the beginning */
  1462. }
  1463.  
  1464. bool
  1465. there_is_another_patch()
  1466. {
  1467.     bool no_input_file = (filearg[0] == Nullch);
  1468.     
  1469.     if (p_base != 0L && p_base >= p_filesize) {
  1470.     if (verbose)
  1471.         say("done\n");
  1472.     return FALSE;
  1473.     }
  1474.     if (verbose)
  1475.     say("Hmm...");
  1476.     diff_type = intuit_diff_type();
  1477.     if (!diff_type) {
  1478.     if (p_base != 0L) {
  1479.         if (verbose)
  1480.         say("  Ignoring the trailing garbage.\ndone\n");
  1481.     }
  1482.     else
  1483.         say("  I can't seem to find a patch in there anywhere.\n");
  1484.     return FALSE;
  1485.     }
  1486.     if (verbose)
  1487.     say("  %sooks like %s to me...\n",
  1488.         (p_base == 0L ? "L" : "The next patch l"),
  1489.         diff_type == CONTEXT_DIFF ? "a context diff" :
  1490.         diff_type == NORMAL_DIFF ? "a normal diff" :
  1491.         "an ed script" );
  1492.     if (p_indent && verbose)
  1493.     say("(Patch is indented %d space%s.)\n",p_indent,p_indent==1?"":"s");
  1494.     skip_to(p_start);
  1495.     if (no_input_file) {
  1496.     if (filearg[0] == Nullch) {
  1497.         ask("File to patch: ");
  1498.         filearg[0] = fetchname(buf);
  1499.     }
  1500.     else if (verbose) {
  1501.         say("Patching file %s...\n",filearg[0]);
  1502.     }
  1503.     }
  1504.     return TRUE;
  1505. }
  1506.  
  1507. intuit_diff_type()
  1508. {
  1509.     long this_line = 0;
  1510.     long previous_line;
  1511.     long first_command_line = -1;
  1512.     bool last_line_was_command = FALSE;
  1513.     bool this_line_is_command = FALSE;
  1514.     register int indent;
  1515.     register char *s, *t;
  1516.     char *oldname = Nullch;
  1517.     char *newname = Nullch;
  1518.     bool no_filearg = (filearg[0] == Nullch);
  1519.  
  1520.     Fseek(pfp,p_base,0);
  1521.     for (;;) {
  1522.     previous_line = this_line;
  1523.     last_line_was_command = this_line_is_command;
  1524.     this_line = ftell(pfp);
  1525.     indent = 0;
  1526.     if (fgets(buf,sizeof buf,pfp) == Nullch) {
  1527.         if (first_command_line >= 0L) {
  1528.                     /* nothing but deletes!? */
  1529.         p_start = first_command_line;
  1530.         return ED_DIFF;
  1531.         }
  1532.         else {
  1533.         p_start = this_line;
  1534.         return 0;
  1535.         }
  1536.     }
  1537.     for (s = buf; *s == ' ' || *s == '\t'; s++) {
  1538.         if (*s == '\t')
  1539.         indent += 8 - (indent % 8);
  1540.         else
  1541.         indent++;
  1542.     }
  1543.     for (t=s; isdigit(*t) || *t == ','; t++) ; 
  1544.     this_line_is_command = (isdigit(*s) &&
  1545.       (*t == 'd' || *t == 'c' || *t == 'a') );
  1546.     if (first_command_line < 0L && this_line_is_command) { 
  1547.         first_command_line = this_line;
  1548.         p_indent = indent;        /* assume this for now */
  1549.     }
  1550.     if (strnEQ(s,"*** ",4))
  1551.         oldname = fetchname(s+4);
  1552.     else if (strnEQ(s,"--- ",4)) {
  1553.         newname = fetchname(s+4);
  1554.         if (no_filearg) {
  1555.         if (oldname && newname) {
  1556.             if (strlen(oldname) < strlen(newname))
  1557.             filearg[0] = oldname;
  1558.             else
  1559.             filearg[0] = newname;
  1560.         }
  1561.         else if (oldname)
  1562.             filearg[0] = oldname;
  1563.         else if (newname)
  1564.             filearg[0] = newname;
  1565.         }
  1566.     }
  1567.     else if (strnEQ(s,"Index:",6)) {
  1568.         if (no_filearg) 
  1569.         filearg[0] = fetchname(s+6);
  1570.                     /* this filearg might get limboed */
  1571.     }
  1572.     else if (strnEQ(s,"Prereq:",7)) {
  1573.         for (t=s+7; isspace(*t); t++) ;
  1574.         revision = savestr(t);
  1575.         for (t=revision; *t && !isspace(*t); t++) ;
  1576.         *t = '\0';
  1577.         if (!*revision) {
  1578.         free(revision);
  1579.         revision = Nullch;
  1580.         }
  1581.     }
  1582.     if ((!diff_type || diff_type == ED_DIFF) &&
  1583.       first_command_line >= 0L &&
  1584.       strEQ(s,".\n") ) {
  1585.         p_indent = indent;
  1586.         p_start = first_command_line;
  1587.         return ED_DIFF;
  1588.     }
  1589.     if ((!diff_type || diff_type == CONTEXT_DIFF) &&
  1590.          strnEQ(s,"********",8)) {
  1591.         p_indent = indent;
  1592.         p_start = this_line;
  1593.         return CONTEXT_DIFF;
  1594.     }
  1595.     if ((!diff_type || diff_type == NORMAL_DIFF) && 
  1596.       last_line_was_command &&
  1597.       (strnEQ(s,"< ",2) || strnEQ(s,"> ",2)) ) {
  1598.         p_start = previous_line;
  1599.         p_indent = indent;
  1600.         return NORMAL_DIFF;
  1601.     }
  1602.     }
  1603. }
  1604.  
  1605. char *
  1606. fetchname(at)
  1607. char *at;
  1608. {
  1609.     char *s = savestr(at);
  1610.     char *name;
  1611.     register char *t;
  1612.     char tmpbuf[200];
  1613.  
  1614.     for (t=s; isspace(*t); t++) ;
  1615.     name = t;
  1616.     for (; *t && !isspace(*t); t++)
  1617.     if (!usepath)
  1618.         if (*t == '/')
  1619.         name = t+1;
  1620.     *t = '\0';
  1621.     name = savestr(name);
  1622.     Sprintf(tmpbuf,"RCS/%s",name);
  1623.     free(s);
  1624.     if (stat(name,&filestat) < 0) {
  1625.     Strcat(tmpbuf,RCSSUFFIX);
  1626.     if (stat(tmpbuf,&filestat) < 0 && stat(tmpbuf+4,&filestat) < 0) {
  1627.         Sprintf(tmpbuf,"SCCS/%s%s",SCCSPREFIX,name);
  1628.         if (stat(tmpbuf,&filestat) < 0 && stat(tmpbuf+5,&filestat) < 0) {
  1629.         free(name);
  1630.         name = Nullch;
  1631.         }
  1632.     }
  1633.     }
  1634.     return name;
  1635. }
  1636.  
  1637. next_intuit_at(file_pos)
  1638. long file_pos;
  1639. {
  1640.     p_base = file_pos;
  1641. }
  1642.  
  1643. skip_to(file_pos)
  1644. long file_pos;
  1645. {
  1646.     char *ret;
  1647.  
  1648.     assert(p_base <= file_pos);
  1649.     if (verbose && p_base < file_pos) {
  1650.     Fseek(pfp,p_base,0);
  1651.     say("The text leading up to this was:\n--------------------------\n");
  1652.     while (ftell(pfp) < file_pos) {
  1653.         ret = fgets(buf,sizeof buf,pfp);
  1654.         assert(ret != Nullch);
  1655.         say("|%s",buf);
  1656.     }
  1657.     say("--------------------------\n");
  1658.     }
  1659.     else
  1660.     Fseek(pfp,file_pos,0);
  1661. }
  1662.  
  1663. bool
  1664. another_hunk()
  1665. {
  1666.     register char *s;
  1667.     char *ret;
  1668.     int context = 0;
  1669.  
  1670.     while (p_end >= 0) {
  1671.     free(p_line[p_end--]);
  1672.     }
  1673.     assert(p_end == -1);
  1674.  
  1675.     p_max = MAXHUNKSIZE;        /* gets reduced when --- found */
  1676.     if (diff_type == CONTEXT_DIFF) {
  1677.     long line_beginning = ftell(pfp);
  1678.     LINENUM repl_beginning = 0;
  1679.  
  1680.     ret = pgets(buf,sizeof buf, pfp);
  1681.     if (ret == Nullch || strnNE(buf,"********",8)) {
  1682.         next_intuit_at(line_beginning);
  1683.         return FALSE;
  1684.     }
  1685.     p_context = 100;
  1686.     while (p_end < p_max) {
  1687.         ret = pgets(buf,sizeof buf, pfp);
  1688.         if (ret == Nullch) {
  1689.         if (p_max - p_end < 4)
  1690.             Strcpy(buf,"  \n");    /* assume blank lines got chopped */
  1691.         else
  1692.             fatal("Unexpected end of file in patch.\n");
  1693.         }
  1694.         p_input_line++;
  1695.         if (strnEQ(buf,"********",8))
  1696.         fatal("Unexpected end of hunk at line %d.\n",
  1697.             p_input_line);
  1698.         p_char[++p_end] = *buf;
  1699.         switch (*buf) {
  1700.         case '*':
  1701.         if (p_end != 0)
  1702.             fatal("Unexpected *** at line %d: %s", p_input_line, buf);
  1703.         context = 0;
  1704.         p_line[p_end] = savestr(buf);
  1705.         for (s=buf; *s && !isdigit(*s); s++) ;
  1706.         p_first = (LINENUM) atol(s);
  1707.         while (isdigit(*s)) s++;
  1708.         for (; *s && !isdigit(*s); s++) ;
  1709.         p_ptrn_lines = ((LINENUM)atol(s)) - p_first + 1;
  1710.         break;
  1711.         case '-':
  1712.         if (buf[1] == '-') {
  1713.             if (p_end != p_ptrn_lines + 1 &&
  1714.             p_end != p_ptrn_lines + 2)
  1715.             fatal("Unexpected --- at line %d: %s",
  1716.                 p_input_line,buf);
  1717.             repl_beginning = p_end;
  1718.             context = 0;
  1719.             p_line[p_end] = savestr(buf);
  1720.             p_char[p_end] = '=';
  1721.             for (s=buf; *s && !isdigit(*s); s++) ;
  1722.             p_newfirst = (LINENUM) atol(s);
  1723.             while (isdigit(*s)) s++;
  1724.             for (; *s && !isdigit(*s); s++) ;
  1725.             p_max = ((LINENUM)atol(s)) - p_newfirst + 1 + p_end;
  1726.             break;
  1727.         }
  1728.         /* FALL THROUGH */
  1729.         case '+': case '!':
  1730.         if (context > 0) {
  1731.             if (context < p_context)
  1732.             p_context = context;
  1733.             context = -100;
  1734.         }
  1735.         p_line[p_end] = savestr(buf+2);
  1736.         break;
  1737.         case '\t': case '\n':    /* assume the 2 spaces got eaten */
  1738.         p_line[p_end] = savestr(buf);
  1739.         if (p_end != p_ptrn_lines + 1) {
  1740.             context++;
  1741.             p_char[p_end] = ' ';
  1742.         }
  1743.         break;
  1744.         case ' ':
  1745.         context++;
  1746.         p_line[p_end] = savestr(buf+2);
  1747.         break;
  1748.         default:
  1749.         fatal("Malformed patch at line %d: %s",p_input_line,buf);
  1750.         }
  1751.         p_len[p_end] = strlen(p_line[p_end]);
  1752.                     /* for strncmp() so we do not have */
  1753.                     /* to assume null termination */
  1754.     }
  1755.     if (p_end >=0 && !p_ptrn_lines)
  1756.         fatal("No --- found in patch at line %d\n", pch_hunk_beg());
  1757.     p_repl_lines = p_end - repl_beginning;
  1758.     }
  1759.     else {                /* normal diff--fake it up */
  1760.     char hunk_type;
  1761.     register int i;
  1762.     LINENUM min, max;
  1763.     long line_beginning = ftell(pfp);
  1764.  
  1765.     p_context = 0;
  1766.     ret = pgets(buf,sizeof buf, pfp);
  1767.     p_input_line++;
  1768.     if (ret == Nullch || !isdigit(*buf)) {
  1769.         next_intuit_at(line_beginning);
  1770.         return FALSE;
  1771.     }
  1772.     p_first = (LINENUM)atol(buf);
  1773.     for (s=buf; isdigit(*s); s++) ;
  1774.     if (*s == ',') {
  1775.         p_ptrn_lines = (LINENUM)atol(++s) - p_first + 1;
  1776.         while (isdigit(*s)) s++;
  1777.     }
  1778.     else
  1779.         p_ptrn_lines = (*s != 'a');
  1780.     hunk_type = *s;
  1781.     if (hunk_type == 'a')
  1782.         p_first++;            /* do append rather than insert */
  1783.     min = (LINENUM)atol(++s);
  1784.     for (; isdigit(*s); s++) ;
  1785.     if (*s == ',')
  1786.         max = (LINENUM)atol(++s);
  1787.     else
  1788.         max = min;
  1789.     if (hunk_type == 'd')
  1790.         min++;
  1791.     p_end = p_ptrn_lines + 1 + max - min + 1;
  1792.     p_newfirst = min;
  1793.     p_repl_lines = max - min + 1;
  1794.     Sprintf(buf,"*** %d,%d\n", p_first, p_first + p_ptrn_lines - 1);
  1795.     p_line[0] = savestr(buf);
  1796.     p_char[0] = '*';
  1797.     for (i=1; i<=p_ptrn_lines; i++) {
  1798.         ret = pgets(buf,sizeof buf, pfp);
  1799.         p_input_line++;
  1800.         if (ret == Nullch)
  1801.         fatal("Unexpected end of file in patch at line %d.\n",
  1802.           p_input_line);
  1803.         if (*buf != '<')
  1804.         fatal("< expected at line %d of patch.\n", p_input_line);
  1805.         p_line[i] = savestr(buf+2);
  1806.         p_len[i] = strlen(p_line[i]);
  1807.         p_char[i] = '-';
  1808.     }
  1809.     if (hunk_type == 'c') {
  1810.         ret = pgets(buf,sizeof buf, pfp);
  1811.         p_input_line++;
  1812.         if (ret == Nullch)
  1813.         fatal("Unexpected end of file in patch at line %d.\n",
  1814.             p_input_line);
  1815.         if (*buf != '-')
  1816.         fatal("--- expected at line %d of patch.\n", p_input_line);
  1817.     }
  1818.     Sprintf(buf,"--- %d,%d\n",min,max);
  1819.     p_line[i] = savestr(buf);
  1820.     p_char[i] = '=';
  1821.     for (i++; i<=p_end; i++) {
  1822.         ret = pgets(buf,sizeof buf, pfp);
  1823.         p_input_line++;
  1824.         if (ret == Nullch)
  1825.         fatal("Unexpected end of file in patch at line %d.\n",
  1826.             p_input_line);
  1827.         if (*buf != '>')
  1828.         fatal("> expected at line %d of patch.\n", p_input_line);
  1829.         p_line[i] = savestr(buf+2);
  1830.         p_len[i] = strlen(p_line[i]);
  1831.         p_char[i] = '+';
  1832.     }
  1833.     }
  1834.     if (reverse)            /* backwards patch? */
  1835.     pch_swap();
  1836. #ifdef DEBUGGING
  1837.     if (debug & 2) {
  1838.     int i;
  1839.     char special;
  1840.  
  1841.     for (i=0; i <= p_end; i++) {
  1842.         if (i == p_ptrn_lines)
  1843.         special = '^';
  1844.         else
  1845.         special = ' ';
  1846.         printf("%3d %c %c %s",i,p_char[i],special,p_line[i]);
  1847.     }
  1848.     }
  1849. #endif
  1850.     return TRUE;
  1851. }
  1852.  
  1853. char *
  1854. pgets(bf,sz,fp)
  1855. char *bf;
  1856. int sz;
  1857. FILE *fp;
  1858. {
  1859.     char *ret = fgets(bf,sz,fp);
  1860.     register char *s;
  1861.     register int indent = 0;
  1862.  
  1863.     if (p_indent && ret != Nullch) {
  1864.     for (s=buf; indent < p_indent && (*s == ' ' || *s == '\t'); s++) {
  1865.         if (*s == '\t')
  1866.         indent += 8 - (indent % 7);
  1867.         else
  1868.         indent++;
  1869.     }
  1870.     if (buf != s)
  1871.         Strcpy(buf,s);
  1872.     }
  1873.     return ret;
  1874. }
  1875.  
  1876. pch_swap()
  1877. {
  1878.     char *tp_line[MAXHUNKSIZE];        /* the text of the hunk */
  1879.     char tp_char[MAXHUNKSIZE];        /* +, -, and ! */
  1880.     int tp_len[MAXHUNKSIZE];        /* length of each line */
  1881.     register LINENUM i, n;
  1882.     bool blankline = FALSE;
  1883.     register char *s;
  1884.  
  1885.     i = p_first;
  1886.     p_first = p_newfirst;
  1887.     p_newfirst = i;
  1888.     
  1889.     /* make a scratch copy */
  1890.  
  1891.     for (i=0; i<=p_end; i++) {
  1892.     tp_line[i] = p_line[i];
  1893.     tp_char[i] = p_char[i];
  1894.     tp_len[i] = p_len[i];
  1895.     }
  1896.  
  1897.     /* now turn the new into the old */
  1898.  
  1899.     i = p_ptrn_lines + 1;
  1900.     if (tp_char[i] == '\n') {        /* account for possible blank line */
  1901.     blankline = TRUE;
  1902.     i++;
  1903.     }
  1904.     for (n=0; i <= p_end; i++,n++) {
  1905.     p_line[n] = tp_line[i];
  1906.     p_char[n] = tp_char[i];
  1907.     if (p_char[n] == '+')
  1908.         p_char[n] = '-';
  1909.     p_len[n] = tp_len[i];
  1910.     }
  1911.     if (blankline) {
  1912.     i = p_ptrn_lines + 1;
  1913.     p_line[n] = tp_line[i];
  1914.     p_char[n] = tp_char[i];
  1915.     p_len[n] = tp_len[i];
  1916.     n++;
  1917.     }
  1918.     assert(p_char[0] == '=');
  1919.     p_char[0] = '*';
  1920.     for (s=p_line[0]; *s; s++)
  1921.     if (*s == '-')
  1922.         *s = '*';
  1923.  
  1924.     /* now turn the old into the new */
  1925.  
  1926.     assert(tp_char[0] == '*');
  1927.     tp_char[0] = '=';
  1928.     for (s=tp_line[0]; *s; s++)
  1929.     if (*s == '*')
  1930.         *s = '-';
  1931.     for (i=0; n <= p_end; i++,n++) {
  1932.     p_line[n] = tp_line[i];
  1933.     p_char[n] = tp_char[i];
  1934.     if (p_char[n] == '-')
  1935.         p_char[n] = '+';
  1936.     p_len[n] = tp_len[i];
  1937.     }
  1938.     assert(i == p_ptrn_lines + 1);
  1939.     i = p_ptrn_lines;
  1940.     p_ptrn_lines = p_repl_lines;
  1941.     p_repl_lines = i;
  1942. }
  1943.  
  1944. LINENUM
  1945. pch_first()
  1946. {
  1947.     return p_first;
  1948. }
  1949.  
  1950. LINENUM
  1951. pch_ptrn_lines()
  1952. {
  1953.     return p_ptrn_lines;
  1954. }
  1955.  
  1956. LINENUM
  1957. pch_newfirst()
  1958. {
  1959.     return p_newfirst;
  1960. }
  1961.  
  1962. LINENUM
  1963. pch_repl_lines()
  1964. {
  1965.     return p_repl_lines;
  1966. }
  1967.  
  1968. LINENUM
  1969. pch_end()
  1970. {
  1971.     return p_end;
  1972. }
  1973.  
  1974. LINENUM
  1975. pch_context()
  1976. {
  1977.     return p_context;
  1978. }
  1979.  
  1980. pch_line_len(line)
  1981. LINENUM line;
  1982. {
  1983.     return p_len[line];
  1984. }
  1985.  
  1986. char
  1987. pch_char(line)
  1988. LINENUM line;
  1989. {
  1990.     return p_char[line];
  1991. }
  1992.  
  1993. char *
  1994. pfetch(line)
  1995. LINENUM line;
  1996. {
  1997.     return p_line[line];
  1998. }
  1999.  
  2000. LINENUM
  2001. pch_hunk_beg()
  2002. {
  2003.     return p_input_line - p_end - 1;
  2004. }
  2005.  
  2006. char *
  2007. savestr(s)
  2008. register char *s;
  2009. {
  2010.     register char  *rv,
  2011.                    *t;
  2012.  
  2013.     t = s;
  2014.     while (*t++);
  2015.     rv = malloc((MEM) (t - s));
  2016.     if (rv == NULL)
  2017.     fatal ("patch: out of memory (savestr)\n");
  2018.     t = rv;
  2019.     while (*t++ = *s++);
  2020.     return rv;
  2021. }
  2022.  
  2023. my_exit(status)
  2024. int status;
  2025. {
  2026.     Unlink(TMPINNAME);
  2027.     Unlink(TMPOUTNAME);
  2028.     Unlink(TMPREJNAME);
  2029.     Unlink(TMPPATNAME);
  2030.     exit(status);
  2031. }
  2032.  
  2033. #ifdef lint
  2034.  
  2035. /*VARARGS ARGSUSED*/
  2036. say(pat) char *pat; { ; }
  2037. /*VARARGS ARGSUSED*/
  2038. fatal(pat) char *pat; { ; }
  2039. /*VARARGS ARGSUSED*/
  2040. ask(pat) char *pat; { ; }
  2041.  
  2042. #else lint
  2043.  
  2044. say(pat,arg1,arg2,arg3)
  2045. char *pat;
  2046. int arg1,arg2,arg3;
  2047. {
  2048.     fprintf(stderr,pat,arg1,arg2,arg3);
  2049.     Fflush(stderr);
  2050. }
  2051.  
  2052. fatal(pat,arg1,arg2,arg3)
  2053. char *pat;
  2054. int arg1,arg2,arg3;
  2055. {
  2056.     say(pat,arg1,arg2,arg3);
  2057.     my_exit(1);
  2058. }
  2059.  
  2060. ask(pat,arg1,arg2,arg3)
  2061. char *pat;
  2062. int arg1,arg2,arg3;
  2063. {
  2064.     int ttyfd = open("/dev/tty",2);
  2065.     int r;
  2066.  
  2067.     say(pat,arg1,arg2,arg3);
  2068.     if (ttyfd >= 0) {
  2069.     r = read(ttyfd, buf, sizeof buf);
  2070.     Close(ttyfd);
  2071.     }
  2072.     else
  2073.     r = read(2, buf, sizeof buf);
  2074.     if (r <= 0)
  2075.     buf[0] = 0;
  2076. }
  2077. #endif lint
  2078.  
  2079. bool
  2080. rev_in_string(string)
  2081. char *string;
  2082. {
  2083.     register char *s;
  2084.     register int patlen;
  2085.  
  2086.     if (revision == Nullch)
  2087.     return TRUE;
  2088.     patlen = strlen(revision);
  2089.     for (s = string; *s; s++) {
  2090.     if (isspace(*s) && strnEQ(s+1,revision,patlen) && 
  2091.         isspace(s[patlen+1] )) {
  2092.         return TRUE;
  2093.     }
  2094.     }
  2095.     return FALSE;
  2096. }
  2097.  
  2098. set_signals()
  2099. {
  2100.     /*NOSTRICT*/
  2101.     if (signal(SIGHUP, SIG_IGN) != SIG_IGN)
  2102.     Signal(SIGHUP, my_exit);
  2103.     /*NOSTRICT*/
  2104.     if (signal(SIGINT, SIG_IGN) != SIG_IGN)
  2105.     Signal(SIGINT, my_exit);
  2106. }
  2107.  
  2108. ignore_signals()
  2109. {
  2110.     /*NOSTRICT*/
  2111.     Signal(SIGHUP, SIG_IGN);
  2112.     /*NOSTRICT*/
  2113.     Signal(SIGINT, SIG_IGN);
  2114. }
  2115. !STUFFY!FUNK!
  2116. echo Extracting Makefile
  2117. cat >Makefile <<'!STUFFY!FUNK!'
  2118. # $Header: Makefile,v 1.3 85/03/26 15:03:26 lwall Exp $
  2119.  
  2120. # $Log:    Makefile,v $
  2121. # Revision 1.3  85/03/26  15:03:26  lwall
  2122. # Frozen.
  2123. # 
  2124.  
  2125. DESTDIR = /usr/local
  2126.  
  2127. patch: patch.c
  2128.     cc patch.c -O -o patch
  2129. install:
  2130.     install -c patch $(DESTDIR)
  2131. clean:
  2132.     rm patch
  2133. shar:
  2134.     shar patch.man patch.c Makefile >patch.kit
  2135. lint:
  2136.     lint -phbvxac patch.c
  2137. !STUFFY!FUNK!
  2138. echo ""
  2139. echo "End of kit"
  2140. : I do not append .signature, but someone might mail this.
  2141. exit
  2142.  
  2143.