home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / unix / volume7 / patch2 / patch10 / text0000.txt < prev   
Encoding:
Text File  |  1988-06-04  |  44.3 KB  |  1,632 lines
  1. System: patch version 2.0
  2. Patch #: 10
  3. Priority: MEDIUM
  4. Subject: new Configure for better portability
  5. Subject: installation script needs to remove old cat files on some systems
  6. Subject: systems without flexfilenames now use ~ or # as extension
  7. Subject: -B lets you specify a backup prefix instead of a suffix
  8. Subject: some machines don't like backslash-newline in double quotes
  9. Subject: a Prereq: wouldn't match first thing on a line
  10. Subject: an malloc() is now supplied
  11. Subject: exit code wasn't set properly
  12. Subject: signals could get permanently ignored
  13. Subject: the argument to -D is now checked for sanity
  14. Subject: fixed some typos in the manual page
  15. Subject: can now extract patches from shar files with leading X
  16. Subject: handles some gnu diff ideosyncracies
  17. Subject: double swap of first hunk could cause core dump
  18.  
  19. Description:
  20.     Subject: new Configure for better portability.
  21.  
  22.     Now based on the latest version of metaconfig, which knows everything
  23.     I know about Unix portability.
  24.  
  25.     Subject: installation script needs to remove old cat files on some
  26.     systems.
  27.  
  28.     Some systems have a stupid man command that doesn't compare dates
  29.     between the man version and the cat version, so the cat version
  30.     has to be removed at installation time.
  31.  
  32.     Subject: systems without flexfilenames now use ~ or # as extension.
  33.  
  34.     Systems that are restricted to 14 character filenames now will not
  35.     find files disappearing because they resolve to the same name.
  36.  
  37.     Subject: -B lets you specify a backup prefix instead of a suffix.
  38.  
  39.     This also helps the 14 character filename problem.  It also lets
  40.     you put backup files into a subdirectory.
  41.  
  42.     Subject: some machines don't like backslash-newline in double quotes.
  43.  
  44.     What can I say?
  45.  
  46.     Subject: a Prereq: wouldn't match first thing on a line.
  47.  
  48.     Now it does.
  49.  
  50.     Subject: an malloc() is now supplied.
  51.  
  52.     No particular reason, except that the new Configure made it easy.
  53.  
  54.     Subject: exit code wasn't set properly.
  55.  
  56.     Now you can use patch in a shell loop and stop if something goes
  57.     wrong.
  58.  
  59.     Subject: signals could get permanently ignored.
  60.  
  61.     It now remembers better what the original signals handlers were.
  62.  
  63.     Subject: the argument to -D is now checked for sanity.
  64.  
  65.     If you confused -d and -D, you could make your program unparseable
  66.     by the C preprocessor.
  67.  
  68.     Subject: can now extract patches from shar files with leading X.
  69.  
  70.     An X is treated like a space or tab on the front of a patch now.
  71.     There must be a consistent number of them for the duration of
  72.     the diff, however.
  73.  
  74.     Subject: handles some gnu diff ideosyncracies.
  75.  
  76.     Gnu diff says 0,0 instead of 0.
  77.  
  78.     Subject: double swap of first hunk could cause core dump.
  79.  
  80.     If an initial hunk didn't match, was swapped to try -R, then
  81.     swapped back and applied with a fuzz factor, there could be
  82.     a duplicate free().
  83.  
  84. Fix:    You need to both this patch and the next one.
  85.  
  86.     From rn, say "| patch -p -N -d DIR", where DIR is your patch source
  87.     directory.  Outside of rn, say "cd DIR; patch -p -N <thisarticle".
  88.     If you don't have the patch program, apply the following by hand,
  89.     or get patch (version 2.0, latest patchlevel).
  90.  
  91.     After applying:
  92.         DO NOT RECOMPILE
  93.         Apply patch 11, which is a shar, not a normal patch.
  94.  
  95.     If patch indicates that patchlevel is the wrong version, you may need
  96.     to apply one or more previous patches, or the patch may already
  97.     have been applied.  See the patchlevel.h file to find out what has or
  98.     has not been applied.  In any event, don't continue with the patch.
  99.  
  100.     If you are missing previous patches they can be obtained from me:
  101.  
  102.     Larry Wall
  103.     lwall@jpl-devvax.jpl.nasa.gov
  104.  
  105.     If you send a mail message of the following form it will greatly speed
  106.     processing:
  107.  
  108.     Subject: Command
  109.     @SH mailpatch PATH patch 2.0 LIST
  110.            ^ note the c
  111.  
  112.     where PATH is a return path FROM ME TO YOU in Internet notation, and
  113.     LIST is the number of one or more patches you need, separated by spaces,
  114.     commas, and/or hyphens.  Saying 35- says everything from 35 to the end.
  115.  
  116.     You can also get the patches via anonymous FTP from
  117.     jpl-devvax.jpl.nasa.gov (128.149.8.43).
  118.  
  119. Index: patchlevel.h
  120. Prereq: 9
  121. 1c1
  122. < #define PATCHLEVEL 9
  123. ---
  124. > #define PATCHLEVEL 10
  125.  
  126. Index: Makefile.SH
  127. Prereq: 2.0
  128. *** Makefile.SH.old    Fri Jun  3 15:26:55 1988
  129. --- Makefile.SH    Fri Jun  3 15:26:56 1988
  130. ***************
  131. *** 3,11 ****
  132.   esac
  133.   echo "Extracting Makefile (with variable substitutions)"
  134.   cat >Makefile <<!GROK!THIS!
  135. ! # $Header: Makefile.SH,v 2.0 86/09/17 15:36:15 lwall Exp $
  136.   #
  137.   # $Log:    Makefile.SH,v $
  138.   # Revision 2.0  86/09/17  15:36:15  lwall
  139.   # Baseline for netwide release.
  140.   # 
  141. --- 3,14 ----
  142.   esac
  143.   echo "Extracting Makefile (with variable substitutions)"
  144.   cat >Makefile <<!GROK!THIS!
  145. ! # $Header: Makefile.SH,v 2.0.1.1 88/06/03 15:00:48 lwall Locked $
  146.   #
  147.   # $Log:    Makefile.SH,v $
  148. + # Revision 2.0.1.1  88/06/03  15:00:48  lwall
  149. + # patch10: upgraded to match some new metaconfig stuff
  150. + # 
  151.   # Revision 2.0  86/09/17  15:36:15  lwall
  152.   # Baseline for netwide release.
  153.   # 
  154. ***************
  155. *** 20,27 ****
  156.   bin = $bin
  157.   mansrc = $mansrc
  158.   manext = $manext
  159. ! CFLAGS = $iandd -O
  160. ! LDFLAGS = $iandd
  161.   
  162.   !GROK!THIS!
  163.   cat >>Makefile <<'!NO!SUBS!'
  164. --- 23,32 ----
  165.   bin = $bin
  166.   mansrc = $mansrc
  167.   manext = $manext
  168. ! CFLAGS = $ccflags -O
  169. ! LDFLAGS = $ldflags
  170. ! SMALL = $small
  171. ! LARGE = $large $split
  172.   
  173.   !GROK!THIS!
  174.   cat >>Makefile <<'!NO!SUBS!'
  175. ***************
  176. *** 43,49 ****
  177.   SHELL = /bin/sh
  178.   
  179.   .c.o:
  180. !     $(CC) -c $(CFLAGS) $*.c
  181.   
  182.   all: $(public) $(private) $(util)
  183.       touch all
  184. --- 48,54 ----
  185.   SHELL = /bin/sh
  186.   
  187.   .c.o:
  188. !     $(CC) -c $(CFLAGS) $(LARGE) $*.c
  189.   
  190.   all: $(public) $(private) $(util)
  191.       touch all
  192. ***************
  193. *** 59,64 ****
  194. --- 64,70 ----
  195.       cd $(bin); chmod 755 $(public)
  196.       - if test `pwd` != $(mansrc); then \
  197.   for page in $(manpages); do \
  198. + rm -f $(mansrc)/../cat$(manext)/`basename $$page .man`.$(manext); \
  199.   cp $$page $(mansrc)/`basename $$page .man`.$(manext); \
  200.   done; \
  201.   fi
  202.  
  203. Index: common.h
  204. Prereq: 2.0
  205. *** common.h.old    Fri Jun  3 15:27:03 1988
  206. --- common.h    Fri Jun  3 15:27:04 1988
  207. ***************
  208. *** 1,6 ****
  209. ! /* $Header: common.h,v 2.0 86/09/17 15:36:39 lwall Exp $
  210.    *
  211.    * $Log:    common.h,v $
  212.    * Revision 2.0  86/09/17  15:36:39  lwall
  213.    * Baseline for netwide release.
  214.    * 
  215. --- 1,9 ----
  216. ! /* $Header: common.h,v 2.0.1.1 88/06/03 15:01:56 lwall Locked $
  217.    *
  218.    * $Log:    common.h,v $
  219. +  * Revision 2.0.1.1  88/06/03  15:01:56  lwall
  220. +  * patch10: support for shorter extensions.
  221. +  * 
  222.    * Revision 2.0  86/09/17  15:36:39  lwall
  223.    * Baseline for netwide release.
  224.    * 
  225. ***************
  226. *** 42,53 ****
  227.   #define INITHUNKMAX 125            /* initial dynamic allocation size */
  228.   #define MAXLINELEN 1024
  229.   #define BUFFERSIZE 1024
  230. - #define ORIGEXT ".orig"
  231.   #define SCCSPREFIX "s."
  232.   #define GET "get -e %s"
  233.   #define RCSSUFFIX ",v"
  234.   #define CHECKOUT "co -l %s"
  235.   
  236.   /* handy definitions */
  237.   
  238.   #define Null(t) ((t)0)
  239. --- 45,63 ----
  240.   #define INITHUNKMAX 125            /* initial dynamic allocation size */
  241.   #define MAXLINELEN 1024
  242.   #define BUFFERSIZE 1024
  243.   #define SCCSPREFIX "s."
  244.   #define GET "get -e %s"
  245.   #define RCSSUFFIX ",v"
  246.   #define CHECKOUT "co -l %s"
  247.   
  248. + #ifdef FLEXFILENAMES
  249. + #define ORIGEXT ".orig"
  250. + #define REJEXT ".rej"
  251. + #else
  252. + #define ORIGEXT "~"
  253. + #define REJEXT "#"
  254. + #endif
  255. + 
  256.   /* handy definitions */
  257.   
  258.   #define Null(t) ((t)0)
  259. ***************
  260. *** 95,100 ****
  261. --- 105,111 ----
  262.   EXT char rejname[128];
  263.   
  264.   EXT char *origext INIT(Nullch);
  265. + EXT char *origprae INIT(Nullch);
  266.   
  267.   EXT char TMPOUTNAME[] INIT("/tmp/patchoXXXXXX");
  268.   EXT char TMPINNAME[] INIT("/tmp/patchiXXXXXX");    /* might want /usr/tmp here */
  269. ***************
  270. *** 134,140 ****
  271.   char *realloc();
  272.   char *strcpy();
  273.   char *strcat();
  274. - char *sprintf();        /* usually */
  275.   long atol();
  276.   long lseek();
  277.   char *mktemp();
  278. --- 145,155 ----
  279.   char *realloc();
  280.   char *strcpy();
  281.   char *strcat();
  282.   long atol();
  283.   long lseek();
  284.   char *mktemp();
  285. + #ifdef CHARSPRINTF
  286. + char *sprintf();
  287. + #else
  288. + int *sprintf();
  289. + #endif
  290.  
  291. Index: config.h.SH
  292. *** config.h.SH.old    Fri Jun  3 15:27:12 1988
  293. --- config.h.SH    Fri Jun  3 15:27:14 1988
  294. ***************
  295. *** 0 ****
  296. --- 1,136 ----
  297. + case $CONFIG in
  298. + '')
  299. +     if test ! -f config.sh; then
  300. +     ln ../config.sh . || \
  301. +     ln ../../config.sh . || \
  302. +     ln ../../../config.sh . || \
  303. +     (echo "Can't find config.sh."; exit 1)
  304. +     echo "Using config.sh from above..."
  305. +     fi
  306. +     . ./config.sh
  307. +     ;;
  308. + esac
  309. + echo "Extracting config.h (with variable substitutions)"
  310. + cat <<!GROK!THIS! >config.h
  311. + /* config.h
  312. +  * This file was produced by running the config.h.SH script, which
  313. +  * gets its values from config.sh, which is generally produced by
  314. +  * running Configure.
  315. +  *
  316. +  * Feel free to modify any of this as the need arises.  Note, however,
  317. +  * that running config.h.SH again will wipe out any changes you've made.
  318. +  * For a more permanent change edit config.sh and rerun config.h.SH.
  319. +  */
  320. + 
  321. + 
  322. + /* EUNICE:
  323. +  *    This symbol, if defined, indicates that the program is being compiled
  324. +  *    under the EUNICE package under VMS.  The program will need to handle
  325. +  *    things like files that don't go away the first time you unlink them,
  326. +  *    due to version numbering.  It will also need to compensate for lack
  327. +  *    of a respectable link() command.
  328. +  */
  329. + /* VMS:
  330. +  *    This symbol, if defined, indicates that the program is running under
  331. +  *    VMS.  It is currently only set in conjunction with the EUNICE symbol.
  332. +  */
  333. + #$d_eunice    EUNICE        /**/
  334. + #$d_eunice    VMS        /**/
  335. + 
  336. + /* CPPSTDIN:
  337. +  *    This symbol contains the first part of the string which will invoke
  338. +  *    the C preprocessor on the standard input and produce to standard
  339. +  *    output.     Typical value of "cc -E" or "/lib/cpp".
  340. +  */
  341. + /* CPPMINUS:
  342. +  *    This symbol contains the second part of the string which will invoke
  343. +  *    the C preprocessor on the standard input and produce to standard
  344. +  *    output.  This symbol will have the value "-" if CPPSTDIN needs a minus
  345. +  *    to specify standard input, otherwise the value is "".
  346. +  */
  347. + #define CPPSTDIN "$cppstdin"
  348. + #define CPPMINUS "$cppminus"
  349. + 
  350. + /* CHARSPRINTF:
  351. +  *    This symbol is defined if this system declares "char *sprintf()" in
  352. +  *    stdio.h.  The trend seems to be to declare it as "int sprintf()".  It
  353. +  *    is up to the package author to declare sprintf correctly based on the
  354. +  *    symbol.
  355. +  */
  356. + #$d_charsprf    CHARSPRINTF     /**/
  357. + 
  358. + /* FLEXFILENAMES:
  359. +  *    This symbol, if defined, indicates that the system supports filenames
  360. +  *    longer than 14 characters.
  361. +  */
  362. + #$d_flexfnam    FLEXFILENAMES        /**/
  363. + 
  364. + /* index:
  365. +  *    This preprocessor symbol is defined, along with rindex, if the system
  366. +  *    uses the strchr and strrchr routines instead.
  367. +  */
  368. + /* rindex:
  369. +  *    This preprocessor symbol is defined, along with index, if the system
  370. +  *    uses the strchr and strrchr routines instead.
  371. +  */
  372. + #$d_index    index strchr    /* cultural */
  373. + #$d_index    rindex strrchr    /*  differences? */
  374. + 
  375. + /* VOIDSIG:
  376. +  *    This symbol is defined if this system declares "void (*signal())()" in
  377. +  *    signal.h.  The old way was to declare it as "int (*signal())()".  It
  378. +  *    is up to the package author to declare things correctly based on the
  379. +  *    symbol.
  380. +  */
  381. + #$d_voidsig    VOIDSIG     /**/
  382. + 
  383. + /* Reg1:
  384. +  *    This symbol, along with Reg2, Reg3, etc. is either the word "register"
  385. +  *    or null, depending on whether the C compiler pays attention to this
  386. +  *    many register declarations.  The intent is that you don't have to
  387. +  *    order your register declarations in the order of importance, so you
  388. +  *    can freely declare register variables in sub-blocks of code and as
  389. +  *    function parameters.  Do not use Reg<n> more than once per routine.
  390. +  */
  391. + 
  392. + #define Reg1 $reg1        /**/
  393. + #define Reg2 $reg2        /**/
  394. + #define Reg3 $reg3        /**/
  395. + #define Reg4 $reg4        /**/
  396. + #define Reg5 $reg5        /**/
  397. + #define Reg6 $reg6        /**/
  398. + #define Reg7 $reg7        /**/
  399. + #define Reg8 $reg8        /**/
  400. + #define Reg9 $reg9        /**/
  401. + #define Reg10 $reg10        /**/
  402. + #define Reg11 $reg11        /**/
  403. + #define Reg12 $reg12        /**/
  404. + #define Reg13 $reg13        /**/
  405. + #define Reg14 $reg14        /**/
  406. + #define Reg15 $reg15        /**/
  407. + #define Reg16 $reg16        /**/
  408. + 
  409. + /* VOIDFLAGS:
  410. +  *    This symbol indicates how much support of the void type is given by this
  411. +  *    compiler.  What various bits mean:
  412. +  *
  413. +  *        1 = supports declaration of void
  414. +  *        2 = supports arrays of pointers to functions returning void
  415. +  *        4 = supports comparisons between pointers to void functions and
  416. +  *            addresses of void functions
  417. +  *
  418. +  *    The package designer should define VOIDUSED to indicate the requirements
  419. +  *    of the package.  This can be done either by #defining VOIDUSED before
  420. +  *    including config.h, or by defining defvoidused in Myinit.U.  If the
  421. +  *    level of void support necessary is not present, defines void to int.
  422. +  */
  423. + #ifndef VOIDUSED
  424. + #define VOIDUSED $defvoidused
  425. + #endif
  426. + #define VOIDFLAGS $voidflags
  427. + #if (VOIDFLAGS & VOIDUSED) != VOIDUSED
  428. + #$define void int        /* is void to be avoided? */
  429. + #$define M_VOID        /* Xenix strikes again */
  430. + #endif
  431. + 
  432. + !GROK!THIS!
  433.  
  434. Index: inp.c
  435. Prereq: 2.0
  436. *** inp.c.old    Fri Jun  3 15:27:20 1988
  437. --- inp.c    Fri Jun  3 15:27:21 1988
  438. ***************
  439. *** 1,6 ****
  440. ! /* $Header: inp.c,v 2.0 86/09/17 15:37:02 lwall Exp $
  441.    *
  442.    * $Log:    inp.c,v $
  443.    * Revision 2.0  86/09/17  15:37:02  lwall
  444.    * Baseline for netwide release.
  445.    * 
  446. --- 1,9 ----
  447. ! /* $Header: inp.c,v 2.0.1.1 88/06/03 15:06:13 lwall Locked $
  448.    *
  449.    * $Log:    inp.c,v $
  450. +  * Revision 2.0.1.1  88/06/03  15:06:13  lwall
  451. +  * patch10: made a little smarter about sccs files
  452. +  * 
  453.    * Revision 2.0  86/09/17  15:37:02  lwall
  454.    * Baseline for netwide release.
  455.    * 
  456. ***************
  457. *** 94,102 ****
  458.           fatal2("Can't check out %s.\n", filename);
  459.       }
  460.       else {
  461. !         Sprintf(buf, "SCCS/%s%s", SCCSPREFIX, filename);
  462. !         if (stat(buf, &filestat) >= 0 || stat(buf+5, &filestat) >= 0) {
  463. !         Sprintf(buf, GET, filename);
  464.           if (verbose)
  465.               say2("Can't find %s--attempting to get it from SCCS.\n",
  466.               filename);
  467. --- 97,106 ----
  468.           fatal2("Can't check out %s.\n", filename);
  469.       }
  470.       else {
  471. !         Sprintf(buf+20, "SCCS/%s%s", SCCSPREFIX, filename);
  472. !         if (stat(s=buf+20, &filestat) >= 0 ||
  473. !           stat(s=buf+25, &filestat) >= 0) {
  474. !         Sprintf(buf, GET, s);
  475.           if (verbose)
  476.               say2("Can't find %s--attempting to get it from SCCS.\n",
  477.               filename);
  478. ***************
  479. *** 171,183 ****
  480.       if (!rev_in_string(i_womp)) {
  481.           if (force) {
  482.           if (verbose)
  483. !             say2("\
  484. ! Warning: this file doesn't appear to be the %s version--patching anyway.\n",
  485.               revision);
  486.           }
  487.           else {
  488. !         ask2("\
  489. ! This file doesn't appear to be the %s version--patch anyway? [n] ",
  490.               revision);
  491.           if (*buf != 'y')
  492.           fatal1("Aborted.\n");
  493. --- 175,187 ----
  494.       if (!rev_in_string(i_womp)) {
  495.           if (force) {
  496.           if (verbose)
  497. !             say2(
  498. ! "Warning: this file doesn't appear to be the %s version--patching anyway.\n",
  499.               revision);
  500.           }
  501.           else {
  502. !         ask2(
  503. ! "This file doesn't appear to be the %s version--patch anyway? [n] ",
  504.               revision);
  505.           if (*buf != 'y')
  506.           fatal1("Aborted.\n");
  507. ***************
  508. *** 216,228 ****
  509.       if (!found_revision) {
  510.           if (force) {
  511.           if (verbose)
  512. !             say2("\
  513. ! Warning: this file doesn't appear to be the %s version--patching anyway.\n",
  514.               revision);
  515.           }
  516.           else {
  517. !         ask2("\
  518. ! This file doesn't appear to be the %s version--patch anyway? [n] ",
  519.               revision);
  520.           if (*buf != 'y')
  521.               fatal1("Aborted.\n");
  522. --- 220,232 ----
  523.       if (!found_revision) {
  524.           if (force) {
  525.           if (verbose)
  526. !             say2(
  527. ! "Warning: this file doesn't appear to be the %s version--patching anyway.\n",
  528.               revision);
  529.           }
  530.           else {
  531. !         ask2(
  532. ! "This file doesn't appear to be the %s version--patch anyway? [n] ",
  533.               revision);
  534.           if (*buf != 'y')
  535.               fatal1("Aborted.\n");
  536. ***************
  537. *** 302,307 ****
  538. --- 306,313 ----
  539.       if (revision == Nullch)
  540.       return TRUE;
  541.       patlen = strlen(revision);
  542. +     if (strnEQ(string,revision,patlen) && isspace(s[patlen]))
  543. +     return TRUE;
  544.       for (s = string; *s; s++) {
  545.       if (isspace(*s) && strnEQ(s+1, revision, patlen) && 
  546.           isspace(s[patlen+1] )) {
  547.  
  548. Index: malloc.c
  549. *** malloc.c.old    Fri Jun  3 15:27:28 1988
  550. --- malloc.c    Fri Jun  3 15:27:30 1988
  551. ***************
  552. *** 0 ****
  553. --- 1,467 ----
  554. + /*
  555. +  * @(#)nmalloc.c 1 (Caltech) 2/21/82
  556. +  *
  557. +  *    U of M Modified: 20 Jun 1983 ACT: strange hacks for Emacs
  558. +  *
  559. +  *    Nov 1983, Mike@BRL, Added support for 4.1C/4.2 BSD.
  560. +  *
  561. +  * This is a very fast storage allocator.  It allocates blocks of a small 
  562. +  * number of different sizes, and keeps free lists of each size.  Blocks
  563. +  * that don't exactly fit are passed up to the next larger size.  In this 
  564. +  * implementation, the available sizes are (2^n)-4 (or -16) bytes long.
  565. +  * This is designed for use in a program that uses vast quantities of
  566. +  * memory, but bombs when it runs out.  To make it a little better, it
  567. +  * warns the user when he starts to get near the end.
  568. +  *
  569. +  * June 84, ACT: modified rcheck code to check the range given to malloc,
  570. +  * rather than the range determined by the 2-power used.
  571. +  *
  572. +  * Jan 85, RMS: calls malloc_warning to issue warning on nearly full.
  573. +  * No longer Emacs-specific; can serve as all-purpose malloc for GNU.
  574. +  * You should call malloc_init to reinitialize after loading dumped Emacs.
  575. +  * Call malloc_stats to get info on memory stats if MSTATS turned on.
  576. +  * realloc knows how to return same block given, just changing its size,
  577. +  * if the power of 2 is correct.
  578. +  */
  579. + 
  580. + /*
  581. +  * nextf[i] is the pointer to the next free block of size 2^(i+3).  The
  582. +  * smallest allocatable block is 8 bytes.  The overhead information will
  583. +  * go in the first int of the block, and the returned pointer will point
  584. +  * to the second.
  585. +  *
  586. + #ifdef MSTATS
  587. +  * nmalloc[i] is the difference between the number of mallocs and frees
  588. +  * for a given block size.
  589. + #endif /* MSTATS */
  590. +  */
  591. + 
  592. + #define ISALLOC ((char) 0xf7)    /* magic byte that implies allocation */
  593. + #define ISFREE ((char) 0x54)    /* magic byte that implies free block */
  594. +                 /* this is for error checking only */
  595. + 
  596. + extern char etext;
  597. + 
  598. + /* end of the program; can be changed by calling init_malloc */
  599. + static char *endofpure = &etext;
  600. + 
  601. + #ifdef MSTATS
  602. + static int nmalloc[30];
  603. + static int nmal, nfre;
  604. + #endif /* MSTATS */
  605. + 
  606. + /* If range checking is not turned on, all we have is a flag indicating
  607. +    whether memory is allocated, an index in nextf[], and a size field; to
  608. +    realloc() memory we copy either size bytes or 1<<(index+3) bytes depending
  609. +    on whether the former can hold the exact size (given the value of
  610. +    'index').  If range checking is on, we always need to know how much space
  611. +    is allocated, so the 'size' field is never used. */
  612. + 
  613. + struct mhead {
  614. +     char     mh_alloc;    /* ISALLOC or ISFREE */
  615. +     char     mh_index;    /* index in nextf[] */
  616. + /* Remainder are valid only when block is allocated */
  617. +     unsigned short mh_size;    /* size, if < 0x10000 */
  618. + #ifdef rcheck
  619. +     unsigned mh_nbytes;    /* number of bytes allocated */
  620. +     int      mh_magic4;    /* should be == MAGIC4 */
  621. + #endif /* rcheck */
  622. +     };
  623. + 
  624. + /* Access free-list pointer of a block.
  625. +   It is stored at block + 4.
  626. +   This is not a field in the mhead structure
  627. +   because we want sizeof (struct mhead)
  628. +   to describe the overhead for when the block is in use,
  629. +   and we do not want the free-list pointer to count in that.  */
  630. + 
  631. + #define CHAIN(a) \
  632. +   (*(struct mhead **) (sizeof (char *) + (char *) (a)))
  633. + 
  634. + #ifdef rcheck
  635. + 
  636. + /* To implement range checking, we write magic values in at the beginning and
  637. +    end of each allocated block, and make sure they are undisturbed whenever a
  638. +    free or a realloc occurs. */
  639. + /* Written in each of the 4 bytes following the block's real space */
  640. + #define MAGIC1 0x55
  641. + /* Written in the 4 bytes before the block's real space */
  642. + #define MAGIC4 0x55555555
  643. + #define ASSERT(p) if (!(p)) botch("p"); else
  644. + static
  645. + botch(s)
  646. +     char *s;
  647. + {
  648. + 
  649. +     printf("assertion botched: %s\n", s);
  650. +     abort();
  651. + }
  652. + #define EXTRA  4        /* 4 bytes extra for MAGIC1s */
  653. + #else
  654. + #define ASSERT(p)
  655. + #define EXTRA  0
  656. + #endif /* rcheck */
  657. + 
  658. + /* nextf[i] is free list of blocks of size 2**(i + 3)  */
  659. + 
  660. + static struct mhead *nextf[30];
  661. + 
  662. + #ifdef    M_WARN
  663. + /* Number of bytes of writable memory we can expect to be able to get */
  664. + static int  lim_data;
  665. + /* Level number of warnings already issued.
  666. +   0 -- no warnings issued.
  667. +   1 -- 75% warning already issued.
  668. +   2 -- 85% warning already issued.
  669. + */
  670. + static int  warnlevel;
  671. + #endif /* M_WARN */
  672. + 
  673. + /* nonzero once initial bunch of free blocks made */
  674. + static int gotpool;
  675. + 
  676. + /* Cause reinitialization based on job parameters;
  677. +   also declare where the end of pure storage is. */
  678. + malloc_init (end)
  679. +     char *end; {
  680. +     endofpure = end;
  681. + #ifdef    M_WARN
  682. +     lim_data = 0;
  683. +     warnlevel = 0;
  684. + #endif /* M_WARN */
  685. +     }
  686. + 
  687. + static
  688. + morecore (nu)            /* ask system for more memory */
  689. +     register int nu; {        /* size index to get more of  */
  690. +     char   *sbrk ();
  691. +     register char  *cp;
  692. +     register int    nblks;
  693. +     register int    siz;
  694. + 
  695. + #ifdef    M_WARN
  696. + #ifndef BSD42
  697. + #ifdef USG
  698. +     extern long ulimit ();
  699. +     if (lim_data == 0)        /* find out how much we can get */
  700. +         lim_data = ulimit (3, 0) - TEXT_START;
  701. + #else    /*HMS: was endif */
  702. +     if (lim_data == 0)        /* find out how much we can get */
  703. +         lim_data = vlimit (LIM_DATA, -1);
  704. + #endif /* USG */    /HMS:* was not here */
  705. + #else
  706. +     if (lim_data == 0) {
  707. +         struct rlimit   XXrlimit;
  708. + 
  709. +         getrlimit (RLIMIT_DATA, &XXrlimit);
  710. +         lim_data = XXrlimit.rlim_cur;}    /* soft limit */
  711. + #endif /* BSD42 */
  712. + #endif /* M_WARN */
  713. + 
  714. +     /* On initial startup, get two blocks of each size up to 1k bytes */
  715. +     if (!gotpool)
  716. +         getpool (), getpool (), gotpool = 1;
  717. + 
  718. +     /* Find current end of memory and issue warning if getting near max */
  719. + 
  720. +     cp = sbrk (0);
  721. +     siz = cp - endofpure;
  722. + #ifdef    M_WARN
  723. +     switch (warnlevel) {
  724. +         case 0: 
  725. +         if (siz > (lim_data / 4) * 3) {
  726. +             warnlevel++;
  727. +             malloc_warning ("Warning: past 75% of memory limit");}
  728. +         break;
  729. +         case 1: 
  730. +         if (siz > (lim_data / 20) * 17) {
  731. +             warnlevel++;
  732. +             malloc_warning ("Warning: past 85% of memory limit");}
  733. +         break;
  734. +         case 2: 
  735. +         if (siz > (lim_data / 20) * 19) {
  736. +             warnlevel++;
  737. +             malloc_warning ("Warning: past 95% of memory limit");}
  738. +         break;}
  739. + #endif /* M_WARN */
  740. + 
  741. +     if ((int) cp & 0x3ff)    /* land on 1K boundaries */
  742. +         sbrk (1024 - ((int) cp & 0x3ff));
  743. + 
  744. +     /* Take at least 2k, and figure out how many blocks of the desired size we're about to get */
  745. +     nblks = 1;
  746. +     if ((siz = nu) < 8)
  747. +         nblks = 1 << ((siz = 8) - nu);
  748. + 
  749. +     if ((cp = sbrk (1 << (siz + 3))) == (char *) -1)
  750. +         return;            /* no more room! */
  751. +     if ((int) cp & 7) {        /* shouldn't happen, but just in case */
  752. +         cp = (char *) (((int) cp + 8) & ~7);
  753. +         nblks--;}
  754. + 
  755. +     /* save new header and link the nblks blocks together */
  756. +     nextf[nu] = (struct mhead *) cp;
  757. +     siz = 1 << (nu + 3);
  758. +     while (1) {
  759. +         ((struct mhead *) cp) -> mh_alloc = ISFREE;
  760. +         ((struct mhead *) cp) -> mh_index = nu;
  761. +         if (--nblks <= 0) break;
  762. +         CHAIN ((struct mhead *) cp) = (struct mhead *) (cp + siz);
  763. +         cp += siz;}
  764. + /*    CHAIN ((struct mhead *) cp) = 0;    /* since sbrk() returns cleared core, this is already set */
  765. +     }
  766. + 
  767. + static
  768. + getpool () {
  769. +     register int nu;
  770. +     register char *cp = sbrk (0);
  771. + 
  772. +     if ((int) cp & 0x3ff)    /* land on 1K boundaries */
  773. +         sbrk (1024 - ((int) cp & 0x3ff));
  774. + 
  775. +     /* Get 2k of storage */
  776. + 
  777. +     cp = sbrk (04000);
  778. +     if (cp == (char *) -1)
  779. +         return;
  780. + 
  781. +     /* Divide it into an initial 8-word block
  782. +     plus one block of size 2**nu for nu = 3 ... 10.  */
  783. + 
  784. +     CHAIN (cp) = nextf[0];
  785. +     nextf[0] = (struct mhead *) cp;
  786. +     ((struct mhead *) cp) -> mh_alloc = ISFREE;
  787. +     ((struct mhead *) cp) -> mh_index = 0;
  788. +     cp += 8;
  789. + 
  790. +     for (nu = 0; nu < 7; nu++) {
  791. +         CHAIN (cp) = nextf[nu];
  792. +         nextf[nu] = (struct mhead *) cp;
  793. +         ((struct mhead *) cp) -> mh_alloc = ISFREE;
  794. +         ((struct mhead *) cp) -> mh_index = nu;
  795. +         cp += 8 << nu;}}
  796. + 
  797. + char *
  798. + malloc (n)        /* get a block */
  799. +     unsigned n; {
  800. +     register struct  mhead *p;
  801. +     register unsigned int  nbytes;
  802. +     register int    nunits = 0;
  803. + 
  804. +     /* Figure out how many bytes are required, rounding up to the nearest
  805. +     multiple of 4, then figure out which nextf[] area to use */
  806. +     nbytes = (n + sizeof *p + EXTRA + 3) & ~3;
  807. +         {
  808. +         register unsigned int   shiftr = (nbytes - 1) >> 2;
  809. + 
  810. +         while (shiftr >>= 1)
  811. +             nunits++;
  812. +         }
  813. + 
  814. +     /* If there are no blocks of the appropriate size, go get some */
  815. +     /* COULD SPLIT UP A LARGER BLOCK HERE ... ACT */
  816. +     if (nextf[nunits] == 0)
  817. +         morecore (nunits);
  818. + 
  819. +     /* Get one block off the list, and set the new list head */
  820. +     if ((p = nextf[nunits]) == 0)
  821. +         return 0;
  822. +     nextf[nunits] = CHAIN (p);
  823. + 
  824. +     /* Check for free block clobbered */
  825. +     /* If not for this check, we would gobble a clobbered free chain ptr */
  826. +     /* and bomb out on the NEXT allocate of this size block */
  827. +     if (p -> mh_alloc != ISFREE || p -> mh_index != nunits)
  828. + #ifdef rcheck
  829. +         botch ("block on free list clobbered");
  830. + #else
  831. +         abort ();
  832. + #endif /* rcheck */
  833. + 
  834. +     /* Fill in the info, and if range checking, set up the magic numbers */
  835. +     p -> mh_alloc = ISALLOC;
  836. + #ifdef rcheck
  837. +     p -> mh_nbytes = n;
  838. +     p -> mh_magic4 = MAGIC4;
  839. +         {
  840. +         register char  *m = (char *) (p + 1) + n;
  841. + 
  842. +         *m++ = MAGIC1, *m++ = MAGIC1, *m++ = MAGIC1, *m = MAGIC1;
  843. +         }
  844. + #else
  845. +     p -> mh_size = n;
  846. + #endif /* rcheck */
  847. + #ifdef MSTATS
  848. +     nmalloc[nunits]++;
  849. +     nmal++;
  850. + #endif /* MSTATS */
  851. +     return (char *) (p + 1);}
  852. + 
  853. + free (mem)
  854. +     char *mem; {
  855. +     register struct mhead *p;
  856. +         {
  857. +         register char *ap = mem;
  858. + 
  859. +         ASSERT (ap != 0);
  860. +         p = (struct mhead *) ap - 1;
  861. +         ASSERT (p -> mh_alloc == ISALLOC);
  862. + #ifdef rcheck
  863. +         ASSERT (p -> mh_magic4 == MAGIC4);
  864. +         ap += p -> mh_nbytes;
  865. +         ASSERT (*ap++ == MAGIC1); ASSERT (*ap++ == MAGIC1);
  866. +         ASSERT (*ap++ == MAGIC1); ASSERT (*ap   == MAGIC1);
  867. + #endif /* rcheck */
  868. +         }
  869. +         {
  870. +         register int nunits = p -> mh_index;
  871. + 
  872. +         ASSERT (nunits <= 29);
  873. +         p -> mh_alloc = ISFREE;
  874. +         CHAIN (p) = nextf[nunits];
  875. +         nextf[nunits] = p;
  876. + #ifdef MSTATS
  877. +         nmalloc[nunits]--;
  878. +         nfre++;
  879. + #endif /* MSTATS */
  880. +         }
  881. +     }
  882. + 
  883. + char *
  884. + realloc (mem, n)
  885. +     char *mem;
  886. +     register unsigned n; {
  887. +     register struct mhead *p;
  888. +     register unsigned int tocopy;
  889. +     register int nbytes;
  890. +     register int nunits;
  891. + 
  892. +     if ((p = (struct mhead *) mem) == 0)
  893. +         return malloc (n);
  894. +     p--;
  895. +     nunits = p -> mh_index;
  896. +     ASSERT (p -> mh_alloc == ISALLOC);
  897. + #ifdef rcheck
  898. +     ASSERT (p -> mh_magic4 == MAGIC4);
  899. +         {
  900. +         register char *m = mem + (tocopy = p -> mh_nbytes);
  901. +         ASSERT (*m++ == MAGIC1); ASSERT (*m++ == MAGIC1);
  902. +         ASSERT (*m++ == MAGIC1); ASSERT (*m   == MAGIC1);
  903. +         }
  904. + #else
  905. +     if (p -> mh_index >= 13)
  906. +         tocopy = (1 << (p -> mh_index + 3)) - sizeof *p;
  907. +     else
  908. +         tocopy = p -> mh_size;
  909. + #endif /* rcheck */
  910. + 
  911. +     /* See if desired size rounds to same power of 2 as actual size. */
  912. +     nbytes = (n + sizeof *p + EXTRA + 7) & ~7;
  913. + 
  914. +     /* If ok, use the same block, just marking its size as changed.  */
  915. +     if (nbytes > (4 << nunits) && nbytes <= (8 << nunits)) {
  916. + #ifdef rcheck
  917. +         register char *m = mem + tocopy;
  918. +         *m++ = 0;  *m++ = 0;  *m++ = 0;  *m++ = 0;
  919. +         p-> mh_nbytes = n;
  920. +         m = mem + n;
  921. +         *m++ = MAGIC1;  *m++ = MAGIC1;  *m++ = MAGIC1;  *m++ = MAGIC1;
  922. + #else
  923. +         p -> mh_size = n;
  924. + #endif /* rcheck */
  925. +         return mem;}
  926. + 
  927. +     if (n < tocopy)
  928. +         tocopy = n;
  929. +         {
  930. +         register char *new;
  931. +         void bcopy();    /*HMS: here? */
  932. + 
  933. +         if ((new = malloc (n)) == 0)
  934. +             return 0;
  935. +         bcopy (mem, new, tocopy);
  936. +         free (mem);
  937. +         return new;
  938. +         }
  939. +     }
  940. + 
  941. + #ifdef MSTATS
  942. + /* Return statistics describing allocation of blocks of size 2**n. */
  943. + 
  944. + struct mstats_value {
  945. +     int blocksize;
  946. +     int nfree;
  947. +     int nused;
  948. +     };
  949. + 
  950. + struct mstats_value
  951. + malloc_stats (size)
  952. +     int size; {
  953. +     struct mstats_value v;
  954. +     register int i;
  955. +     register struct mhead *p;
  956. + 
  957. +     v.nfree = 0;
  958. + 
  959. +     if (size < 0 || size >= 30) {
  960. +         v.blocksize = 0;
  961. +         v.nused = 0;
  962. +         return v;}
  963. + 
  964. +     v.blocksize = 1 << (size + 3);
  965. +     v.nused = nmalloc[size];
  966. + 
  967. +     for (p = nextf[size]; p; p = CHAIN (p))
  968. +         v.nfree++;
  969. + 
  970. +     return v;}
  971. + #endif
  972. + 
  973. + /* how much space is available? */
  974. + 
  975. + unsigned freespace() {
  976. +       register int i, j;
  977. +       register struct mhead *p;
  978. +       register unsigned space = 0;
  979. +     int local;    /* address only is used */
  980. + 
  981. +     space = (char *)&local - sbrk(0);    /* stack space */
  982. + 
  983. +       for (i = 0; i < 30; i++) {
  984. +           for (j = 0, p = nextf[i]; p; p = CHAIN (p), j++) ;
  985. +           space += j * (1 << (i + 3));}
  986. + 
  987. +     return(space);}
  988. + 
  989. + /* How big is this cell? */
  990. + 
  991. + unsigned mc_size(cp)
  992. +     char *cp;{
  993. +     register struct mhead *p;
  994. + 
  995. +     if ((p = (struct mhead *) cp) == 0) {
  996. +         /*HMS? */
  997. +         }
  998. +     p--;
  999. + #ifdef rcheck
  1000. +     return p -> mh_nbytes;
  1001. + #else
  1002. +     return (1 << (p -> mh_index + 3)) - sizeof *p;
  1003. + /**/
  1004. + /*    if (p -> mh_index >= 13)
  1005. + /*        return (1 << (p -> mh_index + 3)) - sizeof *p;
  1006. + /*    else
  1007. + /*        return p -> mh_size;
  1008. + /**/
  1009. + #endif /* rcheck */
  1010. +     }
  1011. + 
  1012. + /*HMS: Really should use memcpy, if available... */
  1013. + 
  1014. + void bcopy(source, dest, len)
  1015. +     register char *source, *dest;
  1016. +     register len; {
  1017. +     register i;
  1018. +     
  1019. +     for (i = 0; i < len; i++)
  1020. +         *dest++ = *source++;}
  1021.  
  1022. Index: patch.c
  1023. Prereq: 2.0.1.4
  1024. *** patch.c.old    Fri Jun  3 15:27:40 1988
  1025. --- patch.c    Fri Jun  3 15:27:44 1988
  1026. ***************
  1027. *** 1,5 ****
  1028.   char rcsid[] =
  1029. !     "$Header: patch.c,v 2.0.1.4 87/02/16 14:00:04 lwall Exp $";
  1030.   
  1031.   /* patch - a program to apply diffs to original files
  1032.    *
  1033. --- 1,5 ----
  1034.   char rcsid[] =
  1035. !     "$Header: patch.c,v 2.0.1.5 88/06/03 15:09:37 lwall Locked $";
  1036.   
  1037.   /* patch - a program to apply diffs to original files
  1038.    *
  1039. ***************
  1040. *** 9,14 ****
  1041. --- 9,18 ----
  1042.    * money off of it, or pretend that you wrote it.
  1043.    *
  1044.    * $Log:    patch.c,v $
  1045. +  * Revision 2.0.1.5  88/06/03  15:09:37  lwall
  1046. +  * patch10: exit code improved.
  1047. +  * patch10: better support for non-flexfilenames.
  1048. +  * 
  1049.    * Revision 2.0.1.4  87/02/16  14:00:04  lwall
  1050.    * Short replacement caused spurious "Out of sync" message.
  1051.    * 
  1052. ***************
  1053. *** 117,122 ****
  1054. --- 121,127 ----
  1055.       LINENUM mymaxfuzz;
  1056.       int hunk = 0;
  1057.       int failed = 0;
  1058. +     int failtotal = 0;
  1059.       int i;
  1060.   
  1061.       setbuf(stderr, serrbuf);
  1062. ***************
  1063. *** 133,139 ****
  1064.       get_some_switches();
  1065.       
  1066.       /* make sure we clean up /tmp in case of disaster */
  1067. !     set_signals();
  1068.   
  1069.       for (
  1070.       open_patch_file(filearg[1]);
  1071. --- 138,144 ----
  1072.       get_some_switches();
  1073.       
  1074.       /* make sure we clean up /tmp in case of disaster */
  1075. !     set_signals(0);
  1076.   
  1077.       for (
  1078.       open_patch_file(filearg[1]);
  1079. ***************
  1080. *** 181,188 ****
  1081.                           /* dwim for reversed patch? */
  1082.               if (!pch_swap()) {
  1083.                   if (fuzz == Nulline)
  1084. !                 say1("\
  1085. ! Not enough memory to try swapped hunk!  Assuming unswapped.\n");
  1086.                   continue;
  1087.               }
  1088.               reverse = !reverse;
  1089. --- 186,193 ----
  1090.                           /* dwim for reversed patch? */
  1091.               if (!pch_swap()) {
  1092.                   if (fuzz == Nulline)
  1093. !                 say1(
  1094. ! "Not enough memory to try swapped hunk!  Assuming unswapped.\n");
  1095.                   continue;
  1096.               }
  1097.               reverse = !reverse;
  1098. ***************
  1099. *** 196,208 ****
  1100.                   if (!pch_swap())         /* put it back to normal */
  1101.                   fatal1("Lost hunk on alloc error!\n");
  1102.                   reverse = !reverse;
  1103. !                 say1("\
  1104. ! Ignoring previously applied (or reversed) patch.\n");
  1105.                   skip_rest_of_patch = TRUE;
  1106.               }
  1107.               else {
  1108. !                 ask3("\
  1109. ! %seversed (or previously applied) patch detected!  %s -R? [y] ",
  1110.                   reverse ? "R" : "Unr",
  1111.                   reverse ? "Assume" : "Ignore");
  1112.                   if (*buf == 'n') {
  1113. --- 201,213 ----
  1114.                   if (!pch_swap())         /* put it back to normal */
  1115.                   fatal1("Lost hunk on alloc error!\n");
  1116.                   reverse = !reverse;
  1117. !                 say1(
  1118. ! "Ignoring previously applied (or reversed) patch.\n");
  1119.                   skip_rest_of_patch = TRUE;
  1120.               }
  1121.               else {
  1122. !                 ask3(
  1123. ! "%seversed (or previously applied) patch detected!  %s -R? [y] ",
  1124.                   reverse ? "R" : "Unr",
  1125.                   reverse ? "Assume" : "Ignore");
  1126.                   if (*buf == 'n') {
  1127. ***************
  1128. *** 278,286 ****
  1129.       Fclose(rejfp);
  1130.       rejfp = Nullfp;
  1131.       if (failed) {
  1132.           if (!*rejname) {
  1133.           Strcpy(rejname, outname);
  1134. !         Strcat(rejname, ".rej");
  1135.           }
  1136.           if (skip_rest_of_patch) {
  1137.           say4("%d out of %d hunks ignored--saving rejects to %s\n",
  1138. --- 283,304 ----
  1139.       Fclose(rejfp);
  1140.       rejfp = Nullfp;
  1141.       if (failed) {
  1142. +         failtotal += failed;
  1143.           if (!*rejname) {
  1144.           Strcpy(rejname, outname);
  1145. ! #ifndef FLEXFILENAMES
  1146. !         {
  1147. !             char *s = rindex(rejname,'/');
  1148. ! 
  1149. !             if (!s)
  1150. !             s = rejname;
  1151. !             if (strlen(s) > 13)
  1152. !             if (s[12] == '.')    /* try to preserve difference */
  1153. !                 s[12] = s[13];    /* between .h, .c, .y, etc. */
  1154. !             s[13] = '\0';
  1155. !         }
  1156. ! #endif
  1157. !         Strcat(rejname, REJEXT);
  1158.           }
  1159.           if (skip_rest_of_patch) {
  1160.           say4("%d out of %d hunks ignored--saving rejects to %s\n",
  1161. ***************
  1162. *** 293,301 ****
  1163.           if (move_file(TMPREJNAME, rejname) < 0)
  1164.           trejkeep = TRUE;
  1165.       }
  1166. !     set_signals();
  1167.       }
  1168. !     my_exit(0);
  1169.   }
  1170.   
  1171.   /* Prepare to find the next patch to do in the patch file. */
  1172. --- 311,319 ----
  1173.           if (move_file(TMPREJNAME, rejname) < 0)
  1174.           trejkeep = TRUE;
  1175.       }
  1176. !     set_signals(1);
  1177.       }
  1178. !     my_exit(failtotal);
  1179.   }
  1180.   
  1181.   /* Prepare to find the next patch to do in the patch file. */
  1182. ***************
  1183. *** 366,371 ****
  1184. --- 384,393 ----
  1185.           origext = savestr(Argv[1]);
  1186.           Argc--,Argv++;
  1187.           break;
  1188. +         case 'B':
  1189. +         origprae = savestr(Argv[1]);
  1190. +         Argc--,Argv++;
  1191. +         break;
  1192.           case 'c':
  1193.           diff_type = CONTEXT_DIFF;
  1194.           break;
  1195. ***************
  1196. *** 383,388 ****
  1197. --- 405,412 ----
  1198.               Argc--,Argv++;
  1199.               s = Argv[0];
  1200.           }
  1201. +         if (!isalpha(*s))
  1202. +             fatal1("Argument to -D not an identifier.\n");
  1203.           Sprintf(if_defined, "#ifdef %s\n", s);
  1204.           Sprintf(not_defined, "#ifndef %s\n", s);
  1205.           Sprintf(end_defined, "#endif /* %s */\n", s);
  1206.  
  1207. Index: patch.man
  1208. Prereq: 2.0
  1209. *** patch.man.old    Fri Jun  3 15:27:54 1988
  1210. --- patch.man    Fri Jun  3 15:27:55 1988
  1211. ***************
  1212. *** 1,6 ****
  1213. ! ''' $Header: patch.man,v 2.0 86/09/17 15:39:09 lwall Exp $
  1214.   ''' 
  1215.   ''' $Log:    patch.man,v $
  1216.   ''' Revision 2.0  86/09/17  15:39:09  lwall
  1217.   ''' Baseline for netwide release.
  1218.   ''' 
  1219. --- 1,10 ----
  1220. ! .rn '' }`
  1221. ! ''' $Header: patch.man,v 2.0.1.1 88/06/03 15:12:51 lwall Locked $
  1222.   ''' 
  1223.   ''' $Log:    patch.man,v $
  1224. + ''' Revision 2.0.1.1  88/06/03  15:12:51  lwall
  1225. + ''' patch10: -B switch was contributed.
  1226. + ''' 
  1227.   ''' Revision 2.0  86/09/17  15:39:09  lwall
  1228.   ''' Baseline for netwide release.
  1229.   ''' 
  1230. ***************
  1231. *** 80,86 ****
  1232.   version.
  1233.   By default, the patched version is put in place of the original, with
  1234.   the original file backed up to the same name with the
  1235. ! extension \*(L".orig\*(R", or as specified by the
  1236.   .B -b
  1237.   switch.
  1238.   You may also specify where you want the output to go with a
  1239. --- 84,90 ----
  1240.   version.
  1241.   By default, the patched version is put in place of the original, with
  1242.   the original file backed up to the same name with the
  1243. ! extension \*(L".orig\*(R" or \*(L"~\*(R" , or as specified by the
  1244.   .B -b
  1245.   switch.
  1246.   You may also specify where you want the output to go with a
  1247. ***************
  1248. *** 137,143 ****
  1249.   .I patch
  1250.   cannot find a place to install that hunk of the patch, it will put the
  1251.   hunk out to a reject file, which normally is the name of the output file
  1252. ! plus \*(L".rej\*(R".
  1253.   (Note that the rejected hunk will come out in context diff form whether the
  1254.   input patch was a context diff or a normal diff.
  1255.   If the input was a normal diff, many of the contexts will simply be null.)
  1256. --- 141,147 ----
  1257.   .I patch
  1258.   cannot find a place to install that hunk of the patch, it will put the
  1259.   hunk out to a reject file, which normally is the name of the output file
  1260. ! plus \*(L".rej\*(R" or \*(L"#\*(R" .
  1261.   (Note that the rejected hunk will come out in context diff form whether the
  1262.   input patch was a context diff or a normal diff.
  1263.   If the input was a normal diff, many of the contexts will simply be null.)
  1264. ***************
  1265. *** 211,218 ****
  1266.   .TP 5
  1267.   .B \-b
  1268.   causes the next argument to be interpreted as the backup extension, to be
  1269. ! used in place of \*(L".orig\*(R".
  1270.   .TP 5
  1271.   .B \-c
  1272.   forces
  1273.   .I patch
  1274. --- 215,228 ----
  1275.   .TP 5
  1276.   .B \-b
  1277.   causes the next argument to be interpreted as the backup extension, to be
  1278. ! used in place of \*(L".orig\*(R" or \*(L"~\*(R".
  1279.   .TP 5
  1280. + .B \-B
  1281. + causes the next argument to be interpreted as a prefix to the backup file
  1282. + name. If this argument is specified any argument from -b will be ignored.
  1283. + This argument is an extension to Larry Wall's patch v2.0.1.4, patchlevel 8,
  1284. + made by M. Greim (greim@sbsvax.uucp).
  1285. + .TP 5
  1286.   .B \-c
  1287.   forces
  1288.   .I patch
  1289. ***************
  1290. *** 250,256 ****
  1291.   .TP 5
  1292.   .B \-F<number>
  1293.   sets the maximum fuzz factor.
  1294. ! This switch only applied to context diffs, and causes
  1295.   .I patch
  1296.   to ignore up to that many lines in looking for places to install a hunk.
  1297.   Note that a larger fuzz factor increases the odds of a faulty patch.
  1298. --- 260,266 ----
  1299.   .TP 5
  1300.   .B \-F<number>
  1301.   sets the maximum fuzz factor.
  1302. ! This switch only applies to context diffs, and causes
  1303.   .I patch
  1304.   to ignore up to that many lines in looking for places to install a hunk.
  1305.   Note that a larger fuzz factor increases the odds of a faulty patch.
  1306. ***************
  1307. *** 285,291 ****
  1308.   which controls how pathnames found in the patch file are treated, in case
  1309.   the you keep your files in a different directory than the person who sent
  1310.   out the patch.
  1311. ! The strip count specifies how many backslashes are to be stripped from
  1312.   the front of the pathname.
  1313.   (Any intervening directory names also go away.)
  1314.   For example, supposing the filename in the patch file was
  1315. --- 295,301 ----
  1316.   which controls how pathnames found in the patch file are treated, in case
  1317.   the you keep your files in a different directory than the person who sent
  1318.   out the patch.
  1319. ! The strip count specifies how many slashes are to be stripped from
  1320.   the front of the pathname.
  1321.   (Any intervening directory names also go away.)
  1322.   For example, supposing the filename in the patch file was
  1323. ***************
  1324. *** 413,418 ****
  1325. --- 423,433 ----
  1326.   .I patch
  1327.   is attempting to intuit whether there is a patch in that text and, if so,
  1328.   what kind of patch it is.
  1329. + .PP
  1330. + .I Patch
  1331. + will exit with a non-zero status if any reject files were created.
  1332. + When applying a set of patches in a loop it behooves you to check this
  1333. + exit status so you don't apply a later patch to a partially patched file.
  1334.   .SH CAVEATS
  1335.   .I Patch
  1336.   cannot tell if the line numbers are off in an ed script, and can only detect
  1337. ***************
  1338. *** 444,446 ****
  1339. --- 459,462 ----
  1340.   .I patch
  1341.   will think it is a reversed patch, and offer to un-apply the patch.
  1342.   This could be construed as a feature.
  1343. + .rn }` ''
  1344.  
  1345. Index: pch.c
  1346. Prereq: 2.0.1.6
  1347. *** pch.c.old    Fri Jun  3 15:28:08 1988
  1348. --- pch.c    Fri Jun  3 15:28:12 1988
  1349. ***************
  1350. *** 1,6 ****
  1351. ! /* $Header: pch.c,v 2.0.1.6 87/06/04 16:18:13 lwall Exp $
  1352.    *
  1353.    * $Log:    pch.c,v $
  1354.    * Revision 2.0.1.6  87/06/04  16:18:13  lwall
  1355.    * pch_swap didn't swap p_bfake and p_efake.
  1356.    * 
  1357. --- 1,10 ----
  1358. ! /* $Header: pch.c,v 2.0.1.7 88/06/03 15:13:28 lwall Locked $
  1359.    *
  1360.    * $Log:    pch.c,v $
  1361. +  * Revision 2.0.1.7  88/06/03  15:13:28  lwall
  1362. +  * patch10: Can now find patches in shar scripts.
  1363. +  * patch10: Hunks that swapped and then swapped back could core dump.
  1364. +  * 
  1365.    * Revision 2.0.1.6  87/06/04  16:18:13  lwall
  1366.    * pch_swap didn't swap p_bfake and p_efake.
  1367.    * 
  1368. ***************
  1369. *** 243,249 ****
  1370.           goto scan_exit;
  1371.           }
  1372.       }
  1373. !     for (s = buf; *s == ' ' || *s == '\t'; s++) {
  1374.           if (*s == '\t')
  1375.           indent += 8 - (indent % 8);
  1376.           else
  1377. --- 247,253 ----
  1378.           goto scan_exit;
  1379.           }
  1380.       }
  1381. !     for (s = buf; *s == ' ' || *s == '\t' || *s == 'X'; s++) {
  1382.           if (*s == '\t')
  1383.           indent += 8 - (indent % 8);
  1384.           else
  1385. ***************
  1386. *** 466,472 ****
  1387. --- 470,480 ----
  1388.           p_end++;
  1389.           assert(p_end < hunkmax);
  1390.           p_char[p_end] = *buf;
  1391. + #ifdef zilog
  1392. +         p_line[(short)p_end] = Nullch;
  1393. + #else
  1394.           p_line[p_end] = Nullch;
  1395. + #endif
  1396.           switch (*buf) {
  1397.           case '*':
  1398.           if (strnEQ(buf, "********", 8)) {
  1399. ***************
  1400. *** 494,499 ****
  1401. --- 502,509 ----
  1402.           for (s=buf; *s && !isdigit(*s); s++) ;
  1403.           if (!*s)
  1404.               goto malformed;
  1405. +         if (strnEQ(s,"0,0",3))
  1406. +             strcpy(s,s+2);
  1407.           p_first = (LINENUM) atol(s);
  1408.           while (isdigit(*s)) s++;
  1409.           if (*s == ',') {
  1410. ***************
  1411. *** 586,591 ****
  1412. --- 596,603 ----
  1413.           case '+':  case '!':
  1414.           repl_could_be_missing = FALSE;
  1415.             change_line:
  1416. +         if (buf[1] == '\n' && canonicalize)
  1417. +             strcpy(buf+1," \n");
  1418.           if (!isspace(buf[1]) && buf[1] != '>' && buf[1] != '<' &&
  1419.             repl_beginning && repl_could_be_missing) {
  1420.               repl_missing = TRUE;
  1421. ***************
  1422. *** 674,682 ****
  1423.       if (diff_type == CONTEXT_DIFF &&
  1424.         (fillcnt || (p_first > 1 && ptrn_copiable > 2*p_context)) ) {
  1425.           if (verbose)
  1426. !         say1("\
  1427. ! (Fascinating--this is really a new-style context diff but without the telltale\n\
  1428. ! extra asterisks on the *** line that usually indicate the new style...)\n");
  1429.           diff_type = NEW_CONTEXT_DIFF;
  1430.       }
  1431.       
  1432. --- 686,695 ----
  1433.       if (diff_type == CONTEXT_DIFF &&
  1434.         (fillcnt || (p_first > 1 && ptrn_copiable > 2*p_context)) ) {
  1435.           if (verbose)
  1436. !         say4("%s\n%s\n%s\n",
  1437. ! "(Fascinating--this is really a new-style context diff but without",
  1438. ! "the telltale extra asterisks on the *** line that usually indicate",
  1439. ! "the new style...)");
  1440.           diff_type = NEW_CONTEXT_DIFF;
  1441.       }
  1442.       
  1443. ***************
  1444. *** 844,850 ****
  1445.       Reg2 int indent = 0;
  1446.   
  1447.       if (p_indent && ret != Nullch) {
  1448. !     for (s=buf; indent < p_indent && (*s == ' ' || *s == '\t'); s++) {
  1449.           if (*s == '\t')
  1450.           indent += 8 - (indent % 7);
  1451.           else
  1452. --- 857,864 ----
  1453.       Reg2 int indent = 0;
  1454.   
  1455.       if (p_indent && ret != Nullch) {
  1456. !     for (s=buf;
  1457. !       indent < p_indent && (*s == ' ' || *s == '\t' || *s == 'X'); s++) {
  1458.           if (*s == '\t')
  1459.           indent += 8 - (indent % 7);
  1460.           else
  1461. ***************
  1462. *** 905,913 ****
  1463.       i++;
  1464.       }
  1465.       if (p_efake >= 0) {            /* fix non-freeable ptr range */
  1466. !     n = p_end - i + 1;
  1467. !     if (p_efake > i)
  1468. !         n = -n;
  1469.       p_efake += n;
  1470.       p_bfake += n;
  1471.       }
  1472. --- 919,928 ----
  1473.       i++;
  1474.       }
  1475.       if (p_efake >= 0) {            /* fix non-freeable ptr range */
  1476. !     if (p_efake <= i)
  1477. !         n = p_end - i + 1;
  1478. !     else
  1479. !         n = -i;
  1480.       p_efake += n;
  1481.       p_bfake += n;
  1482.       }
  1483. ***************
  1484. *** 1104,1108 ****
  1485.       }
  1486.       else
  1487.       chmod(outname, filemode);
  1488. !     set_signals();
  1489.   }
  1490. --- 1119,1123 ----
  1491.       }
  1492.       else
  1493.       chmod(outname, filemode);
  1494. !     set_signals(1);
  1495.   }
  1496.  
  1497. Index: util.c
  1498. *** util.c.old    Fri Jun  3 15:28:23 1988
  1499. --- util.c    Fri Jun  3 15:28:24 1988
  1500. ***************
  1501. *** 31,38 ****
  1502.       return 0;
  1503.       }
  1504.   
  1505. !     Strcpy(bakname, to);
  1506. !     Strcat(bakname, origext?origext:ORIGEXT);
  1507.       if (stat(to, &filestat) >= 0) {    /* output file exists */
  1508.       dev_t to_device = filestat.st_dev;
  1509.       ino_t to_inode  = filestat.st_ino;
  1510. --- 31,43 ----
  1511.       return 0;
  1512.       }
  1513.   
  1514. !     if (origprae) {
  1515. !         Strcpy (bakname, origprae);
  1516. !         Strcat(bakname, to);
  1517. !     } else {
  1518. !            Strcpy(bakname, to);
  1519. !         Strcat(bakname, origext?origext:ORIGEXT);
  1520. !     }
  1521.       if (stat(to, &filestat) >= 0) {    /* output file exists */
  1522.       dev_t to_device = filestat.st_dev;
  1523.       ino_t to_inode  = filestat.st_ino;
  1524. ***************
  1525. *** 155,161 ****
  1526.   void
  1527.   say(pat,arg1,arg2,arg3)
  1528.   char *pat;
  1529. ! int arg1,arg2,arg3;
  1530.   {
  1531.       fprintf(stderr, pat, arg1, arg2, arg3);
  1532.       Fflush(stderr);
  1533. --- 160,166 ----
  1534.   void
  1535.   say(pat,arg1,arg2,arg3)
  1536.   char *pat;
  1537. ! long arg1,arg2,arg3;
  1538.   {
  1539.       fprintf(stderr, pat, arg1, arg2, arg3);
  1540.       Fflush(stderr);
  1541. ***************
  1542. *** 166,172 ****
  1543.   void                /* very void */
  1544.   fatal(pat,arg1,arg2,arg3)
  1545.   char *pat;
  1546. ! int arg1,arg2,arg3;
  1547.   {
  1548.       void my_exit();
  1549.   
  1550. --- 171,177 ----
  1551.   void                /* very void */
  1552.   fatal(pat,arg1,arg2,arg3)
  1553.   char *pat;
  1554. ! long arg1,arg2,arg3;
  1555.   {
  1556.       void my_exit();
  1557.   
  1558. ***************
  1559. *** 179,185 ****
  1560.   void
  1561.   ask(pat,arg1,arg2,arg3)
  1562.   char *pat;
  1563. ! int arg1,arg2,arg3;
  1564.   {
  1565.       int ttyfd;
  1566.       int r;
  1567. --- 184,190 ----
  1568.   void
  1569.   ask(pat,arg1,arg2,arg3)
  1570.   char *pat;
  1571. ! long arg1,arg2,arg3;
  1572.   {
  1573.       int ttyfd;
  1574.       int r;
  1575. ***************
  1576. *** 218,237 ****
  1577.       if (!tty2)
  1578.       say1(buf);
  1579.   }
  1580. ! #endif lint
  1581.   
  1582.   /* How to handle certain events when not in a critical region. */
  1583.   
  1584.   void
  1585. ! set_signals()
  1586.   {
  1587.       void my_exit();
  1588. - 
  1589.   #ifndef lint
  1590. !     if (signal(SIGHUP, SIG_IGN) != SIG_IGN)
  1591. !     Signal(SIGHUP, my_exit);
  1592. !     if (signal(SIGINT, SIG_IGN) != SIG_IGN)
  1593. !     Signal(SIGINT, my_exit);
  1594.   #endif
  1595.   }
  1596.   
  1597. --- 223,254 ----
  1598.       if (!tty2)
  1599.       say1(buf);
  1600.   }
  1601. ! #endif /* lint */
  1602.   
  1603.   /* How to handle certain events when not in a critical region. */
  1604.   
  1605.   void
  1606. ! set_signals(reset)
  1607. ! int reset;
  1608.   {
  1609.       void my_exit();
  1610.   #ifndef lint
  1611. ! #ifdef VOIDSIG
  1612. !     static void (*hupval)(),(*intval)();
  1613. ! #else
  1614. !     static int (*hupval)(),(*intval)();
  1615. ! #endif
  1616. ! 
  1617. !     if (!reset) {
  1618. !     hupval = signal(SIGHUP, SIG_IGN);
  1619. !     if (hupval != SIG_IGN)
  1620. !         hupval = my_exit;
  1621. !     intval = signal(SIGINT, SIG_IGN);
  1622. !     if (intval != SIG_IGN)
  1623. !         intval = my_exit;
  1624. !     }
  1625. !     Signal(SIGHUP, hupval);
  1626. !     Signal(SIGINT, intval);
  1627.   #endif
  1628.   }
  1629.   
  1630.  
  1631.  
  1632.