home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / misc / volume25 / perl / patch16 < prev    next >
Encoding:
Text File  |  1991-11-13  |  48.4 KB  |  1,848 lines
  1. Newsgroups: comp.sources.misc
  2. From: lwall@netlabs.com (Larry Wall)
  3. Subject:  v25i065:  perl - The perl programming language, Patch16
  4. Message-ID: <1991Nov13.214519.3898@sparky.imd.sterling.com>
  5. X-Md4-Signature: 804831971202fcf3ea912a072808a5da
  6. Date: Wed, 13 Nov 1991 21:45:19 GMT
  7. Approved: kent@sparky.imd.sterling.com
  8.  
  9. Submitted-by: lwall@netlabs.com (Larry Wall)
  10. Posting-number: Volume 25, Issue 65
  11. Archive-name: perl/patch16
  12. Environment: UNIX, MS-DOS, OS2
  13. Patch-To: perl: Volume 18, Issue 19-54
  14.  
  15. System: perl version 4.0
  16. Patch #: 16
  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: 15
  56. 1c1
  57. < #define PATCHLEVEL 15
  58. ---
  59. > #define PATCHLEVEL 16
  60.  
  61. Index: lib/perldb.pl
  62. Prereq: 4.0.1.1
  63. *** lib/perldb.pl.old    Tue Nov  5 19:27:07 1991
  64. --- lib/perldb.pl    Tue Nov  5 19:27:08 1991
  65. ***************
  66. *** 1,6 ****
  67.   package DB;
  68.   
  69. ! $header = '$RCSfile: perldb.pl,v $$Revision: 4.0.1.1 $$Date: 91/06/07 11:17:44 $';
  70.   #
  71.   # This file is automatically included if you do perl -d.
  72.   # It's probably not useful to include this yourself.
  73. --- 1,10 ----
  74.   package DB;
  75.   
  76. ! # modified Perl debugger, to be run from Emacs in perldb-mode
  77. ! # Ray Lischner (uunet!mntgfx!lisch) as of 5 Nov 1990
  78. ! # Johan Vromans -- upgrade to 4.0 pl 10
  79. ! 
  80. ! $header = '$RCSfile: perldb.pl,v $$Revision: 4.0.1.2 $$Date: 91/11/05 17:55:58 $';
  81.   #
  82.   # This file is automatically included if you do perl -d.
  83.   # It's probably not useful to include this yourself.
  84. ***************
  85. *** 10,15 ****
  86. --- 14,22 ----
  87.   # have a breakpoint.  It also inserts a do 'perldb.pl' before the first line.
  88.   #
  89.   # $Log:    perldb.pl,v $
  90. + # Revision 4.0.1.2  91/11/05  17:55:58  lwall
  91. + # patch11: perldb.pl modified to run within emacs in perldb-mode
  92. + # 
  93.   # Revision 4.0.1.1  91/06/07  11:17:44  lwall
  94.   # patch4: added $^P variable to control calling of perldb routines
  95.   # patch4: debugger sometimes listed wrong number of lines for a statement
  96. ***************
  97. *** 57,64 ****
  98.   $| = 1;                # for real STDOUT
  99.   $sub = '';
  100.   
  101.   $header =~ s/.Header: ([^,]+),v(\s+\S+\s+\S+).*$/$1$2/;
  102. ! print OUT "\nLoading DB routines from $header\n\nEnter h for help.\n\n";
  103.   
  104.   sub DB {
  105.       &save;
  106. --- 64,79 ----
  107.   $| = 1;                # for real STDOUT
  108.   $sub = '';
  109.   
  110. + # Is Perl being run from Emacs?
  111. + $emacs = $main'ARGV[$[] eq '-emacs';
  112. + shift(@main'ARGV) if $emacs;
  113. + 
  114.   $header =~ s/.Header: ([^,]+),v(\s+\S+\s+\S+).*$/$1$2/;
  115. ! print OUT "\nLoading DB routines from $header\n";
  116. ! print OUT ("Emacs support ",
  117. !        $emacs ? "enabled" : "available",
  118. !        ".\n");
  119. ! print OUT "\nEnter h for help.\n\n";
  120.   
  121.   sub DB {
  122.       &save;
  123. ***************
  124. *** 78,88 ****
  125.       }
  126.       }
  127.       if ($single || $trace || $signal) {
  128. !     print OUT "$package'" unless $sub =~ /'/;
  129. !     print OUT "$sub($filename:$line):\t",$dbline[$line];
  130. !     for ($i = $line + 1; $i <= $max && $dbline[$i] == 0; ++$i) {
  131. !         last if $dbline[$i] =~ /^\s*(;|}|#|\n)/;
  132. !         print OUT "$sub($filename:$i):\t",$dbline[$i];
  133.       }
  134.       }
  135.       $evalarg = $action, &eval if $action;
  136. --- 93,107 ----
  137.       }
  138.       }
  139.       if ($single || $trace || $signal) {
  140. !     if ($emacs) {
  141. !         print OUT "\032\032$filename:$line:0\n";
  142. !     } else {
  143. !         print OUT "$package'" unless $sub =~ /'/;
  144. !         print OUT "$sub($filename:$line):\t",$dbline[$line];
  145. !         for ($i = $line + 1; $i <= $max && $dbline[$i] == 0; ++$i) {
  146. !         last if $dbline[$i] =~ /^\s*(}|#|\n)/;
  147. !         print OUT "$sub($filename:$i):\t",$dbline[$i];
  148. !         }
  149.       }
  150.       }
  151.       $evalarg = $action, &eval if $action;
  152. ***************
  153. *** 244,252 ****
  154.               $i = $2;
  155.               $i = $line if $i eq '.';
  156.               $i = 1 if $i < 1;
  157. !             for (; $i <= $end; $i++) {
  158. !             print OUT "$i:\t", $dbline[$i];
  159. !             last if $signal;
  160.               }
  161.               $start = $i;    # remember in case they want more
  162.               $start = $max if $start > $max;
  163. --- 263,276 ----
  164.               $i = $2;
  165.               $i = $line if $i eq '.';
  166.               $i = 1 if $i < 1;
  167. !             if ($emacs) {
  168. !             print OUT "\032\032$filename:$i:0\n";
  169. !             $i = $end;
  170. !             } else {
  171. !             for (; $i <= $end; $i++) {
  172. !                 print OUT "$i:\t", $dbline[$i];
  173. !                 last if $signal;
  174. !             }
  175.               }
  176.               $start = $i;    # remember in case they want more
  177.               $start = $max if $start > $max;
  178. ***************
  179. *** 393,399 ****
  180.               $start = 1 if ($start > $max);
  181.               last if ($start == $end);
  182.               if ($dbline[$start] =~ m'."\n$pat\n".'i) {
  183. !                 print OUT "$start:\t", $dbline[$start], "\n";
  184.                   last;
  185.               }
  186.               } ';
  187. --- 417,427 ----
  188.               $start = 1 if ($start > $max);
  189.               last if ($start == $end);
  190.               if ($dbline[$start] =~ m'."\n$pat\n".'i) {
  191. !                 if ($emacs) {
  192. !                 print OUT "\032\032$filename:$start:0\n";
  193. !                 } else {
  194. !                 print OUT "$start:\t", $dbline[$start], "\n";
  195. !                 }
  196.                   last;
  197.               }
  198.               } ';
  199. ***************
  200. *** 417,423 ****
  201.               $start = $max if ($start <= 0);
  202.               last if ($start == $end);
  203.               if ($dbline[$start] =~ m'."\n$pat\n".'i) {
  204. !                 print OUT "$start:\t", $dbline[$start], "\n";
  205.                   last;
  206.               }
  207.               } ';
  208. --- 445,455 ----
  209.               $start = $max if ($start <= 0);
  210.               last if ($start == $end);
  211.               if ($dbline[$start] =~ m'."\n$pat\n".'i) {
  212. !                 if ($emacs) {
  213. !                 print OUT "\032\032$filename:$start:0\n";
  214. !                 } else {
  215. !                 print OUT "$start:\t", $dbline[$start], "\n";
  216. !                 }
  217.                   last;
  218.               }
  219.               } ';
  220.  
  221. Index: perly.y
  222. *** perly.y.old    Tue Nov  5 19:27:37 1991
  223. --- perly.y    Tue Nov  5 19:27:37 1991
  224. ***************
  225. *** 1,4 ****
  226. ! /* $RCSfile: perly.y,v $$Revision: 4.0.1.1 $$Date: 91/06/07 11:42:34 $
  227.    *
  228.    *    Copyright (c) 1991, Larry Wall
  229.    *
  230. --- 1,4 ----
  231. ! /* $RCSfile: perly.y,v $$Revision: 4.0.1.2 $$Date: 91/11/05 18:17:38 $
  232.    *
  233.    *    Copyright (c) 1991, Larry Wall
  234.    *
  235. ***************
  236. *** 6,11 ****
  237. --- 6,16 ----
  238.    *    License or the Artistic License, as specified in the README file.
  239.    *
  240.    * $Log:    perly.y,v $
  241. +  * Revision 4.0.1.2  91/11/05  18:17:38  lwall
  242. +  * patch11: extra comma at end of list is now allowed in more places (Hi, Felix!)
  243. +  * patch11: once-thru blocks didn't display right in the debugger
  244. +  * patch11: debugger got confused over nested subroutine definitions
  245. +  * 
  246.    * Revision 4.0.1.1  91/06/07  11:42:34  lwall
  247.    * patch4: new copyright notice
  248.    * 
  249. ***************
  250. *** 18,23 ****
  251. --- 23,32 ----
  252.   #include "INTERN.h"
  253.   #include "perl.h"
  254.   
  255. + /*SUPPRESS 530*/
  256. + /*SUPPRESS 593*/
  257. + /*SUPPRESS 595*/
  258. + 
  259.   STAB *scrstab;
  260.   ARG *arg4;    /* rarely used arguments to make_op() */
  261.   ARG *arg5;
  262. ***************
  263. *** 36,41 ****
  264. --- 45,52 ----
  265.       FCMD *formval;
  266.   }
  267.   
  268. + %token <ival> '{' ')'
  269. + 
  270.   %token <cval> WORD
  271.   %token <ival> APPEND OPEN SSELECT LOOPEX
  272.   %token <ival> USING FORMAT DO SHIFT PUSH POP LVALFUN
  273. ***************
  274. *** 49,55 ****
  275.   %token <arg> SUBST PATTERN
  276.   %token <arg> RSTRING TRANS
  277.   
  278. ! %type <ival> prog decl format remember
  279.   %type <cmdval> block lineseq line loop cond sideff nexpr else
  280.   %type <arg> expr sexpr cexpr csexpr term handle aryword hshword
  281.   %type <arg> texpr listop bareword
  282. --- 60,66 ----
  283.   %token <arg> SUBST PATTERN
  284.   %token <arg> RSTRING TRANS
  285.   
  286. ! %type <ival> prog decl format remember crp
  287.   %type <cmdval> block lineseq line loop cond sideff nexpr else
  288.   %type <arg> expr sexpr cexpr csexpr term handle aryword hshword
  289.   %type <arg> texpr listop bareword
  290. ***************
  291. *** 110,115 ****
  292. --- 121,128 ----
  293.   
  294.   block    :    '{' remember lineseq '}'
  295.               { $$ = block_head($3);
  296. +               if (cmdline > $1)
  297. +                   cmdline = $1;
  298.                 if (savestack->ary_fill > $2)
  299.                   restorelist($2); }
  300.       ;
  301. ***************
  302. *** 190,196 ****
  303.               { cmdline = $2;
  304.                   $$ = wopt(add_label($1,
  305.                   invert(make_ccmd(C_WHILE, cmd_to_arg($3),$4)) )); }
  306. !     |    label FOR REG '(' expr ')' compblock
  307.               { cmdline = $2;
  308.                   /*
  309.                    * The following gobbledygook catches EXPRs that
  310. --- 203,209 ----
  311.               { cmdline = $2;
  312.                   $$ = wopt(add_label($1,
  313.                   invert(make_ccmd(C_WHILE, cmd_to_arg($3),$4)) )); }
  314. !     |    label FOR REG '(' expr crp compblock
  315.               { cmdline = $2;
  316.                   /*
  317.                    * The following gobbledygook catches EXPRs that
  318. ***************
  319. *** 229,235 ****
  320.                   make_ccmd(C_WHILE,$5,$7) )));
  321.                   }
  322.               }
  323. !     |    label FOR '(' expr ')' compblock
  324.               { cmdline = $2;
  325.                   if ($4->arg_type != O_ARRAY) {
  326.                   scrstab = aadd(genstab());
  327. --- 242,248 ----
  328.                   make_ccmd(C_WHILE,$5,$7) )));
  329.                   }
  330.               }
  331. !     |    label FOR '(' expr crp compblock
  332.               { cmdline = $2;
  333.                   if ($4->arg_type != O_ARRAY) {
  334.                   scrstab = aadd(genstab());
  335. ***************
  336. *** 303,309 ****
  337.       ;
  338.   
  339.   subrout    :    SUB WORD block
  340. !             { make_sub($2,$3); }
  341.       ;
  342.   
  343.   package :    PACKAGE WORD ';'
  344. --- 316,325 ----
  345.       ;
  346.   
  347.   subrout    :    SUB WORD block
  348. !             { make_sub($2,$3);
  349. !               cmdline = NOLINE;
  350. !               if (savestack->ary_fill > $1)
  351. !                 restorelist($1); }
  352.       ;
  353.   
  354.   package :    PACKAGE WORD ';'
  355. ***************
  356. *** 443,456 ****
  357.                   stab2arg(A_STAB,
  358.                     $1 == O_FTTTY?stabent("STDIN",TRUE):defstab),
  359.                   Nullarg, Nullarg); }
  360. !     |    LOCAL '(' expr ')'
  361.               { $$ = l(localize(make_op(O_ASSIGN, 1,
  362.                   localize(listish(make_list($3))),
  363.                   Nullarg,Nullarg))); }
  364. !     |    '(' expr ',' ')'
  365.               { $$ = make_list($2); }
  366. -     |    '(' expr ')'
  367. -             { $$ = make_list($2); }
  368.       |    '(' ')'
  369.               { $$ = make_list(Nullarg); }
  370.       |    DO sexpr    %prec FILETEST
  371. --- 459,470 ----
  372.                   stab2arg(A_STAB,
  373.                     $1 == O_FTTTY?stabent("STDIN",TRUE):defstab),
  374.                   Nullarg, Nullarg); }
  375. !     |    LOCAL '(' expr crp
  376.               { $$ = l(localize(make_op(O_ASSIGN, 1,
  377.                   localize(listish(make_list($3))),
  378.                   Nullarg,Nullarg))); }
  379. !     |    '(' expr crp
  380.               { $$ = make_list($2); }
  381.       |    '(' ')'
  382.               { $$ = make_list(Nullarg); }
  383.       |    DO sexpr    %prec FILETEST
  384. ***************
  385. *** 478,484 ****
  386.                   stab2arg(A_STAB,hadd($1)),
  387.                   jmaybe($3),
  388.                   Nullarg); }
  389. !     |    '(' expr ')' '[' expr ']'    %prec '('
  390.               { $$ = make_op(O_LSLICE, 3,
  391.                   Nullarg,
  392.                   listish(make_list($5)),
  393. --- 492,498 ----
  394.                   stab2arg(A_STAB,hadd($1)),
  395.                   jmaybe($3),
  396.                   Nullarg); }
  397. !     |    '(' expr crp '[' expr ']'    %prec '('
  398.               { $$ = make_op(O_LSLICE, 3,
  399.                   Nullarg,
  400.                   listish(make_list($5)),
  401. ***************
  402. *** 513,552 ****
  403.               { $$ = $1; }
  404.       |    TRANS    %prec '('
  405.               { $$ = $1; }
  406. !     |    DO WORD '(' expr ')'
  407.               { $$ = make_op((perldb ? O_DBSUBR : O_SUBR), 2,
  408. !                 stab2arg(A_WORD,stabent($2,TRUE)),
  409.                   make_list($4),
  410.                   Nullarg); Safefree($2); $2 = Nullch;
  411.                   $$->arg_flags |= AF_DEPR; }
  412. !     |    AMPER WORD '(' expr ')'
  413.               { $$ = make_op((perldb ? O_DBSUBR : O_SUBR), 2,
  414. !                 stab2arg(A_WORD,stabent($2,TRUE)),
  415.                   make_list($4),
  416.                   Nullarg); Safefree($2); $2 = Nullch; }
  417.       |    DO WORD '(' ')'
  418.               { $$ = make_op((perldb ? O_DBSUBR : O_SUBR), 2,
  419. !                 stab2arg(A_WORD,stabent($2,TRUE)),
  420.                   make_list(Nullarg),
  421.                   Nullarg);
  422.                   $$->arg_flags |= AF_DEPR; }
  423.       |    AMPER WORD '(' ')'
  424.               { $$ = make_op((perldb ? O_DBSUBR : O_SUBR), 2,
  425. !                 stab2arg(A_WORD,stabent($2,TRUE)),
  426.                   make_list(Nullarg),
  427.                   Nullarg); }
  428.       |    AMPER WORD
  429.               { $$ = make_op((perldb ? O_DBSUBR : O_SUBR), 2,
  430. !                 stab2arg(A_WORD,stabent($2,TRUE)),
  431.                   Nullarg,
  432.                   Nullarg); }
  433. !     |    DO REG '(' expr ')'
  434.               { $$ = make_op((perldb ? O_DBSUBR : O_SUBR), 2,
  435.                   stab2arg(A_STAB,$2),
  436.                   make_list($4),
  437.                   Nullarg);
  438.                   $$->arg_flags |= AF_DEPR; }
  439. !     |    AMPER REG '(' expr ')'
  440.               { $$ = make_op((perldb ? O_DBSUBR : O_SUBR), 2,
  441.                   stab2arg(A_STAB,$2),
  442.                   make_list($4),
  443. --- 527,566 ----
  444.               { $$ = $1; }
  445.       |    TRANS    %prec '('
  446.               { $$ = $1; }
  447. !     |    DO WORD '(' expr crp
  448.               { $$ = make_op((perldb ? O_DBSUBR : O_SUBR), 2,
  449. !                 stab2arg(A_WORD,stabent($2,MULTI)),
  450.                   make_list($4),
  451.                   Nullarg); Safefree($2); $2 = Nullch;
  452.                   $$->arg_flags |= AF_DEPR; }
  453. !     |    AMPER WORD '(' expr crp
  454.               { $$ = make_op((perldb ? O_DBSUBR : O_SUBR), 2,
  455. !                 stab2arg(A_WORD,stabent($2,MULTI)),
  456.                   make_list($4),
  457.                   Nullarg); Safefree($2); $2 = Nullch; }
  458.       |    DO WORD '(' ')'
  459.               { $$ = make_op((perldb ? O_DBSUBR : O_SUBR), 2,
  460. !                 stab2arg(A_WORD,stabent($2,MULTI)),
  461.                   make_list(Nullarg),
  462.                   Nullarg);
  463.                   $$->arg_flags |= AF_DEPR; }
  464.       |    AMPER WORD '(' ')'
  465.               { $$ = make_op((perldb ? O_DBSUBR : O_SUBR), 2,
  466. !                 stab2arg(A_WORD,stabent($2,MULTI)),
  467.                   make_list(Nullarg),
  468.                   Nullarg); }
  469.       |    AMPER WORD
  470.               { $$ = make_op((perldb ? O_DBSUBR : O_SUBR), 2,
  471. !                 stab2arg(A_WORD,stabent($2,MULTI)),
  472.                   Nullarg,
  473.                   Nullarg); }
  474. !     |    DO REG '(' expr crp
  475.               { $$ = make_op((perldb ? O_DBSUBR : O_SUBR), 2,
  476.                   stab2arg(A_STAB,$2),
  477.                   make_list($4),
  478.                   Nullarg);
  479.                   $$->arg_flags |= AF_DEPR; }
  480. !     |    AMPER REG '(' expr crp
  481.               { $$ = make_op((perldb ? O_DBSUBR : O_SUBR), 2,
  482.                   stab2arg(A_STAB,$2),
  483.                   make_list($4),
  484. ***************
  485. *** 574,583 ****
  486. --- 588,605 ----
  487.                   Nullarg,Nullarg); }
  488.       |    UNIOP
  489.               { $$ = make_op($1,0,Nullarg,Nullarg,Nullarg); }
  490. +     |    UNIOP block
  491. +             { $$ = make_op($1,1,cmd_to_arg($2),Nullarg,Nullarg); }
  492.       |    UNIOP sexpr
  493.               { $$ = make_op($1,1,$2,Nullarg,Nullarg); }
  494.       |    SSELECT
  495.               { $$ = make_op(O_SELECT, 0, Nullarg, Nullarg, Nullarg);}
  496. +     |    SSELECT  WORD
  497. +             { $$ = make_op(O_SELECT, 1,
  498. +                 stab2arg(A_WORD,stabent($2,TRUE)),
  499. +                 Nullarg,
  500. +                 Nullarg);
  501. +                 Safefree($2); $2 = Nullch; }
  502.       |    SSELECT '(' handle ')'
  503.               { $$ = make_op(O_SELECT, 1, $3, Nullarg, Nullarg); }
  504.       |    SSELECT '(' sexpr csexpr csexpr csexpr ')'
  505. ***************
  506. *** 628,637 ****
  507.       |    FILOP25 '(' handle ',' handle csexpr csexpr cexpr ')'
  508.               { arg4 = $7; arg5 = $8;
  509.                 $$ = make_op($1, 5, $3, $5, $6); }
  510. !     |    PUSH '(' aryword cexpr ')'
  511.               { $$ = make_op($1, 2,
  512.                   $3,
  513. !                 make_list($4),
  514.                   Nullarg); }
  515.       |    POP aryword    %prec '('
  516.               { $$ = make_op(O_POP, 1, $2, Nullarg, Nullarg); }
  517. --- 650,659 ----
  518.       |    FILOP25 '(' handle ',' handle csexpr csexpr cexpr ')'
  519.               { arg4 = $7; arg5 = $8;
  520.                 $$ = make_op($1, 5, $3, $5, $6); }
  521. !     |    PUSH '(' aryword ',' expr crp
  522.               { $$ = make_op($1, 2,
  523.                   $3,
  524. !                 make_list($5),
  525.                   Nullarg); }
  526.       |    POP aryword    %prec '('
  527.               { $$ = make_op(O_POP, 1, $2, Nullarg, Nullarg); }
  528. ***************
  529. *** 671,677 ****
  530.                   $3,
  531.                   listish(make_list($4)),
  532.                   Nullarg); }
  533. !     |    FLIST '(' expr ')'
  534.               { $$ = make_op($1, 1,
  535.                   make_list($3),
  536.                   Nullarg,
  537. --- 693,699 ----
  538.                   $3,
  539.                   listish(make_list($4)),
  540.                   Nullarg); }
  541. !     |    FLIST '(' expr crp
  542.               { $$ = make_op($1, 1,
  543.                   make_list($3),
  544.                   Nullarg,
  545. ***************
  546. *** 752,757 ****
  547. --- 774,784 ----
  548.                   stab2arg(A_STAB,$2),
  549.                   maybelistish($1,make_list($3)),
  550.                   Nullarg); }
  551. +     |    LISTOP block expr
  552. +             { $$ = make_op($1,2,
  553. +                 cmd_to_arg($2),
  554. +                 maybelistish($1,make_list($3)),
  555. +                 Nullarg); }
  556.       ;
  557.   
  558.   handle    :    WORD
  559. ***************
  560. *** 774,779 ****
  561. --- 801,812 ----
  562.               { $$ = stab2arg(A_STAB,$1); }
  563.       ;
  564.   
  565. + crp    :    ',' ')'
  566. +             { $$ = 1; }
  567. +     |    ')'
  568. +             { $$ = 0; }
  569. +     ;
  570. + 
  571.   /*
  572.    * NOTE:  The following entry must stay at the end of the file so that
  573.    * reduce/reduce conflicts resolve to it only if it's the only option.
  574. ***************
  575. *** 785,791 ****
  576.                   $$->arg_type = O_ITEM;
  577.                   $$[1].arg_type = A_SINGLE;
  578.                   $$[1].arg_ptr.arg_str = str_make($1,0);
  579. !                 for (s = $1; *s && islower(*s); s++) ;
  580.                   if (dowarn && !*s)
  581.                   warn(
  582.                     "\"%s\" may clash with future reserved word",
  583. --- 818,824 ----
  584.                   $$->arg_type = O_ITEM;
  585.                   $$[1].arg_type = A_SINGLE;
  586.                   $$[1].arg_ptr.arg_str = str_make($1,0);
  587. !                 for (s = $1; *s && isLOWER(*s); s++) ;
  588.                   if (dowarn && !*s)
  589.                   warn(
  590.                     "\"%s\" may clash with future reserved word",
  591.  
  592. Index: regcomp.c
  593. *** regcomp.c.old    Tue Nov  5 19:27:40 1991
  594. --- regcomp.c    Tue Nov  5 19:27:41 1991
  595. ***************
  596. *** 7,15 ****
  597.    * blame Henry for some of the lack of readability.
  598.    */
  599.   
  600. ! /* $RCSfile: regcomp.c,v $$Revision: 4.0.1.2 $$Date: 91/06/07 11:48:24 $
  601.    *
  602.    * $Log:    regcomp.c,v $
  603.    * Revision 4.0.1.2  91/06/07  11:48:24  lwall
  604.    * patch4: new copyright notice
  605.    * patch4: /(x+) \1/ incorrectly optimized to not match "xxx xx"
  606. --- 7,21 ----
  607.    * blame Henry for some of the lack of readability.
  608.    */
  609.   
  610. ! /* $RCSfile: regcomp.c,v $$Revision: 4.0.1.3 $$Date: 91/11/05 18:22:28 $
  611.    *
  612.    * $Log:    regcomp.c,v $
  613. +  * Revision 4.0.1.3  91/11/05  18:22:28  lwall
  614. +  * patch11: minimum match length calculation in regexp is now cumulative
  615. +  * patch11: initial .* in pattern had dependency on value of $*
  616. +  * patch11: certain patterns made use of garbage pointers from uncleared memory
  617. +  * patch11: prepared for ctype implementations that don't define isascii()
  618. +  * 
  619.    * Revision 4.0.1.2  91/06/07  11:48:24  lwall
  620.    * patch4: new copyright notice
  621.    * patch4: /(x+) \1/ incorrectly optimized to not match "xxx xx"
  622. ***************
  623. *** 22,28 ****
  624.    * 4.0 baseline.
  625.    * 
  626.    */
  627. ! 
  628.   /*
  629.    * regcomp and regexec -- regsub and regerror are not used in perl
  630.    *
  631. --- 28,34 ----
  632.    * 4.0 baseline.
  633.    * 
  634.    */
  635. ! /*SUPPRESS 112*/
  636.   /*
  637.    * regcomp and regexec -- regsub and regerror are not used in perl
  638.    *
  639. ***************
  640. *** 150,155 ****
  641. --- 156,162 ----
  642.       int backish;
  643.       int backest;
  644.       int curback;
  645. +     int minlen;
  646.       extern char *safemalloc();
  647.       extern char *savestr();
  648.       int sawplus = 0;
  649. ***************
  650. *** 168,174 ****
  651.       regnpar = 1;
  652.       regsize = 0L;
  653.       regcode = ®dummy;
  654. !     regc(MAGIC);
  655.       if (reg(0, &flags) == NULL) {
  656.           Safefree(regprecomp);
  657.           regprecomp = Nullch;
  658. --- 175,181 ----
  659.       regnpar = 1;
  660.       regsize = 0L;
  661.       regcode = ®dummy;
  662. !     regc((char)MAGIC);
  663.       if (reg(0, &flags) == NULL) {
  664.           Safefree(regprecomp);
  665.           regprecomp = Nullch;
  666. ***************
  667. *** 193,199 ****
  668.       regparse = exp;
  669.       regnpar = 1;
  670.       regcode = r->program;
  671. !     regc(MAGIC);
  672.       if (reg(0, &flags) == NULL)
  673.           return(NULL);
  674.   
  675. --- 200,206 ----
  676.       regparse = exp;
  677.       regnpar = 1;
  678.       regcode = r->program;
  679. !     regc((char)MAGIC);
  680.       if (reg(0, &flags) == NULL)
  681.           return(NULL);
  682.   
  683. ***************
  684. *** 233,239 ****
  685.               r->regstclass = first;
  686.           else if (OP(first) == BOL ||
  687.               (OP(first) == STAR && OP(NEXTOPER(first)) == ANY) ) {
  688. !             r->reganch = ROPT_ANCH;    /* kinda turn .* into ^.* */
  689.               first = NEXTOPER(first);
  690.                   goto again;
  691.           }
  692. --- 240,247 ----
  693.               r->regstclass = first;
  694.           else if (OP(first) == BOL ||
  695.               (OP(first) == STAR && OP(NEXTOPER(first)) == ANY) ) {
  696. !             /* kinda turn .* into ^.* */
  697. !             r->reganch = ROPT_ANCH | ROPT_IMPLICIT;
  698.               first = NEXTOPER(first);
  699.                   goto again;
  700.           }
  701. ***************
  702. *** 259,264 ****
  703. --- 267,273 ----
  704.           longish = str_make("",0);
  705.           longest = str_make("",0);
  706.           len = 0;
  707. +         minlen = 0;
  708.           curback = 0;
  709.           backish = 0;
  710.           backest = 0;
  711. ***************
  712. *** 278,283 ****
  713. --- 287,293 ----
  714.                   first = scan;
  715.                   while (OP(t = regnext(scan)) == CLOSE)
  716.                   scan = t;
  717. +                 minlen += *OPERAND(first);
  718.                   if (curback - backish == len) {
  719.                   str_ncat(longish, OPERAND(first)+1,
  720.                       *OPERAND(first));
  721. ***************
  722. *** 303,311 ****
  723. --- 313,328 ----
  724.                   backest = backish;
  725.                   }
  726.                   str_nset(longish,"",0);
  727. +                 if (OP(scan) == PLUS &&
  728. +                   index(simple,OP(NEXTOPER(scan))))
  729. +                 minlen++;
  730. +                 else if (OP(scan) == CURLY &&
  731. +                   index(simple,OP(NEXTOPER(scan)+4)))
  732. +                 minlen += ARG1(scan);
  733.               }
  734.               else if (index(simple,OP(scan))) {
  735.                   curback++;
  736. +                 minlen++;
  737.                   len = 0;
  738.                   if (longish->str_cur > longest->str_cur) {
  739.                   str_sset(longest,longish);
  740. ***************
  741. *** 328,335 ****
  742.               &&
  743.               (!r->regstart
  744.                ||
  745. !              !fbminstr(r->regstart->str_ptr,
  746. !               r->regstart->str_ptr + r->regstart->str_cur,
  747.                 longest)
  748.               )
  749.              )
  750. --- 345,353 ----
  751.               &&
  752.               (!r->regstart
  753.                ||
  754. !              !fbminstr((unsigned char*) r->regstart->str_ptr,
  755. !               (unsigned char *) r->regstart->str_ptr
  756. !                 + r->regstart->str_cur,
  757.                 longest)
  758.               )
  759.              )
  760. ***************
  761. *** 354,361 ****
  762.   
  763.       r->do_folding = fold;
  764.       r->nparens = regnpar - 1;
  765. !     New(1002, r->startp, regnpar, char*);
  766. !     New(1002, r->endp, regnpar, char*);
  767.   #ifdef DEBUGGING
  768.       if (debug & 512)
  769.           regdump(r);
  770. --- 372,380 ----
  771.   
  772.       r->do_folding = fold;
  773.       r->nparens = regnpar - 1;
  774. !     r->minlen = minlen;
  775. !     Newz(1002, r->startp, regnpar, char*);
  776. !     Newz(1002, r->endp, regnpar, char*);
  777.   #ifdef DEBUGGING
  778.       if (debug & 512)
  779.           regdump(r);
  780. ***************
  781. *** 515,521 ****
  782.       if (op == '{' && regcurly(regparse)) {
  783.           next = regparse + 1;
  784.           max = Nullch;
  785. !         while (isdigit(*next) || *next == ',') {
  786.           if (*next == ',') {
  787.               if (max)
  788.               break;
  789. --- 534,540 ----
  790.       if (op == '{' && regcurly(regparse)) {
  791.           next = regparse + 1;
  792.           max = Nullch;
  793. !         while (isDIGIT(*next) || *next == ',') {
  794.           if (*next == ',') {
  795.               if (max)
  796.               break;
  797. ***************
  798. *** 758,764 ****
  799.                   else {
  800.                   regsawback = 1;
  801.                   ret = reganode(REF, num);
  802. !                 while (isascii(*regparse) && isdigit(*regparse))
  803.                       regparse++;
  804.                   *flagp |= SIMPLE;
  805.                   }
  806. --- 777,783 ----
  807.                   else {
  808.                   regsawback = 1;
  809.                   ret = reganode(REF, num);
  810. !                 while (isDIGIT(*regparse))
  811.                       regparse++;
  812.                   *flagp |= SIMPLE;
  813.                   }
  814. ***************
  815. *** 839,845 ****
  816.                   case 'c':
  817.                       p++;
  818.                       ender = *p++;
  819. !                     if (islower(ender))
  820.                       ender = toupper(ender);
  821.                       ender ^= 64;
  822.                       break;
  823. --- 858,864 ----
  824.                   case 'c':
  825.                       p++;
  826.                       ender = *p++;
  827. !                     if (isLOWER(ender))
  828.                       ender = toupper(ender);
  829.                       ender ^= 64;
  830.                       break;
  831. ***************
  832. *** 846,852 ****
  833.                   case '0': case '1': case '2': case '3':case '4':
  834.                   case '5': case '6': case '7': case '8':case '9':
  835.                       if (*p == '0' ||
  836. !                       (isdigit(p[1]) && atoi(p) >= regnpar) ) {
  837.                       ender = scanoct(p, 3, &numlen);
  838.                       p += numlen;
  839.                       }
  840. --- 865,871 ----
  841.                   case '0': case '1': case '2': case '3':case '4':
  842.                   case '5': case '6': case '7': case '8':case '9':
  843.                       if (*p == '0' ||
  844. !                       (isDIGIT(p[1]) && atoi(p) >= regnpar) ) {
  845.                       ender = scanoct(p, 3, &numlen);
  846.                       p += numlen;
  847.                       }
  848. ***************
  849. *** 868,874 ****
  850.                   ender = *p++;
  851.                   break;
  852.                   }
  853. !                 if (regfold && isupper(ender))
  854.                       ender = tolower(ender);
  855.                   if (ISMULT2(p)) { /* Back off on ?+*. */
  856.                   if (len)
  857. --- 887,893 ----
  858.                   ender = *p++;
  859.                   break;
  860.                   }
  861. !                 if (regfold && isUPPER(ender))
  862.                       ender = tolower(ender);
  863.                   if (ISMULT2(p)) { /* Back off on ?+*. */
  864.                   if (len)
  865. ***************
  866. *** 992,998 ****
  867.                   break;
  868.               case 'c':
  869.                   class = *regparse++;
  870. !                 if (islower(class))
  871.                       class = toupper(class);
  872.                   class ^= 64;
  873.                   break;
  874. --- 1011,1017 ----
  875.                   break;
  876.               case 'c':
  877.                   class = *regparse++;
  878. !                 if (isLOWER(class))
  879.                       class = toupper(class);
  880.                   class ^= 64;
  881.                   break;
  882. ***************
  883. *** 1019,1025 ****
  884.           }
  885.           for ( ; lastclass <= class; lastclass++) {
  886.               regset(bits,def,lastclass);
  887. !             if (regfold && isupper(lastclass))
  888.                   regset(bits,def,tolower(lastclass));
  889.           }
  890.           lastclass = class;
  891. --- 1038,1044 ----
  892.           }
  893.           for ( ; lastclass <= class; lastclass++) {
  894.               regset(bits,def,lastclass);
  895. !             if (regfold && isUPPER(lastclass))
  896.                   regset(bits,def,tolower(lastclass));
  897.           }
  898.           lastclass = class;
  899. ***************
  900. *** 1226,1238 ****
  901.   {
  902.       if (*s++ != '{')
  903.       return FALSE;
  904. !     if (!isdigit(*s))
  905.       return FALSE;
  906. !     while (isdigit(*s))
  907.       s++;
  908.       if (*s == ',')
  909.       s++;
  910. !     while (isdigit(*s))
  911.       s++;
  912.       if (*s != '}')
  913.       return FALSE;
  914. --- 1245,1257 ----
  915.   {
  916.       if (*s++ != '{')
  917.       return FALSE;
  918. !     if (!isDIGIT(*s))
  919.       return FALSE;
  920. !     while (isDIGIT(*s))
  921.       s++;
  922.       if (*s == ',')
  923.       s++;
  924. !     while (isDIGIT(*s))
  925.       s++;
  926.       if (*s != '}')
  927.       return FALSE;
  928. ***************
  929. *** 1292,1300 ****
  930. --- 1311,1322 ----
  931.           fprintf(stderr,"anchored ");
  932.       if (r->reganch & ROPT_SKIP)
  933.           fprintf(stderr,"plus ");
  934. +     if (r->reganch & ROPT_IMPLICIT)
  935. +         fprintf(stderr,"implicit ");
  936.       if (r->regmust != NULL)
  937.           fprintf(stderr,"must have \"%s\" back %d ", r->regmust->str_ptr,
  938.             r->regback);
  939. +     fprintf(stderr, "minlen %d ", r->minlen);
  940.       fprintf(stderr,"\n");
  941.   }
  942.   
  943.  
  944. Index: regexec.c
  945. *** regexec.c.old    Tue Nov  5 19:27:44 1991
  946. --- regexec.c    Tue Nov  5 19:27:44 1991
  947. ***************
  948. *** 7,15 ****
  949.    * blame Henry for some of the lack of readability.
  950.    */
  951.   
  952. ! /* $RCSfile: regexec.c,v $$Revision: 4.0.1.2 $$Date: 91/06/07 11:50:33 $
  953.    *
  954.    * $Log:    regexec.c,v $
  955.    * Revision 4.0.1.2  91/06/07  11:50:33  lwall
  956.    * patch4: new copyright notice
  957.    * patch4: // wouldn't use previous pattern if it started with a null character
  958. --- 7,19 ----
  959.    * blame Henry for some of the lack of readability.
  960.    */
  961.   
  962. ! /* $RCSfile: regexec.c,v $$Revision: 4.0.1.3 $$Date: 91/11/05 18:23:55 $
  963.    *
  964.    * $Log:    regexec.c,v $
  965. +  * Revision 4.0.1.3  91/11/05  18:23:55  lwall
  966. +  * patch11: prepared for ctype implementations that don't define isascii()
  967. +  * patch11: initial .* in pattern had dependency on value of $*
  968. +  * 
  969.    * Revision 4.0.1.2  91/06/07  11:50:33  lwall
  970.    * patch4: new copyright notice
  971.    * patch4: // wouldn't use previous pattern if it started with a null character
  972. ***************
  973. *** 21,27 ****
  974.    * 4.0 baseline.
  975.    * 
  976.    */
  977. ! 
  978.   /*
  979.    * regcomp and regexec -- regsub and regerror are not used in perl
  980.    *
  981. --- 25,31 ----
  982.    * 4.0 baseline.
  983.    * 
  984.    */
  985. ! /*SUPPRESS 112*/
  986.   /*
  987.    * regcomp and regexec -- regsub and regerror are not used in perl
  988.    *
  989. ***************
  990. *** 65,75 ****
  991.   int regnarrate = 0;
  992.   #endif
  993.   
  994. - #define isALNUM(c) (isascii(c) && (isalpha(c) || isdigit(c) || c == '_'))
  995. - #define isSPACE(c) (isascii(c) && isspace(c))
  996. - #define isDIGIT(c) (isascii(c) && isdigit(c))
  997. - #define isUPPER(c) (isascii(c) && isupper(c))
  998. - 
  999.   /*
  1000.    * regexec and friends
  1001.    */
  1002. --- 69,74 ----
  1003. ***************
  1004. *** 221,227 ****
  1005.       if (prog->reganch & ROPT_ANCH) {
  1006.           if (regtry(prog, string))
  1007.               goto got_it;
  1008. !         else if (multiline) {
  1009.               if (minlen)
  1010.                   dontbother = minlen - 1;
  1011.               strend -= dontbother;
  1012. --- 220,226 ----
  1013.       if (prog->reganch & ROPT_ANCH) {
  1014.           if (regtry(prog, string))
  1015.               goto got_it;
  1016. !         else if (multiline || (prog->reganch & ROPT_IMPLICIT)) {
  1017.               if (minlen)
  1018.                   dontbother = minlen - 1;
  1019.               strend -= dontbother;
  1020. ***************
  1021. *** 279,284 ****
  1022. --- 278,284 ----
  1023.           }
  1024.           goto phooey;
  1025.       }
  1026. +     /*SUPPRESS 560*/
  1027.       if (c = prog->regstclass) {
  1028.           int doevery = (prog->reganch & ROPT_SKIP) == 0;
  1029.   
  1030. ***************
  1031. *** 721,726 ****
  1032. --- 721,727 ----
  1033.                           if (regmatch(NEXTOPER(scan)))
  1034.                               return(1);
  1035.   #ifdef REGALIGN
  1036. +                         /*SUPPRESS 560*/
  1037.                           if (n = NEXT(scan))
  1038.                               scan += n;
  1039.                           else
  1040.  
  1041. Index: stab.c
  1042. *** stab.c.old    Tue Nov  5 19:27:48 1991
  1043. --- stab.c    Tue Nov  5 19:27:49 1991
  1044. ***************
  1045. *** 1,4 ****
  1046. ! /* $RCSfile: stab.c,v $$Revision: 4.0.1.2 $$Date: 91/06/07 11:55:53 $
  1047.    *
  1048.    *    Copyright (c) 1991, Larry Wall
  1049.    *
  1050. --- 1,4 ----
  1051. ! /* $RCSfile: stab.c,v $$Revision: 4.0.1.3 $$Date: 91/11/05 18:35:33 $
  1052.    *
  1053.    *    Copyright (c) 1991, Larry Wall
  1054.    *
  1055. ***************
  1056. *** 6,11 ****
  1057. --- 6,18 ----
  1058.    *    License or the Artistic License, as specified in the README file.
  1059.    *
  1060.    * $Log:    stab.c,v $
  1061. +  * Revision 4.0.1.3  91/11/05  18:35:33  lwall
  1062. +  * patch11: length($x) was sometimes wrong for numeric $x
  1063. +  * patch11: perl now issues warning if $SIG{'ALARM'} is referenced
  1064. +  * patch11: *foo = undef coredumped
  1065. +  * patch11: solitary subroutine references no longer trigger typo warnings
  1066. +  * patch11: local(*FILEHANDLE) had a memory leak
  1067. +  * 
  1068.    * Revision 4.0.1.2  91/06/07  11:55:53  lwall
  1069.    * patch4: new copyright notice
  1070.    * patch4: added $^P variable to control calling of perldb routines
  1071. ***************
  1072. *** 247,253 ****
  1073.       char *s;
  1074.   
  1075.       if (str->str_rare)
  1076. !     return stab_val(stab)->str_cur;
  1077.   
  1078.       switch (*stab->str_magic->str_ptr) {
  1079.       case '1': case '2': case '3': case '4':
  1080. --- 254,260 ----
  1081.       char *s;
  1082.   
  1083.       if (str->str_rare)
  1084. !     return str_len(stab_val(stab));
  1085.   
  1086.       switch (*stab->str_magic->str_ptr) {
  1087.       case '1': case '2': case '3': case '4':
  1088. ***************
  1089. *** 303,309 ****
  1090.       case '\\':
  1091.       return (STRLEN)orslen;
  1092.       default:
  1093. !     return stab_str(str)->str_cur;
  1094.       }
  1095.   }
  1096.   
  1097. --- 310,316 ----
  1098.       case '\\':
  1099.       return (STRLEN)orslen;
  1100.       default:
  1101. !     return str_len(stab_str(str));
  1102.       }
  1103.   }
  1104.   
  1105. ***************
  1106. *** 311,317 ****
  1107.   register STR *mstr;
  1108.   STR *str;
  1109.   {
  1110. !     STAB *stab = mstr->str_u.str_stab;
  1111.       register char *s;
  1112.       int i;
  1113.   
  1114. --- 318,324 ----
  1115.   register STR *mstr;
  1116.   STR *str;
  1117.   {
  1118. !     STAB *stab;
  1119.       register char *s;
  1120.       int i;
  1121.   
  1122. ***************
  1123. *** 338,343 ****
  1124. --- 345,352 ----
  1125.       case 'S':
  1126.       s = str_get(str);
  1127.       i = whichsig(mstr->str_ptr);    /* ...no, a brick */
  1128. +     if (!i && (dowarn || strEQ(mstr->str_ptr,"ALARM")))
  1129. +         warn("No such signal: SIG%s", mstr->str_ptr);
  1130.       if (strEQ(s,"IGNORE"))
  1131.   #ifndef lint
  1132.           (void)signal(i,SIG_IGN);
  1133. ***************
  1134. *** 356,361 ****
  1135. --- 365,371 ----
  1136.       break;
  1137.   #ifdef SOME_DBM
  1138.       case 'D':
  1139. +     stab = mstr->str_u.str_stab;
  1140.       hdbmstore(stab_hash(stab),mstr->str_ptr,mstr->str_cur,str);
  1141.       break;
  1142.   #endif
  1143. ***************
  1144. *** 363,368 ****
  1145. --- 373,379 ----
  1146.       {
  1147.           CMD *cmd;
  1148.   
  1149. +         stab = mstr->str_u.str_stab;
  1150.           i = str_true(str);
  1151.           str = afetch(stab_xarray(stab),atoi(mstr->str_ptr), FALSE);
  1152.           cmd = str->str_magic->str_u.str_cmd;
  1153. ***************
  1154. *** 371,386 ****
  1155.       }
  1156.       break;
  1157.       case '#':
  1158.       afill(stab_array(stab), (int)str_gnum(str) - arybase);
  1159.       break;
  1160.       case 'X':    /* merely a copy of a * string */
  1161.       break;
  1162.       case '*':
  1163. !     s = str_get(str);
  1164.       if (strNE(s,"StB") || str->str_cur != sizeof(STBP)) {
  1165.           if (!*s) {
  1166.           STBP *stbp;
  1167.   
  1168.           (void)savenostab(stab);    /* schedule a free of this stab */
  1169.           if (stab->str_len)
  1170.               Safefree(stab->str_ptr);
  1171. --- 382,400 ----
  1172.       }
  1173.       break;
  1174.       case '#':
  1175. +     stab = mstr->str_u.str_stab;
  1176.       afill(stab_array(stab), (int)str_gnum(str) - arybase);
  1177.       break;
  1178.       case 'X':    /* merely a copy of a * string */
  1179.       break;
  1180.       case '*':
  1181. !     s = str->str_pok ? str_get(str) : "";
  1182.       if (strNE(s,"StB") || str->str_cur != sizeof(STBP)) {
  1183. +         stab = mstr->str_u.str_stab;
  1184.           if (!*s) {
  1185.           STBP *stbp;
  1186.   
  1187. +         /*SUPPRESS 701*/
  1188.           (void)savenostab(stab);    /* schedule a free of this stab */
  1189.           if (stab->str_len)
  1190.               Safefree(stab->str_ptr);
  1191. ***************
  1192. *** 402,408 ****
  1193.           if (!stab_io(stab))
  1194.               stab_io(stab) = stio_new();
  1195.           }
  1196. !         str_sset(str,stab);
  1197.       }
  1198.       break;
  1199.       case 's': {
  1200. --- 416,422 ----
  1201.           if (!stab_io(stab))
  1202.               stab_io(stab) = stio_new();
  1203.           }
  1204. !         str_sset(str, (STR*) stab);
  1205.       }
  1206.       break;
  1207.       case 's': {
  1208. ***************
  1209. *** 422,427 ****
  1210. --- 436,444 ----
  1211.       break;
  1212.   
  1213.       case 0:
  1214. +     /*SUPPRESS 560*/
  1215. +     if (!(stab = mstr->str_u.str_stab))
  1216. +         break;
  1217.       switch (*stab->str_magic->str_ptr) {
  1218.       case '\004':    /* ^D */
  1219.   #ifdef DEBUGGING
  1220. ***************
  1221. *** 711,716 ****
  1222. --- 728,734 ----
  1223.           sig_name[sig], stab_name(stab) );
  1224.       return;
  1225.       }
  1226. +     /*SUPPRESS 701*/
  1227.       saveaptr(&stack);
  1228.       str = Str_new(15, sizeof(CSV));
  1229.       str->str_state = SS_SCSV;
  1230. ***************
  1231. *** 791,797 ****
  1232.       char *prevquote = Nullch;
  1233.       bool global = FALSE;
  1234.   
  1235. !     if (isascii(*name) && isupper(*name)) {
  1236.       if (*name > 'I') {
  1237.           if (*name == 'S' && (
  1238.             strEQ(name, "SIG") ||
  1239. --- 809,815 ----
  1240.       char *prevquote = Nullch;
  1241.       bool global = FALSE;
  1242.   
  1243. !     if (isUPPER(*name)) {
  1244.       if (*name > 'I') {
  1245.           if (*name == 'S' && (
  1246.             strEQ(name, "SIG") ||
  1247. ***************
  1248. *** 822,830 ****
  1249.       sawquote = Nullch;
  1250.       name++;
  1251.       }
  1252. !     else if (!isalpha(*name) || global)
  1253.       stash = defstash;
  1254. !     else if (curcmd == &compiling)
  1255.       stash = curstash;
  1256.       else
  1257.       stash = curcmd->c_stash;
  1258. --- 840,848 ----
  1259.       sawquote = Nullch;
  1260.       name++;
  1261.       }
  1262. !     else if (!isALPHA(*name) || global)
  1263.       stash = defstash;
  1264. !     else if ((CMD*)curcmd == &compiling)
  1265.       stash = curstash;
  1266.       else
  1267.       stash = curcmd->c_stash;
  1268. ***************
  1269. *** 833,838 ****
  1270. --- 851,857 ----
  1271.       char *s, *d;
  1272.   
  1273.       *sawquote = '\0';
  1274. +     /*SUPPRESS 560*/
  1275.       if (s = prevquote) {
  1276.           strncpy(tmpbuf,name,s-name+1);
  1277.           d = tmpbuf+(s-name+1);
  1278. ***************
  1279. *** 869,880 ****
  1280.       strcpy(stab_magic(stab),"StB");
  1281.       stab_val(stab) = Str_new(72,0);
  1282.       stab_line(stab) = curcmd->c_line;
  1283. !     str_magic(stab,stab,'*',name,len);
  1284.       stab_stash(stab) = stash;
  1285. !     if (isdigit(*name) && *name != '0') {
  1286.           stab_flags(stab) = SF_VMAGIC;
  1287.           str_magic(stab_val(stab), stab, 0, Nullch, 0);
  1288.       }
  1289.       return stab;
  1290.       }
  1291.   }
  1292. --- 888,901 ----
  1293.       strcpy(stab_magic(stab),"StB");
  1294.       stab_val(stab) = Str_new(72,0);
  1295.       stab_line(stab) = curcmd->c_line;
  1296. !     str_magic((STR*)stab, stab, '*', name, len);
  1297.       stab_stash(stab) = stash;
  1298. !     if (isDIGIT(*name) && *name != '0') {
  1299.           stab_flags(stab) = SF_VMAGIC;
  1300.           str_magic(stab_val(stab), stab, 0, Nullch, 0);
  1301.       }
  1302. +     if (add & 2)
  1303. +         stab->str_pok |= SP_MULTI;
  1304.       return stab;
  1305.       }
  1306.   }
  1307. ***************
  1308. *** 945,955 ****
  1309. --- 966,979 ----
  1310.       stab_xhash(stab) = Null(HASH*);
  1311.       str_free(stab_val(stab));
  1312.       stab_val(stab) = Nullstr;
  1313. +     /*SUPPRESS 560*/
  1314.       if (stio = stab_io(stab)) {
  1315.       do_close(stab,FALSE);
  1316.       Safefree(stio->top_name);
  1317.       Safefree(stio->fmt_name);
  1318. +     Safefree(stio);
  1319.       }
  1320. +     /*SUPPRESS 560*/
  1321.       if (sub = stab_sub(stab)) {
  1322.       afree(sub->tosave);
  1323.       cmd_free(sub->cmd);
  1324.  
  1325. Index: stab.h
  1326. *** stab.h.old    Tue Nov  5 19:27:51 1991
  1327. --- stab.h    Tue Nov  5 19:27:52 1991
  1328. ***************
  1329. *** 1,4 ****
  1330. ! /* $RCSfile: stab.h,v $$Revision: 4.0.1.1 $$Date: 91/06/07 11:56:35 $
  1331.    *
  1332.    *    Copyright (c) 1991, Larry Wall
  1333.    *
  1334. --- 1,4 ----
  1335. ! /* $RCSfile: stab.h,v $$Revision: 4.0.1.2 $$Date: 91/11/05 18:36:15 $
  1336.    *
  1337.    *    Copyright (c) 1991, Larry Wall
  1338.    *
  1339. ***************
  1340. *** 6,11 ****
  1341. --- 6,14 ----
  1342.    *    License or the Artistic License, as specified in the README file.
  1343.    *
  1344.    * $Log:    stab.h,v $
  1345. +  * Revision 4.0.1.2  91/11/05  18:36:15  lwall
  1346. +  * patch11: length($x) was sometimes wrong for numeric $x
  1347. +  * 
  1348.    * Revision 4.0.1.1  91/06/07  11:56:35  lwall
  1349.    * patch4: new copyright notice
  1350.    * patch4: length($`), length($&), length($') now optimized to avoid string copy
  1351. ***************
  1352. *** 100,106 ****
  1353.   STRLEN stab_len();
  1354.   
  1355.   #define STAB_STR(s) (tmpstab = (s), stab_flags(tmpstab) & SF_VMAGIC ? stab_str(stab_val(tmpstab)->str_magic) : stab_val(tmpstab))
  1356. ! #define STAB_LEN(s) (tmpstab = (s), stab_flags(tmpstab) & SF_VMAGIC ? stab_len(stab_val(tmpstab)->str_magic) : stab_val(tmpstab)->str_cur)
  1357.   #define STAB_GET(s) (tmpstab = (s), str_get(stab_flags(tmpstab) & SF_VMAGIC ? stab_str(tmpstab->str_magic) : stab_val(tmpstab)))
  1358.   #define STAB_GNUM(s) (tmpstab = (s), str_gnum(stab_flags(tmpstab) & SF_VMAGIC ? stab_str(tmpstab->str_magic) : stab_val(tmpstab)))
  1359.   
  1360. --- 103,109 ----
  1361.   STRLEN stab_len();
  1362.   
  1363.   #define STAB_STR(s) (tmpstab = (s), stab_flags(tmpstab) & SF_VMAGIC ? stab_str(stab_val(tmpstab)->str_magic) : stab_val(tmpstab))
  1364. ! #define STAB_LEN(s) (tmpstab = (s), stab_flags(tmpstab) & SF_VMAGIC ? stab_len(stab_val(tmpstab)->str_magic) : str_len(stab_val(tmpstab)))
  1365.   #define STAB_GET(s) (tmpstab = (s), str_get(stab_flags(tmpstab) & SF_VMAGIC ? stab_str(tmpstab->str_magic) : stab_val(tmpstab)))
  1366.   #define STAB_GNUM(s) (tmpstab = (s), str_gnum(stab_flags(tmpstab) & SF_VMAGIC ? stab_str(tmpstab->str_magic) : stab_val(tmpstab)))
  1367.   
  1368.  
  1369. Index: t/op/stat.t
  1370. *** t/op/stat.t.old    Tue Nov  5 19:28:06 1991
  1371. --- t/op/stat.t    Tue Nov  5 19:28:06 1991
  1372. ***************
  1373. *** 1,6 ****
  1374.   #!./perl
  1375.   
  1376. ! # $RCSfile: stat.t,v $$Revision: 4.0.1.1 $$Date: 91/06/07 12:02:42 $
  1377.   
  1378.   print "1..56\n";
  1379.   
  1380. --- 1,6 ----
  1381.   #!./perl
  1382.   
  1383. ! # $RCSfile: stat.t,v $$Revision: 4.0.1.2 $$Date: 91/11/05 18:44:44 $
  1384.   
  1385.   print "1..56\n";
  1386.   
  1387. ***************
  1388. *** 9,23 ****
  1389.   $DEV = `ls -l /dev`;
  1390.   
  1391.   unlink "Op.stat.tmp";
  1392. ! open(foo, ">Op.stat.tmp");
  1393.   
  1394.   ($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,$atime,$mtime,$ctime,
  1395. !     $blksize,$blocks) = stat(foo);
  1396.   if ($nlink == 1) {print "ok 1\n";} else {print "not ok 1\n";}
  1397.   if ($mtime && $mtime == $ctime) {print "ok 2\n";} else {print "not ok 2\n";}
  1398.   
  1399. ! print foo "Now is the time for all good men to come to.\n";
  1400. ! close(foo);
  1401.   
  1402.   sleep 2;
  1403.   
  1404. --- 9,23 ----
  1405.   $DEV = `ls -l /dev`;
  1406.   
  1407.   unlink "Op.stat.tmp";
  1408. ! open(FOO, ">Op.stat.tmp");
  1409.   
  1410.   ($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,$atime,$mtime,$ctime,
  1411. !     $blksize,$blocks) = stat(FOO);
  1412.   if ($nlink == 1) {print "ok 1\n";} else {print "not ok 1\n";}
  1413.   if ($mtime && $mtime == $ctime) {print "ok 2\n";} else {print "not ok 2\n";}
  1414.   
  1415. ! print FOO "Now is the time for all good men to come to.\n";
  1416. ! close(FOO);
  1417.   
  1418.   sleep 2;
  1419.   
  1420. ***************
  1421. *** 141,164 ****
  1422.   if (-B './perl') {print "ok 43\n";} else {print "not ok 43\n";}
  1423.   if (! -T './perl') {print "ok 44\n";} else {print "not ok 44\n";}
  1424.   
  1425. ! open(foo,'op/stat.t');
  1426. ! if (-T foo) {print "ok 45\n";} else {print "not ok 45\n";}
  1427. ! if (! -B foo) {print "ok 46\n";} else {print "not ok 46\n";}
  1428. ! $_ = <foo>;
  1429. ! if (/perl/) {print "ok 47\n";} else {print "not ok 47\n";}
  1430. ! if (-T foo) {print "ok 48\n";} else {print "not ok 48\n";}
  1431. ! if (! -B foo) {print "ok 49\n";} else {print "not ok 49\n";}
  1432. ! close(foo);
  1433.   
  1434. ! open(foo,'op/stat.t');
  1435. ! $_ = <foo>;
  1436. ! if (/perl/) {print "ok 50\n";} else {print "not ok 50\n";}
  1437. ! if (-T foo) {print "ok 51\n";} else {print "not ok 51\n";}
  1438. ! if (! -B foo) {print "ok 52\n";} else {print "not ok 52\n";}
  1439. ! seek(foo,0,0);
  1440. ! if (-T foo) {print "ok 53\n";} else {print "not ok 53\n";}
  1441. ! if (! -B foo) {print "ok 54\n";} else {print "not ok 54\n";}
  1442. ! close(foo);
  1443.   
  1444.   if (-T '/dev/null') {print "ok 55\n";} else {print "not ok 55\n";}
  1445.   if (-B '/dev/null') {print "ok 56\n";} else {print "not ok 56\n";}
  1446. --- 141,173 ----
  1447.   if (-B './perl') {print "ok 43\n";} else {print "not ok 43\n";}
  1448.   if (! -T './perl') {print "ok 44\n";} else {print "not ok 44\n";}
  1449.   
  1450. ! open(FOO,'op/stat.t');
  1451. ! eval { -T FOO; };
  1452. ! if ($@ =~ /not implemented/) {
  1453. !     print "# $@";
  1454. !     for (45 .. 54) {
  1455. !     print "ok $_\n";
  1456. !     }
  1457. ! }
  1458. ! else {
  1459. !     if (-T FOO) {print "ok 45\n";} else {print "not ok 45\n";}
  1460. !     if (! -B FOO) {print "ok 46\n";} else {print "not ok 46\n";}
  1461. !     $_ = <FOO>;
  1462. !     if (/perl/) {print "ok 47\n";} else {print "not ok 47\n";}
  1463. !     if (-T FOO) {print "ok 48\n";} else {print "not ok 48\n";}
  1464. !     if (! -B FOO) {print "ok 49\n";} else {print "not ok 49\n";}
  1465. !     close(FOO);
  1466.   
  1467. !     open(FOO,'op/stat.t');
  1468. !     $_ = <FOO>;
  1469. !     if (/perl/) {print "ok 50\n";} else {print "not ok 50\n";}
  1470. !     if (-T FOO) {print "ok 51\n";} else {print "not ok 51\n";}
  1471. !     if (! -B FOO) {print "ok 52\n";} else {print "not ok 52\n";}
  1472. !     seek(FOO,0,0);
  1473. !     if (-T FOO) {print "ok 53\n";} else {print "not ok 53\n";}
  1474. !     if (! -B FOO) {print "ok 54\n";} else {print "not ok 54\n";}
  1475. ! }
  1476. ! close(FOO);
  1477.   
  1478.   if (-T '/dev/null') {print "ok 55\n";} else {print "not ok 55\n";}
  1479.   if (-B '/dev/null') {print "ok 56\n";} else {print "not ok 56\n";}
  1480.  
  1481. Index: hints/stellar.sh
  1482. *** hints/stellar.sh.old    Tue Nov  5 19:26:37 1991
  1483. --- hints/stellar.sh    Tue Nov  5 19:26:38 1991
  1484. ***************
  1485. *** 0 ****
  1486. --- 1,2 ----
  1487. + optimize="-O0"
  1488. + ccflags="$ccflags -nw"
  1489.  
  1490. Index: str.c
  1491. *** str.c.old    Tue Nov  5 19:27:54 1991
  1492. --- str.c    Tue Nov  5 19:27:55 1991
  1493. ***************
  1494. *** 1,4 ****
  1495. ! /* $RCSfile: str.c,v $$Revision: 4.0.1.3 $$Date: 91/06/10 01:27:54 $
  1496.    *
  1497.    *    Copyright (c) 1991, Larry Wall
  1498.    *
  1499. --- 1,4 ----
  1500. ! /* $RCSfile: str.c,v $$Revision: 4.0.1.4 $$Date: 91/11/05 18:40:51 $
  1501.    *
  1502.    *    Copyright (c) 1991, Larry Wall
  1503.    *
  1504. ***************
  1505. *** 6,11 ****
  1506. --- 6,16 ----
  1507.    *    License or the Artistic License, as specified in the README file.
  1508.    *
  1509.    * $Log:    str.c,v $
  1510. +  * Revision 4.0.1.4  91/11/05  18:40:51  lwall
  1511. +  * patch11: $foo .= <BAR> could overrun malloced memory
  1512. +  * patch11: \$ didn't always make it through double-quoter to regexp routines
  1513. +  * patch11: prepared for ctype implementations that don't define isascii()
  1514. +  * 
  1515.    * Revision 4.0.1.3  91/06/10  01:27:54  lwall
  1516.    * patch10: $) and $| incorrectly handled in run-time patterns
  1517.    * 
  1518. ***************
  1519. *** 255,260 ****
  1520. --- 260,266 ----
  1521.           }
  1522.           str_nset(dstr,sstr->str_ptr,sstr->str_cur);
  1523.       }
  1524. +     /*SUPPRESS 560*/
  1525.       if (dstr->str_nok = sstr->str_nok)
  1526.           dstr->str_u.str_nval = sstr->str_u.str_nval;
  1527.       else {
  1528. ***************
  1529. *** 556,561 ****
  1530. --- 562,568 ----
  1531.       *mid = '\0';
  1532.       bigstr->str_cur = mid - big;
  1533.       }
  1534. +     /*SUPPRESS 560*/
  1535.       else if (i = mid - big) {    /* faster from front */
  1536.       midend -= littlelen;
  1537.       mid = midend;
  1538. ***************
  1539. *** 709,719 ****
  1540. --- 716,728 ----
  1541.       (void)str_2ptr(str2);
  1542.   
  1543.       if (str1->str_cur < str2->str_cur) {
  1544. +     /*SUPPRESS 560*/
  1545.       if (retval = memcmp(str1->str_ptr, str2->str_ptr, str1->str_cur))
  1546.           return retval < 0 ? -1 : 1;
  1547.       else
  1548.           return -1;
  1549.       }
  1550. +     /*SUPPRESS 560*/
  1551.       else if (retval = memcmp(str1->str_ptr, str2->str_ptr, str2->str_cur))
  1552.       return retval < 0 ? -1 : 1;
  1553.       else if (str1->str_cur == str2->str_cur)
  1554. ***************
  1555. *** 742,748 ****
  1556.       cnt = fp->_cnt;            /* get count into register */
  1557.       str->str_nok = 0;            /* invalidate number */
  1558.       str->str_pok = 1;            /* validate pointer */
  1559. !     if (str->str_len <= cnt + 1) {    /* make sure we have the room */
  1560.       if (cnt > 80 && str->str_len > append) {
  1561.           shortbuffered = cnt - str->str_len + append + 1;
  1562.           cnt -= shortbuffered;
  1563. --- 751,757 ----
  1564.       cnt = fp->_cnt;            /* get count into register */
  1565.       str->str_nok = 0;            /* invalidate number */
  1566.       str->str_pok = 1;            /* validate pointer */
  1567. !     if (str->str_len - append <= cnt + 1) { /* make sure we have the room */
  1568.       if (cnt > 80 && str->str_len > append) {
  1569.           shortbuffered = cnt - str->str_len + append + 1;
  1570.           cnt -= shortbuffered;
  1571. ***************
  1572. *** 928,941 ****
  1573.       if (*s == '\\' && s[1] && index("$@[{\\]}lLuUE",s[1])) {
  1574.           str_ncat(str, t, s - t);
  1575.           ++s;
  1576. !         if (isalpha(*s)) {
  1577.           str_ncat(str, "$c", 2);
  1578.           sawcase = (*s != 'E');
  1579.           }
  1580.           else {
  1581. !         if (*nointrp && s+1 < send)
  1582. !             if (*s != '@' && (*s != '$' || index(nointrp,s[1])))
  1583.               str_ncat(str,s-1,1);
  1584.           str_ncat(str, "$b", 2);
  1585.           }
  1586.           str_ncat(str, s, 1);
  1587. --- 937,957 ----
  1588.       if (*s == '\\' && s[1] && index("$@[{\\]}lLuUE",s[1])) {
  1589.           str_ncat(str, t, s - t);
  1590.           ++s;
  1591. !         if (isALPHA(*s)) {
  1592.           str_ncat(str, "$c", 2);
  1593.           sawcase = (*s != 'E');
  1594.           }
  1595.           else {
  1596. !         if (*nointrp) {        /* in a regular expression */
  1597. !             if (*s == '@')    /* always strip \@ */ /*SUPPRESS 530*/
  1598. !             ;
  1599. !             else if (*s == '$') {
  1600. !             if (s+1 >= send || index(nointrp, s[1]))
  1601. !                 str_ncat(str,s-1,1); /* only strip \$ for vars */
  1602. !             }
  1603. !             else        /* don't strip \\, \[, \{ etc. */
  1604.               str_ncat(str,s-1,1);
  1605. +         }
  1606.           str_ncat(str, "$b", 2);
  1607.           }
  1608.           str_ncat(str, s, 1);
  1609. ***************
  1610. *** 952,958 ****
  1611.       else if ((*s == '@' || *s == '$') && s+1 < send) {
  1612.           str_ncat(str,t,s-t);
  1613.           t = s;
  1614. !         if (*s == '$' && s[1] == '#' && (isalpha(s[2]) || s[2] == '_'))
  1615.           s++;
  1616.           s = scanident(s,send,tokenbuf);
  1617.           if (*t == '@' &&
  1618. --- 968,974 ----
  1619.       else if ((*s == '@' || *s == '$') && s+1 < send) {
  1620.           str_ncat(str,t,s-t);
  1621.           t = s;
  1622. !         if (*s == '$' && s[1] == '#' && (isALPHA(s[2]) || s[2] == '_'))
  1623.           s++;
  1624.           s = scanident(s,send,tokenbuf);
  1625.           if (*t == '@' &&
  1626. ***************
  1627. *** 988,993 ****
  1628. --- 1004,1010 ----
  1629.               case '\'':
  1630.               case '"':
  1631.               if (s[-1] != '$') {
  1632. +                 /*SUPPRESS 68*/
  1633.                   s = cpytill(tokenbuf,s+1,send,*s,&len);
  1634.                   if (s >= send)
  1635.                   fatal("Unterminated string");
  1636. ***************
  1637. *** 1002,1011 ****
  1638.               d = checkpoint;
  1639.               if (*d == '{' && s[-1] == '}') {    /* maybe {n,m} */
  1640.               ++d;
  1641. !             if (isdigit(*d)) {    /* matches /^{\d,?\d*}$/ */
  1642.                   if (*++d == ',')
  1643.                   ++d;
  1644. !                 while (isdigit(*d))
  1645.                   d++;
  1646.                   if (d == s - 1)
  1647.                   s = checkpoint;        /* Is {n,m}! Backoff! */
  1648. --- 1019,1028 ----
  1649.               d = checkpoint;
  1650.               if (*d == '{' && s[-1] == '}') {    /* maybe {n,m} */
  1651.               ++d;
  1652. !             if (isDIGIT(*d)) {    /* matches /^{\d,?\d*}$/ */
  1653.                   if (*++d == ',')
  1654.                   ++d;
  1655. !                 while (isDIGIT(*d))
  1656.                   d++;
  1657.                   if (d == s - 1)
  1658.                   s = checkpoint;        /* Is {n,m}! Backoff! */
  1659. ***************
  1660. *** 1022,1030 ****
  1661.                   weight += 150;
  1662.               else if (d[1] == '$')
  1663.                   weight -= 3;
  1664. !             if (isdigit(d[1])) {
  1665.                   if (d[2]) {
  1666. !                 if (isdigit(d[2]) && !d[3])
  1667.                       weight -= 10;
  1668.                   }
  1669.                   else
  1670. --- 1039,1047 ----
  1671.                   weight += 150;
  1672.               else if (d[1] == '$')
  1673.                   weight -= 3;
  1674. !             if (isDIGIT(d[1])) {
  1675.                   if (d[2]) {
  1676. !                 if (isDIGIT(d[2]) && !d[3])
  1677.                       weight -= 10;
  1678.                   }
  1679.                   else
  1680. ***************
  1681. *** 1037,1044 ****
  1682.                   case '&':
  1683.                   case '$':
  1684.                   weight -= seen[un_char] * 10;
  1685. !                 if (isalpha(d[1]) || isdigit(d[1]) ||
  1686. !                   d[1] == '_') {
  1687.                       d = scanident(d,s,tokenbuf);
  1688.                       if (stabent(tokenbuf,FALSE))
  1689.                       weight -= 100;
  1690. --- 1054,1060 ----
  1691.                   case '&':
  1692.                   case '$':
  1693.                   weight -= seen[un_char] * 10;
  1694. !                 if (isALNUM(d[1])) {
  1695.                       d = scanident(d,s,tokenbuf);
  1696.                       if (stabent(tokenbuf,FALSE))
  1697.                       weight -= 100;
  1698. ***************
  1699. *** 1062,1070 ****
  1700.                       weight += 1;
  1701.                       else if (index("rnftb",d[1]))
  1702.                       weight += 40;
  1703. !                     else if (isdigit(d[1])) {
  1704.                       weight += 40;
  1705. !                     while (d[1] && isdigit(d[1]))
  1706.                           d++;
  1707.                       }
  1708.                   }
  1709. --- 1078,1086 ----
  1710.                       weight += 1;
  1711.                       else if (index("rnftb",d[1]))
  1712.                       weight += 40;
  1713. !                     else if (isDIGIT(d[1])) {
  1714.                       weight += 40;
  1715. !                     while (d[1] && isDIGIT(d[1]))
  1716.                           d++;
  1717.                       }
  1718.                   }
  1719. ***************
  1720. *** 1082,1088 ****
  1721.                   else
  1722.                       weight -= 1;
  1723.                   default:
  1724. !                 if (isalpha(*d) && d[1] && isalpha(d[1])) {
  1725.                       bufptr = d;
  1726.                       if (yylex() != WORD)
  1727.                       weight -= 150;
  1728. --- 1098,1104 ----
  1729.                   else
  1730.                       weight -= 1;
  1731.                   default:
  1732. !                 if (isALPHA(*d) && d[1] && isALPHA(d[1])) {
  1733.                       bufptr = d;
  1734.                       if (yylex() != WORD)
  1735.                       weight -= 150;
  1736. ***************
  1737. *** 1243,1249 ****
  1738.   register char *send;
  1739.   {
  1740.       while (s < send) {
  1741. !     if (isascii(*s) && islower(*s))
  1742.           *s = toupper(*s);
  1743.       s++;
  1744.       }
  1745. --- 1259,1265 ----
  1746.   register char *send;
  1747.   {
  1748.       while (s < send) {
  1749. !     if (isLOWER(*s))
  1750.           *s = toupper(*s);
  1751.       s++;
  1752.       }
  1753. ***************
  1754. *** 1254,1260 ****
  1755.   register char *send;
  1756.   {
  1757.       while (s < send) {
  1758. !     if (isascii(*s) && isupper(*s))
  1759.           *s = tolower(*s);
  1760.       s++;
  1761.       }
  1762. --- 1270,1276 ----
  1763.   register char *send;
  1764.   {
  1765.       while (s < send) {
  1766. !     if (isUPPER(*s))
  1767.           *s = tolower(*s);
  1768.       s++;
  1769.       }
  1770. ***************
  1771. *** 1280,1287 ****
  1772.       return;
  1773.       }
  1774.       d = str->str_ptr;
  1775. !     while (isalpha(*d)) d++;
  1776. !     while (isdigit(*d)) d++;
  1777.       if (*d) {
  1778.           str_numset(str,atof(str->str_ptr) + 1.0);  /* punt */
  1779.       return;
  1780. --- 1296,1303 ----
  1781.       return;
  1782.       }
  1783.       d = str->str_ptr;
  1784. !     while (isALPHA(*d)) d++;
  1785. !     while (isDIGIT(*d)) d++;
  1786.       if (*d) {
  1787.           str_numset(str,atof(str->str_ptr) + 1.0);  /* punt */
  1788.       return;
  1789. ***************
  1790. *** 1288,1294 ****
  1791.       }
  1792.       d--;
  1793.       while (d >= str->str_ptr) {
  1794. !     if (isdigit(*d)) {
  1795.           if (++*d <= '9')
  1796.           return;
  1797.           *(d--) = '0';
  1798. --- 1304,1310 ----
  1799.       }
  1800.       d--;
  1801.       while (d >= str->str_ptr) {
  1802. !     if (isDIGIT(*d)) {
  1803.           if (++*d <= '9')
  1804.           return;
  1805.           *(d--) = '0';
  1806. ***************
  1807. *** 1295,1301 ****
  1808.       }
  1809.       else {
  1810.           ++*d;
  1811. !         if (isalpha(*d))
  1812.           return;
  1813.           *(d--) -= 'z' - 'a' + 1;
  1814.       }
  1815. --- 1311,1317 ----
  1816.       }
  1817.       else {
  1818.           ++*d;
  1819. !         if (isALPHA(*d))
  1820.           return;
  1821.           *(d--) -= 'z' - 'a' + 1;
  1822.       }
  1823. ***************
  1824. *** 1305,1311 ****
  1825.       str->str_cur++;
  1826.       for (d = str->str_ptr + str->str_cur; d > str->str_ptr; d--)
  1827.       *d = d[-1];
  1828. !     if (isdigit(d[1]))
  1829.       *d = '1';
  1830.       else
  1831.       *d = d[1];
  1832. --- 1321,1327 ----
  1833.       str->str_cur++;
  1834.       for (d = str->str_ptr + str->str_cur; d > str->str_ptr; d--)
  1835.       *d = d[-1];
  1836. !     if (isDIGIT(d[1]))
  1837.       *d = '1';
  1838.       else
  1839.       *d = d[1];
  1840.  
  1841. *** End of Patch 16 ***
  1842. exit 0 # Just in case...
  1843. -- 
  1844. Kent Landfield                   INTERNET: kent@sparky.IMD.Sterling.COM
  1845. Sterling Software, IMD           UUCP:     uunet!sparky!kent
  1846. Phone:    (402) 291-8300         FAX:      (402) 291-4362
  1847. Please send comp.sources.misc-related mail to kent@uunet.uu.net.
  1848.