home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / misc / volume25 / perl / patch13 < prev    next >
Encoding:
Text File  |  1991-11-13  |  48.1 KB  |  2,015 lines
  1. Newsgroups: comp.sources.misc
  2. From: lwall@netlabs.com (Larry Wall)
  3. Subject:  v25i062:  perl - The perl programming language, Patch13
  4. Message-ID: <1991Nov13.214304.3635@sparky.imd.sterling.com>
  5. X-Md4-Signature: 17152091640fcdfbbad255056f547d34
  6. Date: Wed, 13 Nov 1991 21:43:04 GMT
  7. Approved: kent@sparky.imd.sterling.com
  8.  
  9. Submitted-by: lwall@netlabs.com (Larry Wall)
  10. Posting-number: Volume 25, Issue 62
  11. Archive-name: perl/patch13
  12. Environment: UNIX, MS-DOS, OS2
  13. Patch-To: perl: Volume 18, Issue 19-54
  14.  
  15. System: perl version 4.0
  16. Patch #: 13
  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: 12
  56. 1c1
  57. < #define PATCHLEVEL 12
  58. ---
  59. > #define PATCHLEVEL 13
  60.  
  61. Index: config_h.SH
  62. *** config_h.SH.old    Tue Nov  5 19:25:44 1991
  63. --- config_h.SH    Tue Nov  5 19:25:45 1991
  64. ***************
  65. *** 24,29 ****
  66. --- 24,30 ----
  67.    * that running config.h.SH again will wipe out any changes you've made.
  68.    * For a more permanent change edit config.sh and rerun config.h.SH.
  69.    */
  70. +  /*SUPPRESS 460*/
  71.   
  72.   
  73.   /* EUNICE
  74. ***************
  75. *** 55,61 ****
  76.   
  77.   /* BYTEORDER
  78.    *    This symbol contains an encoding of the order of bytes in a long.
  79. !  *    Usual values (in octal) are 01234, 04321, 02143, 03412...
  80.    */
  81.   #define BYTEORDER 0x$byteorder        /**/
  82.   
  83. --- 56,62 ----
  84.   
  85.   /* BYTEORDER
  86.    *    This symbol contains an encoding of the order of bytes in a long.
  87. !  *    Usual values (in hex) are 0x1234, 0x4321, 0x2143, 0x3412...
  88.    */
  89.   #define BYTEORDER 0x$byteorder        /**/
  90.   
  91. ***************
  92. *** 752,760 ****
  93. --- 753,766 ----
  94.   #$i_my_dir    I_MY_DIR    /**/
  95.   #$d_dirnamlen    DIRNAMLEN    /**/
  96.   
  97. + /* MYMALLOC
  98. +  *    This symbol, if defined, indicates that we're using our own malloc.
  99. +  */
  100.   /* MALLOCPTRTYPE
  101.    *    This symbol defines the kind of ptr returned by malloc and realloc.
  102.    */
  103. + #$d_mymalloc MYMALLOC            /**/
  104. + 
  105.   #define MALLOCPTRTYPE $mallocptrtype         /**/
  106.   
  107.   
  108.  
  109. Index: cons.c
  110. *** cons.c.old    Tue Nov  5 19:25:47 1991
  111. --- cons.c    Tue Nov  5 19:25:48 1991
  112. ***************
  113. *** 1,4 ****
  114. ! /* $RCSfile: cons.c,v $$Revision: 4.0.1.1 $$Date: 91/06/07 10:31:15 $
  115.    *
  116.    *    Copyright (c) 1991, Larry Wall
  117.    *
  118. --- 1,4 ----
  119. ! /* $RCSfile: cons.c,v $$Revision: 4.0.1.2 $$Date: 91/11/05 16:15:13 $
  120.    *
  121.    *    Copyright (c) 1991, Larry Wall
  122.    *
  123. ***************
  124. *** 6,11 ****
  125. --- 6,15 ----
  126.    *    License or the Artistic License, as specified in the README file.
  127.    *
  128.    * $Log:    cons.c,v $
  129. +  * Revision 4.0.1.2  91/11/05  16:15:13  lwall
  130. +  * patch11: debugger got confused over nested subroutine definitions
  131. +  * patch11: prepared for ctype implementations that don't define isascii()
  132. +  * 
  133.    * Revision 4.0.1.1  91/06/07  10:31:15  lwall
  134.    * patch4: new copyright notice
  135.    * patch4: added global modifier for pattern matches
  136. ***************
  137. *** 74,81 ****
  138.       STR *str;
  139.       STR *tmpstr = str_mortal(&str_undef);
  140.   
  141. !     sprintf(buf,"%s:%ld",stab_val(curcmd->c_filestab)->str_ptr,
  142. !       (long)subline);
  143.       str = str_make(buf,0);
  144.       str_cat(str,"-");
  145.       sprintf(buf,"%ld",(long)curcmd->c_line);
  146. --- 78,84 ----
  147.       STR *str;
  148.       STR *tmpstr = str_mortal(&str_undef);
  149.   
  150. !     sprintf(buf,"%s:%ld",stab_val(curcmd->c_filestab)->str_ptr, subline);
  151.       str = str_make(buf,0);
  152.       str_cat(str,"-");
  153.       sprintf(buf,"%ld",(long)curcmd->c_line);
  154. ***************
  155. *** 83,91 ****
  156.       name = str_get(subname);
  157.       stab_fullname(tmpstr,stab);
  158.       hstore(stab_xhash(DBsub), tmpstr->str_ptr, tmpstr->str_cur, str, 0);
  159. -     str_set(subname,"main");
  160.       }
  161. -     subline = 0;
  162.       return sub;
  163.   }
  164.   
  165. --- 86,92 ----
  166. ***************
  167. *** 732,737 ****
  168. --- 733,739 ----
  169.            arg->arg_type == O_SLT || arg->arg_type == O_SGT) {
  170.       if (arg[1].arg_type == A_STAB || arg[1].arg_type == A_LVAL) {
  171.           if (arg[2].arg_type == A_SINGLE) {
  172. +         /*SUPPRESS 594*/
  173.           char *junk = str_get(arg[2].arg_ptr.arg_str);
  174.   
  175.           cmd->c_stab  = arg[1].arg_ptr.arg_stab;
  176. ***************
  177. *** 908,914 ****
  178.   
  179.       if (bufptr > oldoldbufptr && bufptr - oldoldbufptr < 200 &&
  180.         oldoldbufptr != oldbufptr && oldbufptr != bufptr) {
  181. !     while (isspace(*oldoldbufptr))
  182.           oldoldbufptr++;
  183.       strncpy(tmp2buf, oldoldbufptr, bufptr - oldoldbufptr);
  184.       tmp2buf[bufptr - oldoldbufptr] = '\0';
  185. --- 910,916 ----
  186.   
  187.       if (bufptr > oldoldbufptr && bufptr - oldoldbufptr < 200 &&
  188.         oldoldbufptr != oldbufptr && oldbufptr != bufptr) {
  189. !     while (isSPACE(*oldoldbufptr))
  190.           oldoldbufptr++;
  191.       strncpy(tmp2buf, oldoldbufptr, bufptr - oldoldbufptr);
  192.       tmp2buf[bufptr - oldoldbufptr] = '\0';
  193. ***************
  194. *** 916,922 ****
  195.       }
  196.       else if (bufptr > oldbufptr && bufptr - oldbufptr < 200 &&
  197.         oldbufptr != bufptr) {
  198. !     while (isspace(*oldbufptr))
  199.           oldbufptr++;
  200.       strncpy(tmp2buf, oldbufptr, bufptr - oldbufptr);
  201.       tmp2buf[bufptr - oldbufptr] = '\0';
  202. --- 918,924 ----
  203.       }
  204.       else if (bufptr > oldbufptr && bufptr - oldbufptr < 200 &&
  205.         oldbufptr != bufptr) {
  206. !     while (isSPACE(*oldbufptr))
  207.           oldbufptr++;
  208.       strncpy(tmp2buf, oldbufptr, bufptr - oldbufptr);
  209.       tmp2buf[bufptr - oldbufptr] = '\0';
  210. ***************
  211. *** 1083,1088 ****
  212. --- 1085,1091 ----
  213.           break;
  214.           tail = tail->c_next;
  215.       }
  216. +     /*SUPPRESS 530*/
  217.       for ( ; tail->c_next; tail = tail->c_next) ;
  218.       }
  219.   
  220. ***************
  221. *** 1118,1124 ****
  222.       cmd->c_flags &= ~CF_OPTIMIZE;    /* clear optimization type */
  223.       cmd->c_flags |= CFT_ARRAY;        /* and set it to do the iteration */
  224.       cmd->c_stab = eachstab;
  225. !     cmd->c_short = str_new(0);        /* just to save a field in struct cmd */
  226.       cmd->c_short->str_u.str_useful = -1;
  227.   
  228.       return cmd;
  229. --- 1121,1127 ----
  230.       cmd->c_flags &= ~CF_OPTIMIZE;    /* clear optimization type */
  231.       cmd->c_flags |= CFT_ARRAY;        /* and set it to do the iteration */
  232.       cmd->c_stab = eachstab;
  233. !     cmd->c_short = Str_new(23,0);    /* just to save a field in struct cmd */
  234.       cmd->c_short->str_u.str_useful = -1;
  235.   
  236.       return cmd;
  237. ***************
  238. *** 1268,1273 ****
  239. --- 1271,1277 ----
  240.           for (sp = stash->tbl_spatroot;
  241.             sp && sp->spat_next != spat;
  242.             sp = sp->spat_next)
  243. +         /*SUPPRESS 530*/
  244.           ;
  245.           if (sp)
  246.           sp->spat_next = spat->spat_next;
  247.  
  248. Index: consarg.c
  249. *** consarg.c.old    Tue Nov  5 19:25:51 1991
  250. --- consarg.c    Tue Nov  5 19:25:52 1991
  251. ***************
  252. *** 1,4 ****
  253. ! /* $RCSfile: consarg.c,v $$Revision: 4.0.1.2 $$Date: 91/06/07 10:33:12 $
  254.    *
  255.    *    Copyright (c) 1991, Larry Wall
  256.    *
  257. --- 1,4 ----
  258. ! /* $RCSfile: consarg.c,v $$Revision: 4.0.1.3 $$Date: 91/11/05 16:21:16 $
  259.    *
  260.    *    Copyright (c) 1991, Larry Wall
  261.    *
  262. ***************
  263. *** 6,11 ****
  264. --- 6,18 ----
  265.    *    License or the Artistic License, as specified in the README file.
  266.    *
  267.    * $Log:    consarg.c,v $
  268. +  * Revision 4.0.1.3  91/11/05  16:21:16  lwall
  269. +  * patch11: random cleanup
  270. +  * patch11: added eval {}
  271. +  * patch11: added sort {} LIST
  272. +  * patch11: "foo" x -1 dumped core
  273. +  * patch11: substr() and vec() weren't allowed in an lvalue list
  274. +  * 
  275.    * Revision 4.0.1.2  91/06/07  10:33:12  lwall
  276.    * patch4: new copyright notice
  277.    * patch4: length($`), length($&), length($') now optimized to avoid string copy
  278. ***************
  279. *** 54,61 ****
  280.           arg[3].arg_ptr.arg_arg = limarg;
  281.       }
  282.       }
  283. !     else
  284.       arg[3].arg_type = A_NULL;
  285.       arg->arg_type = O_SPLIT;
  286.       spat = arg[2].arg_ptr.arg_spat;
  287.       spat->spat_repl = stab2arg(A_STAB,aadd(stab));
  288. --- 61,71 ----
  289.           arg[3].arg_ptr.arg_arg = limarg;
  290.       }
  291.       }
  292. !     else {
  293. !     arg[3].arg_flags = 0;
  294.       arg[3].arg_type = A_NULL;
  295. +     arg[3].arg_ptr.arg_arg = Nullarg;
  296. +     }
  297.       arg->arg_type = O_SPLIT;
  298.       spat = arg[2].arg_ptr.arg_spat;
  299.       spat->spat_repl = stab2arg(A_STAB,aadd(stab));
  300. ***************
  301. *** 154,159 ****
  302. --- 164,170 ----
  303.   
  304.       arg = op_new(newlen);
  305.       arg->arg_type = type;
  306. +     /*SUPPRESS 560*/
  307.       if (chld = arg1) {
  308.       if (chld->arg_type == O_ITEM &&
  309.           (hoistable[ i = (chld[1].arg_type&A_MASK)] || i == A_LVAL ||
  310. ***************
  311. *** 173,178 ****
  312. --- 184,190 ----
  313.           arg[1].arg_ptr.arg_arg = chld;
  314.       }
  315.       }
  316. +     /*SUPPRESS 560*/
  317.       if (chld = arg2) {
  318.       if (chld->arg_type == O_ITEM && 
  319.           (hoistable[chld[1].arg_type&A_MASK] || 
  320. ***************
  321. *** 193,198 ****
  322. --- 205,211 ----
  323.           arg[2].arg_ptr.arg_arg = chld;
  324.       }
  325.       }
  326. +     /*SUPPRESS 560*/
  327.       if (chld = arg3) {
  328.       if (chld->arg_type == O_ITEM && hoistable[chld[1].arg_type&A_MASK]) {
  329.           arg[3].arg_type = chld[1].arg_type;
  330. ***************
  331. *** 300,305 ****
  332. --- 313,331 ----
  333.       switch (arg->arg_type) {
  334.       default:
  335.       return arg;
  336. +     case O_SORT:
  337. +     if (arg[1].arg_type == A_CMD)
  338. +         arg[1].arg_type |= A_DONT;
  339. +     return arg;
  340. +     case O_EVAL:
  341. +     if (arg[1].arg_type == A_CMD) {
  342. +         arg->arg_type = O_TRY;
  343. +         arg[1].arg_type |= A_DONT;
  344. +         return arg;
  345. +     }
  346. +     CHECK1;
  347. +     arg->arg_type = O_EVALONCE;
  348. +     return arg;
  349.       case O_AELEM:
  350.       CHECK2;
  351.       i = (int)str_gnum(s2);
  352. ***************
  353. *** 322,331 ****
  354.       i = (int)str_gnum(s2);
  355.       tmps = str_get(s1);
  356.       str_nset(str,"",0);
  357. !     STR_GROW(str, i * s1->str_cur + 1);
  358. !     repeatcpy(str->str_ptr, tmps, s1->str_cur, i);
  359. !     str->str_cur = i * s1->str_cur;
  360. !     str->str_ptr[str->str_cur] = '\0';
  361.       break;
  362.       case O_MULTIPLY:
  363.       CHECK12;
  364. --- 348,359 ----
  365.       i = (int)str_gnum(s2);
  366.       tmps = str_get(s1);
  367.       str_nset(str,"",0);
  368. !     if (i > 0) {
  369. !         STR_GROW(str, i * s1->str_cur + 1);
  370. !         repeatcpy(str->str_ptr, tmps, s1->str_cur, i);
  371. !         str->str_cur = i * s1->str_cur;
  372. !         str->str_ptr[str->str_cur] = '\0';
  373. !     }
  374.       break;
  375.       case O_MULTIPLY:
  376.       CHECK12;
  377. ***************
  378. *** 338,344 ****
  379.       if (value == 0.0)
  380.           yyerror("Illegal division by constant zero");
  381.       else
  382. ! #ifdef cray
  383.       /* insure that 20./5. == 4. */
  384.       {
  385.           double x;
  386. --- 366,372 ----
  387.       if (value == 0.0)
  388.           yyerror("Illegal division by constant zero");
  389.       else
  390. ! #ifdef SLOPPYDIVIDE
  391.       /* insure that 20./5. == 4. */
  392.       {
  393.           double x;
  394. ***************
  395. *** 497,503 ****
  396. --- 525,535 ----
  397.       break;
  398.       case O_NOT:
  399.       CHECK1;
  400. + #ifdef NOTNOT
  401. +     { char xxx = str_true(s1); str_numset(str,(double)!xxx); }
  402. + #else
  403.       str_numset(str,(double)(!str_true(s1)));
  404. + #endif
  405.       break;
  406.       case O_COMPLEMENT:
  407.       CHECK1;
  408. ***************
  409. *** 704,709 ****
  410. --- 736,747 ----
  411.               case O_HSLICE: case O_LHSLICE:
  412.               arg1[i].arg_ptr.arg_arg->arg_type = O_LHSLICE;
  413.               break;
  414. +             case O_SUBSTR: case O_VEC:
  415. +             (void)l(arg1[i].arg_ptr.arg_arg);
  416. +             Renewc(arg1[i].arg_ptr.arg_arg->arg_ptr.arg_str, 1,
  417. +               struct lstring, STR);
  418. +                 /* grow string struct to hold an lstring struct */
  419. +             break;
  420.               default:
  421.               goto ill_item;
  422.               }
  423. ***************
  424. *** 802,811 ****
  425.           Renewc(arg1->arg_ptr.arg_str, 1, struct lstring, STR);
  426.               /* grow string struct to hold an lstring struct */
  427.       }
  428. !     else if (arg1->arg_type == O_ASSIGN) {
  429. ! /*        if (arg->arg_type == O_CHOP)
  430. !         arg[1].arg_flags &= ~AF_ARYOK;    /* grandfather chop idiom */
  431. !     }
  432.       else {
  433.           (void)sprintf(tokenbuf,
  434.             "Illegal expression (%s) as lvalue",opname[arg1->arg_type]);
  435. --- 840,848 ----
  436.           Renewc(arg1->arg_ptr.arg_str, 1, struct lstring, STR);
  437.               /* grow string struct to hold an lstring struct */
  438.       }
  439. !     else if (arg1->arg_type == O_ASSIGN)
  440. !         /*SUPPRESS 530*/
  441. !         ;
  442.       else {
  443.           (void)sprintf(tokenbuf,
  444.             "Illegal expression (%s) as lvalue",opname[arg1->arg_type]);
  445. ***************
  446. *** 980,986 ****
  447.   listish(arg)
  448.   ARG *arg;
  449.   {
  450. !     if (arg->arg_flags & AF_LISTISH)
  451.       arg = make_op(O_LIST,1,arg,Nullarg,Nullarg);
  452.       return arg;
  453.   }
  454. --- 1017,1023 ----
  455.   listish(arg)
  456.   ARG *arg;
  457.   {
  458. !     if (arg && arg->arg_flags & AF_LISTISH)
  459.       arg = make_op(O_LIST,1,arg,Nullarg,Nullarg);
  460.       return arg;
  461.   }
  462.  
  463. Index: usub/curses.mus
  464. Prereq: 4.0
  465. *** usub/curses.mus.old    Tue Nov  5 19:28:20 1991
  466. --- usub/curses.mus    Tue Nov  5 19:28:20 1991
  467. ***************
  468. *** 1,6 ****
  469. ! /* $Header: curses.mus,v 4.0 91/03/20 01:56:13 lwall Locked $
  470.    *
  471.    * $Log:    curses.mus,v $
  472.    * Revision 4.0  91/03/20  01:56:13  lwall
  473.    * 4.0 baseline.
  474.    * 
  475. --- 1,9 ----
  476. ! /* $RCSfile: curses.mus,v $$Revision: 4.0.1.1 $$Date: 91/11/05 19:06:19 $
  477.    *
  478.    * $Log:    curses.mus,v $
  479. +  * Revision 4.0.1.1  91/11/05  19:06:19  lwall
  480. +  * patch11: usub/curses.mus now supports SysV curses
  481. +  * 
  482.    * Revision 4.0  91/03/20  01:56:13  lwall
  483.    * 4.0 baseline.
  484.    * 
  485. ***************
  486. *** 11,32 ****
  487.   
  488.   #include "EXTERN.h"
  489.   #include "perl.h"
  490. - extern int wantarray;
  491.   
  492.   char *savestr();
  493.   
  494.   #include <curses.h>
  495.   
  496.   static enum uservars {
  497.       UV_curscr,
  498.       UV_stdscr,
  499. -     UV_Def_term,
  500. -     UV_My_term,
  501.       UV_ttytype,
  502.       UV_LINES,
  503.       UV_COLS,
  504.       UV_ERR,
  505.       UV_OK,
  506.   };
  507.   
  508.   static enum usersubs {
  509. --- 14,63 ----
  510.   
  511.   #include "EXTERN.h"
  512.   #include "perl.h"
  513.   
  514.   char *savestr();
  515.   
  516. + #undef bool
  517.   #include <curses.h>
  518.   
  519. + #ifndef A_UNDERLINE
  520. + #define NOSETATTR
  521. + #define A_STANDOUT  0x0200
  522. + #define A_UNDERLINE 0x0100
  523. + #define A_REVERSE   0x0200
  524. + #define A_BLINK     0x0400
  525. + #define A_BOLD      0x0800
  526. + #define A_ALTCHARSET 0x1000    
  527. + #define A_NORMAL    0
  528. + #endif
  529. + 
  530. + #ifdef USG
  531. + static char *tcbuf = NULL;
  532. + #endif
  533. + 
  534. + #ifdef NOSETATTR
  535. + static unsigned curattr = NORMAL;
  536. + #endif
  537. + 
  538.   static enum uservars {
  539.       UV_curscr,
  540.       UV_stdscr,
  541.       UV_ttytype,
  542.       UV_LINES,
  543.       UV_COLS,
  544.       UV_ERR,
  545.       UV_OK,
  546. + #ifdef BSD
  547. +     UV_Def_term,
  548. +     UV_My_term,
  549. + #endif    
  550. +     UV_A_STANDOUT,
  551. +     UV_A_UNDERLINE,
  552. +     UV_A_REVERSE,
  553. +     UV_A_BLINK,
  554. +     UV_A_DIM,
  555. +     UV_A_BOLD,
  556. +     UV_A_NORMAL,
  557.   };
  558.   
  559.   static enum usersubs {
  560. ***************
  561. *** 48,54 ****
  562.       US_wdeleteln,
  563.       US_erase,
  564.       US_werase,
  565. -     US_flushok,
  566.       US_idlok,
  567.       US_insch,
  568.       US_winsch,
  569. --- 79,84 ----
  570. ***************
  571. *** 58,65 ****
  572.       US_wmove,
  573.       US_overlay,
  574.       US_overwrite,
  575. -     US_printw,
  576. -     US_wprintw,
  577.       US_refresh,
  578.       US_wrefresh,
  579.       US_standout,
  580. --- 88,93 ----
  581. ***************
  582. *** 76,88 ****
  583.       US_wgetstr,
  584.       US_raw,
  585.       US_noraw,
  586. -     US_scanw,
  587. -     US_wscanw,
  588.       US_baudrate,
  589.       US_delwin,
  590.       US_endwin,
  591.       US_erasechar,
  592. -     US_getcap,
  593.       US_getyx,
  594.       US_inch,
  595.       US_winch,
  596. --- 104,113 ----
  597. ***************
  598. *** 90,96 ****
  599.       US_killchar,
  600.       US_leaveok,
  601.       US_longname,
  602. -     US_fullname,
  603.       US_mvwin,
  604.       US_newwin,
  605.       US_nl,
  606. --- 115,120 ----
  607. ***************
  608. *** 98,104 ****
  609.       US_scrollok,
  610.       US_subwin,
  611.       US_touchline,
  612. -     US_touchoverlap,
  613.       US_touchwin,
  614.       US_unctrl,
  615.       US_gettmode,
  616. --- 122,127 ----
  617. ***************
  618. *** 107,114 ****
  619. --- 130,157 ----
  620.       US_savetty,
  621.       US_resetty,
  622.       US_setterm,
  623. +     US_attroff,
  624. +     US_wattroff,
  625. +     US_attron,
  626. +     US_wattron,
  627. +     US_attrset,
  628. +     US_wattrset,
  629. + #ifdef CURSEFMT
  630. +     US_printw, /* remove */
  631. +     US_wprintw, /* remove */
  632. +     US_scanw,     /* delete */
  633. +     US_wscanw,     /* delete */
  634. + #endif
  635. +     US_getcap,
  636. + #ifdef BSD
  637. +     US_flushok,
  638. +     US_fullname,
  639. +     US_touchoverlap,
  640.       US_tstp,
  641.       US__putchar,
  642. + #endif
  643. +     US_mysub,
  644. +     US_testcallback,
  645.   };
  646.   
  647.   static int usersub();
  648. ***************
  649. *** 128,140 ****
  650.   
  651.       MAGICVAR("curscr",    UV_curscr);
  652.       MAGICVAR("stdscr",    UV_stdscr);
  653. -     MAGICVAR("Def_term",UV_Def_term);
  654. -     MAGICVAR("My_term",    UV_My_term);
  655.       MAGICVAR("ttytype",    UV_ttytype);
  656.       MAGICVAR("LINES",    UV_LINES);
  657.       MAGICVAR("COLS",    UV_COLS);
  658.       MAGICVAR("ERR",    UV_ERR);
  659.       MAGICVAR("OK",    UV_OK);
  660.   
  661.       make_usub("addch",        US_addch,    usersub, filename);
  662.       make_usub("waddch",        US_waddch,    usersub, filename);
  663. --- 171,192 ----
  664.   
  665.       MAGICVAR("curscr",    UV_curscr);
  666.       MAGICVAR("stdscr",    UV_stdscr);
  667.       MAGICVAR("ttytype",    UV_ttytype);
  668.       MAGICVAR("LINES",    UV_LINES);
  669.       MAGICVAR("COLS",    UV_COLS);
  670.       MAGICVAR("ERR",    UV_ERR);
  671.       MAGICVAR("OK",    UV_OK);
  672. + #ifdef BSD
  673. +     MAGICVAR("Def_term",UV_Def_term);
  674. +     MAGICVAR("My_term",    UV_My_term);
  675. + #endif
  676. +     MAGICVAR("A_STANDOUT", UV_A_STANDOUT);
  677. +     MAGICVAR("A_UNDERLINE", UV_A_UNDERLINE);
  678. +     MAGICVAR("A_REVERSE", UV_A_REVERSE);
  679. +     MAGICVAR("A_BLINK", UV_A_BLINK);
  680. +     MAGICVAR("A_DIM", UV_A_DIM);
  681. +     MAGICVAR("A_BOLD", UV_A_BOLD);
  682. +     MAGICVAR("A_NORMAL", UV_A_NORMAL);
  683.   
  684.       make_usub("addch",        US_addch,    usersub, filename);
  685.       make_usub("waddch",        US_waddch,    usersub, filename);
  686. ***************
  687. *** 154,160 ****
  688.       make_usub("wdeleteln",    US_wdeleteln,    usersub, filename);
  689.       make_usub("erase",        US_erase,    usersub, filename);
  690.       make_usub("werase",        US_werase,    usersub, filename);
  691. -     make_usub("flushok",    US_flushok,    usersub, filename);
  692.       make_usub("idlok",        US_idlok,    usersub, filename);
  693.       make_usub("insch",        US_insch,    usersub, filename);
  694.       make_usub("winsch",        US_winsch,    usersub, filename);
  695. --- 206,211 ----
  696. ***************
  697. *** 164,171 ****
  698.       make_usub("wmove",        US_wmove,    usersub, filename);
  699.       make_usub("overlay",    US_overlay,    usersub, filename);
  700.       make_usub("overwrite",    US_overwrite,    usersub, filename);
  701. -     make_usub("printw",        US_printw,    usersub, filename);
  702. -     make_usub("wprintw",    US_wprintw,    usersub, filename);
  703.       make_usub("refresh",    US_refresh,    usersub, filename);
  704.       make_usub("wrefresh",    US_wrefresh,    usersub, filename);
  705.       make_usub("standout",    US_standout,    usersub, filename);
  706. --- 215,220 ----
  707. ***************
  708. *** 182,194 ****
  709.       make_usub("wgetstr",    US_wgetstr,    usersub, filename);
  710.       make_usub("raw",        US_raw,        usersub, filename);
  711.       make_usub("noraw",        US_noraw,    usersub, filename);
  712. -     make_usub("scanw",        US_scanw,    usersub, filename);
  713. -     make_usub("wscanw",        US_wscanw,    usersub, filename);
  714.       make_usub("baudrate",    US_baudrate,    usersub, filename);
  715.       make_usub("delwin",        US_delwin,    usersub, filename);
  716.       make_usub("endwin",        US_endwin,    usersub, filename);
  717.       make_usub("erasechar",    US_erasechar,    usersub, filename);
  718. -     make_usub("getcap",        US_getcap,    usersub, filename);
  719.       make_usub("getyx",        US_getyx,    usersub, filename);
  720.       make_usub("inch",        US_inch,    usersub, filename);
  721.       make_usub("winch",        US_winch,    usersub, filename);
  722. --- 231,240 ----
  723. ***************
  724. *** 196,202 ****
  725.       make_usub("killchar",    US_killchar,    usersub, filename);
  726.       make_usub("leaveok",    US_leaveok,    usersub, filename);
  727.       make_usub("longname",    US_longname,    usersub, filename);
  728. -     make_usub("fullname",    US_fullname,    usersub, filename);
  729.       make_usub("mvwin",        US_mvwin,    usersub, filename);
  730.       make_usub("newwin",        US_newwin,    usersub, filename);
  731.       make_usub("nl",        US_nl,        usersub, filename);
  732. --- 242,247 ----
  733. ***************
  734. *** 204,210 ****
  735.       make_usub("scrollok",    US_scrollok,    usersub, filename);
  736.       make_usub("subwin",        US_subwin,    usersub, filename);
  737.       make_usub("touchline",    US_touchline,    usersub, filename);
  738. -     make_usub("touchoverlap",    US_touchoverlap,usersub, filename);
  739.       make_usub("touchwin",    US_touchwin,    usersub, filename);
  740.       make_usub("unctrl",        US_unctrl,    usersub, filename);
  741.       make_usub("gettmode",    US_gettmode,    usersub, filename);
  742. --- 249,254 ----
  743. ***************
  744. *** 213,222 ****
  745.       make_usub("savetty",    US_savetty,    usersub, filename);
  746.       make_usub("resetty",    US_resetty,    usersub, filename);
  747.       make_usub("setterm",    US_setterm,    usersub, filename);
  748.       make_usub("tstp",        US_tstp,    usersub, filename);
  749.       make_usub("_putchar",    US__putchar,    usersub, filename);
  750. ! };
  751.   
  752.   static int
  753.   usersub(ix, sp, items)
  754.   int ix;
  755. --- 257,353 ----
  756.       make_usub("savetty",    US_savetty,    usersub, filename);
  757.       make_usub("resetty",    US_resetty,    usersub, filename);
  758.       make_usub("setterm",    US_setterm,    usersub, filename);
  759. +     make_usub("getcap",        US_getcap,    usersub, filename);
  760. +     make_usub("attroff",        US_attroff,    usersub, filename);
  761. +     make_usub("wattroff",       US_wattroff,    usersub, filename);
  762. +     make_usub("attron",         US_attron,    usersub, filename);
  763. +     make_usub("wattron",        US_wattron,    usersub, filename);
  764. +     make_usub("attrset",        US_attrset,    usersub, filename);
  765. +     make_usub("wattrset",       US_wattrset,    usersub, filename);
  766. + #ifdef CURSEFMT
  767. +     make_usub("printw",        US_printw,    usersub, filename);
  768. +     make_usub("wprintw",    US_wprintw,    usersub, filename);
  769. +     make_usub("scanw",        US_scanw,    usersub, filename);
  770. +     make_usub("wscanw",        US_wscanw,    usersub, filename);
  771. + #endif
  772. + #ifdef BSD
  773. +     make_usub("flushok",    US_flushok,    usersub, filename);
  774. +     make_usub("fullname",    US_fullname,    usersub, filename);
  775. +     make_usub("touchoverlap",    US_touchoverlap,usersub, filename);
  776.       make_usub("tstp",        US_tstp,    usersub, filename);
  777.       make_usub("_putchar",    US__putchar,    usersub, filename);
  778. ! #endif
  779. !     make_usub("testcallback",    US_testcallback,usersub, filename);
  780. !   };
  781. !   
  782. ! #ifdef USG
  783. ! static char
  784. ! *getcap(cap)
  785. ! register char *cap;
  786. ! {
  787. !     static char nocaperr[] = "Cannot read termcap entry.";
  788.   
  789. +     extern char *tgetstr();
  790. + 
  791. +     if (tcbuf == NULL) {
  792. +     if ((tcbuf = malloc(1024)) == NULL) {
  793. +         fatal(nocaperr);
  794. +     }
  795. +     if (tgetent(tcbuf, ttytype) == -1) {
  796. +         fatal(nocaperr);
  797. +     }
  798. +     }
  799. + 
  800. +     return (tgetstr(cap, NULL));
  801. + }
  802. + #endif
  803. + 
  804. + #ifdef NOSETATTR
  805. + #define attron(attr)    wattron(stdscr, attr)
  806. + #define attroff(attr)   wattroff(stdscr, attr)
  807. + #define attset(attr)    wattset(stdscr, attr)
  808. + 
  809. + int
  810. + wattron(win, attr)
  811. + WINDOW *win;
  812. + chtype attr;
  813. + {
  814. +     curattr |= attr;
  815. +     if (curattr & A_STANDOUT) {
  816. +     return(wstandout(win));
  817. +     } else {
  818. +     return(wstandend(win));
  819. +     }
  820. + }
  821. + 
  822. + int
  823. + wattroff(win, attr)
  824. + WINDOW *win;
  825. + chtype attr;
  826. + {
  827. +     curattr &= (~attr);
  828. +     if (curattr & A_STANDOUT) {
  829. +     return(wstandout(win));
  830. +     } else {
  831. +     return(wstandend(win));
  832. +     }
  833. + }
  834. + 
  835. + int
  836. + wattrset(win, attr)
  837. + WINDOW *win;
  838. + chtype attr;
  839. + {
  840. +     curattr = attr;
  841. +     if (curattr & A_STANDOUT) {
  842. +     return(wstandout(win));
  843. +     } else {
  844. +     return(wstandend(win));
  845. +     }
  846. + }
  847. + 
  848. + #endif
  849. +     
  850.   static int
  851.   usersub(ix, sp, items)
  852.   int ix;
  853. ***************
  854. *** 300,310 ****
  855.   I    WINDOW*        win
  856.   END
  857.   
  858. - CASE int flushok
  859. - I    WINDOW*        win
  860. - I    bool        boolf
  861. - END
  862. - 
  863.   CASE int idlok
  864.   I    WINDOW*        win
  865.   I    bool        boolf
  866. --- 431,436 ----
  867. ***************
  868. *** 347,381 ****
  869.   I    WINDOW*        win2
  870.   END
  871.   
  872. -     case US_printw:
  873. -     if (items < 1)
  874. -         fatal("Usage: &printw($fmt, $arg1, $arg2, ... )");
  875. -     else {
  876. -         int retval;
  877. -         STR*    str =        str_new(0);
  878. - 
  879. -         do_sprintf(str, items - 1, st + 1);
  880. -         retval = addstr(str->str_ptr);
  881. -         str_numset(st[0], (double) retval);
  882. -         str_free(str);
  883. -     }
  884. -     return sp;
  885. - 
  886. -     case US_wprintw:
  887. -     if (items < 2)
  888. -         fatal("Usage: &wprintw($win, $fmt, $arg1, $arg2, ... )");
  889. -     else {
  890. -         int retval;
  891. -         STR*    str =        str_new(0);
  892. -         WINDOW*    win =        *(WINDOW**)    str_get(st[1]);
  893. - 
  894. -         do_sprintf(str, items - 1, st + 1);
  895. -         retval = waddstr(win, str->str_ptr);
  896. -         str_numset(st[0], (double) retval);
  897. -         str_free(str);
  898. -     }
  899. -     return sp;
  900. - 
  901.   CASE int refresh
  902.   END
  903.   
  904. --- 473,478 ----
  905. ***************
  906. *** 410,422 ****
  907.   END
  908.   
  909.       case US_getch:
  910. !         if (items != 0)
  911. !             fatal("Usage: &getch()");
  912. !         else {
  913. !             int retval;
  914.           char retch;
  915.   
  916. !             retval = getch();
  917.           if (retval == EOF)
  918.           st[0] = &str_undef;
  919.           else {
  920. --- 507,519 ----
  921.   END
  922.   
  923.       case US_getch:
  924. !     if (items != 0)
  925. !         fatal("Usage: &getch()");
  926. !     else {
  927. !         int retval;
  928.           char retch;
  929.   
  930. !         retval = getch();
  931.           if (retval == EOF)
  932.           st[0] = &str_undef;
  933.           else {
  934. ***************
  935. *** 423,440 ****
  936.           retch = retval;
  937.           str_nset(st[0], &retch, 1);
  938.           }
  939. !         }
  940. !         return sp;
  941.   
  942.       case US_wgetch:
  943. !         if (items != 1)
  944. !             fatal("Usage: &wgetch($win)");
  945. !         else {
  946. !             int retval;
  947.           char retch;
  948. !             WINDOW*     win =           *(WINDOW**)     str_get(st[1]);
  949.   
  950. !             retval = wgetch(win);
  951.           if (retval == EOF)
  952.           st[0] = &str_undef;
  953.           else {
  954. --- 520,537 ----
  955.           retch = retval;
  956.           str_nset(st[0], &retch, 1);
  957.           }
  958. !     }
  959. !     return sp;
  960.   
  961.       case US_wgetch:
  962. !     if (items != 1)
  963. !         fatal("Usage: &wgetch($win)");
  964. !     else {
  965. !         int retval;
  966.           char retch;
  967. !         WINDOW*     win =           *(WINDOW**)     str_get(st[1]);
  968.   
  969. !         retval = wgetch(win);
  970.           if (retval == EOF)
  971.           st[0] = &str_undef;
  972.           else {
  973. ***************
  974. *** 441,456 ****
  975.           retch = retval;
  976.           str_nset(st[0], &retch, 1);
  977.           }
  978. !         }
  979. !         return sp;
  980.   
  981.   CASE int getstr
  982. ! IO    char*        str
  983.   END
  984.   
  985.   CASE int wgetstr
  986.   I    WINDOW*        win
  987. ! IO    char*        str
  988.   END
  989.   
  990.   CASE int raw
  991. --- 538,553 ----
  992.           retch = retval;
  993.           str_nset(st[0], &retch, 1);
  994.           }
  995. !     }
  996. !     return sp;
  997.   
  998.   CASE int getstr
  999. ! O    char*        str
  1000.   END
  1001.   
  1002.   CASE int wgetstr
  1003.   I    WINDOW*        win
  1004. ! O    char*        str
  1005.   END
  1006.   
  1007.   CASE int raw
  1008. ***************
  1009. *** 472,481 ****
  1010.   CASE int erasechar
  1011.   END
  1012.   
  1013. - CASE char* getcap
  1014. - I    char*        str
  1015. - END
  1016. - 
  1017.       case US_getyx:
  1018.       if (items != 3)
  1019.           fatal("Usage: &getyx($win, $y, $x)");
  1020. --- 569,574 ----
  1021. ***************
  1022. *** 494,500 ****
  1023.           str_free(str);
  1024.       }
  1025.       return sp;
  1026. - 
  1027.       
  1028.   CASE int inch
  1029.   END
  1030. --- 587,592 ----
  1031. ***************
  1032. *** 514,528 ****
  1033.   I    bool        boolf
  1034.   END
  1035.   
  1036.   CASE char* longname
  1037.   I    char*        termbuf
  1038.   IO    char*        name
  1039.   END
  1040. ! 
  1041. ! CASE int fullname
  1042. ! I    char*        termbuf
  1043. ! IO    char*        name
  1044.   END
  1045.   
  1046.   CASE int mvwin
  1047.   I    WINDOW*        win
  1048. --- 606,622 ----
  1049.   I    bool        boolf
  1050.   END
  1051.   
  1052. + #ifdef BSD
  1053.   CASE char* longname
  1054.   I    char*        termbuf
  1055.   IO    char*        name
  1056.   END
  1057. ! #else
  1058. ! CASE char* longname
  1059. ! I    char*        termbug
  1060. ! I    char*        name
  1061.   END
  1062. + #endif
  1063.   
  1064.   CASE int mvwin
  1065.   I    WINDOW*        win
  1066. ***************
  1067. *** 563,573 ****
  1068.   I    int        endx
  1069.   END
  1070.   
  1071. - CASE int touchoverlap
  1072. - I    WINDOW*        win1
  1073. - I    WINDOW*        win2
  1074. - END
  1075. - 
  1076.   CASE int touchwin
  1077.   I    WINDOW*        win
  1078.   END
  1079. --- 657,662 ----
  1080. ***************
  1081. *** 600,605 ****
  1082. --- 689,770 ----
  1083.   I    char*        name
  1084.   END
  1085.   
  1086. + CASE int attroff
  1087. + I       chtype          str
  1088. + END
  1089. + 
  1090. + CASE int wattroff
  1091. + I       chtype          str
  1092. + END
  1093. + 
  1094. + CASE int wattron
  1095. + I       chtype          str
  1096. + END
  1097. + 
  1098. + CASE int attron
  1099. + I       chtype          str
  1100. + END
  1101. + 
  1102. + CASE int attrset
  1103. + I       chtype          str
  1104. + END
  1105. + 
  1106. + CASE int wattrset
  1107. + I       chtype          str
  1108. + END
  1109. + 
  1110. + #ifdef    CURSEFMT
  1111. +     case US_printw:
  1112. +     if (items < 1)
  1113. +         fatal("Usage: &printw($fmt, $arg1, $arg2, ... )");
  1114. +     else {
  1115. +         int retval;
  1116. +         STR*    str =        str_new(0);
  1117. + 
  1118. +         do_sprintf(str, items - 1, st + 1);
  1119. +         retval = addstr(str->str_ptr);
  1120. +         str_numset(st[0], (double) retval);
  1121. +         str_free(str);
  1122. +     }
  1123. +     return sp;
  1124. + 
  1125. +     case US_wprintw:
  1126. +     if (items < 2)
  1127. +         fatal("Usage: &wprintw($win, $fmt, $arg1, $arg2, ... )");
  1128. +     else {
  1129. +         int retval;
  1130. +         STR*    str =        str_new(0);
  1131. +         WINDOW*    win =        *(WINDOW**)    str_get(st[1]);
  1132. + 
  1133. +         do_sprintf(str, items - 1, st + 1);
  1134. +         retval = waddstr(win, str->str_ptr);
  1135. +         str_numset(st[0], (double) retval);
  1136. +         str_free(str);
  1137. +     }
  1138. +     return sp;
  1139. + 
  1140. + #endif
  1141. + 
  1142. + CASE char* getcap
  1143. + I    char*        str
  1144. + END
  1145. + 
  1146. + #ifdef BSD
  1147. + CASE int flushok
  1148. + I    WINDOW*        win
  1149. + I    bool        boolf
  1150. + END
  1151. + 
  1152. + CASE int fullname
  1153. + I    char*        termbuf
  1154. + IO    char*        name
  1155. + END
  1156. + 
  1157. + CASE int touchoverlap
  1158. + I    WINDOW*        win1
  1159. + I    WINDOW*        win2
  1160. + END
  1161. + 
  1162.   CASE int tstp
  1163.   END
  1164.   
  1165. ***************
  1166. *** 607,612 ****
  1167. --- 772,783 ----
  1168.   I    char        ch
  1169.   END
  1170.   
  1171. +     case US_testcallback:
  1172. +     sp = callback("callback", sp + items, curcsv->wantarray, 1, items);
  1173. +     break;
  1174. + 
  1175. + #endif
  1176. + 
  1177.       default:
  1178.       fatal("Unimplemented user-defined subroutine");
  1179.       }
  1180. ***************
  1181. *** 622,630 ****
  1182.       case UV_COLS:
  1183.       str_numset(str, (double)COLS);
  1184.       break;
  1185. -     case UV_Def_term:
  1186. -     str_set(str, Def_term);
  1187. -     break;
  1188.       case UV_ERR:
  1189.       str_numset(str, (double)ERR);
  1190.       break;
  1191. --- 793,798 ----
  1192. ***************
  1193. *** 631,639 ****
  1194.       case UV_LINES:
  1195.       str_numset(str, (double)LINES);
  1196.       break;
  1197. -     case UV_My_term:
  1198. -     str_numset(str, (double)My_term);
  1199. -     break;
  1200.       case UV_OK:
  1201.       str_numset(str, (double)OK);
  1202.       break;
  1203. --- 799,804 ----
  1204. ***************
  1205. *** 646,651 ****
  1206. --- 811,845 ----
  1207.       case UV_ttytype:
  1208.       str_set(str, ttytype);
  1209.       break;
  1210. + #ifdef BSD
  1211. +     case UV_Def_term:
  1212. +     str_set(str, Def_term);
  1213. +     break;
  1214. +     case UV_My_term:
  1215. +     str_numset(str, (double)My_term);
  1216. +     break;
  1217. + #endif
  1218. +     case UV_A_STANDOUT:
  1219. +     str_numset(str, (double)A_STANDOUT);
  1220. +     break;
  1221. +     case UV_A_UNDERLINE:
  1222. +     str_numset(str, (double)A_UNDERLINE);
  1223. +     break;
  1224. +     case UV_A_REVERSE:
  1225. +     str_numset(str, (double)A_REVERSE);
  1226. +     break;
  1227. +     case UV_A_BLINK:
  1228. +     str_numset(str, (double)A_BLINK);
  1229. +     break;
  1230. +     case UV_A_DIM:
  1231. +     str_numset(str, (double)A_DIM);
  1232. +     break;
  1233. +     case UV_A_BOLD:
  1234. +     str_numset(str, (double)A_BOLD);
  1235. +     break;
  1236. +     case UV_A_NORMAL:
  1237. +     str_numset(str, (double)A_NORMAL);
  1238. +     break;
  1239.       }
  1240.       return 0;
  1241.   }
  1242. ***************
  1243. *** 659,676 ****
  1244.       case UV_COLS:
  1245.       COLS = (int)str_gnum(str);
  1246.       break;
  1247. -     case UV_Def_term:
  1248. -     Def_term = savestr(str_get(str));    /* never freed */
  1249. -     break;
  1250.       case UV_LINES:
  1251.       LINES = (int)str_gnum(str);
  1252.       break;
  1253. -     case UV_My_term:
  1254. -     My_term = (bool)str_gnum(str);
  1255. -     break;
  1256.       case UV_ttytype:
  1257.       strcpy(ttytype, str_get(str));        /* hope it fits */
  1258.       break;
  1259.       }
  1260.       return 0;
  1261.   }
  1262. --- 853,878 ----
  1263.       case UV_COLS:
  1264.       COLS = (int)str_gnum(str);
  1265.       break;
  1266.       case UV_LINES:
  1267.       LINES = (int)str_gnum(str);
  1268.       break;
  1269.       case UV_ttytype:
  1270.       strcpy(ttytype, str_get(str));        /* hope it fits */
  1271. + #ifdef USG
  1272. +     if (tcbuf != NULL) {
  1273. +         free(tcbuf);
  1274. +         tcbuf = NULL;
  1275. +     }
  1276. + #endif    
  1277.       break;
  1278. + #ifdef BSD
  1279. +     case UV_Def_term:
  1280. +     Def_term = savestr(str_get(str));    /* never freed */
  1281. +     break;
  1282. +     case UV_My_term:
  1283. +     My_term = (bool)str_gnum(str);
  1284. +     break;
  1285. + #endif
  1286.       }
  1287.       return 0;
  1288.   }
  1289.  
  1290. Index: doSH
  1291. *** doSH.old    Tue Nov  5 19:25:54 1991
  1292. --- doSH    Tue Nov  5 19:25:54 1991
  1293. ***************
  1294. *** 3,8 ****
  1295. --- 3,10 ----
  1296.   : if this fails, just run all the .SH files by hand
  1297.   . ./config.sh
  1298.   
  1299. + rm -f x2p/config.sh
  1300. + 
  1301.   echo " "
  1302.   echo "Doing variable substitutions on .SH files..."
  1303.   set x `awk '{print $1}' <MANIFEST | grep '\.SH'`
  1304. ***************
  1305. *** 21,30 ****
  1306.       */*)
  1307.       dir=`expr X$file : 'X\(.*\)/'`
  1308.       file=`expr X$file : 'X.*/\(.*\)'`
  1309. !     (cd $dir && . $file)
  1310.       ;;
  1311.       *)
  1312. !     . $file
  1313.       ;;
  1314.       esac
  1315.   done
  1316. --- 23,32 ----
  1317.       */*)
  1318.       dir=`expr X$file : 'X\(.*\)/'`
  1319.       file=`expr X$file : 'X.*/\(.*\)'`
  1320. !     (cd $dir && . ./$file)
  1321.       ;;
  1322.       *)
  1323. !     . ./$file
  1324.       ;;
  1325.       esac
  1326.   done
  1327. ***************
  1328. *** 31,36 ****
  1329.   if test -f config.h.SH; then
  1330.       if test ! -f config.h; then
  1331.       : oops, they left it out of MANIFEST, probably, so do it anyway.
  1332. !     . config.h.SH
  1333.       fi
  1334.   fi
  1335. --- 33,39 ----
  1336.   if test -f config.h.SH; then
  1337.       if test ! -f config.h; then
  1338.       : oops, they left it out of MANIFEST, probably, so do it anyway.
  1339. !     . ./config.h.SH
  1340.       fi
  1341.   fi
  1342. + exit 0
  1343.  
  1344. Index: doarg.c
  1345. *** doarg.c.old    Tue Nov  5 19:25:57 1991
  1346. --- doarg.c    Tue Nov  5 19:25:58 1991
  1347. ***************
  1348. *** 1,4 ****
  1349. ! /* $RCSfile: doarg.c,v $$Revision: 4.0.1.3 $$Date: 91/06/10 01:18:41 $
  1350.    *
  1351.    *    Copyright (c) 1991, Larry Wall
  1352.    *
  1353. --- 1,4 ----
  1354. ! /* $RCSfile: doarg.c,v $$Revision: 4.0.1.4 $$Date: 91/11/05 16:35:06 $
  1355.    *
  1356.    *    Copyright (c) 1991, Larry Wall
  1357.    *
  1358. ***************
  1359. *** 6,11 ****
  1360. --- 6,20 ----
  1361.    *    License or the Artistic License, as specified in the README file.
  1362.    *
  1363.    * $Log:    doarg.c,v $
  1364. +  * Revision 4.0.1.4  91/11/05  16:35:06  lwall
  1365. +  * patch11: /$foo/o optimizer could access deallocated data
  1366. +  * patch11: minimum match length calculation in regexp is now cumulative
  1367. +  * patch11: added some support for 64-bit integers
  1368. +  * patch11: prepared for ctype implementations that don't define isascii()
  1369. +  * patch11: sprintf() now supports any length of s field
  1370. +  * patch11: indirect subroutine calls through magic vars (e.g. &$1) didn't work
  1371. +  * patch11: defined(&$foo) and undef(&$foo) didn't work
  1372. +  * 
  1373.    * Revision 4.0.1.3  91/06/10  01:18:41  lwall
  1374.    * patch10: pack(hh,1) dumped core
  1375.    * 
  1376. ***************
  1377. *** 78,86 ****
  1378.       spat->spat_regexp = regcomp(m,m+dstr->str_cur,
  1379.           spat->spat_flags & SPAT_FOLD);
  1380.       if (spat->spat_flags & SPAT_KEEP) {
  1381.           arg_free(spat->spat_runtime);    /* it won't change, so */
  1382.           spat->spat_runtime = Nullarg;    /* no point compiling again */
  1383. -         scanconst(spat, m, dstr->str_cur);
  1384.           hoistmust(spat);
  1385.               if (curcmd->c_expr && (curcmd->c_flags & CF_OPTIMIZE) == CFT_EVAL) {
  1386.                   curcmd->c_flags &= ~CF_OPTIMIZE;
  1387. --- 87,95 ----
  1388.       spat->spat_regexp = regcomp(m,m+dstr->str_cur,
  1389.           spat->spat_flags & SPAT_FOLD);
  1390.       if (spat->spat_flags & SPAT_KEEP) {
  1391. +         scanconst(spat, m, dstr->str_cur);
  1392.           arg_free(spat->spat_runtime);    /* it won't change, so */
  1393.           spat->spat_runtime = Nullarg;    /* no point compiling again */
  1394.           hoistmust(spat);
  1395.               if (curcmd->c_expr && (curcmd->c_flags & CF_OPTIMIZE) == CFT_EVAL) {
  1396.                   curcmd->c_flags &= ~CF_OPTIMIZE;
  1397. ***************
  1398. *** 151,157 ****
  1399.       }
  1400.       c = str_get(dstr);
  1401.       clen = dstr->str_cur;
  1402. !     if (clen <= spat->spat_slen + (int)spat->spat_regexp->regback) {
  1403.                       /* can do inplace substitution */
  1404.           if (regexec(spat->spat_regexp, s, strend, orig, 0,
  1405.             str->str_pok & SP_STUDIED ? str : Nullstr, safebase)) {
  1406. --- 160,166 ----
  1407.       }
  1408.       c = str_get(dstr);
  1409.       clen = dstr->str_cur;
  1410. !     if (clen <= spat->spat_regexp->minlen) {
  1411.                       /* can do inplace substitution */
  1412.           if (regexec(spat->spat_regexp, s, strend, orig, 0,
  1413.             str->str_pok & SP_STUDIED ? str : Nullstr, safebase)) {
  1414. ***************
  1415. *** 181,186 ****
  1416. --- 190,196 ----
  1417.               stack->ary_array[++sp] = arg->arg_ptr.arg_str;
  1418.               return sp;
  1419.               }
  1420. +             /*SUPPRESS 560*/
  1421.               else if (i = m - s) {    /* faster from front */
  1422.               d -= clen;
  1423.               m = d;
  1424. ***************
  1425. *** 217,222 ****
  1426. --- 227,233 ----
  1427.               if (iters++ > maxiters)
  1428.               fatal("Substitution loop");
  1429.               m = spat->spat_regexp->startp[0];
  1430. +             /*SUPPRESS 560*/
  1431.               if (i = m - s) {
  1432.               if (s != d)
  1433.                   (void)bcopy(s,d,i);
  1434. ***************
  1435. *** 407,412 ****
  1436. --- 418,424 ----
  1437.       register int len;
  1438.       int datumtype;
  1439.       STR *fromstr;
  1440. +     /*SUPPRESS 442*/
  1441.       static char *null10 = "\0\0\0\0\0\0\0\0\0\0";
  1442.       static char *space10 = "          ";
  1443.   
  1444. ***************
  1445. *** 417,422 ****
  1446. --- 429,438 ----
  1447.       unsigned int auint;
  1448.       long along;
  1449.       unsigned long aulong;
  1450. + #ifdef QUAD
  1451. +     quad aquad;
  1452. +     unsigned quad auquad;
  1453. + #endif
  1454.       char *aptr;
  1455.       float afloat;
  1456.       double adouble;
  1457. ***************
  1458. *** 431,439 ****
  1459.           len = index("@Xxu",datumtype) ? 0 : items;
  1460.           pat++;
  1461.       }
  1462. !     else if (isdigit(*pat)) {
  1463.           len = *pat++ - '0';
  1464. !         while (isdigit(*pat))
  1465.           len = (len * 10) + (*pat++ - '0');
  1466.       }
  1467.       else
  1468. --- 447,455 ----
  1469.           len = index("@Xxu",datumtype) ? 0 : items;
  1470.           pat++;
  1471.       }
  1472. !     else if (isDIGIT(*pat)) {
  1473.           len = *pat++ - '0';
  1474. !         while (isDIGIT(*pat))
  1475.           len = (len * 10) + (*pat++ - '0');
  1476.       }
  1477.       else
  1478. ***************
  1479. *** 573,579 ****
  1480.           items = 0;
  1481.           if (datumtype == 'H') {
  1482.               for (len = 0; len++ < aint;) {
  1483. !             if (isalpha(*pat))
  1484.                   items |= ((*pat++ & 15) + 9) & 15;
  1485.               else
  1486.                   items |= *pat++ & 15;
  1487. --- 589,595 ----
  1488.           items = 0;
  1489.           if (datumtype == 'H') {
  1490.               for (len = 0; len++ < aint;) {
  1491. !             if (isALPHA(*pat))
  1492.                   items |= ((*pat++ & 15) + 9) & 15;
  1493.               else
  1494.                   items |= *pat++ & 15;
  1495. ***************
  1496. *** 587,593 ****
  1497.           }
  1498.           else {
  1499.               for (len = 0; len++ < aint;) {
  1500. !             if (isalpha(*pat))
  1501.                   items |= (((*pat++ & 15) + 9) & 15) << 4;
  1502.               else
  1503.                   items |= (*pat++ & 15) << 4;
  1504. --- 603,609 ----
  1505.           }
  1506.           else {
  1507.               for (len = 0; len++ < aint;) {
  1508. !             if (isALPHA(*pat))
  1509.                   items |= (((*pat++ & 15) + 9) & 15) << 4;
  1510.               else
  1511.                   items |= (*pat++ & 15) << 4;
  1512. ***************
  1513. *** 691,696 ****
  1514. --- 707,728 ----
  1515.           str_ncat(str,(char*)&along,sizeof(long));
  1516.           }
  1517.           break;
  1518. + #ifdef QUAD
  1519. +     case 'Q':
  1520. +         while (len-- > 0) {
  1521. +         fromstr = NEXTFROM;
  1522. +         auquad = (unsigned quad)str_gnum(fromstr);
  1523. +         str_ncat(str,(char*)&auquad,sizeof(unsigned quad));
  1524. +         }
  1525. +         break;
  1526. +     case 'q':
  1527. +         while (len-- > 0) {
  1528. +         fromstr = NEXTFROM;
  1529. +         aquad = (quad)str_gnum(fromstr);
  1530. +         str_ncat(str,(char*)&aquad,sizeof(quad));
  1531. +         }
  1532. +         break;
  1533. + #endif /* QUAD */
  1534.       case 'p':
  1535.           while (len-- > 0) {
  1536.           fromstr = NEXTFROM;
  1537. ***************
  1538. *** 761,784 ****
  1539.       register char *t;
  1540.       register char *f;
  1541.       bool dolong;
  1542.       char ch;
  1543.       static STR *sargnull = &str_no;
  1544.       register char *send;
  1545.       char *xs;
  1546.       int xlen;
  1547.       double value;
  1548. -     char *origs;
  1549.   
  1550.       str_set(str,"");
  1551.       len--;            /* don't count pattern string */
  1552. !     origs = t = s = str_get(*sarg);
  1553.       send = s + (*sarg)->str_cur;
  1554.       sarg++;
  1555.       for ( ; ; len--) {
  1556. !     if (len <= 0 || !*sarg) {
  1557. !         sarg = &sargnull;
  1558. !         len = 0;
  1559. !     }
  1560.       for ( ; t < send && *t != '%'; t++) ;
  1561.       if (t >= send)
  1562.           break;        /* end of format string, ignore extra args */
  1563. --- 793,823 ----
  1564.       register char *t;
  1565.       register char *f;
  1566.       bool dolong;
  1567. + #ifdef QUAD
  1568. +     bool doquad;
  1569. + #endif /* QUAD */
  1570.       char ch;
  1571.       static STR *sargnull = &str_no;
  1572.       register char *send;
  1573. +     register STR *arg;
  1574.       char *xs;
  1575.       int xlen;
  1576. +     int pre;
  1577. +     int post;
  1578.       double value;
  1579.   
  1580.       str_set(str,"");
  1581.       len--;            /* don't count pattern string */
  1582. !     t = s = str_get(*sarg);
  1583.       send = s + (*sarg)->str_cur;
  1584.       sarg++;
  1585.       for ( ; ; len--) {
  1586. ! 
  1587. !     /*SUPPRESS 560*/
  1588. !     if (len <= 0 || !(arg = *sarg++))
  1589. !         arg = sargnull;
  1590. ! 
  1591. !     /*SUPPRESS 530*/
  1592.       for ( ; t < send && *t != '%'; t++) ;
  1593.       if (t >= send)
  1594.           break;        /* end of format string, ignore extra args */
  1595. ***************
  1596. *** 785,791 ****
  1597. --- 824,834 ----
  1598.       f = t;
  1599.       *buf = '\0';
  1600.       xs = buf;
  1601. + #ifdef QUAD
  1602. +     doquad =
  1603. + #endif /* QUAD */
  1604.       dolong = FALSE;
  1605. +     pre = post = 0;
  1606.       for (t++; t < send; t++) {
  1607.           switch (*t) {
  1608.           default:
  1609. ***************
  1610. *** 792,798 ****
  1611.           ch = *(++t);
  1612.           *t = '\0';
  1613.           (void)sprintf(xs,f);
  1614. !         len++;
  1615.           xlen = strlen(xs);
  1616.           break;
  1617.           case '0': case '1': case '2': case '3': case '4':
  1618. --- 835,841 ----
  1619.           ch = *(++t);
  1620.           *t = '\0';
  1621.           (void)sprintf(xs,f);
  1622. !         len++, sarg--;
  1623.           xlen = strlen(xs);
  1624.           break;
  1625.           case '0': case '1': case '2': case '3': case '4':
  1626. ***************
  1627. *** 800,811 ****
  1628.           case '.': case '#': case '-': case '+': case ' ':
  1629.           continue;
  1630.           case 'l':
  1631.           dolong = TRUE;
  1632.           continue;
  1633.           case 'c':
  1634.           ch = *(++t);
  1635.           *t = '\0';
  1636. !         xlen = (int)str_gnum(*(sarg++));
  1637.           if (strEQ(f,"%c")) { /* some printfs fail on null chars */
  1638.               *xs = xlen;
  1639.               xs[1] = '\0';
  1640. --- 843,860 ----
  1641.           case '.': case '#': case '-': case '+': case ' ':
  1642.           continue;
  1643.           case 'l':
  1644. + #ifdef QUAD
  1645. +         if (dolong) {
  1646. +             dolong = FALSE;
  1647. +             doquad = TRUE;
  1648. +         } else
  1649. + #endif
  1650.           dolong = TRUE;
  1651.           continue;
  1652.           case 'c':
  1653.           ch = *(++t);
  1654.           *t = '\0';
  1655. !         xlen = (int)str_gnum(arg);
  1656.           if (strEQ(f,"%c")) { /* some printfs fail on null chars */
  1657.               *xs = xlen;
  1658.               xs[1] = '\0';
  1659. ***************
  1660. *** 822,831 ****
  1661.           case 'd':
  1662.           ch = *(++t);
  1663.           *t = '\0';
  1664.           if (dolong)
  1665. !             (void)sprintf(xs,f,(long)str_gnum(*(sarg++)));
  1666.           else
  1667. !             (void)sprintf(xs,f,(int)str_gnum(*(sarg++)));
  1668.           xlen = strlen(xs);
  1669.           break;
  1670.           case 'X': case 'O':
  1671. --- 871,885 ----
  1672.           case 'd':
  1673.           ch = *(++t);
  1674.           *t = '\0';
  1675. + #ifdef QUAD
  1676. +         if (doquad)
  1677. +             (void)sprintf(buf,s,(quad)str_gnum(arg));
  1678. +         else
  1679. + #endif
  1680.           if (dolong)
  1681. !             (void)sprintf(xs,f,(long)str_gnum(arg));
  1682.           else
  1683. !             (void)sprintf(xs,f,(int)str_gnum(arg));
  1684.           xlen = strlen(xs);
  1685.           break;
  1686.           case 'X': case 'O':
  1687. ***************
  1688. *** 834,840 ****
  1689.           case 'x': case 'o': case 'u':
  1690.           ch = *(++t);
  1691.           *t = '\0';
  1692. !         value = str_gnum(*(sarg++));
  1693.           if (dolong)
  1694.               (void)sprintf(xs,f,U_L(value));
  1695.           else
  1696. --- 888,899 ----
  1697.           case 'x': case 'o': case 'u':
  1698.           ch = *(++t);
  1699.           *t = '\0';
  1700. !         value = str_gnum(arg);
  1701. ! #ifdef QUAD
  1702. !         if (doquad)
  1703. !             (void)sprintf(buf,s,(unsigned quad)value);
  1704. !         else
  1705. ! #endif
  1706.           if (dolong)
  1707.               (void)sprintf(xs,f,U_L(value));
  1708.           else
  1709. ***************
  1710. *** 844,862 ****
  1711.           case 'E': case 'e': case 'f': case 'G': case 'g':
  1712.           ch = *(++t);
  1713.           *t = '\0';
  1714. !         (void)sprintf(xs,f,str_gnum(*(sarg++)));
  1715.           xlen = strlen(xs);
  1716.           break;
  1717.           case 's':
  1718.           ch = *(++t);
  1719.           *t = '\0';
  1720. !         xs = str_get(*sarg);
  1721. !         xlen = (*sarg)->str_cur;
  1722.           if (*xs == 'S' && xs[1] == 't' && xs[2] == 'B' && xs[3] == '\0'
  1723.             && xlen == sizeof(STBP)) {
  1724.               STR *tmpstr = Str_new(24,0);
  1725.   
  1726. !             stab_fullname(tmpstr, ((STAB*)(*sarg))); /* a stab value! */
  1727.               sprintf(tokenbuf,"*%s",tmpstr->str_ptr);
  1728.                       /* reformat to non-binary */
  1729.               xs = tokenbuf;
  1730. --- 903,921 ----
  1731.           case 'E': case 'e': case 'f': case 'G': case 'g':
  1732.           ch = *(++t);
  1733.           *t = '\0';
  1734. !         (void)sprintf(xs,f,str_gnum(arg));
  1735.           xlen = strlen(xs);
  1736.           break;
  1737.           case 's':
  1738.           ch = *(++t);
  1739.           *t = '\0';
  1740. !         xs = str_get(arg);
  1741. !         xlen = arg->str_cur;
  1742.           if (*xs == 'S' && xs[1] == 't' && xs[2] == 'B' && xs[3] == '\0'
  1743.             && xlen == sizeof(STBP)) {
  1744.               STR *tmpstr = Str_new(24,0);
  1745.   
  1746. !             stab_fullname(tmpstr, ((STAB*)arg)); /* a stab value! */
  1747.               sprintf(tokenbuf,"*%s",tmpstr->str_ptr);
  1748.                       /* reformat to non-binary */
  1749.               xs = tokenbuf;
  1750. ***************
  1751. *** 863,872 ****
  1752.               xlen = strlen(tokenbuf);
  1753.               str_free(tmpstr);
  1754.           }
  1755. -         sarg++;
  1756.           if (strEQ(f,"%s")) {    /* some printfs fail on >128 chars */
  1757. !             break;        /* so handle simple case */
  1758.           }
  1759.           strcpy(tokenbuf+64,f);    /* sprintf($s,...$s...) */
  1760.           *t = ch;
  1761.           (void)sprintf(buf,tokenbuf+64,xs);
  1762. --- 922,958 ----
  1763.               xlen = strlen(tokenbuf);
  1764.               str_free(tmpstr);
  1765.           }
  1766.           if (strEQ(f,"%s")) {    /* some printfs fail on >128 chars */
  1767. !             break;        /* so handle simple cases */
  1768.           }
  1769. +         else if (f[1] == '-') {
  1770. +             char *mp = index(f, '.');
  1771. +             int min = atoi(f+2);
  1772. + 
  1773. +             if (xlen < min)
  1774. +             post = min - xlen;
  1775. +             else if (mp) {
  1776. +             int max = atoi(mp+1);
  1777. + 
  1778. +             if (xlen > max)
  1779. +                 xlen = max;
  1780. +             }
  1781. +             break;
  1782. +         }
  1783. +         else if (isDIGIT(f[1])) {
  1784. +             char *mp = index(f, '.');
  1785. +             int min = atoi(f+1);
  1786. + 
  1787. +             if (xlen < min)
  1788. +             pre = min - xlen;
  1789. +             else if (mp) {
  1790. +             int max = atoi(mp+1);
  1791. + 
  1792. +             if (xlen > max)
  1793. +                 xlen = max;
  1794. +             }
  1795. +             break;
  1796. +         }
  1797.           strcpy(tokenbuf+64,f);    /* sprintf($s,...$s...) */
  1798.           *t = ch;
  1799.           (void)sprintf(buf,tokenbuf+64,xs);
  1800. ***************
  1801. *** 876,884 ****
  1802.           }
  1803.           /* end of switch, copy results */
  1804.           *t = ch;
  1805. !         STR_GROW(str, str->str_cur + (f - s) + len + 1);
  1806.           str_ncat(str, s, f - s);
  1807.           str_ncat(str, xs, xlen);
  1808.           s = t;
  1809.           break;        /* break from for loop */
  1810.       }
  1811. --- 962,978 ----
  1812.           }
  1813.           /* end of switch, copy results */
  1814.           *t = ch;
  1815. !         STR_GROW(str, str->str_cur + (f - s) + xlen + 1 + pre + post);
  1816.           str_ncat(str, s, f - s);
  1817. +         if (pre) {
  1818. +         repeatcpy(str->str_ptr + str->str_cur, " ", 1, pre);
  1819. +         str->str_cur += pre;
  1820. +         }
  1821.           str_ncat(str, xs, xlen);
  1822. +         if (post) {
  1823. +         repeatcpy(str->str_ptr + str->str_cur, " ", 1, post);
  1824. +         str->str_cur += post;
  1825. +         }
  1826.           s = t;
  1827.           break;        /* break from for loop */
  1828.       }
  1829. ***************
  1830. *** 946,952 ****
  1831.       if ((arg[1].arg_type & A_MASK) == A_WORD)
  1832.       stab = arg[1].arg_ptr.arg_stab;
  1833.       else {
  1834. !     STR *tmpstr = stab_val(arg[1].arg_ptr.arg_stab);
  1835.   
  1836.       if (tmpstr)
  1837.           stab = stabent(str_get(tmpstr),TRUE);
  1838. --- 1040,1046 ----
  1839.       if ((arg[1].arg_type & A_MASK) == A_WORD)
  1840.       stab = arg[1].arg_ptr.arg_stab;
  1841.       else {
  1842. !     STR *tmpstr = STAB_STR(arg[1].arg_ptr.arg_stab);
  1843.   
  1844.       if (tmpstr)
  1845.           stab = stabent(str_get(tmpstr),TRUE);
  1846. ***************
  1847. *** 1034,1040 ****
  1848.       HASH *hash;
  1849.       int i;
  1850.   
  1851. !     makelocal = (arg->arg_flags & AF_LOCAL);
  1852.       localizing = makelocal;
  1853.       delaymagic = DM_DELAY;        /* catch simultaneous items */
  1854.   
  1855. --- 1128,1134 ----
  1856.       HASH *hash;
  1857.       int i;
  1858.   
  1859. !     makelocal = (arg->arg_flags & AF_LOCAL) != 0;
  1860.       localizing = makelocal;
  1861.       delaymagic = DM_DELAY;        /* catch simultaneous items */
  1862.   
  1863. ***************
  1864. *** 1044,1049 ****
  1865. --- 1138,1144 ----
  1866.        */
  1867.       if (arg->arg_flags & AF_COMMON) {
  1868.       for (relem = firstrelem; relem <= lastrelem; relem++) {
  1869. +         /*SUPPRESS 560*/
  1870.           if (str = *relem)
  1871.           *relem = str_mortal(str);
  1872.       }
  1873. ***************
  1874. *** 1179,1185 ****
  1875.       }
  1876.   }
  1877.   
  1878. ! int
  1879.   do_study(str,arg,gimme,arglast)
  1880.   STR *str;
  1881.   ARG *arg;
  1882. --- 1274,1280 ----
  1883.       }
  1884.   }
  1885.   
  1886. ! int                    /*SUPPRESS 590*/
  1887.   do_study(str,arg,gimme,arglast)
  1888.   STR *str;
  1889.   ARG *arg;
  1890. ***************
  1891. *** 1254,1260 ****
  1892.       return retarg;
  1893.   }
  1894.   
  1895. ! int
  1896.   do_defined(str,arg,gimme,arglast)
  1897.   STR *str;
  1898.   register ARG *arg;
  1899. --- 1349,1355 ----
  1900.       return retarg;
  1901.   }
  1902.   
  1903. ! int                    /*SUPPRESS 590*/
  1904.   do_defined(str,arg,gimme,arglast)
  1905.   STR *str;
  1906.   register ARG *arg;
  1907. ***************
  1908. *** 1272,1279 ****
  1909.       arg = arg[1].arg_ptr.arg_arg;
  1910.       type = arg->arg_type;
  1911.   
  1912. !     if (type == O_SUBR || type == O_DBSUBR)
  1913. !     retval = stab_sub(arg[1].arg_ptr.arg_stab) != 0;
  1914.       else if (type == O_ARRAY || type == O_LARRAY ||
  1915.            type == O_ASLICE || type == O_LASLICE )
  1916.       retval = ((ary = stab_xarray(arg[1].arg_ptr.arg_stab)) != 0
  1917. --- 1367,1381 ----
  1918.       arg = arg[1].arg_ptr.arg_arg;
  1919.       type = arg->arg_type;
  1920.   
  1921. !     if (type == O_SUBR || type == O_DBSUBR) {
  1922. !     if ((arg[1].arg_type & A_MASK) == A_WORD)
  1923. !         retval = stab_sub(arg[1].arg_ptr.arg_stab) != 0;
  1924. !     else {
  1925. !         STR *tmpstr = STAB_STR(arg[1].arg_ptr.arg_stab);
  1926. ! 
  1927. !         retval = tmpstr && stab_sub(stabent(str_get(tmpstr),TRUE)) != 0;
  1928. !     }
  1929. !     }
  1930.       else if (type == O_ARRAY || type == O_LARRAY ||
  1931.            type == O_ASLICE || type == O_LASLICE )
  1932.       retval = ((ary = stab_xarray(arg[1].arg_ptr.arg_stab)) != 0
  1933. ***************
  1934. *** 1289,1295 ****
  1935.       return retarg;
  1936.   }
  1937.   
  1938. ! int
  1939.   do_undef(str,arg,gimme,arglast)
  1940.   STR *str;
  1941.   register ARG *arg;
  1942. --- 1391,1397 ----
  1943.       return retarg;
  1944.   }
  1945.   
  1946. ! int                        /*SUPPRESS 590*/
  1947.   do_undef(str,arg,gimme,arglast)
  1948.   STR *str;
  1949.   register ARG *arg;
  1950. ***************
  1951. *** 1325,1331 ****
  1952.       }
  1953.       else if (type == O_SUBR || type == O_DBSUBR) {
  1954.       stab = arg[1].arg_ptr.arg_stab;
  1955. !     if (stab_sub(stab)) {
  1956.           cmd_free(stab_sub(stab)->cmd);
  1957.           stab_sub(stab)->cmd = Nullcmd;
  1958.           afree(stab_sub(stab)->tosave);
  1959. --- 1427,1441 ----
  1960.       }
  1961.       else if (type == O_SUBR || type == O_DBSUBR) {
  1962.       stab = arg[1].arg_ptr.arg_stab;
  1963. !     if ((arg[1].arg_type & A_MASK) != A_WORD) {
  1964. !         STR *tmpstr = STAB_STR(arg[1].arg_ptr.arg_stab);
  1965. ! 
  1966. !         if (tmpstr)
  1967. !         stab = stabent(str_get(tmpstr),TRUE);
  1968. !         else
  1969. !         stab = Nullstab;
  1970. !     }
  1971. !     if (stab && stab_sub(stab)) {
  1972.           cmd_free(stab_sub(stab)->cmd);
  1973.           stab_sub(stab)->cmd = Nullcmd;
  1974.           afree(stab_sub(stab)->tosave);
  1975. ***************
  1976. *** 1376,1384 ****
  1977.           if (size == 8)
  1978.           retnum = s[offset];
  1979.           else if (size == 16)
  1980. !         retnum = (s[offset] << 8) + s[offset+1];
  1981.           else if (size == 32)
  1982. !         retnum = (s[offset] << 24) + (s[offset + 1] << 16) +
  1983.               (s[offset + 2] << 8) + s[offset+3];
  1984.       }
  1985.   
  1986. --- 1486,1495 ----
  1987.           if (size == 8)
  1988.           retnum = s[offset];
  1989.           else if (size == 16)
  1990. !         retnum = ((unsigned long) s[offset] << 8) + s[offset+1];
  1991.           else if (size == 32)
  1992. !         retnum = ((unsigned long) s[offset] << 24) +
  1993. !             ((unsigned long) s[offset + 1] << 16) +
  1994.               (s[offset + 2] << 8) + s[offset+3];
  1995.       }
  1996.   
  1997. ***************
  1998. *** 1458,1463 ****
  1999. --- 1569,1575 ----
  2000.       if (str->str_state == SS_HASH) {
  2001.       hash = stab_hash(str->str_u.str_stab);
  2002.       (void)hiterinit(hash);
  2003. +     /*SUPPRESS 560*/
  2004.       while (entry = hiternext(hash))
  2005.           do_chop(astr,hiterval(hash,entry));
  2006.       return;
  2007.  
  2008. *** End of Patch 13 ***
  2009. exit 0 # Just in case...
  2010. -- 
  2011. Kent Landfield                   INTERNET: kent@sparky.IMD.Sterling.COM
  2012. Sterling Software, IMD           UUCP:     uunet!sparky!kent
  2013. Phone:    (402) 291-8300         FAX:      (402) 291-4362
  2014. Please send comp.sources.misc-related mail to kent@uunet.uu.net.
  2015.