home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / misc / volume30 / perl / patch31 < prev    next >
Encoding:
Text File  |  1992-06-11  |  49.1 KB  |  1,991 lines
  1. Newsgroups: comp.sources.misc
  2. From: lwall@netlabs.com (Larry Wall)
  3. Subject:  v30i042:  perl - The perl programming language, Patch31
  4. Message-ID: <1992Jun11.180837.1513@sparky.imd.sterling.com>
  5. X-Md4-Signature: caccc3bc2532ecd416516dc628dc3e6e
  6. Date: Thu, 11 Jun 1992 18:08:37 GMT
  7. Approved: kent@sparky.imd.sterling.com
  8.  
  9. Submitted-by: lwall@netlabs.com (Larry Wall)
  10. Posting-number: Volume 30, Issue 42
  11. Archive-name: perl/patch31
  12. Environment: UNIX, MS-DOS, OS2
  13. Patch-To: perl: Volume 18, Issue 19-54
  14.  
  15. System: perl version 4.0
  16. Patch #: 31
  17. Priority: highish
  18. Subject: patch #20, continued
  19.  
  20. Description:
  21.     See patch #20.
  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 #33 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: 30
  56. 1c1
  57. < #define PATCHLEVEL 30
  58. ---
  59. > #define PATCHLEVEL 31
  60.  
  61. Index: regcomp.c
  62. *** regcomp.c.old    Mon Jun  8 17:51:34 1992
  63. --- regcomp.c    Mon Jun  8 17:51:35 1992
  64. ***************
  65. *** 7,15 ****
  66.    * blame Henry for some of the lack of readability.
  67.    */
  68.   
  69. ! /* $RCSfile: regcomp.c,v $$Revision: 4.0.1.4 $$Date: 91/11/05 22:55:14 $
  70.    *
  71.    * $Log:    regcomp.c,v $
  72.    * Revision 4.0.1.4  91/11/05  22:55:14  lwall
  73.    * patch11: Erratum
  74.    * 
  75. --- 7,21 ----
  76.    * blame Henry for some of the lack of readability.
  77.    */
  78.   
  79. ! /* $RCSfile: regcomp.c,v $$Revision: 4.0.1.5 $$Date: 92/06/08 15:23:36 $
  80.    *
  81.    * $Log:    regcomp.c,v $
  82. +  * Revision 4.0.1.5  92/06/08  15:23:36  lwall
  83. +  * patch20: Perl now distinguishes overlapped copies from non-overlapped
  84. +  * patch20: /^stuff/ wrongly assumed an implicit $* == 1
  85. +  * patch20: /x{0}/ was wrongly interpreted as /x{0,}/
  86. +  * patch20: added \W, \S and \D inside /[...]/
  87. +  * 
  88.    * Revision 4.0.1.4  91/11/05  22:55:14  lwall
  89.    * patch11: Erratum
  90.    * 
  91. ***************
  92. *** 86,92 ****
  93. --- 92,102 ----
  94.   #define    ISMULT1(c)    ((c) == '*' || (c) == '+' || (c) == '?')
  95.   #define    ISMULT2(s)    ((*s) == '*' || (*s) == '+' || (*s) == '?' || \
  96.       ((*s) == '{' && regcurly(s)))
  97. + #ifdef atarist
  98. + #define    PERL_META    "^$.[()|?+*\\"
  99. + #else
  100.   #define    META    "^$.[()|?+*\\"
  101. + #endif
  102.   
  103.   #ifdef SPSTART
  104.   #undef SPSTART        /* dratted cpp namespace... */
  105. ***************
  106. *** 160,169 ****
  107.       int backest;
  108.       int curback;
  109.       int minlen;
  110. - #ifndef safemalloc
  111. -     extern char *safemalloc();
  112. - #endif
  113. -     extern char *savestr();
  114.       int sawplus = 0;
  115.       int sawopen = 0;
  116.   
  117. --- 170,175 ----
  118. ***************
  119. *** 198,204 ****
  120.   
  121.       /* Second pass: emit code. */
  122.       if (regsawbracket)
  123. !         bcopy(regprecomp,exp,xend-exp);
  124.       r->prelen = xend-exp;
  125.       r->precomp = regprecomp;
  126.       r->subbeg = r->subbase = NULL;
  127. --- 204,210 ----
  128.   
  129.       /* Second pass: emit code. */
  130.       if (regsawbracket)
  131. !         Copy(regprecomp,exp,xend-exp,char);
  132.       r->prelen = xend-exp;
  133.       r->precomp = regprecomp;
  134.       r->subbeg = r->subbase = NULL;
  135. ***************
  136. *** 243,251 ****
  137.               r->regstclass = first;
  138.           else if (OP(first) == BOUND || OP(first) == NBOUND)
  139.               r->regstclass = first;
  140. !         else if (OP(first) == BOL ||
  141. !             (OP(first) == STAR && OP(NEXTOPER(first)) == ANY) ) {
  142. !             /* kinda turn .* into ^.* */
  143.               r->reganch = ROPT_ANCH | ROPT_IMPLICIT;
  144.               first = NEXTOPER(first);
  145.                   goto again;
  146. --- 249,262 ----
  147.               r->regstclass = first;
  148.           else if (OP(first) == BOUND || OP(first) == NBOUND)
  149.               r->regstclass = first;
  150. !         else if (OP(first) == BOL) {
  151. !             r->reganch = ROPT_ANCH;
  152. !             first = NEXTOPER(first);
  153. !                 goto again;
  154. !         }
  155. !         else if ((OP(first) == STAR && OP(NEXTOPER(first)) == ANY) &&
  156. !              !(r->reganch & ROPT_ANCH) ) {
  157. !             /* turn .* into ^.* with an implied $*=1 */
  158.               r->reganch = ROPT_ANCH | ROPT_IMPLICIT;
  159.               first = NEXTOPER(first);
  160.                   goto again;
  161. ***************
  162. *** 564,569 ****
  163. --- 575,582 ----
  164.               else
  165.               max = regparse;
  166.               tmp = atoi(max);
  167. +             if (!tmp && *max != '0')
  168. +             tmp = 32767;        /* meaning "infinity" */
  169.               if (tmp && tmp < iter)
  170.               fatal("Can't do {n,m} with n > m");
  171.               if (regcode != ®dummy) {
  172. ***************
  173. *** 967,994 ****
  174.               class = UCHARAT(regparse++);
  175.               switch (class) {
  176.               case 'w':
  177. !                 for (class = 'a'; class <= 'z'; class++)
  178.                       regset(bits,def,class);
  179. !                 for (class = 'A'; class <= 'Z'; class++)
  180.                       regset(bits,def,class);
  181. -                 for (class = '0'; class <= '9'; class++)
  182. -                     regset(bits,def,class);
  183. -                 regset(bits,def,'_');
  184.                   lastclass = 1234;
  185.                   continue;
  186.               case 's':
  187. !                 regset(bits,def,' ');
  188. !                 regset(bits,def,'\t');
  189. !                 regset(bits,def,'\r');
  190. !                 regset(bits,def,'\f');
  191. !                 regset(bits,def,'\n');
  192.                   lastclass = 1234;
  193.                   continue;
  194.               case 'd':
  195.                   for (class = '0'; class <= '9'; class++)
  196.                       regset(bits,def,class);
  197.                   lastclass = 1234;
  198.                   continue;
  199.               case 'n':
  200.                   class = '\n';
  201.                   break;
  202. --- 980,1020 ----
  203.               class = UCHARAT(regparse++);
  204.               switch (class) {
  205.               case 'w':
  206. !                 for (class = 0; class < 256; class++)
  207. !                     if (isALNUM(class))
  208.                       regset(bits,def,class);
  209. !                 lastclass = 1234;
  210. !                 continue;
  211. !             case 'W':
  212. !                 for (class = 0; class < 256; class++)
  213. !                     if (!isALNUM(class))
  214.                       regset(bits,def,class);
  215.                   lastclass = 1234;
  216.                   continue;
  217.               case 's':
  218. !                 for (class = 0; class < 256; class++)
  219. !                     if (isSPACE(class))
  220. !                     regset(bits,def,class);
  221.                   lastclass = 1234;
  222.                   continue;
  223. +             case 'S':
  224. +                 for (class = 0; class < 256; class++)
  225. +                     if (!isSPACE(class))
  226. +                     regset(bits,def,class);
  227. +                 lastclass = 1234;
  228. +                 continue;
  229.               case 'd':
  230.                   for (class = '0'; class <= '9'; class++)
  231.                       regset(bits,def,class);
  232.                   lastclass = 1234;
  233.                   continue;
  234. +             case 'D':
  235. +                 for (class = 0; class < '0'; class++)
  236. +                     regset(bits,def,class);
  237. +                 for (class = '9' + 1; class < 256; class++)
  238. +                     regset(bits,def,class);
  239. +                 lastclass = 1234;
  240. +                 continue;
  241.               case 'n':
  242.                   class = '\n';
  243.                   break;
  244. ***************
  245. *** 1184,1189 ****
  246. --- 1210,1218 ----
  247.       *place++ = '\0';
  248.       while (offset-- > 0)
  249.           *place++ = '\0';
  250. + #ifdef REGALIGN
  251. +     *place++ = '\177';
  252. + #endif
  253.   }
  254.   
  255.   /*
  256. ***************
  257. *** 1420,1425 ****
  258. --- 1449,1455 ----
  259.   }
  260.   #endif /* DEBUGGING */
  261.   
  262. + void
  263.   regfree(r)
  264.   struct regexp *r;
  265.   {
  266.  
  267. Index: regexec.c
  268. *** regexec.c.old    Mon Jun  8 17:51:40 1992
  269. --- regexec.c    Mon Jun  8 17:51:40 1992
  270. ***************
  271. *** 7,15 ****
  272.    * blame Henry for some of the lack of readability.
  273.    */
  274.   
  275. ! /* $RCSfile: regexec.c,v $$Revision: 4.0.1.3 $$Date: 91/11/05 18:23:55 $
  276.    *
  277.    * $Log:    regexec.c,v $
  278.    * Revision 4.0.1.3  91/11/05  18:23:55  lwall
  279.    * patch11: prepared for ctype implementations that don't define isascii()
  280.    * patch11: initial .* in pattern had dependency on value of $*
  281. --- 7,20 ----
  282.    * blame Henry for some of the lack of readability.
  283.    */
  284.   
  285. ! /* $RCSfile: regexec.c,v $$Revision: 4.0.1.4 $$Date: 92/06/08 15:25:50 $
  286.    *
  287.    * $Log:    regexec.c,v $
  288. +  * Revision 4.0.1.4  92/06/08  15:25:50  lwall
  289. +  * patch20: pattern modifiers i and g didn't interact right
  290. +  * patch20: in some cases $` and $' didn't get set by match
  291. +  * patch20: /x{0}/ was wrongly interpreted as /x{0,}/
  292. +  * 
  293.    * Revision 4.0.1.3  91/11/05  18:23:55  lwall
  294.    * patch11: prepared for ctype implementations that don't define isascii()
  295.    * patch11: initial .* in pattern had dependency on value of $*
  296. ***************
  297. *** 140,149 ****
  298.       }
  299.   
  300.       if (prog->do_folding) {
  301. -         safebase = FALSE;
  302.           i = strend - string;
  303.           New(1101,c,i+1,char);
  304. !         (void)bcopy(string, c, i+1);
  305.           string = c;
  306.           strend = string + i;
  307.           for (s = string; s < strend; s++)
  308. --- 145,153 ----
  309.       }
  310.   
  311.       if (prog->do_folding) {
  312.           i = strend - string;
  313.           New(1101,c,i+1,char);
  314. !         Copy(string, c, i+1, char);
  315.           string = c;
  316.           strend = string + i;
  317.           for (s = string; s < strend; s++)
  318. ***************
  319. *** 441,446 ****
  320. --- 445,452 ----
  321.       goto phooey;
  322.   
  323.       got_it:
  324. +     prog->subbeg = strbeg;
  325. +     prog->subend = strend;
  326.       if ((!safebase && (prog->nparens || sawampersand)) || prog->do_folding){
  327.           strend += dontbother;    /* uncheat */
  328.           if (safebase)            /* no need for $digit later */
  329. ***************
  330. *** 453,460 ****
  331.               prog->subbeg = prog->subbase = s;
  332.               prog->subend = s+i;
  333.           }
  334. !         else
  335. !             s = prog->subbase;
  336.           s += (stringarg - strbeg);
  337.           for (i = 0; i <= prog->nparens; i++) {
  338.               if (prog->endp[i]) {
  339. --- 459,469 ----
  340.               prog->subbeg = prog->subbase = s;
  341.               prog->subend = s+i;
  342.           }
  343. !         else {
  344. !             i = strend - string + (stringarg - strbeg);
  345. !             prog->subbeg = s = prog->subbase;
  346. !             prog->subend = s+i;
  347. !         }
  348.           s += (stringarg - strbeg);
  349.           for (i = 0; i <= prog->nparens; i++) {
  350.               if (prog->endp[i]) {
  351. ***************
  352. *** 742,748 ****
  353.               goto repeat;
  354.           case STAR:
  355.               ln = 0;
  356. !             n = 0;
  357.               scan = NEXTOPER(scan);
  358.               goto repeat;
  359.           case PLUS:
  360. --- 751,757 ----
  361.               goto repeat;
  362.           case STAR:
  363.               ln = 0;
  364. !             n = 32767;
  365.               scan = NEXTOPER(scan);
  366.               goto repeat;
  367.           case PLUS:
  368. ***************
  369. *** 751,757 ****
  370.                * when we know what character comes next.
  371.                */
  372.               ln = 1;
  373. !             n = 0;
  374.               scan = NEXTOPER(scan);
  375.               repeat:
  376.               if (OP(next) == EXACTLY)
  377. --- 760,766 ----
  378.                * when we know what character comes next.
  379.                */
  380.               ln = 1;
  381. !             n = 32767;
  382.               scan = NEXTOPER(scan);
  383.               repeat:
  384.               if (OP(next) == EXACTLY)
  385. ***************
  386. *** 813,819 ****
  387.       register char *loceol = regeol;
  388.   
  389.       scan = reginput;
  390. !     if (max && max < loceol - scan)
  391.           loceol = scan + max;
  392.       opnd = OPERAND(p);
  393.       switch (OP(p)) {
  394. --- 822,828 ----
  395.       register char *loceol = regeol;
  396.   
  397.       scan = reginput;
  398. !     if (max != 32767 && max < loceol - scan)
  399.           loceol = scan + max;
  400.       opnd = OPERAND(p);
  401.       switch (OP(p)) {
  402.  
  403. Index: x2p/s2p.SH
  404. *** x2p/s2p.SH.old    Mon Jun  8 17:52:59 1992
  405. --- x2p/s2p.SH    Mon Jun  8 17:52:59 1992
  406. ***************
  407. *** 20,28 ****
  408. --- 20,32 ----
  409.   : Move anything that needs config subs from !NO!SUBS! section to !GROK!THIS!.
  410.   : Protect any dollar signs and backticks that you do not want interpreted
  411.   : by putting a backslash in front.  You may delete these comments.
  412. + rm -f s2p
  413.   $spitshell >s2p <<!GROK!THIS!
  414.   #!$bin/perl
  415.   
  416. + eval 'exec $bin/perl -S \$0 \${1+"\$@"}'
  417. +     if \$running_under_some_shell;
  418. + 
  419.   \$bin = '$bin';
  420.   !GROK!THIS!
  421.   
  422. ***************
  423. *** 29,37 ****
  424.   : In the following dollars and backticks do not need the extra backslash.
  425.   $spitshell >>s2p <<'!NO!SUBS!'
  426.   
  427. ! # $RCSfile: s2p.SH,v $$Revision: 4.0.1.1 $$Date: 91/06/07 12:19:18 $
  428.   #
  429.   # $Log:    s2p.SH,v $
  430.   # Revision 4.0.1.1  91/06/07  12:19:18  lwall
  431.   # patch4: s2p now handles embedded newlines better and optimizes common idioms
  432.   # 
  433. --- 33,46 ----
  434.   : In the following dollars and backticks do not need the extra backslash.
  435.   $spitshell >>s2p <<'!NO!SUBS!'
  436.   
  437. ! # $RCSfile: s2p.SH,v $$Revision: 4.0.1.2 $$Date: 92/06/08 17:26:31 $
  438.   #
  439.   # $Log:    s2p.SH,v $
  440. + # Revision 4.0.1.2  92/06/08  17:26:31  lwall
  441. + # patch20: s2p didn't output portable startup code
  442. + # patch20: added ... as variant on ..
  443. + # patch20: s2p didn't translate s/pat/\&/ or s/pat/\$/ or s/pat/\\1/ right
  444. + # 
  445.   # Revision 4.0.1.1  91/06/07  12:19:18  lwall
  446.   # patch4: s2p now handles embedded newlines better and optimizes common idioms
  447.   # 
  448. ***************
  449. *** 162,168 ****
  450.       } else {
  451.           &Die("Invalid second address at line $.\n");
  452.       }
  453. !     $addr1 .= " .. $addr2";
  454.       }
  455.   
  456.       # Now we check for metacommands {, }, and ! and worry
  457. --- 171,182 ----
  458.       } else {
  459.           &Die("Invalid second address at line $.\n");
  460.       }
  461. !     if ($addr2 =~ /^\d+$/) {
  462. !         $addr1 .= "..$addr2";
  463. !     }
  464. !     else {
  465. !         $addr1 .= "...$addr2";
  466. !     }
  467.       }
  468.   
  469.       # Now we check for metacommands {, }, and ! and worry
  470. ***************
  471. *** 488,494 ****
  472. --- 502,521 ----
  473.                 substr($_,$i,1) =~ /^[<>]$/) {
  474.               substr($_,$i,1) = 'b';
  475.               }
  476. +             elsif ($repl && substr($_,$i,1) =~ /^\d$/) {
  477. +             substr($_,$i-1,1) = '$';
  478. +             }
  479.           }
  480. +         elsif ($c eq '&' && $repl) {
  481. +             substr($_, $i, 0) = '$';
  482. +             $i++;
  483. +             $len++;
  484. +         }
  485. +         elsif ($c eq '$' && $repl) {
  486. +             substr($_, $i, 0) = '\\';
  487. +             $i++;
  488. +             $len++;
  489. +         }
  490.           elsif ($c eq '[' && !$repl) {
  491.               $i++ if substr($_,$i,1) eq '^';
  492.               $i++ if substr($_,$i,1) eq ']';
  493. ***************
  494. *** 515,523 ****
  495.           $end = substr($_, $end + 1, 1000);
  496.           &simplify($pat);
  497.           $dol = '$';
  498. -         $repl =~ s/\$/\\$/;
  499. -         $repl =~ s'&'$&'g;
  500. -         $repl =~ s/[\\]([0-9])/$dol$1/g;
  501.           $subst = "$pat$repl$delim";
  502.           $cmd = '';
  503.           while ($end) {
  504. --- 542,547 ----
  505.  
  506. Index: hints/sco_2_3_3.sh
  507. *** hints/sco_2_3_3.sh.old    Mon Jun  8 17:48:13 1992
  508. --- hints/sco_2_3_3.sh    Mon Jun  8 17:48:13 1992
  509. ***************
  510. *** 1,4 ****
  511.   yacc='/usr/bin/yacc -Sm25000'
  512. - libswanted=`echo $libswanted | sed 's/ x / /'`
  513.   echo "NOTE: you may have problems due to a spurious semicolon on the strerror()"
  514.   echo "macro definition in /usr/include/string.h.  If so, delete the semicolon."
  515. --- 1,3 ----
  516.  
  517. Index: hints/sco_2_3_4.sh
  518. *** hints/sco_2_3_4.sh.old    Mon Jun  8 17:48:15 1992
  519. --- hints/sco_2_3_4.sh    Mon Jun  8 17:48:15 1992
  520. ***************
  521. *** 0 ****
  522. --- 1,5 ----
  523. + yacc='/usr/bin/yacc -Sm25000'
  524. + ccflags="$ccflags -UM_I86"
  525. + d_mymalloc=define
  526. + echo "NOTE: you may have problems due to a spurious semicolon on the strerror()"
  527. + echo "macro definition in /usr/include/string.h.  If so, delete the semicolon."
  528.  
  529. Index: hints/sgi.sh
  530. *** hints/sgi.sh.old    Mon Jun  8 17:48:17 1992
  531. --- hints/sgi.sh    Mon Jun  8 17:48:18 1992
  532. ***************
  533. *** 1,6 ****
  534.   optimize='-O1'
  535. ! usemymalloc='y'
  536.   mallocsrc='malloc.c'
  537.   mallocobj='malloc.o'
  538.   d_voidsig=define
  539.   d_vfork=undef
  540. --- 1,12 ----
  541.   optimize='-O1'
  542. ! d_mymalloc=define
  543.   mallocsrc='malloc.c'
  544.   mallocobj='malloc.o'
  545.   d_voidsig=define
  546.   d_vfork=undef
  547. + d_charsprf=undef
  548. + case `(uname -r) 2>/dev/null` in
  549. + 4*)libswanted=`echo $libswanted | sed 's/c_s \(.*\)/\1 c_s/'`
  550. +     ccflags="$ccflags -DLANGUAGE_C -DBSD_SIGNALS -cckr -signed"
  551. +     ;;
  552. + esac
  553.  
  554. Index: lib/shellwords.pl
  555. *** lib/shellwords.pl.old    Mon Jun  8 17:49:11 1992
  556. --- lib/shellwords.pl    Mon Jun  8 17:49:12 1992
  557. ***************
  558. *** 1,12 ****
  559. ! #; shellwords.pl
  560. ! #;
  561. ! #; Usage:
  562. ! #;    require 'shellwords.pl';
  563. ! #;    @words = &shellwords($line);
  564. ! #;    or
  565. ! #;    @words = &shellwords(@lines);
  566. ! #;    or
  567. ! #;    @words = &shellwords;        # defaults to $_ (and clobbers it)
  568.   
  569.   sub shellwords {
  570.       package shellwords;
  571. --- 1,12 ----
  572. ! ;# shellwords.pl
  573. ! ;#
  574. ! ;# Usage:
  575. ! ;#    require 'shellwords.pl';
  576. ! ;#    @words = &shellwords($line);
  577. ! ;#    or
  578. ! ;#    @words = &shellwords(@lines);
  579. ! ;#    or
  580. ! ;#    @words = &shellwords;        # defaults to $_ (and clobbers it)
  581.   
  582.   sub shellwords {
  583.       package shellwords;
  584. ***************
  585. *** 17,27 ****
  586.       while ($_ ne '') {
  587.       $field = '';
  588.       for (;;) {
  589. !         if (s/^"(([^"\\]+|\\[\\"])*)"//) {
  590.           ($snippet = $1) =~ s#\\(.)#$1#g;
  591.           }
  592. !         elsif (s/^'(([^'\\]+|\\[\\'])*)'//) {
  593.           ($snippet = $1) =~ s#\\(.)#$1#g;
  594.           }
  595.           elsif (s/^\\(.)//) {
  596.           $snippet = $1;
  597. --- 17,33 ----
  598.       while ($_ ne '') {
  599.       $field = '';
  600.       for (;;) {
  601. !         if (s/^"(([^"\\]|\\[\\"])*)"//) {
  602.           ($snippet = $1) =~ s#\\(.)#$1#g;
  603.           }
  604. !         elsif (/^"/) {
  605. !         die "Unmatched double quote: $_\n";
  606. !         }
  607. !         elsif (s/^'(([^'\\]|\\[\\'])*)'//) {
  608.           ($snippet = $1) =~ s#\\(.)#$1#g;
  609. +         }
  610. +         elsif (/^'/) {
  611. +         die "Unmatched single quote: $_\n";
  612.           }
  613.           elsif (s/^\\(.)//) {
  614.           $snippet = $1;
  615.  
  616. Index: atarist/test/sig
  617. *** atarist/test/sig.old    Mon Jun  8 17:45:21 1992
  618. --- atarist/test/sig    Mon Jun  8 17:45:21 1992
  619. ***************
  620. *** 0 ****
  621. --- 1,12 ----
  622. + sub handler {
  623. +     local($sig) = @_;
  624. +     print "Caught SIG$sig\n";
  625. +     exit(0);
  626. + }
  627. + 
  628. + $SIG{'INT'} = 'handler';
  629. + 
  630. + print "Hit CRTL-C to see if it is trapped\n";
  631. + while($_ = <ARGV>) {
  632. +     print $_;
  633. + }
  634.  
  635. Index: stab.c
  636. *** stab.c.old    Mon Jun  8 17:51:45 1992
  637. --- stab.c    Mon Jun  8 17:51:45 1992
  638. ***************
  639. *** 1,4 ****
  640. ! /* $RCSfile: stab.c,v $$Revision: 4.0.1.3 $$Date: 91/11/05 18:35:33 $
  641.    *
  642.    *    Copyright (c) 1991, Larry Wall
  643.    *
  644. --- 1,4 ----
  645. ! /* $RCSfile: stab.c,v $$Revision: 4.0.1.4 $$Date: 92/06/08 15:32:19 $
  646.    *
  647.    *    Copyright (c) 1991, Larry Wall
  648.    *
  649. ***************
  650. *** 6,11 ****
  651. --- 6,18 ----
  652.    *    License or the Artistic License, as specified in the README file.
  653.    *
  654.    * $Log:    stab.c,v $
  655. +  * Revision 4.0.1.4  92/06/08  15:32:19  lwall
  656. +  * patch20: fixed confusion between a *var's real name and its effective name
  657. +  * patch20: the debugger now warns you on lines that can't set a breakpoint
  658. +  * patch20: the debugger made perl forget the last pattern used by //
  659. +  * patch20: paragraph mode now skips extra newlines automatically
  660. +  * patch20: ($<,$>) = ... didn't work on some architectures
  661. +  * 
  662.    * Revision 4.0.1.3  91/11/05  18:35:33  lwall
  663.    * patch11: length($x) was sometimes wrong for numeric $x
  664.    * patch11: perl now issues warning if $SIG{'ALARM'} is referenced
  665. ***************
  666. *** 91,97 ****
  667.       case '1': case '2': case '3': case '4':
  668.       case '5': case '6': case '7': case '8': case '9': case '&':
  669.       if (curspat) {
  670. !         paren = atoi(stab_name(stab));
  671.         getparen:
  672.           if (curspat->spat_regexp &&
  673.             paren <= curspat->spat_regexp->nparens &&
  674. --- 98,104 ----
  675.       case '1': case '2': case '3': case '4':
  676.       case '5': case '6': case '7': case '8': case '9': case '&':
  677.       if (curspat) {
  678. !         paren = atoi(stab_ename(stab));
  679.         getparen:
  680.           if (curspat->spat_regexp &&
  681.             paren <= curspat->spat_regexp->nparens &&
  682. ***************
  683. *** 138,144 ****
  684.       break;
  685.       case '.':
  686.   #ifndef lint
  687. !     if (last_in_stab) {
  688.           str_numset(stab_val(stab),(double)stab_io(last_in_stab)->lines);
  689.       }
  690.   #endif
  691. --- 145,151 ----
  692.       break;
  693.       case '.':
  694.   #ifndef lint
  695. !     if (last_in_stab && stab_io(last_in_stab)) {
  696.           str_numset(stab_val(stab),(double)stab_io(last_in_stab)->lines);
  697.       }
  698.   #endif
  699. ***************
  700. *** 151,157 ****
  701.       if (s)
  702.           str_set(stab_val(stab),s);
  703.       else {
  704. !         str_set(stab_val(stab),stab_name(curoutstab));
  705.           str_cat(stab_val(stab),"_TOP");
  706.       }
  707.       break;
  708. --- 158,164 ----
  709.       if (s)
  710.           str_set(stab_val(stab),s);
  711.       else {
  712. !         str_set(stab_val(stab),stab_ename(curoutstab));
  713.           str_cat(stab_val(stab),"_TOP");
  714.       }
  715.       break;
  716. ***************
  717. *** 158,164 ****
  718.       case '~':
  719.       s = stab_io(curoutstab)->fmt_name;
  720.       if (!s)
  721. !         s = stab_name(curoutstab);
  722.       str_set(stab_val(stab),s);
  723.       break;
  724.   #ifndef lint
  725. --- 165,171 ----
  726.       case '~':
  727.       s = stab_io(curoutstab)->fmt_name;
  728.       if (!s)
  729. !         s = stab_ename(curoutstab);
  730.       str_set(stab_val(stab),s);
  731.       break;
  732.   #ifndef lint
  733. ***************
  734. *** 172,177 ****
  735. --- 179,186 ----
  736.       str_numset(stab_val(stab),(double)stab_io(curoutstab)->page);
  737.       break;
  738.   #endif
  739. +     case ':':
  740. +     break;
  741.       case '/':
  742.       break;
  743.       case '[':
  744. ***************
  745. *** 260,266 ****
  746.       case '1': case '2': case '3': case '4':
  747.       case '5': case '6': case '7': case '8': case '9': case '&':
  748.       if (curspat) {
  749. !         paren = atoi(stab_name(stab));
  750.         getparen:
  751.           if (curspat->spat_regexp &&
  752.             paren <= curspat->spat_regexp->nparens &&
  753. --- 269,275 ----
  754.       case '1': case '2': case '3': case '4':
  755.       case '5': case '6': case '7': case '8': case '9': case '&':
  756.       if (curspat) {
  757. !         paren = atoi(stab_ename(stab));
  758.         getparen:
  759.           if (curspat->spat_regexp &&
  760.             paren <= curspat->spat_regexp->nparens &&
  761. ***************
  762. *** 314,319 ****
  763. --- 323,329 ----
  764.       }
  765.   }
  766.   
  767. + void
  768.   stabset(mstr,str)
  769.   register STR *mstr;
  770.   STR *str;
  771. ***************
  772. *** 324,330 ****
  773.   
  774.       switch (mstr->str_rare) {
  775.       case 'E':
  776. !     setenv(mstr->str_ptr,str_get(str));
  777.                   /* And you'll never guess what the dog had */
  778.                   /*   in its mouth... */
  779.   #ifdef TAINT
  780. --- 334,340 ----
  781.   
  782.       switch (mstr->str_rare) {
  783.       case 'E':
  784. !     my_setenv(mstr->str_ptr,str_get(str));
  785.                   /* And you'll never guess what the dog had */
  786.                   /*   in its mouth... */
  787.   #ifdef TAINT
  788. ***************
  789. *** 376,384 ****
  790.           stab = mstr->str_u.str_stab;
  791.           i = str_true(str);
  792.           str = afetch(stab_xarray(stab),atoi(mstr->str_ptr), FALSE);
  793. !         cmd = str->str_magic->str_u.str_cmd;
  794. !         cmd->c_flags &= ~CF_OPTIMIZE;
  795. !         cmd->c_flags |= i? CFT_D1 : CFT_D0;
  796.       }
  797.       break;
  798.       case '#':
  799. --- 386,397 ----
  800.           stab = mstr->str_u.str_stab;
  801.           i = str_true(str);
  802.           str = afetch(stab_xarray(stab),atoi(mstr->str_ptr), FALSE);
  803. !         if (str->str_magic && (cmd = str->str_magic->str_u.str_cmd)) {
  804. !         cmd->c_flags &= ~CF_OPTIMIZE;
  805. !         cmd->c_flags |= i? CFT_D1 : CFT_D0;
  806. !         }
  807. !         else
  808. !         warn("Can't break at that line\n");
  809.       }
  810.       break;
  811.       case '#':
  812. ***************
  813. *** 405,411 ****
  814.           strcpy(stab_magic(stab),"StB");
  815.           stab_val(stab) = Str_new(70,0);
  816.           stab_line(stab) = curcmd->c_line;
  817. !         stab_stash(stab) = curcmd->c_stash;
  818.           }
  819.           else {
  820.           stab = stabent(s,TRUE);
  821. --- 418,424 ----
  822.           strcpy(stab_magic(stab),"StB");
  823.           stab_val(stab) = Str_new(70,0);
  824.           stab_line(stab) = curcmd->c_line;
  825. !         stab_estab(stab) = stab;
  826.           }
  827.           else {
  828.           stab = stabent(s,TRUE);
  829. ***************
  830. *** 459,468 ****
  831.           inplace = Nullch;
  832.           break;
  833.       case '\020':    /* ^P */
  834. !         perldb = (int)str_gnum(str);
  835.           break;
  836.       case '\024':    /* ^T */
  837. !         basetime = (long)str_gnum(str);
  838.           break;
  839.       case '\027':    /* ^W */
  840.           dowarn = (bool)str_gnum(str);
  841. --- 472,490 ----
  842.           inplace = Nullch;
  843.           break;
  844.       case '\020':    /* ^P */
  845. !         i = (int)str_gnum(str);
  846. !         if (i != perldb) {
  847. !         static SPAT *oldlastspat;
  848. ! 
  849. !         if (perldb)
  850. !             oldlastspat = lastspat;
  851. !         else
  852. !             lastspat = oldlastspat;
  853. !         }
  854. !         perldb = i;
  855.           break;
  856.       case '\024':    /* ^T */
  857. !         basetime = (time_t)str_gnum(str);
  858.           break;
  859.       case '\027':    /* ^W */
  860.           dowarn = (bool)str_gnum(str);
  861. ***************
  862. *** 508,514 ****
  863.           if (str->str_pok) {
  864.           rs = str_get(str);
  865.           rslen = str->str_cur;
  866. !         if (!rslen) {
  867.               rs = "\n\n";
  868.               rslen = 2;
  869.           }
  870. --- 530,536 ----
  871.           if (str->str_pok) {
  872.           rs = str_get(str);
  873.           rslen = str->str_cur;
  874. !         if (rspara = !rslen) {
  875.               rs = "\n\n";
  876.               rslen = 2;
  877.           }
  878. ***************
  879. *** 547,588 ****
  880.           break;
  881.       case '<':
  882.           uid = (int)str_gnum(str);
  883. - #if defined(HAS_SETREUID) || !defined(HAS_SETRUID)
  884.           if (delaymagic) {
  885. !         delaymagic |= DM_REUID;
  886.           break;                /* don't do magic till later */
  887.           }
  888. - #endif /* HAS_SETREUID or not HASSETRUID */
  889.   #ifdef HAS_SETRUID
  890. !         if (setruid((UIDTYPE)uid) < 0)
  891. !         uid = (int)getuid();
  892.   #else
  893.   #ifdef HAS_SETREUID
  894. !         if (setreuid((UIDTYPE)uid, (UIDTYPE)-1) < 0)
  895. !         uid = (int)getuid();
  896.   #else
  897.           if (uid == euid)        /* special case $< = $> */
  898. !         setuid(uid);
  899.           else
  900.           fatal("setruid() not implemented");
  901.   #endif
  902.   #endif
  903.           break;
  904.       case '>':
  905.           euid = (int)str_gnum(str);
  906. - #if defined(HAS_SETREUID) || !defined(HAS_SETEUID)
  907.           if (delaymagic) {
  908. !         delaymagic |= DM_REUID;
  909.           break;                /* don't do magic till later */
  910.           }
  911. - #endif /* HAS_SETREUID or not HAS_SETEUID */
  912.   #ifdef HAS_SETEUID
  913. !         if (seteuid((UIDTYPE)euid) < 0)
  914. !         euid = (int)geteuid();
  915.   #else
  916.   #ifdef HAS_SETREUID
  917. !         if (setreuid((UIDTYPE)-1, (UIDTYPE)euid) < 0)
  918. !         euid = (int)geteuid();
  919.   #else
  920.           if (euid == uid)        /* special case $> = $< */
  921.           setuid(euid);
  922. --- 569,603 ----
  923.           break;
  924.       case '<':
  925.           uid = (int)str_gnum(str);
  926.           if (delaymagic) {
  927. !         delaymagic |= DM_RUID;
  928.           break;                /* don't do magic till later */
  929.           }
  930.   #ifdef HAS_SETRUID
  931. !         (void)setruid((UIDTYPE)uid);
  932.   #else
  933.   #ifdef HAS_SETREUID
  934. !         (void)setreuid((UIDTYPE)uid, (UIDTYPE)-1);
  935.   #else
  936.           if (uid == euid)        /* special case $< = $> */
  937. !         (void)setuid(uid);
  938.           else
  939.           fatal("setruid() not implemented");
  940.   #endif
  941.   #endif
  942. +         uid = (int)getuid();
  943.           break;
  944.       case '>':
  945.           euid = (int)str_gnum(str);
  946.           if (delaymagic) {
  947. !         delaymagic |= DM_EUID;
  948.           break;                /* don't do magic till later */
  949.           }
  950.   #ifdef HAS_SETEUID
  951. !         (void)seteuid((UIDTYPE)euid);
  952.   #else
  953.   #ifdef HAS_SETREUID
  954. !         (void)setreuid((UIDTYPE)-1, (UIDTYPE)euid);
  955.   #else
  956.           if (euid == uid)        /* special case $> = $< */
  957.           setuid(euid);
  958. ***************
  959. *** 590,604 ****
  960.           fatal("seteuid() not implemented");
  961.   #endif
  962.   #endif
  963.           break;
  964.       case '(':
  965.           gid = (int)str_gnum(str);
  966. - #if defined(HAS_SETREGID) || !defined(HAS_SETRGID)
  967.           if (delaymagic) {
  968. !         delaymagic |= DM_REGID;
  969.           break;                /* don't do magic till later */
  970.           }
  971. - #endif /* HAS_SETREGID or not HAS_SETRGID */
  972.   #ifdef HAS_SETRGID
  973.           (void)setrgid((GIDTYPE)gid);
  974.   #else
  975. --- 605,618 ----
  976.           fatal("seteuid() not implemented");
  977.   #endif
  978.   #endif
  979. +         euid = (int)geteuid();
  980.           break;
  981.       case '(':
  982.           gid = (int)str_gnum(str);
  983.           if (delaymagic) {
  984. !         delaymagic |= DM_RGID;
  985.           break;                /* don't do magic till later */
  986.           }
  987.   #ifdef HAS_SETRGID
  988.           (void)setrgid((GIDTYPE)gid);
  989.   #else
  990. ***************
  991. *** 605,622 ****
  992.   #ifdef HAS_SETREGID
  993.           (void)setregid((GIDTYPE)gid, (GIDTYPE)-1);
  994.   #else
  995. !         fatal("setrgid() not implemented");
  996.   #endif
  997.   #endif
  998.           break;
  999.       case ')':
  1000.           egid = (int)str_gnum(str);
  1001. - #if defined(HAS_SETREGID) || !defined(HAS_SETEGID)
  1002.           if (delaymagic) {
  1003. !         delaymagic |= DM_REGID;
  1004.           break;                /* don't do magic till later */
  1005.           }
  1006. - #endif /* HAS_SETREGID or not HAS_SETEGID */
  1007.   #ifdef HAS_SETEGID
  1008.           (void)setegid((GIDTYPE)egid);
  1009.   #else
  1010. --- 619,638 ----
  1011.   #ifdef HAS_SETREGID
  1012.           (void)setregid((GIDTYPE)gid, (GIDTYPE)-1);
  1013.   #else
  1014. !         if (gid == egid)            /* special case $( = $) */
  1015. !         (void)setgid(gid);
  1016. !         else
  1017. !         fatal("setrgid() not implemented");
  1018.   #endif
  1019.   #endif
  1020. +         gid = (int)getgid();
  1021.           break;
  1022.       case ')':
  1023.           egid = (int)str_gnum(str);
  1024.           if (delaymagic) {
  1025. !         delaymagic |= DM_EGID;
  1026.           break;                /* don't do magic till later */
  1027.           }
  1028.   #ifdef HAS_SETEGID
  1029.           (void)setegid((GIDTYPE)egid);
  1030.   #else
  1031. ***************
  1032. *** 623,631 ****
  1033.   #ifdef HAS_SETREGID
  1034.           (void)setregid((GIDTYPE)-1, (GIDTYPE)egid);
  1035.   #else
  1036. !         fatal("setegid() not implemented");
  1037.   #endif
  1038.   #endif
  1039.           break;
  1040.       case ':':
  1041.           chopset = str_get(str);
  1042. --- 639,651 ----
  1043.   #ifdef HAS_SETREGID
  1044.           (void)setregid((GIDTYPE)-1, (GIDTYPE)egid);
  1045.   #else
  1046. !         if (egid == gid)            /* special case $) = $( */
  1047. !         (void)setgid(egid);
  1048. !         else
  1049. !         fatal("setegid() not implemented");
  1050.   #endif
  1051.   #endif
  1052. +         egid = (int)getegid();
  1053.           break;
  1054.       case ':':
  1055.           chopset = str_get(str);
  1056. ***************
  1057. *** 640,646 ****
  1058.               s += strlen(++s);    /* this one is ok too */
  1059.           }
  1060.           if (origenviron[0] == s + 1) {    /* can grab env area too? */
  1061. !             setenv("NoNeSuCh", Nullch);    /* force copy of environment */
  1062.               for (i = 0; origenviron[i]; i++)
  1063.               if (origenviron[i] == s + 1)
  1064.                   s += strlen(++s);
  1065. --- 660,667 ----
  1066.               s += strlen(++s);    /* this one is ok too */
  1067.           }
  1068.           if (origenviron[0] == s + 1) {    /* can grab env area too? */
  1069. !             my_setenv("NoNeSuCh", Nullch);
  1070. !                         /* force copy of environment */
  1071.               for (i = 0; origenviron[i]; i++)
  1072.               if (origenviron[i] == s + 1)
  1073.                   s += strlen(++s);
  1074. ***************
  1075. *** 653,662 ****
  1076.           i = origalen;
  1077.           str->str_cur = i;
  1078.           str->str_ptr[i] = '\0';
  1079. !         bcopy(s, origargv[0], i);
  1080.           }
  1081.           else {
  1082. !         bcopy(s, origargv[0], i);
  1083.           s = origargv[0]+i;
  1084.           *s++ = '\0';
  1085.           while (++i < origalen)
  1086. --- 674,683 ----
  1087.           i = origalen;
  1088.           str->str_cur = i;
  1089.           str->str_ptr[i] = '\0';
  1090. !         Copy(s, origargv[0], i, char);
  1091.           }
  1092.           else {
  1093. !         Copy(s, origargv[0], i, char);
  1094.           s = origargv[0]+i;
  1095.           *s++ = '\0';
  1096.           while (++i < origalen)
  1097. ***************
  1098. *** 676,681 ****
  1099. --- 697,703 ----
  1100.       }
  1101.   }
  1102.   
  1103. + int
  1104.   whichsig(sig)
  1105.   char *sig;
  1106.   {
  1107. ***************
  1108. *** 725,731 ****
  1109.       if (!sub) {
  1110.       if (dowarn)
  1111.           warn("SIG%s handler \"%s\" not defined.\n",
  1112. !         sig_name[sig], stab_name(stab) );
  1113.       return;
  1114.       }
  1115.       /*SUPPRESS 701*/
  1116. --- 747,753 ----
  1117.       if (!sub) {
  1118.       if (dowarn)
  1119.           warn("SIG%s handler \"%s\" not defined.\n",
  1120. !         sig_name[sig], stab_ename(stab) );
  1121.       return;
  1122.       }
  1123.       /*SUPPRESS 701*/
  1124. ***************
  1125. *** 751,757 ****
  1126.       sub->depth++;
  1127.       if (sub->depth >= 2) {    /* save temporaries on recursion? */
  1128.       if (sub->depth == 100 && dowarn)
  1129. !         warn("Deep recursion on subroutine \"%s\"",stab_name(stab));
  1130.       savelist(sub->tosave->ary_array,sub->tosave->ary_fill);
  1131.       }
  1132.   
  1133. --- 773,779 ----
  1134.       sub->depth++;
  1135.       if (sub->depth >= 2) {    /* save temporaries on recursion? */
  1136.       if (sub->depth == 100 && dowarn)
  1137. !         warn("Deep recursion on subroutine \"%s\"",stab_ename(stab));
  1138.       savelist(sub->tosave->ary_array,sub->tosave->ary_fill);
  1139.       }
  1140.   
  1141. ***************
  1142. *** 888,893 ****
  1143. --- 910,916 ----
  1144.       strcpy(stab_magic(stab),"StB");
  1145.       stab_val(stab) = Str_new(72,0);
  1146.       stab_line(stab) = curcmd->c_line;
  1147. +     stab_estab(stab) = stab;
  1148.       str_magic((STR*)stab, stab, '*', name, len);
  1149.       stab_stash(stab) = stash;
  1150.       if (isDIGIT(*name) && *name != '0') {
  1151. ***************
  1152. *** 900,905 ****
  1153. --- 923,929 ----
  1154.       }
  1155.   }
  1156.   
  1157. + void
  1158.   stab_fullname(str,stab)
  1159.   STR *str;
  1160.   STAB *stab;
  1161. ***************
  1162. *** 913,918 ****
  1163. --- 937,956 ----
  1164.       str_scat(str,stab->str_magic);
  1165.   }
  1166.   
  1167. + void
  1168. + stab_efullname(str,stab)
  1169. + STR *str;
  1170. + STAB *stab;
  1171. + {
  1172. +     HASH *tb = stab_estash(stab);
  1173. + 
  1174. +     if (!tb)
  1175. +     return;
  1176. +     str_set(str,tb->tbl_name);
  1177. +     str_ncat(str,"'", 1);
  1178. +     str_scat(str,stab_estab(stab)->str_magic);
  1179. + }
  1180. + 
  1181.   STIO *
  1182.   stio_new()
  1183.   {
  1184. ***************
  1185. *** 923,928 ****
  1186. --- 961,967 ----
  1187.       return stio;
  1188.   }
  1189.   
  1190. + void
  1191.   stab_check(min,max)
  1192.   int min;
  1193.   register int max;
  1194. ***************
  1195. *** 960,965 ****
  1196. --- 999,1006 ----
  1197.       STIO *stio;
  1198.       SUBR *sub;
  1199.   
  1200. +     if (!stab || !stab->str_ptr)
  1201. +     return;
  1202.       afree(stab_xarray(stab));
  1203.       stab_xarray(stab) = Null(ARRAY*);
  1204.       (void)hfree(stab_xhash(stab), FALSE);
  1205.  
  1206. Index: stab.h
  1207. *** stab.h.old    Mon Jun  8 17:51:49 1992
  1208. --- stab.h    Mon Jun  8 17:51:50 1992
  1209. ***************
  1210. *** 1,4 ****
  1211. ! /* $RCSfile: stab.h,v $$Revision: 4.0.1.2 $$Date: 91/11/05 18:36:15 $
  1212.    *
  1213.    *    Copyright (c) 1991, Larry Wall
  1214.    *
  1215. --- 1,4 ----
  1216. ! /* $RCSfile: stab.h,v $$Revision: 4.0.1.3 $$Date: 92/06/08 15:33:44 $
  1217.    *
  1218.    *    Copyright (c) 1991, Larry Wall
  1219.    *
  1220. ***************
  1221. *** 6,11 ****
  1222. --- 6,15 ----
  1223.    *    License or the Artistic License, as specified in the README file.
  1224.    *
  1225.    * $Log:    stab.h,v $
  1226. +  * Revision 4.0.1.3  92/06/08  15:33:44  lwall
  1227. +  * patch20: fixed confusion between a *var's real name and its effective name
  1228. +  * patch20: ($<,$>) = ... didn't work on some architectures
  1229. +  * 
  1230.    * Revision 4.0.1.2  91/11/05  18:36:15  lwall
  1231.    * patch11: length($x) was sometimes wrong for numeric $x
  1232.    * 
  1233. ***************
  1234. *** 25,31 ****
  1235.       FCMD    *stbp_form;    /* format value */
  1236.       ARRAY    *stbp_array;    /* array value */
  1237.       HASH    *stbp_hash;    /* associative array value */
  1238. !     HASH    *stbp_stash;    /* symbol table for this stab */
  1239.       SUBR    *stbp_sub;    /* subroutine value */
  1240.       int        stbp_lastexpr;    /* used by nothing_in_common() */
  1241.       line_t    stbp_line;    /* line first declared at (for -w) */
  1242. --- 29,35 ----
  1243.       FCMD    *stbp_form;    /* format value */
  1244.       ARRAY    *stbp_array;    /* array value */
  1245.       HASH    *stbp_hash;    /* associative array value */
  1246. !     STAB    *stbp_stab;    /* effective stab, if *glob */
  1247.       SUBR    *stbp_sub;    /* subroutine value */
  1248.       int        stbp_lastexpr;    /* used by nothing_in_common() */
  1249.       line_t    stbp_line;    /* line first declared at (for -w) */
  1250. ***************
  1251. *** 56,68 ****
  1252.                    ((STBP*)(stab->str_ptr))->stbp_hash : \
  1253.                    ((STBP*)(hadd(stab)->str_ptr))->stbp_hash)
  1254.   #endif            /* Microport 2.4 hack */
  1255. - #define stab_stash(stab)    (((STBP*)(stab->str_ptr))->stbp_stash)
  1256.   #define stab_sub(stab)        (((STBP*)(stab->str_ptr))->stbp_sub)
  1257.   #define stab_lastexpr(stab)    (((STBP*)(stab->str_ptr))->stbp_lastexpr)
  1258.   #define stab_line(stab)        (((STBP*)(stab->str_ptr))->stbp_line)
  1259.   #define stab_flags(stab)    (((STBP*)(stab->str_ptr))->stbp_flags)
  1260.   #define stab_name(stab)        (stab->str_magic->str_ptr)
  1261.   
  1262.   #define SF_VMAGIC 1        /* call routine to dereference STR val */
  1263.   #define SF_MULTI 2        /* seen more than once */
  1264.   
  1265. --- 60,79 ----
  1266.                    ((STBP*)(stab->str_ptr))->stbp_hash : \
  1267.                    ((STBP*)(hadd(stab)->str_ptr))->stbp_hash)
  1268.   #endif            /* Microport 2.4 hack */
  1269.   #define stab_sub(stab)        (((STBP*)(stab->str_ptr))->stbp_sub)
  1270.   #define stab_lastexpr(stab)    (((STBP*)(stab->str_ptr))->stbp_lastexpr)
  1271.   #define stab_line(stab)        (((STBP*)(stab->str_ptr))->stbp_line)
  1272.   #define stab_flags(stab)    (((STBP*)(stab->str_ptr))->stbp_flags)
  1273. + 
  1274. + #define stab_stab(stab)        (stab->str_magic->str_u.str_stab)
  1275. + #define stab_estab(stab)    (((STBP*)(stab->str_ptr))->stbp_stab)
  1276. + 
  1277.   #define stab_name(stab)        (stab->str_magic->str_ptr)
  1278. + #define stab_ename(stab)    stab_name(stab_estab(stab))
  1279.   
  1280. + #define stab_stash(stab)    (stab->str_magic->str_u.str_stash)
  1281. + #define stab_estash(stab)    stab_stash(stab_estab(stab))
  1282. + 
  1283.   #define SF_VMAGIC 1        /* call routine to dereference STR val */
  1284.   #define SF_MULTI 2        /* seen more than once */
  1285.   
  1286. ***************
  1287. *** 114,123 ****
  1288.   EXT unsigned short statusvalue;
  1289.   
  1290.   EXT int delaymagic INIT(0);
  1291. ! #define DM_DELAY 1
  1292. ! #define DM_REUID 2
  1293. ! #define DM_REGID 4
  1294.   
  1295.   STAB *aadd();
  1296.   STAB *hadd();
  1297.   STAB *fstab();
  1298. --- 125,142 ----
  1299.   EXT unsigned short statusvalue;
  1300.   
  1301.   EXT int delaymagic INIT(0);
  1302. ! #define DM_UID   0x003
  1303. ! #define DM_RUID   0x001
  1304. ! #define DM_EUID   0x002
  1305. ! #define DM_GID   0x030
  1306. ! #define DM_RGID   0x010
  1307. ! #define DM_EGID   0x020
  1308. ! #define DM_DELAY 0x100
  1309.   
  1310.   STAB *aadd();
  1311.   STAB *hadd();
  1312.   STAB *fstab();
  1313. + void stabset();
  1314. + void stab_fullname();
  1315. + void stab_efullname();
  1316. + void stab_check();
  1317.  
  1318. Index: str.c
  1319. *** str.c.old    Mon Jun  8 17:51:53 1992
  1320. --- str.c    Mon Jun  8 17:51:54 1992
  1321. ***************
  1322. *** 1,4 ****
  1323. ! /* $RCSfile: str.c,v $$Revision: 4.0.1.4 $$Date: 91/11/05 18:40:51 $
  1324.    *
  1325.    *    Copyright (c) 1991, Larry Wall
  1326.    *
  1327. --- 1,4 ----
  1328. ! /* $RCSfile: str.c,v $$Revision: 4.0.1.5 $$Date: 92/06/08 15:40:43 $
  1329.    *
  1330.    *    Copyright (c) 1991, Larry Wall
  1331.    *
  1332. ***************
  1333. *** 6,11 ****
  1334. --- 6,21 ----
  1335.    *    License or the Artistic License, as specified in the README file.
  1336.    *
  1337.    * $Log:    str.c,v $
  1338. +  * Revision 4.0.1.5  92/06/08  15:40:43  lwall
  1339. +  * patch20: removed implicit int declarations on functions
  1340. +  * patch20: Perl now distinguishes overlapped copies from non-overlapped
  1341. +  * patch20: paragraph mode now skips extra newlines automatically
  1342. +  * patch20: fixed memory leak in doube-quote interpretation
  1343. +  * patch20: made /\$$foo/ look for literal '$foo'
  1344. +  * patch20: "$var{$foo'bar}" didn't scan subscript correctly
  1345. +  * patch20: a splice on non-existent array elements could dump core
  1346. +  * patch20: running taintperl explicitly now does checks even if $< == $>
  1347. +  * 
  1348.    * Revision 4.0.1.4  91/11/05  18:40:51  lwall
  1349.    * patch11: $foo .= <BAR> could overrun malloced memory
  1350.    * patch11: \$ didn't always make it through double-quoter to regexp routines
  1351. ***************
  1352. *** 32,37 ****
  1353. --- 42,50 ----
  1354.   #include "perl.h"
  1355.   #include "perly.h"
  1356.   
  1357. + static void ucase();
  1358. + static void lcase();
  1359. + 
  1360.   #ifndef str_get
  1361.   char *
  1362.   str_get(str)
  1363. ***************
  1364. *** 48,53 ****
  1365. --- 61,67 ----
  1366.    * dlb the following functions are usually macros.
  1367.    */
  1368.   #ifndef str_true
  1369. + int
  1370.   str_true(Str)
  1371.   STR *Str;
  1372.   {
  1373. ***************
  1374. *** 81,87 ****
  1375.   char *
  1376.   str_grow(str,newlen)
  1377.   register STR *str;
  1378. ! #ifndef MSDOS
  1379.   register int newlen;
  1380.   #else
  1381.   unsigned long newlen;
  1382. --- 95,101 ----
  1383.   char *
  1384.   str_grow(str,newlen)
  1385.   register STR *str;
  1386. ! #ifndef DOSISH
  1387.   register int newlen;
  1388.   #else
  1389.   unsigned long newlen;
  1390. ***************
  1391. *** 99,105 ****
  1392.       str->str_len += str->str_u.str_useful;
  1393.       str->str_ptr -= str->str_u.str_useful;
  1394.       str->str_u.str_useful = 0L;
  1395. !     bcopy(s, str->str_ptr, str->str_cur+1);
  1396.       s = str->str_ptr;
  1397.       str->str_state = SS_NORM;            /* normal again */
  1398.       if (newlen > str->str_len)
  1399. --- 113,119 ----
  1400.       str->str_len += str->str_u.str_useful;
  1401.       str->str_ptr -= str->str_u.str_useful;
  1402.       str->str_u.str_useful = 0L;
  1403. !     Move(s, str->str_ptr, str->str_cur+1, char);
  1404.       s = str->str_ptr;
  1405.       str->str_state = SS_NORM;            /* normal again */
  1406.       if (newlen > str->str_len)
  1407. ***************
  1408. *** 116,121 ****
  1409. --- 130,136 ----
  1410.       return s;
  1411.   }
  1412.   
  1413. + void
  1414.   str_numset(str,num)
  1415.   register STR *str;
  1416.   double num;
  1417. ***************
  1418. *** 212,217 ****
  1419. --- 227,233 ----
  1420.    * as temporary.
  1421.    */
  1422.   
  1423. + void
  1424.   str_sset(dstr,sstr)
  1425.   STR *dstr;
  1426.   register STR *sstr;
  1427. ***************
  1428. *** 273,278 ****
  1429. --- 289,298 ----
  1430.           char *tmps = dstr->str_ptr;
  1431.   
  1432.           if (*tmps == 'S' && bcmp(tmps,"StB",4) == 0) {
  1433. +             if (dstr->str_magic && dstr->str_magic->str_rare == 'X') {
  1434. +             str_free(dstr->str_magic);
  1435. +             dstr->str_magic = Nullstr;
  1436. +             }
  1437.               if (!dstr->str_magic) {
  1438.               dstr->str_magic = str_smake(sstr->str_magic);
  1439.               dstr->str_magic->str_rare = 'X';
  1440. ***************
  1441. *** 296,301 ****
  1442. --- 316,322 ----
  1443.       }
  1444.   }
  1445.   
  1446. + void
  1447.   str_nset(str,ptr,len)
  1448.   register STR *str;
  1449.   register char *ptr;
  1450. ***************
  1451. *** 305,311 ****
  1452.       return;
  1453.       STR_GROW(str, len + 1);
  1454.       if (ptr)
  1455. !     (void)bcopy(ptr,str->str_ptr,len);
  1456.       str->str_cur = len;
  1457.       *(str->str_ptr+str->str_cur) = '\0';
  1458.       str->str_nok = 0;        /* invalidate number */
  1459. --- 326,332 ----
  1460.       return;
  1461.       STR_GROW(str, len + 1);
  1462.       if (ptr)
  1463. !     Move(ptr,str->str_ptr,len,char);
  1464.       str->str_cur = len;
  1465.       *(str->str_ptr+str->str_cur) = '\0';
  1466.       str->str_nok = 0;        /* invalidate number */
  1467. ***************
  1468. *** 315,320 ****
  1469. --- 336,342 ----
  1470.   #endif
  1471.   }
  1472.   
  1473. + void
  1474.   str_set(str,ptr)
  1475.   register STR *str;
  1476.   register char *ptr;
  1477. ***************
  1478. *** 327,333 ****
  1479.       ptr = "";
  1480.       len = strlen(ptr);
  1481.       STR_GROW(str, len + 1);
  1482. !     (void)bcopy(ptr,str->str_ptr,len+1);
  1483.       str->str_cur = len;
  1484.       str->str_nok = 0;        /* invalidate number */
  1485.       str->str_pok = 1;        /* validate pointer */
  1486. --- 349,355 ----
  1487.       ptr = "";
  1488.       len = strlen(ptr);
  1489.       STR_GROW(str, len + 1);
  1490. !     Move(ptr,str->str_ptr,len+1,char);
  1491.       str->str_cur = len;
  1492.       str->str_nok = 0;        /* invalidate number */
  1493.       str->str_pok = 1;        /* validate pointer */
  1494. ***************
  1495. *** 336,341 ****
  1496. --- 358,364 ----
  1497.   #endif
  1498.   }
  1499.   
  1500. + void
  1501.   str_chop(str,ptr)    /* like set but assuming ptr is in str */
  1502.   register STR *str;
  1503.   register char *ptr;
  1504. ***************
  1505. *** 358,363 ****
  1506. --- 381,387 ----
  1507.       str->str_pok = 1;        /* validate pointer (and unstudy str) */
  1508.   }
  1509.   
  1510. + void
  1511.   str_ncat(str,ptr,len)
  1512.   register STR *str;
  1513.   register char *ptr;
  1514. ***************
  1515. *** 368,374 ****
  1516.       if (!(str->str_pok))
  1517.       (void)str_2ptr(str);
  1518.       STR_GROW(str, str->str_cur + len + 1);
  1519. !     (void)bcopy(ptr,str->str_ptr+str->str_cur,len);
  1520.       str->str_cur += len;
  1521.       *(str->str_ptr+str->str_cur) = '\0';
  1522.       str->str_nok = 0;        /* invalidate number */
  1523. --- 392,398 ----
  1524.       if (!(str->str_pok))
  1525.       (void)str_2ptr(str);
  1526.       STR_GROW(str, str->str_cur + len + 1);
  1527. !     Move(ptr,str->str_ptr+str->str_cur,len,char);
  1528.       str->str_cur += len;
  1529.       *(str->str_ptr+str->str_cur) = '\0';
  1530.       str->str_nok = 0;        /* invalidate number */
  1531. ***************
  1532. *** 378,383 ****
  1533. --- 402,408 ----
  1534.   #endif
  1535.   }
  1536.   
  1537. + void
  1538.   str_scat(dstr,sstr)
  1539.   STR *dstr;
  1540.   register STR *sstr;
  1541. ***************
  1542. *** 393,398 ****
  1543. --- 418,424 ----
  1544.       str_ncat(dstr,sstr->str_ptr,sstr->str_cur);
  1545.   }
  1546.   
  1547. + void
  1548.   str_cat(str,ptr)
  1549.   register STR *str;
  1550.   register char *ptr;
  1551. ***************
  1552. *** 407,413 ****
  1553.       (void)str_2ptr(str);
  1554.       len = strlen(ptr);
  1555.       STR_GROW(str, str->str_cur + len + 1);
  1556. !     (void)bcopy(ptr,str->str_ptr+str->str_cur,len+1);
  1557.       str->str_cur += len;
  1558.       str->str_nok = 0;        /* invalidate number */
  1559.       str->str_pok = 1;        /* validate pointer */
  1560. --- 433,439 ----
  1561.       (void)str_2ptr(str);
  1562.       len = strlen(ptr);
  1563.       STR_GROW(str, str->str_cur + len + 1);
  1564. !     Move(ptr,str->str_ptr+str->str_cur,len+1,char);
  1565.       str->str_cur += len;
  1566.       str->str_nok = 0;        /* invalidate number */
  1567.       str->str_pok = 1;        /* validate pointer */
  1568. ***************
  1569. *** 530,542 ****
  1570.       *bigend = '\0';
  1571.       while (midend > mid)        /* shove everything down */
  1572.           *--bigend = *--midend;
  1573. !     (void)bcopy(little,big+offset,littlelen);
  1574.       bigstr->str_cur += i;
  1575.       STABSET(bigstr);
  1576.       return;
  1577.       }
  1578.       else if (i == 0) {
  1579. !     (void)bcopy(little,bigstr->str_ptr+offset,len);
  1580.       STABSET(bigstr);
  1581.       return;
  1582.       }
  1583. --- 556,568 ----
  1584.       *bigend = '\0';
  1585.       while (midend > mid)        /* shove everything down */
  1586.           *--bigend = *--midend;
  1587. !     Move(little,big+offset,littlelen,char);
  1588.       bigstr->str_cur += i;
  1589.       STABSET(bigstr);
  1590.       return;
  1591.       }
  1592.       else if (i == 0) {
  1593. !     Move(little,bigstr->str_ptr+offset,len,char);
  1594.       STABSET(bigstr);
  1595.       return;
  1596.       }
  1597. ***************
  1598. *** 551,562 ****
  1599.   
  1600.       if (mid - big > bigend - midend) {    /* faster to shorten from end */
  1601.       if (littlelen) {
  1602. !         (void)bcopy(little, mid, littlelen);
  1603.           mid += littlelen;
  1604.       }
  1605.       i = bigend - midend;
  1606.       if (i > 0) {
  1607. !         (void)bcopy(midend, mid, i);
  1608.           mid += i;
  1609.       }
  1610.       *mid = '\0';
  1611. --- 577,588 ----
  1612.   
  1613.       if (mid - big > bigend - midend) {    /* faster to shorten from end */
  1614.       if (littlelen) {
  1615. !         Move(little, mid, littlelen,char);
  1616.           mid += littlelen;
  1617.       }
  1618.       i = bigend - midend;
  1619.       if (i > 0) {
  1620. !         Move(midend, mid, i,char);
  1621.           mid += i;
  1622.       }
  1623.       *mid = '\0';
  1624. ***************
  1625. *** 571,582 ****
  1626.       while (i--)
  1627.           *--midend = *--big;
  1628.       if (littlelen)
  1629. !         (void)bcopy(little, mid, littlelen);
  1630.       }
  1631.       else if (littlelen) {
  1632.       midend -= littlelen;
  1633.       str_chop(bigstr,midend);
  1634. !     (void)bcopy(little,midend,littlelen);
  1635.       }
  1636.       else {
  1637.       str_chop(bigstr,midend);
  1638. --- 597,608 ----
  1639.       while (i--)
  1640.           *--midend = *--big;
  1641.       if (littlelen)
  1642. !         Move(little, mid, littlelen,char);
  1643.       }
  1644.       else if (littlelen) {
  1645.       midend -= littlelen;
  1646.       str_chop(bigstr,midend);
  1647. !     Move(little,midend,littlelen,char);
  1648.       }
  1649.       else {
  1650.       str_chop(bigstr,midend);
  1651. ***************
  1652. *** 679,684 ****
  1653. --- 705,711 ----
  1654.       return 0;
  1655.   }
  1656.   
  1657. + int
  1658.   str_eq(str1,str2)
  1659.   register STR *str1;
  1660.   register STR *str2;
  1661. ***************
  1662. *** 699,704 ****
  1663. --- 726,732 ----
  1664.       return !bcmp(str1->str_ptr, str2->str_ptr, str1->str_cur);
  1665.   }
  1666.   
  1667. + int
  1668.   str_cmp(str1,str2)
  1669.   register STR *str1;
  1670.   register STR *str2;
  1671. ***************
  1672. *** 747,752 ****
  1673. --- 775,789 ----
  1674.   
  1675.       if (str == &str_undef)
  1676.       return Nullch;
  1677. +     if (rspara) {        /* have to do this both before and after */
  1678. +     do {            /* to make sure file boundaries work right */
  1679. +         i = getc(fp);
  1680. +         if (i != '\n') {
  1681. +         ungetc(i,fp);
  1682. +         break;
  1683. +         }
  1684. +     } while (i != EOF);
  1685. +     }
  1686.   #ifdef STDSTDIO        /* Here is some breathtakingly efficient cheating */
  1687.       cnt = fp->_cnt;            /* get count into register */
  1688.       str->str_nok = 0;            /* invalidate number */
  1689. ***************
  1690. *** 849,854 ****
  1691. --- 886,900 ----
  1692.   
  1693.   #endif /* STDSTDIO */
  1694.   
  1695. +     if (rspara) {
  1696. +         while (i != EOF) {
  1697. +         i = getc(fp);
  1698. +         if (i != '\n') {
  1699. +         ungetc(i,fp);
  1700. +         break;
  1701. +         }
  1702. +     }
  1703. +     }
  1704.       return str->str_cur - append ? str->str_ptr : Nullch;
  1705.   }
  1706.   
  1707. ***************
  1708. *** 906,912 ****
  1709.       if (cmd->c_type != C_EXPR || cmd->c_next || arg->arg_type != O_LIST)
  1710.       fatal("panic: error in parselist %d %x %d", cmd->c_type,
  1711.         cmd->c_next, arg ? arg->arg_type : -1);
  1712. !     Safefree(cmd);
  1713.       eval_root = Nullcmd;
  1714.       return arg;
  1715.   }
  1716. --- 952,959 ----
  1717.       if (cmd->c_type != C_EXPR || cmd->c_next || arg->arg_type != O_LIST)
  1718.       fatal("panic: error in parselist %d %x %d", cmd->c_type,
  1719.         cmd->c_next, arg ? arg->arg_type : -1);
  1720. !     cmd->c_expr = Nullarg;
  1721. !     cmd_free(cmd);
  1722.       eval_root = Nullcmd;
  1723.       return arg;
  1724.   }
  1725. ***************
  1726. *** 945,954 ****
  1727.           if (*nointrp) {        /* in a regular expression */
  1728.               if (*s == '@')    /* always strip \@ */ /*SUPPRESS 530*/
  1729.               ;
  1730. -             else if (*s == '$') {
  1731. -             if (s+1 >= send || index(nointrp, s[1]))
  1732. -                 str_ncat(str,s-1,1); /* only strip \$ for vars */
  1733. -             }
  1734.               else        /* don't strip \\, \[, \{ etc. */
  1735.               str_ncat(str,s-1,1);
  1736.           }
  1737. --- 992,997 ----
  1738. ***************
  1739. *** 988,1014 ****
  1740.           do {
  1741.               switch (*s) {
  1742.               case '[':
  1743. !             if (s[-1] != '$')
  1744. !                 brackets++;
  1745.               break;
  1746.               case '{':
  1747.               brackets++;
  1748.               break;
  1749.               case ']':
  1750. !             if (s[-1] != '$')
  1751. !                 brackets--;
  1752.               break;
  1753.               case '}':
  1754.               brackets--;
  1755.               break;
  1756.               case '\'':
  1757.               case '"':
  1758. !             if (s[-1] != '$') {
  1759. !                 /*SUPPRESS 68*/
  1760. !                 s = cpytill(tokenbuf,s+1,send,*s,&len);
  1761. !                 if (s >= send)
  1762. !                 fatal("Unterminated string");
  1763. !             }
  1764.               break;
  1765.               }
  1766.               s++;
  1767. --- 1031,1060 ----
  1768.           do {
  1769.               switch (*s) {
  1770.               case '[':
  1771. !             brackets++;
  1772.               break;
  1773.               case '{':
  1774.               brackets++;
  1775.               break;
  1776.               case ']':
  1777. !             brackets--;
  1778.               break;
  1779.               case '}':
  1780.               brackets--;
  1781.               break;
  1782. +             case '$':
  1783. +             case '%':
  1784. +             case '@':
  1785. +             case '&':
  1786. +             case '*':
  1787. +             s = scanident(s,send,tokenbuf);
  1788. +             break;
  1789.               case '\'':
  1790.               case '"':
  1791. !             /*SUPPRESS 68*/
  1792. !             s = cpytill(tokenbuf,s+1,send,*s,&len);
  1793. !             if (s >= send)
  1794. !                 fatal("Unterminated string");
  1795.               break;
  1796.               }
  1797.               s++;
  1798. ***************
  1799. *** 1254,1259 ****
  1800. --- 1300,1306 ----
  1801.       return str;
  1802.   }
  1803.   
  1804. + static void
  1805.   ucase(s,send)
  1806.   register char *s;
  1807.   register char *send;
  1808. ***************
  1809. *** 1265,1270 ****
  1810. --- 1312,1318 ----
  1811.       }
  1812.   }
  1813.   
  1814. + static void
  1815.   lcase(s,send)
  1816.   register char *s;
  1817.   register char *send;
  1818. ***************
  1819. *** 1381,1387 ****
  1820.   str_2mortal(str)
  1821.   register STR *str;
  1822.   {
  1823. !     if (str == &str_undef)
  1824.       return str;
  1825.       if (++tmps_max > tmps_size) {
  1826.       tmps_size = tmps_max;
  1827. --- 1429,1435 ----
  1828.   str_2mortal(str)
  1829.   register STR *str;
  1830.   {
  1831. !     if (!str || str == &str_undef)
  1832.       return str;
  1833.       if (++tmps_max > tmps_size) {
  1834.       tmps_size = tmps_max;
  1835. ***************
  1836. *** 1439,1445 ****
  1837.       Str_Grow(old,0);
  1838.       if (new->str_ptr)
  1839.       Safefree(new->str_ptr);
  1840. !     Copy(old,new,1,STR);
  1841.       if (old->str_ptr) {
  1842.       new->str_ptr = nsavestr(old->str_ptr,old->str_len);
  1843.       new->str_pok &= ~SP_TEMP;
  1844. --- 1487,1493 ----
  1845.       Str_Grow(old,0);
  1846.       if (new->str_ptr)
  1847.       Safefree(new->str_ptr);
  1848. !     StructCopy(old,new,STR);
  1849.       if (old->str_ptr) {
  1850.       new->str_ptr = nsavestr(old->str_ptr,old->str_len);
  1851.       new->str_pok &= ~SP_TEMP;
  1852. ***************
  1853. *** 1447,1452 ****
  1854. --- 1495,1501 ----
  1855.       return new;
  1856.   }
  1857.   
  1858. + void
  1859.   str_reset(s,stash)
  1860.   register char *s;
  1861.   HASH *stash;
  1862. ***************
  1863. *** 1504,1509 ****
  1864. --- 1553,1559 ----
  1865.   }
  1866.   
  1867.   #ifdef TAINT
  1868. + void
  1869.   taintproper(s)
  1870.   char *s;
  1871.   {
  1872. ***************
  1873. *** 1511,1517 ****
  1874.       if (debug & 2048)
  1875.       fprintf(stderr,"%s %d %d %d\n",s,tainted,uid, euid);
  1876.   #endif
  1877. !     if (tainted && (!euid || euid != uid || egid != gid)) {
  1878.       if (!unsafe)
  1879.           fatal("%s", s);
  1880.       else if (dowarn)
  1881. --- 1561,1567 ----
  1882.       if (debug & 2048)
  1883.       fprintf(stderr,"%s %d %d %d\n",s,tainted,uid, euid);
  1884.   #endif
  1885. !     if (tainted && (!euid || euid != uid || egid != gid || taintanyway)) {
  1886.       if (!unsafe)
  1887.           fatal("%s", s);
  1888.       else if (dowarn)
  1889. ***************
  1890. *** 1519,1524 ****
  1891. --- 1569,1575 ----
  1892.       }
  1893.   }
  1894.   
  1895. + void
  1896.   taintenv()
  1897.   {
  1898.       register STR *envstr;
  1899.  
  1900. Index: lib/syslog.pl
  1901. *** lib/syslog.pl.old    Mon Jun  8 17:49:14 1992
  1902. --- lib/syslog.pl    Mon Jun  8 17:49:14 1992
  1903. ***************
  1904. *** 2,7 ****
  1905. --- 2,10 ----
  1906.   # syslog.pl
  1907.   #
  1908.   # $Log:    syslog.pl,v $
  1909. + # Revision 4.0.1.1  92/06/08  13:48:05  lwall
  1910. + # patch20: new warning for ambiguous use of unary operators
  1911. + # 
  1912.   # Revision 4.0  91/03/20  01:26:24  lwall
  1913.   # 4.0 baseline.
  1914.   # 
  1915. ***************
  1916. *** 164,170 ****
  1917.       $name =~ y/a-z/A-Z/;
  1918.       $name = "LOG_$name" unless $name =~ /^LOG_/;
  1919.       $name = "syslog'$name";
  1920. !     eval &$name || -1;
  1921.   }
  1922.   
  1923.   sub connect {
  1924. --- 167,173 ----
  1925.       $name =~ y/a-z/A-Z/;
  1926.       $name = "LOG_$name" unless $name =~ /^LOG_/;
  1927.       $name = "syslog'$name";
  1928. !     eval(&$name) || -1;
  1929.   }
  1930.   
  1931.   sub connect {
  1932.  
  1933. Index: atarist/test/tbinmode
  1934. *** atarist/test/tbinmode.old    Mon Jun  8 17:45:23 1992
  1935. --- atarist/test/tbinmode    Mon Jun  8 17:45:25 1992
  1936. ***************
  1937. *** 0 ****
  1938. --- 1,12 ----
  1939. + open(FP, ">bintest") || die "Can't open bintest for write\n";
  1940. + binmode FP;
  1941. + print FP pack("C*", 0xaa, 0x55, 0xaa, 0x55,
  1942. +                     0xff, 0x0d, 0x0a);
  1943. + close FP;
  1944. + 
  1945. + open(FP, "<bintest") || die "Can't open bintest for read\n";
  1946. + binmode FP;
  1947. + @got = unpack("C*", <FP>);
  1948. + close FP;
  1949. + printf "expect:\t7 elements: aa 55 aa 55 ff 0d 0a\n";
  1950. + printf "got:\t%d elements: %x %x %x %x %x %02x %02x\n", $#got+1-$[, @got;
  1951.  
  1952. Index: hints/ultrix_4.sh
  1953. *** hints/ultrix_4.sh.old    Mon Jun  8 17:48:29 1992
  1954. --- hints/ultrix_4.sh    Mon Jun  8 17:48:29 1992
  1955. ***************
  1956. *** 18,22 ****
  1957. --- 18,23 ----
  1958.       toke_cflags='optimize="-g"'
  1959.       ttoke_cflags='optimize="-g"'
  1960.       ;;
  1961. + *4.2*) libswanted=`echo $libswanted | sed 's/ malloc / /'` ;;
  1962.   esac
  1963.   
  1964.  
  1965. Index: hints/unisysdynix.sh
  1966. *** hints/unisysdynix.sh.old    Mon Jun  8 17:47:43 1992
  1967. --- hints/unisysdynix.sh    Mon Jun  8 17:47:43 1992
  1968. ***************
  1969. *** 0 ****
  1970. --- 1 ----
  1971. + d_waitpid=undef
  1972.  
  1973. Index: atarist/usersub.c
  1974. *** atarist/usersub.c.old    Mon Jun  8 17:45:26 1992
  1975. --- atarist/usersub.c    Mon Jun  8 17:45:27 1992
  1976. ***************
  1977. *** 0 ****
  1978. --- 1,9 ----
  1979. + #include "EXTERN.h"
  1980. + #include "perl.h"
  1981. + #include <stdio.h>
  1982. + 
  1983. + int userinit()
  1984. + {
  1985. +     install_null();    /* install device /dev/null or NUL: */
  1986. +     return 0;
  1987. + }
  1988.  
  1989. *** End of Patch 31 ***
  1990. exit 0 # Just in case...
  1991.