home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD1.mdf / perl / os2perl / cmd.c < prev    next >
C/C++ Source or Header  |  1991-06-11  |  31KB  |  1,223 lines
  1. /* $RCSfile: cmd.c,v $$Revision: 4.0.1.2 $$Date: 91/06/07 10:26:45 $
  2.  *
  3.  *    Copyright (c) 1991, Larry Wall
  4.  *
  5.  *    You may distribute under the terms of either the GNU General Public
  6.  *    License or the Artistic License, as specified in the README file.
  7.  *
  8.  * $Log:    cmd.c,v $
  9.  * Revision 4.0.1.2  91/06/07  10:26:45  lwall
  10.  * patch4: new copyright notice
  11.  * patch4: made some allowances for "semi-standard" C
  12.  *
  13.  * Revision 4.0.1.1  91/04/11  17:36:16  lwall
  14.  * patch1: you may now use "die" and "caller" in a signal handler
  15.  *
  16.  * Revision 4.0  91/03/20  01:04:18  lwall
  17.  * 4.0 baseline.
  18.  *
  19.  */
  20.  
  21. #include "EXTERN.h"
  22. #include "perl.h"
  23.  
  24. #ifdef I_VARARGS
  25. #  include <varargs.h>
  26. #endif
  27.  
  28. static STR str_chop;
  29.  
  30. void grow_dlevel();
  31.  
  32. /* do longjmps() clobber register variables? */
  33.  
  34. #if defined(cray) || defined(STANDARD_C)
  35. #define JMPCLOBBER
  36. #endif
  37.  
  38. /* This is the main command loop.  We try to spend as much time in this loop
  39.  * as possible, so lots of optimizations do their activities in here.  This
  40.  * means things get a little sloppy.
  41.  */
  42.  
  43. int
  44. cmd_exec(cmdparm,gimme,sp)
  45. CMD *VOLATILE cmdparm;
  46. VOLATILE int gimme;
  47. VOLATILE int sp;
  48. {
  49.     register CMD *cmd = cmdparm;
  50.     SPAT *VOLATILE oldspat;
  51.     VOLATILE int firstsave = savestack->ary_fill;
  52.     VOLATILE int oldsave;
  53.     VOLATILE int aryoptsave;
  54. #ifdef DEBUGGING
  55.     VOLATILE int olddlevel;
  56.     VOLATILE int entdlevel;
  57. #endif
  58.     register STR *retstr = &str_undef;
  59.     register char *tmps;
  60.     register int cmdflags;
  61.     register int match;
  62.     register char *go_to = goto_targ;
  63.     register int newsp = -2;
  64.     register STR **st = stack->ary_array;
  65.     FILE *VOLATILE fp;
  66.     ARRAY *VOLATILE ar;
  67.  
  68.     lastsize = 0;
  69. #ifdef DEBUGGING
  70.     entdlevel = dlevel;
  71. #endif
  72. tail_recursion_entry:
  73. #ifdef DEBUGGING
  74.     dlevel = entdlevel;
  75. #endif
  76. #ifdef TAINT
  77.     tainted = 0;    /* Each statement is presumed innocent */
  78. #endif
  79.     if (cmd == Nullcmd) {
  80.     if (gimme == G_ARRAY && newsp > -2)
  81.         return newsp;
  82.     else {
  83.         st[++sp] = retstr;
  84.         return sp;
  85.     }
  86.     }
  87.     cmdflags = cmd->c_flags;    /* hopefully load register */
  88.     if (go_to) {
  89.     if (cmd->c_label && strEQ(go_to,cmd->c_label))
  90.         goto_targ = go_to = Nullch;        /* here at last */
  91.     else {
  92.         switch (cmd->c_type) {
  93.         case C_IF:
  94.         oldspat = curspat;
  95.         oldsave = savestack->ary_fill;
  96. #ifdef DEBUGGING
  97.         olddlevel = dlevel;
  98. #endif
  99.         retstr = &str_yes;
  100.         newsp = -2;
  101.         if (cmd->ucmd.ccmd.cc_true) {
  102. #ifdef DEBUGGING
  103.             if (debug) {
  104.             debname[dlevel] = 't';
  105.             debdelim[dlevel] = '_';
  106.             if (++dlevel >= dlmax)
  107.                 grow_dlevel();
  108.             }
  109. #endif
  110.             newsp = cmd_exec(cmd->ucmd.ccmd.cc_true,gimme && (cmdflags & CF_TERM),sp);
  111.             st = stack->ary_array;    /* possibly reallocated */
  112.             retstr = st[newsp];
  113.         }
  114.         if (!goto_targ)
  115.             go_to = Nullch;
  116.         curspat = oldspat;
  117.         if (savestack->ary_fill > oldsave)
  118.             restorelist(oldsave);
  119. #ifdef DEBUGGING
  120.         dlevel = olddlevel;
  121. #endif
  122.         cmd = cmd->ucmd.ccmd.cc_alt;
  123.         goto tail_recursion_entry;
  124.         case C_ELSE:
  125.         oldspat = curspat;
  126.         oldsave = savestack->ary_fill;
  127. #ifdef DEBUGGING
  128.         olddlevel = dlevel;
  129. #endif
  130.         retstr = &str_undef;
  131.         newsp = -2;
  132.         if (cmd->ucmd.ccmd.cc_true) {
  133. #ifdef DEBUGGING
  134.             if (debug) {
  135.             debname[dlevel] = 'e';
  136.             debdelim[dlevel] = '_';
  137.             if (++dlevel >= dlmax)
  138.                 grow_dlevel();
  139.             }
  140. #endif
  141.             newsp = cmd_exec(cmd->ucmd.ccmd.cc_true,gimme && (cmdflags & CF_TERM),sp);
  142.             st = stack->ary_array;    /* possibly reallocated */
  143.             retstr = st[newsp];
  144.         }
  145.         if (!goto_targ)
  146.             go_to = Nullch;
  147.         curspat = oldspat;
  148.         if (savestack->ary_fill > oldsave)
  149.             restorelist(oldsave);
  150. #ifdef DEBUGGING
  151.         dlevel = olddlevel;
  152. #endif
  153.         break;
  154.         case C_BLOCK:
  155.         case C_WHILE:
  156.         if (!(cmdflags & CF_ONCE)) {
  157.             cmdflags |= CF_ONCE;
  158.             if (++loop_ptr >= loop_max) {
  159.             loop_max += 128;
  160.             Renew(loop_stack, loop_max, struct loop);
  161.             }
  162.             loop_stack[loop_ptr].loop_label = cmd->c_label;
  163.             loop_stack[loop_ptr].loop_sp = sp;
  164. #ifdef DEBUGGING
  165.             if (debug & 4) {
  166.             deb("(Pushing label #%d %s)\n",
  167.               loop_ptr, cmd->c_label ? cmd->c_label : "");
  168.             }
  169. #endif
  170.         }
  171. #ifdef JMPCLOBBER
  172.         cmdparm = cmd;
  173. #endif
  174.         match = setjmp(loop_stack[loop_ptr].loop_env);
  175.         if (match) {
  176.             st = stack->ary_array;    /* possibly reallocated */
  177. #ifdef JMPCLOBBER
  178.             cmd = cmdparm;
  179.             cmdflags = cmd->c_flags|CF_ONCE;
  180. #endif
  181.             if (savestack->ary_fill > oldsave)
  182.             restorelist(oldsave);
  183.             switch (match) {
  184.             default:
  185.             fatal("longjmp returned bad value (%d)",match);
  186.             case O_LAST:    /* not done unless go_to found */
  187.             go_to = Nullch;
  188.             if (lastretstr) {
  189.                 retstr = lastretstr;
  190.                 newsp = -2;
  191.             }
  192.             else {
  193.                 newsp = sp + lastsize;
  194.                 retstr = st[newsp];
  195.             }
  196. #ifdef DEBUGGING
  197.             olddlevel = dlevel;
  198. #endif
  199.             curspat = oldspat;
  200.             goto next_cmd;
  201.             case O_NEXT:    /* not done unless go_to found */
  202.             go_to = Nullch;
  203. #ifdef JMPCLOBBER
  204.             newsp = -2;
  205.             retstr = &str_undef;
  206. #endif
  207.             goto next_iter;
  208.             case O_REDO:    /* not done unless go_to found */
  209.             go_to = Nullch;
  210. #ifdef JMPCLOBBER
  211.             newsp = -2;
  212.             retstr = &str_undef;
  213. #endif
  214.             goto doit;
  215.             }
  216.         }
  217.         oldspat = curspat;
  218.         oldsave = savestack->ary_fill;
  219. #ifdef DEBUGGING
  220.         olddlevel = dlevel;
  221. #endif
  222.         if (cmd->ucmd.ccmd.cc_true) {
  223. #ifdef DEBUGGING
  224.             if (debug) {
  225.             debname[dlevel] = 't';
  226.             debdelim[dlevel] = '_';
  227.             if (++dlevel >= dlmax)
  228.                 grow_dlevel();
  229.             }
  230. #endif
  231.             newsp = cmd_exec(cmd->ucmd.ccmd.cc_true,gimme && (cmdflags & CF_TERM),sp);
  232.             st = stack->ary_array;    /* possibly reallocated */
  233.             retstr = st[newsp];
  234.         }
  235.         if (!goto_targ) {
  236.             go_to = Nullch;
  237.             goto next_iter;
  238.         }
  239. #ifdef DEBUGGING
  240.         dlevel = olddlevel;
  241. #endif
  242.         if (cmd->ucmd.ccmd.cc_alt) {
  243. #ifdef DEBUGGING
  244.             if (debug) {
  245.             debname[dlevel] = 'a';
  246.             debdelim[dlevel] = '_';
  247.             if (++dlevel >= dlmax)
  248.                 grow_dlevel();
  249.             }
  250. #endif
  251.             newsp = cmd_exec(cmd->ucmd.ccmd.cc_alt,gimme && (cmdflags & CF_TERM),sp);
  252.             st = stack->ary_array;    /* possibly reallocated */
  253.             retstr = st[newsp];
  254.         }
  255.         if (goto_targ)
  256.             break;
  257.         go_to = Nullch;
  258.         goto finish_while;
  259.         }
  260.         cmd = cmd->c_next;
  261.         if (cmd && cmd->c_head == cmd)
  262.                     /* reached end of while loop */
  263.         return sp;        /* targ isn't in this block */
  264.         if (cmdflags & CF_ONCE) {
  265. #ifdef DEBUGGING
  266.         if (debug & 4) {
  267.             tmps = loop_stack[loop_ptr].loop_label;
  268.             deb("(Popping label #%d %s)\n",loop_ptr,
  269.             tmps ? tmps : "" );
  270.         }
  271. #endif
  272.         loop_ptr--;
  273.         }
  274.         goto tail_recursion_entry;
  275.     }
  276.     }
  277.  
  278. until_loop:
  279.  
  280.     /* Set line number so run-time errors can be located */
  281.  
  282.     curcmd = cmd;
  283.  
  284. #ifdef DEBUGGING
  285.     if (debug) {
  286.     if (debug & 2) {
  287.         deb("%s    (%lx)    r%lx    t%lx    a%lx    n%lx    cs%lx\n",
  288.         cmdname[cmd->c_type],cmd,cmd->c_expr,
  289.         cmd->ucmd.ccmd.cc_true,cmd->ucmd.ccmd.cc_alt,cmd->c_next,
  290.         curspat);
  291.     }
  292.     debname[dlevel] = cmdname[cmd->c_type][0];
  293.     debdelim[dlevel] = '!';
  294.     if (++dlevel >= dlmax)
  295.         grow_dlevel();
  296.     }
  297. #endif
  298.  
  299.     /* Here is some common optimization */
  300.  
  301.     if (cmdflags & CF_COND) {
  302.     switch (cmdflags & CF_OPTIMIZE) {
  303.  
  304.     case CFT_FALSE:
  305.         retstr = cmd->c_short;
  306.         newsp = -2;
  307.         match = FALSE;
  308.         if (cmdflags & CF_NESURE)
  309.         goto maybe;
  310.         break;
  311.     case CFT_TRUE:
  312.         retstr = cmd->c_short;
  313.         newsp = -2;
  314.         match = TRUE;
  315.         if (cmdflags & CF_EQSURE)
  316.         goto flipmaybe;
  317.         break;
  318.  
  319.     case CFT_REG:
  320.         retstr = STAB_STR(cmd->c_stab);
  321.         newsp = -2;
  322.         match = str_true(retstr);    /* => retstr = retstr, c2 should fix */
  323.         if (cmdflags & (match ? CF_EQSURE : CF_NESURE))
  324.         goto flipmaybe;
  325.         break;
  326.  
  327.     case CFT_ANCHOR:    /* /^pat/ optimization */
  328.         if (multiline) {
  329.         if (*cmd->c_short->str_ptr && !(cmdflags & CF_EQSURE))
  330.             goto scanner;    /* just unanchor it */
  331.         else
  332.             break;        /* must evaluate */
  333.         }
  334.         /* FALL THROUGH */
  335.     case CFT_STROP:        /* string op optimization */
  336.         retstr = STAB_STR(cmd->c_stab);
  337.         newsp = -2;
  338. #ifndef I286
  339.         if (*cmd->c_short->str_ptr == *str_get(retstr) &&
  340.             bcmp(cmd->c_short->str_ptr, str_get(retstr),
  341.               cmd->c_slen) == 0 ) {
  342.         if (cmdflags & CF_EQSURE) {
  343.             if (sawampersand && (cmdflags & CF_OPTIMIZE) != CFT_STROP) {
  344.             curspat = Nullspat;
  345.             if (leftstab)
  346.                 str_nset(stab_val(leftstab),"",0);
  347.             if (amperstab)
  348.                 str_sset(stab_val(amperstab),cmd->c_short);
  349.             if (rightstab)
  350.                 str_nset(stab_val(rightstab),
  351.                   retstr->str_ptr + cmd->c_slen,
  352.                   retstr->str_cur - cmd->c_slen);
  353.             }
  354.             if (cmd->c_spat)
  355.             lastspat = cmd->c_spat;
  356.             match = !(cmdflags & CF_FIRSTNEG);
  357.             retstr = &str_yes;
  358.             goto flipmaybe;
  359.         }
  360.         }
  361.         else if (cmdflags & CF_NESURE) {
  362.         match = cmdflags & CF_FIRSTNEG;
  363.         retstr = &str_no;
  364.         goto flipmaybe;
  365.         }
  366. #else
  367.         {
  368.         char *zap1, *zap2, zap1c, zap2c;
  369.         int  zaplen;
  370.  
  371.         zap1 = cmd->c_short->str_ptr;
  372.         zap2 = str_get(retstr);
  373.         zap1c = *zap1;
  374.         zap2c = *zap2;
  375.         zaplen = cmd->c_slen;
  376.         if ((zap1c == zap2c) && (bcmp(zap1, zap2, zaplen) == 0)) {
  377.             if (cmdflags & CF_EQSURE) {
  378.             if (sawampersand &&
  379.               (cmdflags & CF_OPTIMIZE) != CFT_STROP) {
  380.                 curspat = Nullspat;
  381.                 if (leftstab)
  382.                 str_nset(stab_val(leftstab),"",0);
  383.                 if (amperstab)
  384.                 str_sset(stab_val(amperstab),cmd->c_short);
  385.                 if (rightstab)
  386.                 str_nset(stab_val(rightstab),
  387.                      retstr->str_ptr + cmd->c_slen,
  388.                      retstr->str_cur - cmd->c_slen);
  389.             }
  390.             if (cmd->c_spat)
  391.                 lastspat = cmd->c_spat;
  392.              match = !(cmdflags & CF_FIRSTNEG);
  393.              retstr = &str_yes;
  394.              goto flipmaybe;
  395.             }
  396.         }
  397.         else if (cmdflags & CF_NESURE) {
  398.             match = cmdflags & CF_FIRSTNEG;
  399.             retstr = &str_no;
  400.             goto flipmaybe;
  401.         }
  402.         }
  403. #endif
  404.         break;            /* must evaluate */
  405.  
  406.     case CFT_SCAN:            /* non-anchored search */
  407.       scanner:
  408.         retstr = STAB_STR(cmd->c_stab);
  409.         newsp = -2;
  410.         if (retstr->str_pok & SP_STUDIED)
  411.         if (screamfirst[cmd->c_short->str_rare] >= 0)
  412.             tmps = screaminstr(retstr, cmd->c_short);
  413.         else
  414.             tmps = Nullch;
  415.         else {
  416.         tmps = str_get(retstr);        /* make sure it's pok */
  417. #ifndef lint
  418.         tmps = fbminstr((unsigned char*)tmps,
  419.             (unsigned char*)tmps + retstr->str_cur, cmd->c_short);
  420. #endif
  421.         }
  422.         if (tmps) {
  423.         if (cmdflags & CF_EQSURE) {
  424.             ++cmd->c_short->str_u.str_useful;
  425.             if (sawampersand) {
  426.             curspat = Nullspat;
  427.             if (leftstab)
  428.                 str_nset(stab_val(leftstab),retstr->str_ptr,
  429.                   tmps - retstr->str_ptr);
  430.             if (amperstab)
  431.                 str_nset(stab_val(amperstab),
  432.                   tmps, cmd->c_short->str_cur);
  433.             if (rightstab)
  434.                 str_nset(stab_val(rightstab),
  435.                   tmps + cmd->c_short->str_cur,
  436.                   retstr->str_cur - (tmps - retstr->str_ptr) -
  437.                 cmd->c_short->str_cur);
  438.             }
  439.             lastspat = cmd->c_spat;
  440.             match = !(cmdflags & CF_FIRSTNEG);
  441.             retstr = &str_yes;
  442.             goto flipmaybe;
  443.         }
  444.         else
  445.             hint = tmps;
  446.         }
  447.         else {
  448.         if (cmdflags & CF_NESURE) {
  449.             ++cmd->c_short->str_u.str_useful;
  450.             match = cmdflags & CF_FIRSTNEG;
  451.             retstr = &str_no;
  452.             goto flipmaybe;
  453.         }
  454.         }
  455.         if (--cmd->c_short->str_u.str_useful < 0) {
  456.         cmdflags &= ~CF_OPTIMIZE;
  457.         cmdflags |= CFT_EVAL;    /* never try this optimization again */
  458.         cmd->c_flags = (cmdflags & ~CF_ONCE);
  459.         }
  460.         break;            /* must evaluate */
  461.  
  462.     case CFT_NUMOP:        /* numeric op optimization */
  463.         retstr = STAB_STR(cmd->c_stab);
  464.         newsp = -2;
  465.         switch (cmd->c_slen) {
  466.         case O_EQ:
  467.         if (dowarn) {
  468.             if ((!retstr->str_nok && !looks_like_number(retstr)))
  469.             warn("Possible use of == on string value");
  470.         }
  471.         match = (str_gnum(retstr) == cmd->c_short->str_u.str_nval);
  472.         break;
  473.         case O_NE:
  474.         match = (str_gnum(retstr) != cmd->c_short->str_u.str_nval);
  475.         break;
  476.         case O_LT:
  477.         match = (str_gnum(retstr) <  cmd->c_short->str_u.str_nval);
  478.         break;
  479.         case O_LE:
  480.         match = (str_gnum(retstr) <= cmd->c_short->str_u.str_nval);
  481.         break;
  482.         case O_GT:
  483.         match = (str_gnum(retstr) >  cmd->c_short->str_u.str_nval);
  484.         break;
  485.         case O_GE:
  486.         match = (str_gnum(retstr) >= cmd->c_short->str_u.str_nval);
  487.         break;
  488.         }
  489.         if (match) {
  490.         if (cmdflags & CF_EQSURE) {
  491.             retstr = &str_yes;
  492.             goto flipmaybe;
  493.         }
  494.         }
  495.         else if (cmdflags & CF_NESURE) {
  496.         retstr = &str_no;
  497.         goto flipmaybe;
  498.         }
  499.         break;            /* must evaluate */
  500.  
  501.     case CFT_INDGETS:        /* while (<$foo>) */
  502.         last_in_stab = stabent(str_get(STAB_STR(cmd->c_stab)),TRUE);
  503.         if (!stab_io(last_in_stab))
  504.         stab_io(last_in_stab) = stio_new();
  505.         goto dogets;
  506.     case CFT_GETS:            /* really a while (<file>) */
  507.         last_in_stab = cmd->c_stab;
  508.       dogets:
  509.         fp = stab_io(last_in_stab)->ifp;
  510.         retstr = stab_val(defstab);
  511.         newsp = -2;
  512.       keepgoing:
  513.         if (fp && str_gets(retstr, fp, 0)) {
  514.         if (*retstr->str_ptr == '0' && retstr->str_cur == 1)
  515.             match = FALSE;
  516.         else
  517.             match = TRUE;
  518.         stab_io(last_in_stab)->lines++;
  519.         }
  520.         else if (stab_io(last_in_stab)->flags & IOF_ARGV) {
  521.         if (!fp)
  522.             goto doeval;    /* first time through */
  523.         fp = nextargv(last_in_stab);
  524.         if (fp)
  525.             goto keepgoing;
  526.         (void)do_close(last_in_stab,FALSE);
  527.         stab_io(last_in_stab)->flags |= IOF_START;
  528.         retstr = &str_undef;
  529.         match = FALSE;
  530.         }
  531.         else {
  532.         retstr = &str_undef;
  533.         match = FALSE;
  534.         }
  535.         goto flipmaybe;
  536.     case CFT_EVAL:
  537.         break;
  538.     case CFT_UNFLIP:
  539.         while (tmps_max > tmps_base) {    /* clean up after last eval */
  540.         str_free(tmps_list[tmps_max]);
  541.         tmps_list[tmps_max--] = Nullstr;
  542.         }
  543.         newsp = eval(cmd->c_expr,gimme && (cmdflags & CF_TERM),sp);
  544.         st = stack->ary_array;    /* possibly reallocated */
  545.         retstr = st[newsp];
  546.         match = str_true(retstr);
  547.         if (cmd->c_expr->arg_type == O_FLIP)    /* undid itself? */
  548.         cmdflags = copyopt(cmd,cmd->c_expr[3].arg_ptr.arg_cmd);
  549.         goto maybe;
  550.     case CFT_CHOP:
  551.         retstr = stab_val(cmd->c_stab);
  552.         newsp = -2;
  553.         match = (retstr->str_cur != 0);
  554.         tmps = str_get(retstr);
  555.         tmps += retstr->str_cur - match;
  556.         str_nset(&str_chop,tmps,match);
  557.         *tmps = '\0';
  558.         retstr->str_nok = 0;
  559.         retstr->str_cur = tmps - retstr->str_ptr;
  560.         STABSET(retstr);
  561.         retstr = &str_chop;
  562.         goto flipmaybe;
  563.     case CFT_ARRAY:
  564.         match = cmd->c_short->str_u.str_useful; /* just to get register */
  565.  
  566.         if (match < 0) {        /* first time through here? */
  567.         ar = stab_array(cmd->c_expr[1].arg_ptr.arg_stab);
  568.         aryoptsave = savestack->ary_fill;
  569.         savesptr(&stab_val(cmd->c_stab));
  570.         savelong(&cmd->c_short->str_u.str_useful);
  571.         }
  572.         else {
  573.         ar = stab_xarray(cmd->c_expr[1].arg_ptr.arg_stab);
  574.         if (cmd->c_type != C_WHILE && savestack->ary_fill > firstsave)
  575.             restorelist(firstsave);
  576.         }
  577.  
  578.         if (match >= ar->ary_fill) {    /* we're in LAST, probably */
  579.         retstr = &str_undef;
  580.         cmd->c_short->str_u.str_useful = -1;    /* actually redundant */
  581.         match = FALSE;
  582.         }
  583.         else {
  584.         match++;
  585.         if (!(retstr = ar->ary_array[match]))
  586.             retstr = afetch(ar,match,TRUE);
  587.         stab_val(cmd->c_stab) = retstr;
  588.         cmd->c_short->str_u.str_useful = match;
  589.         match = TRUE;
  590.         }
  591.         newsp = -2;
  592.         goto maybe;
  593.     case CFT_D1:
  594.         break;
  595.     case CFT_D0:
  596.         if (DBsingle->str_u.str_nval != 0)
  597.         break;
  598.         if (DBsignal->str_u.str_nval != 0)
  599.         break;
  600.         if (DBtrace->str_u.str_nval != 0)
  601.         break;
  602.         goto next_cmd;
  603.     }
  604.  
  605.     /* we have tried to make this normal case as abnormal as possible */
  606.  
  607.     doeval:
  608.     if (gimme == G_ARRAY) {
  609.         lastretstr = Nullstr;
  610.         lastspbase = sp;
  611.         lastsize = newsp - sp;
  612.         if (lastsize < 0)
  613.         lastsize = 0;
  614.     }
  615.     else
  616.         lastretstr = retstr;
  617.     while (tmps_max > tmps_base) {    /* clean up after last eval */
  618.         str_free(tmps_list[tmps_max]);
  619.         tmps_list[tmps_max--] = Nullstr;
  620.     }
  621.     newsp = eval(cmd->c_expr,
  622.       gimme && (cmdflags & CF_TERM) && cmd->c_type == C_EXPR &&
  623.         !cmd->ucmd.acmd.ac_expr,
  624.       sp);
  625.     st = stack->ary_array;    /* possibly reallocated */
  626.     retstr = st[newsp];
  627.     if (newsp > sp && retstr)
  628.         match = str_true(retstr);
  629.     else
  630.         match = FALSE;
  631.     goto maybe;
  632.  
  633.     /* if flipflop was true, flop it */
  634.  
  635.     flipmaybe:
  636.     if (match && cmdflags & CF_FLIP) {
  637.         while (tmps_max > tmps_base) {    /* clean up after last eval */
  638.         str_free(tmps_list[tmps_max]);
  639.         tmps_list[tmps_max--] = Nullstr;
  640.         }
  641.         if (cmd->c_expr->arg_type == O_FLOP) {    /* currently toggled? */
  642.         newsp = eval(cmd->c_expr,G_SCALAR,sp);/*let eval undo it*/
  643.         cmdflags = copyopt(cmd,cmd->c_expr[3].arg_ptr.arg_cmd);
  644.         }
  645.         else {
  646.         newsp = eval(cmd->c_expr,G_SCALAR,sp);/* let eval do it */
  647.         if (cmd->c_expr->arg_type == O_FLOP)    /* still toggled? */
  648.             cmdflags = copyopt(cmd,cmd->c_expr[4].arg_ptr.arg_cmd);
  649.         }
  650.     }
  651.     else if (cmdflags & CF_FLIP) {
  652.         if (cmd->c_expr->arg_type == O_FLOP) {    /* currently toggled? */
  653.         match = TRUE;                /* force on */
  654.         }
  655.     }
  656.  
  657.     /* at this point, match says whether our expression was true */
  658.  
  659.     maybe:
  660.     if (cmdflags & CF_INVERT)
  661.         match = !match;
  662.     if (!match)
  663.         goto next_cmd;
  664.     }
  665. #ifdef TAINT
  666.     tainted = 0;    /* modifier doesn't affect regular expression */
  667. #endif
  668.  
  669.     /* now to do the actual command, if any */
  670.  
  671.     switch (cmd->c_type) {
  672.     case C_NULL:
  673.     fatal("panic: cmd_exec");
  674.     case C_EXPR:            /* evaluated for side effects */
  675.     if (cmd->ucmd.acmd.ac_expr) {    /* more to do? */
  676.         if (gimme == G_ARRAY) {
  677.         lastretstr = Nullstr;
  678.         lastspbase = sp;
  679.         lastsize = newsp - sp;
  680.         if (lastsize < 0)
  681.             lastsize = 0;
  682.         }
  683.         else
  684.         lastretstr = retstr;
  685.         while (tmps_max > tmps_base) {    /* clean up after last eval */
  686.         str_free(tmps_list[tmps_max]);
  687.         tmps_list[tmps_max--] = Nullstr;
  688.         }
  689.         newsp = eval(cmd->ucmd.acmd.ac_expr,gimme && (cmdflags&CF_TERM),sp);
  690.         st = stack->ary_array;    /* possibly reallocated */
  691.         retstr = st[newsp];
  692.     }
  693.     break;
  694.     case C_NSWITCH:
  695.     {
  696.         double value = str_gnum(STAB_STR(cmd->c_stab));
  697.  
  698.         match = (int)value;
  699.         if (value < 0.0) {
  700.         if (((double)match) > value)
  701.             --match;        /* was fractional--truncate other way */
  702.         }
  703.     }
  704.     goto doswitch;
  705.     case C_CSWITCH:
  706.     match = *(str_get(STAB_STR(cmd->c_stab))) & 255;
  707.       doswitch:
  708.     match -= cmd->ucmd.scmd.sc_offset;
  709.     if (match < 0)
  710.         match = 0;
  711.     else if (match > cmd->ucmd.scmd.sc_max)
  712.         match = cmd->ucmd.scmd.sc_max;
  713.     cmd = cmd->ucmd.scmd.sc_next[match];
  714.     goto tail_recursion_entry;
  715.     case C_NEXT:
  716.     cmd = cmd->ucmd.ccmd.cc_alt;
  717.     goto tail_recursion_entry;
  718.     case C_ELSIF:
  719.     fatal("panic: ELSIF");
  720.     case C_IF:
  721.     oldspat = curspat;
  722.     oldsave = savestack->ary_fill;
  723. #ifdef DEBUGGING
  724.     olddlevel = dlevel;
  725. #endif
  726.     retstr = &str_yes;
  727.     newsp = -2;
  728.     if (cmd->ucmd.ccmd.cc_true) {
  729. #ifdef DEBUGGING
  730.         if (debug) {
  731.         debname[dlevel] = 't';
  732.         debdelim[dlevel] = '_';
  733.         if (++dlevel >= dlmax)
  734.             grow_dlevel();
  735.         }
  736. #endif
  737.         newsp = cmd_exec(cmd->ucmd.ccmd.cc_true,gimme && (cmdflags & CF_TERM),sp);
  738.         st = stack->ary_array;    /* possibly reallocated */
  739.         retstr = st[newsp];
  740.     }
  741.     curspat = oldspat;
  742.     if (savestack->ary_fill > oldsave)
  743.         restorelist(oldsave);
  744. #ifdef DEBUGGING
  745.     dlevel = olddlevel;
  746. #endif
  747.     cmd = cmd->ucmd.ccmd.cc_alt;
  748.     goto tail_recursion_entry;
  749.     case C_ELSE:
  750.     oldspat = curspat;
  751.     oldsave = savestack->ary_fill;
  752. #ifdef DEBUGGING
  753.     olddlevel = dlevel;
  754. #endif
  755.     retstr = &str_undef;
  756.     newsp = -2;
  757.     if (cmd->ucmd.ccmd.cc_true) {
  758. #ifdef DEBUGGING
  759.         if (debug) {
  760.         debname[dlevel] = 'e';
  761.         debdelim[dlevel] = '_';
  762.         if (++dlevel >= dlmax)
  763.             grow_dlevel();
  764.         }
  765. #endif
  766.         newsp = cmd_exec(cmd->ucmd.ccmd.cc_true,gimme && (cmdflags & CF_TERM),sp);
  767.         st = stack->ary_array;    /* possibly reallocated */
  768.         retstr = st[newsp];
  769.     }
  770.     curspat = oldspat;
  771.     if (savestack->ary_fill > oldsave)
  772.         restorelist(oldsave);
  773. #ifdef DEBUGGING
  774.     dlevel = olddlevel;
  775. #endif
  776.     break;
  777.     case C_BLOCK:
  778.     case C_WHILE:
  779.     if (!(cmdflags & CF_ONCE)) {    /* first time through here? */
  780.         cmdflags |= CF_ONCE;
  781.         if (++loop_ptr >= loop_max) {
  782.         loop_max += 128;
  783.         Renew(loop_stack, loop_max, struct loop);
  784.         }
  785.         loop_stack[loop_ptr].loop_label = cmd->c_label;
  786.         loop_stack[loop_ptr].loop_sp = sp;
  787. #ifdef DEBUGGING
  788.         if (debug & 4) {
  789.         deb("(Pushing label #%d %s)\n",
  790.           loop_ptr, cmd->c_label ? cmd->c_label : "");
  791.         }
  792. #endif
  793.     }
  794. #ifdef JMPCLOBBER
  795.     cmdparm = cmd;
  796. #endif
  797.     match = setjmp(loop_stack[loop_ptr].loop_env);
  798.     if (match) {
  799.         st = stack->ary_array;    /* possibly reallocated */
  800. #ifdef JMPCLOBBER
  801.         cmd = cmdparm;
  802.         cmdflags = cmd->c_flags|CF_ONCE;
  803.         go_to = goto_targ;
  804. #endif
  805.         if (savestack->ary_fill > oldsave)
  806.         restorelist(oldsave);
  807.         switch (match) {
  808.         default:
  809.         fatal("longjmp returned bad value (%d)",match);
  810.         case O_LAST:
  811.         if (lastretstr) {
  812.             retstr = lastretstr;
  813.             newsp = -2;
  814.         }
  815.         else {
  816.             newsp = sp + lastsize;
  817.             retstr = st[newsp];
  818.         }
  819.         curspat = oldspat;
  820.         goto next_cmd;
  821.         case O_NEXT:
  822. #ifdef JMPCLOBBER
  823.         newsp = -2;
  824.         retstr = &str_undef;
  825. #endif
  826.         goto next_iter;
  827.         case O_REDO:
  828. #ifdef DEBUGGING
  829.         dlevel = olddlevel;
  830. #endif
  831. #ifdef JMPCLOBBER
  832.         newsp = -2;
  833.         retstr = &str_undef;
  834. #endif
  835.         goto doit;
  836.         }
  837.     }
  838.     oldspat = curspat;
  839.     oldsave = savestack->ary_fill;
  840. #ifdef DEBUGGING
  841.     olddlevel = dlevel;
  842. #endif
  843.     doit:
  844.     if (cmd->ucmd.ccmd.cc_true) {
  845. #ifdef DEBUGGING
  846.         if (debug) {
  847.         debname[dlevel] = 't';
  848.         debdelim[dlevel] = '_';
  849.         if (++dlevel >= dlmax)
  850.             grow_dlevel();
  851.         }
  852. #endif
  853.         newsp = cmd_exec(cmd->ucmd.ccmd.cc_true,gimme && (cmdflags & CF_TERM),sp);
  854.         st = stack->ary_array;    /* possibly reallocated */
  855.         retstr = st[newsp];
  856.     }
  857.     /* actually, this spot is rarely reached anymore since the above
  858.      * cmd_exec() returns through longjmp().  Hooray for structure.
  859.      */
  860.       next_iter:
  861. #ifdef DEBUGGING
  862.     dlevel = olddlevel;
  863. #endif
  864.     if (cmd->ucmd.ccmd.cc_alt) {
  865. #ifdef DEBUGGING
  866.         if (debug) {
  867.         debname[dlevel] = 'a';
  868.         debdelim[dlevel] = '_';
  869.         if (++dlevel >= dlmax)
  870.             grow_dlevel();
  871.         }
  872. #endif
  873.         newsp = cmd_exec(cmd->ucmd.ccmd.cc_alt,gimme && (cmdflags & CF_TERM),sp);
  874.         st = stack->ary_array;    /* possibly reallocated */
  875.         retstr = st[newsp];
  876.     }
  877.       finish_while:
  878.     curspat = oldspat;
  879.     if (savestack->ary_fill > oldsave) {
  880.         if (cmdflags & CF_TERM) {
  881.         for (match = sp + 1; match <= newsp; match++)
  882.             st[match] = str_mortal(st[match]);
  883.         retstr = st[newsp];
  884.         }
  885.         restorelist(oldsave);
  886.     }
  887. #ifdef DEBUGGING
  888.     dlevel = olddlevel - 1;
  889. #endif
  890.     if (cmd->c_type != C_BLOCK)
  891.         goto until_loop;    /* go back and evaluate conditional again */
  892.     }
  893.     if (cmdflags & CF_LOOP) {
  894.     cmdflags |= CF_COND;        /* now test the condition */
  895. #ifdef DEBUGGING
  896.     dlevel = entdlevel;
  897. #endif
  898.     goto until_loop;
  899.     }
  900.   next_cmd:
  901.     if (cmdflags & CF_ONCE) {
  902. #ifdef DEBUGGING
  903.     if (debug & 4) {
  904.         tmps = loop_stack[loop_ptr].loop_label;
  905.         deb("(Popping label #%d %s)\n",loop_ptr, tmps ? tmps : "");
  906.     }
  907. #endif
  908.     loop_ptr--;
  909.     if ((cmdflags & CF_OPTIMIZE) == CFT_ARRAY &&
  910.       savestack->ary_fill > aryoptsave)
  911.         restorelist(aryoptsave);
  912.     }
  913.     cmd = cmd->c_next;
  914.     goto tail_recursion_entry;
  915. }
  916.  
  917. #ifdef DEBUGGING
  918. #  ifndef I_VARARGS
  919. /*VARARGS1*/
  920. deb(pat,a1,a2,a3,a4,a5,a6,a7,a8)
  921. char *pat;
  922. {
  923.     register int i;
  924.  
  925.     fprintf(stderr,"%-4ld",(long)curcmd->c_line);
  926.     for (i=0; i<dlevel; i++)
  927.     fprintf(stderr,"%c%c ",debname[i],debdelim[i]);
  928.     fprintf(stderr,pat,a1,a2,a3,a4,a5,a6,a7,a8);
  929. }
  930. #  else
  931. /*VARARGS1*/
  932. deb(va_alist)
  933. va_dcl
  934. {
  935.     va_list args;
  936.     char *pat;
  937.     register int i;
  938.  
  939.     va_start(args);
  940.     fprintf(stderr,"%-4ld",(long)curcmd->c_line);
  941.     for (i=0; i<dlevel; i++)
  942.     fprintf(stderr,"%c%c ",debname[i],debdelim[i]);
  943.  
  944.     pat = va_arg(args, char *);
  945.     (void) vfprintf(stderr,pat,args);
  946.     va_end( args );
  947. }
  948. #  endif
  949. #endif
  950.  
  951. copyopt(cmd,which)
  952. register CMD *cmd;
  953. register CMD *which;
  954. {
  955.     cmd->c_flags &= CF_ONCE|CF_COND|CF_LOOP;
  956.     cmd->c_flags |= which->c_flags;
  957.     cmd->c_short = which->c_short;
  958.     cmd->c_slen = which->c_slen;
  959.     cmd->c_stab = which->c_stab;
  960.     return cmd->c_flags;
  961. }
  962.  
  963. ARRAY *
  964. saveary(stab)
  965. STAB *stab;
  966. {
  967.     register STR *str;
  968.  
  969.     str = Str_new(10,0);
  970.     str->str_state = SS_SARY;
  971.     str->str_u.str_stab = stab;
  972.     if (str->str_ptr) {
  973.     Safefree(str->str_ptr);
  974.     str->str_ptr = Nullch;
  975.     str->str_len = 0;
  976.     }
  977.     str->str_ptr = (char*)stab_array(stab);
  978.     (void)apush(savestack,str); /* save array ptr */
  979.     stab_xarray(stab) = Null(ARRAY*);
  980.     return stab_xarray(aadd(stab));
  981. }
  982.  
  983. HASH *
  984. savehash(stab)
  985. STAB *stab;
  986. {
  987.     register STR *str;
  988.  
  989.     str = Str_new(11,0);
  990.     str->str_state = SS_SHASH;
  991.     str->str_u.str_stab = stab;
  992.     if (str->str_ptr) {
  993.     Safefree(str->str_ptr);
  994.     str->str_ptr = Nullch;
  995.     str->str_len = 0;
  996.     }
  997.     str->str_ptr = (char*)stab_hash(stab);
  998.     (void)apush(savestack,str); /* save hash ptr */
  999.     stab_xhash(stab) = Null(HASH*);
  1000.     return stab_xhash(hadd(stab));
  1001. }
  1002.  
  1003. void
  1004. saveitem(item)
  1005. register STR *item;
  1006. {
  1007.     register STR *str;
  1008.  
  1009.     (void)apush(savestack,item);        /* remember the pointer */
  1010.     str = Str_new(12,0);
  1011.     str_sset(str,item);
  1012.     (void)apush(savestack,str);            /* remember the value */
  1013. }
  1014.  
  1015. void
  1016. saveint(intp)
  1017. int *intp;
  1018. {
  1019.     register STR *str;
  1020.  
  1021.     str = Str_new(13,0);
  1022.     str->str_state = SS_SINT;
  1023.     str->str_u.str_useful = (long)*intp;    /* remember value */
  1024.     if (str->str_ptr) {
  1025.     Safefree(str->str_ptr);
  1026.     str->str_len = 0;
  1027.     }
  1028.     str->str_ptr = (char*)intp;        /* remember pointer */
  1029.     (void)apush(savestack,str);
  1030. }
  1031.  
  1032. void
  1033. savelong(longp)
  1034. long *longp;
  1035. {
  1036.     register STR *str;
  1037.  
  1038.     str = Str_new(14,0);
  1039.     str->str_state = SS_SLONG;
  1040.     str->str_u.str_useful = *longp;        /* remember value */
  1041.     if (str->str_ptr) {
  1042.     Safefree(str->str_ptr);
  1043.     str->str_len = 0;
  1044.     }
  1045.     str->str_ptr = (char*)longp;        /* remember pointer */
  1046.     (void)apush(savestack,str);
  1047. }
  1048.  
  1049. void
  1050. savesptr(sptr)
  1051. STR **sptr;
  1052. {
  1053.     register STR *str;
  1054.  
  1055.     str = Str_new(15,0);
  1056.     str->str_state = SS_SSTRP;
  1057.     str->str_magic = *sptr;        /* remember value */
  1058.     if (str->str_ptr) {
  1059.     Safefree(str->str_ptr);
  1060.     str->str_len = 0;
  1061.     }
  1062.     str->str_ptr = (char*)sptr;        /* remember pointer */
  1063.     (void)apush(savestack,str);
  1064. }
  1065.  
  1066. void
  1067. savenostab(stab)
  1068. STAB *stab;
  1069. {
  1070.     register STR *str;
  1071.  
  1072.     str = Str_new(16,0);
  1073.     str->str_state = SS_SNSTAB;
  1074.     str->str_magic = (STR*)stab;    /* remember which stab to free */
  1075.     (void)apush(savestack,str);
  1076. }
  1077.  
  1078. void
  1079. savehptr(hptr)
  1080. HASH **hptr;
  1081. {
  1082.     register STR *str;
  1083.  
  1084.     str = Str_new(17,0);
  1085.     str->str_state = SS_SHPTR;
  1086.     str->str_u.str_hash = *hptr;    /* remember value */
  1087.     if (str->str_ptr) {
  1088.     Safefree(str->str_ptr);
  1089.     str->str_len = 0;
  1090.     }
  1091.     str->str_ptr = (char*)hptr;        /* remember pointer */
  1092.     (void)apush(savestack,str);
  1093. }
  1094.  
  1095. void
  1096. saveaptr(aptr)
  1097. ARRAY **aptr;
  1098. {
  1099.     register STR *str;
  1100.  
  1101.     str = Str_new(17,0);
  1102.     str->str_state = SS_SAPTR;
  1103.     str->str_u.str_array = *aptr;    /* remember value */
  1104.     if (str->str_ptr) {
  1105.     Safefree(str->str_ptr);
  1106.     str->str_len = 0;
  1107.     }
  1108.     str->str_ptr = (char*)aptr;        /* remember pointer */
  1109.     (void)apush(savestack,str);
  1110. }
  1111.  
  1112. void
  1113. savelist(sarg,maxsarg)
  1114. register STR **sarg;
  1115. int maxsarg;
  1116. {
  1117.     register STR *str;
  1118.     register int i;
  1119.  
  1120.     for (i = 1; i <= maxsarg; i++) {
  1121.     (void)apush(savestack,sarg[i]);        /* remember the pointer */
  1122.     str = Str_new(18,0);
  1123.     str_sset(str,sarg[i]);
  1124.     (void)apush(savestack,str);            /* remember the value */
  1125.     sarg[i]->str_u.str_useful = -1;
  1126.     }
  1127. }
  1128.  
  1129. void
  1130. restorelist(base)
  1131. int base;
  1132. {
  1133.     register STR *str;
  1134.     register STR *value;
  1135.     register STAB *stab;
  1136.  
  1137.     if (base < -1)
  1138.     fatal("panic: corrupt saved stack index");
  1139.     while (savestack->ary_fill > base) {
  1140.     value = apop(savestack);
  1141.     switch (value->str_state) {
  1142.     case SS_NORM:                /* normal string */
  1143.     case SS_INCR:
  1144.         str = apop(savestack);
  1145.         str_replace(str,value);
  1146.         STABSET(str);
  1147.         break;
  1148.     case SS_SARY:                /* array reference */
  1149.         stab = value->str_u.str_stab;
  1150.         afree(stab_xarray(stab));
  1151.         stab_xarray(stab) = (ARRAY*)value->str_ptr;
  1152.         value->str_ptr = Nullch;
  1153.         str_free(value);
  1154.         break;
  1155.     case SS_SHASH:                /* hash reference */
  1156.         stab = value->str_u.str_stab;
  1157.         (void)hfree(stab_xhash(stab), FALSE);
  1158.         stab_xhash(stab) = (HASH*)value->str_ptr;
  1159.         value->str_ptr = Nullch;
  1160.         str_free(value);
  1161.         break;
  1162.     case SS_SINT:                /* int reference */
  1163.         *((int*)value->str_ptr) = (int)value->str_u.str_useful;
  1164.         value->str_ptr = Nullch;
  1165.         str_free(value);
  1166.         break;
  1167.     case SS_SLONG:                /* long reference */
  1168.         *((long*)value->str_ptr) = value->str_u.str_useful;
  1169.         value->str_ptr = Nullch;
  1170.         str_free(value);
  1171.         break;
  1172.     case SS_SSTRP:                /* STR* reference */
  1173.         *((STR**)value->str_ptr) = value->str_magic;
  1174.         value->str_magic = Nullstr;
  1175.         value->str_ptr = Nullch;
  1176.         str_free(value);
  1177.         break;
  1178.     case SS_SHPTR:                /* HASH* reference */
  1179.         *((HASH**)value->str_ptr) = value->str_u.str_hash;
  1180.         value->str_ptr = Nullch;
  1181.         str_free(value);
  1182.         break;
  1183.     case SS_SAPTR:                /* ARRAY* reference */
  1184.         *((ARRAY**)value->str_ptr) = value->str_u.str_array;
  1185.         value->str_ptr = Nullch;
  1186.         str_free(value);
  1187.         break;
  1188.     case SS_SNSTAB:
  1189.         stab = (STAB*)value->str_magic;
  1190.         value->str_magic = Nullstr;
  1191.         (void)stab_clear(stab);
  1192.         str_free(value);
  1193.         break;
  1194.     case SS_SCSV:                /* callsave structure */
  1195.         {
  1196.         CSV *csv = (CSV*) value->str_ptr;
  1197.  
  1198.         curcmd = csv->curcmd;
  1199.         curcsv = csv->curcsv;
  1200.         csv->sub->depth = csv->depth;
  1201.         if (csv->hasargs) {        /* put back old @_ */
  1202.             afree(csv->argarray);
  1203.             stab_xarray(defstab) = csv->savearray;
  1204.         }
  1205.         str_free(value);
  1206.         }
  1207.         break;
  1208.     default:
  1209.         fatal("panic: restorelist inconsistency");
  1210.     }
  1211.     }
  1212. }
  1213.  
  1214. #ifdef DEBUGGING
  1215. void
  1216. grow_dlevel()
  1217. {
  1218.     dlmax += 128;
  1219.     Renew(debname, dlmax, char);
  1220.     Renew(debdelim, dlmax, char);
  1221. }
  1222. #endif
  1223.