home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / misc / volume25 / perl / patch17 < prev    next >
Encoding:
Text File  |  1991-11-13  |  46.9 KB  |  1,932 lines
  1. Newsgroups: comp.sources.misc
  2. From: lwall@netlabs.com (Larry Wall)
  3. Subject:  v25i066:  perl - The perl programming language, Patch17
  4. Message-ID: <1991Nov13.214600.3968@sparky.imd.sterling.com>
  5. X-Md4-Signature: 2ca4c293c1a20f9300b96dd274f08234
  6. Date: Wed, 13 Nov 1991 21:46:00 GMT
  7. Approved: kent@sparky.imd.sterling.com
  8.  
  9. Submitted-by: lwall@netlabs.com (Larry Wall)
  10. Posting-number: Volume 25, Issue 66
  11. Archive-name: perl/patch17
  12. Environment: UNIX, MS-DOS, OS2
  13. Patch-To: perl: Volume 18, Issue 19-54
  14.  
  15. System: perl version 4.0
  16. Patch #: 17
  17. Priority: MED-HIGH
  18. Subject: patch #11, continued
  19.  
  20. Description:
  21.     See patch #11.
  22.  
  23. Fix:    From rn, say "| patch -p -N -d DIR", where DIR is your perl source
  24.     directory.  Outside of rn, say "cd DIR; patch -p -N <thisarticle".
  25.     If you don't have the patch program, apply the following by hand,
  26.     or get patch (version 2.0, latest patchlevel).
  27.  
  28.     After patching:
  29.         *** DO NOTHING--INSTALL ALL PATCHES UP THROUGH #18 FIRST ***
  30.  
  31.     If patch indicates that patchlevel is the wrong version, you may need
  32.     to apply one or more previous patches, or the patch may already
  33.     have been applied.  See the patchlevel.h file to find out what has or
  34.     has not been applied.  In any event, don't continue with the patch.
  35.  
  36.     If you are missing previous patches they can be obtained from me:
  37.  
  38.     Larry Wall
  39.     lwall@netlabs.com
  40.  
  41.     If you send a mail message of the following form it will greatly speed
  42.     processing:
  43.  
  44.     Subject: Command
  45.     @SH mailpatch PATH perl 4.0 LIST
  46.            ^ note the c
  47.  
  48.     where PATH is a return path FROM ME TO YOU either in Internet notation,
  49.     or in bang notation from some well-known host, and LIST is the number
  50.     of one or more patches you need, separated by spaces, commas, and/or
  51.     hyphens.  Saying 35- says everything from 35 to the end.
  52.  
  53.  
  54. Index: patchlevel.h
  55. Prereq: 16
  56. 1c1
  57. < #define PATCHLEVEL 16
  58. ---
  59. > #define PATCHLEVEL 17
  60.  
  61. Index: str.h
  62. *** str.h.old    Tue Nov  5 19:27:58 1991
  63. --- str.h    Tue Nov  5 19:27:58 1991
  64. ***************
  65. *** 1,4 ****
  66. ! /* $RCSfile: str.h,v $$Revision: 4.0.1.2 $$Date: 91/06/07 11:58:33 $
  67.    *
  68.    *    Copyright (c) 1991, Larry Wall
  69.    *
  70. --- 1,4 ----
  71. ! /* $RCSfile: str.h,v $$Revision: 4.0.1.3 $$Date: 91/11/05 18:41:47 $
  72.    *
  73.    *    Copyright (c) 1991, Larry Wall
  74.    *
  75. ***************
  76. *** 6,11 ****
  77. --- 6,15 ----
  78.    *    License or the Artistic License, as specified in the README file.
  79.    *
  80.    * $Log:    str.h,v $
  81. +  * Revision 4.0.1.3  91/11/05  18:41:47  lwall
  82. +  * patch11: random cleanup
  83. +  * patch11: solitary subroutine references no longer trigger typo warnings
  84. +  * 
  85.    * Revision 4.0.1.2  91/06/07  11:58:33  lwall
  86.    * patch4: new copyright notice
  87.    * 
  88. ***************
  89. *** 32,39 ****
  90.       STRLEN    str_cur;    /* length of str_ptr as a C string */
  91.       STR        *str_magic;    /* while free, link to next free str */
  92.                   /* while in use, ptr to "key" for magic items */
  93. !     char    str_pok;    /* state of str_ptr */
  94. !     char    str_nok;    /* state of str_nval */
  95.       unsigned char str_rare;    /* used by search strings */
  96.       unsigned char str_state;    /* one of SS_* below */
  97.                   /* also used by search strings for backoff */
  98. --- 36,43 ----
  99.       STRLEN    str_cur;    /* length of str_ptr as a C string */
  100.       STR        *str_magic;    /* while free, link to next free str */
  101.                   /* while in use, ptr to "key" for magic items */
  102. !     unsigned char str_pok;    /* state of str_ptr */
  103. !     unsigned char str_nok;    /* state of str_nval */
  104.       unsigned char str_rare;    /* used by search strings */
  105.       unsigned char str_state;    /* one of SS_* below */
  106.                   /* also used by search strings for backoff */
  107. ***************
  108. *** 57,64 ****
  109.       STRLEN    str_cur;    /* length of str_ptr as a C string */
  110.       STR        *str_magic;    /* while free, link to next free str */
  111.                   /* while in use, ptr to "key" for magic items */
  112. !     char    str_pok;    /* state of str_ptr */
  113. !     char    str_nok;    /* state of str_nval */
  114.       unsigned char str_rare;    /* used by search strings */
  115.       unsigned char str_state;    /* one of SS_* below */
  116.                   /* also used by search strings for backoff */
  117. --- 61,68 ----
  118.       STRLEN    str_cur;    /* length of str_ptr as a C string */
  119.       STR        *str_magic;    /* while free, link to next free str */
  120.                   /* while in use, ptr to "key" for magic items */
  121. !     unsigned char str_pok;    /* state of str_ptr */
  122. !     unsigned char str_nok;    /* state of str_nval */
  123.       unsigned char str_rare;    /* used by search strings */
  124.       unsigned char str_state;    /* one of SS_* below */
  125.                   /* also used by search strings for backoff */
  126. ***************
  127. *** 136,138 ****
  128. --- 140,144 ----
  129.   void str_magic();
  130.   void str_insert();
  131.   STRLEN str_len();
  132. + 
  133. + #define MULTI    (3)
  134.  
  135. Index: t/cmd/subval.t
  136. Prereq: 4.0
  137. *** t/cmd/subval.t.old    Tue Nov  5 19:28:00 1991
  138. --- t/cmd/subval.t    Tue Nov  5 19:28:00 1991
  139. ***************
  140. *** 1,6 ****
  141.   #!./perl
  142.   
  143. ! # $Header: subval.t,v 4.0 91/03/20 01:49:40 lwall Locked $
  144.   
  145.   sub foo1 {
  146.       'true1';
  147. --- 1,6 ----
  148.   #!./perl
  149.   
  150. ! # $RCSfile: subval.t,v $$Revision: 4.0.1.1 $$Date: 91/11/05 18:42:31 $
  151.   
  152.   sub foo1 {
  153.       'true1';
  154. ***************
  155. *** 102,108 ****
  156.   sub somesub {
  157.       local($num,$P,$F,$L) = @_;
  158.       ($p,$f,$l) = caller;
  159. !     print "$p:$f:$l" eq "$P:$F:$L" ? "ok $num\n" : "not ok $num\n";
  160.   }
  161.   
  162.   &somesub(27, 'main', __FILE__, __LINE__);
  163. --- 102,108 ----
  164.   sub somesub {
  165.       local($num,$P,$F,$L) = @_;
  166.       ($p,$f,$l) = caller;
  167. !     print "$p:$f:$l" eq "$P:$F:$L" ? "ok $num\n" : "not ok $num $p:$f:$l ne $P:$F:$L\n";
  168.   }
  169.   
  170.   &somesub(27, 'main', __FILE__, __LINE__);
  171.  
  172. Index: hints/sunos_4_0_1.sh
  173. *** hints/sunos_4_0_1.sh.old    Tue Nov  5 19:26:39 1991
  174. --- hints/sunos_4_0_1.sh    Tue Nov  5 19:26:39 1991
  175. ***************
  176. *** 1 ****
  177. ! $ccflags="$ccflags -DFPUTS_BOTCH"
  178. --- 1 ----
  179. ! ccflags="$ccflags -DFPUTS_BOTCH"
  180.  
  181. Index: hints/sunos_4_0_2.sh
  182. *** hints/sunos_4_0_2.sh.old    Tue Nov  5 19:26:41 1991
  183. --- hints/sunos_4_0_2.sh    Tue Nov  5 19:26:41 1991
  184. ***************
  185. *** 1 ****
  186. ! $ccflags="$ccflags -DFPUTS_BOTCH"
  187. --- 1 ----
  188. ! ccflags="$ccflags -DFPUTS_BOTCH"
  189.  
  190. Index: hints/ti1500.sh
  191. *** hints/ti1500.sh.old    Tue Nov  5 19:26:43 1991
  192. --- hints/ti1500.sh    Tue Nov  5 19:26:43 1991
  193. ***************
  194. *** 0 ****
  195. --- 1 ----
  196. + d_mymalloc='undef'
  197.  
  198. Index: toke.c
  199. *** toke.c.old    Tue Nov  5 19:28:09 1991
  200. --- toke.c    Tue Nov  5 19:28:10 1991
  201. ***************
  202. *** 1,4 ****
  203. ! /* $RCSfile: toke.c,v $$Revision: 4.0.1.3 $$Date: 91/06/10 01:32:26 $
  204.    *
  205.    *    Copyright (c) 1991, Larry Wall
  206.    *
  207. --- 1,4 ----
  208. ! /* $RCSfile: toke.c,v $$Revision: 4.0.1.4 $$Date: 91/11/05 19:02:48 $
  209.    *
  210.    *    Copyright (c) 1991, Larry Wall
  211.    *
  212. ***************
  213. *** 6,11 ****
  214. --- 6,19 ----
  215.    *    License or the Artistic License, as specified in the README file.
  216.    *
  217.    * $Log:    toke.c,v $
  218. +  * Revision 4.0.1.4  91/11/05  19:02:48  lwall
  219. +  * patch11: \x and \c were subject to double interpretation in regexps
  220. +  * patch11: prepared for ctype implementations that don't define isascii()
  221. +  * patch11: nested list operators could miscount parens
  222. +  * patch11: once-thru blocks didn't display right in the debugger
  223. +  * patch11: sort eval "whatever" didn't work
  224. +  * patch11: underscore is now allowed within literal octal and hex numbers
  225. +  * 
  226.    * Revision 4.0.1.3  91/06/10  01:32:26  lwall
  227.    * patch10: m'$foo' now treats string as single quoted
  228.    * patch10: certain pattern optimizations were botched
  229. ***************
  230. *** 41,47 ****
  231.   
  232.   /* which backslash sequences to keep in m// or s// */
  233.   
  234. ! static char *patleave = "\\.^$@dDwWsSbB+*?|()-nrtf0123456789[{]}";
  235.   
  236.   char *reparse;        /* if non-null, scanident found ${foo[$bar]} */
  237.   
  238. --- 49,55 ----
  239.   
  240.   /* which backslash sequences to keep in m// or s// */
  241.   
  242. ! static char *patleave = "\\.^$@dDwWsSbB+*?|()-nrtfeaxc0123456789[{]}";
  243.   
  244.   char *reparse;        /* if non-null, scanident found ${foo[$bar]} */
  245.   
  246. ***************
  247. *** 92,98 ****
  248.    * paren came before the listop rather than after.
  249.    */
  250.   #define LOP(f) return(CLINE, *s == '(' || (s = skipspace(s), *s == '(') ? \
  251. !     (*s = META('('), bufptr = oldbufptr, '(') : \
  252.       (yylval.ival=f,expectterm = TRUE,bufptr = s,(int)LISTOP))
  253.   /* grandfather return to old style */
  254.   #define OLDLOP(f) return(yylval.ival=f,expectterm = TRUE,bufptr = s,(int)LISTOP)
  255. --- 100,106 ----
  256.    * paren came before the listop rather than after.
  257.    */
  258.   #define LOP(f) return(CLINE, *s == '(' || (s = skipspace(s), *s == '(') ? \
  259. !     (*s = (char) META('('), bufptr = oldbufptr, '(') : \
  260.       (yylval.ival=f,expectterm = TRUE,bufptr = s,(int)LISTOP))
  261.   /* grandfather return to old style */
  262.   #define OLDLOP(f) return(yylval.ival=f,expectterm = TRUE,bufptr = s,(int)LISTOP)
  263. ***************
  264. *** 101,107 ****
  265.   skipspace(s)
  266.   register char *s;
  267.   {
  268. !     while (s < bufend && isascii(*s) && isspace(*s))
  269.       s++;
  270.       return s;
  271.   }
  272. --- 109,115 ----
  273.   skipspace(s)
  274.   register char *s;
  275.   {
  276. !     while (s < bufend && isSPACE(*s))
  277.       s++;
  278.       return s;
  279.   }
  280. ***************
  281. *** 175,182 ****
  282.   #endif
  283.   #ifdef BADSWITCH
  284.       if (*s & 128) {
  285. !     if ((*s & 127) == '(')
  286.           *s++ = '(';
  287.       else
  288.           warn("Unrecognized character \\%03o ignored", *s++ & 255);
  289.       goto retry;
  290. --- 183,192 ----
  291.   #endif
  292.   #ifdef BADSWITCH
  293.       if (*s & 128) {
  294. !     if ((*s & 127) == '(') {
  295.           *s++ = '(';
  296. +         oldbufptr = s;
  297. +     }
  298.       else
  299.           warn("Unrecognized character \\%03o ignored", *s++ & 255);
  300.       goto retry;
  301. ***************
  302. *** 184,191 ****
  303.   #endif
  304.       switch (*s) {
  305.       default:
  306. !     if ((*s & 127) == '(')
  307.           *s++ = '(';
  308.       else
  309.           warn("Unrecognized character \\%03o ignored", *s++ & 255);
  310.       goto retry;
  311. --- 194,203 ----
  312.   #endif
  313.       switch (*s) {
  314.       default:
  315. !     if ((*s & 127) == '(') {
  316.           *s++ = '(';
  317. +         oldbufptr = s;
  318. +     }
  319.       else
  320.           warn("Unrecognized character \\%03o ignored", *s++ & 255);
  321.       goto retry;
  322. ***************
  323. *** 238,244 ****
  324.           if (rsfp) {
  325.               if (preprocess)
  326.               (void)mypclose(rsfp);
  327. !             else if (rsfp == stdin)
  328.               clearerr(stdin);
  329.               else
  330.               (void)fclose(rsfp);
  331. --- 250,256 ----
  332.           if (rsfp) {
  333.               if (preprocess)
  334.               (void)mypclose(rsfp);
  335. !             else if ((FILE*)rsfp == stdin)
  336.               clearerr(stdin);
  337.               else
  338.               (void)fclose(rsfp);
  339. ***************
  340. *** 283,297 ****
  341.               if (*s == ' ')
  342.               s++;
  343.               cmd = s;
  344. !             while (s < bufend && !isspace(*s))
  345.               s++;
  346.               *s++ = '\0';
  347. !             while (s < bufend && isspace(*s))
  348.               s++;
  349.               if (s < bufend) {
  350.               Newz(899,newargv,origargc+3,char*);
  351.               newargv[1] = s;
  352. !             while (s < bufend && !isspace(*s))
  353.                   s++;
  354.               *s = '\0';
  355.               Copy(origargv+1, newargv+2, origargc+1, char*);
  356. --- 295,309 ----
  357.               if (*s == ' ')
  358.               s++;
  359.               cmd = s;
  360. !             while (s < bufend && !isSPACE(*s))
  361.               s++;
  362.               *s++ = '\0';
  363. !             while (s < bufend && isSPACE(*s))
  364.               s++;
  365.               if (s < bufend) {
  366.               Newz(899,newargv,origargc+3,char*);
  367.               newargv[1] = s;
  368. !             while (s < bufend && !isSPACE(*s))
  369.                   s++;
  370.               *s = '\0';
  371.               Copy(origargv+1, newargv+2, origargc+1, char*);
  372. ***************
  373. *** 304,310 ****
  374.           }
  375.           }
  376.           else {
  377. !         while (s < bufend && isspace(*s))
  378.               s++;
  379.           if (*s == ':')    /* for csh's that have to exec sh scripts */
  380.               s++;
  381. --- 316,322 ----
  382.           }
  383.           }
  384.           else {
  385. !         while (s < bufend && isSPACE(*s))
  386.               s++;
  387.           if (*s == ':')    /* for csh's that have to exec sh scripts */
  388.               s++;
  389. ***************
  390. *** 316,326 ****
  391.       goto retry;
  392.       case '#':
  393.       if (preprocess && s == str_get(linestr) &&
  394. !            s[1] == ' ' && isdigit(s[2])) {
  395. !         curcmd->c_line = atoi(s+2)-1;
  396. !         for (s += 2; isdigit(*s); s++) ;
  397.           d = bufend;
  398. !         while (s < d && isspace(*s)) s++;
  399.           s[strlen(s)-1] = '\0';    /* wipe out newline */
  400.           if (*s == '"') {
  401.           s++;
  402. --- 328,341 ----
  403.       goto retry;
  404.       case '#':
  405.       if (preprocess && s == str_get(linestr) &&
  406. !            s[1] == ' ' && (isDIGIT(s[2]) || strnEQ(s+2,"line ",5)) ) {
  407. !         while (*s && !isDIGIT(*s))
  408. !         s++;
  409. !         curcmd->c_line = atoi(s)-1;
  410. !         while (isDIGIT(*s))
  411. !         s++;
  412.           d = bufend;
  413. !         while (s < d && isSPACE(*s)) s++;
  414.           s[strlen(s)-1] = '\0';    /* wipe out newline */
  415.           if (*s == '"') {
  416.           s++;
  417. ***************
  418. *** 355,361 ****
  419.       }
  420.       goto retry;
  421.       case '-':
  422. !     if (s[1] && isalpha(s[1]) && !isalpha(s[2])) {
  423.           s++;
  424.           switch (*s++) {
  425.           case 'r': FTST(O_FTEREAD);
  426. --- 370,376 ----
  427.       }
  428.       goto retry;
  429.       case '-':
  430. !     if (s[1] && isALPHA(s[1]) && !isALPHA(s[2])) {
  431.           s++;
  432.           switch (*s++) {
  433.           case 'r': FTST(O_FTEREAD);
  434. ***************
  435. *** 441,447 ****
  436.       OPERATOR(tmp);
  437.       case '{':
  438.       tmp = *s++;
  439. !     if (isspace(*s) || *s == '#')
  440.           cmdline = NOLINE;   /* invalidate current command line number */
  441.       OPERATOR(tmp);
  442.       case ';':
  443. --- 456,463 ----
  444.       OPERATOR(tmp);
  445.       case '{':
  446.       tmp = *s++;
  447. !     yylval.ival = curcmd->c_line;
  448. !     if (isSPACE(*s) || *s == '#')
  449.           cmdline = NOLINE;   /* invalidate current command line number */
  450.       OPERATOR(tmp);
  451.       case ';':
  452. ***************
  453. *** 464,472 ****
  454.       s--;
  455.       if (expectterm) {
  456.           d = bufend;
  457. !         while (s < d && isspace(*s))
  458.           s++;
  459. !         if (isalpha(*s) || *s == '_' || *s == '\'')
  460.           *(--s) = '\\';    /* force next ident to WORD */
  461.           OPERATOR(AMPER);
  462.       }
  463. --- 480,488 ----
  464.       s--;
  465.       if (expectterm) {
  466.           d = bufend;
  467. !         while (s < d && isSPACE(*s))
  468.           s++;
  469. !         if (isALPHA(*s) || *s == '_' || *s == '\'')
  470.           *(--s) = '\\';    /* force next ident to WORD */
  471.           OPERATOR(AMPER);
  472.       }
  473. ***************
  474. *** 526,533 ****
  475.   
  476.   #define SNARFWORD \
  477.       d = tokenbuf; \
  478. !     while (isascii(*s) && \
  479. !       (isalpha(*s) || isdigit(*s) || *s == '_' || *s == '\'')) \
  480.           *d++ = *s++; \
  481.       while (d[-1] == '\'') \
  482.           d--,s--; \
  483. --- 542,548 ----
  484.   
  485.   #define SNARFWORD \
  486.       d = tokenbuf; \
  487. !     while (isALNUM(*s) || *s == '\'') \
  488.           *d++ = *s++; \
  489.       while (d[-1] == '\'') \
  490.           d--,s--; \
  491. ***************
  492. *** 535,541 ****
  493.       d = tokenbuf;
  494.   
  495.       case '$':
  496. !     if (s[1] == '#' && (isalpha(s[2]) || s[2] == '_')) {
  497.           s++;
  498.           s = scanident(s,bufend,tokenbuf);
  499.           yylval.stabval = aadd(stabent(tokenbuf,TRUE));
  500. --- 550,556 ----
  501.       d = tokenbuf;
  502.   
  503.       case '$':
  504. !     if (s[1] == '#' && (isALPHA(s[2]) || s[2] == '_')) {
  505.           s++;
  506.           s = scanident(s,bufend,tokenbuf);
  507.           yylval.stabval = aadd(stabent(tokenbuf,TRUE));
  508. ***************
  509. *** 574,580 ****
  510.       OPERATOR(tmp);
  511.   
  512.       case '.':
  513. !     if (!expectterm || !isdigit(s[1])) {
  514.           tmp = *s++;
  515.           if (*s == tmp) {
  516.           s++;
  517. --- 589,595 ----
  518.       OPERATOR(tmp);
  519.   
  520.       case '.':
  521. !     if (!expectterm || !isDIGIT(s[1])) {
  522.           tmp = *s++;
  523.           if (*s == tmp) {
  524.           s++;
  525. ***************
  526. *** 613,618 ****
  527. --- 628,634 ----
  528.           STAB *stab;
  529.           int fd;
  530.   
  531. +         /*SUPPRESS 560*/
  532.           if (stab = stabent("DATA",FALSE)) {
  533.               stab->str_pok |= SP_MULTI;
  534.               stab_io(stab) = stio_new();
  535. ***************
  536. *** 623,629 ****
  537.   #endif
  538.               if (preprocess)
  539.               stab_io(stab)->type = '|';
  540. !             else if (rsfp == stdin)
  541.               stab_io(stab)->type = '-';
  542.               else
  543.               stab_io(stab)->type = '<';
  544. --- 639,645 ----
  545.   #endif
  546.               if (preprocess)
  547.               stab_io(stab)->type = '|';
  548. !             else if ((FILE*)rsfp == stdin)
  549.               stab_io(stab)->type = '-';
  550.               else
  551.               stab_io(stab)->type = '<';
  552. ***************
  553. *** 670,676 ****
  554.           UNI(O_CALLER);
  555.       if (strEQ(d,"crypt")) {
  556.   #ifdef FCRYPT
  557. !         init_des();
  558.   #endif
  559.           FUN2(O_CRYPT);
  560.       }
  561. --- 686,695 ----
  562.           UNI(O_CALLER);
  563.       if (strEQ(d,"crypt")) {
  564.   #ifdef FCRYPT
  565. !         static int cryptseen = 0;
  566. ! 
  567. !         if (!cryptseen++)
  568. !         init_des();
  569.   #endif
  570.           FUN2(O_CRYPT);
  571.       }
  572. ***************
  573. *** 689,697 ****
  574.       SNARFWORD;
  575.       if (strEQ(d,"do")) {
  576.           d = bufend;
  577. !         while (s < d && isspace(*s))
  578.           s++;
  579. !         if (isalpha(*s) || *s == '_')
  580.           *(--s) = '\\';    /* force next ident to WORD */
  581.           OPERATOR(DO);
  582.       }
  583. --- 708,716 ----
  584.       SNARFWORD;
  585.       if (strEQ(d,"do")) {
  586.           d = bufend;
  587. !         while (s < d && isSPACE(*s))
  588.           s++;
  589. !         if (isALPHA(*s) || *s == '_')
  590.           *(--s) = '\\';    /* force next ident to WORD */
  591.           OPERATOR(DO);
  592.       }
  593. ***************
  594. *** 755,763 ****
  595.       }
  596.       if (strEQ(d,"format")) {
  597.           d = bufend;
  598. !         while (s < d && isspace(*s))
  599.           s++;
  600. !         if (isalpha(*s) || *s == '_')
  601.           *(--s) = '\\';    /* force next ident to WORD */
  602.           in_format = TRUE;
  603.           allstabs = TRUE;        /* must initialize everything since */
  604. --- 774,782 ----
  605.       }
  606.       if (strEQ(d,"format")) {
  607.           d = bufend;
  608. !         while (s < d && isSPACE(*s))
  609.           s++;
  610. !         if (isALPHA(*s) || *s == '_')
  611.           *(--s) = '\\';    /* force next ident to WORD */
  612.           in_format = TRUE;
  613.           allstabs = TRUE;        /* must initialize everything since */
  614. ***************
  615. *** 1125,1135 ****
  616.           if (strEQ(d,"sort")) {
  617.           checkcomma(s,"subroutine name");
  618.           d = bufend;
  619. !         while (s < d && isascii(*s) && isspace(*s)) s++;
  620.           if (*s == ';' || *s == ')')        /* probably a close */
  621.               fatal("sort is now a reserved word");
  622. !         if (isascii(*s) && (isalpha(*s) || *s == '_')) {
  623. !             for (d = s; isalpha(*d) || isdigit(*d) || *d == '_'; d++) ;
  624.               strncpy(tokenbuf,s,d-s);
  625.               if (strNE(tokenbuf,"keys") &&
  626.               strNE(tokenbuf,"values") &&
  627. --- 1144,1155 ----
  628.           if (strEQ(d,"sort")) {
  629.           checkcomma(s,"subroutine name");
  630.           d = bufend;
  631. !         while (s < d && isSPACE(*s)) s++;
  632.           if (*s == ';' || *s == ')')        /* probably a close */
  633.               fatal("sort is now a reserved word");
  634. !         if (isALPHA(*s) || *s == '_') {
  635. !             /*SUPPRESS 530*/
  636. !             for (d = s; isALNUM(*d); d++) ;
  637.               strncpy(tokenbuf,s,d-s);
  638.               if (strNE(tokenbuf,"keys") &&
  639.               strNE(tokenbuf,"values") &&
  640. ***************
  641. *** 1138,1144 ****
  642.               strNE(tokenbuf,"readdir") &&
  643.               strNE(tokenbuf,"unpack") &&
  644.               strNE(tokenbuf,"do") &&
  645. !             (d >= bufend || isspace(*d)) )
  646.               *(--s) = '\\';    /* force next ident to WORD */
  647.           }
  648.           LOP(O_SORT);
  649. --- 1158,1165 ----
  650.               strNE(tokenbuf,"readdir") &&
  651.               strNE(tokenbuf,"unpack") &&
  652.               strNE(tokenbuf,"do") &&
  653. !             strNE(tokenbuf,"eval") &&
  654. !             (d >= bufend || isSPACE(*d)) )
  655.               *(--s) = '\\';    /* force next ident to WORD */
  656.           }
  657.           LOP(O_SORT);
  658. ***************
  659. *** 1176,1192 ****
  660.           if (strEQ(d,"substr"))
  661.           FUN2x(O_SUBSTR);
  662.           if (strEQ(d,"sub")) {
  663.           subline = curcmd->c_line;
  664.           d = bufend;
  665. !         while (s < d && isspace(*s))
  666.               s++;
  667. !         if (isalpha(*s) || *s == '_' || *s == '\'') {
  668.               if (perldb) {
  669.               str_sset(subname,curstname);
  670.               str_ncat(subname,"'",1);
  671. !             for (d = s+1;
  672. !               isalpha(*d) || isdigit(*d) || *d == '_' || *d == '\'';
  673. !               d++);
  674.               if (d[-1] == '\'')
  675.                   d--;
  676.               str_ncat(subname,s,d-s);
  677. --- 1197,1219 ----
  678.           if (strEQ(d,"substr"))
  679.           FUN2x(O_SUBSTR);
  680.           if (strEQ(d,"sub")) {
  681. +         yylval.ival = savestack->ary_fill; /* restore stuff on reduce */
  682. +         if (perldb) {
  683. +             savelong(&subline);
  684. +             saveitem(subname);
  685. +         }
  686. + 
  687.           subline = curcmd->c_line;
  688.           d = bufend;
  689. !         while (s < d && isSPACE(*s))
  690.               s++;
  691. !         if (isALPHA(*s) || *s == '_' || *s == '\'') {
  692.               if (perldb) {
  693.               str_sset(subname,curstname);
  694.               str_ncat(subname,"'",1);
  695. !             for (d = s+1; isALNUM(*d) || *d == '\''; d++)
  696. !                 /*SUPPRESS 530*/
  697. !                 ;
  698.               if (d[-1] == '\'')
  699.                   d--;
  700.               str_ncat(subname,s,d-s);
  701. ***************
  702. *** 1322,1328 ****
  703.       yylval.cval = savestr(d);
  704.       expectterm = FALSE;
  705.       if (oldoldbufptr && oldoldbufptr < bufptr) {
  706. !     while (isspace(*oldoldbufptr))
  707.           oldoldbufptr++;
  708.       if (*oldoldbufptr == 'p' && strnEQ(oldoldbufptr,"print",5))
  709.           expectterm = TRUE;
  710. --- 1349,1355 ----
  711.       yylval.cval = savestr(d);
  712.       expectterm = FALSE;
  713.       if (oldoldbufptr && oldoldbufptr < bufptr) {
  714. !     while (isSPACE(*oldoldbufptr))
  715.           oldoldbufptr++;
  716.       if (*oldoldbufptr == 'p' && strnEQ(oldoldbufptr,"print",5))
  717.           expectterm = TRUE;
  718. ***************
  719. *** 1341,1353 ****
  720.   
  721.       if (*s == '(')
  722.       s++;
  723. !     while (s < bufend && isascii(*s) && isspace(*s))
  724.       s++;
  725. !     if (isascii(*s) && (isalpha(*s) || *s == '_')) {
  726.       someword = s++;
  727. !     while (isalpha(*s) || isdigit(*s) || *s == '_')
  728.           s++;
  729. !     while (s < bufend && isspace(*s))
  730.           s++;
  731.       if (*s == ',') {
  732.           *s = '\0';
  733. --- 1368,1380 ----
  734.   
  735.       if (*s == '(')
  736.       s++;
  737. !     while (s < bufend && isSPACE(*s))
  738.       s++;
  739. !     if (isALPHA(*s) || *s == '_') {
  740.       someword = s++;
  741. !     while (isALNUM(*s))
  742.           s++;
  743. !     while (s < bufend && isSPACE(*s))
  744.           s++;
  745.       if (*s == ',') {
  746.           *s = '\0';
  747. ***************
  748. *** 1375,1386 ****
  749.       reparse = Nullch;
  750.       s++;
  751.       d = dest;
  752. !     if (isdigit(*s)) {
  753. !     while (isdigit(*s))
  754.           *d++ = *s++;
  755.       }
  756.       else {
  757. !     while (isalpha(*s) || isdigit(*s) || *s == '_' || *s == '\'')
  758.           *d++ = *s++;
  759.       }
  760.       while (d > dest+1 && d[-1] == '\'')
  761. --- 1402,1413 ----
  762.       reparse = Nullch;
  763.       s++;
  764.       d = dest;
  765. !     if (isDIGIT(*s)) {
  766. !     while (isDIGIT(*s))
  767.           *d++ = *s++;
  768.       }
  769.       else {
  770. !     while (isALNUM(*s) || *s == '\'')
  771.           *d++ = *s++;
  772.       }
  773.       while (d > dest+1 && d[-1] == '\'')
  774. ***************
  775. *** 1393,1400 ****
  776.           d = dest;
  777.           brackets++;
  778.           while (s < send && brackets) {
  779. !         if (!reparse && (d == dest || (*s && isascii(*s) &&
  780. !           (isalpha(*s) || isdigit(*s) || *s == '_') ))) {
  781.               *d++ = *s++;
  782.               continue;
  783.           }
  784. --- 1420,1426 ----
  785.           d = dest;
  786.           brackets++;
  787.           while (s < send && brackets) {
  788. !         if (!reparse && (d == dest || (*s && isALNUM(*s) ))) {
  789.               *d++ = *s++;
  790.               continue;
  791.           }
  792. ***************
  793. *** 1418,1435 ****
  794.       else
  795.           d[1] = '\0';
  796.       }
  797. !     if (*d == '^' && (isupper(*s) || index("[\\]^_?",*s)))
  798.       *d = *s++ ^ 64;
  799.       return s;
  800.   }
  801.   
  802. ! STR *
  803.   scanconst(spat,string,len)
  804.   SPAT *spat;
  805.   char *string;
  806.   int len;
  807.   {
  808. !     register STR *retstr;
  809.       register char *t;
  810.       register char *d;
  811.       register char *e;
  812. --- 1444,1466 ----
  813.       else
  814.           d[1] = '\0';
  815.       }
  816. !     if (*d == '^' && (isUPPER(*s) || index("[\\]^_?", *s))) {
  817. ! #ifdef DEBUGGING
  818. !     if (*s == 'D')
  819. !         debug |= 32768;
  820. ! #endif
  821.       *d = *s++ ^ 64;
  822. +     }
  823.       return s;
  824.   }
  825.   
  826. ! void
  827.   scanconst(spat,string,len)
  828.   SPAT *spat;
  829.   char *string;
  830.   int len;
  831.   {
  832. !     register STR *tmpstr;
  833.       register char *t;
  834.       register char *d;
  835.       register char *e;
  836. ***************
  837. *** 1437,1463 ****
  838.       static char *vert = "|";
  839.   
  840.       if (ninstr(string, string+len, vert, vert+1))
  841. !     return Nullstr;
  842.       if (*string == '^')
  843.       string++, len--;
  844. !     retstr = Str_new(86,len);
  845. !     str_nset(retstr,string,len);
  846. !     t = str_get(retstr);
  847.       e = t + len;
  848. !     retstr->str_u.str_useful = 100;
  849.       for (d=t; d < e; ) {
  850.       switch (*d) {
  851.       case '{':
  852. !         if (isdigit(d[1]))
  853.           e = d;
  854.           else
  855.           goto defchar;
  856.           break;
  857.       case '.': case '[': case '$': case '(': case ')': case '|': case '+':
  858.           e = d;
  859.           break;
  860.       case '\\':
  861. !         if (d[1] && index("wWbB0123456789sSdDlLuUE",d[1])) {
  862.           e = d;
  863.           break;
  864.           }
  865. --- 1468,1495 ----
  866.       static char *vert = "|";
  867.   
  868.       if (ninstr(string, string+len, vert, vert+1))
  869. !     return;
  870.       if (*string == '^')
  871.       string++, len--;
  872. !     tmpstr = Str_new(86,len);
  873. !     str_nset(tmpstr,string,len);
  874. !     t = str_get(tmpstr);
  875.       e = t + len;
  876. !     tmpstr->str_u.str_useful = 100;
  877.       for (d=t; d < e; ) {
  878.       switch (*d) {
  879.       case '{':
  880. !         if (isDIGIT(d[1]))
  881.           e = d;
  882.           else
  883.           goto defchar;
  884.           break;
  885.       case '.': case '[': case '$': case '(': case ')': case '|': case '+':
  886. +     case '^':
  887.           e = d;
  888.           break;
  889.       case '\\':
  890. !         if (d[1] && index("wWbB0123456789sSdDlLuUExc",d[1])) {
  891.           e = d;
  892.           break;
  893.           }
  894. ***************
  895. *** 1494,1511 ****
  896.       }
  897.       }
  898.       if (d == t) {
  899. !     str_free(retstr);
  900. !     return Nullstr;
  901.       }
  902.       *d = '\0';
  903. !     retstr->str_cur = d - t;
  904.       if (d == t+len)
  905.       spat->spat_flags |= SPAT_ALL;
  906.       if (*origstring != '^')
  907.       spat->spat_flags |= SPAT_SCANFIRST;
  908. !     spat->spat_short = retstr;
  909.       spat->spat_slen = d - t;
  910. -     return retstr;
  911.   }
  912.   
  913.   char *
  914. --- 1526,1542 ----
  915.       }
  916.       }
  917.       if (d == t) {
  918. !     str_free(tmpstr);
  919. !     return;
  920.       }
  921.       *d = '\0';
  922. !     tmpstr->str_cur = d - t;
  923.       if (d == t+len)
  924.       spat->spat_flags |= SPAT_ALL;
  925.       if (*origstring != '^')
  926.       spat->spat_flags |= SPAT_SCANFIRST;
  927. !     spat->spat_short = tmpstr;
  928.       spat->spat_slen = d - t;
  929.   }
  930.   
  931.   char *
  932. ***************
  933. *** 1663,1677 ****
  934.           arg->arg_type = O_ITEM;
  935.           arg[1].arg_type = A_DOUBLE;
  936.           arg[1].arg_ptr.arg_str = str_smake(str);
  937. !         d = scanident(d,bufend,buf);
  938.           (void)stabent(buf,TRUE);        /* make sure it's created */
  939.           for (; *d; d++) {
  940.           if (*d == '$' && d[1] && d[-1] != '\\' && d[1] != '|') {
  941. !             d = scanident(d,bufend,buf);
  942.               (void)stabent(buf,TRUE);
  943.           }
  944.           else if (*d == '@' && d[-1] != '\\') {
  945. !             d = scanident(d,bufend,buf);
  946.               if (strEQ(buf,"ARGV") || strEQ(buf,"ENV") ||
  947.                 strEQ(buf,"SIG") || strEQ(buf,"INC"))
  948.               (void)stabent(buf,TRUE);
  949. --- 1694,1708 ----
  950.           arg->arg_type = O_ITEM;
  951.           arg[1].arg_type = A_DOUBLE;
  952.           arg[1].arg_ptr.arg_str = str_smake(str);
  953. !         d = scanident(d,e,buf);
  954.           (void)stabent(buf,TRUE);        /* make sure it's created */
  955.           for (; *d; d++) {
  956.           if (*d == '$' && d[1] && d[-1] != '\\' && d[1] != '|') {
  957. !             d = scanident(d,e,buf);
  958.               (void)stabent(buf,TRUE);
  959.           }
  960.           else if (*d == '@' && d[-1] != '\\') {
  961. !             d = scanident(d,e,buf);
  962.               if (strEQ(buf,"ARGV") || strEQ(buf,"ENV") ||
  963.                 strEQ(buf,"SIG") || strEQ(buf,"INC"))
  964.               (void)stabent(buf,TRUE);
  965. ***************
  966. *** 1701,1707 ****
  967.       e = tmpstr->str_ptr + tmpstr->str_cur;
  968.       for (t = tmpstr->str_ptr; t < e; t++) {
  969.           if (*t == '$' && t[1] && (index("`'&+0123456789",t[1]) ||
  970. !           (t[1] == '{' /*}*/ && isdigit(t[2])) ))
  971.           spat->spat_flags &= ~SPAT_CONST;
  972.       }
  973.       }
  974. --- 1732,1738 ----
  975.       e = tmpstr->str_ptr + tmpstr->str_cur;
  976.       for (t = tmpstr->str_ptr; t < e; t++) {
  977.           if (*t == '$' && t[1] && (index("`'&+0123456789",t[1]) ||
  978. !           (t[1] == '{' /*}*/ && isDIGIT(t[2])) ))
  979.           spat->spat_flags &= ~SPAT_CONST;
  980.       }
  981.       }
  982. ***************
  983. *** 1710,1716 ****
  984.           s++;
  985.           if ((spat->spat_repl[1].arg_type & A_MASK) == A_DOUBLE)
  986.           spat->spat_repl[1].arg_type = A_SINGLE;
  987. !         spat->spat_repl = make_op(O_EVAL,2,
  988.           spat->spat_repl,
  989.           Nullarg,
  990.           Nullarg);
  991. --- 1741,1749 ----
  992.           s++;
  993.           if ((spat->spat_repl[1].arg_type & A_MASK) == A_DOUBLE)
  994.           spat->spat_repl[1].arg_type = A_SINGLE;
  995. !         spat->spat_repl = make_op(
  996. !         (spat->spat_repl[1].arg_type == A_SINGLE ? O_EVALONCE : O_EVAL),
  997. !         2,
  998.           spat->spat_repl,
  999.           Nullarg,
  1000.           Nullarg);
  1001. ***************
  1002. *** 1950,1955 ****
  1003. --- 1983,1991 ----
  1004.           switch (*s) {
  1005.           default:
  1006.               goto out;
  1007. +         case '_':
  1008. +             s++;
  1009. +             break;
  1010.           case '8': case '9':
  1011.               if (shift != 4)
  1012.               yyerror("Illegal octal digit");
  1013. ***************
  1014. *** 1984,1990 ****
  1015.         decimal:
  1016.       arg[1].arg_type = A_SINGLE;
  1017.       d = tokenbuf;
  1018. !     while (isdigit(*s) || *s == '_') {
  1019.           if (*s == '_')
  1020.           s++;
  1021.           else
  1022. --- 2020,2026 ----
  1023.         decimal:
  1024.       arg[1].arg_type = A_SINGLE;
  1025.       d = tokenbuf;
  1026. !     while (isDIGIT(*s) || *s == '_') {
  1027.           if (*s == '_')
  1028.           s++;
  1029.           else
  1030. ***************
  1031. *** 1992,1998 ****
  1032.       }
  1033.       if (*s == '.' && s[1] && index("0123456789eE ;",s[1])) {
  1034.           *d++ = *s++;
  1035. !         while (isdigit(*s) || *s == '_') {
  1036.           if (*s == '_')
  1037.               s++;
  1038.           else
  1039. --- 2028,2034 ----
  1040.       }
  1041.       if (*s == '.' && s[1] && index("0123456789eE ;",s[1])) {
  1042.           *d++ = *s++;
  1043. !         while (isDIGIT(*s) || *s == '_') {
  1044.           if (*s == '_')
  1045.               s++;
  1046.           else
  1047. ***************
  1048. *** 2003,2009 ****
  1049.           *d++ = *s++;
  1050.           if (*s == '+' || *s == '-')
  1051.           *d++ = *s++;
  1052. !         while (isdigit(*s))
  1053.           *d++ = *s++;
  1054.       }
  1055.       *d = '\0';
  1056. --- 2039,2045 ----
  1057.           *d++ = *s++;
  1058.           if (*s == '+' || *s == '-')
  1059.           *d++ = *s++;
  1060. !         while (isDIGIT(*s))
  1061.           *d++ = *s++;
  1062.       }
  1063.       *d = '\0';
  1064. ***************
  1065. *** 2034,2040 ****
  1066.               s++, term = '\'';
  1067.           else
  1068.               term = '"';
  1069. !         while (isascii(*s) && (isalpha(*s) || isdigit(*s) || *s == '_'))
  1070.               *d++ = *s++;
  1071.           }                /* assuming tokenbuf won't clobber */
  1072.           *d++ = '\n';
  1073. --- 2070,2076 ----
  1074.               s++, term = '\'';
  1075.           else
  1076.               term = '"';
  1077. !         while (isALNUM(*s))
  1078.               *d++ = *s++;
  1079.           }                /* assuming tokenbuf won't clobber */
  1080.           *d++ = '\n';
  1081. ***************
  1082. *** 2057,2064 ****
  1083.       if (s < bufend)
  1084.           s++;
  1085.       if (*d == '$') d++;
  1086. !     while (*d &&
  1087. !       (isalpha(*d) || isdigit(*d) || *d == '_' || *d == '\''))
  1088.           d++;
  1089.       if (d - tokenbuf != len) {
  1090.           d = tokenbuf;
  1091. --- 2093,2099 ----
  1092.       if (s < bufend)
  1093.           s++;
  1094.       if (*d == '$') d++;
  1095. !     while (*d && (isALNUM(*d) || *d == '\''))
  1096.           d++;
  1097.       if (d - tokenbuf != len) {
  1098.           d = tokenbuf;
  1099. ***************
  1100. *** 2209,2215 ****
  1101.           s = tmpstr->str_ptr;
  1102.           send = s + tmpstr->str_cur;
  1103.           while (s < send) {        /* see if we can make SINGLE */
  1104. !         if (*s == '\\' && s[1] && isdigit(s[1]) && !isdigit(s[2]) &&
  1105.             !alwaysdollar && s[1] != '0')
  1106.               *s = '$';        /* grandfather \digit in subst */
  1107.           if ((*s == '$' || *s == '@') && s+1 < send &&
  1108. --- 2244,2250 ----
  1109.           s = tmpstr->str_ptr;
  1110.           send = s + tmpstr->str_cur;
  1111.           while (s < send) {        /* see if we can make SINGLE */
  1112. !         if (*s == '\\' && s[1] && isDIGIT(s[1]) && !isDIGIT(s[2]) &&
  1113.             !alwaysdollar && s[1] != '0')
  1114.               *s = '$';        /* grandfather \digit in subst */
  1115.           if ((*s == '$' || *s == '@') && s+1 < send &&
  1116. ***************
  1117. *** 2228,2233 ****
  1118. --- 2263,2270 ----
  1119.           if ((*s == '$' && s+1 < send &&
  1120.               (alwaysdollar || /*(*/ (s[1] != ')' && s[1] != '|')) ) ||
  1121.               (*s == '@' && s+1 < send) ) {
  1122. +             if (s[1] == '#' && (isALPHA(s[2]) || s[2] == '_'))
  1123. +             *d++ = *s++;
  1124.               len = scanident(s,send,tokenbuf) - s;
  1125.               if (*s == '$' || strEQ(tokenbuf,"ARGV")
  1126.                 || strEQ(tokenbuf,"ENV")
  1127. ***************
  1128. *** 2258,2264 ****
  1129.               case 'c':
  1130.               s++;
  1131.               *d = *s++;
  1132. !             if (islower(*d))
  1133.                   *d = toupper(*d);
  1134.               *d++ ^= 64;
  1135.               continue;
  1136. --- 2295,2301 ----
  1137.               case 'c':
  1138.               s++;
  1139.               *d = *s++;
  1140. !             if (isLOWER(*d))
  1141.                   *d = toupper(*d);
  1142.               *d++ ^= 64;
  1143.               continue;
  1144. ***************
  1145. *** 2337,2342 ****
  1146. --- 2374,2380 ----
  1147.           astore(stab_xarray(curcmd->c_filestab), (int)curcmd->c_line,tmpstr);
  1148.       }
  1149.       if (*s == '.') {
  1150. +         /*SUPPRESS 530*/
  1151.           for (t = s+1; *t == ' ' || *t == '\t'; t++) ;
  1152.           if (*t == '\n') {
  1153.           bufptr = s;
  1154. ***************
  1155. *** 2479,2485 ****
  1156.           }
  1157.           else {
  1158.           eol[-1] = '\n';
  1159. !         while (s < eol && isspace(*s))
  1160.               s++;
  1161.           t = s;
  1162.           while (s < eol) {
  1163. --- 2517,2523 ----
  1164.           }
  1165.           else {
  1166.           eol[-1] = '\n';
  1167. !         while (s < eol && isSPACE(*s))
  1168.               s++;
  1169.           t = s;
  1170.           while (s < eol) {
  1171. ***************
  1172. *** 2487,2493 ****
  1173.               case ' ': case '\t': case '\n': case ';':
  1174.               str_ncat(str, t, s - t);
  1175.               str_ncat(str, "," ,1);
  1176. !             while (s < eol && (isspace(*s) || *s == ';'))
  1177.                   s++;
  1178.               t = s;
  1179.               break;
  1180. --- 2525,2531 ----
  1181.               case ' ': case '\t': case '\n': case ';':
  1182.               str_ncat(str, t, s - t);
  1183.               str_ncat(str, "," ,1);
  1184. !             while (s < eol && (isSPACE(*s) || *s == ';'))
  1185.                   s++;
  1186.               t = s;
  1187.               break;
  1188.  
  1189. Index: hints/ultrix_4.sh
  1190. *** hints/ultrix_4.sh.old    Tue Nov  5 19:26:44 1991
  1191. --- hints/ultrix_4.sh    Tue Nov  5 19:26:45 1991
  1192. ***************
  1193. *** 6,11 ****
  1194. --- 6,14 ----
  1195.   may cause utime() to work incorrectly.  If so, regression test io/fs
  1196.   may fail if run under NFS.  Ignore the failure.
  1197.   EOF
  1198. +     case "$tmp" in
  1199. +     *4.2*) d_volatile=undef;;
  1200. +     esac
  1201.   ;;
  1202.   esac
  1203.   case "$tmp" in
  1204.  
  1205. Index: usub/usersub.c
  1206. Prereq: 4.0
  1207. *** usub/usersub.c.old    Tue Nov  5 19:28:24 1991
  1208. --- usub/usersub.c    Tue Nov  5 19:28:25 1991
  1209. ***************
  1210. *** 1,6 ****
  1211. ! /* $Header: usersub.c,v 4.0 91/03/20 01:56:34 lwall Locked $
  1212.    *
  1213.    * $Log:    usersub.c,v $
  1214.    * Revision 4.0  91/03/20  01:56:34  lwall
  1215.    * 4.0 baseline.
  1216.    * 
  1217. --- 1,9 ----
  1218. ! /* $RCSfile: usersub.c,v $$Revision: 4.0.1.1 $$Date: 91/11/05 19:07:24 $
  1219.    *
  1220.    * $Log:    usersub.c,v $
  1221. +  * Revision 4.0.1.1  91/11/05  19:07:24  lwall
  1222. +  * patch11: there are now subroutines for calling back from C into Perl
  1223. +  * 
  1224.    * Revision 4.0  91/03/20  01:56:34  lwall
  1225.    * 4.0 baseline.
  1226.    * 
  1227. ***************
  1228. *** 18,20 ****
  1229. --- 21,72 ----
  1230.       init_curses();
  1231.   }
  1232.   
  1233. + /* Be sure to refetch the stack pointer after calling these routines. */
  1234. + 
  1235. + int
  1236. + callback(subname, sp, gimme, hasargs, numargs)
  1237. + char *subname;
  1238. + int sp;            /* stack pointer after args are pushed */
  1239. + int gimme;        /* called in array or scalar context */
  1240. + int hasargs;        /* whether to create a @_ array for routine */
  1241. + int numargs;        /* how many args are pushed on the stack */
  1242. + {
  1243. +     static ARG myarg[3];    /* fake syntax tree node */
  1244. +     int arglast[3];
  1245. +     
  1246. +     arglast[2] = sp;
  1247. +     sp -= numargs;
  1248. +     arglast[1] = sp--;
  1249. +     arglast[0] = sp;
  1250. + 
  1251. +     if (!myarg[0].arg_ptr.arg_str)
  1252. +     myarg[0].arg_ptr.arg_str = str_make("",0);
  1253. + 
  1254. +     myarg[1].arg_type = A_WORD;
  1255. +     myarg[1].arg_ptr.arg_stab = stabent(subname, FALSE);
  1256. + 
  1257. +     myarg[2].arg_type = hasargs ? A_EXPR : A_NULL;
  1258. + 
  1259. +     return do_subr(myarg, gimme, arglast);
  1260. + }
  1261. + 
  1262. + int
  1263. + callv(subname, sp, gimme, argv)
  1264. + char *subname;
  1265. + register int sp;    /* current stack pointer */
  1266. + int gimme;        /* called in array or scalar context */
  1267. + register char **argv;    /* null terminated arg list, NULL for no arglist */
  1268. + {
  1269. +     register int items = 0;
  1270. +     int hasargs = (argv != 0);
  1271. + 
  1272. +     astore(stack, ++sp, Nullstr);    /* reserve spot for 1st return arg */
  1273. +     if (hasargs) {
  1274. +     while (*argv) {
  1275. +         astore(stack, ++sp, str_2mortal(str_make(*argv,0)));
  1276. +         items++;
  1277. +         argv++;
  1278. +     }
  1279. +     }
  1280. +     return callback(subname, sp, gimme, hasargs, items);
  1281. + }
  1282.  
  1283. Index: util.c
  1284. *** util.c.old    Tue Nov  5 19:28:27 1991
  1285. --- util.c    Tue Nov  5 19:28:28 1991
  1286. ***************
  1287. *** 1,4 ****
  1288. ! /* $RCSfile: util.c,v $$Revision: 4.0.1.2 $$Date: 91/06/07 12:10:42 $
  1289.    *
  1290.    *    Copyright (c) 1991, Larry Wall
  1291.    *
  1292. --- 1,4 ----
  1293. ! /* $RCSfile: util.c,v $$Revision: 4.0.1.3 $$Date: 91/11/05 19:18:26 $
  1294.    *
  1295.    *    Copyright (c) 1991, Larry Wall
  1296.    *
  1297. ***************
  1298. *** 6,11 ****
  1299. --- 6,17 ----
  1300.    *    License or the Artistic License, as specified in the README file.
  1301.    *
  1302.    * $Log:    util.c,v $
  1303. +  * Revision 4.0.1.3  91/11/05  19:18:26  lwall
  1304. +  * patch11: safe malloc code now integrated into Perl's malloc when possible
  1305. +  * patch11: index("little", "longer string") could visit faraway places
  1306. +  * patch11: warn '-' x 10000 dumped core
  1307. +  * patch11: forked exec on non-existent program now issues a warning
  1308. +  * 
  1309.    * Revision 4.0.1.2  91/06/07  12:10:42  lwall
  1310.    * patch4: new copyright notice
  1311.    * patch4: made some allowances for "semi-standard" C
  1312. ***************
  1313. *** 20,25 ****
  1314. --- 26,32 ----
  1315.    * 4.0 baseline.
  1316.    * 
  1317.    */
  1318. + /*SUPPRESS 112*/
  1319.   
  1320.   #include "EXTERN.h"
  1321.   #include "perl.h"
  1322. ***************
  1323. *** 45,50 ****
  1324. --- 52,59 ----
  1325.   
  1326.   #define FLUSH
  1327.   
  1328. + #ifndef safemalloc
  1329. + 
  1330.   static char nomem[] = "Out of memory!\n";
  1331.   
  1332.   /* paranoid version of malloc */
  1333. ***************
  1334. *** 173,182 ****
  1335. --- 182,194 ----
  1336.   #  endif
  1337.   #endif
  1338.       if (where) {
  1339. +     /*SUPPRESS 701*/
  1340.       free(where);
  1341.       }
  1342.   }
  1343.   
  1344. + #endif /* !safemalloc */
  1345. + 
  1346.   #ifdef LEAKTEST
  1347.   
  1348.   #define ALIGN sizeof(long)
  1349. ***************
  1350. *** 222,228 ****
  1351.       register int i;
  1352.   
  1353.       for (i = 0; i < MAXXCOUNT; i++) {
  1354. !     if (xcount[i] != lastxcount[i]) {
  1355.           fprintf(stderr,"%2d %2d\t%ld\n", i / 100, i % 100, xcount[i]);
  1356.           lastxcount[i] = xcount[i];
  1357.       }
  1358. --- 234,240 ----
  1359.       register int i;
  1360.   
  1361.       for (i = 0; i < MAXXCOUNT; i++) {
  1362. !     if (xcount[i] > lastxcount[i]) {
  1363.           fprintf(stderr,"%2d %2d\t%ld\n", i / 100, i % 100, xcount[i]);
  1364.           lastxcount[i] = xcount[i];
  1365.       }
  1366. ***************
  1367. *** 307,312 ****
  1368. --- 319,326 ----
  1369.   
  1370.       if (!first && little > littleend)
  1371.       return big;
  1372. +     if (bigend - big < littleend - little)
  1373. +     return Nullch;
  1374.       bigend -= littleend - little++;
  1375.       while (big <= bigend) {
  1376.       if (*big++ != first)
  1377. ***************
  1378. *** 433,440 ****
  1379.   {
  1380.       register unsigned char *s;
  1381.       register unsigned char *table;
  1382. !     register int i;
  1383. !     register int len = str->str_cur;
  1384.       int rarest = 0;
  1385.       unsigned int frequency = 256;
  1386.   
  1387. --- 447,454 ----
  1388.   {
  1389.       register unsigned char *s;
  1390.       register unsigned char *table;
  1391. !     register unsigned int i;
  1392. !     register unsigned int len = str->str_cur;
  1393.       int rarest = 0;
  1394.       unsigned int frequency = 256;
  1395.   
  1396. ***************
  1397. *** 564,569 ****
  1398. --- 578,584 ----
  1399.       if (littlestr->str_pok & SP_CASEFOLD) {    /* case insensitive? */
  1400.       if (s < bigend) {
  1401.         top1:
  1402. +         /*SUPPRESS 560*/
  1403.           if (tmp = table[*s]) {
  1404.   #ifdef POINTERRIGOR
  1405.           if (bigend - s > tmp) {
  1406. ***************
  1407. *** 597,602 ****
  1408. --- 612,618 ----
  1409.       else {
  1410.       if (s < bigend) {
  1411.         top2:
  1412. +         /*SUPPRESS 560*/
  1413.           if (tmp = table[*s]) {
  1414.   #ifdef POINTERRIGOR
  1415.           if (bigend - s > tmp) {
  1416. ***************
  1417. *** 660,666 ****
  1418.       big = Null(unsigned char*);
  1419.   #endif
  1420.       bigend = big + bigstr->str_cur;
  1421. -     big -= previous;
  1422.       while (pos < previous) {
  1423.   #ifndef lint
  1424.       if (!(pos += screamnext[pos]))
  1425. --- 676,681 ----
  1426. ***************
  1427. *** 667,676 ****
  1428.   #endif
  1429.           return Nullch;
  1430.       }
  1431.       if (littlestr->str_pok & SP_CASEFOLD) {    /* case insignificant? */
  1432.       do {
  1433. !         if (big[pos] != first && big[pos] != fold[first])
  1434. !         continue;
  1435.           for (x=big+pos+1,s=little; s < littleend; /**/ ) {
  1436.           if (x >= bigend)
  1437.               return Nullch;
  1438. --- 682,757 ----
  1439.   #endif
  1440.           return Nullch;
  1441.       }
  1442. + #ifdef POINTERRIGOR
  1443.       if (littlestr->str_pok & SP_CASEFOLD) {    /* case insignificant? */
  1444.       do {
  1445. ! #ifndef lint
  1446. !         while (big[pos-previous] != first && big[pos-previous] != fold[first]
  1447. !           && (pos += screamnext[pos]) )
  1448. !         /*SUPPRESS 530*/
  1449. !         ;
  1450. ! #endif
  1451. !         for (x=big+pos+1-previous,s=little; s < littleend; /**/ ) {
  1452. !         if (x >= bigend)
  1453. !             return Nullch;
  1454. !         if (*s++ != *x++ && fold[*(s-1)] != *(x-1)) {
  1455. !             s--;
  1456. !             break;
  1457. !         }
  1458. !         }
  1459. !         if (s == littleend)
  1460. ! #ifndef lint
  1461. !         return (char *)(big+pos-previous);
  1462. ! #else
  1463. !         return Nullch;
  1464. ! #endif
  1465. !     } while (
  1466. ! #ifndef lint
  1467. !         pos += screamnext[pos]    /* does this goof up anywhere? */
  1468. ! #else
  1469. !         pos += screamnext[0]
  1470. ! #endif
  1471. !         );
  1472. !     }
  1473. !     else {
  1474. !     do {
  1475. ! #ifndef lint
  1476. !         while (big[pos-previous] != first && (pos += screamnext[pos]))
  1477. !         /*SUPPRESS 530*/
  1478. !         ;
  1479. ! #endif
  1480. !         for (x=big+pos+1-previous,s=little; s < littleend; /**/ ) {
  1481. !         if (x >= bigend)
  1482. !             return Nullch;
  1483. !         if (*s++ != *x++) {
  1484. !             s--;
  1485. !             break;
  1486. !         }
  1487. !         }
  1488. !         if (s == littleend)
  1489. ! #ifndef lint
  1490. !         return (char *)(big+pos-previous);
  1491. ! #else
  1492. !         return Nullch;
  1493. ! #endif
  1494. !     } while (
  1495. ! #ifndef lint
  1496. !         pos += screamnext[pos]
  1497. ! #else
  1498. !         pos += screamnext[0]
  1499. ! #endif
  1500. !         );
  1501. !     }
  1502. ! #else /* !POINTERRIGOR */
  1503. !     big -= previous;
  1504. !     if (littlestr->str_pok & SP_CASEFOLD) {    /* case insignificant? */
  1505. !     do {
  1506. ! #ifndef lint
  1507. !         while (big[pos] != first && big[pos] != fold[first]
  1508. !           && (pos += screamnext[pos]) )
  1509. !         /*SUPPRESS 530*/
  1510. !         ;
  1511. ! #endif
  1512.           for (x=big+pos+1,s=little; s < littleend; /**/ ) {
  1513.           if (x >= bigend)
  1514.               return Nullch;
  1515. ***************
  1516. *** 695,702 ****
  1517.       }
  1518.       else {
  1519.       do {
  1520. !         if (big[pos] != first)
  1521. !         continue;
  1522.           for (x=big+pos+1,s=little; s < littleend; /**/ ) {
  1523.           if (x >= bigend)
  1524.               return Nullch;
  1525. --- 776,786 ----
  1526.       }
  1527.       else {
  1528.       do {
  1529. ! #ifndef lint
  1530. !         while (big[pos] != first && (pos += screamnext[pos]))
  1531. !         /*SUPPRESS 530*/
  1532. !         ;
  1533. ! #endif
  1534.           for (x=big+pos+1,s=little; s < littleend; /**/ ) {
  1535.           if (x >= bigend)
  1536.               return Nullch;
  1537. ***************
  1538. *** 719,724 ****
  1539. --- 803,809 ----
  1540.   #endif
  1541.           );
  1542.       }
  1543. + #endif /* POINTERRIGOR */
  1544.       return Nullch;
  1545.   }
  1546.   
  1547. ***************
  1548. *** 774,783 ****
  1549.   long a1, a2, a3, a4;
  1550.   {
  1551.       char *s;
  1552.   
  1553.       s = buf;
  1554. !     (void)sprintf(s,pat,a1,a2,a3,a4);
  1555. !     s += strlen(s);
  1556.       if (s[-1] != '\n') {
  1557.       if (curcmd->c_line) {
  1558.           (void)sprintf(s," at %s line %ld",
  1559. --- 859,878 ----
  1560.   long a1, a2, a3, a4;
  1561.   {
  1562.       char *s;
  1563. +     int usermess = strEQ(pat,"%s");
  1564. +     STR *tmpstr;
  1565.   
  1566.       s = buf;
  1567. !     if (usermess) {
  1568. !     tmpstr = str_mortal(&str_undef);
  1569. !     str_set(tmpstr, (char*)a1);
  1570. !     *s++ = tmpstr->str_ptr[tmpstr->str_cur-1];
  1571. !     }
  1572. !     else {
  1573. !     (void)sprintf(s,pat,a1,a2,a3,a4);
  1574. !     s += strlen(s);
  1575. !     }
  1576. ! 
  1577.       if (s[-1] != '\n') {
  1578.       if (curcmd->c_line) {
  1579.           (void)sprintf(s," at %s line %ld",
  1580. ***************
  1581. *** 793,799 ****
  1582. --- 888,900 ----
  1583.           s += strlen(s);
  1584.       }
  1585.       (void)strcpy(s,".\n");
  1586. +     if (usermess)
  1587. +         str_cat(tmpstr,buf+1);
  1588.       }
  1589. +     if (usermess)
  1590. +     return tmpstr->str_ptr;
  1591. +     else
  1592. +     return buf;
  1593.   }
  1594.   
  1595.   /*VARARGS1*/
  1596. ***************
  1597. *** 804,813 ****
  1598.       extern FILE *e_fp;
  1599.       extern char *e_tmpname;
  1600.       char *tmps;
  1601.   
  1602. !     mess(pat,a1,a2,a3,a4);
  1603.       if (in_eval) {
  1604. !     str_set(stab_val(stabent("@",TRUE)),buf);
  1605.       tmps = "_EVAL_";
  1606.       while (loop_ptr >= 0 && (!loop_stack[loop_ptr].loop_label ||
  1607.         strNE(tmps,loop_stack[loop_ptr].loop_label) )) {
  1608. --- 905,915 ----
  1609.       extern FILE *e_fp;
  1610.       extern char *e_tmpname;
  1611.       char *tmps;
  1612. +     char *message;
  1613.   
  1614. !     message = mess(pat,a1,a2,a3,a4);
  1615.       if (in_eval) {
  1616. !     str_set(stab_val(stabent("@",TRUE)),message);
  1617.       tmps = "_EVAL_";
  1618.       while (loop_ptr >= 0 && (!loop_stack[loop_ptr].loop_label ||
  1619.         strNE(tmps,loop_stack[loop_ptr].loop_label) )) {
  1620. ***************
  1621. *** 831,837 ****
  1622.       }
  1623.       longjmp(loop_stack[loop_ptr].loop_env, 1);
  1624.       }
  1625. !     fputs(buf,stderr);
  1626.       (void)fflush(stderr);
  1627.       if (e_fp)
  1628.       (void)UNLINK(e_tmpname);
  1629. --- 933,939 ----
  1630.       }
  1631.       longjmp(loop_stack[loop_ptr].loop_env, 1);
  1632.       }
  1633. !     fputs(message,stderr);
  1634.       (void)fflush(stderr);
  1635.       if (e_fp)
  1636.       (void)UNLINK(e_tmpname);
  1637. ***************
  1638. *** 844,851 ****
  1639.   char *pat;
  1640.   long a1, a2, a3, a4;
  1641.   {
  1642. !     mess(pat,a1,a2,a3,a4);
  1643. !     fputs(buf,stderr);
  1644.   #ifdef LEAKTEST
  1645.   #ifdef DEBUGGING
  1646.       if (debug & 4096)
  1647. --- 946,955 ----
  1648.   char *pat;
  1649.   long a1, a2, a3, a4;
  1650.   {
  1651. !     char *message;
  1652. ! 
  1653. !     message = mess(pat,a1,a2,a3,a4);
  1654. !     fputs(message,stderr);
  1655.   #ifdef LEAKTEST
  1656.   #ifdef DEBUGGING
  1657.       if (debug & 4096)
  1658. ***************
  1659. *** 856,866 ****
  1660. --- 960,973 ----
  1661.   }
  1662.   #else
  1663.   /*VARARGS0*/
  1664. + char *
  1665.   mess(args)
  1666.   va_list args;
  1667.   {
  1668.       char *pat;
  1669.       char *s;
  1670. +     STR *tmpstr;
  1671. +     int usermess;
  1672.   #ifndef HAS_VPRINTF
  1673.   #ifdef CHARVSPRINTF
  1674.       char *vsprintf();
  1675. ***************
  1676. *** 869,883 ****
  1677.   #endif
  1678.   #endif
  1679.   
  1680. -     s = buf;
  1681.   #ifdef lint
  1682.       pat = Nullch;
  1683.   #else
  1684.       pat = va_arg(args, char *);
  1685.   #endif
  1686. !     (void) vsprintf(s,pat,args);
  1687.   
  1688. -     s += strlen(s);
  1689.       if (s[-1] != '\n') {
  1690.       if (curcmd->c_line) {
  1691.           (void)sprintf(s," at %s line %ld",
  1692. --- 976,998 ----
  1693.   #endif
  1694.   #endif
  1695.   
  1696.   #ifdef lint
  1697.       pat = Nullch;
  1698.   #else
  1699.       pat = va_arg(args, char *);
  1700.   #endif
  1701. !     s = buf;
  1702. !     usermess = strEQ(pat, "%s");
  1703. !     if (usermess) {
  1704. !     tmpstr = str_mortal(&str_undef);
  1705. !     str_set(tmpstr, va_arg(args, char *));
  1706. !     *s++ = tmpstr->str_ptr[tmpstr->str_cur-1];
  1707. !     }
  1708. !     else {
  1709. !     (void) vsprintf(s,pat,args);
  1710. !     s += strlen(s);
  1711. !     }
  1712.   
  1713.       if (s[-1] != '\n') {
  1714.       if (curcmd->c_line) {
  1715.           (void)sprintf(s," at %s line %ld",
  1716. ***************
  1717. *** 893,899 ****
  1718. --- 1008,1021 ----
  1719.           s += strlen(s);
  1720.       }
  1721.       (void)strcpy(s,".\n");
  1722. +     if (usermess)
  1723. +         str_cat(tmpstr,buf+1);
  1724.       }
  1725. + 
  1726. +     if (usermess)
  1727. +     return tmpstr->str_ptr;
  1728. +     else
  1729. +     return buf;
  1730.   }
  1731.   
  1732.   /*VARARGS0*/
  1733. ***************
  1734. *** 904,909 ****
  1735. --- 1026,1032 ----
  1736.       extern FILE *e_fp;
  1737.       extern char *e_tmpname;
  1738.       char *tmps;
  1739. +     char *message;
  1740.   
  1741.   #ifndef lint
  1742.       va_start(args);
  1743. ***************
  1744. *** 910,919 ****
  1745.   #else
  1746.       args = 0;
  1747.   #endif
  1748. !     mess(args);
  1749.       va_end(args);
  1750.       if (in_eval) {
  1751. !     str_set(stab_val(stabent("@",TRUE)),buf);
  1752.       tmps = "_EVAL_";
  1753.       while (loop_ptr >= 0 && (!loop_stack[loop_ptr].loop_label ||
  1754.         strNE(tmps,loop_stack[loop_ptr].loop_label) )) {
  1755. --- 1033,1042 ----
  1756.   #else
  1757.       args = 0;
  1758.   #endif
  1759. !     message = mess(args);
  1760.       va_end(args);
  1761.       if (in_eval) {
  1762. !     str_set(stab_val(stabent("@",TRUE)),message);
  1763.       tmps = "_EVAL_";
  1764.       while (loop_ptr >= 0 && (!loop_stack[loop_ptr].loop_label ||
  1765.         strNE(tmps,loop_stack[loop_ptr].loop_label) )) {
  1766. ***************
  1767. *** 937,943 ****
  1768.       }
  1769.       longjmp(loop_stack[loop_ptr].loop_env, 1);
  1770.       }
  1771. !     fputs(buf,stderr);
  1772.       (void)fflush(stderr);
  1773.       if (e_fp)
  1774.       (void)UNLINK(e_tmpname);
  1775. --- 1060,1066 ----
  1776.       }
  1777.       longjmp(loop_stack[loop_ptr].loop_env, 1);
  1778.       }
  1779. !     fputs(message,stderr);
  1780.       (void)fflush(stderr);
  1781.       if (e_fp)
  1782.       (void)UNLINK(e_tmpname);
  1783. ***************
  1784. *** 950,955 ****
  1785. --- 1073,1079 ----
  1786.   va_dcl
  1787.   {
  1788.       va_list args;
  1789. +     char *message;
  1790.   
  1791.   #ifndef lint
  1792.       va_start(args);
  1793. ***************
  1794. *** 956,965 ****
  1795.   #else
  1796.       args = 0;
  1797.   #endif
  1798. !     mess(args);
  1799.       va_end(args);
  1800.   
  1801. !     fputs(buf,stderr);
  1802.   #ifdef LEAKTEST
  1803.   #ifdef DEBUGGING
  1804.       if (debug & 4096)
  1805. --- 1080,1089 ----
  1806.   #else
  1807.       args = 0;
  1808.   #endif
  1809. !     message = mess(args);
  1810.       va_end(args);
  1811.   
  1812. !     fputs(message,stderr);
  1813.   #ifdef LEAKTEST
  1814.   #ifdef DEBUGGING
  1815.       if (debug & 4096)
  1816. ***************
  1817. *** 981,986 ****
  1818. --- 1105,1111 ----
  1819.       int max;
  1820.       char **tmpenv;
  1821.   
  1822. +     /*SUPPRESS 530*/
  1823.       for (max = i; environ[max]; max++) ;
  1824.       New(901,tmpenv, max+2, char*);
  1825.       for (j=0; j<max; j++)        /* copy environment */
  1826. ***************
  1827. *** 1242,1249 ****
  1828. --- 1367,1376 ----
  1829.           close(fd);
  1830.   #endif
  1831.           do_exec(cmd);    /* may or may not use the shell */
  1832. +         warn("Can't exec \"%s\": %s", cmd, strerror(errno));
  1833.           _exit(1);
  1834.       }
  1835. +     /*SUPPRESS 560*/
  1836.       if (tmpstab = stabent("$",allstabs))
  1837.           str_numset(STAB_STR(tmpstab),(double)getpid());
  1838.       forkprocess = 0;
  1839. ***************
  1840. *** 1321,1329 ****
  1841.       int pid;
  1842.   
  1843.       str = afetch(fdpid,fileno(ptr),TRUE);
  1844.       astore(fdpid,fileno(ptr),Nullstr);
  1845.       fclose(ptr);
  1846. -     pid = (int)str->str_u.str_useful;
  1847.       hstat = signal(SIGHUP, SIG_IGN);
  1848.       istat = signal(SIGINT, SIG_IGN);
  1849.       qstat = signal(SIGQUIT, SIG_IGN);
  1850. --- 1448,1456 ----
  1851.       int pid;
  1852.   
  1853.       str = afetch(fdpid,fileno(ptr),TRUE);
  1854. +     pid = (int)str->str_u.str_useful;
  1855.       astore(fdpid,fileno(ptr),Nullstr);
  1856.       fclose(ptr);
  1857.       hstat = signal(SIGHUP, SIG_IGN);
  1858.       istat = signal(SIGINT, SIG_IGN);
  1859.       qstat = signal(SIGQUIT, SIG_IGN);
  1860. ***************
  1861. *** 1340,1348 ****
  1862. --- 1467,1477 ----
  1863.   int *statusp;
  1864.   int flags;
  1865.   {
  1866. + #if !defined(HAS_WAIT4) && !defined(HAS_WAITPID)
  1867.       int result;
  1868.       STR *str;
  1869.       char spid[16];
  1870. + #endif
  1871.   
  1872.       if (!pid)
  1873.       return -1;
  1874. ***************
  1875. *** 1387,1392 ****
  1876. --- 1516,1522 ----
  1877.   #endif
  1878.   }
  1879.   
  1880. + /*SUPPRESS 590*/
  1881.   pidgone(pid,status)
  1882.   int pid;
  1883.   int status;
  1884.  
  1885. Index: util.h
  1886. *** util.h.old    Tue Nov  5 19:28:31 1991
  1887. --- util.h    Tue Nov  5 19:28:31 1991
  1888. ***************
  1889. *** 1,4 ****
  1890. ! /* $RCSfile: util.h,v $$Revision: 4.0.1.1 $$Date: 91/06/07 12:11:00 $
  1891.    *
  1892.    *    Copyright (c) 1991, Larry Wall
  1893.    *
  1894. --- 1,4 ----
  1895. ! /* $RCSfile: util.h,v $$Revision: 4.0.1.2 $$Date: 91/11/05 19:18:40 $
  1896.    *
  1897.    *    Copyright (c) 1991, Larry Wall
  1898.    *
  1899. ***************
  1900. *** 6,11 ****
  1901. --- 6,14 ----
  1902.    *    License or the Artistic License, as specified in the README file.
  1903.    *
  1904.    * $Log:    util.h,v $
  1905. +  * Revision 4.0.1.2  91/11/05  19:18:40  lwall
  1906. +  * patch11: safe malloc code now integrated into Perl's malloc when possible
  1907. +  * 
  1908.    * Revision 4.0.1.1  91/06/07  12:11:00  lwall
  1909.    * patch4: new copyright notice
  1910.    * 
  1911. ***************
  1912. *** 17,24 ****
  1913. --- 20,29 ----
  1914.   EXT int *screamfirst INIT(Null(int*));
  1915.   EXT int *screamnext INIT(Null(int*));
  1916.   
  1917. + #ifndef safemalloc
  1918.   char    *safemalloc();
  1919.   char    *saferealloc();
  1920. + #endif
  1921.   char    *cpytill();
  1922.   char    *instr();
  1923.   char    *fbminstr();
  1924.  
  1925. *** End of Patch 17 ***
  1926. exit 0 # Just in case...
  1927. -- 
  1928. Kent Landfield                   INTERNET: kent@sparky.IMD.Sterling.COM
  1929. Sterling Software, IMD           UUCP:     uunet!sparky!kent
  1930. Phone:    (402) 291-8300         FAX:      (402) 291-4362
  1931. Please send comp.sources.misc-related mail to kent@uunet.uu.net.
  1932.