/*

 * profile.c - gawk bytecode pretty-printer with counts

 */

/*

 * Copyright (C) 1999-2017 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

 */

#include "awk.h"

static void pprint(INSTRUCTION *startp, INSTRUCTION *endp, int flags);

static INSTRUCTION *end_line(INSTRUCTION *ip);

static void pp_parenthesize(NODE *n);

static void parenthesize(int type, NODE *left, NODE *right);

static char *pp_list(int nargs, const char *paren, const char *delim);

static char *pp_group3(const char *s1, const char *s2, const char *s3);

static char *pp_concat(int nargs);

static char *pp_string_or_typed_regex(const char *in_str, size_t len, int delim, bool typed_regex);

static char *pp_typed_regex(const char *in_str, size_t len, int delim);

static bool is_binary(int type);

static bool is_scalar(int type);

static int prec_level(int type);

static void pp_push(int type, char *s, int flag);

static NODE *pp_pop(void);

static void print_comment(INSTRUCTION *pc, long in);

const char *redir2str(int redirtype);

#define pp_str	vname

#define pp_len	sub.nodep.reserved

#define pp_next	rnode

#define DONT_FREE 1

#define CAN_FREE  2

static void dump_and_exit(int signum) ATTRIBUTE_NORETURN;

static void just_dump(int signum);

/* pretty printing related functions and variables */

static NODE *pp_stack = NULL;

static NODE *func_params;	/* function parameters */

static FILE *prof_fp;	/* where to send the profile */

static long indent_level = 0;

#define SPACEOVER	0

#define NO_PPRINT_FLAGS	0

#define IN_FOR_HEADER	1

#define IN_ELSE_IF	2

/* set_prof_file --- set the output file for profiling or pretty-printing */

void

set_prof_file(const char *file)

{

	int fd;

	assert(file != NULL);

	fd = devopen_simple(file, "w", true);

	if (fd == INVALID_HANDLE)

		prof_fp = NULL;

	else if (fd == fileno(stdout))

		prof_fp = stdout;

	else if (fd == fileno(stderr))

		prof_fp = stderr;

	else

		prof_fp = fdopen(fd, "w");

	if (prof_fp == NULL) {

		/* don't leak file descriptors */

		int e = errno;

		if (   fd != INVALID_HANDLE

		    && fd != fileno(stdout)

		    && fd != fileno(stderr))

			(void) close(fd);

		errno = e;

		warning(_("could not open `%s' for writing: %s"),

				file, strerror(errno));

		warning(_("sending profile to standard error"));

		prof_fp = stderr;

	}

}

/* init_profiling_signals --- set up signal handling for gawk --profile */

void

init_profiling_signals()

{

#ifdef __DJGPP__

	signal(SIGINT, dump_and_exit);

	signal(SIGQUIT, just_dump);

#else  /* !__DJGPP__ */

#ifdef SIGHUP

	signal(SIGHUP, dump_and_exit);

#endif

#ifdef SIGUSR1

	signal(SIGUSR1, just_dump);

#endif

#endif /* !__DJGPP__ */

}

/* indent --- print out enough tabs */

static void

indent(long count)

{

	int i;

	if (do_profile) {

		if (count == 0)

			fprintf(prof_fp, "\t");

		else

			fprintf(prof_fp, "%6ld  ", count);

	}

	assert(indent_level >= 0);

	for (i = 0; i < indent_level; i++)

		fprintf(prof_fp, "\t");

}

/* indent_in --- increase the level, with error checking */

static void

indent_in(void)

{

	assert(indent_level >= 0);

	indent_level++;

}

/* indent_out --- decrease the level, with error checking */

static void

indent_out(void)

{

	indent_level--;

	assert(indent_level >= 0);

}

/* pp_push --- push a pretty printed string onto the stack */

static void

pp_push(int type, char *s, int flag)

{

	NODE *n;

	getnode(n);

	n->pp_str = s;

	n->pp_len = strlen(s);

	n->flags = flag;

	n->type = type;

	n->pp_next = pp_stack;

	pp_stack = n;

}

