1 /* $Header: cmd.c,v 3.0.1.6 90/03/12 16:21:09 lwall Locked $
3 * Copyright (c) 1989, Larry Wall
5 * You may distribute under the terms of the GNU General Public License
6 * as specified in the README file that comes with the perl 3.0 kit.
9 * Revision 3.0.1.6 90/03/12 16:21:09 lwall
10 * patch13: fixed some backwards VOLATILE declarations
11 * patch13: while (s/x//) {} still caused some anomolies
12 * patch13: greater-than test of numeric switch structures did less-than action
14 * Revision 3.0.1.5 90/02/28 16:38:31 lwall
15 * patch9: volatilized some more variables for super-optimizing compilers
16 * patch9: nested foreach loops didn't reset inner loop on next to outer loop
17 * patch9: returned values were read from obsolete stack
18 * patch9: added sanity check on longjmp() return value
19 * patch9: substitutions that almost always succeed can corrupt label stack
20 * patch9: subs which return by both mechanisms can clobber local return data
22 * Revision 3.0.1.4 89/12/21 19:17:41 lwall
23 * patch7: arranged for certain registers to be restored after longjmp()
24 * patch7: made nested or recursive foreach work right
26 * Revision 3.0.1.3 89/11/17 15:04:36 lwall
27 * patch5: nested foreach on same array didn't work
29 * Revision 3.0.1.2 89/11/11 04:08:56 lwall
30 * patch2: non-BSD machines required two ^D's for <>
31 * patch2: grow_dlevel() not inside #ifdef DEBUGGING
33 * Revision 3.0.1.1 89/10/26 23:04:21 lwall
34 * patch1: heuristically disabled optimization could cause core dump
36 * Revision 3.0 89/10/18 15:09:02 lwall
52 /* do longjmps() clobber register variables? */
54 #if defined(cray) || defined(__STDC__)
58 /* This is the main command loop. We try to spend as much time in this loop
59 * as possible, so lots of optimizations do their activities in here. This
60 * means things get a little sloppy.
64 cmd_exec(cmdparm,gimme,sp)
65 CMD *VOLATILE cmdparm;
69 register CMD *cmd = cmdparm;
70 SPAT *VOLATILE oldspat;
71 VOLATILE int firstsave = savestack->ary_fill;
73 VOLATILE int aryoptsave;
75 VOLATILE int olddlevel;
76 VOLATILE int entdlevel;
78 register STR *retstr = &str_undef;
80 register int cmdflags;
82 register char *go_to = goto_targ;
83 register int newsp = -2;
84 register STR **st = stack->ary_array;
97 tainted = 0; /* Each statement is presumed innocent */
100 if (gimme == G_ARRAY && newsp > -2)
107 cmdflags = cmd->c_flags; /* hopefully load register */
109 if (cmd->c_label && strEQ(go_to,cmd->c_label))
110 goto_targ = go_to = Nullch; /* here at last */
112 switch (cmd->c_type) {
115 oldsave = savestack->ary_fill;
121 if (cmd->ucmd.ccmd.cc_true) {
124 debname[dlevel] = 't';
125 debdelim[dlevel] = '_';
126 if (++dlevel >= dlmax)
130 newsp = cmd_exec(cmd->ucmd.ccmd.cc_true,gimme,sp);
131 st = stack->ary_array; /* possibly reallocated */
137 if (savestack->ary_fill > oldsave)
138 restorelist(oldsave);
142 cmd = cmd->ucmd.ccmd.cc_alt;
143 goto tail_recursion_entry;
146 oldsave = savestack->ary_fill;
152 if (cmd->ucmd.ccmd.cc_true) {
155 debname[dlevel] = 'e';
156 debdelim[dlevel] = '_';
157 if (++dlevel >= dlmax)
161 newsp = cmd_exec(cmd->ucmd.ccmd.cc_true,gimme,sp);
162 st = stack->ary_array; /* possibly reallocated */
168 if (savestack->ary_fill > oldsave)
169 restorelist(oldsave);
176 if (!(cmdflags & CF_ONCE)) {
178 if (++loop_ptr >= loop_max) {
180 Renew(loop_stack, loop_max, struct loop);
182 loop_stack[loop_ptr].loop_label = cmd->c_label;
183 loop_stack[loop_ptr].loop_sp = sp;
186 deb("(Pushing label #%d %s)\n",
187 loop_ptr, cmd->c_label ? cmd->c_label : "");
194 if (match = setjmp(loop_stack[loop_ptr].loop_env)) {
195 st = stack->ary_array; /* possibly reallocated */
198 cmdflags = cmd->c_flags|CF_ONCE;
200 if (savestack->ary_fill > oldsave)
201 restorelist(oldsave);
204 fatal("longjmp returned bad value (%d)",match);
205 case O_LAST: /* not done unless go_to found */
212 newsp = sp + lastsize;
220 case O_NEXT: /* not done unless go_to found */
227 case O_REDO: /* not done unless go_to found */
237 oldsave = savestack->ary_fill;
241 if (cmd->ucmd.ccmd.cc_true) {
244 debname[dlevel] = 't';
245 debdelim[dlevel] = '_';
246 if (++dlevel >= dlmax)
250 newsp = cmd_exec(cmd->ucmd.ccmd.cc_true,gimme,sp);
251 st = stack->ary_array; /* possibly reallocated */
261 if (cmd->ucmd.ccmd.cc_alt) {
264 debname[dlevel] = 'a';
265 debdelim[dlevel] = '_';
266 if (++dlevel >= dlmax)
270 newsp = cmd_exec(cmd->ucmd.ccmd.cc_alt,gimme,sp);
271 st = stack->ary_array; /* possibly reallocated */
280 if (cmd && cmd->c_head == cmd)
281 /* reached end of while loop */
282 return sp; /* targ isn't in this block */
283 if (cmdflags & CF_ONCE) {
286 tmps = loop_stack[loop_ptr].loop_label;
287 deb("(Popping label #%d %s)\n",loop_ptr,
293 goto tail_recursion_entry;
299 /* Set line number so run-time errors can be located */
306 deb("%s (%lx) r%lx t%lx a%lx n%lx cs%lx\n",
307 cmdname[cmd->c_type],cmd,cmd->c_expr,
308 cmd->ucmd.ccmd.cc_true,cmd->ucmd.ccmd.cc_alt,cmd->c_next,
311 debname[dlevel] = cmdname[cmd->c_type][0];
312 debdelim[dlevel] = '!';
313 if (++dlevel >= dlmax)
318 /* Here is some common optimization */
320 if (cmdflags & CF_COND) {
321 switch (cmdflags & CF_OPTIMIZE) {
324 retstr = cmd->c_short;
327 if (cmdflags & CF_NESURE)
331 retstr = cmd->c_short;
334 if (cmdflags & CF_EQSURE)
339 retstr = STAB_STR(cmd->c_stab);
341 match = str_true(retstr); /* => retstr = retstr, c2 should fix */
342 if (cmdflags & (match ? CF_EQSURE : CF_NESURE))
346 case CFT_ANCHOR: /* /^pat/ optimization */
348 if (*cmd->c_short->str_ptr && !(cmdflags & CF_EQSURE))
349 goto scanner; /* just unanchor it */
351 break; /* must evaluate */
354 case CFT_STROP: /* string op optimization */
355 retstr = STAB_STR(cmd->c_stab);
358 if (*cmd->c_short->str_ptr == *str_get(retstr) &&
359 bcmp(cmd->c_short->str_ptr, str_get(retstr),
360 cmd->c_slen) == 0 ) {
361 if (cmdflags & CF_EQSURE) {
362 if (sawampersand && (cmdflags & CF_OPTIMIZE) != CFT_STROP) {
365 str_nset(stab_val(leftstab),"",0);
367 str_sset(stab_val(amperstab),cmd->c_short);
369 str_nset(stab_val(rightstab),
370 retstr->str_ptr + cmd->c_slen,
371 retstr->str_cur - cmd->c_slen);
373 match = !(cmdflags & CF_FIRSTNEG);
378 else if (cmdflags & CF_NESURE) {
379 match = cmdflags & CF_FIRSTNEG;
385 char *zap1, *zap2, zap1c, zap2c;
388 zap1 = cmd->c_short->str_ptr;
389 zap2 = str_get(retstr);
392 zaplen = cmd->c_slen;
393 if ((zap1c == zap2c) && (bcmp(zap1, zap2, zaplen) == 0)) {
394 if (cmdflags & CF_EQSURE) {
396 (cmdflags & CF_OPTIMIZE) != CFT_STROP) {
399 str_nset(stab_val(leftstab),"",0);
401 str_sset(stab_val(amperstab),cmd->c_short);
403 str_nset(stab_val(rightstab),
404 retstr->str_ptr + cmd->c_slen,
405 retstr->str_cur - cmd->c_slen);
407 match = !(cmdflags & CF_FIRSTNEG);
412 else if (cmdflags & CF_NESURE) {
413 match = cmdflags & CF_FIRSTNEG;
419 break; /* must evaluate */
421 case CFT_SCAN: /* non-anchored search */
423 retstr = STAB_STR(cmd->c_stab);
425 if (retstr->str_pok & SP_STUDIED)
426 if (screamfirst[cmd->c_short->str_rare] >= 0)
427 tmps = screaminstr(retstr, cmd->c_short);
431 tmps = str_get(retstr); /* make sure it's pok */
433 tmps = fbminstr((unsigned char*)tmps,
434 (unsigned char*)tmps + retstr->str_cur, cmd->c_short);
438 if (cmdflags & CF_EQSURE) {
439 ++cmd->c_short->str_u.str_useful;
443 str_nset(stab_val(leftstab),retstr->str_ptr,
444 tmps - retstr->str_ptr);
446 str_sset(stab_val(amperstab),cmd->c_short);
448 str_nset(stab_val(rightstab),
449 tmps + cmd->c_short->str_cur,
450 retstr->str_cur - (tmps - retstr->str_ptr) -
451 cmd->c_short->str_cur);
453 match = !(cmdflags & CF_FIRSTNEG);
461 if (cmdflags & CF_NESURE) {
462 ++cmd->c_short->str_u.str_useful;
463 match = cmdflags & CF_FIRSTNEG;
468 if (--cmd->c_short->str_u.str_useful < 0) {
469 cmdflags &= ~CF_OPTIMIZE;
470 cmdflags |= CFT_EVAL; /* never try this optimization again */
471 cmd->c_flags = (cmdflags & ~CF_ONCE);
473 break; /* must evaluate */
475 case CFT_NUMOP: /* numeric op optimization */
476 retstr = STAB_STR(cmd->c_stab);
478 switch (cmd->c_slen) {
481 if ((!retstr->str_nok && !looks_like_number(retstr)))
482 warn("Possible use of == on string value");
484 match = (str_gnum(retstr) == cmd->c_short->str_u.str_nval);
487 match = (str_gnum(retstr) != cmd->c_short->str_u.str_nval);
490 match = (str_gnum(retstr) < cmd->c_short->str_u.str_nval);
493 match = (str_gnum(retstr) <= cmd->c_short->str_u.str_nval);
496 match = (str_gnum(retstr) > cmd->c_short->str_u.str_nval);
499 match = (str_gnum(retstr) >= cmd->c_short->str_u.str_nval);
503 if (cmdflags & CF_EQSURE) {
508 else if (cmdflags & CF_NESURE) {
512 break; /* must evaluate */
514 case CFT_INDGETS: /* while (<$foo>) */
515 last_in_stab = stabent(str_get(STAB_STR(cmd->c_stab)),TRUE);
516 if (!stab_io(last_in_stab))
517 stab_io(last_in_stab) = stio_new();
519 case CFT_GETS: /* really a while (<file>) */
520 last_in_stab = cmd->c_stab;
522 fp = stab_io(last_in_stab)->ifp;
523 retstr = stab_val(defstab);
526 if (fp && str_gets(retstr, fp, 0)) {
527 if (*retstr->str_ptr == '0' && retstr->str_cur == 1)
531 stab_io(last_in_stab)->lines++;
533 else if (stab_io(last_in_stab)->flags & IOF_ARGV) {
535 goto doeval; /* first time through */
536 fp = nextargv(last_in_stab);
539 (void)do_close(last_in_stab,FALSE);
540 stab_io(last_in_stab)->flags |= IOF_START;
552 while (tmps_max > tmps_base) /* clean up after last eval */
553 str_free(tmps_list[tmps_max--]);
554 newsp = eval(cmd->c_expr,gimme && (cmdflags & CF_TERM),sp);
555 st = stack->ary_array; /* possibly reallocated */
557 match = str_true(retstr);
558 if (cmd->c_expr->arg_type == O_FLIP) /* undid itself? */
559 cmdflags = copyopt(cmd,cmd->c_expr[3].arg_ptr.arg_cmd);
562 retstr = stab_val(cmd->c_stab);
564 match = (retstr->str_cur != 0);
565 tmps = str_get(retstr);
566 tmps += retstr->str_cur - match;
567 str_nset(&str_chop,tmps,match);
570 retstr->str_cur = tmps - retstr->str_ptr;
574 match = cmd->c_short->str_u.str_useful; /* just to get register */
576 if (match < 0) { /* first time through here? */
577 ar = stab_array(cmd->c_expr[1].arg_ptr.arg_stab);
578 aryoptsave = savestack->ary_fill;
579 savesptr(&stab_val(cmd->c_stab));
580 savelong(&cmd->c_short->str_u.str_useful);
583 ar = stab_xarray(cmd->c_expr[1].arg_ptr.arg_stab);
584 if (cmd->c_type != C_WHILE && savestack->ary_fill > firstsave)
585 restorelist(firstsave);
588 if (match >= ar->ary_fill) { /* we're in LAST, probably */
590 cmd->c_short->str_u.str_useful = -1; /* actually redundant */
595 retstr = stab_val(cmd->c_stab) = ar->ary_array[match];
596 cmd->c_short->str_u.str_useful = match;
603 /* we have tried to make this normal case as abnormal as possible */
606 if (gimme == G_ARRAY) {
607 lastretstr = Nullstr;
609 lastsize = newsp - sp;
613 while (tmps_max > tmps_base) /* clean up after last eval */
614 str_free(tmps_list[tmps_max--]);
615 newsp = eval(cmd->c_expr,gimme && (cmdflags & CF_TERM),sp);
616 st = stack->ary_array; /* possibly reallocated */
618 if (newsp > sp && retstr)
619 match = str_true(retstr);
624 /* if flipflop was true, flop it */
627 if (match && cmdflags & CF_FLIP) {
628 while (tmps_max > tmps_base) /* clean up after last eval */
629 str_free(tmps_list[tmps_max--]);
630 if (cmd->c_expr->arg_type == O_FLOP) { /* currently toggled? */
631 newsp = eval(cmd->c_expr,G_SCALAR,sp);/*let eval undo it*/
632 cmdflags = copyopt(cmd,cmd->c_expr[3].arg_ptr.arg_cmd);
635 newsp = eval(cmd->c_expr,G_SCALAR,sp);/* let eval do it */
636 if (cmd->c_expr->arg_type == O_FLOP) /* still toggled? */
637 cmdflags = copyopt(cmd,cmd->c_expr[4].arg_ptr.arg_cmd);
640 else if (cmdflags & CF_FLIP) {
641 if (cmd->c_expr->arg_type == O_FLOP) { /* currently toggled? */
642 match = TRUE; /* force on */
646 /* at this point, match says whether our expression was true */
649 if (cmdflags & CF_INVERT)
655 tainted = 0; /* modifier doesn't affect regular expression */
658 /* now to do the actual command, if any */
660 switch (cmd->c_type) {
662 fatal("panic: cmd_exec");
663 case C_EXPR: /* evaluated for side effects */
664 if (cmd->ucmd.acmd.ac_expr) { /* more to do? */
665 if (gimme == G_ARRAY) {
666 lastretstr = Nullstr;
668 lastsize = newsp - sp;
672 while (tmps_max > tmps_base) /* clean up after last eval */
673 str_free(tmps_list[tmps_max--]);
674 newsp = eval(cmd->ucmd.acmd.ac_expr,gimme && (cmdflags&CF_TERM),sp);
675 st = stack->ary_array; /* possibly reallocated */
680 match = (int)str_gnum(STAB_STR(cmd->c_stab));
683 match = *(str_get(STAB_STR(cmd->c_stab))) & 255;
685 match -= cmd->ucmd.scmd.sc_offset;
688 else if (match > cmd->ucmd.scmd.sc_max)
689 match = cmd->ucmd.scmd.sc_max;
690 cmd = cmd->ucmd.scmd.sc_next[match];
691 goto tail_recursion_entry;
693 cmd = cmd->ucmd.ccmd.cc_alt;
694 goto tail_recursion_entry;
696 fatal("panic: ELSIF");
699 oldsave = savestack->ary_fill;
705 if (cmd->ucmd.ccmd.cc_true) {
708 debname[dlevel] = 't';
709 debdelim[dlevel] = '_';
710 if (++dlevel >= dlmax)
714 newsp = cmd_exec(cmd->ucmd.ccmd.cc_true,gimme,sp);
715 st = stack->ary_array; /* possibly reallocated */
719 if (savestack->ary_fill > oldsave)
720 restorelist(oldsave);
724 cmd = cmd->ucmd.ccmd.cc_alt;
725 goto tail_recursion_entry;
728 oldsave = savestack->ary_fill;
734 if (cmd->ucmd.ccmd.cc_true) {
737 debname[dlevel] = 'e';
738 debdelim[dlevel] = '_';
739 if (++dlevel >= dlmax)
743 newsp = cmd_exec(cmd->ucmd.ccmd.cc_true,gimme,sp);
744 st = stack->ary_array; /* possibly reallocated */
748 if (savestack->ary_fill > oldsave)
749 restorelist(oldsave);
756 if (!(cmdflags & CF_ONCE)) { /* first time through here? */
758 if (++loop_ptr >= loop_max) {
760 Renew(loop_stack, loop_max, struct loop);
762 loop_stack[loop_ptr].loop_label = cmd->c_label;
763 loop_stack[loop_ptr].loop_sp = sp;
766 deb("(Pushing label #%d %s)\n",
767 loop_ptr, cmd->c_label ? cmd->c_label : "");
774 if (match = setjmp(loop_stack[loop_ptr].loop_env)) {
775 st = stack->ary_array; /* possibly reallocated */
778 cmdflags = cmd->c_flags|CF_ONCE;
781 if (savestack->ary_fill > oldsave)
782 restorelist(oldsave);
785 fatal("longjmp returned bad value (%d)",match);
792 newsp = sp + lastsize;
815 oldsave = savestack->ary_fill;
820 if (cmd->ucmd.ccmd.cc_true) {
823 debname[dlevel] = 't';
824 debdelim[dlevel] = '_';
825 if (++dlevel >= dlmax)
829 newsp = cmd_exec(cmd->ucmd.ccmd.cc_true,gimme,sp);
830 st = stack->ary_array; /* possibly reallocated */
833 /* actually, this spot is rarely reached anymore since the above
834 * cmd_exec() returns through longjmp(). Hooray for structure.
840 if (cmd->ucmd.ccmd.cc_alt) {
843 debname[dlevel] = 'a';
844 debdelim[dlevel] = '_';
845 if (++dlevel >= dlmax)
849 newsp = cmd_exec(cmd->ucmd.ccmd.cc_alt,gimme,sp);
850 st = stack->ary_array; /* possibly reallocated */
855 if (savestack->ary_fill > oldsave) {
856 if (cmdflags & CF_TERM) {
857 for (match = sp + 1; match <= newsp; match++)
858 st[match] = str_static(st[match]);
861 restorelist(oldsave);
864 dlevel = olddlevel - 1;
866 if (cmd->c_type != C_BLOCK)
867 goto until_loop; /* go back and evaluate conditional again */
869 if (cmdflags & CF_LOOP) {
870 cmdflags |= CF_COND; /* now test the condition */
877 if (cmdflags & CF_ONCE) {
880 tmps = loop_stack[loop_ptr].loop_label;
881 deb("(Popping label #%d %s)\n",loop_ptr, tmps ? tmps : "");
885 if ((cmdflags & CF_OPTIMIZE) == CFT_ARRAY &&
886 savestack->ary_fill > aryoptsave)
887 restorelist(aryoptsave);
890 goto tail_recursion_entry;
896 deb(pat,a1,a2,a3,a4,a5,a6,a7,a8)
901 fprintf(stderr,"%-4ld",(long)line);
902 for (i=0; i<dlevel; i++)
903 fprintf(stderr,"%c%c ",debname[i],debdelim[i]);
904 fprintf(stderr,pat,a1,a2,a3,a4,a5,a6,a7,a8);
916 fprintf(stderr,"%-4ld",(long)line);
917 for (i=0; i<dlevel; i++)
918 fprintf(stderr,"%c%c ",debname[i],debdelim[i]);
920 pat = va_arg(args, char *);
921 (void) vfprintf(stderr,pat,args);
931 cmd->c_flags &= CF_ONCE|CF_COND|CF_LOOP;
932 cmd->c_flags |= which->c_flags;
933 cmd->c_short = which->c_short;
934 cmd->c_slen = which->c_slen;
935 cmd->c_stab = which->c_stab;
946 str->str_state = SS_SARY;
947 str->str_u.str_stab = stab;
949 Safefree(str->str_ptr);
952 str->str_ptr = (char*)stab_array(stab);
953 (void)apush(savestack,str); /* save array ptr */
954 stab_xarray(stab) = Null(ARRAY*);
955 return stab_xarray(aadd(stab));
965 str->str_state = SS_SHASH;
966 str->str_u.str_stab = stab;
968 Safefree(str->str_ptr);
971 str->str_ptr = (char*)stab_hash(stab);
972 (void)apush(savestack,str); /* save hash ptr */
973 stab_xhash(stab) = Null(HASH*);
974 return stab_xhash(hadd(stab));
983 (void)apush(savestack,item); /* remember the pointer */
986 (void)apush(savestack,str); /* remember the value */
996 str->str_state = SS_SINT;
997 str->str_u.str_useful = (long)*intp; /* remember value */
999 Safefree(str->str_ptr);
1002 str->str_ptr = (char*)intp; /* remember pointer */
1003 (void)apush(savestack,str);
1012 str = Str_new(14,0);
1013 str->str_state = SS_SLONG;
1014 str->str_u.str_useful = *longp; /* remember value */
1016 Safefree(str->str_ptr);
1019 str->str_ptr = (char*)longp; /* remember pointer */
1020 (void)apush(savestack,str);
1029 str = Str_new(15,0);
1030 str->str_state = SS_SSTRP;
1031 str->str_magic = *sptr; /* remember value */
1033 Safefree(str->str_ptr);
1036 str->str_ptr = (char*)sptr; /* remember pointer */
1037 (void)apush(savestack,str);
1046 str = Str_new(16,0);
1047 str->str_state = SS_SNSTAB;
1048 str->str_magic = (STR*)stab; /* remember which stab to free */
1049 (void)apush(savestack,str);
1058 str = Str_new(17,0);
1059 str->str_state = SS_SHPTR;
1060 str->str_u.str_hash = *hptr; /* remember value */
1062 Safefree(str->str_ptr);
1065 str->str_ptr = (char*)hptr; /* remember pointer */
1066 (void)apush(savestack,str);
1070 savelist(sarg,maxsarg)
1071 register STR **sarg;
1077 for (i = 1; i <= maxsarg; i++) {
1078 (void)apush(savestack,sarg[i]); /* remember the pointer */
1079 str = Str_new(18,0);
1080 str_sset(str,sarg[i]);
1081 (void)apush(savestack,str); /* remember the value */
1082 sarg[i]->str_u.str_useful = -1;
1091 register STR *value;
1092 register STAB *stab;
1095 fatal("panic: corrupt saved stack index");
1096 while (savestack->ary_fill > base) {
1097 value = apop(savestack);
1098 switch (value->str_state) {
1099 case SS_NORM: /* normal string */
1101 str = apop(savestack);
1102 str_replace(str,value);
1105 case SS_SARY: /* array reference */
1106 stab = value->str_u.str_stab;
1107 afree(stab_xarray(stab));
1108 stab_xarray(stab) = (ARRAY*)value->str_ptr;
1109 value->str_ptr = Nullch;
1112 case SS_SHASH: /* hash reference */
1113 stab = value->str_u.str_stab;
1114 (void)hfree(stab_xhash(stab));
1115 stab_xhash(stab) = (HASH*)value->str_ptr;
1116 value->str_ptr = Nullch;
1119 case SS_SINT: /* int reference */
1120 *((int*)value->str_ptr) = (int)value->str_u.str_useful;
1121 value->str_ptr = Nullch;
1124 case SS_SLONG: /* long reference */
1125 *((long*)value->str_ptr) = value->str_u.str_useful;
1126 value->str_ptr = Nullch;
1129 case SS_SSTRP: /* STR* reference */
1130 *((STR**)value->str_ptr) = value->str_magic;
1131 value->str_magic = Nullstr;
1132 value->str_ptr = Nullch;
1135 case SS_SHPTR: /* HASH* reference */
1136 *((HASH**)value->str_ptr) = value->str_u.str_hash;
1137 value->str_ptr = Nullch;
1141 stab = (STAB*)value->str_magic;
1142 value->str_magic = Nullstr;
1143 (void)stab_clear(stab);
1147 fatal("panic: restorelist inconsistency");
1157 Renew(debname, dlmax, char);
1158 Renew(debdelim, dlmax, char);