| /* $RCSfile$$Revision$$Date$ |
| * |
| * Copyright (c) 1989, Larry Wall |
| * |
| * You may distribute under the terms of the GNU General Public License |
| * as specified in the README file that comes with the perl 3.0 kit. |
| * |
| * $Log$ |
| * Revision 1.1 2004/02/17 22:21:15 criswell |
| * Initial commit of the perl Malloc Benchmark. I've cheated a little by |
| * generating the yacc output files and committing them directly, but it was |
| * easier than disabling the Bison Voodoo that gets executed by default. |
| * |
| * Revision 4.0.1.1 91/04/11 17:36:16 lwall |
| * patch1: you may now use "die" and "caller" in a signal handler |
| * |
| * Revision 4.0 91/03/20 01:04:18 lwall |
| * 4.0 baseline. |
| * |
| */ |
| |
| #include "EXTERN.h" |
| #include "perl.h" |
| |
| #ifdef I_VARARGS |
| # include <varargs.h> |
| #endif |
| |
| static STR str_chop; |
| |
| void grow_dlevel(); |
| |
| /* do longjmps() clobber register variables? */ |
| |
| #if defined(cray) || defined(__STDC__) |
| #define JMPCLOBBER |
| #endif |
| |
| /* This is the main command loop. We try to spend as much time in this loop |
| * as possible, so lots of optimizations do their activities in here. This |
| * means things get a little sloppy. |
| */ |
| |
| int |
| cmd_exec(cmdparm,gimme,sp) |
| CMD *VOLATILE cmdparm; |
| VOLATILE int gimme; |
| VOLATILE int sp; |
| { |
| register CMD *cmd = cmdparm; |
| SPAT *VOLATILE oldspat; |
| VOLATILE int firstsave = savestack->ary_fill; |
| VOLATILE int oldsave; |
| VOLATILE int aryoptsave; |
| #ifdef DEBUGGING |
| VOLATILE int olddlevel; |
| VOLATILE int entdlevel; |
| #endif |
| register STR *retstr = &str_undef; |
| register char *tmps; |
| register int cmdflags; |
| register int match; |
| register char *go_to = goto_targ; |
| register int newsp = -2; |
| register STR **st = stack->ary_array; |
| FILE *VOLATILE fp; |
| ARRAY *VOLATILE ar; |
| |
| lastsize = 0; |
| #ifdef DEBUGGING |
| entdlevel = dlevel; |
| #endif |
| tail_recursion_entry: |
| #ifdef DEBUGGING |
| dlevel = entdlevel; |
| #endif |
| #ifdef TAINT |
| tainted = 0; /* Each statement is presumed innocent */ |
| #endif |
| if (cmd == Nullcmd) { |
| if (gimme == G_ARRAY && newsp > -2) |
| return newsp; |
| else { |
| st[++sp] = retstr; |
| return sp; |
| } |
| } |
| cmdflags = cmd->c_flags; /* hopefully load register */ |
| if (go_to) { |
| if (cmd->c_label && strEQ(go_to,cmd->c_label)) |
| goto_targ = go_to = Nullch; /* here at last */ |
| else { |
| switch (cmd->c_type) { |
| case C_IF: |
| oldspat = curspat; |
| oldsave = savestack->ary_fill; |
| #ifdef DEBUGGING |
| olddlevel = dlevel; |
| #endif |
| retstr = &str_yes; |
| newsp = -2; |
| if (cmd->ucmd.ccmd.cc_true) { |
| #ifdef DEBUGGING |
| if (debug) { |
| debname[dlevel] = 't'; |
| debdelim[dlevel] = '_'; |
| if (++dlevel >= dlmax) |
| grow_dlevel(); |
| } |
| #endif |
| newsp = cmd_exec(cmd->ucmd.ccmd.cc_true,gimme && (cmdflags & CF_TERM),sp); |
| st = stack->ary_array; /* possibly reallocated */ |
| retstr = st[newsp]; |
| } |
| if (!goto_targ) |
| go_to = Nullch; |
| curspat = oldspat; |
| if (savestack->ary_fill > oldsave) |
| restorelist(oldsave); |
| #ifdef DEBUGGING |
| dlevel = olddlevel; |
| #endif |
| cmd = cmd->ucmd.ccmd.cc_alt; |
| goto tail_recursion_entry; |
| case C_ELSE: |
| oldspat = curspat; |
| oldsave = savestack->ary_fill; |
| #ifdef DEBUGGING |
| olddlevel = dlevel; |
| #endif |
| retstr = &str_undef; |
| newsp = -2; |
| if (cmd->ucmd.ccmd.cc_true) { |
| #ifdef DEBUGGING |
| if (debug) { |
| debname[dlevel] = 'e'; |
| debdelim[dlevel] = '_'; |
| if (++dlevel >= dlmax) |
| grow_dlevel(); |
| } |
| #endif |
| newsp = cmd_exec(cmd->ucmd.ccmd.cc_true,gimme && (cmdflags & CF_TERM),sp); |
| st = stack->ary_array; /* possibly reallocated */ |
| retstr = st[newsp]; |
| } |
| if (!goto_targ) |
| go_to = Nullch; |
| curspat = oldspat; |
| if (savestack->ary_fill > oldsave) |
| restorelist(oldsave); |
| #ifdef DEBUGGING |
| dlevel = olddlevel; |
| #endif |
| break; |
| case C_BLOCK: |
| case C_WHILE: |
| if (!(cmdflags & CF_ONCE)) { |
| cmdflags |= CF_ONCE; |
| if (++loop_ptr >= loop_max) { |
| loop_max += 128; |
| Renew(loop_stack, loop_max, struct loop); |
| } |
| loop_stack[loop_ptr].loop_label = cmd->c_label; |
| loop_stack[loop_ptr].loop_sp = sp; |
| #ifdef DEBUGGING |
| if (debug & 4) { |
| deb("(Pushing label #%d %s)\n", |
| loop_ptr, cmd->c_label ? cmd->c_label : ""); |
| } |
| #endif |
| } |
| #ifdef JMPCLOBBER |
| cmdparm = cmd; |
| #endif |
| match = setjmp(loop_stack[loop_ptr].loop_env); |
| if (match) { |
| st = stack->ary_array; /* possibly reallocated */ |
| #ifdef JMPCLOBBER |
| cmd = cmdparm; |
| cmdflags = cmd->c_flags|CF_ONCE; |
| #endif |
| if (savestack->ary_fill > oldsave) |
| restorelist(oldsave); |
| switch (match) { |
| default: |
| fatal("longjmp returned bad value (%d)",match); |
| case O_LAST: /* not done unless go_to found */ |
| go_to = Nullch; |
| if (lastretstr) { |
| retstr = lastretstr; |
| newsp = -2; |
| } |
| else { |
| newsp = sp + lastsize; |
| retstr = st[newsp]; |
| } |
| #ifdef DEBUGGING |
| olddlevel = dlevel; |
| #endif |
| curspat = oldspat; |
| goto next_cmd; |
| case O_NEXT: /* not done unless go_to found */ |
| go_to = Nullch; |
| #ifdef JMPCLOBBER |
| newsp = -2; |
| retstr = &str_undef; |
| #endif |
| goto next_iter; |
| case O_REDO: /* not done unless go_to found */ |
| go_to = Nullch; |
| #ifdef JMPCLOBBER |
| newsp = -2; |
| retstr = &str_undef; |
| #endif |
| goto doit; |
| } |
| } |
| oldspat = curspat; |
| oldsave = savestack->ary_fill; |
| #ifdef DEBUGGING |
| olddlevel = dlevel; |
| #endif |
| if (cmd->ucmd.ccmd.cc_true) { |
| #ifdef DEBUGGING |
| if (debug) { |
| debname[dlevel] = 't'; |
| debdelim[dlevel] = '_'; |
| if (++dlevel >= dlmax) |
| grow_dlevel(); |
| } |
| #endif |
| newsp = cmd_exec(cmd->ucmd.ccmd.cc_true,gimme && (cmdflags & CF_TERM),sp); |
| st = stack->ary_array; /* possibly reallocated */ |
| retstr = st[newsp]; |
| } |
| if (!goto_targ) { |
| go_to = Nullch; |
| goto next_iter; |
| } |
| #ifdef DEBUGGING |
| dlevel = olddlevel; |
| #endif |
| if (cmd->ucmd.ccmd.cc_alt) { |
| #ifdef DEBUGGING |
| if (debug) { |
| debname[dlevel] = 'a'; |
| debdelim[dlevel] = '_'; |
| if (++dlevel >= dlmax) |
| grow_dlevel(); |
| } |
| #endif |
| newsp = cmd_exec(cmd->ucmd.ccmd.cc_alt,gimme && (cmdflags & CF_TERM),sp); |
| st = stack->ary_array; /* possibly reallocated */ |
| retstr = st[newsp]; |
| } |
| if (goto_targ) |
| break; |
| go_to = Nullch; |
| goto finish_while; |
| } |
| cmd = cmd->c_next; |
| if (cmd && cmd->c_head == cmd) |
| /* reached end of while loop */ |
| return sp; /* targ isn't in this block */ |
| if (cmdflags & CF_ONCE) { |
| #ifdef DEBUGGING |
| if (debug & 4) { |
| tmps = loop_stack[loop_ptr].loop_label; |
| deb("(Popping label #%d %s)\n",loop_ptr, |
| tmps ? tmps : "" ); |
| } |
| #endif |
| loop_ptr--; |
| } |
| goto tail_recursion_entry; |
| } |
| } |
| |
| until_loop: |
| |
| /* Set line number so run-time errors can be located */ |
| |
| curcmd = cmd; |
| |
| #ifdef DEBUGGING |
| if (debug) { |
| if (debug & 2) { |
| deb("%s (%lx) r%lx t%lx a%lx n%lx cs%lx\n", |
| cmdname[cmd->c_type],cmd,cmd->c_expr, |
| cmd->ucmd.ccmd.cc_true,cmd->ucmd.ccmd.cc_alt,cmd->c_next, |
| curspat); |
| } |
| debname[dlevel] = cmdname[cmd->c_type][0]; |
| debdelim[dlevel] = '!'; |
| if (++dlevel >= dlmax) |
| grow_dlevel(); |
| } |
| #endif |
| |
| /* Here is some common optimization */ |
| |
| if (cmdflags & CF_COND) { |
| switch (cmdflags & CF_OPTIMIZE) { |
| |
| case CFT_FALSE: |
| retstr = cmd->c_short; |
| newsp = -2; |
| match = FALSE; |
| if (cmdflags & CF_NESURE) |
| goto maybe; |
| break; |
| case CFT_TRUE: |
| retstr = cmd->c_short; |
| newsp = -2; |
| match = TRUE; |
| if (cmdflags & CF_EQSURE) |
| goto flipmaybe; |
| break; |
| |
| case CFT_REG: |
| retstr = STAB_STR(cmd->c_stab); |
| newsp = -2; |
| match = str_true(retstr); /* => retstr = retstr, c2 should fix */ |
| if (cmdflags & (match ? CF_EQSURE : CF_NESURE)) |
| goto flipmaybe; |
| break; |
| |
| case CFT_ANCHOR: /* /^pat/ optimization */ |
| if (multiline) { |
| if (*cmd->c_short->str_ptr && !(cmdflags & CF_EQSURE)) |
| goto scanner; /* just unanchor it */ |
| else |
| break; /* must evaluate */ |
| } |
| /* FALL THROUGH */ |
| case CFT_STROP: /* string op optimization */ |
| retstr = STAB_STR(cmd->c_stab); |
| newsp = -2; |
| #ifndef I286 |
| if (*cmd->c_short->str_ptr == *str_get(retstr) && |
| bcmp(cmd->c_short->str_ptr, str_get(retstr), |
| cmd->c_slen) == 0 ) { |
| if (cmdflags & CF_EQSURE) { |
| if (sawampersand && (cmdflags & CF_OPTIMIZE) != CFT_STROP) { |
| curspat = Nullspat; |
| if (leftstab) |
| str_nset(stab_val(leftstab),"",0); |
| if (amperstab) |
| str_sset(stab_val(amperstab),cmd->c_short); |
| if (rightstab) |
| str_nset(stab_val(rightstab), |
| retstr->str_ptr + cmd->c_slen, |
| retstr->str_cur - cmd->c_slen); |
| } |
| if (cmd->c_spat) |
| lastspat = cmd->c_spat; |
| match = !(cmdflags & CF_FIRSTNEG); |
| retstr = &str_yes; |
| goto flipmaybe; |
| } |
| } |
| else if (cmdflags & CF_NESURE) { |
| match = cmdflags & CF_FIRSTNEG; |
| retstr = &str_no; |
| goto flipmaybe; |
| } |
| #else |
| { |
| char *zap1, *zap2, zap1c, zap2c; |
| int zaplen; |
| |
| zap1 = cmd->c_short->str_ptr; |
| zap2 = str_get(retstr); |
| zap1c = *zap1; |
| zap2c = *zap2; |
| zaplen = cmd->c_slen; |
| if ((zap1c == zap2c) && (bcmp(zap1, zap2, zaplen) == 0)) { |
| if (cmdflags & CF_EQSURE) { |
| if (sawampersand && |
| (cmdflags & CF_OPTIMIZE) != CFT_STROP) { |
| curspat = Nullspat; |
| if (leftstab) |
| str_nset(stab_val(leftstab),"",0); |
| if (amperstab) |
| str_sset(stab_val(amperstab),cmd->c_short); |
| if (rightstab) |
| str_nset(stab_val(rightstab), |
| retstr->str_ptr + cmd->c_slen, |
| retstr->str_cur - cmd->c_slen); |
| } |
| if (cmd->c_spat) |
| lastspat = cmd->c_spat; |
| match = !(cmdflags & CF_FIRSTNEG); |
| retstr = &str_yes; |
| goto flipmaybe; |
| } |
| } |
| else if (cmdflags & CF_NESURE) { |
| match = cmdflags & CF_FIRSTNEG; |
| retstr = &str_no; |
| goto flipmaybe; |
| } |
| } |
| #endif |
| break; /* must evaluate */ |
| |
| case CFT_SCAN: /* non-anchored search */ |
| scanner: |
| retstr = STAB_STR(cmd->c_stab); |
| newsp = -2; |
| if (retstr->str_pok & SP_STUDIED) |
| if (screamfirst[cmd->c_short->str_rare] >= 0) |
| tmps = screaminstr(retstr, cmd->c_short); |
| else |
| tmps = Nullch; |
| else { |
| tmps = str_get(retstr); /* make sure it's pok */ |
| #ifndef lint |
| tmps = fbminstr((unsigned char*)tmps, |
| (unsigned char*)tmps + retstr->str_cur, cmd->c_short); |
| #endif |
| } |
| if (tmps) { |
| if (cmdflags & CF_EQSURE) { |
| ++cmd->c_short->str_u.str_useful; |
| if (sawampersand) { |
| curspat = Nullspat; |
| if (leftstab) |
| str_nset(stab_val(leftstab),retstr->str_ptr, |
| tmps - retstr->str_ptr); |
| if (amperstab) |
| str_nset(stab_val(amperstab), |
| tmps, cmd->c_short->str_cur); |
| if (rightstab) |
| str_nset(stab_val(rightstab), |
| tmps + cmd->c_short->str_cur, |
| retstr->str_cur - (tmps - retstr->str_ptr) - |
| cmd->c_short->str_cur); |
| } |
| lastspat = cmd->c_spat; |
| match = !(cmdflags & CF_FIRSTNEG); |
| retstr = &str_yes; |
| goto flipmaybe; |
| } |
| else |
| hint = tmps; |
| } |
| else { |
| if (cmdflags & CF_NESURE) { |
| ++cmd->c_short->str_u.str_useful; |
| match = cmdflags & CF_FIRSTNEG; |
| retstr = &str_no; |
| goto flipmaybe; |
| } |
| } |
| if (--cmd->c_short->str_u.str_useful < 0) { |
| cmdflags &= ~CF_OPTIMIZE; |
| cmdflags |= CFT_EVAL; /* never try this optimization again */ |
| cmd->c_flags = (cmdflags & ~CF_ONCE); |
| } |
| break; /* must evaluate */ |
| |
| case CFT_NUMOP: /* numeric op optimization */ |
| retstr = STAB_STR(cmd->c_stab); |
| newsp = -2; |
| switch (cmd->c_slen) { |
| case O_EQ: |
| if (dowarn) { |
| if ((!retstr->str_nok && !looks_like_number(retstr))) |
| warn("Possible use of == on string value"); |
| } |
| match = (str_gnum(retstr) == cmd->c_short->str_u.str_nval); |
| break; |
| case O_NE: |
| match = (str_gnum(retstr) != cmd->c_short->str_u.str_nval); |
| break; |
| case O_LT: |
| match = (str_gnum(retstr) < cmd->c_short->str_u.str_nval); |
| break; |
| case O_LE: |
| match = (str_gnum(retstr) <= cmd->c_short->str_u.str_nval); |
| break; |
| case O_GT: |
| match = (str_gnum(retstr) > cmd->c_short->str_u.str_nval); |
| break; |
| case O_GE: |
| match = (str_gnum(retstr) >= cmd->c_short->str_u.str_nval); |
| break; |
| } |
| if (match) { |
| if (cmdflags & CF_EQSURE) { |
| retstr = &str_yes; |
| goto flipmaybe; |
| } |
| } |
| else if (cmdflags & CF_NESURE) { |
| retstr = &str_no; |
| goto flipmaybe; |
| } |
| break; /* must evaluate */ |
| |
| case CFT_INDGETS: /* while (<$foo>) */ |
| last_in_stab = stabent(str_get(STAB_STR(cmd->c_stab)),TRUE); |
| if (!stab_io(last_in_stab)) |
| stab_io(last_in_stab) = stio_new(); |
| goto dogets; |
| case CFT_GETS: /* really a while (<file>) */ |
| last_in_stab = cmd->c_stab; |
| dogets: |
| fp = stab_io(last_in_stab)->ifp; |
| retstr = stab_val(defstab); |
| newsp = -2; |
| keepgoing: |
| if (fp && str_gets(retstr, fp, 0)) { |
| if (*retstr->str_ptr == '0' && retstr->str_cur == 1) |
| match = FALSE; |
| else |
| match = TRUE; |
| stab_io(last_in_stab)->lines++; |
| } |
| else if (stab_io(last_in_stab)->flags & IOF_ARGV) { |
| if (!fp) |
| goto doeval; /* first time through */ |
| fp = nextargv(last_in_stab); |
| if (fp) |
| goto keepgoing; |
| (void)do_close(last_in_stab,FALSE); |
| stab_io(last_in_stab)->flags |= IOF_START; |
| retstr = &str_undef; |
| match = FALSE; |
| } |
| else { |
| retstr = &str_undef; |
| match = FALSE; |
| } |
| goto flipmaybe; |
| case CFT_EVAL: |
| break; |
| case CFT_UNFLIP: |
| while (tmps_max > tmps_base) { /* clean up after last eval */ |
| str_free(tmps_list[tmps_max]); |
| tmps_list[tmps_max--] = Nullstr; |
| } |
| newsp = eval(cmd->c_expr,gimme && (cmdflags & CF_TERM),sp); |
| st = stack->ary_array; /* possibly reallocated */ |
| retstr = st[newsp]; |
| match = str_true(retstr); |
| if (cmd->c_expr->arg_type == O_FLIP) /* undid itself? */ |
| cmdflags = copyopt(cmd,cmd->c_expr[3].arg_ptr.arg_cmd); |
| goto maybe; |
| case CFT_CHOP: |
| retstr = stab_val(cmd->c_stab); |
| newsp = -2; |
| match = (retstr->str_cur != 0); |
| tmps = str_get(retstr); |
| tmps += retstr->str_cur - match; |
| str_nset(&str_chop,tmps,match); |
| *tmps = '\0'; |
| retstr->str_nok = 0; |
| retstr->str_cur = tmps - retstr->str_ptr; |
| STABSET(retstr); |
| retstr = &str_chop; |
| goto flipmaybe; |
| case CFT_ARRAY: |
| match = cmd->c_short->str_u.str_useful; /* just to get register */ |
| |
| if (match < 0) { /* first time through here? */ |
| ar = stab_array(cmd->c_expr[1].arg_ptr.arg_stab); |
| aryoptsave = savestack->ary_fill; |
| savesptr(&stab_val(cmd->c_stab)); |
| savelong(&cmd->c_short->str_u.str_useful); |
| } |
| else { |
| ar = stab_xarray(cmd->c_expr[1].arg_ptr.arg_stab); |
| if (cmd->c_type != C_WHILE && savestack->ary_fill > firstsave) |
| restorelist(firstsave); |
| } |
| |
| if (match >= ar->ary_fill) { /* we're in LAST, probably */ |
| retstr = &str_undef; |
| cmd->c_short->str_u.str_useful = -1; /* actually redundant */ |
| match = FALSE; |
| } |
| else { |
| match++; |
| if (!(retstr = ar->ary_array[match])) |
| retstr = afetch(ar,match,TRUE); |
| stab_val(cmd->c_stab) = retstr; |
| cmd->c_short->str_u.str_useful = match; |
| match = TRUE; |
| } |
| newsp = -2; |
| goto maybe; |
| case CFT_D1: |
| break; |
| case CFT_D0: |
| if (DBsingle->str_u.str_nval != 0) |
| break; |
| if (DBsignal->str_u.str_nval != 0) |
| break; |
| if (DBtrace->str_u.str_nval != 0) |
| break; |
| goto next_cmd; |
| } |
| |
| /* we have tried to make this normal case as abnormal as possible */ |
| |
| doeval: |
| if (gimme == G_ARRAY) { |
| lastretstr = Nullstr; |
| lastspbase = sp; |
| lastsize = newsp - sp; |
| if (lastsize < 0) |
| lastsize = 0; |
| } |
| else |
| lastretstr = retstr; |
| while (tmps_max > tmps_base) { /* clean up after last eval */ |
| str_free(tmps_list[tmps_max]); |
| tmps_list[tmps_max--] = Nullstr; |
| } |
| newsp = eval(cmd->c_expr, |
| gimme && (cmdflags & CF_TERM) && cmd->c_type == C_EXPR && |
| !cmd->ucmd.acmd.ac_expr, |
| sp); |
| st = stack->ary_array; /* possibly reallocated */ |
| retstr = st[newsp]; |
| if (newsp > sp && retstr) |
| match = str_true(retstr); |
| else |
| match = FALSE; |
| goto maybe; |
| |
| /* if flipflop was true, flop it */ |
| |
| flipmaybe: |
| if (match && cmdflags & CF_FLIP) { |
| while (tmps_max > tmps_base) { /* clean up after last eval */ |
| str_free(tmps_list[tmps_max]); |
| tmps_list[tmps_max--] = Nullstr; |
| } |
| if (cmd->c_expr->arg_type == O_FLOP) { /* currently toggled? */ |
| newsp = eval(cmd->c_expr,G_SCALAR,sp);/*let eval undo it*/ |
| cmdflags = copyopt(cmd,cmd->c_expr[3].arg_ptr.arg_cmd); |
| } |
| else { |
| newsp = eval(cmd->c_expr,G_SCALAR,sp);/* let eval do it */ |
| if (cmd->c_expr->arg_type == O_FLOP) /* still toggled? */ |
| cmdflags = copyopt(cmd,cmd->c_expr[4].arg_ptr.arg_cmd); |
| } |
| } |
| else if (cmdflags & CF_FLIP) { |
| if (cmd->c_expr->arg_type == O_FLOP) { /* currently toggled? */ |
| match = TRUE; /* force on */ |
| } |
| } |
| |
| /* at this point, match says whether our expression was true */ |
| |
| maybe: |
| if (cmdflags & CF_INVERT) |
| match = !match; |
| if (!match) |
| goto next_cmd; |
| } |
| #ifdef TAINT |
| tainted = 0; /* modifier doesn't affect regular expression */ |
| #endif |
| |
| /* now to do the actual command, if any */ |
| |
| switch (cmd->c_type) { |
| case C_NULL: |
| fatal("panic: cmd_exec"); |
| case C_EXPR: /* evaluated for side effects */ |
| if (cmd->ucmd.acmd.ac_expr) { /* more to do? */ |
| if (gimme == G_ARRAY) { |
| lastretstr = Nullstr; |
| lastspbase = sp; |
| lastsize = newsp - sp; |
| if (lastsize < 0) |
| lastsize = 0; |
| } |
| else |
| lastretstr = retstr; |
| while (tmps_max > tmps_base) { /* clean up after last eval */ |
| str_free(tmps_list[tmps_max]); |
| tmps_list[tmps_max--] = Nullstr; |
| } |
| newsp = eval(cmd->ucmd.acmd.ac_expr,gimme && (cmdflags&CF_TERM),sp); |
| st = stack->ary_array; /* possibly reallocated */ |
| retstr = st[newsp]; |
| } |
| break; |
| case C_NSWITCH: |
| { |
| double value = str_gnum(STAB_STR(cmd->c_stab)); |
| |
| match = (int)value; |
| if (value < 0.0) { |
| if (((double)match) > value) |
| --match; /* was fractional--truncate other way */ |
| } |
| } |
| goto doswitch; |
| case C_CSWITCH: |
| match = *(str_get(STAB_STR(cmd->c_stab))) & 255; |
| doswitch: |
| match -= cmd->ucmd.scmd.sc_offset; |
| if (match < 0) |
| match = 0; |
| else if (match > cmd->ucmd.scmd.sc_max) |
| match = cmd->ucmd.scmd.sc_max; |
| cmd = cmd->ucmd.scmd.sc_next[match]; |
| goto tail_recursion_entry; |
| case C_NEXT: |
| cmd = cmd->ucmd.ccmd.cc_alt; |
| goto tail_recursion_entry; |
| case C_ELSIF: |
| fatal("panic: ELSIF"); |
| case C_IF: |
| oldspat = curspat; |
| oldsave = savestack->ary_fill; |
| #ifdef DEBUGGING |
| olddlevel = dlevel; |
| #endif |
| retstr = &str_yes; |
| newsp = -2; |
| if (cmd->ucmd.ccmd.cc_true) { |
| #ifdef DEBUGGING |
| if (debug) { |
| debname[dlevel] = 't'; |
| debdelim[dlevel] = '_'; |
| if (++dlevel >= dlmax) |
| grow_dlevel(); |
| } |
| #endif |
| newsp = cmd_exec(cmd->ucmd.ccmd.cc_true,gimme && (cmdflags & CF_TERM),sp); |
| st = stack->ary_array; /* possibly reallocated */ |
| retstr = st[newsp]; |
| } |
| curspat = oldspat; |
| if (savestack->ary_fill > oldsave) |
| restorelist(oldsave); |
| #ifdef DEBUGGING |
| dlevel = olddlevel; |
| #endif |
| cmd = cmd->ucmd.ccmd.cc_alt; |
| goto tail_recursion_entry; |
| case C_ELSE: |
| oldspat = curspat; |
| oldsave = savestack->ary_fill; |
| #ifdef DEBUGGING |
| olddlevel = dlevel; |
| #endif |
| retstr = &str_undef; |
| newsp = -2; |
| if (cmd->ucmd.ccmd.cc_true) { |
| #ifdef DEBUGGING |
| if (debug) { |
| debname[dlevel] = 'e'; |
| debdelim[dlevel] = '_'; |
| if (++dlevel >= dlmax) |
| grow_dlevel(); |
| } |
| #endif |
| newsp = cmd_exec(cmd->ucmd.ccmd.cc_true,gimme && (cmdflags & CF_TERM),sp); |
| st = stack->ary_array; /* possibly reallocated */ |
| retstr = st[newsp]; |
| } |
| curspat = oldspat; |
| if (savestack->ary_fill > oldsave) |
| restorelist(oldsave); |
| #ifdef DEBUGGING |
| dlevel = olddlevel; |
| #endif |
| break; |
| case C_BLOCK: |
| case C_WHILE: |
| if (!(cmdflags & CF_ONCE)) { /* first time through here? */ |
| cmdflags |= CF_ONCE; |
| if (++loop_ptr >= loop_max) { |
| loop_max += 128; |
| Renew(loop_stack, loop_max, struct loop); |
| } |
| loop_stack[loop_ptr].loop_label = cmd->c_label; |
| loop_stack[loop_ptr].loop_sp = sp; |
| #ifdef DEBUGGING |
| if (debug & 4) { |
| deb("(Pushing label #%d %s)\n", |
| loop_ptr, cmd->c_label ? cmd->c_label : ""); |
| } |
| #endif |
| } |
| #ifdef JMPCLOBBER |
| cmdparm = cmd; |
| #endif |
| match = setjmp(loop_stack[loop_ptr].loop_env); |
| if (match) { |
| st = stack->ary_array; /* possibly reallocated */ |
| #ifdef JMPCLOBBER |
| cmd = cmdparm; |
| cmdflags = cmd->c_flags|CF_ONCE; |
| go_to = goto_targ; |
| #endif |
| if (savestack->ary_fill > oldsave) |
| restorelist(oldsave); |
| switch (match) { |
| default: |
| fatal("longjmp returned bad value (%d)",match); |
| case O_LAST: |
| if (lastretstr) { |
| retstr = lastretstr; |
| newsp = -2; |
| } |
| else { |
| newsp = sp + lastsize; |
| retstr = st[newsp]; |
| } |
| curspat = oldspat; |
| goto next_cmd; |
| case O_NEXT: |
| #ifdef JMPCLOBBER |
| newsp = -2; |
| retstr = &str_undef; |
| #endif |
| goto next_iter; |
| case O_REDO: |
| #ifdef DEBUGGING |
| dlevel = olddlevel; |
| #endif |
| #ifdef JMPCLOBBER |
| newsp = -2; |
| retstr = &str_undef; |
| #endif |
| goto doit; |
| } |
| } |
| oldspat = curspat; |
| oldsave = savestack->ary_fill; |
| #ifdef DEBUGGING |
| olddlevel = dlevel; |
| #endif |
| doit: |
| if (cmd->ucmd.ccmd.cc_true) { |
| #ifdef DEBUGGING |
| if (debug) { |
| debname[dlevel] = 't'; |
| debdelim[dlevel] = '_'; |
| if (++dlevel >= dlmax) |
| grow_dlevel(); |
| } |
| #endif |
| newsp = cmd_exec(cmd->ucmd.ccmd.cc_true,gimme && (cmdflags & CF_TERM),sp); |
| st = stack->ary_array; /* possibly reallocated */ |
| retstr = st[newsp]; |
| } |
| /* actually, this spot is rarely reached anymore since the above |
| * cmd_exec() returns through longjmp(). Hooray for structure. |
| */ |
| next_iter: |
| #ifdef DEBUGGING |
| dlevel = olddlevel; |
| #endif |
| if (cmd->ucmd.ccmd.cc_alt) { |
| #ifdef DEBUGGING |
| if (debug) { |
| debname[dlevel] = 'a'; |
| debdelim[dlevel] = '_'; |
| if (++dlevel >= dlmax) |
| grow_dlevel(); |
| } |
| #endif |
| newsp = cmd_exec(cmd->ucmd.ccmd.cc_alt,gimme && (cmdflags & CF_TERM),sp); |
| st = stack->ary_array; /* possibly reallocated */ |
| retstr = st[newsp]; |
| } |
| finish_while: |
| curspat = oldspat; |
| if (savestack->ary_fill > oldsave) { |
| if (cmdflags & CF_TERM) { |
| for (match = sp + 1; match <= newsp; match++) |
| st[match] = str_mortal(st[match]); |
| retstr = st[newsp]; |
| } |
| restorelist(oldsave); |
| } |
| #ifdef DEBUGGING |
| dlevel = olddlevel - 1; |
| #endif |
| if (cmd->c_type != C_BLOCK) |
| goto until_loop; /* go back and evaluate conditional again */ |
| } |
| if (cmdflags & CF_LOOP) { |
| cmdflags |= CF_COND; /* now test the condition */ |
| #ifdef DEBUGGING |
| dlevel = entdlevel; |
| #endif |
| goto until_loop; |
| } |
| next_cmd: |
| if (cmdflags & CF_ONCE) { |
| #ifdef DEBUGGING |
| if (debug & 4) { |
| tmps = loop_stack[loop_ptr].loop_label; |
| deb("(Popping label #%d %s)\n",loop_ptr, tmps ? tmps : ""); |
| } |
| #endif |
| loop_ptr--; |
| if ((cmdflags & CF_OPTIMIZE) == CFT_ARRAY && |
| savestack->ary_fill > aryoptsave) |
| restorelist(aryoptsave); |
| } |
| cmd = cmd->c_next; |
| goto tail_recursion_entry; |
| } |
| |
| #ifdef DEBUGGING |
| # ifndef I_VARARGS |
| /*VARARGS1*/ |
| deb(pat,a1,a2,a3,a4,a5,a6,a7,a8) |
| char *pat; |
| { |
| register int i; |
| |
| fprintf(stderr,"%-4ld",(long)curcmd->c_line); |
| for (i=0; i<dlevel; i++) |
| fprintf(stderr,"%c%c ",debname[i],debdelim[i]); |
| fprintf(stderr,pat,a1,a2,a3,a4,a5,a6,a7,a8); |
| } |
| # else |
| /*VARARGS1*/ |
| deb(va_alist) |
| va_dcl |
| { |
| va_list args; |
| char *pat; |
| register int i; |
| |
| va_start(args); |
| fprintf(stderr,"%-4ld",(long)curcmd->c_line); |
| for (i=0; i<dlevel; i++) |
| fprintf(stderr,"%c%c ",debname[i],debdelim[i]); |
| |
| pat = va_arg(args, char *); |
| (void) vfprintf(stderr,pat,args); |
| va_end( args ); |
| } |
| # endif |
| #endif |
| |
| copyopt(cmd,which) |
| register CMD *cmd; |
| register CMD *which; |
| { |
| cmd->c_flags &= CF_ONCE|CF_COND|CF_LOOP; |
| cmd->c_flags |= which->c_flags; |
| cmd->c_short = which->c_short; |
| cmd->c_slen = which->c_slen; |
| cmd->c_stab = which->c_stab; |
| return cmd->c_flags; |
| } |
| |
| ARRAY * |
| saveary(stab) |
| STAB *stab; |
| { |
| register STR *str; |
| |
| str = Str_new(10,0); |
| str->str_state = SS_SARY; |
| str->str_u.str_stab = stab; |
| if (str->str_ptr) { |
| Safefree(str->str_ptr); |
| str->str_ptr = Nullch; |
| str->str_len = 0; |
| } |
| str->str_ptr = (char*)stab_array(stab); |
| (void)apush(savestack,str); /* save array ptr */ |
| stab_xarray(stab) = Null(ARRAY*); |
| return stab_xarray(aadd(stab)); |
| } |
| |
| HASH * |
| savehash(stab) |
| STAB *stab; |
| { |
| register STR *str; |
| |
| str = Str_new(11,0); |
| str->str_state = SS_SHASH; |
| str->str_u.str_stab = stab; |
| if (str->str_ptr) { |
| Safefree(str->str_ptr); |
| str->str_ptr = Nullch; |
| str->str_len = 0; |
| } |
| str->str_ptr = (char*)stab_hash(stab); |
| (void)apush(savestack,str); /* save hash ptr */ |
| stab_xhash(stab) = Null(HASH*); |
| return stab_xhash(hadd(stab)); |
| } |
| |
| void |
| saveitem(item) |
| register STR *item; |
| { |
| register STR *str; |
| |
| (void)apush(savestack,item); /* remember the pointer */ |
| str = Str_new(12,0); |
| str_sset(str,item); |
| (void)apush(savestack,str); /* remember the value */ |
| } |
| |
| void |
| saveint(intp) |
| int *intp; |
| { |
| register STR *str; |
| |
| str = Str_new(13,0); |
| str->str_state = SS_SINT; |
| str->str_u.str_useful = (long)*intp; /* remember value */ |
| if (str->str_ptr) { |
| Safefree(str->str_ptr); |
| str->str_len = 0; |
| } |
| str->str_ptr = (char*)intp; /* remember pointer */ |
| (void)apush(savestack,str); |
| } |
| |
| void |
| savelong(longp) |
| long *longp; |
| { |
| register STR *str; |
| |
| str = Str_new(14,0); |
| str->str_state = SS_SLONG; |
| str->str_u.str_useful = *longp; /* remember value */ |
| if (str->str_ptr) { |
| Safefree(str->str_ptr); |
| str->str_len = 0; |
| } |
| str->str_ptr = (char*)longp; /* remember pointer */ |
| (void)apush(savestack,str); |
| } |
| |
| void |
| savesptr(sptr) |
| STR **sptr; |
| { |
| register STR *str; |
| |
| str = Str_new(15,0); |
| str->str_state = SS_SSTRP; |
| str->str_magic = *sptr; /* remember value */ |
| if (str->str_ptr) { |
| Safefree(str->str_ptr); |
| str->str_len = 0; |
| } |
| str->str_ptr = (char*)sptr; /* remember pointer */ |
| (void)apush(savestack,str); |
| } |
| |
| void |
| savenostab(stab) |
| STAB *stab; |
| { |
| register STR *str; |
| |
| str = Str_new(16,0); |
| str->str_state = SS_SNSTAB; |
| str->str_magic = (STR*)stab; /* remember which stab to free */ |
| (void)apush(savestack,str); |
| } |
| |
| void |
| savehptr(hptr) |
| HASH **hptr; |
| { |
| register STR *str; |
| |
| str = Str_new(17,0); |
| str->str_state = SS_SHPTR; |
| str->str_u.str_hash = *hptr; /* remember value */ |
| if (str->str_ptr) { |
| Safefree(str->str_ptr); |
| str->str_len = 0; |
| } |
| str->str_ptr = (char*)hptr; /* remember pointer */ |
| (void)apush(savestack,str); |
| } |
| |
| void |
| saveaptr(aptr) |
| ARRAY **aptr; |
| { |
| register STR *str; |
| |
| str = Str_new(17,0); |
| str->str_state = SS_SAPTR; |
| str->str_u.str_array = *aptr; /* remember value */ |
| if (str->str_ptr) { |
| Safefree(str->str_ptr); |
| str->str_len = 0; |
| } |
| str->str_ptr = (char*)aptr; /* remember pointer */ |
| (void)apush(savestack,str); |
| } |
| |
| void |
| savelist(sarg,maxsarg) |
| register STR **sarg; |
| int maxsarg; |
| { |
| register STR *str; |
| register int i; |
| |
| for (i = 1; i <= maxsarg; i++) { |
| (void)apush(savestack,sarg[i]); /* remember the pointer */ |
| str = Str_new(18,0); |
| str_sset(str,sarg[i]); |
| (void)apush(savestack,str); /* remember the value */ |
| sarg[i]->str_u.str_useful = -1; |
| } |
| } |
| |
| void |
| restorelist(base) |
| int base; |
| { |
| register STR *str; |
| register STR *value; |
| register STAB *stab; |
| |
| if (base < -1) |
| fatal("panic: corrupt saved stack index"); |
| while (savestack->ary_fill > base) { |
| value = apop(savestack); |
| switch (value->str_state) { |
| case SS_NORM: /* normal string */ |
| case SS_INCR: |
| str = apop(savestack); |
| str_replace(str,value); |
| STABSET(str); |
| break; |
| case SS_SARY: /* array reference */ |
| stab = value->str_u.str_stab; |
| afree(stab_xarray(stab)); |
| stab_xarray(stab) = (ARRAY*)value->str_ptr; |
| value->str_ptr = Nullch; |
| str_free(value); |
| break; |
| case SS_SHASH: /* hash reference */ |
| stab = value->str_u.str_stab; |
| (void)hfree(stab_xhash(stab), FALSE); |
| stab_xhash(stab) = (HASH*)value->str_ptr; |
| value->str_ptr = Nullch; |
| str_free(value); |
| break; |
| case SS_SINT: /* int reference */ |
| *((int*)value->str_ptr) = (int)value->str_u.str_useful; |
| value->str_ptr = Nullch; |
| str_free(value); |
| break; |
| case SS_SLONG: /* long reference */ |
| *((long*)value->str_ptr) = value->str_u.str_useful; |
| value->str_ptr = Nullch; |
| str_free(value); |
| break; |
| case SS_SSTRP: /* STR* reference */ |
| *((STR**)value->str_ptr) = value->str_magic; |
| value->str_magic = Nullstr; |
| value->str_ptr = Nullch; |
| str_free(value); |
| break; |
| case SS_SHPTR: /* HASH* reference */ |
| *((HASH**)value->str_ptr) = value->str_u.str_hash; |
| value->str_ptr = Nullch; |
| str_free(value); |
| break; |
| case SS_SAPTR: /* ARRAY* reference */ |
| *((ARRAY**)value->str_ptr) = value->str_u.str_array; |
| value->str_ptr = Nullch; |
| str_free(value); |
| break; |
| case SS_SNSTAB: |
| stab = (STAB*)value->str_magic; |
| value->str_magic = Nullstr; |
| (void)stab_clear(stab); |
| str_free(value); |
| break; |
| case SS_SCSV: /* callsave structure */ |
| { |
| CSV *csv = (CSV*) value->str_ptr; |
| |
| curcmd = csv->curcmd; |
| curcsv = csv->curcsv; |
| csv->sub->depth = csv->depth; |
| if (csv->hasargs) { /* put back old @_ */ |
| afree(csv->argarray); |
| stab_xarray(defstab) = csv->savearray; |
| } |
| str_free(value); |
| } |
| break; |
| default: |
| fatal("panic: restorelist inconsistency"); |
| } |
| } |
| } |
| |
| #ifdef DEBUGGING |
| void |
| grow_dlevel() |
| { |
| dlmax += 128; |
| Renew(debname, dlmax, char); |
| Renew(debdelim, dlmax, char); |
| } |
| #endif |
