home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / misc / volume30 / perl / patch33 < prev    next >
Text File  |  1992-06-11  |  46KB  |  1,850 lines
  1. Newsgroups: comp.sources.misc
  2. From: lwall@netlabs.com (Larry Wall)
  3. Subject:  v30i044:  perl - The perl programming language, Patch33
  4. Message-ID: <1992Jun11.181002.1679@sparky.imd.sterling.com>
  5. X-Md4-Signature: 439bcf7bec81c24f76aee025c9511c5f
  6. Date: Thu, 11 Jun 1992 18:10:02 GMT
  7. Approved: kent@sparky.imd.sterling.com
  8.  
  9. Submitted-by: lwall@netlabs.com (Larry Wall)
  10. Posting-number: Volume 30, Issue 44
  11. Archive-name: perl/patch33
  12. Environment: UNIX, MS-DOS, OS2
  13. Patch-To: perl: Volume 18, Issue 19-54
  14.  
  15. System: perl version 4.0
  16. Patch #: 33
  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.         Configure -d
  30.         make depend
  31.         make
  32.         make test
  33.         make install
  34.  
  35.     If patch indicates that patchlevel is the wrong version, you may need
  36.     to apply one or more previous patches, or the patch may already
  37.     have been applied.  See the patchlevel.h file to find out what has or
  38.     has not been applied.  In any event, don't continue with the patch.
  39.  
  40.     If you are missing previous patches they can be obtained from me:
  41.  
  42.     Larry Wall
  43.     lwall@netlabs.com
  44.  
  45.     If you send a mail message of the following form it will greatly speed
  46.     processing:
  47.  
  48.     Subject: Command
  49.     @SH mailpatch PATH perl 4.0 LIST
  50.            ^ note the c
  51.  
  52.     where PATH is a return path FROM ME TO YOU either in Internet notation,
  53.     or in bang notation from some well-known host, and LIST is the number
  54.     of one or more patches you need, separated by spaces, commas, and/or
  55.     hyphens.  Saying 35- says everything from 35 to the end.
  56.  
  57.  
  58. Index: patchlevel.h
  59. Prereq: 32
  60. 1c1
  61. < #define PATCHLEVEL 32
  62. ---
  63. > #define PATCHLEVEL 33
  64.  
  65. Index: toke.c
  66. *** toke.c.old    Mon Jun  8 17:52:16 1992
  67. --- toke.c    Mon Jun  8 17:52:17 1992
  68. ***************
  69. *** 1,4 ****
  70. ! /* $RCSfile: toke.c,v $$Revision: 4.0.1.5 $$Date: 91/11/11 16:45:51 $
  71.    *
  72.    *    Copyright (c) 1991, Larry Wall
  73.    *
  74. --- 1,4 ----
  75. ! /* $RCSfile: toke.c,v $$Revision: 4.0.1.6 $$Date: 92/06/08 16:03:49 $
  76.    *
  77.    *    Copyright (c) 1991, Larry Wall
  78.    *
  79. ***************
  80. *** 6,11 ****
  81. --- 6,24 ----
  82.    *    License or the Artistic License, as specified in the README file.
  83.    *
  84.    * $Log:    toke.c,v $
  85. +  * Revision 4.0.1.6  92/06/08  16:03:49  lwall
  86. +  * patch20: an EXPR may now start with a bareword
  87. +  * patch20: print $fh EXPR can now expect term rather than operator in EXPR
  88. +  * patch20: added ... as variant on ..
  89. +  * patch20: new warning on spurious backslash
  90. +  * patch20: new warning on missing $ for foreach variable
  91. +  * patch20: "foo"x1024 now legal without space after x
  92. +  * patch20: new warning on print accidentally used as function
  93. +  * patch20: tr/stuff// wasn't working right
  94. +  * patch20: 2. now eats the dot
  95. +  * patch20: <@ARGV> now notices @ARGV
  96. +  * patch20: tr/// now lets you say \-
  97. +  * 
  98.    * Revision 4.0.1.5  91/11/11  16:45:51  lwall
  99.    * patch19: default arg for shift was wrong after first subroutine definition
  100.    * 
  101. ***************
  102. *** 39,44 ****
  103. --- 52,59 ----
  104.   #include "perl.h"
  105.   #include "perly.h"
  106.   
  107. + static void set_csh();
  108. + 
  109.   #ifdef I_FCNTL
  110.   #include <fcntl.h>
  111.   #endif
  112. ***************
  113. *** 63,69 ****
  114. --- 78,88 ----
  115.   #endif
  116.   #define CLINE (cmdline = (curcmd->c_line < cmdline ? curcmd->c_line : cmdline))
  117.   
  118. + #ifdef atarist
  119. + #define PERL_META(c) ((c) | 128)
  120. + #else
  121.   #define META(c) ((c) | 128)
  122. + #endif
  123.   
  124.   #define RETURN(retval) return (bufptr = s,(int)retval)
  125.   #define OPERATOR(retval) return (expectterm = TRUE,bufptr = s,(int)retval)
  126. ***************
  127. *** 93,110 ****
  128.   #define FOP22(f) return(yylval.ival=f,expectterm = FALSE,bufptr = s,(int)FILOP22)
  129.   #define FOP25(f) return(yylval.ival=f,expectterm = FALSE,bufptr = s,(int)FILOP25)
  130.   
  131.   /* This bit of chicanery makes a unary function followed by
  132.    * a parenthesis into a function with one argument, highest precedence.
  133.    */
  134. ! #define UNI(f) return(yylval.ival = f,expectterm = TRUE,bufptr = s, \
  135.       (*s == '(' || (s = skipspace(s), *s == '(') ? (int)FUNC1 : (int)UNIOP) )
  136.   
  137.   /* This does similarly for list operators, merely by pretending that the
  138.    * paren came before the listop rather than after.
  139.    */
  140.   #define LOP(f) return(CLINE, *s == '(' || (s = skipspace(s), *s == '(') ? \
  141.       (*s = (char) META('('), bufptr = oldbufptr, '(') : \
  142.       (yylval.ival=f,expectterm = TRUE,bufptr = s,(int)LISTOP))
  143.   /* grandfather return to old style */
  144.   #define OLDLOP(f) return(yylval.ival=f,expectterm = TRUE,bufptr = s,(int)LISTOP)
  145.   
  146. --- 112,140 ----
  147.   #define FOP22(f) return(yylval.ival=f,expectterm = FALSE,bufptr = s,(int)FILOP22)
  148.   #define FOP25(f) return(yylval.ival=f,expectterm = FALSE,bufptr = s,(int)FILOP25)
  149.   
  150. + static char *last_uni;
  151. + 
  152.   /* This bit of chicanery makes a unary function followed by
  153.    * a parenthesis into a function with one argument, highest precedence.
  154.    */
  155. ! #define UNI(f) return(yylval.ival = f, \
  156. !     expectterm = TRUE, \
  157. !     bufptr = s, \
  158. !     last_uni = oldbufptr, \
  159.       (*s == '(' || (s = skipspace(s), *s == '(') ? (int)FUNC1 : (int)UNIOP) )
  160.   
  161.   /* This does similarly for list operators, merely by pretending that the
  162.    * paren came before the listop rather than after.
  163.    */
  164. + #ifdef atarist
  165.   #define LOP(f) return(CLINE, *s == '(' || (s = skipspace(s), *s == '(') ? \
  166. +     (*s = (char) PERL_META('('), bufptr = oldbufptr, '(') : \
  167. +     (yylval.ival=f,expectterm = TRUE,bufptr = s,(int)LISTOP))
  168. + #else
  169. + #define LOP(f) return(CLINE, *s == '(' || (s = skipspace(s), *s == '(') ? \
  170.       (*s = (char) META('('), bufptr = oldbufptr, '(') : \
  171.       (yylval.ival=f,expectterm = TRUE,bufptr = s,(int)LISTOP))
  172. + #endif
  173.   /* grandfather return to old style */
  174.   #define OLDLOP(f) return(yylval.ival=f,expectterm = TRUE,bufptr = s,(int)LISTOP)
  175.   
  176. ***************
  177. *** 117,122 ****
  178. --- 147,168 ----
  179.       return s;
  180.   }
  181.   
  182. + void
  183. + check_uni() {
  184. +     char *s;
  185. +     char ch;
  186. + 
  187. +     if (oldoldbufptr != last_uni)
  188. +     return;
  189. +     while (isSPACE(*last_uni))
  190. +     last_uni++;
  191. +     for (s = last_uni; isALNUM(*s); s++) ;
  192. +     ch = *s;
  193. +     *s = '\0';
  194. +     warn("Warning: Use of \"%s\" without parens is ambiguous", last_uni);
  195. +     *s = ch;
  196. + }
  197. + 
  198.   #ifdef CRIPPLED_CC
  199.   
  200.   #undef UNI
  201. ***************
  202. *** 132,137 ****
  203. --- 178,184 ----
  204.       yylval.ival = f;
  205.       expectterm = TRUE;
  206.       bufptr = s;
  207. +     last_uni = oldbufptr;
  208.       if (*s == '(')
  209.       return FUNC1;
  210.       s = skipspace(s);
  211. ***************
  212. *** 150,156 ****
  213. --- 197,207 ----
  214.       if (*s != '(')
  215.       s = skipspace(s);
  216.       if (*s == '(') {
  217. + #ifdef atarist
  218. +     *s = PERL_META('(');
  219. + #else
  220.       *s = META('(');
  221. + #endif
  222.       bufptr = oldbufptr;
  223.       return '(';
  224.       }
  225. ***************
  226. *** 164,169 ****
  227. --- 215,221 ----
  228.   
  229.   #endif /* CRIPPLED_CC */
  230.   
  231. + int
  232.   yylex()
  233.   {
  234.       register char *s = bufptr;
  235. ***************
  236. *** 190,195 ****
  237. --- 242,251 ----
  238.           *s++ = '(';
  239.           oldbufptr = s;
  240.       }
  241. +     else if ((*s & 127) == '}') {
  242. +         *s++ = '}';
  243. +         RETURN('}');
  244. +     }
  245.       else
  246.           warn("Unrecognized character \\%03o ignored", *s++ & 255);
  247.       goto retry;
  248. ***************
  249. *** 201,206 ****
  250. --- 257,266 ----
  251.           *s++ = '(';
  252.           oldbufptr = s;
  253.       }
  254. +     else if ((*s & 127) == '}') {
  255. +         *s++ = '}';
  256. +         RETURN('}');
  257. +     }
  258.       else
  259.           warn("Unrecognized character \\%03o ignored", *s++ & 255);
  260.       goto retry;
  261. ***************
  262. *** 212,217 ****
  263. --- 272,278 ----
  264.           RETURN(0);
  265.       if (s++ < bufend)
  266.           goto retry;            /* ignore stray nulls */
  267. +     last_uni = 0;
  268.       if (firstline) {
  269.           firstline = FALSE;
  270.           if (minus_n || minus_p || perldb) {
  271. ***************
  272. *** 413,420 ****
  273.           s++;
  274.           RETURN(DEC);
  275.       }
  276. !     if (expectterm)
  277.           OPERATOR('-');
  278.       else
  279.           AOP(O_SUBTRACT);
  280.       case '+':
  281. --- 474,484 ----
  282.           s++;
  283.           RETURN(DEC);
  284.       }
  285. !     if (expectterm) {
  286. !         if (isSPACE(*s) || !isSPACE(*bufptr))
  287. !         check_uni();
  288.           OPERATOR('-');
  289. +     }
  290.       else
  291.           AOP(O_SUBTRACT);
  292.       case '+':
  293. ***************
  294. *** 423,435 ****
  295.           s++;
  296.           RETURN(INC);
  297.       }
  298. !     if (expectterm)
  299.           OPERATOR('+');
  300.       else
  301.           AOP(O_ADD);
  302.   
  303.       case '*':
  304.       if (expectterm) {
  305.           s = scanident(s,bufend,tokenbuf);
  306.           yylval.stabval = stabent(tokenbuf,TRUE);
  307.           TERM(STAR);
  308. --- 487,503 ----
  309.           s++;
  310.           RETURN(INC);
  311.       }
  312. !     if (expectterm) {
  313. !         if (isSPACE(*s) || !isSPACE(*bufptr))
  314. !         check_uni();
  315.           OPERATOR('+');
  316. +     }
  317.       else
  318.           AOP(O_ADD);
  319.   
  320.       case '*':
  321.       if (expectterm) {
  322. +         check_uni();
  323.           s = scanident(s,bufend,tokenbuf);
  324.           yylval.stabval = stabent(tokenbuf,TRUE);
  325.           TERM(STAR);
  326. ***************
  327. *** 442,447 ****
  328. --- 510,517 ----
  329.       MOP(O_MULTIPLY);
  330.       case '%':
  331.       if (expectterm) {
  332. +         if (!isALPHA(s[1]))
  333. +         check_uni();
  334.           s = scanident(s,bufend,tokenbuf);
  335.           yylval.stabval = hadd(stabent(tokenbuf,TRUE));
  336.           TERM(HSH);
  337. ***************
  338. *** 473,480 ****
  339.       tmp = *s++;
  340.       TERM(tmp);
  341.       case '}':
  342. !     tmp = *s++;
  343. !     RETURN(tmp);
  344.       case '&':
  345.       s++;
  346.       tmp = *s++;
  347. --- 543,550 ----
  348.       tmp = *s++;
  349.       TERM(tmp);
  350.       case '}':
  351. !     *s |= 128;
  352. !     RETURN(';');
  353.       case '&':
  354.       s++;
  355.       tmp = *s++;
  356. ***************
  357. *** 487,492 ****
  358. --- 557,564 ----
  359.           s++;
  360.           if (isALPHA(*s) || *s == '_' || *s == '\'')
  361.           *(--s) = '\\';    /* force next ident to WORD */
  362. +         else
  363. +         check_uni();
  364.           OPERATOR(AMPER);
  365.       }
  366.       OPERATOR('&');
  367. ***************
  368. *** 517,523 ****
  369.       OPERATOR('!');
  370.       case '<':
  371.       if (expectterm) {
  372. !         s = scanstr(s);
  373.           TERM(RSTRING);
  374.       }
  375.       s++;
  376. --- 589,597 ----
  377.       OPERATOR('!');
  378.       case '<':
  379.       if (expectterm) {
  380. !         if (s[1] != '<' && !index(s,'>'))
  381. !         check_uni();
  382. !         s = scanstr(s, SCAN_DEF);
  383.           TERM(RSTRING);
  384.       }
  385.       s++;
  386. ***************
  387. *** 570,576 ****
  388.           goto retry;
  389.       }
  390.       yylval.stabval = stabent(tokenbuf,TRUE);
  391. !     TERM(REG);
  392.   
  393.       case '@':
  394.       d = s;
  395. --- 644,664 ----
  396.           goto retry;
  397.       }
  398.       yylval.stabval = stabent(tokenbuf,TRUE);
  399. !     expectterm = FALSE;
  400. !     if (isSPACE(*s) && oldoldbufptr && oldoldbufptr < bufptr) {
  401. !         s++;
  402. !         while (isSPACE(*oldoldbufptr))
  403. !         oldoldbufptr++;
  404. !         if (*oldoldbufptr == 'p' && strnEQ(oldoldbufptr,"print",5)) {
  405. !         if (index("&*<%", *s) && isALPHA(s[1]))
  406. !             expectterm = TRUE;        /* e.g. print $fh &sub */
  407. !         else if (*s == '.' && isDIGIT(s[1]))
  408. !             expectterm = TRUE;        /* e.g. print $fh .3 */
  409. !         else if (index("/?-+", *s) && !isSPACE(s[1]))
  410. !             expectterm = TRUE;        /* e.g. print $fh -1 */
  411. !         }
  412. !     }
  413. !     RETURN(REG);
  414.   
  415.       case '@':
  416.       d = s;
  417. ***************
  418. *** 583,588 ****
  419. --- 671,677 ----
  420.       case '/':            /* may either be division or pattern */
  421.       case '?':            /* may either be conditional or pattern */
  422.       if (expectterm) {
  423. +         check_uni();
  424.           s = scanpat(s);
  425.           TERM(PATTERN);
  426.       }
  427. ***************
  428. *** 596,603 ****
  429. --- 685,700 ----
  430.           tmp = *s++;
  431.           if (*s == tmp) {
  432.           s++;
  433. +         if (*s == tmp) {
  434. +             s++;
  435. +             yylval.ival = 0;
  436. +         }
  437. +         else
  438. +             yylval.ival = AF_COMMON;
  439.           OPERATOR(DOTDOT);
  440.           }
  441. +         if (expectterm)
  442. +         check_uni();
  443.           AOP(O_CONCAT);
  444.       }
  445.       /* FALL THROUGH */
  446. ***************
  447. *** 604,614 ****
  448.       case '0': case '1': case '2': case '3': case '4':
  449.       case '5': case '6': case '7': case '8': case '9':
  450.       case '\'': case '"': case '`':
  451. !     s = scanstr(s);
  452.       TERM(RSTRING);
  453.   
  454.       case '\\':    /* some magic to force next word to be a WORD */
  455.       s++;    /* used by do and sub to force a separate namespace */
  456.       /* FALL THROUGH */
  457.       case '_':
  458.       SNARFWORD;
  459. --- 701,715 ----
  460.       case '0': case '1': case '2': case '3': case '4':
  461.       case '5': case '6': case '7': case '8': case '9':
  462.       case '\'': case '"': case '`':
  463. !     s = scanstr(s, SCAN_DEF);
  464.       TERM(RSTRING);
  465.   
  466.       case '\\':    /* some magic to force next word to be a WORD */
  467.       s++;    /* used by do and sub to force a separate namespace */
  468. +     if (!isALPHA(*s) && *s != '_' && *s != '\'') {
  469. +         warn("Spurious backslash ignored");
  470. +         goto retry;
  471. +     }
  472.       /* FALL THROUGH */
  473.       case '_':
  474.       SNARFWORD;
  475. ***************
  476. *** 627,640 ****
  477.           TERM(RSTRING);
  478.           }
  479.           else if (strEQ(d,"__END__")) {
  480. - #ifndef TAINT
  481.           STAB *stab;
  482.           int fd;
  483.   
  484.           /*SUPPRESS 560*/
  485. !         if (stab = stabent("DATA",FALSE)) {
  486.               stab->str_pok |= SP_MULTI;
  487. !             stab_io(stab) = stio_new();
  488.               stab_io(stab)->ifp = rsfp;
  489.   #if defined(HAS_FCNTL) && defined(F_SETFD)
  490.               fd = fileno(rsfp);
  491. --- 728,741 ----
  492.           TERM(RSTRING);
  493.           }
  494.           else if (strEQ(d,"__END__")) {
  495.           STAB *stab;
  496.           int fd;
  497.   
  498.           /*SUPPRESS 560*/
  499. !         if (!in_eval && (stab = stabent("DATA",FALSE))) {
  500.               stab->str_pok |= SP_MULTI;
  501. !             if (!stab_io(stab))
  502. !             stab_io(stab) = stio_new();
  503.               stab_io(stab)->ifp = rsfp;
  504.   #if defined(HAS_FCNTL) && defined(F_SETFD)
  505.               fd = fileno(rsfp);
  506. ***************
  507. *** 648,654 ****
  508.               stab_io(stab)->type = '<';
  509.               rsfp = Nullfp;
  510.           }
  511. - #endif
  512.           goto fake_eof;
  513.           }
  514.       }
  515. --- 749,754 ----
  516. ***************
  517. *** 773,778 ****
  518. --- 873,882 ----
  519.       SNARFWORD;
  520.       if (strEQ(d,"for") || strEQ(d,"foreach")) {
  521.           yylval.ival = curcmd->c_line;
  522. +         while (s < bufend && isSPACE(*s))
  523. +         s++;
  524. +         if (isALPHA(*s))
  525. +         fatal("Missing $ on loop variable");
  526.           OPERATOR(FOR);
  527.       }
  528.       if (strEQ(d,"format")) {
  529. ***************
  530. *** 981,991 ****
  531.       case 'p': case 'P':
  532.       SNARFWORD;
  533.       if (strEQ(d,"print")) {
  534. !         checkcomma(s,"filehandle");
  535.           LOP(O_PRINT);
  536.       }
  537.       if (strEQ(d,"printf")) {
  538. !         checkcomma(s,"filehandle");
  539.           LOP(O_PRTF);
  540.       }
  541.       if (strEQ(d,"push")) {
  542. --- 1085,1095 ----
  543.       case 'p': case 'P':
  544.       SNARFWORD;
  545.       if (strEQ(d,"print")) {
  546. !         checkcomma(s,d,"filehandle");
  547.           LOP(O_PRINT);
  548.       }
  549.       if (strEQ(d,"printf")) {
  550. !         checkcomma(s,d,"filehandle");
  551.           LOP(O_PRTF);
  552.       }
  553.       if (strEQ(d,"push")) {
  554. ***************
  555. *** 999,1018 ****
  556.       if (strEQ(d,"package"))
  557.           OPERATOR(PACKAGE);
  558.       if (strEQ(d,"pipe"))
  559. !         FOP22(O_PIPE);
  560.       break;
  561.       case 'q': case 'Q':
  562.       SNARFWORD;
  563.       if (strEQ(d,"q")) {
  564. !         s = scanstr(s-1);
  565.           TERM(RSTRING);
  566.       }
  567.       if (strEQ(d,"qq")) {
  568. !         s = scanstr(s-2);
  569.           TERM(RSTRING);
  570.       }
  571.       if (strEQ(d,"qx")) {
  572. !         s = scanstr(s-2);
  573.           TERM(RSTRING);
  574.       }
  575.       break;
  576. --- 1103,1122 ----
  577.       if (strEQ(d,"package"))
  578.           OPERATOR(PACKAGE);
  579.       if (strEQ(d,"pipe"))
  580. !         FOP22(O_PIPE_OP);
  581.       break;
  582.       case 'q': case 'Q':
  583.       SNARFWORD;
  584.       if (strEQ(d,"q")) {
  585. !         s = scanstr(s-1, SCAN_DEF);
  586.           TERM(RSTRING);
  587.       }
  588.       if (strEQ(d,"qq")) {
  589. !         s = scanstr(s-2, SCAN_DEF);
  590.           TERM(RSTRING);
  591.       }
  592.       if (strEQ(d,"qx")) {
  593. !         s = scanstr(s-2, SCAN_DEF);
  594.           TERM(RSTRING);
  595.       }
  596.       break;
  597. ***************
  598. *** 1145,1151 ****
  599.           if (strEQ(d,"socketpair"))
  600.           FOP25(O_SOCKPAIR);
  601.           if (strEQ(d,"sort")) {
  602. !         checkcomma(s,"subroutine name");
  603.           d = bufend;
  604.           while (s < d && isSPACE(*s)) s++;
  605.           if (*s == ';' || *s == ')')        /* probably a close */
  606. --- 1249,1255 ----
  607.           if (strEQ(d,"socketpair"))
  608.           FOP25(O_SOCKPAIR);
  609.           if (strEQ(d,"sort")) {
  610. !         checkcomma(s,d,"subroutine name");
  611.           d = bufend;
  612.           while (s < d && isSPACE(*s)) s++;
  613.           if (*s == ';' || *s == ')')        /* probably a close */
  614. ***************
  615. *** 1154,1159 ****
  616. --- 1258,1264 ----
  617.               /*SUPPRESS 530*/
  618.               for (d = s; isALNUM(*d); d++) ;
  619.               strncpy(tokenbuf,s,d-s);
  620. +             tokenbuf[d-s] = '\0';
  621.               if (strNE(tokenbuf,"keys") &&
  622.               strNE(tokenbuf,"values") &&
  623.               strNE(tokenbuf,"split") &&
  624. ***************
  625. *** 1324,1332 ****
  626.           FOP(O_WRITE);
  627.       break;
  628.       case 'x': case 'X':
  629. !     SNARFWORD;
  630. !     if (!expectterm && strEQ(d,"x"))
  631.           MOP(O_REPEAT);
  632.       break;
  633.       case 'y': case 'Y':
  634.       if (s[1] == '\'') {
  635. --- 1429,1444 ----
  636.           FOP(O_WRITE);
  637.       break;
  638.       case 'x': case 'X':
  639. !     if (*s == 'x' && isDIGIT(s[1]) && !expectterm) {
  640. !         s++;
  641.           MOP(O_REPEAT);
  642. +     }
  643. +     SNARFWORD;
  644. +     if (strEQ(d,"x")) {
  645. +         if (!expectterm)
  646. +         MOP(O_REPEAT);
  647. +         check_uni();
  648. +     }
  649.       break;
  650.       case 'y': case 'Y':
  651.       if (s[1] == '\'') {
  652. ***************
  653. *** 1346,1351 ****
  654. --- 1458,1472 ----
  655.       break;
  656.       }
  657.       yylval.cval = savestr(d);
  658. +     if (expectterm == 2) {        /* special case: start of statement */
  659. +     while (isSPACE(*s)) s++;
  660. +     if (*s == ':') {
  661. +         s++;
  662. +         CLINE;
  663. +         OPERATOR(LABEL);
  664. +     }
  665. +     TERM(WORD);
  666. +     }
  667.       expectterm = FALSE;
  668.       if (oldoldbufptr && oldoldbufptr < bufptr) {
  669.       while (isSPACE(*oldoldbufptr))
  670. ***************
  671. *** 1359,1376 ****
  672.   }
  673.   
  674.   void
  675. ! checkcomma(s,what)
  676.   register char *s;
  677.   char *what;
  678.   {
  679. !     char *someword;
  680.   
  681.       if (*s == '(')
  682.       s++;
  683.       while (s < bufend && isSPACE(*s))
  684.       s++;
  685.       if (isALPHA(*s) || *s == '_') {
  686. !     someword = s++;
  687.       while (isALNUM(*s))
  688.           s++;
  689.       while (s < bufend && isSPACE(*s))
  690. --- 1480,1507 ----
  691.   }
  692.   
  693.   void
  694. ! checkcomma(s,name,what)
  695.   register char *s;
  696. + char *name;
  697.   char *what;
  698.   {
  699. !     char *w;
  700.   
  701. +     if (dowarn && *s == ' ' && s[1] == '(') {
  702. +     w = index(s,')');
  703. +     if (w)
  704. +         for (w++; *w && isSPACE(*w); w++) ;
  705. +     if (!w || !*w || !index(";|}", *w))    /* an advisory hack only... */
  706. +         warn("%s (...) interpreted as function",name);
  707. +     }
  708. +     while (s < bufend && isSPACE(*s))
  709. +     s++;
  710.       if (*s == '(')
  711.       s++;
  712.       while (s < bufend && isSPACE(*s))
  713.       s++;
  714.       if (isALPHA(*s) || *s == '_') {
  715. !     w = s++;
  716.       while (isALNUM(*s))
  717.           s++;
  718.       while (s < bufend && isSPACE(*s))
  719. ***************
  720. *** 1377,1388 ****
  721.           s++;
  722.       if (*s == ',') {
  723.           *s = '\0';
  724. !         someword = instr(
  725.             "tell eof times getlogin wait length shift umask getppid \
  726.             cos exp int log rand sin sqrt ord wantarray",
  727. !           someword);
  728.           *s = ',';
  729. !         if (someword)
  730.           return;
  731.           fatal("No comma allowed after %s", what);
  732.       }
  733. --- 1508,1519 ----
  734.           s++;
  735.       if (*s == ',') {
  736.           *s = '\0';
  737. !         w = instr(
  738.             "tell eof times getlogin wait length shift umask getppid \
  739.             cos exp int log rand sin sqrt ord wantarray",
  740. !           w);
  741.           *s = ',';
  742. !         if (w)
  743.           return;
  744.           fatal("No comma allowed after %s", what);
  745.       }
  746. ***************
  747. *** 1492,1498 ****
  748.           e = d;
  749.           break;
  750.           }
  751. !         (void)bcopy(d+1,d,e-d);
  752.           e--;
  753.           switch(*d) {
  754.           case 'n':
  755. --- 1623,1629 ----
  756.           e = d;
  757.           break;
  758.           }
  759. !         Move(d+1,d,e-d,char);
  760.           e--;
  761.           switch(*d) {
  762.           case 'n':
  763. ***************
  764. *** 1626,1636 ****
  765.       }
  766.       }
  767.       if (spat->spat_flags & SPAT_FOLD)
  768. ! #ifdef STRUCTCOPY
  769. !     savespat = *spat;
  770. ! #else
  771. !     (void)bcopy((char *)spat, (char *)&savespat, sizeof(SPAT));
  772. ! #endif
  773.       scanconst(spat,str->str_ptr,len);
  774.       if ((spat->spat_flags & SPAT_ALL) && (spat->spat_flags & SPAT_SCANFIRST)) {
  775.       fbmcompile(spat->spat_short, spat->spat_flags & SPAT_FOLD);
  776. --- 1757,1763 ----
  777.       }
  778.       }
  779.       if (spat->spat_flags & SPAT_FOLD)
  780. !     StructCopy(spat, &savespat, SPAT);
  781.       scanconst(spat,str->str_ptr,len);
  782.       if ((spat->spat_flags & SPAT_ALL) && (spat->spat_flags & SPAT_SCANFIRST)) {
  783.       fbmcompile(spat->spat_short, spat->spat_flags & SPAT_FOLD);
  784. ***************
  785. *** 1642,1652 ****
  786.       }
  787.       else {
  788.       if (spat->spat_flags & SPAT_FOLD)
  789. ! #ifdef STRUCTCOPY
  790. !         *spat = savespat;
  791. ! #else
  792. !         (void)bcopy((char *)&savespat, (char *)spat, sizeof(SPAT));
  793. ! #endif
  794.       if (spat->spat_short)
  795.           fbmcompile(spat->spat_short, spat->spat_flags & SPAT_FOLD);
  796.       spat->spat_regexp = regcomp(str->str_ptr,str->str_ptr+len,
  797. --- 1769,1775 ----
  798.       }
  799.       else {
  800.       if (spat->spat_flags & SPAT_FOLD)
  801. !     StructCopy(&savespat, spat, SPAT);
  802.       if (spat->spat_short)
  803.           fbmcompile(spat->spat_short, spat->spat_flags & SPAT_FOLD);
  804.       spat->spat_regexp = regcomp(str->str_ptr,str->str_ptr+len,
  805. ***************
  806. *** 1660,1679 ****
  807.   }
  808.   
  809.   char *
  810. ! scansubst(s)
  811. ! register char *s;
  812.   {
  813.       register SPAT *spat;
  814.       register char *d;
  815.       register char *e;
  816.       int len;
  817.       STR *str = Str_new(93,0);
  818.   
  819.       Newz(802,spat,1,SPAT);
  820.       spat->spat_next = curstash->tbl_spatroot;    /* link into spat list */
  821.       curstash->tbl_spatroot = spat;
  822.   
  823. !     s = str_append_till(str,s+1,bufend,*s,patleave);
  824.       if (s >= bufend) {
  825.       str_free(str);
  826.       yyerror("Substitution pattern not terminated");
  827. --- 1783,1807 ----
  828.   }
  829.   
  830.   char *
  831. ! scansubst(start)
  832. ! char *start;
  833.   {
  834. +     register char *s = start;
  835.       register SPAT *spat;
  836.       register char *d;
  837.       register char *e;
  838.       int len;
  839.       STR *str = Str_new(93,0);
  840. +     char term = *s;
  841.   
  842. +     if (term && (d = index("([{< )]}> )]}>",term)))
  843. +     term = d[5];
  844. + 
  845.       Newz(802,spat,1,SPAT);
  846.       spat->spat_next = curstash->tbl_spatroot;    /* link into spat list */
  847.       curstash->tbl_spatroot = spat;
  848.   
  849. !     s = str_append_till(str,s+1,bufend,term,patleave);
  850.       if (s >= bufend) {
  851.       str_free(str);
  852.       yyerror("Substitution pattern not terminated");
  853. ***************
  854. *** 1712,1718 ****
  855.       }
  856.       scanconst(spat,str->str_ptr,len);
  857.   get_repl:
  858. !     s = scanstr(s);
  859.       if (s >= bufend) {
  860.       str_free(str);
  861.       yyerror("Substitution replacement not terminated");
  862. --- 1840,1848 ----
  863.       }
  864.       scanconst(spat,str->str_ptr,len);
  865.   get_repl:
  866. !     if (term != *start)
  867. !     s++;
  868. !     s = scanstr(s, SCAN_REPL);
  869.       if (s >= bufend) {
  870.       str_free(str);
  871.       yyerror("Substitution replacement not terminated");
  872. ***************
  873. *** 1736,1747 ****
  874.       }
  875.       }
  876.       while (*s == 'g' || *s == 'i' || *s == 'e' || *s == 'o') {
  877.       if (*s == 'e') {
  878.           s++;
  879.           if ((spat->spat_repl[1].arg_type & A_MASK) == A_DOUBLE)
  880.           spat->spat_repl[1].arg_type = A_SINGLE;
  881.           spat->spat_repl = make_op(
  882. !         (spat->spat_repl[1].arg_type == A_SINGLE ? O_EVALONCE : O_EVAL),
  883.           2,
  884.           spat->spat_repl,
  885.           Nullarg,
  886. --- 1866,1882 ----
  887.       }
  888.       }
  889.       while (*s == 'g' || *s == 'i' || *s == 'e' || *s == 'o') {
  890. +     int es = 0;
  891. + 
  892.       if (*s == 'e') {
  893.           s++;
  894. +         es++;
  895.           if ((spat->spat_repl[1].arg_type & A_MASK) == A_DOUBLE)
  896.           spat->spat_repl[1].arg_type = A_SINGLE;
  897.           spat->spat_repl = make_op(
  898. !         (!es && spat->spat_repl[1].arg_type == A_SINGLE
  899. !             ? O_EVALONCE
  900. !             : O_EVAL),
  901.           2,
  902.           spat->spat_repl,
  903.           Nullarg,
  904. ***************
  905. *** 1818,1853 ****
  906.   }
  907.   
  908.   char *
  909. ! expand_charset(s,len,retlen)
  910. ! register char *s;
  911. ! int len;
  912. ! int *retlen;
  913.   {
  914. !     char t[520];
  915. !     register char *d = t;
  916. !     register int i;
  917. !     register char *send = s + len;
  918. ! 
  919. !     while (s < send && d - t <= 256) {
  920. !     if (s[1] == '-' && s+2 < send) {
  921. !         for (i = (s[0] & 0377); i <= (s[2] & 0377); i++)
  922. !         *d++ = i;
  923. !         s += 3;
  924. !     }
  925. !     else
  926. !         *d++ = *s++;
  927. !     }
  928. !     *d = '\0';
  929. !     *retlen = d - t;
  930. !     return nsavestr(t,d-t);
  931. ! }
  932. ! 
  933. ! char *
  934. ! scantrans(s)
  935. ! register char *s;
  936. ! {
  937.       ARG *arg =
  938.       l(make_op(O_TRANS,2,stab2arg(A_STAB,defstab),Nullarg,Nullarg));
  939.       register char *t;
  940.       register char *r;
  941.       register short *tbl;
  942. --- 1953,1966 ----
  943.   }
  944.   
  945.   char *
  946. ! scantrans(start)
  947. ! char *start;
  948.   {
  949. !     register char *s = start;
  950.       ARG *arg =
  951.       l(make_op(O_TRANS,2,stab2arg(A_STAB,defstab),Nullarg,Nullarg));
  952. +     STR *tstr;
  953. +     STR *rstr;
  954.       register char *t;
  955.       register char *r;
  956.       register short *tbl;
  957. ***************
  958. *** 1861,1881 ****
  959.       New(803,tbl,256,short);
  960.       arg[2].arg_type = A_NULL;
  961.       arg[2].arg_ptr.arg_cval = (char*) tbl;
  962. !     s = scanstr(s);
  963.       if (s >= bufend) {
  964.       yyerror("Translation pattern not terminated");
  965.       yylval.arg = Nullarg;
  966.       return s;
  967.       }
  968. !     t = expand_charset(yylval.arg[1].arg_ptr.arg_str->str_ptr,
  969. !     yylval.arg[1].arg_ptr.arg_str->str_cur,&tlen);
  970.       arg_free(yylval.arg);
  971. !     s = scanstr(s-1);
  972.       if (s >= bufend) {
  973.       yyerror("Translation replacement not terminated");
  974.       yylval.arg = Nullarg;
  975.       return s;
  976.       }
  977.       complement = delete = squash = 0;
  978.       while (*s == 'c' || *s == 'd' || *s == 's') {
  979.       if (*s == 'c')
  980. --- 1974,2007 ----
  981.       New(803,tbl,256,short);
  982.       arg[2].arg_type = A_NULL;
  983.       arg[2].arg_ptr.arg_cval = (char*) tbl;
  984. ! 
  985. !     s = scanstr(s, SCAN_TR);
  986.       if (s >= bufend) {
  987.       yyerror("Translation pattern not terminated");
  988.       yylval.arg = Nullarg;
  989.       return s;
  990.       }
  991. !     tstr = yylval.arg[1].arg_ptr.arg_str; 
  992. !     yylval.arg[1].arg_ptr.arg_str = Nullstr; 
  993.       arg_free(yylval.arg);
  994. !     t = tstr->str_ptr;
  995. !     tlen = tstr->str_cur;
  996. ! 
  997. !     if (s[-1] == *start)
  998. !     s--;
  999. ! 
  1000. !     s = scanstr(s, SCAN_TR|SCAN_REPL);
  1001.       if (s >= bufend) {
  1002.       yyerror("Translation replacement not terminated");
  1003.       yylval.arg = Nullarg;
  1004.       return s;
  1005.       }
  1006. +     rstr = yylval.arg[1].arg_ptr.arg_str; 
  1007. +     yylval.arg[1].arg_ptr.arg_str = Nullstr; 
  1008. +     arg_free(yylval.arg);
  1009. +     r = rstr->str_ptr;
  1010. +     rlen = rstr->str_cur;
  1011. + 
  1012.       complement = delete = squash = 0;
  1013.       while (*s == 'c' || *s == 'd' || *s == 's') {
  1014.       if (*s == 'c')
  1015. ***************
  1016. *** 1886,1900 ****
  1017.           squash = 1;
  1018.       s++;
  1019.       }
  1020. -     r = expand_charset(yylval.arg[1].arg_ptr.arg_str->str_ptr,
  1021. -     yylval.arg[1].arg_ptr.arg_str->str_cur,&rlen);
  1022. -     arg_free(yylval.arg);
  1023.       arg[2].arg_len = delete|squash;
  1024.       yylval.arg = arg;
  1025. -     if (!rlen && !delete) {
  1026. -     Safefree(r);
  1027. -     r = t; rlen = tlen;
  1028. -     }
  1029.       if (complement) {
  1030.       Zero(tbl, 256, short);
  1031.       for (i = 0; i < tlen; i++)
  1032. --- 2012,2019 ----
  1033. ***************
  1034. *** 1904,1918 ****
  1035.           if (j >= rlen) {
  1036.               if (delete)
  1037.               tbl[i] = -2;
  1038.               else
  1039. !             tbl[i] = r[j-1];
  1040.           }
  1041.           else
  1042. !             tbl[i] = r[j++];
  1043.           }
  1044.       }
  1045.       }
  1046.       else {
  1047.       for (i = 0; i < 256; i++)
  1048.           tbl[i] = -1;
  1049.       for (i = 0, j = 0; i < tlen; i++,j++) {
  1050. --- 2023,2042 ----
  1051.           if (j >= rlen) {
  1052.               if (delete)
  1053.               tbl[i] = -2;
  1054. +             else if (rlen)
  1055. +             tbl[i] = r[j-1] & 0377;
  1056.               else
  1057. !             tbl[i] = i;
  1058.           }
  1059.           else
  1060. !             tbl[i] = r[j++] & 0377;
  1061.           }
  1062.       }
  1063.       }
  1064.       else {
  1065. +     if (!rlen && !delete) {
  1066. +         r = t; rlen = tlen;
  1067. +     }
  1068.       for (i = 0; i < 256; i++)
  1069.           tbl[i] = -1;
  1070.       for (i = 0, j = 0; i < tlen; i++,j++) {
  1071. ***************
  1072. *** 1928,1943 ****
  1073.           tbl[t[i] & 0377] = r[j] & 0377;
  1074.       }
  1075.       }
  1076. !     if (r != t)
  1077. !     Safefree(r);
  1078. !     Safefree(t);
  1079.       return s;
  1080.   }
  1081.   
  1082.   char *
  1083. ! scanstr(s)
  1084. ! register char *s;
  1085.   {
  1086.       register char term;
  1087.       register char *d;
  1088.       register ARG *arg;
  1089. --- 2052,2068 ----
  1090.           tbl[t[i] & 0377] = r[j] & 0377;
  1091.       }
  1092.       }
  1093. !     str_free(tstr);
  1094. !     str_free(rstr);
  1095.       return s;
  1096.   }
  1097.   
  1098.   char *
  1099. ! scanstr(start, in_what)
  1100. ! char *start;
  1101. ! int in_what;
  1102.   {
  1103. +     register char *s = start;
  1104.       register char term;
  1105.       register char *d;
  1106.       register ARG *arg;
  1107. ***************
  1108. *** 1948,1954 ****
  1109.       bool hereis = FALSE;
  1110.       STR *herewas;
  1111.       STR *str;
  1112. !     char *leave = "\\$@nrtfbeacx0123456789[{]}lLuUE"; /* which backslash sequences to keep */
  1113.       int len;
  1114.   
  1115.       arg = op_new(1);
  1116. --- 2073,2082 ----
  1117.       bool hereis = FALSE;
  1118.       STR *herewas;
  1119.       STR *str;
  1120. !     /* which backslash sequences to keep */
  1121. !     char *leave = (in_what & SCAN_TR)
  1122. !     ? "\\$@nrtfbeacx0123456789-"
  1123. !     : "\\$@nrtfbeacx0123456789[{]}lLuUE";
  1124.       int len;
  1125.   
  1126.       arg = op_new(1);
  1127. ***************
  1128. *** 2025,2031 ****
  1129.           else
  1130.           *d++ = *s++;
  1131.       }
  1132. !     if (*s == '.' && s[1] && index("0123456789eE ;",s[1])) {
  1133.           *d++ = *s++;
  1134.           while (isDIGIT(*s) || *s == '_') {
  1135.           if (*s == '_')
  1136. --- 2153,2159 ----
  1137.           else
  1138.           *d++ = *s++;
  1139.       }
  1140. !     if (*s == '.' && s[1] != '.') {
  1141.           *d++ = *s++;
  1142.           while (isDIGIT(*s) || *s == '_') {
  1143.           if (*s == '_')
  1144. ***************
  1145. *** 2052,2057 ****
  1146. --- 2180,2187 ----
  1147.       arg[1].arg_ptr.arg_str = str;
  1148.       break;
  1149.       case '<':
  1150. +     if (in_what & (SCAN_REPL|SCAN_TR))
  1151. +         goto do_double;
  1152.       if (*++s == '<') {
  1153.           hereis = TRUE;
  1154.           d = tokenbuf;
  1155. ***************
  1156. *** 2091,2108 ****
  1157.       s = cpytill(d,s,bufend,'>',&len);
  1158.       if (s < bufend)
  1159.           s++;
  1160.       if (*d == '$') d++;
  1161.       while (*d && (isALNUM(*d) || *d == '\''))
  1162.           d++;
  1163.       if (d - tokenbuf != len) {
  1164. !         d = tokenbuf;
  1165.           arg[1].arg_type = A_GLOB;
  1166. -         d = nsavestr(d,len);
  1167. -         arg[1].arg_ptr.arg_stab = stab = genstab();
  1168. -         stab_io(stab) = stio_new();
  1169. -         stab_val(stab) = str_make(d,len);
  1170. -         Safefree(d);
  1171.           set_csh();
  1172.       }
  1173.       else {
  1174.           d = tokenbuf;
  1175. --- 2221,2239 ----
  1176.       s = cpytill(d,s,bufend,'>',&len);
  1177.       if (s < bufend)
  1178.           s++;
  1179. +     else
  1180. +         fatal("Unterminated <> operator");
  1181. + 
  1182.       if (*d == '$') d++;
  1183.       while (*d && (isALNUM(*d) || *d == '\''))
  1184.           d++;
  1185.       if (d - tokenbuf != len) {
  1186. !         s = start;
  1187. !         term = *s;
  1188.           arg[1].arg_type = A_GLOB;
  1189.           set_csh();
  1190. +         alwaysdollar = TRUE;    /* treat $) and $| as variables */
  1191. +         goto snarf_it;
  1192.       }
  1193.       else {
  1194.           d = tokenbuf;
  1195. ***************
  1196. *** 2160,2165 ****
  1197. --- 2291,2297 ----
  1198.         snarf_it:
  1199.       {
  1200.           STR *tmpstr;
  1201. +         STR *tmpstr2 = Nullstr;
  1202.           char *tmps;
  1203.   
  1204.           CLINE;
  1205. ***************
  1206. *** 2235,2241 ****
  1207.           tmpstr->str_len = tmpstr->str_cur + 1;
  1208.           Renew(tmpstr->str_ptr, tmpstr->str_len, char);
  1209.           }
  1210. !         if ((arg[1].arg_type & A_MASK) == A_SINGLE) {
  1211.           arg[1].arg_ptr.arg_str = tmpstr;
  1212.           break;
  1213.           }
  1214. --- 2367,2373 ----
  1215.           tmpstr->str_len = tmpstr->str_cur + 1;
  1216.           Renew(tmpstr->str_ptr, tmpstr->str_len, char);
  1217.           }
  1218. !         if (arg[1].arg_type == A_SINGLE) {
  1219.           arg[1].arg_ptr.arg_str = tmpstr;
  1220.           break;
  1221.           }
  1222. ***************
  1223. *** 2259,2280 ****
  1224.           }
  1225.           s = d = tmpstr->str_ptr;    /* assuming shrinkage only */
  1226.           while (s < send) {
  1227. !         if ((*s == '$' && s+1 < send &&
  1228. !             (alwaysdollar || /*(*/ (s[1] != ')' && s[1] != '|')) ) ||
  1229. !             (*s == '@' && s+1 < send) ) {
  1230. !             if (s[1] == '#' && (isALPHA(s[2]) || s[2] == '_'))
  1231. !             *d++ = *s++;
  1232. !             len = scanident(s,send,tokenbuf) - s;
  1233. !             if (*s == '$' || strEQ(tokenbuf,"ARGV")
  1234. !               || strEQ(tokenbuf,"ENV")
  1235. !               || strEQ(tokenbuf,"SIG")
  1236. !               || strEQ(tokenbuf,"INC") )
  1237. !             (void)stabent(tokenbuf,TRUE); /* make sure it exists */
  1238. !             while (len--)
  1239. !             *d++ = *s++;
  1240. !             continue;
  1241.           }
  1242. !         else if (*s == '\\' && s+1 < send) {
  1243.               s++;
  1244.               switch (*s) {
  1245.               default:
  1246. --- 2391,2431 ----
  1247.           }
  1248.           s = d = tmpstr->str_ptr;    /* assuming shrinkage only */
  1249.           while (s < send) {
  1250. !         if (in_what & SCAN_TR) {
  1251. !             if (*s != '\\' && s[1] == '-' && s+2 < send) {
  1252. !             int i;
  1253. !             if (!tmpstr2) {    /* oops, have to grow */
  1254. !                 tmpstr2 = str_smake(tmpstr);
  1255. !                 s = tmpstr2->str_ptr + (s - tmpstr->str_ptr);
  1256. !                 send = tmpstr2->str_ptr + (send - tmpstr->str_ptr);
  1257. !             }
  1258. !             i = d - tmpstr->str_ptr;
  1259. !             STR_GROW(tmpstr, tmpstr->str_len + 256);
  1260. !             d = tmpstr->str_ptr + i;
  1261. !             for (i = (s[0] & 0377); i <= (s[2] & 0377); i++)
  1262. !                 *d++ = i;
  1263. !             s += 3;
  1264. !             continue;
  1265. !             }
  1266.           }
  1267. !         else {
  1268. !             if ((*s == '$' && s+1 < send &&
  1269. !             (alwaysdollar || /*(*/(s[1] != ')' && s[1] != '|')) ) ||
  1270. !             (*s == '@' && s+1 < send) ) {
  1271. !             if (s[1] == '#' && (isALPHA(s[2]) || s[2] == '_'))
  1272. !                 *d++ = *s++;
  1273. !             len = scanident(s,send,tokenbuf) - s;
  1274. !             if (*s == '$' || strEQ(tokenbuf,"ARGV")
  1275. !               || strEQ(tokenbuf,"ENV")
  1276. !               || strEQ(tokenbuf,"SIG")
  1277. !               || strEQ(tokenbuf,"INC") )
  1278. !                 (void)stabent(tokenbuf,TRUE); /* add symbol */
  1279. !             while (len--)
  1280. !                 *d++ = *s++;
  1281. !             continue;
  1282. !             }
  1283. !         }
  1284. !         if (*s == '\\' && s+1 < send) {
  1285.               s++;
  1286.               switch (*s) {
  1287.               default:
  1288. ***************
  1289. *** 2327,2338 ****
  1290.           }
  1291.           *d = '\0';
  1292.   
  1293. !         if ((arg[1].arg_type & A_MASK) == A_DOUBLE && makesingle)
  1294. !             arg[1].arg_type = A_SINGLE;    /* now we can optimize on it */
  1295.   
  1296.           tmpstr->str_cur = d - tmpstr->str_ptr;
  1297. !         arg[1].arg_ptr.arg_str = tmpstr;
  1298.           s = tmps;
  1299.           break;
  1300.       }
  1301.       }
  1302. --- 2478,2497 ----
  1303.           }
  1304.           *d = '\0';
  1305.   
  1306. !         if (arg[1].arg_type == A_DOUBLE && makesingle)
  1307. !         arg[1].arg_type = A_SINGLE;    /* now we can optimize on it */
  1308.   
  1309.           tmpstr->str_cur = d - tmpstr->str_ptr;
  1310. !         if (arg[1].arg_type == A_GLOB) {
  1311. !         arg[1].arg_ptr.arg_stab = stab = genstab();
  1312. !         stab_io(stab) = stio_new();
  1313. !         str_sset(stab_val(stab), tmpstr);
  1314. !         }
  1315. !         else
  1316. !         arg[1].arg_ptr.arg_str = tmpstr;
  1317.           s = tmps;
  1318. +         if (tmpstr2)
  1319. +         str_free(tmpstr2);
  1320.           break;
  1321.       }
  1322.       }
  1323. ***************
  1324. *** 2564,2569 ****
  1325. --- 2723,2729 ----
  1326.       return froot.f_next;
  1327.   }
  1328.   
  1329. + static void
  1330.   set_csh()
  1331.   {
  1332.   #ifdef CSH
  1333.  
  1334. Index: atarist/wildmat.c
  1335. *** atarist/wildmat.c.old    Mon Jun  8 17:45:40 1992
  1336. --- atarist/wildmat.c    Mon Jun  8 17:45:41 1992
  1337. ***************
  1338. *** 0 ****
  1339. --- 1,507 ----
  1340. + /*  $Revision: 4.0.1.1 $
  1341. + **
  1342. + **  Do shell-style pattern matching for ?, \, [], and * characters.
  1343. + **  Might not be robust in face of malformed patterns; e.g., "foo[a-"
  1344. + **  could cause a segmentation violation.  It is 8bit clean.
  1345. + **
  1346. + **  Written by Rich $alz, mirror!rs, Wed Nov 26 19:03:17 EST 1986.
  1347. + **  Rich $alz is now <rsalz@bbn.com>.
  1348. + **  April, 1991:  Replaced mutually-recursive calls with in-line code
  1349. + **  for the star character.
  1350. + **
  1351. + **  Special thanks to Lars Mathiesen <thorinn@diku.dk> for the ABORT code.
  1352. + **  This can greatly speed up failing wildcard patterns.  For example:
  1353. + **    pattern: -*-*-*-*-*-*-12-*-*-*-m-*-*-*
  1354. + **    text 1:     -adobe-courier-bold-o-normal--12-120-75-75-m-70-iso8859-1
  1355. + **    text 2:     -adobe-courier-bold-o-normal--12-120-75-75-X-70-iso8859-1
  1356. + **  Text 1 matches with 51 calls, while text 2 fails with 54 calls.  Without
  1357. + **  the ABORT, then it takes 22310 calls to fail.  Ugh.  The following
  1358. + **  explanation is from Lars:
  1359. + **  The precondition that must be fulfilled is that DoMatch will consume
  1360. + **  at least one character in text.  This is true if *p is neither '*' nor
  1361. + **  '\0'.)  The last return has ABORT instead of FALSE to avoid quadratic
  1362. + **  behaviour in cases like pattern "*a*b*c*d" with text "abcxxxxx".  With
  1363. + **  FALSE, each star-loop has to run to the end of the text; with ABORT
  1364. + **  only the last one does.
  1365. + **
  1366. + **  Once the control of one instance of DoMatch enters the star-loop, that
  1367. + **  instance will return either TRUE or ABORT, and any calling instance
  1368. + **  will therefore return immediately after (without calling recursively
  1369. + **  again).  In effect, only one star-loop is ever active.  It would be
  1370. + **  possible to modify the code to maintain this context explicitly,
  1371. + **  eliminating all recursive calls at the cost of some complication and
  1372. + **  loss of clarity (and the ABORT stuff seems to be unclear enough by
  1373. + **  itself).  I think it would be unwise to try to get this into a
  1374. + **  released version unless you have a good test data base to try it out
  1375. + **  on.
  1376. + */
  1377. + 
  1378. + #define TRUE            1
  1379. + #define FALSE            0
  1380. + #define ABORT            -1
  1381. + 
  1382. + 
  1383. +     /* What character marks an inverted character class? */
  1384. + #define NEGATE_CLASS        '^'
  1385. +     /* Is "*" a common pattern? */
  1386. + #define OPTIMIZE_JUST_STAR
  1387. +     /* Do tar(1) matching rules, which ignore a trailing slash? */
  1388. + #undef MATCH_TAR_PATTERN
  1389. + 
  1390. + 
  1391. + /*
  1392. + **  Match text and p, return TRUE, FALSE, or ABORT.
  1393. + */
  1394. + static int
  1395. + DoMatch(text, p)
  1396. +     char    *text;
  1397. +     char    *p;
  1398. + {
  1399. +     int    last;
  1400. +     int    matched;
  1401. +     int    reverse;
  1402. + 
  1403. +     for ( ; *p; text++, p++) {
  1404. +     if (*text == '\0' && *p != '*')
  1405. +         return ABORT;
  1406. +     switch (*p) {
  1407. +     case '\\':
  1408. +         /* Literal match with following character. */
  1409. +         p++;
  1410. +         /* FALLTHROUGH */
  1411. +     default:
  1412. +         if (*text != *p)
  1413. +         return FALSE;
  1414. +         continue;
  1415. +     case '?':
  1416. +         /* Match anything. */
  1417. +         continue;
  1418. +     case '*':
  1419. +         while (*++p == '*')
  1420. +         /* Consecutive stars act just like one. */
  1421. +         continue;
  1422. +         if (*p == '\0')
  1423. +         /* Trailing star matches everything. */
  1424. +         return TRUE;
  1425. +         while (*text)
  1426. +         if ((matched = DoMatch(text++, p)) != FALSE)
  1427. +             return matched;
  1428. +         return ABORT;
  1429. +     case '[':
  1430. +         reverse = p[1] == NEGATE_CLASS ? TRUE : FALSE;
  1431. +         if (reverse)
  1432. +         /* Inverted character class. */
  1433. +         p++;
  1434. +         for (last = 0400, matched = FALSE; *++p && *p != ']'; last = *p)
  1435. +         /* This next line requires a good C compiler. */
  1436. +         if (*p == '-' ? *text <= *++p && *text >= last : *text == *p)
  1437. +             matched = TRUE;
  1438. +         if (matched == reverse)
  1439. +         return FALSE;
  1440. +         continue;
  1441. +     }
  1442. +     }
  1443. + 
  1444. + #ifdef    MATCH_TAR_PATTERN
  1445. +     if (*text == '/')
  1446. +     return TRUE;
  1447. + #endif    /* MATCH_TAR_ATTERN */
  1448. +     return *text == '\0';
  1449. + }
  1450. + 
  1451. + 
  1452. + /*
  1453. + **  User-level routine.  Returns TRUE or FALSE.
  1454. + */
  1455. + int
  1456. + wildmat(text, p)
  1457. +     char    *text;
  1458. +     char    *p;
  1459. + {
  1460. + #ifdef    OPTIMIZE_JUST_STAR
  1461. +     if (p[0] == '*' && p[1] == '\0')
  1462. +     return TRUE;
  1463. + #endif    /* OPTIMIZE_JUST_STAR */
  1464. +     return DoMatch(text, p) == TRUE;
  1465. + }
  1466. + 
  1467. + #include <stdio.h>
  1468. + #include <sys/types.h>
  1469. + #include <dirent.h>
  1470. + #include <sys/stat.h>
  1471. + #if __STDC__
  1472. + #ifdef unix
  1473. + #define _SIZE_T    /* unix defines size_t in sys/types.h */
  1474. + #endif
  1475. + #ifndef _COMPILER_H
  1476. + #  include <compiler.h>
  1477. + #endif
  1478. + #include <stddef.h>
  1479. + #include <stdlib.h>
  1480. + #else
  1481. + extern char *malloc(), *realloc();
  1482. + extern char *rindex(),  *strdup();
  1483. + #define __PROTO(x) ()
  1484. + #endif
  1485. + #include <string.h>
  1486. + 
  1487. + #define MAX_DIR    32    /* max depth of dir recursion */
  1488. + static struct {
  1489. +     char *dir, *patt;
  1490. + } dir_stack[MAX_DIR];
  1491. + static int stack_p;
  1492. + static char **matches;
  1493. + static int nmatches;
  1494. + 
  1495. + static void *ck_memalloc __PROTO((void *));
  1496. + #define ck_strdup(p) ck_memalloc(strdup(p))
  1497. + #define ck_malloc(s) ck_memalloc(malloc(s))
  1498. + #define ck_realloc(p, s) ck_memalloc(realloc(p, s))
  1499. + 
  1500. + 
  1501. + #define DEBUGX(x) 
  1502. + 
  1503. + /*
  1504. +  * return true if patt contains a wildcard char
  1505. +  */
  1506. + int contains_wild(patt)
  1507. + char *patt;
  1508. + {
  1509. +     char c;
  1510. +     char *p;
  1511. + 
  1512. +     /* only check for wilds in the basename part of the pathname only */
  1513. +     if((p = rindex(patt, '/')) == NULL)
  1514. +     p = rindex(patt, '\\');
  1515. +     if(!p)
  1516. +     p = patt;
  1517. + 
  1518. +     while((c = *p++))
  1519. +     if((c == '*') || (c == '?') || (c == '['))
  1520. +         return 1;
  1521. +     return 0;
  1522. + }
  1523. + 
  1524. + #ifndef ZOO
  1525. + void free_all()
  1526. + {
  1527. +     char **p;
  1528. + 
  1529. +     if(!matches)
  1530. +     return;
  1531. + 
  1532. +     for(p = matches; *p; p++)
  1533. +     free(*p);
  1534. +     free(matches);
  1535. +     matches = NULL;
  1536. + }
  1537. + #endif
  1538. + 
  1539. + static void push(dir, patt)
  1540. + char *dir;
  1541. + char *patt;
  1542. + {
  1543. +     if(stack_p < (MAX_DIR - 2))
  1544. +     stack_p++;
  1545. +     else
  1546. +     {
  1547. +     fprintf(stderr,"directory stack overflow\n");
  1548. +     exit(99);
  1549. +     }
  1550. +     dir_stack[stack_p].dir = dir;
  1551. +     dir_stack[stack_p].patt = patt;
  1552. + }
  1553. + 
  1554. + /*
  1555. +  * glob patt
  1556. +  * if decend_dir is true, recursively decend any directories encountered.
  1557. +  * returns pointer to all matches encountered.
  1558. +  * if the initial patt is a directory, and decend_dir is true, it is
  1559. +  * equivalent to specifying the pattern "patt\*"
  1560. +  *
  1561. +  * Restrictions:
  1562. +  *  - handles wildcards only in the base part of a pathname
  1563. +  *    ie: will not handle \foo\*\bar\ (wildcard in the middle of pathname)
  1564. +  *
  1565. +  *  - max dir recursion is MAX_DIR
  1566. +  *
  1567. +  *  - on certain failures it will just skip potential matches as if they
  1568. +  *    were not present.
  1569. +  *
  1570. +  *  ++jrb    bammi@cadence.com
  1571. +  */
  1572. + static char **do_match __PROTO((int decend_dir));
  1573. + 
  1574. + char **glob(patt, decend_dir)
  1575. + char *patt;
  1576. + int decend_dir;
  1577. + {
  1578. +     char *dir, *basepatt, *p;
  1579. +     struct stat s;
  1580. + 
  1581. +     DEBUGX((fprintf(stderr,"glob(%s, %d)\n", patt, decend_dir)));
  1582. +     matches = NULL;
  1583. +     nmatches = 0;
  1584. +     stack_p = -1;
  1585. + 
  1586. +     /* first check for wildcards */
  1587. +     if(contains_wild(patt))
  1588. +     {
  1589. +     /* break it up into dir and base patt, do_matches and return */
  1590. +     p = ck_strdup(patt);
  1591. +     if((basepatt = rindex(p, '/')) == NULL)
  1592. +         basepatt = rindex(p, '\\');
  1593. +         if(basepatt)
  1594. +         {
  1595. +         dir = p;
  1596. +         *basepatt++ = '\0';
  1597. +         basepatt = ck_strdup(basepatt);
  1598. +         }
  1599. +         else
  1600. +         {
  1601. +         dir = ck_strdup(".");
  1602. +         basepatt = p;
  1603. +         }
  1604. + 
  1605. +         if(strcmp(basepatt, "*.*") == 0)
  1606. +         {
  1607. +             /* the desktop, and other braindead shells strike again */
  1608. +             basepatt[1] = '\0';
  1609. +         }
  1610. +     push(dir, basepatt);
  1611. +     DEBUGX((fprintf(stderr, "calling %s, %s\n", dir, basepatt)));
  1612. +     return do_match(decend_dir);
  1613. +     }
  1614. + 
  1615. +     /* if no wilds, check for dir */
  1616. +     if(decend_dir && (!stat(patt, &s)))
  1617. +     {
  1618. +     if((s.st_mode & S_IFMT) == S_IFDIR)
  1619. +     {   /* is a dir */
  1620. +         size_t len = strlen(patt);
  1621. +         
  1622. +         dir = ck_strdup(patt);
  1623. +         --len;
  1624. +         if(len && ((dir[len] == '/') 
  1625. + #ifdef atarist
  1626. +            || (dir[len] == '\\')
  1627. + #endif
  1628. +          ))
  1629. +         dir[len] = '\0';
  1630. +         basepatt = ck_strdup("*");
  1631. +         push(dir, basepatt);
  1632. +         DEBUGX((fprintf(stderr, "calling %s, %s\n", dir, basepatt)));
  1633. +         return do_match(decend_dir);
  1634. +         }
  1635. +     }
  1636. +     return NULL;
  1637. + }
  1638. + 
  1639. + static char **do_match(decend_dir)
  1640. + int decend_dir;
  1641. + {
  1642. +     DIR *dirp;
  1643. +     struct dirent *d;
  1644. +     struct stat s;
  1645. +     char *dir, *basepatt;
  1646. + 
  1647. +     while(stack_p >= 0)
  1648. +     {
  1649. +     dir = ck_strdup(dir_stack[stack_p].dir); 
  1650. +     free(dir_stack[stack_p].dir);
  1651. +         basepatt = ck_strdup(dir_stack[stack_p].patt);
  1652. +     free(dir_stack[stack_p--].patt);
  1653. +     
  1654. +         DEBUGX((fprintf(stderr,"dir %s patt %s stack %d\n", dir, basepatt, stack_p)));
  1655. + 
  1656. +         dirp = opendir(dir);
  1657. +     if(!dirp)
  1658. +     {
  1659. +         free(dir);
  1660. +         DEBUGX((fprintf(stderr,"no dir\n")));
  1661. +         continue;
  1662. +         }
  1663. +     
  1664. +         while((d = readdir(dirp)))
  1665. +         {
  1666. +         char *p = ck_malloc(strlen(dir) + strlen(d->d_name) + 2L);
  1667. +             if(strcmp(dir, "."))
  1668. +                                      /* If we have a full pathname then */
  1669. +         {                 /* let's append the directory info */
  1670. +         strcpy(p, dir);
  1671. + #ifndef unix
  1672. +         strcat(p, "\\");
  1673. + #else
  1674. +         strcat(p, "/");
  1675. + #endif
  1676. +         strcat(p, d->d_name);
  1677. +         }
  1678. +         else              /* Otherwise, the name is just fine, */
  1679. +         strcpy(p, d->d_name); /* there's no need for './' -- bjsjr */
  1680. + 
  1681. +         DEBUGX((fprintf(stderr, "Testing %s\n", p)));
  1682. +         if(!stat(p, &s))    /* if stat fails, ignore it */
  1683. +             {
  1684. +             if( ((s.st_mode & S_IFMT) == S_IFREG) ||
  1685. +             ((s.st_mode & S_IFMT) == S_IFLNK) )
  1686. +             {  /* it is a file/symbolic link */
  1687. +             if(wildmat(d->d_name, basepatt))
  1688. +             {  /* it matches pattern */
  1689. +             DEBUGX((fprintf(stderr,"File Matched\n")));
  1690. +             if(matches == NULL)
  1691. +                 matches = (char **)ck_malloc(sizeof(char *));
  1692. +             else
  1693. +                 matches = (char **)
  1694. +                   ck_realloc(matches, (nmatches+1)*sizeof(char *)); 
  1695. +             matches[nmatches++] = p;
  1696. +             } /* no match */
  1697. +             else
  1698. +             {
  1699. +             DEBUGX((fprintf(stderr,"No File Match\n")));
  1700. +                 free(p);
  1701. +             }
  1702. +         } else if(decend_dir && ((s.st_mode & S_IFMT) == S_IFDIR))
  1703. +         {
  1704. +             if(!((!strcmp(d->d_name,".")) || (!strcmp(d->d_name, "..")
  1705. + #ifdef atarist
  1706. +                      || (!strcmp(d->d_name, ".dir"))
  1707. + #endif
  1708. +                 )))
  1709. +             {
  1710. +             char *push_p = ck_strdup("*");
  1711. +             push(p, push_p);
  1712. +             DEBUGX((fprintf(stderr,"Dir pushed\n")));
  1713. +             }
  1714. +             else
  1715. +             {
  1716. +             DEBUGX((fprintf(stderr, "DIR skipped\n")));
  1717. +             free(p);
  1718. +             }
  1719. +             }
  1720. +         else
  1721. +         {
  1722. +             DEBUGX((fprintf(stderr, "Not a dir/no decend\n")));
  1723. +             free(p);
  1724. +         }
  1725. +         } /* stat */
  1726. +         else
  1727. +         {
  1728. +         DEBUGX((fprintf(stderr, "Stat failed\n")));
  1729. +         free(p);
  1730. +         }
  1731. +         } /* while readdir */
  1732. +         closedir(dirp);
  1733. +     free(basepatt);
  1734. +     free(dir);
  1735. +     DEBUGX((fprintf(stderr, "Dir done\n\n")));
  1736. +     } /* while dirs in stack */
  1737. +     
  1738. +     if(!nmatches)
  1739. +     {
  1740. +     DEBUGX((fprintf(stderr, "No matches\n")));
  1741. +     return NULL;
  1742. +     }
  1743. +     
  1744. +     matches = (char **)realloc(matches, (nmatches+1)*sizeof(char *));
  1745. +     if(!matches)
  1746. +     {  return NULL; }
  1747. +     matches[nmatches] = NULL;
  1748. +     DEBUGX((fprintf(stderr, "%d matches\n", nmatches)));    
  1749. +     return matches;
  1750. + }
  1751. + 
  1752. + #ifdef ZOO
  1753. + #include "errors.i"
  1754. + #endif
  1755. + 
  1756. + static void *ck_memalloc(p)
  1757. + void *p;
  1758. + {
  1759. +     if(!p)
  1760. +     {
  1761. + #ifndef ZOO
  1762. +         fprintf(stderr, "Out of memory\n");
  1763. +     exit(98);
  1764. + #else
  1765. +         prterror('f', no_memory);
  1766. + #endif
  1767. +     }
  1768. +     return p;
  1769. + }
  1770. + 
  1771. + #ifdef TEST_GLOB
  1772. + void test(path, dec)
  1773. + char *path;
  1774. + int dec;
  1775. + {
  1776. +     char **m;
  1777. +     char **matches;
  1778. + 
  1779. +     printf("Testing %s %d\n", path, dec);
  1780. +     matches = glob(path, dec);
  1781. +     if(!matches)
  1782. +     {
  1783. +     printf("No matches\n");
  1784. +     }
  1785. +     else
  1786. +     {
  1787. +         for(m = matches; *m; m++)
  1788. +         printf("%s\n", *m);
  1789. +     putchar('\n');
  1790. +         free_all();
  1791. +     }
  1792. + }
  1793. + 
  1794. + int main()
  1795. + {
  1796. + #ifndef unix
  1797. +     test("e:\\lib\\*.olb", 0);
  1798. +     test("e:\\lib", 0);
  1799. +     test("e:\\lib\\", 1);
  1800. + #else
  1801. +     test("/net/acae127/home/bammi/News/comp.sources.misc/*.c", 0);
  1802. +     test("/net/acae127/home/bammi/News/comp.sources.misc", 0);
  1803. +     test("/net/acae127/home/bammi/News/comp.sources.misc", 1);
  1804. +     test("/net/acae127/home/bammi/atari/cross-gcc", 1);
  1805. + #endif
  1806. +     
  1807. +     return 0;
  1808. + }
  1809. + 
  1810. + #endif
  1811. + 
  1812. + #ifdef    TEST_WILDMAT
  1813. + #include <stdio.h>
  1814. + 
  1815. + /* Yes, we use gets not fgets.  Sue me. */
  1816. + extern char    *gets();
  1817. + 
  1818. + 
  1819. + main()
  1820. + {
  1821. +     char    pattern[80];
  1822. +     char    text[80];
  1823. + 
  1824. +     printf("Wildmat tester.  Enter pattern, then strings to test.\n");
  1825. +     printf("A blank line gets prompts for a new pattern; a blank pattern\n");
  1826. +     printf("exits the program.\n\n");
  1827. + 
  1828. +     for ( ; ; ) {
  1829. +     printf("Enter pattern:  ");
  1830. +     if (gets(pattern) == NULL)
  1831. +         break;
  1832. +     for ( ; ; ) {
  1833. +         printf("Enter text:  ");
  1834. +         if (gets(text) == NULL)
  1835. +         exit(0);
  1836. +         if (text[0] == '\0')
  1837. +         /* Blank line; go back and get a new pattern. */
  1838. +         break;
  1839. +         printf("      %s\n", wildmat(text, pattern) ? "YES" : "NO");
  1840. +     }
  1841. +     }
  1842. + 
  1843. +     exit(0);
  1844. +     /* NOTREACHED */
  1845. + }
  1846. + #endif    /* TEST_WILDMAT */
  1847.  
  1848. *** End of Patch 33 ***
  1849. exit 0 # Just in case...
  1850.