home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / misc / volume30 / perl / patch25 < prev    next >
Encoding:
Text File  |  1992-06-11  |  49.3 KB  |  1,978 lines
  1. Newsgroups: comp.sources.misc
  2. From: lwall@netlabs.com (Larry Wall)
  3. Subject:  v30i036:  perl - The perl programming language, Patch25
  4. Message-ID: <1992Jun11.180426.453@sparky.imd.sterling.com>
  5. X-Md4-Signature: 4b560f3d04c7edc27e8bfaff209700d2
  6. Date: Thu, 11 Jun 1992 18:04:26 GMT
  7. Approved: kent@sparky.imd.sterling.com
  8.  
  9. Submitted-by: lwall@netlabs.com (Larry Wall)
  10. Posting-number: Volume 30, Issue 36
  11. Archive-name: perl/patch25
  12. Environment: UNIX, MS-DOS, OS2
  13. Patch-To: perl: Volume 18, Issue 19-54
  14.  
  15. System: perl version 4.0
  16. Patch #: 25
  17. Priority: highish
  18. Subject: patch #20, continued
  19.  
  20. Description:
  21.     See patch #20.
  22.  
  23. Fix:    From rn, say "| patch -p -N -d DIR", where DIR is your perl source
  24.     directory.  Outside of rn, say "cd DIR; patch -p -N <thisarticle".
  25.     If you don't have the patch program, apply the following by hand,
  26.     or get patch (version 2.0, latest patchlevel).
  27.  
  28.     After patching:
  29.         *** DO NOTHING--INSTALL ALL PATCHES UP THROUGH #33 FIRST ***
  30.  
  31.     If patch indicates that patchlevel is the wrong version, you may need
  32.     to apply one or more previous patches, or the patch may already
  33.     have been applied.  See the patchlevel.h file to find out what has or
  34.     has not been applied.  In any event, don't continue with the patch.
  35.  
  36.     If you are missing previous patches they can be obtained from me:
  37.  
  38.     Larry Wall
  39.     lwall@netlabs.com
  40.  
  41.     If you send a mail message of the following form it will greatly speed
  42.     processing:
  43.  
  44.     Subject: Command
  45.     @SH mailpatch PATH perl 4.0 LIST
  46.            ^ note the c
  47.  
  48.     where PATH is a return path FROM ME TO YOU either in Internet notation,
  49.     or in bang notation from some well-known host, and LIST is the number
  50.     of one or more patches you need, separated by spaces, commas, and/or
  51.     hyphens.  Saying 35- says everything from 35 to the end.
  52.  
  53.  
  54. Index: patchlevel.h
  55. Prereq: 24
  56. 1c1
  57. < #define PATCHLEVEL 24
  58. ---
  59. > #define PATCHLEVEL 25
  60.  
  61. Index: cons.c
  62. *** cons.c.old    Mon Jun  8 17:46:18 1992
  63. --- cons.c    Mon Jun  8 17:46:19 1992
  64. ***************
  65. *** 1,4 ****
  66. ! /* $RCSfile: cons.c,v $$Revision: 4.0.1.2 $$Date: 91/11/05 16:15:13 $
  67.    *
  68.    *    Copyright (c) 1991, Larry Wall
  69.    *
  70. --- 1,4 ----
  71. ! /* $RCSfile: cons.c,v $$Revision: 4.0.1.3 $$Date: 92/06/08 12:18:35 $
  72.    *
  73.    *    Copyright (c) 1991, Larry Wall
  74.    *
  75. ***************
  76. *** 6,11 ****
  77. --- 6,21 ----
  78.    *    License or the Artistic License, as specified in the README file.
  79.    *
  80.    * $Log:    cons.c,v $
  81. +  * Revision 4.0.1.3  92/06/08  12:18:35  lwall
  82. +  * patch20: removed implicit int declarations on funcions
  83. +  * patch20: deleted some minor memory leaks
  84. +  * patch20: fixed double debug break in foreach with implicit array assignment
  85. +  * patch20: fixed confusion between a *var's real name and its effective name
  86. +  * patch20: Perl now distinguishes overlapped copies from non-overlapped
  87. +  * patch20: debugger sometimes displayed wrong source line
  88. +  * patch20: various error messages have been clarified
  89. +  * patch20: an eval block containing a null block or statement could dump core
  90. +  * 
  91.    * Revision 4.0.1.2  91/11/05  16:15:13  lwall
  92.    * patch11: debugger got confused over nested subroutine definitions
  93.    * patch11: prepared for ctype implementations that don't define isascii()
  94. ***************
  95. *** 29,34 ****
  96. --- 39,46 ----
  97.   static int cmd_tosave();
  98.   static int arg_tosave();
  99.   static int spat_tosave();
  100. + static void make_cswitch();
  101. + static void make_nswitch();
  102.   
  103.   static bool saw_return;
  104.   
  105. ***************
  106. *** 40,47 ****
  107.       register SUBR *sub;
  108.       STAB *stab = stabent(name,TRUE);
  109.   
  110. !     Newz(101,sub,1,SUBR);
  111. !     if (stab_sub(stab)) {
  112.       if (dowarn) {
  113.           CMD *oldcurcmd = curcmd;
  114.   
  115. --- 52,58 ----
  116.       register SUBR *sub;
  117.       STAB *stab = stabent(name,TRUE);
  118.   
  119. !     if (sub = stab_sub(stab)) {
  120.       if (dowarn) {
  121.           CMD *oldcurcmd = curcmd;
  122.   
  123. ***************
  124. *** 50,62 ****
  125.           warn("Subroutine %s redefined",name);
  126.           curcmd = oldcurcmd;
  127.       }
  128. !     if (stab_sub(stab)->cmd) {
  129. !         cmd_free(stab_sub(stab)->cmd);
  130. !         stab_sub(stab)->cmd = Nullcmd;
  131. !         afree(stab_sub(stab)->tosave);
  132.       }
  133. !     Safefree(stab_sub(stab));
  134.       }
  135.       stab_sub(stab) = sub;
  136.       sub->filestab = curcmd->c_filestab;
  137.       saw_return = FALSE;
  138. --- 61,74 ----
  139.           warn("Subroutine %s redefined",name);
  140.           curcmd = oldcurcmd;
  141.       }
  142. !     if (!sub->usersub && sub->cmd) {
  143. !         cmd_free(sub->cmd);
  144. !         sub->cmd = Nullcmd;
  145. !         afree(sub->tosave);
  146.       }
  147. !     Safefree(sub);
  148.       }
  149. +     Newz(101,sub,1,SUBR);
  150.       stab_sub(stab) = sub;
  151.       sub->filestab = curcmd->c_filestab;
  152.       saw_return = FALSE;
  153. ***************
  154. *** 69,75 ****
  155.   
  156.       mycompblock.comp_true = cmd;
  157.       mycompblock.comp_alt = Nullcmd;
  158. !     cmd = add_label(savestr("_SUB_"),make_ccmd(C_BLOCK,Nullarg,mycompblock));
  159.       saw_return = FALSE;
  160.       cmd->c_flags |= CF_TERM;
  161.       }
  162. --- 81,88 ----
  163.   
  164.       mycompblock.comp_true = cmd;
  165.       mycompblock.comp_alt = Nullcmd;
  166. !     cmd = add_label(savestr("_SUB_"),make_ccmd(C_BLOCK,0,
  167. !         Nullarg,mycompblock));
  168.       saw_return = FALSE;
  169.       cmd->c_flags |= CF_TERM;
  170.       }
  171. ***************
  172. *** 83,92 ****
  173.       str_cat(str,"-");
  174.       sprintf(buf,"%ld",(long)curcmd->c_line);
  175.       str_cat(str,buf);
  176. !     name = str_get(subname);
  177. !     stab_fullname(tmpstr,stab);
  178.       hstore(stab_xhash(DBsub), tmpstr->str_ptr, tmpstr->str_cur, str, 0);
  179.       }
  180.       return sub;
  181.   }
  182.   
  183. --- 96,105 ----
  184.       str_cat(str,"-");
  185.       sprintf(buf,"%ld",(long)curcmd->c_line);
  186.       str_cat(str,buf);
  187. !     stab_efullname(tmpstr,stab);
  188.       hstore(stab_xhash(DBsub), tmpstr->str_ptr, tmpstr->str_cur, str, 0);
  189.       }
  190. +     Safefree(name);
  191.       return sub;
  192.   }
  193.   
  194. ***************
  195. *** 102,118 ****
  196.   
  197.       if (!stab)                /* unused function */
  198.       return Null(SUBR*);
  199. !     Newz(101,sub,1,SUBR);
  200. !     if (stab_sub(stab)) {
  201.       if (dowarn)
  202.           warn("Subroutine %s redefined",name);
  203. !     if (stab_sub(stab)->cmd) {
  204. !         cmd_free(stab_sub(stab)->cmd);
  205. !         stab_sub(stab)->cmd = Nullcmd;
  206. !         afree(stab_sub(stab)->tosave);
  207.       }
  208. !     Safefree(stab_sub(stab));
  209.       }
  210.       stab_sub(stab) = sub;
  211.       sub->filestab = fstab(filename);
  212.       sub->usersub = subaddr;
  213. --- 115,131 ----
  214.   
  215.       if (!stab)                /* unused function */
  216.       return Null(SUBR*);
  217. !     if (sub = stab_sub(stab)) {
  218.       if (dowarn)
  219.           warn("Subroutine %s redefined",name);
  220. !     if (!sub->usersub && sub->cmd) {
  221. !         cmd_free(sub->cmd);
  222. !         sub->cmd = Nullcmd;
  223. !         afree(sub->tosave);
  224.       }
  225. !     Safefree(sub);
  226.       }
  227. +     Newz(101,sub,1,SUBR);
  228.       stab_sub(stab) = sub;
  229.       sub->filestab = fstab(filename);
  230.       sub->usersub = subaddr;
  231. ***************
  232. *** 120,125 ****
  233. --- 133,139 ----
  234.       return sub;
  235.   }
  236.   
  237. + void
  238.   make_form(stab,fcmd)
  239.   STAB *stab;
  240.   FCMD *fcmd;
  241. ***************
  242. *** 188,198 ****
  243.       /* now do a little optimization on case-ish structures */
  244.       switch(tail->c_flags & (CF_OPTIMIZE|CF_FIRSTNEG|CF_INVERT)) {
  245.       case CFT_ANCHOR:
  246. -         if (stabent("*",FALSE)) {    /* bad assumption here!!! */
  247. -         opt = 0;
  248. -         break;
  249. -         }
  250. -         /* FALL THROUGH */
  251.       case CFT_STROP:
  252.           opt = (tail->c_flags & CF_NESURE) ? CFT_STROP : 0;
  253.           break;
  254. --- 202,207 ----
  255. ***************
  256. *** 239,244 ****
  257. --- 248,254 ----
  258.    * spat.  Thus we can insert a SWITCH in front and jump directly
  259.    * to the correct one.
  260.    */
  261. + static void
  262.   make_cswitch(head,count)
  263.   register CMD *head;
  264.   int count;
  265. ***************
  266. *** 251,262 ****
  267.   
  268.       /* make a new head in the exact same spot */
  269.       New(102,cur, 1, CMD);
  270. ! #ifdef STRUCTCOPY
  271. !     *cur = *head;
  272. ! #else
  273. !     Copy(head,cur,1,CMD);
  274. ! #endif
  275.       Zero(head,1,CMD);
  276.       head->c_type = C_CSWITCH;
  277.       head->c_next = cur;        /* insert new cmd at front of list */
  278.       head->c_stab = cur->c_stab;
  279. --- 261,269 ----
  280.   
  281.       /* make a new head in the exact same spot */
  282.       New(102,cur, 1, CMD);
  283. !     StructCopy(head,cur,CMD);
  284.       Zero(head,1,CMD);
  285. +     head->c_head = cur->c_head;
  286.       head->c_type = C_CSWITCH;
  287.       head->c_next = cur;        /* insert new cmd at front of list */
  288.       head->c_stab = cur->c_stab;
  289. ***************
  290. *** 289,295 ****
  291.       }
  292.       max++;
  293.       if (min > 0)
  294. !     Copy(&loc[min],&loc[0], max - min, CMD*);
  295.       loc--;
  296.       min--;
  297.       max -= min;
  298. --- 296,302 ----
  299.       }
  300.       max++;
  301.       if (min > 0)
  302. !     Move(&loc[min],&loc[0], max - min, CMD*);
  303.       loc--;
  304.       min--;
  305.       max -= min;
  306. ***************
  307. *** 302,307 ****
  308. --- 309,315 ----
  309.       head->ucmd.scmd.sc_next = loc;
  310.   }
  311.   
  312. + static void
  313.   make_nswitch(head,count)
  314.   register CMD *head;
  315.   int count;
  316. ***************
  317. *** 339,350 ****
  318.   
  319.       /* now make a new head in the exact same spot */
  320.       New(104,cur, 1, CMD);
  321. ! #ifdef STRUCTCOPY
  322. !     *cur = *head;
  323. ! #else
  324. !     Copy(head,cur,1,CMD);
  325. ! #endif
  326.       Zero(head,1,CMD);
  327.       head->c_type = C_NSWITCH;
  328.       head->c_next = cur;        /* insert new cmd at front of list */
  329.       head->c_stab = cur->c_stab;
  330. --- 347,355 ----
  331.   
  332.       /* now make a new head in the exact same spot */
  333.       New(104,cur, 1, CMD);
  334. !     StructCopy(head,cur,CMD);
  335.       Zero(head,1,CMD);
  336. +     head->c_head = cur->c_head;
  337.       head->c_type = C_NSWITCH;
  338.       head->c_next = cur;        /* insert new cmd at front of list */
  339.       head->c_stab = cur->c_stab;
  340. ***************
  341. *** 443,448 ****
  342. --- 448,454 ----
  343.       stab2arg(A_WORD,DBstab),
  344.       Nullarg,
  345.       Nullarg);
  346. +     /*SUPPRESS 53*/
  347.       cmd->c_flags |= CF_COND|CF_DBSUB|CFT_D0;
  348.       cmd->c_line = head->c_line;
  349.       cmd->c_label = head->c_label;
  350. ***************
  351. *** 481,488 ****
  352.   }
  353.   
  354.   CMD *
  355. ! make_ccmd(type,arg,cblock)
  356.   int type;
  357.   ARG *arg;
  358.   struct compcmd cblock;
  359.   {
  360. --- 487,495 ----
  361.   }
  362.   
  363.   CMD *
  364. ! make_ccmd(type,debuggable,arg,cblock)
  365.   int type;
  366. + int debuggable;
  367.   ARG *arg;
  368.   struct compcmd cblock;
  369.   {
  370. ***************
  371. *** 503,509 ****
  372.       }
  373.       cmd->c_filestab = curcmd->c_filestab;
  374.       cmd->c_stash = curstash;
  375. !     if (perldb)
  376.       cmd = dodb(cmd);
  377.       return cmd;
  378.   }
  379. --- 510,516 ----
  380.       }
  381.       cmd->c_filestab = curcmd->c_filestab;
  382.       cmd->c_stash = curstash;
  383. !     if (perldb && debuggable)
  384.       cmd = dodb(cmd);
  385.       return cmd;
  386.   }
  387. ***************
  388. *** 545,551 ****
  389.       if (alt) {            /* a real life ELSE at the end? */
  390.       ncblock.comp_true = alt;
  391.       ncblock.comp_alt = Nullcmd;
  392. !     alt = append_line(cur,make_ccmd(C_ELSE,Nullarg,ncblock));
  393.       cur->ucmd.ccmd.cc_alt = alt;
  394.       }
  395.       else
  396. --- 552,558 ----
  397.       if (alt) {            /* a real life ELSE at the end? */
  398.       ncblock.comp_true = alt;
  399.       ncblock.comp_alt = Nullcmd;
  400. !     alt = append_line(cur,make_ccmd(C_ELSE,1,Nullarg,ncblock));
  401.       cur->ucmd.ccmd.cc_alt = alt;
  402.       }
  403.       else
  404. ***************
  405. *** 693,698 ****
  406. --- 700,706 ----
  407.           sure |= CF_EQSURE;        /* (SUBST must be forced even */
  408.                           /* if we know it will work.) */
  409.           if (arg->arg_type != O_SUBST) {
  410. +         str_free(arg[2].arg_ptr.arg_spat->spat_short);
  411.           arg[2].arg_ptr.arg_spat->spat_short = Nullstr;
  412.           arg[2].arg_ptr.arg_spat->spat_slen = 0; /* only one chk */
  413.           }
  414. ***************
  415. *** 901,906 ****
  416. --- 909,926 ----
  417.       return cmd;
  418.   }
  419.   
  420. + void
  421. + cpy7bit(d,s,l)
  422. + register char *d;
  423. + register char *s;
  424. + register int l;
  425. + {
  426. +     while (l--)
  427. +     *d++ = *s++ & 127;
  428. +     *d = '\0';
  429. + }
  430. + 
  431. + int
  432.   yyerror(s)
  433.   char *s;
  434.   {
  435. ***************
  436. *** 912,919 ****
  437.         oldoldbufptr != oldbufptr && oldbufptr != bufptr) {
  438.       while (isSPACE(*oldoldbufptr))
  439.           oldoldbufptr++;
  440. !     strncpy(tmp2buf, oldoldbufptr, bufptr - oldoldbufptr);
  441. !     tmp2buf[bufptr - oldoldbufptr] = '\0';
  442.       sprintf(tname,"next 2 tokens \"%s\"",tmp2buf);
  443.       }
  444.       else if (bufptr > oldbufptr && bufptr - oldbufptr < 200 &&
  445. --- 932,938 ----
  446.         oldoldbufptr != oldbufptr && oldbufptr != bufptr) {
  447.       while (isSPACE(*oldoldbufptr))
  448.           oldoldbufptr++;
  449. !     cpy7bit(tmp2buf, oldoldbufptr, bufptr - oldoldbufptr);
  450.       sprintf(tname,"next 2 tokens \"%s\"",tmp2buf);
  451.       }
  452.       else if (bufptr > oldbufptr && bufptr - oldbufptr < 200 &&
  453. ***************
  454. *** 920,927 ****
  455.         oldbufptr != bufptr) {
  456.       while (isSPACE(*oldbufptr))
  457.           oldbufptr++;
  458. !     strncpy(tmp2buf, oldbufptr, bufptr - oldbufptr);
  459. !     tmp2buf[bufptr - oldbufptr] = '\0';
  460.       sprintf(tname,"next token \"%s\"",tmp2buf);
  461.       }
  462.       else if (yychar > 256)
  463. --- 939,945 ----
  464.         oldbufptr != bufptr) {
  465.       while (isSPACE(*oldbufptr))
  466.           oldbufptr++;
  467. !     cpy7bit(tmp2buf, oldbufptr, bufptr - oldbufptr);
  468.       sprintf(tname,"next token \"%s\"",tmp2buf);
  469.       }
  470.       else if (yychar > 256)
  471. ***************
  472. *** 1101,1107 ****
  473.       cmd->ucmd.ccmd.cc_alt = tail;    /* every loop has a continue now */
  474.   
  475.   #ifndef lint
  476. !     (void)bcopy((char *)cmd, (char *)tail, sizeof(CMD));
  477.   #endif
  478.       tail->c_type = C_EXPR;
  479.       tail->c_flags ^= CF_INVERT;        /* turn into "last unless" */
  480. --- 1119,1125 ----
  481.       cmd->ucmd.ccmd.cc_alt = tail;    /* every loop has a continue now */
  482.   
  483.   #ifndef lint
  484. !     Copy((char *)cmd, (char *)tail, 1, CMD);
  485.   #endif
  486.       tail->c_type = C_EXPR;
  487.       tail->c_flags ^= CF_INVERT;        /* turn into "last unless" */
  488. ***************
  489. *** 1127,1132 ****
  490. --- 1145,1151 ----
  491.       return cmd;
  492.   }
  493.   
  494. + void
  495.   cmd_free(cmd)
  496.   register CMD *cmd;
  497.   {
  498. ***************
  499. *** 1133,1138 ****
  500. --- 1152,1161 ----
  501.       register CMD *tofree;
  502.       register CMD *head = cmd;
  503.   
  504. +     if (!cmd)
  505. +     return;
  506. +     if (cmd->c_head != cmd)
  507. +     warn("Malformed cmd links\n");
  508.       while (cmd) {
  509.       if (cmd->c_type != C_WHILE) {    /* WHILE block is duplicated */
  510.           if (cmd->c_label) {
  511. ***************
  512. *** 1175,1185 ****
  513. --- 1198,1211 ----
  514.       Safefree(head);
  515.   }
  516.   
  517. + void
  518.   arg_free(arg)
  519.   register ARG *arg;
  520.   {
  521.       register int i;
  522.   
  523. +     if (!arg)
  524. +     return;
  525.       for (i = 1; i <= arg->arg_len; i++) {
  526.       switch (arg[i].arg_type & A_MASK) {
  527.       case A_NULL:
  528. ***************
  529. *** 1231,1236 ****
  530. --- 1257,1263 ----
  531.       free_arg(arg);
  532.   }
  533.   
  534. + void
  535.   spat_free(spat)
  536.   register SPAT *spat;
  537.   {
  538. ***************
  539. *** 1237,1242 ****
  540. --- 1264,1271 ----
  541.       register SPAT *sp;
  542.       HENT *entry;
  543.   
  544. +     if (!spat)
  545. +     return;
  546.       if (spat->spat_runtime) {
  547.       arg_free(spat->spat_runtime);
  548.       spat->spat_runtime = Nullarg;
  549.  
  550. Index: atarist/test/dbm
  551. *** atarist/test/dbm.old    Mon Jun  8 17:44:58 1992
  552. --- atarist/test/dbm    Mon Jun  8 17:44:59 1992
  553. ***************
  554. *** 0 ****
  555. --- 1,124 ----
  556. + die "cant create dbmtest" unless dbmopen(%keys, "dbmtest", 0666);
  557. + 
  558. + print "Writing...\n";
  559. + $keys{'key0'} = 0;
  560. + $keys{'key1'} = 1;
  561. + $keys{'key2'} = 2;
  562. + $keys{'key3'} = 3;
  563. + $keys{'key4'} = 4;
  564. + $keys{'key5'} = 5;
  565. + $keys{'key6'} = 6;
  566. + $keys{'key7'} = 7;
  567. + $keys{'key8'} = 8;
  568. + $keys{'key9'} = 9;
  569. + $keys{'key10'} = 10;
  570. + $keys{'key11'} = 11;
  571. + $keys{'key12'} = 12;
  572. + $keys{'key13'} = 13;
  573. + $keys{'key14'} = 14;
  574. + $keys{'key15'} = 15;
  575. + $keys{'key16'} = 16;
  576. + $keys{'key17'} = 17;
  577. + $keys{'key18'} = 18;
  578. + $keys{'key19'} = 19;
  579. + $keys{'key20'} = 20;
  580. + $keys{'key21'} = 21;
  581. + $keys{'key22'} = 22;
  582. + $keys{'key23'} = 23;
  583. + $keys{'key24'} = 24;
  584. + $keys{'key25'} = 25;
  585. + $keys{'key26'} = 26;
  586. + $keys{'key27'} = 27;
  587. + $keys{'key28'} = 28;
  588. + $keys{'key29'} = 29;
  589. + $keys{'key30'} = 30;
  590. + $keys{'key31'} = 31;
  591. + $keys{'key32'} = 32;
  592. + $keys{'key33'} = 33;
  593. + $keys{'key34'} = 34;
  594. + $keys{'key35'} = 35;
  595. + $keys{'key36'} = 36;
  596. + $keys{'key37'} = 37;
  597. + $keys{'key38'} = 38;
  598. + $keys{'key39'} = 39;
  599. + $keys{'key40'} = 40;
  600. + $keys{'key41'} = 41;
  601. + $keys{'key42'} = 42;
  602. + $keys{'key43'} = 43;
  603. + $keys{'key44'} = 44;
  604. + $keys{'key45'} = 45;
  605. + $keys{'key46'} = 46;
  606. + $keys{'key47'} = 47;
  607. + $keys{'key48'} = 48;
  608. + $keys{'key49'} = 49;
  609. + $keys{'key50'} = 50;
  610. + $keys{'key51'} = 51;
  611. + $keys{'key52'} = 52;
  612. + $keys{'key53'} = 53;
  613. + $keys{'key54'} = 54;
  614. + $keys{'key55'} = 55;
  615. + $keys{'key56'} = 56;
  616. + $keys{'key57'} = 57;
  617. + $keys{'key58'} = 58;
  618. + $keys{'key59'} = 59;
  619. + $keys{'key60'} = 60;
  620. + $keys{'key61'} = 61;
  621. + $keys{'key62'} = 62;
  622. + $keys{'key63'} = 63;
  623. + $keys{'key64'} = 64;
  624. + $keys{'key65'} = 65;
  625. + $keys{'key66'} = 66;
  626. + $keys{'key67'} = 67;
  627. + $keys{'key68'} = 68;
  628. + $keys{'key69'} = 69;
  629. + $keys{'key70'} = 70;
  630. + $keys{'key71'} = 71;
  631. + $keys{'key72'} = 72;
  632. + $keys{'key73'} = 73;
  633. + $keys{'key74'} = 74;
  634. + $keys{'key75'} = 75;
  635. + $keys{'key76'} = 76;
  636. + $keys{'key77'} = 77;
  637. + $keys{'key78'} = 78;
  638. + $keys{'key79'} = 79;
  639. + $keys{'key80'} = 80;
  640. + $keys{'key81'} = 81;
  641. + $keys{'key82'} = 82;
  642. + $keys{'key83'} = 83;
  643. + $keys{'key84'} = 84;
  644. + $keys{'key85'} = 85;
  645. + $keys{'key86'} = 86;
  646. + $keys{'key87'} = 87;
  647. + $keys{'key88'} = 88;
  648. + $keys{'key89'} = 89;
  649. + $keys{'key90'} = 90;
  650. + $keys{'key91'} = 91;
  651. + $keys{'key92'} = 92;
  652. + $keys{'key93'} = 93;
  653. + $keys{'key94'} = 94;
  654. + $keys{'key95'} = 95;
  655. + $keys{'key96'} = 96;
  656. + $keys{'key97'} = 97;
  657. + $keys{'key98'} = 98;
  658. + $keys{'key99'} = 99;
  659. + $keys{'key9998'} = 9998;
  660. + $keys{'key9999'} = 9999;
  661. + print "Done\n";
  662. + 
  663. + dbmclose (%keys);
  664. + 
  665. + die "cant read dbmtest" unless dbmopen(%rkeys, "dbmtest", undef);
  666. + 
  667. + $i = 0;
  668. + print "Reading...\n";
  669. + while (($key, $val) = each %rkeys)
  670. + {
  671. +   if ($keys{$key} != $val)
  672. +   {
  673. +      print 'Incorrect val ', $key, ' = ', $val, ' expecting ', $keys{$key}, "\n";
  674. +      $i = $i + 1;
  675. +   }
  676. + }
  677. + print "Done\n";
  678. + dbmclose (%keys);
  679. + print $i, "Error(s)\n";
  680.  
  681. Index: doarg.c
  682. *** doarg.c.old    Mon Jun  8 17:46:34 1992
  683. --- doarg.c    Mon Jun  8 17:46:36 1992
  684. ***************
  685. *** 1,4 ****
  686. ! /* $RCSfile: doarg.c,v $$Revision: 4.0.1.5 $$Date: 91/11/11 16:31:58 $
  687.    *
  688.    *    Copyright (c) 1991, Larry Wall
  689.    *
  690. --- 1,4 ----
  691. ! /* $RCSfile: doarg.c,v $$Revision: 4.0.1.6 $$Date: 92/06/08 12:34:30 $
  692.    *
  693.    *    Copyright (c) 1991, Larry Wall
  694.    *
  695. ***************
  696. *** 6,11 ****
  697. --- 6,21 ----
  698.    *    License or the Artistic License, as specified in the README file.
  699.    *
  700.    * $Log:    doarg.c,v $
  701. +  * Revision 4.0.1.6  92/06/08  12:34:30  lwall
  702. +  * patch20: removed implicit int declarations on funcions
  703. +  * patch20: pattern modifiers i and o didn't interact right
  704. +  * patch20: join() now pre-extends target string to avoid excessive copying
  705. +  * patch20: fixed confusion between a *var's real name and its effective name
  706. +  * patch20: subroutines didn't localize $`, $&, $', $1 et al correctly
  707. +  * patch20: usersub routines didn't reclaim temp values soon enough
  708. +  * patch20: ($<,$>) = ... didn't work on some architectures
  709. +  * patch20: added Atari ST portability
  710. +  * 
  711.    * Revision 4.0.1.5  91/11/11  16:31:58  lwall
  712.    * patch19: added little-endian pack/unpack options
  713.    * 
  714. ***************
  715. *** 53,58 ****
  716. --- 63,70 ----
  717.    #pragma function(memcmp)
  718.   #endif /* BUGGY_MSC */
  719.   
  720. + static void doencodes();
  721. + 
  722.   int
  723.   do_subst(str,arg,sp)
  724.   STR *str;
  725. ***************
  726. *** 90,96 ****
  727.       spat->spat_regexp = regcomp(m,m+dstr->str_cur,
  728.           spat->spat_flags & SPAT_FOLD);
  729.       if (spat->spat_flags & SPAT_KEEP) {
  730. !         scanconst(spat, m, dstr->str_cur);
  731.           arg_free(spat->spat_runtime);    /* it won't change, so */
  732.           spat->spat_runtime = Nullarg;    /* no point compiling again */
  733.           hoistmust(spat);
  734. --- 102,109 ----
  735.       spat->spat_regexp = regcomp(m,m+dstr->str_cur,
  736.           spat->spat_flags & SPAT_FOLD);
  737.       if (spat->spat_flags & SPAT_KEEP) {
  738. !         if (!(spat->spat_flags & SPAT_FOLD))
  739. !         scanconst(spat, m, dstr->str_cur);
  740.           arg_free(spat->spat_runtime);    /* it won't change, so */
  741.           spat->spat_runtime = Nullarg;    /* no point compiling again */
  742.           hoistmust(spat);
  743. ***************
  744. *** 178,189 ****
  745.               s = orig;
  746.               if (m - s > strend - d) {    /* faster to shorten from end */
  747.               if (clen) {
  748. !                 (void)bcopy(c, m, clen);
  749.                   m += clen;
  750.               }
  751.               i = strend - d;
  752.               if (i > 0) {
  753. !                 (void)bcopy(d, m, i);
  754.                   m += i;
  755.               }
  756.               *m = '\0';
  757. --- 191,202 ----
  758.               s = orig;
  759.               if (m - s > strend - d) {    /* faster to shorten from end */
  760.               if (clen) {
  761. !                 Copy(c, m, clen, char);
  762.                   m += clen;
  763.               }
  764.               i = strend - d;
  765.               if (i > 0) {
  766. !                 Move(d, m, i, char);
  767.                   m += i;
  768.               }
  769.               *m = '\0';
  770. ***************
  771. *** 202,208 ****
  772.               while (i--)
  773.                   *--d = *--s;
  774.               if (clen)
  775. !                 (void)bcopy(c, m, clen);
  776.               STABSET(str);
  777.               str_numset(arg->arg_ptr.arg_str, 1.0);
  778.               stack->ary_array[++sp] = arg->arg_ptr.arg_str;
  779. --- 215,221 ----
  780.               while (i--)
  781.                   *--d = *--s;
  782.               if (clen)
  783. !                 Copy(c, m, clen, char);
  784.               STABSET(str);
  785.               str_numset(arg->arg_ptr.arg_str, 1.0);
  786.               stack->ary_array[++sp] = arg->arg_ptr.arg_str;
  787. ***************
  788. *** 211,217 ****
  789.               else if (clen) {
  790.               d -= clen;
  791.               str_chop(str,d);
  792. !             (void)bcopy(c,d,clen);
  793.               STABSET(str);
  794.               str_numset(arg->arg_ptr.arg_str, 1.0);
  795.               stack->ary_array[++sp] = arg->arg_ptr.arg_str;
  796. --- 224,230 ----
  797.               else if (clen) {
  798.               d -= clen;
  799.               str_chop(str,d);
  800. !             Copy(c,d,clen,char);
  801.               STABSET(str);
  802.               str_numset(arg->arg_ptr.arg_str, 1.0);
  803.               stack->ary_array[++sp] = arg->arg_ptr.arg_str;
  804. ***************
  805. *** 233,243 ****
  806.               /*SUPPRESS 560*/
  807.               if (i = m - s) {
  808.               if (s != d)
  809. !                 (void)bcopy(s,d,i);
  810.               d += i;
  811.               }
  812.               if (clen) {
  813. !             (void)bcopy(c,d,clen);
  814.               d += clen;
  815.               }
  816.               s = spat->spat_regexp->endp[0];
  817. --- 246,256 ----
  818.               /*SUPPRESS 560*/
  819.               if (i = m - s) {
  820.               if (s != d)
  821. !                 Move(s,d,i,char);
  822.               d += i;
  823.               }
  824.               if (clen) {
  825. !             Copy(c,d,clen,char);
  826.               d += clen;
  827.               }
  828.               s = spat->spat_regexp->endp[0];
  829. ***************
  830. *** 246,252 ****
  831.           if (s != d) {
  832.               i = strend - s;
  833.               str->str_cur = d - str->str_ptr + i;
  834. !             (void)bcopy(s,d,i+1);        /* include the Null */
  835.           }
  836.           STABSET(str);
  837.           str_numset(arg->arg_ptr.arg_str, (double)iters);
  838. --- 259,265 ----
  839.           if (s != d) {
  840.               i = strend - s;
  841.               str->str_cur = d - str->str_ptr + i;
  842. !             Move(s,d,i+1,char);        /* include the Null */
  843.           }
  844.           STABSET(str);
  845.           str_numset(arg->arg_ptr.arg_str, (double)iters);
  846. ***************
  847. *** 385,403 ****
  848.   int *arglast;
  849.   {
  850.       register STR **st = stack->ary_array;
  851. !     register int sp = arglast[1];
  852.       register int items = arglast[2] - sp;
  853.       register char *delim = str_get(st[sp]);
  854.       int delimlen = st[sp]->str_cur;
  855.   
  856. !     st += ++sp;
  857.       if (items-- > 0)
  858.       str_sset(str, *st++);
  859.       else
  860.       str_set(str,"");
  861. !     if (delimlen) {
  862.       for (; items > 0; items--,st++) {
  863. !         str_ncat(str,delim,delimlen);
  864.           str_scat(str,*st);
  865.       }
  866.       }
  867. --- 398,432 ----
  868.   int *arglast;
  869.   {
  870.       register STR **st = stack->ary_array;
  871. !     int sp = arglast[1];
  872.       register int items = arglast[2] - sp;
  873.       register char *delim = str_get(st[sp]);
  874. +     register STRLEN len;
  875.       int delimlen = st[sp]->str_cur;
  876.   
  877. !     st += sp + 1;
  878. ! 
  879. !     len = delimlen * (items - 1);
  880. !     if (str->str_len < len + items) {    /* current length is way too short */
  881. !     while (items-- > 0) {
  882. !         if (*st)
  883. !         len += (*st)->str_cur;
  884. !         st++;
  885. !     }
  886. !     STR_GROW(str, len + 1);        /* so try to pre-extend */
  887. ! 
  888. !     items = arglast[2] - sp;
  889. !     st -= items;
  890. !     }
  891. ! 
  892.       if (items-- > 0)
  893.       str_sset(str, *st++);
  894.       else
  895.       str_set(str,"");
  896. !     len = delimlen;
  897. !     if (len) {
  898.       for (; items > 0; items--,st++) {
  899. !         str_ncat(str,delim,len);
  900.           str_scat(str,*st);
  901.       }
  902.       }
  903. ***************
  904. *** 780,785 ****
  905. --- 809,815 ----
  906.   }
  907.   #undef NEXTFROM
  908.   
  909. + static void
  910.   doencodes(str, s, len)
  911.   register STR *str;
  912.   register char *s;
  913. ***************
  914. *** 938,944 ****
  915.             && xlen == sizeof(STBP)) {
  916.               STR *tmpstr = Str_new(24,0);
  917.   
  918. !             stab_fullname(tmpstr, ((STAB*)arg)); /* a stab value! */
  919.               sprintf(tokenbuf,"*%s",tmpstr->str_ptr);
  920.                       /* reformat to non-binary */
  921.               xs = tokenbuf;
  922. --- 968,974 ----
  923.             && xlen == sizeof(STBP)) {
  924.               STR *tmpstr = Str_new(24,0);
  925.   
  926. !             stab_efullname(tmpstr, ((STAB*)arg)); /* a stab value! */
  927.               sprintf(tokenbuf,"*%s",tmpstr->str_ptr);
  928.                       /* reformat to non-binary */
  929.               xs = tokenbuf;
  930. ***************
  931. *** 1053,1058 ****
  932. --- 1083,1089 ----
  933.       register int sp = arglast[1];
  934.       register int items = arglast[2] - sp;
  935.       register SUBR *sub;
  936. +     SPAT * VOLATILE oldspat = curspat;
  937.       STR *str;
  938.       STAB *stab;
  939.       int oldsave = savestack->ary_fill;
  940. ***************
  941. *** 1075,1087 ****
  942.       if (!(sub = stab_sub(stab))) {
  943.       STR *tmpstr = arg[0].arg_ptr.arg_str;
  944.   
  945. !     stab_fullname(tmpstr, stab);
  946.       fatal("Undefined subroutine \"%s\" called",tmpstr->str_ptr);
  947.       }
  948.       if (arg->arg_type == O_DBSUBR && !sub->usersub) {
  949.       str = stab_val(DBsub);
  950.       saveitem(str);
  951. !     stab_fullname(str,stab);
  952.       sub = stab_sub(DBsub);
  953.       if (!sub)
  954.           fatal("No DBsub routine");
  955. --- 1106,1118 ----
  956.       if (!(sub = stab_sub(stab))) {
  957.       STR *tmpstr = arg[0].arg_ptr.arg_str;
  958.   
  959. !     stab_efullname(tmpstr, stab);
  960.       fatal("Undefined subroutine \"%s\" called",tmpstr->str_ptr);
  961.       }
  962.       if (arg->arg_type == O_DBSUBR && !sub->usersub) {
  963.       str = stab_val(DBsub);
  964.       saveitem(str);
  965. !     stab_efullname(str,stab);
  966.       sub = stab_sub(DBsub);
  967.       if (!sub)
  968.           fatal("No DBsub routine");
  969. ***************
  970. *** 1098,1103 ****
  971. --- 1129,1135 ----
  972.       csv->wantarray = gimme;
  973.       csv->hasargs = hasargs;
  974.       curcsv = csv;
  975. +     tmps_base = tmps_max;
  976.       if (sub->usersub) {
  977.       csv->hasargs = 0;
  978.       csv->savearray = Null(ARRAY*);;
  979. ***************
  980. *** 1105,1132 ****
  981.       st[sp] = arg->arg_ptr.arg_str;
  982.       if (!hasargs)
  983.           items = 0;
  984. !     return (*sub->usersub)(sub->userindex,sp,items);
  985.       }
  986. !     if (hasargs) {
  987. !     csv->savearray = stab_xarray(defstab);
  988. !     csv->argarray = afake(defstab, items, &st[sp+1]);
  989. !     stab_xarray(defstab) = csv->argarray;
  990.       }
  991. -     sub->depth++;
  992. -     if (sub->depth >= 2) {    /* save temporaries on recursion? */
  993. -     if (sub->depth == 100 && dowarn)
  994. -         warn("Deep recursion on subroutine \"%s\"",stab_name(stab));
  995. -     savelist(sub->tosave->ary_array,sub->tosave->ary_fill);
  996. -     }
  997. -     tmps_base = tmps_max;
  998. -     sp = cmd_exec(sub->cmd,gimme, --sp);    /* so do it already */
  999. -     st = stack->ary_array;
  1000.   
  1001.       tmps_base = oldtmps_base;
  1002.       for (items = arglast[0] + 1; items <= sp; items++)
  1003.       st[items] = str_mortal(st[items]);
  1004.           /* in case restore wipes old str */
  1005.       restorelist(oldsave);
  1006.       return sp;
  1007.   }
  1008.   
  1009. --- 1137,1166 ----
  1010.       st[sp] = arg->arg_ptr.arg_str;
  1011.       if (!hasargs)
  1012.           items = 0;
  1013. !     sp = (*sub->usersub)(sub->userindex,sp,items);
  1014.       }
  1015. !     else {
  1016. !     if (hasargs) {
  1017. !         csv->savearray = stab_xarray(defstab);
  1018. !         csv->argarray = afake(defstab, items, &st[sp+1]);
  1019. !         stab_xarray(defstab) = csv->argarray;
  1020. !     }
  1021. !     sub->depth++;
  1022. !     if (sub->depth >= 2) {    /* save temporaries on recursion? */
  1023. !         if (sub->depth == 100 && dowarn)
  1024. !         warn("Deep recursion on subroutine \"%s\"",stab_ename(stab));
  1025. !         savelist(sub->tosave->ary_array,sub->tosave->ary_fill);
  1026. !     }
  1027. !     sp = cmd_exec(sub->cmd,gimme, --sp);    /* so do it already */
  1028.       }
  1029.   
  1030. +     st = stack->ary_array;
  1031.       tmps_base = oldtmps_base;
  1032.       for (items = arglast[0] + 1; items <= sp; items++)
  1033.       st[items] = str_mortal(st[items]);
  1034.           /* in case restore wipes old str */
  1035.       restorelist(oldsave);
  1036. +     curspat = oldspat;
  1037.       return sp;
  1038.   }
  1039.   
  1040. ***************
  1041. *** 1264,1285 ****
  1042.           STABSET(str);
  1043.       }
  1044.       }
  1045. !     if (delaymagic > 1) {
  1046. !     if (delaymagic & DM_REUID) {
  1047.   #ifdef HAS_SETREUID
  1048. !         setreuid(uid,euid);
  1049. ! #else
  1050. !         if (uid != euid || setuid(uid) < 0)
  1051. !         fatal("No setreuid available");
  1052. ! #endif
  1053.       }
  1054. !     if (delaymagic & DM_REGID) {
  1055.   #ifdef HAS_SETREGID
  1056. !         setregid(gid,egid);
  1057. ! #else
  1058. !         if (gid != egid || setgid(gid) < 0)
  1059. !         fatal("No setregid available");
  1060. ! #endif
  1061.       }
  1062.       }
  1063.       delaymagic = 0;
  1064. --- 1298,1353 ----
  1065.           STABSET(str);
  1066.       }
  1067.       }
  1068. !     if (delaymagic & ~DM_DELAY) {
  1069. !     if (delaymagic & DM_UID) {
  1070.   #ifdef HAS_SETREUID
  1071. !         (void)setreuid(uid,euid);
  1072. ! #else /* not HAS_SETREUID */
  1073. ! #ifdef HAS_SETRUID
  1074. !         if ((delaymagic & DM_UID) == DM_RUID) {
  1075. !         (void)setruid(uid);
  1076. !         delaymagic =~ DM_RUID;
  1077. !         }
  1078. ! #endif /* HAS_SETRUID */
  1079. ! #ifdef HAS_SETEUID
  1080. !         if ((delaymagic & DM_UID) == DM_EUID) {
  1081. !         (void)seteuid(uid);
  1082. !         delaymagic =~ DM_EUID;
  1083. !         }
  1084. ! #endif /* HAS_SETEUID */
  1085. !         if (delaymagic & DM_UID) {
  1086. !         if (uid != euid)
  1087. !             fatal("No setreuid available");
  1088. !         (void)setuid(uid);
  1089. !         }
  1090. ! #endif /* not HAS_SETREUID */
  1091. !         uid = (int)getuid();
  1092. !         euid = (int)geteuid();
  1093.       }
  1094. !     if (delaymagic & DM_GID) {
  1095.   #ifdef HAS_SETREGID
  1096. !         (void)setregid(gid,egid);
  1097. ! #else /* not HAS_SETREGID */
  1098. ! #ifdef HAS_SETRGID
  1099. !         if ((delaymagic & DM_GID) == DM_RGID) {
  1100. !         (void)setrgid(gid);
  1101. !         delaymagic =~ DM_RGID;
  1102. !         }
  1103. ! #endif /* HAS_SETRGID */
  1104. ! #ifdef HAS_SETEGID
  1105. !         if ((delaymagic & DM_GID) == DM_EGID) {
  1106. !         (void)setegid(gid);
  1107. !         delaymagic =~ DM_EGID;
  1108. !         }
  1109. ! #endif /* HAS_SETEGID */
  1110. !         if (delaymagic & DM_GID) {
  1111. !         if (gid != egid)
  1112. !             fatal("No setregid available");
  1113. !         (void)setgid(gid);
  1114. !         }
  1115. ! #endif /* not HAS_SETREGID */
  1116. !         gid = (int)getgid();
  1117. !         egid = (int)getegid();
  1118.       }
  1119.       }
  1120.       delaymagic = 0;
  1121. ***************
  1122. *** 1498,1504 ****
  1123.       else {
  1124.       if (len > str->str_cur) {
  1125.           STR_GROW(str,len);
  1126. !         (void)bzero(str->str_ptr + str->str_cur, len - str->str_cur);
  1127.           str->str_cur = len;
  1128.       }
  1129.       s = (unsigned char*)str_get(str);
  1130. --- 1566,1572 ----
  1131.       else {
  1132.       if (len > str->str_cur) {
  1133.           STR_GROW(str,len);
  1134. !         (void)memzero(str->str_ptr + str->str_cur, len - str->str_cur);
  1135.           str->str_cur = len;
  1136.       }
  1137.       s = (unsigned char*)str_get(str);
  1138. ***************
  1139. *** 1571,1576 ****
  1140. --- 1639,1645 ----
  1141.       }
  1142.   }
  1143.   
  1144. + void
  1145.   do_chop(astr,str)
  1146.   register STR *astr;
  1147.   register STR *str;
  1148. ***************
  1149. *** 1610,1615 ****
  1150. --- 1679,1685 ----
  1151.       str_nset(astr,"",0);
  1152.   }
  1153.   
  1154. + void
  1155.   do_vop(optype,str,left,right)
  1156.   STR *str;
  1157.   STR *left;
  1158. ***************
  1159. *** 1627,1633 ****
  1160.       str->str_cur = len;
  1161.       else if (str->str_cur < len) {
  1162.       STR_GROW(str,len);
  1163. !     (void)bzero(str->str_ptr + str->str_cur, len - str->str_cur);
  1164.       str->str_cur = len;
  1165.       }
  1166.       str->str_pok = 1;
  1167. --- 1697,1703 ----
  1168.       str->str_cur = len;
  1169.       else if (str->str_cur < len) {
  1170.       STR_GROW(str,len);
  1171. !     (void)memzero(str->str_ptr + str->str_cur, len - str->str_cur);
  1172.       str->str_cur = len;
  1173.       }
  1174.       str->str_pok = 1;
  1175. ***************
  1176. *** 1666,1672 ****
  1177. --- 1736,1746 ----
  1178.       register STR **st = stack->ary_array;
  1179.       register int sp = arglast[1];
  1180.       register int items = arglast[2] - sp;
  1181. + #ifdef atarist
  1182. +     unsigned long arg[14]; /* yes, we really need that many ! */
  1183. + #else
  1184.       unsigned long arg[8];
  1185. + #endif
  1186.       register int i = 0;
  1187.       int retval = -1;
  1188.   
  1189. ***************
  1190. *** 1723,1728 ****
  1191. --- 1797,1828 ----
  1192.       retval = syscall(arg[0],arg[1],arg[2],arg[3],arg[4],arg[5],arg[6],
  1193.         arg[7]);
  1194.       break;
  1195. + #ifdef atarist
  1196. +     case 9:
  1197. +     retval = syscall(arg[0],arg[1],arg[2],arg[3],arg[4],arg[5],arg[6],
  1198. +       arg[7], arg[8]);
  1199. +     break;
  1200. +     case 10:
  1201. +     retval = syscall(arg[0],arg[1],arg[2],arg[3],arg[4],arg[5],arg[6],
  1202. +       arg[7], arg[8], arg[9]);
  1203. +     break;
  1204. +     case 11:
  1205. +     retval = syscall(arg[0],arg[1],arg[2],arg[3],arg[4],arg[5],arg[6],
  1206. +       arg[7], arg[8], arg[9], arg[10]);
  1207. +     break;
  1208. +     case 12:
  1209. +     retval = syscall(arg[0],arg[1],arg[2],arg[3],arg[4],arg[5],arg[6],
  1210. +       arg[7], arg[8], arg[9], arg[10], arg[11]);
  1211. +     break;
  1212. +     case 13:
  1213. +     retval = syscall(arg[0],arg[1],arg[2],arg[3],arg[4],arg[5],arg[6],
  1214. +       arg[7], arg[8], arg[9], arg[10], arg[11], arg[12]);
  1215. +     break;
  1216. +     case 14:
  1217. +     retval = syscall(arg[0],arg[1],arg[2],arg[3],arg[4],arg[5],arg[6],
  1218. +       arg[7], arg[8], arg[9], arg[10], arg[11], arg[12], arg[13]);
  1219. +     break;
  1220. + #endif /* atarist */
  1221.       }
  1222.       return retval;
  1223.   #else
  1224.  
  1225. Index: dump.c
  1226. *** dump.c.old    Mon Jun  8 17:47:08 1992
  1227. --- dump.c    Mon Jun  8 17:47:09 1992
  1228. ***************
  1229. *** 1,4 ****
  1230. ! /* $RCSfile: dump.c,v $$Revision: 4.0.1.1 $$Date: 91/06/07 10:58:44 $
  1231.    *
  1232.    *    Copyright (c) 1991, Larry Wall
  1233.    *
  1234. --- 1,4 ----
  1235. ! /* $RCSfile: dump.c,v $$Revision: 4.0.1.2 $$Date: 92/06/08 13:14:22 $
  1236.    *
  1237.    *    Copyright (c) 1991, Larry Wall
  1238.    *
  1239. ***************
  1240. *** 6,11 ****
  1241. --- 6,15 ----
  1242.    *    License or the Artistic License, as specified in the README file.
  1243.    *
  1244.    * $Log:    dump.c,v $
  1245. +  * Revision 4.0.1.2  92/06/08  13:14:22  lwall
  1246. +  * patch20: removed implicit int declarations on funcions
  1247. +  * patch20: fixed confusion between a *var's real name and its effective name
  1248. +  * 
  1249.    * Revision 4.0.1.1  91/06/07  10:58:44  lwall
  1250.    * patch4: new copyright notice
  1251.    * 
  1252. ***************
  1253. *** 20,25 ****
  1254. --- 24,32 ----
  1255.   #ifdef DEBUGGING
  1256.   static int dumplvl = 0;
  1257.   
  1258. + static void dump();
  1259. + 
  1260. + void
  1261.   dump_all()
  1262.   {
  1263.       register int i;
  1264. ***************
  1265. *** 40,45 ****
  1266. --- 47,53 ----
  1267.       }
  1268.   }
  1269.   
  1270. + void
  1271.   dump_cmd(cmd,alt)
  1272.   register CMD *cmd;
  1273.   register CMD *alt;
  1274. ***************
  1275. *** 160,165 ****
  1276. --- 168,174 ----
  1277.       }
  1278.   }
  1279.   
  1280. + void
  1281.   dump_arg(arg)
  1282.   register ARG *arg;
  1283.   {
  1284. ***************
  1285. *** 231,236 ****
  1286. --- 240,246 ----
  1287.       dump("}\n");
  1288.   }
  1289.   
  1290. + void
  1291.   dump_flags(b,flags)
  1292.   char *b;
  1293.   unsigned int flags;
  1294. ***************
  1295. *** 256,261 ****
  1296. --- 266,272 ----
  1297.       b[strlen(b)-1] = '\0';
  1298.   }
  1299.   
  1300. + void
  1301.   dump_stab(stab)
  1302.   register STAB *stab;
  1303.   {
  1304. ***************
  1305. *** 269,279 ****
  1306.       dumplvl++;
  1307.       fprintf(stderr,"{\n");
  1308.       stab_fullname(str,stab);
  1309. !     dump("STAB_NAME = %s\n", str->str_ptr);
  1310.       dumplvl--;
  1311.       dump("}\n");
  1312.   }
  1313.   
  1314.   dump_spat(spat)
  1315.   register SPAT *spat;
  1316.   {
  1317. --- 280,296 ----
  1318.       dumplvl++;
  1319.       fprintf(stderr,"{\n");
  1320.       stab_fullname(str,stab);
  1321. !     dump("STAB_NAME = %s", str->str_ptr);
  1322. !     if (stab != stab_estab(stab)) {
  1323. !     stab_efullname(str,stab_estab(stab));
  1324. !     dump("-> %s", str->str_ptr);
  1325. !     }
  1326. !     dump("\n");
  1327.       dumplvl--;
  1328.       dump("}\n");
  1329.   }
  1330.   
  1331. + void
  1332.   dump_spat(spat)
  1333.   register SPAT *spat;
  1334.   {
  1335. ***************
  1336. *** 307,313 ****
  1337.   }
  1338.   
  1339.   /* VARARGS1 */
  1340. ! dump(arg1,arg2,arg3,arg4,arg5)
  1341.   char *arg1;
  1342.   long arg2, arg3, arg4, arg5;
  1343.   {
  1344. --- 324,330 ----
  1345.   }
  1346.   
  1347.   /* VARARGS1 */
  1348. ! static void dump(arg1,arg2,arg3,arg4,arg5)
  1349.   char *arg1;
  1350.   long arg2, arg3, arg4, arg5;
  1351.   {
  1352.  
  1353. Index: eval.c
  1354. *** eval.c.old    Mon Jun  8 17:47:17 1992
  1355. --- eval.c    Mon Jun  8 17:47:19 1992
  1356. ***************
  1357. *** 1,4 ****
  1358. ! /* $RCSfile: eval.c,v $$Revision: 4.0.1.3 $$Date: 91/11/05 17:15:21 $
  1359.    *
  1360.    *    Copyright (c) 1991, Larry Wall
  1361.    *
  1362. --- 1,4 ----
  1363. ! /* $RCSfile: eval.c,v $$Revision: 4.0.1.4 $$Date: 92/06/08 13:20:20 $
  1364.    *
  1365.    *    Copyright (c) 1991, Larry Wall
  1366.    *
  1367. ***************
  1368. *** 6,11 ****
  1369. --- 6,21 ----
  1370.    *    License or the Artistic License, as specified in the README file.
  1371.    *
  1372.    * $Log:    eval.c,v $
  1373. +  * Revision 4.0.1.4  92/06/08  13:20:20  lwall
  1374. +  * patch20: added explicit time_t support
  1375. +  * patch20: fixed confusion between a *var's real name and its effective name
  1376. +  * patch20: added Atari ST portability
  1377. +  * patch20: new warning for use of x with non-numeric right operand
  1378. +  * patch20: modulus with highest bit in left operand set didn't always work
  1379. +  * patch20: dbmclose(%array) didn't work
  1380. +  * patch20: added ... as variant on ..
  1381. +  * patch20: O_PIPE conflicted with Atari
  1382. +  * 
  1383.    * Revision 4.0.1.3  91/11/05  17:15:21  lwall
  1384.    * patch11: prepared for ctype implementations that don't define isascii()
  1385.    * patch11: various portability fixes
  1386. ***************
  1387. *** 44,49 ****
  1388. --- 54,64 ----
  1389.   #ifdef I_FCNTL
  1390.   #include <fcntl.h>
  1391.   #endif
  1392. + #ifdef MSDOS
  1393. + /* I_FCNTL *MUST* not be defined for MS-DOS and OS/2
  1394. +    but fcntl.h is required for O_BINARY */
  1395. + #include <fcntl.h>
  1396. + #endif
  1397.   #ifdef I_SYS_FILE
  1398.   #include <sys/file.h>
  1399.   #endif
  1400. ***************
  1401. *** 89,96 ****
  1402.       int argtype;
  1403.       union argptr argptr;
  1404.       int arglast[8];    /* highest sp for arg--valid only for non-O_LIST args */
  1405. !     unsigned long tmplong;
  1406. !     long when;
  1407.       FILE *fp;
  1408.       STR *tmpstr;
  1409.       FCMD *form;
  1410. --- 104,113 ----
  1411.       int argtype;
  1412.       union argptr argptr;
  1413.       int arglast[8];    /* highest sp for arg--valid only for non-O_LIST args */
  1414. !     unsigned long tmpulong;
  1415. !     long tmplong;
  1416. !     time_t when;
  1417. !     STRLEN tmplen;
  1418.       FILE *fp;
  1419.       STR *tmpstr;
  1420.       FCMD *form;
  1421. ***************
  1422. *** 204,210 ****
  1423.           stab_io(stab) = stio_new();
  1424.   #ifdef DEBUGGING
  1425.           if (debug & 8) {
  1426. !         (void)sprintf(buf,"STAR *%s",stab_name(argptr.arg_stab));
  1427.           tmps = buf;
  1428.           }
  1429.   #endif
  1430. --- 221,228 ----
  1431.           stab_io(stab) = stio_new();
  1432.   #ifdef DEBUGGING
  1433.           if (debug & 8) {
  1434. !         (void)sprintf(buf,"STAR *%s -> *%s",
  1435. !             stab_name(argptr.arg_stab), stab_ename(argptr.arg_stab));
  1436.           tmps = buf;
  1437.           }
  1438.   #endif
  1439. ***************
  1440. *** 213,219 ****
  1441.           str = st[++sp] = (STR*)argptr.arg_stab;
  1442.   #ifdef DEBUGGING
  1443.           if (debug & 8) {
  1444. !         (void)sprintf(buf,"LSTAR *%s",stab_name(argptr.arg_stab));
  1445.           tmps = buf;
  1446.           }
  1447.   #endif
  1448. --- 231,238 ----
  1449.           str = st[++sp] = (STR*)argptr.arg_stab;
  1450.   #ifdef DEBUGGING
  1451.           if (debug & 8) {
  1452. !         (void)sprintf(buf,"LSTAR *%s -> *%s",
  1453. !         stab_name(argptr.arg_stab), stab_ename(argptr.arg_stab));
  1454.           tmps = buf;
  1455.           }
  1456.   #endif
  1457. ***************
  1458. *** 390,396 ****
  1459.           old_rschar = rschar;
  1460.           old_rslen = rslen;
  1461.           rslen = 1;
  1462. ! #ifdef MSDOS
  1463.           rschar = 0;
  1464.   #else
  1465.   #ifdef CSH
  1466. --- 409,415 ----
  1467.           old_rschar = rschar;
  1468.           old_rslen = rslen;
  1469.           rslen = 1;
  1470. ! #ifdef DOSISH
  1471.           rschar = 0;
  1472.   #else
  1473.   #ifdef CSH
  1474. ***************
  1475. *** 433,439 ****
  1476.               (void) interp(str,stab_val(last_in_stab),sp);
  1477.               st = stack->ary_array;
  1478.               tmpstr = Str_new(55,0);
  1479. ! #ifdef MSDOS
  1480.               str_set(tmpstr, "perlglob ");
  1481.               str_scat(tmpstr,str);
  1482.               str_cat(tmpstr," |");
  1483. --- 452,458 ----
  1484.               (void) interp(str,stab_val(last_in_stab),sp);
  1485.               st = stack->ary_array;
  1486.               tmpstr = Str_new(55,0);
  1487. ! #ifdef DOSISH
  1488.               str_set(tmpstr, "perlglob ");
  1489.               str_scat(tmpstr,str);
  1490.               str_cat(tmpstr," |");
  1491. ***************
  1492. *** 458,466 ****
  1493.           }
  1494.           }
  1495.           if (!fp && dowarn)
  1496. !         warn("Read on closed filehandle <%s>",stab_name(last_in_stab));
  1497. !         when = str->str_len;    /* remember if already alloced */
  1498. !         if (!when)
  1499.           Str_Grow(str,80);    /* try short-buffering it */
  1500.         keepgoing:
  1501.           if (!fp)
  1502. --- 477,485 ----
  1503.           }
  1504.           }
  1505.           if (!fp && dowarn)
  1506. !         warn("Read on closed filehandle <%s>",stab_ename(last_in_stab));
  1507. !         tmplen = str->str_len;    /* remember if already alloced */
  1508. !         if (!tmplen)
  1509.           Str_Grow(str,80);    /* try short-buffering it */
  1510.         keepgoing:
  1511.           if (!fp)
  1512. ***************
  1513. *** 520,526 ****
  1514.               str = Str_new(58,80);
  1515.               goto keepgoing;
  1516.           }
  1517. !         else if (!when && str->str_len - str->str_cur > 80) {
  1518.               /* try to reclaim a bit of scalar space on 1st alloc */
  1519.               if (str->str_cur < 60)
  1520.               str->str_len = 80;
  1521. --- 539,545 ----
  1522.               str = Str_new(58,80);
  1523.               goto keepgoing;
  1524.           }
  1525. !         else if (!tmplen && str->str_len - str->str_cur > 80) {
  1526.               /* try to reclaim a bit of scalar space on 1st alloc */
  1527.               if (str->str_cur < 60)
  1528.               str->str_len = 80;
  1529. ***************
  1530. *** 584,591 ****
  1531.           sp = do_repeatary(arglast);
  1532.           goto array_return;
  1533.       }
  1534. !     STR_SSET(str,st[arglast[1] - arglast[0]]);
  1535. !     anum = (int)str_gnum(st[arglast[2] - arglast[0]]);
  1536.       if (anum >= 1) {
  1537.           tmpstr = Str_new(50, 0);
  1538.           tmps = str_get(str);
  1539. --- 603,610 ----
  1540.           sp = do_repeatary(arglast);
  1541.           goto array_return;
  1542.       }
  1543. !     STR_SSET(str,st[1]);
  1544. !     anum = (int)str_gnum(st[2]);
  1545.       if (anum >= 1) {
  1546.           tmpstr = Str_new(50, 0);
  1547.           tmps = str_get(str);
  1548. ***************
  1549. *** 598,605 ****
  1550.           str->str_nok = 0;
  1551.           str_free(tmpstr);
  1552.       }
  1553. !     else
  1554.           str_sset(str,&str_no);
  1555.       STABSET(str);
  1556.       break;
  1557.       case O_MATCH:
  1558. --- 617,627 ----
  1559.           str->str_nok = 0;
  1560.           str_free(tmpstr);
  1561.       }
  1562. !     else {
  1563. !         if (dowarn && st[2]->str_pok && !looks_like_number(st[2]))
  1564. !         warn("Right operand of x is not numeric");
  1565.           str_sset(str,&str_no);
  1566. +     }
  1567.       STABSET(str);
  1568.       break;
  1569.       case O_MATCH:
  1570. ***************
  1571. *** 724,738 ****
  1572.   #endif
  1573.       goto donumset;
  1574.       case O_MODULO:
  1575. !     tmplong = (long) str_gnum(st[2]);
  1576. !         if (tmplong == 0L)
  1577.               fatal("Illegal modulus zero");
  1578. -     when = (long)str_gnum(st[1]);
  1579.   #ifndef lint
  1580. !     if (when >= 0)
  1581. !         value = (double)(when % tmplong);
  1582. !     else
  1583. !         value = (double)(tmplong - ((-when - 1) % tmplong)) - 1;
  1584.   #endif
  1585.       goto donumset;
  1586.       case O_ADD:
  1587. --- 746,762 ----
  1588.   #endif
  1589.       goto donumset;
  1590.       case O_MODULO:
  1591. !     tmpulong = (unsigned long) str_gnum(st[2]);
  1592. !         if (tmpulong == 0L)
  1593.               fatal("Illegal modulus zero");
  1594.   #ifndef lint
  1595. !     value = str_gnum(st[1]);
  1596. !     if (value >= 0.0)
  1597. !         value = (double)(((unsigned long)value) % tmpulong);
  1598. !     else {
  1599. !         tmplong = (long)value;
  1600. !         value = (double)(tmpulong - ((-tmplong - 1) % tmpulong)) - 1;
  1601. !     }
  1602.   #endif
  1603.       goto donumset;
  1604.       case O_ADD:
  1605. ***************
  1606. *** 916,922 ****
  1607.       }
  1608.       break;
  1609.       case O_SELECT:
  1610. !     stab_fullname(str,defoutstab);
  1611.       if (maxarg > 0) {
  1612.           if ((arg[1].arg_type & A_MASK) == A_WORD)
  1613.           defoutstab = arg[1].arg_ptr.arg_stab;
  1614. --- 940,946 ----
  1615.       }
  1616.       break;
  1617.       case O_SELECT:
  1618. !     stab_efullname(str,defoutstab);
  1619.       if (maxarg > 0) {
  1620.           if ((arg[1].arg_type & A_MASK) == A_WORD)
  1621.           defoutstab = arg[1].arg_ptr.arg_stab;
  1622. ***************
  1623. *** 989,995 ****
  1624.   #endif
  1625.       case O_DBMCLOSE:
  1626.   #ifdef SOME_DBM
  1627. !     if ((arg[1].arg_type & A_MASK) == A_WORD)
  1628.           stab = arg[1].arg_ptr.arg_stab;
  1629.       else
  1630.           stab = stabent(str_get(st[1]),TRUE);
  1631. --- 1013,1020 ----
  1632.   #endif
  1633.       case O_DBMCLOSE:
  1634.   #ifdef SOME_DBM
  1635. !     anum = arg[1].arg_type & A_MASK;
  1636. !     if (anum == A_WORD || anum == A_STAB)
  1637.           stab = arg[1].arg_ptr.arg_stab;
  1638.       else
  1639.           stab = stabent(str_get(st[1]),TRUE);
  1640. ***************
  1641. *** 1074,1080 ****
  1642.       tmps = str_get(st[2]);
  1643.       str = hdelete(stab_hash(tmpstab),tmps,st[2]->str_cur);
  1644.       if (tmpstab == envstab)
  1645. !         setenv(tmps,Nullch);
  1646.       if (!str)
  1647.           goto say_undef;
  1648.       break;
  1649. --- 1099,1105 ----
  1650.       tmps = str_get(st[2]);
  1651.       str = hdelete(stab_hash(tmpstab),tmps,st[2]->str_cur);
  1652.       if (tmpstab == envstab)
  1653. !         my_setenv(tmps,Nullch);
  1654.       if (!str)
  1655.           goto say_undef;
  1656.       break;
  1657. ***************
  1658. *** 1656,1662 ****
  1659.       if (maxarg < 1)
  1660.           (void)time(&when);
  1661.       else
  1662. !         when = (long)str_gnum(st[1]);
  1663.       sp = do_time(str,localtime(&when),
  1664.         gimme,arglast);
  1665.       goto array_return;
  1666. --- 1681,1687 ----
  1667.       if (maxarg < 1)
  1668.           (void)time(&when);
  1669.       else
  1670. !         when = (time_t)str_gnum(st[1]);
  1671.       sp = do_time(str,localtime(&when),
  1672.         gimme,arglast);
  1673.       goto array_return;
  1674. ***************
  1675. *** 1664,1670 ****
  1676.       if (maxarg < 1)
  1677.           (void)time(&when);
  1678.       else
  1679. !         when = (long)str_gnum(st[1]);
  1680.       sp = do_time(str,gmtime(&when),
  1681.         gimme,arglast);
  1682.       goto array_return;
  1683. --- 1689,1695 ----
  1684.       if (maxarg < 1)
  1685.           (void)time(&when);
  1686.       else
  1687. !         when = (time_t)str_gnum(st[1]);
  1688.       sp = do_time(str,gmtime(&when),
  1689.         gimme,arglast);
  1690.       goto array_return;
  1691. ***************
  1692. *** 1869,1885 ****
  1693.         last_in_stab && (int)str_gnum(st[1]) == stab_io(last_in_stab)->lines
  1694.         :
  1695.         str_true(st[1]) ) {
  1696. -         str_numset(str,0.0);
  1697. -         anum = 2;
  1698. -         arg->arg_type = optype = O_FLOP;
  1699.           arg[2].arg_type &= ~A_DONT;
  1700.           arg[1].arg_type |= A_DONT;
  1701. !         argflags = arg[2].arg_flags;
  1702. !         argtype = arg[2].arg_type & A_MASK;
  1703. !         argptr = arg[2].arg_ptr;
  1704. !         sp = arglast[0];
  1705. !         st -= sp++;
  1706. !         goto re_eval;
  1707.       }
  1708.       str_set(str,"");
  1709.       break;
  1710. --- 1894,1916 ----
  1711.         last_in_stab && (int)str_gnum(st[1]) == stab_io(last_in_stab)->lines
  1712.         :
  1713.         str_true(st[1]) ) {
  1714.           arg[2].arg_type &= ~A_DONT;
  1715.           arg[1].arg_type |= A_DONT;
  1716. !         arg->arg_type = optype = O_FLOP;
  1717. !         if (arg->arg_flags & AF_COMMON) {
  1718. !         str_numset(str,0.0);
  1719. !         anum = 2;
  1720. !         argflags = arg[2].arg_flags;
  1721. !         argtype = arg[2].arg_type & A_MASK;
  1722. !         argptr = arg[2].arg_ptr;
  1723. !         sp = arglast[0];
  1724. !         st -= sp++;
  1725. !         goto re_eval;
  1726. !         }
  1727. !         else {
  1728. !         str_numset(str,1.0);
  1729. !         break;
  1730. !         }
  1731.       }
  1732.       str_set(str,"");
  1733.       break;
  1734. ***************
  1735. *** 2862,2869 ****
  1736.           stab = stabent(str_get(st[1]),TRUE);
  1737.       if (!stab || !(stio = stab_io(stab)) || !(fp = stio->ifp))
  1738.           goto say_undef;
  1739. ! #ifdef MSDOS
  1740.       str_set(str, (setmode(fileno(fp), O_BINARY) != -1) ? Yes : No);
  1741.   #else
  1742.       str_set(str, Yes);
  1743.   #endif
  1744. --- 2893,2910 ----
  1745.           stab = stabent(str_get(st[1]),TRUE);
  1746.       if (!stab || !(stio = stab_io(stab)) || !(fp = stio->ifp))
  1747.           goto say_undef;
  1748. ! #ifdef DOSISH
  1749. ! #ifdef atarist
  1750. !     if(fflush(fp))
  1751. !        str_set(str, No);
  1752. !     else
  1753. !     {
  1754. !         fp->_flag |= _IOBIN;
  1755. !         str_set(str, Yes);
  1756. !     }
  1757. ! #else
  1758.       str_set(str, (setmode(fileno(fp), O_BINARY) != -1) ? Yes : No);
  1759. + #endif
  1760.   #else
  1761.       str_set(str, Yes);
  1762.   #endif
  1763. ***************
  1764. *** 2938,2944 ****
  1765.       case O_SYSCALL:
  1766.       value = (double)do_syscall(arglast);
  1767.       goto donumset;
  1768. !     case O_PIPE:
  1769.   #ifdef HAS_PIPE
  1770.       if ((arg[1].arg_type & A_MASK) == A_WORD)
  1771.           stab = arg[1].arg_ptr.arg_stab;
  1772. --- 2979,2985 ----
  1773.       case O_SYSCALL:
  1774.       value = (double)do_syscall(arglast);
  1775.       goto donumset;
  1776. !     case O_PIPE_OP:
  1777.   #ifdef HAS_PIPE
  1778.       if ((arg[1].arg_type & A_MASK) == A_WORD)
  1779.           stab = arg[1].arg_ptr.arg_stab;
  1780.  
  1781. Index: atarist/explain
  1782. *** atarist/explain.old    Mon Jun  8 17:35:13 1992
  1783. --- atarist/explain    Mon Jun  8 17:35:14 1992
  1784. ***************
  1785. *** 0 ****
  1786. --- 1,77 ----
  1787. + Here is a brief explaination of the diffs in perl.diffs. If anything
  1788. + is unclear please just ask:
  1789. + 
  1790. + General:
  1791. +   Many of the  #ifdef MSDOS where required for the atari too. In order
  1792. + to avoid cluttering up the source, upfront in perl.h we #define
  1793. + MSDOS_OR_ATARI if either defined(MSDOS) or defined(atarist).
  1794. + 
  1795. +  Some of the diffs that i felt were universally applicable are not protected
  1796. + with #ifdef's. In the explainations below i has indicated all such
  1797. + changes.
  1798. + 
  1799. + perl.h:
  1800. +   -- define MSDOS_OR_ATARI if appro.
  1801. +   -- typedef size_t - assume its there in <stddef.h> if STANDARD_C otherwise
  1802. +      typedef it to unsigned int (i would have ideally liked unsigned long,
  1803. +      but we get into trouble with half-assed headers from sun etc)
  1804. + (this change not protected with a #ifdef since hopefully its universally appli)
  1805. + 
  1806. +   -- make the type of STRLEN size_t for all systems
  1807. + (this change not protected with a #ifdef since hopefully its universally appli)
  1808. + 
  1809. +   -- more #ifdef MSDOS -> #ifdef MSDOS_OR_ATARI changes.
  1810. + 
  1811. + arg.h:
  1812. +   -- in the atari headers we already have O_PIPE. Change all instances of
  1813. +      O_PIPE to PERL_O_PIPE. All such changes protected with #ifdef atarist.
  1814. + 
  1815. + handy.h:
  1816. +   -- make MEM_SIZE size_t like STRLEN.
  1817. + (this change not protected with a #ifdef since hopefully its universally appli)
  1818. + 
  1819. + doarg.c:
  1820. +   -- accomodate the large number of args needed for the atari syscall().
  1821. +   -- do the 9 thru 14 arg versions of syscall for the atarist.
  1822. + 
  1823. + doio.c:
  1824. +   -- mode[] needed to be  initialized.
  1825. + (this change not protected with a #ifdef since hopefully its universally appli)
  1826. + 
  1827. +   -- you may find this strange, we do not define STDSTDIO, because even
  1828. +      though we have the "standard" field in FILE, the semantics are
  1829. +      different. However, some contexts will work correctly, and there
  1830. +      you will see #if defined(STDSTDIO) || defined(atarist)
  1831. + 
  1832. +   -- more #ifdef MSDOS -> #ifdef MSDOS_OR_ATARI changes.
  1833. + 
  1834. + eval.c:
  1835. +   -- more #ifdef MSDOS -> #ifdef MSDOS_OR_ATARI changes.
  1836. + 
  1837. + malloc.c::
  1838. +   -- instead of bashfully using ints to hold sizes use MEM_SIZE.
  1839. +      adjust some casts and printf format specifiers due to this.
  1840. +      (atarigcc can run in two modes, with 16 or 32 bit ints, so...)
  1841. + (this change not protected with a #ifdef since hopefully its universally appli)
  1842. + 
  1843. +   -- atarist changes sometimes ||'ed with I286 as appro.
  1844. + 
  1845. + perl.c:
  1846. +   -- more #ifdef MSDOS -> #ifdef MSDOS_OR_ATARI changes.
  1847. + 
  1848. + regcomp.c:
  1849. +   -- like O_PIPE the atarist headers already has META defined. Change all
  1850. +      instances of META to PERL_META. All such changes protected with
  1851. +      #ifdef atarist.
  1852. + 
  1853. + str.c:
  1854. +   -- more #ifdef MSDOS -> #ifdef MSDOS_OR_ATARI changes.
  1855. + 
  1856. + token.c::
  1857. +   -- META -> PERL_META renaming for atari
  1858. + 
  1859. + util.c::
  1860. +   -- more adjustments for memory sizes being MEM_SIZE instead of int.
  1861. +   -- more #ifdef MSDOS -> #ifdef MSDOS_OR_ATARI changes.
  1862. + 
  1863. + ++jrb  bammi@cadence.com
  1864.  
  1865. Index: lib/find.pl
  1866. *** lib/find.pl.old    Mon Jun  8 17:48:56 1992
  1867. --- lib/find.pl    Mon Jun  8 17:48:57 1992
  1868. ***************
  1869. *** 48,53 ****
  1870. --- 48,54 ----
  1871.           unless (($dir,$_) = $topdir =~ m#^(.*/)(.*)$#) {
  1872.           ($dir,$_) = ('.', $topdir);
  1873.           }
  1874. +         $name = $topdir;
  1875.           chdir $dir && &wanted;
  1876.       }
  1877.       chdir $cwd;
  1878. ***************
  1879. *** 61,67 ****
  1880.   
  1881.       # Get the list of files in the current directory.
  1882.   
  1883. !     opendir(DIR,'.') || warn "Can't open $dir: $!\n";
  1884.       local(@filenames) = readdir(DIR);
  1885.       closedir(DIR);
  1886.   
  1887. --- 62,68 ----
  1888.   
  1889.       # Get the list of files in the current directory.
  1890.   
  1891. !     opendir(DIR,'.') || (warn "Can't open $dir: $!\n", return);
  1892.       local(@filenames) = readdir(DIR);
  1893.       closedir(DIR);
  1894.   
  1895.  
  1896. Index: x2p/find2perl.SH
  1897. *** x2p/find2perl.SH.old    Mon Jun  8 17:52:56 1992
  1898. --- x2p/find2perl.SH    Mon Jun  8 17:52:56 1992
  1899. ***************
  1900. *** 6,12 ****
  1901.       ln ../../../config.sh . || \
  1902.       (echo "Can't find config.sh."; exit 1)
  1903.       fi
  1904. !     . config.sh
  1905.       ;;
  1906.   esac
  1907.   : This forces SH files to create target in same directory as SH file.
  1908. --- 6,12 ----
  1909.       ln ../../../config.sh . || \
  1910.       (echo "Can't find config.sh."; exit 1)
  1911.       fi
  1912. !     . ./config.sh
  1913.       ;;
  1914.   esac
  1915.   : This forces SH files to create target in same directory as SH file.
  1916. ***************
  1917. *** 19,27 ****
  1918. --- 19,31 ----
  1919.   : Move anything that needs config subs from !NO!SUBS! section to !GROK!THIS!.
  1920.   : Protect any dollar signs and backticks that you do not want interpreted
  1921.   : by putting a backslash in front.  You may delete these comments.
  1922. + rm -f find2perl
  1923.   $spitshell >find2perl <<!GROK!THIS!
  1924.   #!$bin/perl
  1925.   
  1926. + eval 'exec $bin/perl -S \$0 \${1+"\$@"}'
  1927. +     if \$running_under_some_shell;
  1928. + 
  1929.   \$bin = "$bin";
  1930.   
  1931.   !GROK!THIS!
  1932. ***************
  1933. *** 232,237 ****
  1934. --- 236,244 ----
  1935.   print <<"END";
  1936.   #!$bin/perl
  1937.   
  1938. + eval 'exec $bin/perl -S \$0 \${1+"\$@"}'
  1939. +     if \$running_under_some_shell;
  1940. + 
  1941.   END
  1942.   
  1943.   if ($initls) {
  1944. ***************
  1945. *** 544,550 ****
  1946.   
  1947.       $tabstring = "\t" x ($indent / 2) . ' ' x ($indent % 2 * 4);
  1948.       if (!$statdone) {
  1949. !     if ($_ =~ /^(name|print)/) {
  1950.           $delayedstat++;
  1951.       }
  1952.       else {
  1953. --- 551,557 ----
  1954.   
  1955.       $tabstring = "\t" x ($indent / 2) . ' ' x ($indent % 2 * 4);
  1956.       if (!$statdone) {
  1957. !     if ($_ =~ /^(name|print|prune|exec|ok|\(|\))/) {
  1958.           $delayedstat++;
  1959.       }
  1960.       else {
  1961.  
  1962. Index: lib/getopts.pl
  1963. *** lib/getopts.pl.old    Mon Jun  8 17:48:58 1992
  1964. --- lib/getopts.pl    Mon Jun  8 17:48:59 1992
  1965. ***************
  1966. *** 18,23 ****
  1967. --- 18,24 ----
  1968.           if($args[$pos+1] eq ':') {
  1969.           shift(@ARGV);
  1970.           if($rest eq '') {
  1971. +             ++$errs unless @ARGV;
  1972.               $rest = shift(@ARGV);
  1973.           }
  1974.           eval "\$opt_$first = \$rest;";
  1975.  
  1976. *** End of Patch 25 ***
  1977. exit 0 # Just in case...
  1978.