/* pp_pop --- pop a pretty printed string off the stack */

static NODE *

pp_pop()

{

	NODE *n;

	n = pp_stack;

	pp_stack = n->pp_next;

	return n;

}

/* pp_free --- release a pretty printed node */

static void

pp_free(NODE *n)

{

	if ((n->flags & CAN_FREE) != 0)

		efree(n->pp_str);

	freenode(n);

}

/* pprint --- pretty print a program segment */

static void

pprint(INSTRUCTION *startp, INSTRUCTION *endp, int flags)

{

	INSTRUCTION *pc;

	NODE *t1;

	char *str;

	NODE *t2;

	INSTRUCTION *ip1;

	INSTRUCTION *ip2;

	NODE *m;

	char *tmp;

	int rule;

	static int rule_count[MAXRULE];

	static bool skip_comment = false;

	for (pc = startp; pc != endp; pc = pc->nexti) {

		if (pc->source_line > 0)

			sourceline = pc->source_line;

		/* skip leading EOL comment as it has already been printed  */

		if (pc->opcode == Op_comment

		    && pc->memory->comment_type == EOL_COMMENT

		    && skip_comment) {

			skip_comment = false;

			continue;

		}

		skip_comment = false;

		switch (pc->opcode) {

		case Op_rule:

			/*

			 * Rules are three instructions long.

			 * See append_rule in awkgram.y.

			 * The first has the Rule Op Code, nexti etc.

			 * The second, (pc + 1) has firsti and lasti:

			 * 	the first/last ACTION instructions for this rule.

			 * The third has first_line and last_line:

			 * 	the first and last source line numbers.

			 */

			source = pc->source_file;

			rule = pc->in_rule;

			if (rule != Rule) {

				/* Allow for pre-non-rule-block comment  */

				if (pc->nexti != (pc +1)->firsti

				    && pc->nexti->opcode == Op_comment

				    && pc->nexti->memory->comment_type == FULL_COMMENT)

					print_comment(pc->nexti, -1);

				ip1 = (pc + 1)->firsti;

				ip2 = (pc + 1)->lasti;

				if (do_profile) {

					if (! rule_count[rule]++)

						fprintf(prof_fp, _("\t# %s rule(s)\n\n"), ruletab[rule]);

					indent(0);

				}

				fprintf(prof_fp, "%s {", ruletab[rule]);

				end_line(pc);

				skip_comment = true;

			} else {

				if (do_profile && ! rule_count[rule]++)

					fprintf(prof_fp, _("\t# Rule(s)\n\n"));

				ip1 = pc->nexti;

				indent(ip1->exec_count);

				if (ip1 != (pc + 1)->firsti) {		/* non-empty pattern */

					pprint(ip1->nexti, (pc + 1)->firsti, NO_PPRINT_FLAGS);

					/* Allow for case where the "pattern" is just a comment  */

					if (ip1->nexti->nexti->nexti != (pc +1)->firsti

					    || ip1->nexti->opcode != Op_comment) {

						t1 = pp_pop();

						fprintf(prof_fp, "%s {", t1->pp_str);

						pp_free(t1);

					} else

						fprintf(prof_fp, "{");

					ip1 = (pc + 1)->firsti;

					ip2 = (pc + 1)->lasti;

					if (do_profile && ip1->exec_count > 0)

						fprintf(prof_fp, " # %ld", ip1->exec_count);

					end_line(ip1);

					skip_comment = true;

				} else {

					fprintf(prof_fp, "{\n");

					ip1 = (pc + 1)->firsti;

					ip2 = (pc + 1)->lasti;

				}

				ip1 = ip1->nexti;

			}

			indent_in();

			pprint(ip1, ip2, NO_PPRINT_FLAGS);

			indent_out();

			if (do_profile)

				indent(0);

			fprintf(prof_fp, "}\n\n");

			pc = (pc + 1)->lasti;

			break;

		case Op_atexit:

			break;

		case Op_stop:

			memset(rule_count, 0, MAXRULE * sizeof(int));

			break;

		case Op_push_i:

			m = pc->memory;

			if (m == Nnull_string)	/* optional return or exit value; don't print 0 or "" */

				pp_push(pc->opcode, m->stptr, DONT_FREE);

			else if ((m->flags & NUMBER) != 0)

				pp_push(pc->opcode, pp_number(m), CAN_FREE);

			else {

				str = pp_string(m->stptr, m->stlen, '"');

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

					char *tmp = str;

					str = pp_group3("_", tmp, "");

					efree(tmp);

				}

				pp_push(pc->opcode, str, CAN_FREE);

			}

			break;

		case Op_store_var:

			if (pc->initval != NULL)

				pp_push(Op_push_i, pp_node(pc->initval), CAN_FREE);

			/* fall through */

		case Op_store_sub:

		case Op_assign_concat:

		case Op_push_lhs:

		case Op_push_param:

		case Op_push_array:

		case Op_push:

		case Op_push_arg:

		case Op_push_arg_untyped:

			m = pc->memory;

			switch (m->type) {

			case Node_param_list:

				pp_push(pc->opcode, func_params[m->param_cnt].param, DONT_FREE);

				break;

			case Node_var:

			case Node_var_new:

			case Node_var_array:

				if (m->vname != NULL)

					pp_push(pc->opcode, m->vname, DONT_FREE);

 				else

					fatal(_("internal error: %s with null vname"),

							nodetype2str(m->type));

				break;

			default:

				cant_happen();

			}

			switch (pc->opcode) {

			case Op_store_var:

				t2 = pp_pop(); /* l.h.s. */

				t1 = pp_pop(); /* r.h.s. */

				fprintf(prof_fp, "%s%s%s", t2->pp_str, op2str(pc->opcode), t1->pp_str);

				goto cleanup;

			case Op_store_sub:

				t1 = pp_pop();	/* array */

				tmp = pp_list(pc->expr_count, op2str(Op_subscript), ", "); /*subscript*/

				t2 = pp_pop(); /* r.h.s. */

				fprintf(prof_fp, "%s%s%s%s", t1->pp_str, tmp,

									op2str(pc->opcode), t2->pp_str);

				efree(tmp);

				goto cleanup;

			case Op_assign_concat:

				t2 = pp_pop(); /* l.h.s. */

				t1 = pp_pop();

				tmp = pp_group3(t2->pp_str, op2str(Op_concat), t1->pp_str);

				fprintf(prof_fp, "%s%s%s", t2->pp_str, op2str(Op_assign), tmp);

				efree(tmp);

cleanup:

				pp_free(t2);

				pp_free(t1);

				if ((flags & IN_FOR_HEADER) == 0)

					pc = end_line(pc);

				break;

			default:

				break;

			}

			break;

		case Op_sub_array:

		case Op_subscript_lhs:

		case Op_subscript:

			tmp = pp_list(pc->sub_count, op2str(pc->opcode), ", ");

			t1 = pp_pop();

			str = pp_group3(t1->pp_str, tmp, "");

			efree(tmp);

			pp_free(t1);

			pp_push(pc->opcode, str, CAN_FREE);

			break;

		case Op_and:

		case Op_or:

			pprint(pc->nexti, pc->target_jmp, flags);

			t2 = pp_pop();

			t1 = pp_pop();

			parenthesize(pc->opcode, t1, t2);

			str = pp_group3(t1->pp_str, op2str(pc->opcode), t2->pp_str);

			pp_free(t1);

			pp_free(t2);

			pp_push(pc->opcode, str, CAN_FREE);

			pc = pc->target_jmp;

			break;

		case Op_plus_i:

		case Op_minus_i:

		case Op_times_i:

		case Op_exp_i:

		case Op_quotient_i:

		case Op_mod_i:

			m = pc->memory;

			t1 = pp_pop();

			if (prec_level(pc->opcode) > prec_level(t1->type)

					&& is_binary(t1->type))  /* (a - b) * 1 */

				pp_parenthesize(t1);

			if ((m->flags & NUMBER) != 0)

				tmp = pp_number(m);

			else

				tmp = pp_string(m->stptr, m->stlen, '"');

			str = pp_group3(t1->pp_str, op2str(pc->opcode), tmp);

			efree(tmp);

			pp_free(t1);

			pp_push(pc->opcode, str, CAN_FREE);

			break;

		case Op_parens:

			t1 = pp_pop();

			str = pp_group3("(", t1->pp_str, ")");

			pp_free(t1);

			pp_push(pc->opcode, str, CAN_FREE);

			break;

		case Op_plus:

		case Op_minus:

		case Op_times:

		case Op_exp:

		case Op_quotient:

		case Op_mod:

		case Op_equal:

		case Op_notequal:

		case Op_less:

		case Op_greater:

		case Op_leq:

		case Op_geq:

			t2 = pp_pop();

			t1 = pp_pop();

			parenthesize(pc->opcode, t1, t2);

			str = pp_group3(t1->pp_str, op2str(pc->opcode), t2->pp_str);

			pp_free(t1);

			pp_free(t2);

			pp_push(pc->opcode, str, CAN_FREE);

			break;

		case Op_preincrement:

		case Op_predecrement:

		case Op_postincrement:

		case Op_postdecrement:

			t1 = pp_pop();

			if (pc->opcode == Op_preincrement || pc->opcode == Op_predecrement)

				str = pp_group3(op2str(pc->opcode), t1->pp_str, "");

			else

				str = pp_group3(t1->pp_str, op2str(pc->opcode), "");

			pp_free(t1);

			pp_push(pc->opcode, str, CAN_FREE);

			break;

		case Op_field_spec:

		case Op_field_spec_lhs:

		case Op_unary_minus:

		case Op_unary_plus:

		case Op_not:

			t1 = pp_pop();

			if (is_binary(t1->type)

			    || (((OPCODE) t1->type) == pc->opcode

				    && (pc->opcode == Op_unary_minus

					    || pc->opcode == Op_unary_plus)))

				pp_parenthesize(t1);

			/* optypes table (eval.c) includes space after ! */

			str = pp_group3(op2str(pc->opcode), t1->pp_str, "");

			pp_free(t1);

			pp_push(pc->opcode, str, CAN_FREE);

			break;

		case Op_assign:

		case Op_assign_plus:

		case Op_assign_minus:

		case Op_assign_times:

		case Op_assign_quotient:

		case Op_assign_mod:

		case Op_assign_exp:

			t2 = pp_pop(); /* l.h.s. */

			t1 = pp_pop();

			str = pp_group3(t2->pp_str, op2str(pc->opcode), t1->pp_str);

			pp_free(t2);

			pp_free(t1);

			pp_push(pc->opcode, str, CAN_FREE);

			break;

		case Op_store_field:

			t1 = pp_pop(); /* field num */

			if (is_binary(t1->type))

				pp_parenthesize(t1);

			t2 = pp_pop(); /* r.h.s. */

			fprintf(prof_fp, "$%s%s%s", t1->pp_str, op2str(pc->opcode), t2->pp_str);

			pp_free(t2);

			pp_free(t1);

			if ((flags & IN_FOR_HEADER) == 0)

				pc = end_line(pc);

			break;

		case Op_concat:

			str = pp_concat(pc->expr_count);

			pp_push(Op_concat, str, CAN_FREE);

			break;

		case Op_K_delete:

		{

			char *array;

			t1 = pp_pop();

			array = t1->pp_str;

			if (pc->expr_count > 0) {

				char *sub;

				sub = pp_list(pc->expr_count, NULL, pc->expr_count > 1 ? "][" : ", ");

				fprintf(prof_fp, "%s %s[%s]", op2str(Op_K_delete), array, sub);

				efree(sub);

			} else

				fprintf(prof_fp, "%s %s", op2str(Op_K_delete), array);

			if ((flags & IN_FOR_HEADER) == 0)

				pc = end_line(pc);

			pp_free(t1);

		}

			break;

		case Op_K_delete_loop:

			/* Efficency hack not in effect because of exec_count instruction */

			cant_happen();

			break;

		case Op_in_array:

		{

			char *array, *sub;

			t1 = pp_pop();

			array = t1->pp_str;

			if (pc->expr_count > 1) {

				sub = pp_list(pc->expr_count, "()", ", ");

				str = pp_group3(sub, op2str(Op_in_array), array);

				efree(sub);

			} else {

				t2 = pp_pop();

				if (prec_level(t2->type) < prec_level(Op_in_array)) {

					pp_parenthesize(t2);

				}

				sub = t2->pp_str;

				str = pp_group3(sub, op2str(Op_in_array), array);

				pp_free(t2);

			}

			pp_free(t1);

			pp_push(Op_in_array, str, CAN_FREE);

		}

			break;

		case Op_var_update:

		case Op_var_assign:

		case Op_field_assign:

		case Op_subscript_assign:

		case Op_arrayfor_init:

		case Op_arrayfor_incr:

		case Op_arrayfor_final:

		case Op_newfile:

		case Op_get_record:

		case Op_lint:

		case Op_jmp:

		case Op_jmp_false:

		case Op_jmp_true:

		case Op_no_op:

		case Op_and_final:

		case Op_or_final:

		case Op_cond_pair:

		case Op_after_beginfile:

		case Op_after_endfile:

			break;

		case Op_sub_builtin:

		{

			const char *fname = "sub";

			if ((pc->sub_flags & GSUB) != 0)

				fname = "gsub";

			else if ((pc->sub_flags & GENSUB) != 0)

				fname = "gensub";

			tmp = pp_list(pc->expr_count, "()", ", ");

			str = pp_group3(fname, tmp, "");

			efree(tmp);

			pp_push(Op_sub_builtin, str, CAN_FREE);

		}

			break;

		case Op_builtin:

		case Op_ext_builtin:

		{

			const char *fname;

			if (pc->opcode == Op_builtin)

				fname = getfname(pc->builtin);

			else

				fname = (pc + 1)->func_name;

			if (fname != NULL) {

				if (pc->expr_count > 0) {

					tmp = pp_list(pc->expr_count, "()", ", ");

					str = pp_group3(fname, tmp, "");

					efree(tmp);

				} else

					str = pp_group3(fname, "()", "");

				pp_push(Op_builtin, str, CAN_FREE);

			} else

				fatal(_("internal error: builtin with null fname"));

		}

			break;

		case Op_K_print:

		case Op_K_printf:

		case Op_K_print_rec:

			if (pc->opcode == Op_K_print_rec)

				tmp = pp_group3(" ", op2str(Op_field_spec), "0");

			else if (pc->redir_type != 0)

				tmp = pp_list(pc->expr_count, "()", ", ");

			else {

				tmp = pp_list(pc->expr_count, "  ", ", ");

				tmp[strlen(tmp) - 1] = '\0';	/* remove trailing space */

			}

			if (pc->redir_type != 0) {

				t1 = pp_pop();

				if (is_binary(t1->type))

					pp_parenthesize(t1);

				fprintf(prof_fp, "%s%s%s%s", op2str(pc->opcode),

							tmp, redir2str(pc->redir_type), t1->pp_str);

				pp_free(t1);

			} else

				fprintf(prof_fp, "%s%s", op2str(pc->opcode), tmp);

			efree(tmp);

			if ((flags & IN_FOR_HEADER) == 0)

				pc = end_line(pc);

			break;

		case Op_push_re:

			if (pc->memory->type != Node_regex && (pc->memory->flags & REGEX) == 0)

				break;

			/* else

				fall through */

		case Op_match_rec:

		{

			if (pc->memory->type == Node_regex) {

				NODE *re = pc->memory->re_exp;

				str = pp_string(re->stptr, re->stlen, '/');

			} else {

				assert((pc->memory->flags & REGEX) != 0);

				str = pp_typed_regex(pc->memory->stptr, pc->memory->stlen, '/');

			}

			pp_push(pc->opcode, str, CAN_FREE);

		}

			break;

		case Op_nomatch:

		case Op_match:

		{

			char *restr, *txt;

			t1 = pp_pop();

			if (is_binary(t1->type))

				pp_parenthesize(t1);

			txt = t1->pp_str;

			m = pc->memory;

			if (m->type == Node_dynregex) {

				restr = txt;

				t2 = pp_pop();

				if (is_binary(t2->type))

					pp_parenthesize(t2);

				txt = t2->pp_str;

				str = pp_group3(txt, op2str(pc->opcode), restr);

				pp_free(t2);

			} else if (m->type == Node_val && (m->flags & REGEX) != 0) {

				restr = pp_typed_regex(m->stptr, m->stlen, '/');

				str = pp_group3(txt, op2str(pc->opcode), restr);

				efree(restr);

			} else {

				NODE *re = m->re_exp;

				restr = pp_string(re->stptr, re->stlen, '/');

				str = pp_group3(txt, op2str(pc->opcode), restr);

				efree(restr);

			}

			pp_free(t1);

			pp_push(pc->opcode, str, CAN_FREE);

		}

			break;

		case Op_K_getline:

		case Op_K_getline_redir:

			if (pc->into_var) {

				t1 = pp_pop();

				tmp = pp_group3(op2str(Op_K_getline), " ", t1->pp_str);

				pp_free(t1);

			} else

				tmp = pp_group3(op2str(Op_K_getline), "", "");

			if (pc->redir_type != 0) {

				int before = (pc->redir_type == redirect_pipein

							|| pc->redir_type == redirect_twoway);

				t2 = pp_pop();

				if (is_binary(t2->type))

					pp_parenthesize(t2);

				if (before)

					str = pp_group3(t2->pp_str, redir2str(pc->redir_type), tmp);

				else

					str = pp_group3(tmp, redir2str(pc->redir_type), t2->pp_str);

				efree(tmp);

				pp_free(t2);

			} else

				str = tmp;

			pp_push(pc->opcode, str, CAN_FREE);

			break;

		case Op_indirect_func_call:

		case Op_func_call:

		{

			char *fname = pc->func_name;

			char *pre;

 			int pcount;

			if (pc->opcode == Op_indirect_func_call)

				pre = "@";

			else

				pre = "";

			pcount = (pc + 1)->expr_count;

			if (pcount > 0) {

				tmp = pp_list(pcount, "()", ", ");

				str = pp_group3(pre, fname, tmp);

				efree(tmp);

			} else

				str = pp_group3(pre, fname, "()");

			if (pc->opcode == Op_indirect_func_call) {

				t1 = pp_pop();	/* indirect var */

				pp_free(t1);

			}

			pp_push(pc->opcode, str, CAN_FREE);

		}

			break;

		case Op_K_continue:

		case Op_K_break:

		case Op_K_nextfile:

		case Op_K_next:

			fprintf(prof_fp, "%s", op2str(pc->opcode));

			pc = end_line(pc);

			break;

		case Op_K_return:

		case Op_K_exit:

			t1 = pp_pop();

			if (is_binary(t1->type))

				pp_parenthesize(t1);

			if (pc->source_line > 0) {	/* don't print implicit 'return' at end of function */

				fprintf(prof_fp, "%s %s", op2str(pc->opcode), t1->pp_str);

				pc = end_line(pc);

			}

			pp_free(t1);

			break;

		case Op_pop:

			t1 = pp_pop();

			fprintf(prof_fp, "%s", t1->pp_str);

			if ((flags & IN_FOR_HEADER) == 0)

				pc = end_line(pc);

			pp_free(t1);

			break;

		case Op_line_range:

			ip1 = pc + 1;

			pprint(pc->nexti, ip1->condpair_left, NO_PPRINT_FLAGS);

			pprint(ip1->condpair_left->nexti, ip1->condpair_right, NO_PPRINT_FLAGS);

			t2 = pp_pop();

			t1 = pp_pop();

			str = pp_group3(t1->pp_str, ", ", t2->pp_str);

			pp_free(t1);

			pp_free(t2);

			pp_push(Op_line_range, str, CAN_FREE);

			pc = ip1->condpair_right;

			break;

		case Op_K_while:

			ip1 = pc + 1;

			indent(ip1->while_body->exec_count);

			fprintf(prof_fp, "%s (", op2str(pc->opcode));

			pprint(pc->nexti, ip1->while_body, NO_PPRINT_FLAGS);

			t1 = pp_pop();

			fprintf(prof_fp, "%s) {", t1->pp_str);

			pp_free(t1);

			ip1->while_body = end_line(ip1->while_body);

			indent_in();

			pprint(ip1->while_body->nexti, pc->target_break, NO_PPRINT_FLAGS);

			indent_out();

			indent(SPACEOVER);

			fprintf(prof_fp, "}");

			pc = end_line(pc->target_break);

			break;

		case Op_K_do:

			ip1 = pc + 1;

			indent(pc->nexti->exec_count);

			fprintf(prof_fp, "%s {", op2str(pc->opcode));

			end_line(pc->nexti);

			skip_comment = true;

			indent_in();

			pprint(pc->nexti->nexti, ip1->doloop_cond, NO_PPRINT_FLAGS);

			indent_out();

			pprint(ip1->doloop_cond, pc->target_break, NO_PPRINT_FLAGS);

			indent(SPACEOVER);

			t1 = pp_pop();

			fprintf(prof_fp, "} %s (%s)", op2str(Op_K_while), t1->pp_str);

			pp_free(t1);

			end_line(pc->target_break);

			skip_comment = true;

			pc = pc->target_break;

			break;

		case Op_K_for:

			ip1 = pc + 1;

			indent(ip1->forloop_body->exec_count);

			fprintf(prof_fp, "%s (", op2str(pc->opcode));

			/* If empty for looop header, print it a little more nicely. */

			if (   pc->nexti->opcode == Op_no_op

			    && ip1->forloop_cond == pc->nexti

			    && pc->target_continue->opcode == Op_jmp) {

				fprintf(prof_fp, ";;");

			} else {

				pprint(pc->nexti, ip1->forloop_cond, IN_FOR_HEADER);

				fprintf(prof_fp, "; ");

				if (ip1->forloop_cond->opcode == Op_no_op &&

						ip1->forloop_cond->nexti == ip1->forloop_body)

					fprintf(prof_fp, "; ");

				else {

					pprint(ip1->forloop_cond, ip1->forloop_body, IN_FOR_HEADER);

					t1 = pp_pop();

					fprintf(prof_fp, "%s; ", t1->pp_str);

					pp_free(t1);

				}

				pprint(pc->target_continue, pc->target_break, IN_FOR_HEADER);

			}

			fprintf(prof_fp, ") {");

			end_line(ip1->forloop_body);

			skip_comment = true;

			indent_in();

			pprint(ip1->forloop_body->nexti, pc->target_continue, NO_PPRINT_FLAGS);

			indent_out();

			indent(SPACEOVER);

			fprintf(prof_fp, "}");

			end_line(pc->target_break);

			skip_comment = true;

			pc = pc->target_break;

			break;

		case Op_K_arrayfor:

		{

			char *array;

			const char *item;

			ip1 = pc + 1;

			t1 = pp_pop();

			array = t1->pp_str;

			m = ip1->forloop_cond->array_var;

			if (m->type == Node_param_list)

				item = func_params[m->param_cnt].param;

			else

				item = m->vname;