/*

 * interpret.h ---  run a list of instructions.

 */

/* 

 * Copyright (C) 1986, 1988, 1989, 1991-2018 the Free Software Foundation, Inc.

 * 

 * This file is part of GAWK, the GNU implementation of the

 * AWK Programming Language.

 *

 * GAWK is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 3 of the License, or

 * (at your option) any later version.

 *

 * GAWK is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA

 */

/*

 * If "r" is a field, valref should normally be > 1, because the field is

 * created initially with valref 1, and valref should be bumped when it is

 * pushed onto the stack by Op_field_spec. On the other hand, if we are

 * assigning to $n, then Op_store_field calls unref(*lhs) before assigning

 * the new value, so that decrements valref. So if the RHS is a field with

 * valref 1, that effectively means that this is an assignment like "$n = $n",

 * so a no-op, other than triggering $0 reconstitution.

 */

#define UNFIELD(l, r) \

{ \

	/* if was a field, turn it into a var */ \

	if ((r->flags & MALLOC) != 0 || r->valref == 1) { \

		l = r; \

	} else { \

		l = dupnode(r); \

		DEREF(r); \

	} \

}

int

r_interpret(INSTRUCTION *code)

{

	INSTRUCTION *pc;   /* current instruction */

	OPCODE op;	/* current opcode */

	NODE *r = NULL;

	NODE *m;

	INSTRUCTION *ni;

	NODE *t1, *t2;

	NODE **lhs;

	AWKNUM x, x2;

	int di;

	Regexp *rp;

	NODE *set_array = NULL;	/* array with a post-assignment routine */

	NODE *set_idx = NULL;	/* the index of the array element */

/* array subscript */

#define mk_sub(n)  	(n == 1 ? POP_SCALAR() : concat_exp(n, true))

#ifdef EXEC_HOOK

#define JUMPTO(x)	do { if (post_execute) post_execute(pc); pc = (x); goto top; } while (false)

#else

#define JUMPTO(x)	do { pc = (x); goto top; } while (false)

#endif

	pc = code;

	/* N.B.: always use JUMPTO for next instruction, otherwise bad things

	 * may happen. DO NOT add a real loop (for/while) below to

	 * replace ' forever {'; this catches failure to use JUMPTO to execute

	 * next instruction (e.g. continue statement).

	 */

	/* loop until hit Op_stop instruction */

	/* forever {  */

top:

		if (pc->source_line > 0)

			sourceline = pc->source_line;

#ifdef EXEC_HOOK

		for (di = 0; di < num_exec_hook; di++) {

			if (! pre_execute[di](& pc))

				goto top;

		}

#endif

		switch ((op = pc->opcode)) {

		case Op_rule:

			currule = pc->in_rule;   /* for sole use in Op_K_next, Op_K_nextfile, Op_K_getline */

			/* fall through */

		case Op_func:

			source = pc->source_file;

			break;

		case Op_atexit:

		{

			bool stdio_problem = false;

			/* avoid false source indications */

			source = NULL;

			sourceline = 0;

			(void) nextfile(& curfile, true);	/* close input data file */

			/*

			 * This used to be:

			 *

			 * if (close_io() != 0 && ! exiting && exit_val == 0)

			 *      exit_val = 1;

			 *

			 * Other awks don't care about problems closing open files

			 * and pipes, in that it doesn't affect their exit status.

			 * So we no longer do either.

			 */

			(void) close_io(& stdio_problem);

			/*

			 * However, we do want to exit non-zero if there was a problem

			 * with stdout/stderr, so we reinstate a slightly different

			 * version of the above:

			 */

			if (stdio_problem && ! exiting && exit_val == 0)

				exit_val = 1;

			close_extensions();

		}

			break;

		case Op_stop:

			return 0;

		case Op_push_i:

			m = pc->memory;

			if (! do_traditional && (m->flags & INTLSTR) != 0) {

				char *orig, *trans, save;

				save = m->stptr[m->stlen];

				m->stptr[m->stlen] = '\0';

				orig = m->stptr;

				trans = dgettext(TEXTDOMAIN, orig);

				m->stptr[m->stlen] = save;

				m = make_string(trans, strlen(trans));

			} else

				UPREF(m);

			PUSH(m);

			break;

		case Op_push:

		case Op_push_arg:

		case Op_push_arg_untyped:

		{

			NODE *save_symbol;

			bool isparam = false;

			save_symbol = m = pc->memory;

			if (m->type == Node_param_list) {

				isparam = true;

				save_symbol = m = GET_PARAM(m->param_cnt);

				if (m->type == Node_array_ref) {

					if (m->orig_array->type == Node_var) {

						/* gawk 'func f(x) { a = 10; print x; } BEGIN{ f(a) }' */

						goto uninitialized_scalar;

					}

					m = m->orig_array;

				}

			}

			switch (m->type) {

			case Node_var:

				if (do_lint && var_uninitialized(m))

					lintwarn(isparam ?

						_("reference to uninitialized argument `%s'") :

						_("reference to uninitialized variable `%s'"),

								save_symbol->vname);

				m = m->var_value;

				UPREF(m);

				PUSH(m);

				break;

			case Node_var_new:

uninitialized_scalar:

				if (op != Op_push_arg_untyped) {

					/* convert untyped to scalar */

					m->type = Node_var;

					m->var_value = dupnode(Nnull_string);

				}

				if (do_lint)

					lintwarn(isparam ?

						_("reference to uninitialized argument `%s'") :

						_("reference to uninitialized variable `%s'"),

								save_symbol->vname);

				if (op != Op_push_arg_untyped)

					m = dupnode(Nnull_string);

				PUSH(m);

				break;

			case Node_var_array:

				if (op == Op_push_arg || op == Op_push_arg_untyped)

					PUSH(m);

				else

					fatal(_("attempt to use array `%s' in a scalar context"),

							array_vname(save_symbol));

				break;

			default:

				cant_happen();

			}

		}

			break;

		case Op_push_param:		/* function argument */

			m = pc->memory;

			if (m->type == Node_param_list)

				m = GET_PARAM(m->param_cnt);

			if (m->type == Node_var) {

				m = m->var_value;

				UPREF(m);

				PUSH(m);

		 		break;

			}

 			/* else

				fall through */

		case Op_push_array:

			PUSH(pc->memory);

			break;

		case Op_push_lhs:

			lhs = get_lhs(pc->memory, pc->do_reference);

			PUSH_ADDRESS(lhs);

			break;

		case Op_subscript:

			t2 = mk_sub(pc->sub_count);

			t1 = POP_ARRAY();

			if (do_lint && in_array(t1, t2) == NULL) {

				t2 = force_string(t2);

				lintwarn(_("reference to uninitialized element `%s[\"%.*s\"]'"),

					array_vname(t1), (int) t2->stlen, t2->stptr);

				if (t2->stlen == 0)

					lintwarn(_("subscript of array `%s' is null string"), array_vname(t1));

			}

			/* for FUNCTAB, get the name as the element value */

			if (t1 == func_table) {

				static bool warned = false;

				if (do_lint && ! warned) {

					warned = true;

					lintwarn(_("FUNCTAB is a gawk extension"));

				}

				r = t2;

			} else {

				/* make sure stuff like NF, NR, are up to date */

				if (t1 == symbol_table)

					update_global_values();

				r = *assoc_lookup(t1, t2);

			}

			DEREF(t2);

			/* for SYMTAB, step through to the actual variable */

			if (t1 == symbol_table) {

				static bool warned = false;

				if (do_lint && ! warned) {

					warned = true;

					lintwarn(_("SYMTAB is a gawk extension"));

				}

				if (r->type == Node_var)

					r = r->var_value;

			}

			if (r->type == Node_val)

				UPREF(r);

			PUSH(r);

			break;

		case Op_sub_array:

			t2 = mk_sub(pc->sub_count);

			t1 = POP_ARRAY();

			r = in_array(t1, t2);

			if (r == NULL) {

				r = make_array();

				r->parent_array = t1;

				lhs = assoc_lookup(t1, t2);

				unref(*lhs);

				*lhs = r;

				t2 = force_string(t2);

				r->vname = estrdup(t2->stptr, t2->stlen);	/* the subscript in parent array */

				/* execute post-assignment routine if any */

				if (t1->astore != NULL)

					(*t1->astore)(t1, t2);

			} else if (r->type != Node_var_array) {

				t2 = force_string(t2);

				fatal(_("attempt to use scalar `%s[\"%.*s\"]' as an array"),

						array_vname(t1), (int) t2->stlen, t2->stptr);

			}

			DEREF(t2);

			PUSH(r);

			break;

		case Op_subscript_lhs:

			t2 = mk_sub(pc->sub_count);

			t1 = POP_ARRAY();

			if (do_lint && in_array(t1, t2) == NULL) {

				t2 = force_string(t2);

				if (pc->do_reference)

					lintwarn(_("reference to uninitialized element `%s[\"%.*s\"]'"),

						array_vname(t1), (int) t2->stlen, t2->stptr);

				if (t2->stlen == 0)

					lintwarn(_("subscript of array `%s' is null string"), array_vname(t1));

			}

			lhs = assoc_lookup(t1, t2);

			if ((*lhs)->type == Node_var_array) {

				t2 = force_string(t2);

				fatal(_("attempt to use array `%s[\"%.*s\"]' in a scalar context"),

						array_vname(t1), (int) t2->stlen, t2->stptr);

			}

			/*

			 * Changing something in FUNCTAB is not allowed.

			 *

			 * SYMTAB is a little more messy.  Three kinds of values may

			 * be stored in SYMTAB:

			 * 	1. Variables that don"t yet have a value (Node_var_new)

			 * 	2. Variables that have a value (Node_var)

			 * 	3. Values that awk code stuck into SYMTAB not related to variables (Node_value)

			 * For 1, since we are giving it a value, we have to change the type to Node_var.

			 * For 1 and 2, we have to step through the Node_var to get to the value.

			 * For 3, we just us the value we got from assoc_lookup(), above.

			 */

			if (t1 == func_table)

				fatal(_("cannot assign to elements of FUNCTAB"));

			else if (   t1 == symbol_table

				 && (   (*lhs)->type == Node_var

				     || (*lhs)->type == Node_var_new)) {

				update_global_values();		/* make sure stuff like NF, NR, are up to date */

				(*lhs)->type = Node_var;	/* in case was Node_var_new */

				lhs = & ((*lhs)->var_value);	/* extra level of indirection */

			}

			assert(set_idx == NULL);

			if (t1->astore) {

				/* array has post-assignment routine */

				set_array = t1;

				set_idx = t2;

			} else

				DEREF(t2);

			PUSH_ADDRESS(lhs);

			break;

		case Op_field_spec:

			t1 = TOP_SCALAR();

			lhs = r_get_field(t1, (Func_ptr *) 0, true);

			decr_sp();

			DEREF(t1);

			r = *lhs;

			UPREF(r);

			PUSH(r);

			break;

		case Op_field_spec_lhs:

			t1 = TOP_SCALAR();

			lhs = r_get_field(t1, &pc->target_assign->field_assign, pc->do_reference);

			decr_sp();

			DEREF(t1);

			PUSH_ADDRESS(lhs);

			break;

		case Op_lint:

			if (do_lint) {

				switch (pc->lint_type) {

				case LINT_assign_in_cond:

					lintwarn(_("assignment used in conditional context"));

					break;

				case LINT_no_effect:

					lintwarn(_("statement has no effect"));

					break;

				default:

					cant_happen();

				}

			}

			break;

		case Op_K_break:

		case Op_K_continue:

		case Op_jmp:

			assert(pc->target_jmp != NULL);

			JUMPTO(pc->target_jmp);

		case Op_jmp_false:

			r = POP_SCALAR();

			di = eval_condition(r);

			DEREF(r);

			if (! di)

				JUMPTO(pc->target_jmp);

			break;

		case Op_jmp_true:

			r = POP_SCALAR();

			di = eval_condition(r);

			DEREF(r);

			if (di)

				JUMPTO(pc->target_jmp);

			break;

		case Op_and:

		case Op_or:

			t1 = POP_SCALAR();

			di = eval_condition(t1);

			DEREF(t1);

			if ((op == Op_and && di) || (op == Op_or && ! di))

				break;

			r = node_Boolean[di];

			UPREF(r);

			PUSH(r);

			ni = pc->target_jmp;

			JUMPTO(ni->nexti);

		case Op_and_final:

		case Op_or_final:

			t1 = TOP_SCALAR();

			r = node_Boolean[eval_condition(t1)];

			DEREF(t1);

			UPREF(r);

			REPLACE(r);

			break;

		case Op_not:

			t1 = TOP_SCALAR();

			r = node_Boolean[! eval_condition(t1)];

			DEREF(t1);

			UPREF(r);

			REPLACE(r);

			break;

		case Op_equal:

			r = node_Boolean[cmp_scalars(SCALAR_EQ_NEQ) == 0];

			UPREF(r);

			REPLACE(r);

			break;

		case Op_notequal:

			r = node_Boolean[cmp_scalars(SCALAR_EQ_NEQ) != 0];

			UPREF(r);

			REPLACE(r);

			break;

		case Op_less:

			r = node_Boolean[cmp_scalars(SCALAR_RELATIONAL) < 0];

			UPREF(r);

			REPLACE(r);

			break;

		case Op_greater:

			r = node_Boolean[cmp_scalars(SCALAR_RELATIONAL) > 0];

			UPREF(r);

			REPLACE(r);

			break;

		case Op_leq:

			r = node_Boolean[cmp_scalars(SCALAR_RELATIONAL) <= 0];

			UPREF(r);

			REPLACE(r);

			break;

		case Op_geq:

			r = node_Boolean[cmp_scalars(SCALAR_RELATIONAL) >= 0];

			UPREF(r);

			REPLACE(r);

			break;

		case Op_plus_i:

			x2 = force_number(pc->memory)->numbr;

			goto plus;

		case Op_plus:

			t2 = POP_NUMBER();

			x2 = t2->numbr;

			DEREF(t2);

plus:

			t1 = TOP_NUMBER();

			r = make_number(t1->numbr + x2);

			DEREF(t1);

			REPLACE(r);

			break;

		case Op_minus_i:

			x2 = force_number(pc->memory)->numbr;

			goto minus;

		case Op_minus:

			t2 = POP_NUMBER();

			x2 = t2->numbr;

			DEREF(t2);

minus:

			t1 = TOP_NUMBER();

			r = make_number(t1->numbr - x2);

			DEREF(t1);

			REPLACE(r);

			break;

		case Op_times_i:

			x2 = force_number(pc->memory)->numbr;

			goto times;

		case Op_times:

			t2 = POP_NUMBER();

			x2 = t2->numbr;

			DEREF(t2);

times:

			t1 = TOP_NUMBER();

			r = make_number(t1->numbr * x2);

			DEREF(t1);

			REPLACE(r);

			break;

		case Op_exp_i:

			x2 = force_number(pc->memory)->numbr;

			goto exp;

		case Op_exp:

			t2 = POP_NUMBER();

			x2 = t2->numbr;

			DEREF(t2);

exp:

			t1 = TOP_NUMBER();

			r = make_number(calc_exp(t1->numbr, x2));

			DEREF(t1);

			REPLACE(r);

			break;

		case Op_quotient_i:

			x2 = force_number(pc->memory)->numbr;

			goto quotient;

		case Op_quotient:

			t2 = POP_NUMBER();

			x2 = t2->numbr;

			DEREF(t2);

quotient:

			t1 = TOP_NUMBER();

			if (x2 == 0)

				fatal(_("division by zero attempted"));

			r = make_number(t1->numbr / x2);

			DEREF(t1);

			REPLACE(r);

			break;

		case Op_mod_i:

			x2 = force_number(pc->memory)->numbr;

			goto mod;

		case Op_mod:

			t2 = POP_NUMBER();

			x2 = t2->numbr;

			DEREF(t2);

mod:

			t1 = TOP_NUMBER();

			if (x2 == 0)

				fatal(_("division by zero attempted in `%%'"));

#ifdef HAVE_FMOD

			x = fmod(t1->numbr, x2);

#else	/* ! HAVE_FMOD */

			(void) modf(t1->numbr / x2, &x);

			x = t1->numbr - x * x2;

#endif	/* ! HAVE_FMOD */

			r = make_number(x);

			DEREF(t1);

			REPLACE(r);

			break;

		case Op_preincrement:

		case Op_predecrement:

			x = op == Op_preincrement ? 1.0 : -1.0;

			lhs = TOP_ADDRESS();

			t1 = *lhs;

			force_number(t1);

			if (t1->valref == 1 && t1->flags == (MALLOC|NUMCUR|NUMBER)) {

				/* optimization */

				t1->numbr += x;

				r = t1;

			} else {

				r = *lhs = make_number(t1->numbr + x);

				unref(t1);

			}

			UPREF(r);

			REPLACE(r);

			break;

		case Op_postincrement:

		case Op_postdecrement:

			x = op == Op_postincrement ? 1.0 : -1.0;

			lhs = TOP_ADDRESS();

			t1 = *lhs;

			force_number(t1);

			r = make_number(t1->numbr);

			if (t1->valref == 1 && t1->flags == (MALLOC|NUMCUR|NUMBER)) {

 				/* optimization */

				t1->numbr += x;

			} else {

				*lhs = make_number(t1->numbr + x);

				unref(t1);

			}

			REPLACE(r);

			break;

		case Op_unary_minus:

			t1 = TOP_NUMBER();

			r = make_number(-t1->numbr);

			DEREF(t1);

			REPLACE(r);

			break;

		case Op_unary_plus:

			// Force argument to be numeric

			t1 = TOP_NUMBER();

			r = make_number(t1->numbr);

			DEREF(t1);

			REPLACE(r);

			break;

		case Op_store_sub:

			/*

			 * array[sub] assignment optimization,

			 * see awkgram.y (optimize_assignment)

			 */

			t1 = force_array(pc->memory, true);	/* array */

			t2 = mk_sub(pc->expr_count);	/* subscript */

 			lhs = assoc_lookup(t1, t2);

			if ((*lhs)->type == Node_var_array) {

				t2 = force_string(t2);

				fatal(_("attempt to use array `%s[\"%.*s\"]' in a scalar context"),

						array_vname(t1), (int) t2->stlen, t2->stptr);

			}

			DEREF(t2);

			/*

			 * Changing something in FUNCTAB is not allowed.

			 *

			 * SYMTAB is a little more messy.  Three kinds of values may

			 * be stored in SYMTAB:

			 * 	1. Variables that don"t yet have a value (Node_var_new)

			 * 	2. Variables that have a value (Node_var)

			 * 	3. Values that awk code stuck into SYMTAB not related to variables (Node_value)

			 * For 1, since we are giving it a value, we have to change the type to Node_var.

			 * For 1 and 2, we have to step through the Node_var to get to the value.

			 * For 3, we just us the value we got from assoc_lookup(), above.

			 */

			if (t1 == func_table)

				fatal(_("cannot assign to elements of FUNCTAB"));

			else if (   t1 == symbol_table

				 && (   (*lhs)->type == Node_var

				     || (*lhs)->type == Node_var_new)) {

				(*lhs)->type = Node_var;	/* in case was Node_var_new */

				lhs = & ((*lhs)->var_value);	/* extra level of indirection */

			}

			unref(*lhs);

			r = POP_SCALAR();

			UNFIELD(*lhs, r);

			/* execute post-assignment routine if any */

			if (t1->astore != NULL)

				(*t1->astore)(t1, t2);

			DEREF(t2);

			break;

		case Op_store_var:

			/*

			 * simple variable assignment optimization,

			 * see awkgram.y (optimize_assignment)

			 */

			lhs = get_lhs(pc->memory, false);

			unref(*lhs);

			r = pc->initval;	/* constant initializer */

			if (r != NULL) {

				UPREF(r);

				*lhs = r;

			} else {

				r = POP_SCALAR();

				UNFIELD(*lhs, r);

			}

			break;

		case Op_store_field:

		{

			/* field assignment optimization,

			 * see awkgram.y (optimize_assignment)

			 */

			Func_ptr assign;

			t1 = TOP_SCALAR();

			lhs = r_get_field(t1, & assign, false);

			decr_sp();

			DEREF(t1);

			/*

			 * N.B. We must call assign() before unref, since

			 * we may need to copy $n values before freeing the

			 * $0 buffer.

			 */

			assert(assign != NULL);

			assign();

			unref(*lhs);

			r = POP_SCALAR();

			UNFIELD(*lhs, r);

		}

			break;

		case Op_assign_concat:

			/* x = x ... string concatenation optimization */

			lhs = get_lhs(pc->memory, false);

			t1 = force_string(*lhs);

			t2 = POP_STRING();

			if (t1 != *lhs) {

				unref(*lhs);

				*lhs = dupnode(t1);

			}

			if (t1 != t2 && t1->valref == 1 && (t1->flags & (MALLOC|MPFN|MPZN)) == MALLOC) {

				size_t nlen = t1->stlen + t2->stlen;

				erealloc(t1->stptr, char *, nlen + 1, "r_interpret");

				memcpy(t1->stptr + t1->stlen, t2->stptr, t2->stlen);

				t1->stlen = nlen;

				t1->stptr[nlen] = '\0';

				/* clear flags except WSTRCUR (used below) */

				t1->flags &= WSTRCUR;

				/* configure as a string as in make_str_node */

				t1->flags |= (MALLOC|STRING|STRCUR);

				t1->stfmt = STFMT_UNUSED;

#ifdef HAVE_MPFR

				t1->strndmode = MPFR_round_mode;

#endif

				if ((t1->flags & WSTRCUR) != 0 && (t2->flags & WSTRCUR) != 0) {

					size_t wlen = t1->wstlen + t2->wstlen;

					erealloc(t1->wstptr, wchar_t *,

							sizeof(wchar_t) * (wlen + 1), "r_interpret");

					memcpy(t1->wstptr + t1->wstlen, t2->wstptr, t2->wstlen * sizeof(wchar_t));

					t1->wstlen = wlen;

					t1->wstptr[wlen] = L'\0';

				} else

					free_wstr(*lhs);

			} else {

				size_t nlen = t1->stlen + t2->stlen;

				char *p;

				emalloc(p, char *, nlen + 1, "r_interpret");

				memcpy(p, t1->stptr, t1->stlen);

				memcpy(p + t1->stlen, t2->stptr, t2->stlen);

				/* N.B. No NUL-termination required, since make_str_node will do it. */

				unref(*lhs);

				t1 = *lhs = make_str_node(p, nlen, ALREADY_MALLOCED);

			}

			DEREF(t2);

			break;

		case Op_assign:

			lhs = POP_ADDRESS();

			r = TOP_SCALAR();

			unref(*lhs);

			UPREF(r);

			UNFIELD(*lhs, r);

			REPLACE(r);

			break;

		case Op_subscript_assign:

			/* conditionally execute post-assignment routine for an array element */

			if (set_idx != NULL) {

				di = true;

				if (pc->assign_ctxt == Op_sub_builtin

					&& (r = TOP())

					&& get_number_si(r) == 0	/* no substitution performed */

				)

					di = false;

				else if ((pc->assign_ctxt == Op_K_getline

						|| pc->assign_ctxt == Op_K_getline_redir)

					&& (r = TOP())

					&& get_number_si(r) <= 0 	/* EOF or error */

				)

					di = false;

				if (di)

					(*set_array->astore)(set_array, set_idx);

				unref(set_idx);

				set_idx = NULL;

			}

			break;

		/* numeric assignments */

		case Op_assign_plus:

		case Op_assign_minus:

		case Op_assign_times:

		case Op_assign_quotient:

		case Op_assign_mod:

		case Op_assign_exp:

			op_assign(op);

			break;

		case Op_var_update:        /* update value of NR, FNR or NF */

			pc->update_var();

			break;

		case Op_var_assign:

		case Op_field_assign:

			r = TOP();

			if (pc->assign_ctxt == Op_sub_builtin

				&& get_number_si(r) == 0	/* top of stack has a number == 0 */

			) {

				/* There wasn't any substitutions. If the target is a FIELD,

				 * this means no field re-splitting or $0 reconstruction.

				 * Skip the set_FOO routine if the target is a special variable.

				 */

				break;

			} else if ((pc->assign_ctxt == Op_K_getline

					|| pc->assign_ctxt == Op_K_getline_redir)

				&& get_number_si(r) <= 0 	/* top of stack has a number <= 0 */

			) {

				/* getline returned EOF or error */

				break;

			}

			if (op == Op_var_assign)

				pc->assign_var();

			else

				pc->field_assign();

			break;

		case Op_concat:

			r = concat_exp(pc->expr_count, pc->concat_flag & CSUBSEP);

			PUSH(r);

			break;

		case Op_K_case:

			if ((pc + 1)->match_exp) {

				/* match a constant regex against switch expression instead of $0. */

				m = POP();	/* regex */

				t2 = TOP_SCALAR();	/* switch expression */

				t2 = force_string(t2);

				rp = re_update(m);

				di = (research(rp, t2->stptr, 0, t2->stlen, RE_NO_FLAGS) >= 0);

			} else {

				t1 = POP_SCALAR();	/* case value */

				t2 = TOP_SCALAR();	/* switch expression */

				di = (cmp_nodes(t2, t1, true) == 0);

				DEREF(t1);

			}

			if (di) {

				/* match found */

				t2 = POP_SCALAR();

				DEREF(t2);

				JUMPTO(pc->target_jmp);

			}

			break;

		case Op_K_delete:

			t1 = POP_ARRAY();

			do_delete(t1, pc->expr_count);

			stack_adj(-pc->expr_count);

			break;

		case Op_K_delete_loop:

			t1 = POP_ARRAY();

			lhs = POP_ADDRESS();	/* item */