/*
   +----------------------------------------------------------------------+
   | Copyright © The PHP Group and Contributors.                          |
   +----------------------------------------------------------------------+
   | This source file is subject to the Modified BSD License that is      |
   | bundled with this package in the file LICENSE, and is available      |
   | through the World Wide Web at <https://www.php.net/license/>.        |
   |                                                                      |
   | SPDX-License-Identifier: BSD-3-Clause                                |
   +----------------------------------------------------------------------+
   | Authors: Felipe Pena <felipe@php.net>                                |
   | Authors: Joe Watkins <joe.watkins@live.co.uk>                        |
   | Authors: Bob Weinand <bwoebi@php.net>                                |
   +----------------------------------------------------------------------+
*/

#include <stdio.h>
#include <string.h>
#include "zend.h"
#include "zend_compile.h"
#include "zend_exceptions.h"
#include "zend_vm.h"
#include "zend_generators.h"
#include "zend_interfaces.h"
#include "zend_smart_str.h"
#include "phpdbg.h"
#include "phpdbg_io.h"

#include "phpdbg_help.h"
#include "phpdbg_print.h"
#include "phpdbg_info.h"
#include "phpdbg_break.h"
#include "phpdbg_list.h"
#include "phpdbg_utils.h"
#include "phpdbg_prompt.h"
#include "phpdbg_cmd.h"
#include "phpdbg_set.h"
#include "phpdbg_frame.h"
#include "phpdbg_lexer.h"
#include "phpdbg_parser.h"

#if ZEND_VM_KIND != ZEND_VM_KIND_CALL && ZEND_VM_KIND != ZEND_VM_KIND_TAILCALL && ZEND_VM_KIND != ZEND_VM_KIND_HYBRID
#error "phpdbg can only be built with CALL zend vm kind"
#endif

ZEND_EXTERN_MODULE_GLOBALS(phpdbg)
extern int phpdbg_startup_run;

#ifdef HAVE_LIBDL
#ifdef PHP_WIN32
#include "win32/winutil.h"
#define GET_DL_ERROR()  php_win_err()
#else
#define GET_DL_ERROR()  DL_ERROR()
#endif
#endif

/* {{{ command declarations */
const phpdbg_command_t phpdbg_prompt_commands[] = {
	PHPDBG_COMMAND_D(exec,      "set execution context",                    'e', NULL, "s", 0),
	PHPDBG_COMMAND_D(stdin,     "read script from stdin",                    0 , NULL, "s", 0),
	PHPDBG_COMMAND_D(step,      "step through execution",                   's', NULL, 0, PHPDBG_ASYNC_SAFE),
	PHPDBG_COMMAND_D(continue,  "continue execution",                       'c', NULL, 0, PHPDBG_ASYNC_SAFE),
	PHPDBG_COMMAND_D(run,       "attempt execution",                        'r', NULL, "|s", 0),
	PHPDBG_COMMAND_D(ev,        "evaluate some code",                        0 , NULL, "i", PHPDBG_ASYNC_SAFE), /* restricted ASYNC_SAFE */
	PHPDBG_COMMAND_D(until,     "continue past the current line",           'u', NULL, 0, 0),
	PHPDBG_COMMAND_D(finish,    "continue past the end of the stack",       'F', NULL, 0, 0),
	PHPDBG_COMMAND_D(leave,     "continue until the end of the stack",      'L', NULL, 0, 0),
	PHPDBG_COMMAND_D(generator, "inspect or switch to a generator",         'g', NULL, "|n", 0),
	PHPDBG_COMMAND_D(print,     "print something",                          'p', phpdbg_print_commands, "|*c", 0),
	PHPDBG_COMMAND_D(break,     "set breakpoint",                           'b', phpdbg_break_commands, "|*c", 0),
	PHPDBG_COMMAND_D(back,      "show trace",                               't', NULL, "|n", PHPDBG_ASYNC_SAFE),
	PHPDBG_COMMAND_D(frame,     "switch to a frame",                        'f', NULL, "|n", PHPDBG_ASYNC_SAFE),
	PHPDBG_COMMAND_D(list,      "lists some code",                          'l', phpdbg_list_commands,  "*", PHPDBG_ASYNC_SAFE),
	PHPDBG_COMMAND_D(info,      "displays some information",               'i', phpdbg_info_commands, "|s", PHPDBG_ASYNC_SAFE),
	PHPDBG_COMMAND_D(clean,     "clean the execution environment",          'X', NULL, 0, 0),
	PHPDBG_COMMAND_D(clear,     "clear breakpoints",                        'C', NULL, 0, 0),
	PHPDBG_COMMAND_D(help,      "show help menu",                           'h', phpdbg_help_commands, "|s", PHPDBG_ASYNC_SAFE),
	PHPDBG_COMMAND_D(set,       "set phpdbg configuration",                 'S', phpdbg_set_commands,   "s", PHPDBG_ASYNC_SAFE),
	PHPDBG_COMMAND_D(register,  "register a phpdbginit function as a command alias", 'R', NULL, "s", 0),
	PHPDBG_COMMAND_D(source,    "execute a phpdbginit",                     '<', NULL, "s", 0),
	PHPDBG_COMMAND_D(export,    "export breaks to a .phpdbginit script",    '>', NULL, "s", PHPDBG_ASYNC_SAFE),
	PHPDBG_COMMAND_D(sh,   	    "shell a command",                           0 , NULL, "i", 0),
	PHPDBG_COMMAND_D(quit,      "exit phpdbg",                              'q', NULL, 0, PHPDBG_ASYNC_SAFE),
	PHPDBG_COMMAND_D(watch,     "set watchpoint",                           'w', phpdbg_watch_commands, "|ss", 0),
	PHPDBG_COMMAND_D(next,      "step over next line",                      'n', NULL, 0, PHPDBG_ASYNC_SAFE),
	PHPDBG_END_COMMAND
}; /* }}} */

static inline int phpdbg_call_register(phpdbg_param_t *stack) /* {{{ */
{
	phpdbg_param_t *name = NULL;

	if (stack->type == STACK_PARAM) {
		name = stack->next;

		if (!name || name->type != STR_PARAM) {
			return FAILURE;
		}

		zend_function *user_fn = zend_hash_str_find_ptr_lc(&PHPDBG_G(registered), name->str, name->len);
		if (user_fn != NULL) {
			HashTable *params_ht = NULL;
			if (name->next) {
				phpdbg_param_t *next = name->next;
				zval params;
				array_init(&params);

				while (next) {
					zend_string *buffered = NULL;

					switch (next->type) {
						case OP_PARAM:
						case COND_PARAM:
						case STR_PARAM:
							add_next_index_stringl(&params, next->str, next->len);
						break;

						case NUMERIC_PARAM:
							add_next_index_long(&params, next->num);
						break;

						case METHOD_PARAM:
							buffered = strpprintf(0, "%s::%s", next->method.class, next->method.name);
							add_next_index_str(&params, buffered);
						break;

						case NUMERIC_METHOD_PARAM:
							buffered = strpprintf(0, "%s::%s#"ZEND_LONG_FMT, next->method.class, next->method.name, next->num);
							add_next_index_str(&params, buffered);
						break;

						case NUMERIC_FUNCTION_PARAM:
							buffered = strpprintf(0, "%s#"ZEND_LONG_FMT, next->str, next->num);
							add_next_index_str(&params, buffered);
						break;

						case FILE_PARAM:
							buffered = strpprintf(0, "%s:"ZEND_ULONG_FMT, next->file.name, next->file.line);
							add_next_index_str(&params, buffered);
						break;

						case NUMERIC_FILE_PARAM:
							buffered = strpprintf(0, "%s:#"ZEND_ULONG_FMT, next->file.name, next->file.line);
							add_next_index_str(&params, buffered);
						break;

						default: {
							/* not yet */
						}
					}

					next = next->next;
				}
				/* Add positional arguments */
				params_ht = Z_ARRVAL(params);
				phpdbg_debug("created " PRIu32 " params from arguments", zend_hash_num_elements(params_ht));
			}

			phpdbg_activate_err_buf(0);
			phpdbg_free_err_buf();


			zend_call_known_function(user_fn, NULL, NULL, NULL, 0, NULL, params_ht);
			phpdbg_out("\n");

			if (params_ht) {
				zend_array_destroy(params_ht);
			}

			return SUCCESS;
		}
	}

	return FAILURE;
} /* }}} */

struct phpdbg_init_state {
	int line;
	bool in_code;
	char *code;
	size_t code_len;
	const char *init_file;
};

static void phpdbg_line_init(char *cmd, struct phpdbg_init_state *state) {
	size_t cmd_len = strlen(cmd);

	state->line++;

	while (cmd_len > 0L && isspace((unsigned char)cmd[cmd_len-1])) {
		cmd_len--;
	}

	cmd[cmd_len] = '\0';

	if (*cmd && cmd_len > 0L && cmd[0] != '#') {
		if (cmd_len == 2) {
			if (memcmp(cmd, "<:", sizeof("<:")-1) == SUCCESS) {
				state->in_code = 1;
				return;
			} else {
				if (memcmp(cmd, ":>", sizeof(":>")-1) == SUCCESS) {
					state->in_code = 0;
					state->code[state->code_len] = '\0';
					zend_eval_stringl(state->code, state->code_len, NULL, "phpdbginit code");
					free(state->code);
					state->code = NULL;
					return;
				}
			}
		}

		if (state->in_code) {
			if (state->code == NULL) {
				state->code = pemalloc(cmd_len + 1, true);
			} else {
				state->code = perealloc(state->code, state->code_len + cmd_len + 1, true);
			}

			if (state->code) {
				memcpy(&state->code[state->code_len], cmd, cmd_len);
				state->code_len += cmd_len;
			}

			return;
		}

		zend_try {
			char *input = phpdbg_read_input(cmd);
			phpdbg_param_t stack;

			phpdbg_init_param(&stack, STACK_PARAM);

			phpdbg_activate_err_buf(1);

			if (phpdbg_do_parse(&stack, input) <= 0) {
				switch (phpdbg_stack_execute(&stack, 1 /* allow_async_unsafe == 1 */)) {
					case FAILURE:
						phpdbg_activate_err_buf(0);
						if (phpdbg_call_register(&stack) == FAILURE) {
							if (state->init_file) {
								phpdbg_output_err_buf("Unrecognized command in %s:%d: %s, %s!", state->init_file, state->line, input, PHPDBG_G(err_buf).msg);
							} else {
								phpdbg_output_err_buf("Unrecognized command on line %d: %s, %s!", state->line, input, PHPDBG_G(err_buf).msg);
							}
						}
					break;
				}
			}

			phpdbg_activate_err_buf(0);
			phpdbg_free_err_buf();

			phpdbg_stack_free(&stack);
			phpdbg_destroy_input(&input);
		} zend_catch {
			PHPDBG_G(flags) &= ~(PHPDBG_IS_RUNNING | PHPDBG_IS_CLEANING);
			if (PHPDBG_G(flags) & PHPDBG_IS_QUITTING) {
				zend_bailout();
			}
		} zend_end_try();
	}

}

void phpdbg_string_init(char *buffer) {
	struct phpdbg_init_state state = {0};
	char *str = strtok(buffer, "\n");

	while (str) {
		phpdbg_line_init(str, &state);

		str = strtok(NULL, "\n");
	}

	if (state.code) {
		free(state.code);
	}
}

void phpdbg_try_file_init(char *init_file, size_t init_file_len, bool free_init) /* {{{ */
{
	zend_stat_t sb = {0};

	if (init_file && VCWD_STAT(init_file, &sb) != -1) {
		FILE *fp = fopen(init_file, "r");
		if (fp) {
			char cmd[PHPDBG_MAX_CMD];
			struct phpdbg_init_state state = {0};

			state.init_file = init_file;

			while (fgets(cmd, PHPDBG_MAX_CMD, fp) != NULL) {
				phpdbg_line_init(cmd, &state);
			}

			if (state.code) {
				free(state.code);
			}

			fclose(fp);
		} else {
			phpdbg_error("Failed to open %s for initialization", init_file);
		}

		if (free_init) {
			free(init_file);
		}
	}
} /* }}} */

void phpdbg_init(char *init_file, size_t init_file_len, bool use_default) /* {{{ */
{
	if (init_file) {
		phpdbg_try_file_init(init_file, init_file_len, 1);
	} else if (use_default) {
		char *scan_dir = getenv("PHP_INI_SCAN_DIR");
		char *sys_ini;
		int i;

		size_t sys_ini_length = asprintf(&sys_ini, "%s/" PHPDBG_INIT_FILENAME, PHP_CONFIG_FILE_PATH);
		phpdbg_try_file_init(sys_ini, sys_ini_length, 0);
		free(sys_ini);

		if (!scan_dir) {
			scan_dir = PHP_CONFIG_FILE_SCAN_DIR;
		}
		while (*scan_dir != 0) {
			i = 0;
			while (scan_dir[i] != ':') {
				if (scan_dir[i++] == 0) {
					i = -1;
					break;
				}
			}
			if (i != -1) {
				scan_dir[i] = 0;
			}

			ZEND_IGNORE_VALUE(asprintf(&init_file, "%s/%s", scan_dir, PHPDBG_INIT_FILENAME));
			phpdbg_try_file_init(init_file, init_file_len, 0);
			free(init_file);
			if (i == -1) {
				break;
			}
			scan_dir += i + 1;
		}

		phpdbg_try_file_init(PHPDBG_STRL(PHPDBG_INIT_FILENAME), 0);
	}
}
/* }}} */

void phpdbg_clean(bool full, bool resubmit) /* {{{ */
{
	/* this is implicitly required */
	if (PHPDBG_G(ops)) {
		destroy_op_array(PHPDBG_G(ops));
		efree(PHPDBG_G(ops));
		PHPDBG_G(ops) = NULL;
	}

	if (!resubmit && PHPDBG_G(cur_command)) {
		free(PHPDBG_G(cur_command));
		PHPDBG_G(cur_command) = NULL;
	}

	if (full) {
		PHPDBG_G(flags) |= PHPDBG_IS_CLEANING;
	}
} /* }}} */

PHPDBG_COMMAND(exec) /* {{{ */
{
	zend_stat_t sb = {0};

	if (VCWD_STAT(param->str, &sb) != FAILURE) {
		if (sb.st_mode & (S_IFREG|S_IFLNK)) {
			char *res = phpdbg_resolve_path(param->str);
			size_t res_len = strlen(res);

			if ((res_len != PHPDBG_G(exec_len)) || (memcmp(res, PHPDBG_G(exec), res_len) != SUCCESS)) {
				if (PHPDBG_G(in_execution)) {
					if (phpdbg_ask_user_permission("Do you really want to stop execution to set a new execution context?") == FAILURE) {
						free(res);
						return FAILURE;
					}
				}

				if (PHPDBG_G(exec)) {
					phpdbg_notice("Unsetting old execution context: %s", PHPDBG_G(exec));
					free(PHPDBG_G(exec));
					PHPDBG_G(exec) = NULL;
					PHPDBG_G(exec_len) = 0L;
				}

				if (PHPDBG_G(ops)) {
					phpdbg_notice("Destroying compiled opcodes");
					phpdbg_clean(0, 0);
				}

				PHPDBG_G(exec) = res;
				PHPDBG_G(exec_len) = res_len;

				VCWD_CHDIR_FILE(res);

				*SG(request_info).argv = estrndup(PHPDBG_G(exec), PHPDBG_G(exec_len));
				php_build_argv(NULL, &PG(http_globals)[TRACK_VARS_SERVER]);

				phpdbg_notice("Set execution context: %s", PHPDBG_G(exec));

				if (PHPDBG_G(in_execution)) {
					phpdbg_clean(1, 0);
					return SUCCESS;
				}

				phpdbg_compile();
			} else {
				free(res);
				phpdbg_notice("Execution context not changed");
			}
		} else {
			phpdbg_error("Cannot use %s as execution context, not a valid file or symlink", param->str);
		}
	} else {
		phpdbg_error("Cannot stat %s, ensure the file exists", param->str);
	}
	return SUCCESS;
} /* }}} */

PHPDBG_COMMAND(stdin)
{
	smart_str code = {0};
	char *buf;
	char *sep = param->str;
	int seplen = param->len;
	int bytes = 0;

	smart_str_appends(&code, "?>");

	do {
		PHPDBG_G(input_buflen) += bytes;
		if (PHPDBG_G(input_buflen) <= 0) {
			continue;
		}

		if (sep && seplen) {
			char *nl = buf = PHPDBG_G(input_buffer);
			do {
				if (buf == nl + seplen) {
					if (!memcmp(sep, nl, seplen) && (*buf == '\n' || (*buf == '\r' && buf[1] == '\n'))) {
						smart_str_appendl(&code, PHPDBG_G(input_buffer), nl - PHPDBG_G(input_buffer));
						memmove(PHPDBG_G(input_buffer), ++buf, --PHPDBG_G(input_buflen));
						goto exec_code;
					}
				}
				if (*buf == '\n') {
					nl = buf + 1;
				}
				buf++;
			} while (--PHPDBG_G(input_buflen));
			if (buf != nl && buf <= nl + seplen) {
				smart_str_appendl(&code, PHPDBG_G(input_buffer), nl - PHPDBG_G(input_buffer));
				PHPDBG_G(input_buflen) = buf - nl;
				memmove(PHPDBG_G(input_buffer), nl, PHPDBG_G(input_buflen));
			} else {
				PHPDBG_G(input_buflen) = 0;
				smart_str_appendl(&code, PHPDBG_G(input_buffer), buf - PHPDBG_G(input_buffer));
			}
		} else {
			smart_str_appendl(&code, PHPDBG_G(input_buffer), PHPDBG_G(input_buflen));
			PHPDBG_G(input_buflen) = 0;
		}
	} while ((bytes = phpdbg_mixed_read(PHPDBG_G(io)[PHPDBG_STDIN].fd, PHPDBG_G(input_buffer) + PHPDBG_G(input_buflen), PHPDBG_MAX_CMD - PHPDBG_G(input_buflen), -1)) > 0);

	if (bytes < 0) {
		PHPDBG_G(flags) |= PHPDBG_IS_QUITTING;
		zend_bailout();
	}

exec_code:
	smart_str_0(&code);

	if (phpdbg_compile_stdin(code.s) == FAILURE) {
		zend_exception_error(EG(exception), E_ERROR);
		zend_bailout();
	}

	return SUCCESS;
} /* }}} */

int phpdbg_compile_stdin(zend_string *code) {
	PHPDBG_G(ops) = zend_compile_string(code, "Standard input code", ZEND_COMPILE_POSITION_AFTER_OPEN_TAG);
	zend_string_release(code);

	if (EG(exception)) {
		return FAILURE;
	}

	if (PHPDBG_G(exec)) {
		free(PHPDBG_G(exec));
	}
	PHPDBG_G(exec) = strdup("Standard input code");
	PHPDBG_G(exec_len) = sizeof("Standard input code") - 1;
	{ /* remove leading ?> from source */
		int i;
		/* remove trailing data after zero byte, used for avoiding conflicts in eval()'ed code snippets */
		zend_string *source_path = strpprintf(0, "Standard input code%c%p", 0, PHPDBG_G(ops)->opcodes);
		phpdbg_file_source *data = zend_hash_find_ptr(&PHPDBG_G(file_sources), source_path);
		dtor_func_t dtor = PHPDBG_G(file_sources).pDestructor;
		PHPDBG_G(file_sources).pDestructor = NULL;
		zend_hash_del(&PHPDBG_G(file_sources), source_path);
		PHPDBG_G(file_sources).pDestructor = dtor;
		zend_hash_str_update_ptr(&PHPDBG_G(file_sources), "Standard input code", sizeof("Standard input code")-1, data);
		zend_string_release(source_path);

		for (i = 1; i <= data->lines; i++) {
			data->line[i] -= 2;
		}
		data->len -= 2;
		memmove(data->buf, data->buf + 2, data->len);
	}

	phpdbg_notice("Successful compilation of stdin input");

	return SUCCESS;
}

int phpdbg_compile(void) /* {{{ */
{
	zend_file_handle fh;
	char *buf;
	size_t len;

	if (!PHPDBG_G(exec)) {
		phpdbg_error("No execution context");
		return FAILURE;
	}

	zend_stream_init_filename(&fh, PHPDBG_G(exec));
	if (php_stream_open_for_zend_ex(&fh, USE_PATH|STREAM_OPEN_FOR_INCLUDE) == SUCCESS && zend_stream_fixup(&fh, &buf, &len) == SUCCESS) {
		CG(skip_shebang) = 1;
		PHPDBG_G(ops) = zend_compile_file(&fh, ZEND_INCLUDE);
		zend_destroy_file_handle(&fh);
		if (EG(exception)) {
			zend_exception_error(EG(exception), E_ERROR);
			zend_bailout();
		}

		phpdbg_notice("Successful compilation of %s", PHPDBG_G(exec));

		return SUCCESS;
	} else {
		phpdbg_error("Could not open file %s", PHPDBG_G(exec));
	}
	zend_destroy_file_handle(&fh);
	return FAILURE;
} /* }}} */

PHPDBG_COMMAND(step) /* {{{ */
{
	if (PHPDBG_G(in_execution)) {
		PHPDBG_G(flags) |= PHPDBG_IS_STEPPING;
	}

	return PHPDBG_NEXT;
} /* }}} */

PHPDBG_COMMAND(continue) /* {{{ */
{
	return PHPDBG_NEXT;
} /* }}} */

int phpdbg_skip_line_helper(void) /* {{{ */ {
	zend_execute_data *ex = phpdbg_user_execute_data(EG(current_execute_data));
	const zend_op_array *op_array = &ex->func->op_array;
	const zend_op *opline = op_array->opcodes;

	PHPDBG_G(flags) |= PHPDBG_IN_UNTIL;
	PHPDBG_G(seek_ex) = ex;
	do {
		if (opline->lineno != ex->opline->lineno
		 || opline->opcode == ZEND_RETURN
		 || opline->opcode == ZEND_FAST_RET
		 || opline->opcode == ZEND_GENERATOR_RETURN
		 || opline->opcode == ZEND_YIELD
		 || opline->opcode == ZEND_YIELD_FROM
		) {
			zend_hash_index_update_ptr(&PHPDBG_G(seek), (zend_ulong)(uintptr_t) opline, (void *) opline);
		}
	} while (++opline < op_array->opcodes + op_array->last);

	return PHPDBG_UNTIL;
}
/* }}} */

PHPDBG_COMMAND(until) /* {{{ */
{
	if (!PHPDBG_G(in_execution)) {
		phpdbg_error("Not executing");
		return SUCCESS;
	}

	return phpdbg_skip_line_helper();
} /* }}} */

PHPDBG_COMMAND(next) /* {{{ */
{
	if (!PHPDBG_G(in_execution)) {
		phpdbg_error("Not executing");
		return SUCCESS;
	}

	PHPDBG_G(flags) |= PHPDBG_IS_STEPPING;
	return phpdbg_skip_line_helper();
} /* }}} */

static void phpdbg_seek_to_end(void) /* {{{ */ {
	zend_execute_data *ex = phpdbg_user_execute_data(EG(current_execute_data));
	const zend_op_array *op_array = &ex->func->op_array;
	const zend_op *opline = op_array->opcodes;

	PHPDBG_G(seek_ex) = ex;
	do {
		switch (opline->opcode) {
			case ZEND_RETURN:
			case ZEND_FAST_RET:
			case ZEND_GENERATOR_RETURN:
			case ZEND_YIELD:
			case ZEND_YIELD_FROM:
				zend_hash_index_update_ptr(&PHPDBG_G(seek), (zend_ulong)(uintptr_t) opline, (void *) opline);
		}
	} while (++opline < op_array->opcodes + op_array->last);
}
/* }}} */

PHPDBG_COMMAND(finish) /* {{{ */
{
	if (!PHPDBG_G(in_execution)) {
		phpdbg_error("Not executing");
		return SUCCESS;
	}

	phpdbg_seek_to_end();
	if (zend_hash_index_exists(&PHPDBG_G(seek), (zend_ulong)(uintptr_t) phpdbg_user_execute_data(EG(current_execute_data))->opline)) {
		zend_hash_clean(&PHPDBG_G(seek));
	} else {
		PHPDBG_G(flags) |= PHPDBG_IN_FINISH;
	}

	return PHPDBG_FINISH;
} /* }}} */

PHPDBG_COMMAND(leave) /* {{{ */
{
	if (!PHPDBG_G(in_execution)) {
		phpdbg_error("Not executing");
		return SUCCESS;
	}

	phpdbg_seek_to_end();
	if (zend_hash_index_exists(&PHPDBG_G(seek), (zend_ulong)(uintptr_t) phpdbg_user_execute_data(EG(current_execute_data))->opline)) {
		zend_hash_clean(&PHPDBG_G(seek));
		phpdbg_notice("Already at the end of the function");
		return SUCCESS;
	} else {
		PHPDBG_G(flags) |= PHPDBG_IN_LEAVE;
		return PHPDBG_LEAVE;
	}
} /* }}} */

PHPDBG_COMMAND(frame) /* {{{ */
{
	if (!param) {
		phpdbg_notice("Currently in frame #%d", PHPDBG_G(frame).num);
	} else {
		phpdbg_switch_frame(param->num);
	}

	return SUCCESS;
} /* }}} */

static inline void phpdbg_handle_exception(void) /* {{{ */
{
	zend_object *ex = EG(exception);
	zend_string *msg, *file;
	zend_long line;
	zval rv, tmp;

	EG(exception) = NULL;

	zend_call_known_instance_method_with_0_params(ex->ce->__tostring, ex, &tmp);
	file = zval_get_string(zend_read_property_ex(zend_get_exception_base(ex), ex, ZSTR_KNOWN(ZEND_STR_FILE), /* silent */ true, &rv));
	line = zval_get_long(zend_read_property_ex(zend_get_exception_base(ex), ex, ZSTR_KNOWN(ZEND_STR_LINE), /* silent */ true, &rv));

	if (EG(exception)) {
		EG(exception) = NULL;
		msg = ZSTR_EMPTY_ALLOC();
	} else {
		if (UNEXPECTED(Z_ISREF(tmp))) {
			zend_unwrap_reference(&tmp);
		}
		ZEND_ASSERT(Z_TYPE(tmp) == IS_STRING);
		zend_update_property_string(zend_get_exception_base(ex), ex, ZEND_STRL("string"), Z_STRVAL(tmp));
		zval_ptr_dtor(&tmp);
		msg = zval_get_string(zend_read_property_ex(zend_get_exception_base(ex), ex, ZSTR_KNOWN(ZEND_STR_STRING), /* silent */ true, &rv));
	}

	phpdbg_error("Uncaught %s in %s on line " ZEND_LONG_FMT, ZSTR_VAL(ex->ce->name), ZSTR_VAL(file), line);
	zend_string_release(file);
	phpdbg_writeln("%s", ZSTR_VAL(msg));
	zend_string_release(msg);

	OBJ_RELEASE(ex);
	EG(opline_before_exception) = NULL;

	EG(exit_status) = 255;
} /* }}} */

PHPDBG_COMMAND(run) /* {{{ */
{
	if (PHPDBG_G(ops) || PHPDBG_G(exec)) {
		zend_execute_data *ex = EG(current_execute_data);
		bool restore = 1;

		if (PHPDBG_G(in_execution)) {
			if (phpdbg_ask_user_permission("Do you really want to restart execution?") == SUCCESS) {
				phpdbg_startup_run++;
				phpdbg_clean(1, 1);
			}
			return SUCCESS;
		}

		if (!PHPDBG_G(ops)) {
			if (phpdbg_compile() == FAILURE) {
				phpdbg_error("Failed to compile %s, cannot run", PHPDBG_G(exec));
				EG(exit_status) = FAILURE;
				goto out;
			}
		}

		if (param && param->type != EMPTY_PARAM && param->len != 0) {
			char **argv = emalloc(5 * sizeof(char *));
			char *end = param->str + param->len, *p = param->str;
			char last_byte;
			int argc = 0;
			int i;

			while (*end == '\r' || *end == '\n') *(end--) = 0;
			last_byte = end[1];
			end[1] = 0;

			while (*p == ' ') p++;
			while (*p) {
				char sep = ' ';
				char *buf = emalloc(end - p + 2), *q = buf;

				if (*p == '<') {
					/* use as STDIN */
					do p++; while (*p == ' ');

					if (*p == '\'' || *p == '"') {
						sep = *(p++);
					}
					while (*p && *p != sep) {
						if (*p == '\\' && (p[1] == sep || p[1] == '\\')) {
							p++;
						}
						*(q++) = *(p++);
					}
					*(q++) = 0;
					if (*p) {
						do p++; while (*p == ' ');
					}

					if (*p) {
						phpdbg_error("Invalid run command, cannot put further arguments after stdin");
						goto free_cmd;
					}

					PHPDBG_G(stdin_file) = fopen(buf, "r");
					if (PHPDBG_G(stdin_file) == NULL) {
						phpdbg_error("Could not open '%s' for reading from stdin", buf);
						goto free_cmd;
					}
					efree(buf);
					phpdbg_register_file_handles();
					break;
				}

				if (argc >= 4 && argc == (argc & -argc)) {
					argv = erealloc(argv, (argc * 2 + 1) * sizeof(char *));
				}

				if (*p == '\'' || *p == '"') {
					sep = *(p++);
				}
				if (*p == '\\' && (p[1] == '<' || p[1] == '\'' || p[1] == '"')) {
					p++;
				}
				while (*p && *p != sep) {
					if (*p == '\\' && (p[1] == sep || p[1] == '\\' || (p[1] == '#' && sep == ' '))) {
						p++;
					}
					*(q++) = *(p++);
				}
				if (!*p && sep != ' ') {
					phpdbg_error("Invalid run command, unterminated escape sequence");
free_cmd:
					efree(buf);
					for (i = 0; i < argc; i++) {
						efree(argv[i]);
					}
					efree(argv);
					end[1] = last_byte;
					return SUCCESS;
				}

				*(q++) = 0;
				argv[++argc] = erealloc(buf, q - buf);

				if (*p) {
					do p++; while (*p == ' ');
				}
			}
			end[1] = last_byte;

			argv[0] = SG(request_info).argv[0];
			for (i = SG(request_info).argc; --i;) {
				efree(SG(request_info).argv[i]);
			}
			efree(SG(request_info).argv);
			SG(request_info).argv = erealloc(argv, ++argc * sizeof(char *));
			SG(request_info).argc = argc;

			php_build_argv(NULL, &PG(http_globals)[TRACK_VARS_SERVER]);
		}

		/* clean up from last execution */
		if (ex && (ZEND_CALL_INFO(ex) & ZEND_CALL_HAS_SYMBOL_TABLE)) {
			zend_hash_clean(ex->symbol_table);
		} else {
			zend_rebuild_symbol_table();
		}
		PHPDBG_G(handled_exception) = NULL;

		/* clean seek state */
		PHPDBG_G(flags) &= ~PHPDBG_SEEK_MASK;
		zend_hash_clean(&PHPDBG_G(seek));

		/* reset hit counters */
		phpdbg_reset_breakpoints();

		zend_try {
			PHPDBG_G(flags) ^= PHPDBG_IS_INTERACTIVE;
			PHPDBG_G(flags) |= PHPDBG_IS_RUNNING;
			zend_execute(PHPDBG_G(ops), &PHPDBG_G(retval));
			PHPDBG_G(flags) ^= PHPDBG_IS_INTERACTIVE;
		} zend_catch {
			PHPDBG_G(in_execution) = 0;

			if (!(PHPDBG_G(flags) & PHPDBG_IS_STOPPING)) {
				restore = 0;
			} else {
				zend_bailout();
			}
		} zend_end_try();

		if (restore) {
			zend_try {
				zend_try_exception_handler();
				PHPDBG_G(in_execution) = 1;
			} zend_catch {
				PHPDBG_G(in_execution) = 0;

				if (PHPDBG_G(flags) & PHPDBG_IS_STOPPING) {
					zend_bailout();
				}
			} zend_end_try();

			if (EG(exception) && !zend_is_unwind_exit(EG(exception))) {
				phpdbg_handle_exception();
			}
		}

		PHPDBG_G(flags) &= ~PHPDBG_IS_RUNNING;

		phpdbg_clean(1, 0);
	} else {
		phpdbg_error("Nothing to execute!");
	}

out:
	PHPDBG_FRAME(num) = 0;
	return SUCCESS;
} /* }}} */

int phpdbg_output_ev_variable(char *name, size_t len, char *keyname, size_t keylen, HashTable *parent, zval *zv) /* {{{ */ {
	phpdbg_notice("Printing variable %.*s", (int) len, name);

	zend_print_zval_r(zv, 0);

	phpdbg_out("\n");

	efree(name);
	efree(keyname);

	return SUCCESS;
}
/* }}} */

PHPDBG_COMMAND(ev) /* {{{ */
{
	bool stepping = ((PHPDBG_G(flags) & PHPDBG_IS_STEPPING) == PHPDBG_IS_STEPPING);
	zval retval;

	zend_execute_data *original_execute_data = EG(current_execute_data);
	zend_vm_stack original_stack = EG(vm_stack);
	zend_object *ex = NULL;

	PHPDBG_OUTPUT_BACKUP();

	original_stack->top = EG(vm_stack_top);

	if (PHPDBG_G(flags) & PHPDBG_IN_SIGNAL_HANDLER) {
		phpdbg_try_access {
			phpdbg_parse_variable(param->str, param->len, &EG(symbol_table), 0, phpdbg_output_ev_variable, 0);
		} phpdbg_catch_access {
			phpdbg_error("Could not fetch data, invalid data source");
		} phpdbg_end_try_access();

		PHPDBG_OUTPUT_BACKUP_RESTORE();
		return SUCCESS;
	}

	if (!(PHPDBG_G(flags) & PHPDBG_IS_STEPONEVAL)) {
		PHPDBG_G(flags) &= ~PHPDBG_IS_STEPPING;
	}

	/* disable stepping while eval() in progress */
	PHPDBG_G(flags) |= PHPDBG_IN_EVAL;
	zend_try {
		if (zend_eval_stringl(param->str, param->len, &retval, "eval()'d code") == SUCCESS) {
			if (EG(exception)) {
				ex = EG(exception);
				zend_exception_error(EG(exception), E_ERROR);
			} else {
				zend_print_zval_r(&retval, 0);
				phpdbg_out("\n");
				zval_ptr_dtor(&retval);
			}
		}
	} zend_catch {
		PHPDBG_G(unclean_eval) = 1;
		if (ex) {
			OBJ_RELEASE(ex);
		}
		EG(current_execute_data) = original_execute_data;
		EG(vm_stack_top) = original_stack->top;
		EG(vm_stack_end) = original_stack->end;
		EG(vm_stack) = original_stack;
		EG(exit_status) = 0;
	} zend_end_try();

	PHPDBG_G(flags) &= ~PHPDBG_IN_EVAL;

	/* switch stepping back on */
	if (stepping && !(PHPDBG_G(flags) & PHPDBG_IS_STEPONEVAL)) {
		PHPDBG_G(flags) |= PHPDBG_IS_STEPPING;
	}

	CG(unclean_shutdown) = 0;

	PHPDBG_OUTPUT_BACKUP_RESTORE();

	return SUCCESS;
} /* }}} */

PHPDBG_COMMAND(back) /* {{{ */
{
	if (!PHPDBG_G(in_execution)) {
		phpdbg_error("Not executing!");
		return SUCCESS;
	}

	if (!param) {
		phpdbg_dump_backtrace(0);
	} else {
		phpdbg_dump_backtrace(param->num);
	}

	return SUCCESS;
} /* }}} */

PHPDBG_COMMAND(generator) /* {{{ */
{
	int i;

	if (!PHPDBG_G(in_execution)) {
		phpdbg_error("Not executing!");
		return SUCCESS;
	}

	if (param) {
		i = param->num;
		zend_object **obj = EG(objects_store).object_buckets + i;
		if (i < EG(objects_store).top && *obj && IS_OBJ_VALID(*obj) && (*obj)->ce == zend_ce_generator) {
			zend_generator *gen = (zend_generator *) *obj;
			if (gen->execute_data) {
				if (zend_generator_get_current(gen)->flags & ZEND_GENERATOR_CURRENTLY_RUNNING) {
					phpdbg_error("Generator currently running");
				} else {
					phpdbg_open_generator_frame(gen);
				}
			} else {
				phpdbg_error("Generator already closed");
			}
		} else {
			phpdbg_error("Invalid object handle");
		}
	} else {
		for (i = 0; i < EG(objects_store).top; i++) {
			zend_object *obj = EG(objects_store).object_buckets[i];
			if (obj && IS_OBJ_VALID(obj) && obj->ce == zend_ce_generator) {
				zend_generator *gen = (zend_generator *) obj, *current = zend_generator_get_current(gen);
				if (gen->execute_data) {
					zend_string *s = phpdbg_compile_stackframe(gen->execute_data);
					phpdbg_out("#%d: %.*s", i, (int) ZSTR_LEN(s), ZSTR_VAL(s));
					zend_string_release(s);
					if (gen != current) {
						if (gen->node.parent != current) {
							phpdbg_out(" with direct parent #%d and", gen->node.parent->std.handle);
						}
						phpdbg_out(" executing #%d currently", current->std.handle);
					}
					phpdbg_out("\n");
				}
			}
		}
	}

	return SUCCESS;
} /* }}} */

PHPDBG_COMMAND(print) /* {{{ */
{
	if (!param || param->type == EMPTY_PARAM) {
		return phpdbg_do_print_stack(param);
	} else switch (param->type) {
		case STR_PARAM:
			return phpdbg_do_print_func(param);
		case METHOD_PARAM:
			return phpdbg_do_print_method(param);
		default:
			phpdbg_error("Invalid arguments to print, expected nothing, function name or method name");
			return SUCCESS;
	}
} /* }}} */

PHPDBG_COMMAND(info) /* {{{ */
{
	phpdbg_out("Execution Context Information\n\n");
#ifdef HAVE_PHPDBG_READLINE
# ifdef HAVE_LIBREADLINE
	 phpdbg_writeln( "Readline   yes");
# else
	 phpdbg_writeln("Readline   no");
# endif
# ifdef HAVE_LIBEDIT
	 phpdbg_writeln("Libedit    yes");
# else
	 phpdbg_writeln("Libedit    no");
# endif
#else
	phpdbg_writeln("Readline   unavailable");
#endif

	phpdbg_writeln("Exec       %s", PHPDBG_G(exec) ? PHPDBG_G(exec) : "none");
	phpdbg_writeln("Compiled   %s", PHPDBG_G(ops) ? "yes" : "no");
	phpdbg_writeln("Stepping   %s", (PHPDBG_G(flags) & PHPDBG_IS_STEPPING) ? "on" : "off");
	phpdbg_writeln("Quietness  %s", (PHPDBG_G(flags) & PHPDBG_IS_QUIET) ? "on" : "off");

	if (PHPDBG_G(ops)) {
		phpdbg_writeln("Opcodes    %d", PHPDBG_G(ops)->last);
		phpdbg_writeln("Variables  %d", PHPDBG_G(ops)->last_var ? PHPDBG_G(ops)->last_var - 1 : 0);
	}

	phpdbg_writeln("Executing  %s", PHPDBG_G(in_execution) ? "yes" : "no");
	if (PHPDBG_G(in_execution)) {
		phpdbg_writeln("VM Return  %d", PHPDBG_G(vmret));
	}

	phpdbg_writeln("Classes    %d", zend_hash_num_elements(EG(class_table)));
	phpdbg_writeln("Functions  %d", zend_hash_num_elements(EG(function_table)));
	phpdbg_writeln("Constants  %d", zend_hash_num_elements(EG(zend_constants)));
	phpdbg_writeln("Included   %d", zend_hash_num_elements(&EG(included_files)));

	return SUCCESS;
} /* }}} */

PHPDBG_COMMAND(set) /* {{{ */
{
	phpdbg_error("No set command selected!");

	return SUCCESS;
} /* }}} */

PHPDBG_COMMAND(break) /* {{{ */
{
	if (!param) {
		if (PHPDBG_G(exec)) {
			phpdbg_set_breakpoint_file(
				zend_get_executed_filename(),
				strlen(zend_get_executed_filename()),
				zend_get_executed_lineno());
		} else {
			phpdbg_error("Execution context not set!");
		}
	} else switch (param->type) {
		case ADDR_PARAM:
			phpdbg_set_breakpoint_opline(param->addr);
			break;
		case NUMERIC_PARAM:
			if (PHPDBG_G(exec)) {
				phpdbg_set_breakpoint_file(phpdbg_current_file(), strlen(phpdbg_current_file()), param->num);
			} else {
				phpdbg_error("Execution context not set!");
			}
			break;
		case METHOD_PARAM:
			phpdbg_set_breakpoint_method(param->method.class, param->method.name);
			break;
		case NUMERIC_METHOD_PARAM:
			phpdbg_set_breakpoint_method_opline(param->method.class, param->method.name, param->num);
			break;
		case NUMERIC_FUNCTION_PARAM:
			phpdbg_set_breakpoint_function_opline(param->str, param->num);
			break;
		case FILE_PARAM:
			phpdbg_set_breakpoint_file(param->file.name, 0, param->file.line);
			break;
		case NUMERIC_FILE_PARAM:
			phpdbg_set_breakpoint_file_opline(param->file.name, param->file.line);
			break;
		case COND_PARAM:
			phpdbg_set_breakpoint_expression(param->str, param->len);
			break;
		case STR_PARAM:
			phpdbg_set_breakpoint_symbol(param->str, param->len);
			break;
		case OP_PARAM:
			phpdbg_set_breakpoint_opcode(param->str, param->len);
			break;

		phpdbg_default_switch_case();
	}

	return SUCCESS;
} /* }}} */

PHPDBG_COMMAND(sh) /* {{{ */
{
	FILE *fd = NULL;
	if ((fd=VCWD_POPEN((char*)param->str, "w"))) {
		/* TODO: do something perhaps ?? do we want input ?? */
		pclose(fd);
	} else {
		phpdbg_error("Failed to execute %s", param->str);
	}

	return SUCCESS;
} /* }}} */

static int add_module_info(zend_module_entry *module) /* {{{ */ {
	phpdbg_write("%s\n", module->name);
	return 0;
}
/* }}} */

static void add_zendext_info(zend_extension *ext) /* {{{ */ {
	phpdbg_write("%s\n", ext->name);
}
/* }}} */

#ifdef HAVE_LIBDL
static const char *phpdbg_load_module_or_extension(zend_string **path, const char **name) /* {{{ */ {
	DL_HANDLE handle;
	const zend_string *extension_dir = zend_ini_str_literal("extension_dir");

	if (UNEXPECTED(zend_str_has_nul_byte(extension_dir))) {
		phpdbg_error("extension_dir ini setting contains a nul byte");
		return NULL;
	}
	if (memchr(ZSTR_VAL(*path), '/', ZSTR_LEN(*path)) != NULL || memchr(ZSTR_VAL(*path), '/', ZSTR_LEN(*path)) != NULL) {
		/* path is fine */
	} else if (extension_dir && ZSTR_LEN(extension_dir) > 0) {
		zend_string *libpath;
		if (IS_SLASH(ZSTR_VAL(extension_dir)[ZSTR_LEN(extension_dir)-1])) {
			libpath = zend_string_concat2(
				ZSTR_VAL(extension_dir), ZSTR_LEN(extension_dir),
				ZSTR_VAL(*path), ZSTR_LEN(*path)
			);
		} else {
			libpath = zend_string_concat3(
				ZSTR_VAL(extension_dir), ZSTR_LEN(extension_dir),
				"/", 1,
				ZSTR_VAL(*path), ZSTR_LEN(*path)
			);
		}
		zend_string_release_ex(*path, false);
		*path = libpath;
	} else {
		phpdbg_error("Not a full path given or extension_dir ini setting is not set");

		return NULL;
	}

	handle = DL_LOAD(ZSTR_VAL(*path));

	if (!handle) {
#ifdef PHP_WIN32
		char *err = GET_DL_ERROR();
		if (err && err[0]) {
			phpdbg_error("%s", err);
			php_win32_error_msg_free(err);
		} else {
			phpdbg_error("Unknown reason");
		}
#else
		phpdbg_error("%s", GET_DL_ERROR());
#endif
		return NULL;
	}

#if ZEND_EXTENSIONS_SUPPORT
	do {
		zend_extension *new_extension;

		const zend_extension_version_info *extension_version_info = (const zend_extension_version_info *) DL_FETCH_SYMBOL(handle, "extension_version_info");
		if (!extension_version_info) {
			extension_version_info = (const zend_extension_version_info *) DL_FETCH_SYMBOL(handle, "_extension_version_info");
		}
		new_extension = (zend_extension *) DL_FETCH_SYMBOL(handle, "zend_extension_entry");
		if (!new_extension) {
			new_extension = (zend_extension *) DL_FETCH_SYMBOL(handle, "_zend_extension_entry");
		}
		if (!extension_version_info || !new_extension) {
			break;
		}
		if (extension_version_info->zend_extension_api_no != ZEND_EXTENSION_API_NO &&(!new_extension->api_no_check || new_extension->api_no_check(ZEND_EXTENSION_API_NO) != SUCCESS)) {
			phpdbg_error("%s requires Zend Engine API version %d, which does not match the installed Zend Engine API version %d", new_extension->name, extension_version_info->zend_extension_api_no, ZEND_EXTENSION_API_NO);

			goto quit;
		} else if (strcmp(ZEND_EXTENSION_BUILD_ID, extension_version_info->build_id) && (!new_extension->build_id_check || new_extension->build_id_check(ZEND_EXTENSION_BUILD_ID) != SUCCESS)) {
			phpdbg_error("%s was built with configuration %s, whereas running engine is %s", new_extension->name, extension_version_info->build_id, ZEND_EXTENSION_BUILD_ID);

			goto quit;
		}

		*name = new_extension->name;

		zend_register_extension(new_extension, handle);

		if (new_extension->startup) {
			if (new_extension->startup(new_extension) != SUCCESS) {
				phpdbg_error("Unable to startup Zend extension %s", new_extension->name);

				goto quit;
			}
			zend_append_version_info(new_extension);
		}

		return "Zend extension";
	} while (0);
#endif

	do {
		zend_module_entry *module_entry;
		zend_module_entry *(*get_module)(void);

		get_module = (zend_module_entry *(*)(void)) DL_FETCH_SYMBOL(handle, "get_module");
		if (!get_module) {
			get_module = (zend_module_entry *(*)(void)) DL_FETCH_SYMBOL(handle, "_get_module");
		}

		if (!get_module) {
			break;
		}

		module_entry = get_module();
		*name = module_entry->name;

		if (strcmp(ZEND_EXTENSION_BUILD_ID, module_entry->build_id)) {
			phpdbg_error("%s was built with configuration %s, whereas running engine is %s", module_entry->name, module_entry->build_id, ZEND_EXTENSION_BUILD_ID);

			goto quit;
		}

		if ((module_entry = zend_register_module_ex(module_entry, MODULE_PERSISTENT)) == NULL) {
			phpdbg_error("Unable to register module %s", *name);

			goto quit;
		}

		module_entry->handle = handle;

		if (zend_startup_module_ex(module_entry) == FAILURE) {
			phpdbg_error("Unable to startup module %s", module_entry->name);

			goto quit;
		}

		if (module_entry->request_startup_func) {
			if (module_entry->request_startup_func(MODULE_PERSISTENT, module_entry->module_number) == FAILURE) {
				phpdbg_error("Unable to initialize module %s", module_entry->name);

				goto quit;
			}
		}

		return "module";
	} while (0);

	phpdbg_error("This shared object is nor a Zend extension nor a module");

quit:
	DL_UNLOAD(handle);
	return NULL;
}
/* }}} */
#endif

PHPDBG_COMMAND(dl) /* {{{ */
{
	const char *type, *name;

	if (!param || param->type == EMPTY_PARAM) {
		phpdbg_notice("Zend extensions");
		zend_llist_apply(&zend_extensions, (llist_apply_func_t) add_zendext_info);
		phpdbg_out("\n");
		phpdbg_notice("Modules");
		zend_hash_apply(&module_registry, (apply_func_t) add_module_info);
	} else switch (param->type) {
		case STR_PARAM: {
#ifdef HAVE_LIBDL
			zend_string *path = zend_string_init(param->str, param->len, false);

			phpdbg_activate_err_buf(1);
			if ((type = phpdbg_load_module_or_extension(&path, &name)) == NULL) {
				phpdbg_error("Could not load %s, not found or invalid zend extension / module: %s", ZSTR_VAL(path), PHPDBG_G(err_buf).msg);
			} else {
				phpdbg_notice("Successfully loaded the %s %s at path %s", type, name, ZSTR_VAL(path));
			}
			phpdbg_activate_err_buf(0);
			phpdbg_free_err_buf();
			zend_string_release_ex(path, false);
#else
			phpdbg_error("Cannot dynamically load %.*s - dynamic modules are not supported", (int) param->len, param->str);
#endif
			break;
		}

		phpdbg_default_switch_case();
	}

	return SUCCESS;
} /* }}} */

PHPDBG_COMMAND(source) /* {{{ */
{
	zend_stat_t sb = {0};

	if (VCWD_STAT(param->str, &sb) != -1) {
		phpdbg_try_file_init(param->str, param->len, 0);
	} else {
		phpdbg_error("Failed to stat %s, file does not exist", param->str);
	}

	return SUCCESS;
} /* }}} */

PHPDBG_COMMAND(export) /* {{{ */
{
	FILE *handle = VCWD_FOPEN(param->str, "w+");

	if (handle) {
		phpdbg_export_breakpoints(handle);
		fclose(handle);
	} else {
		phpdbg_error("Failed to open or create %s, check path and permissions", param->str);
	}

	return SUCCESS;
} /* }}} */

PHPDBG_COMMAND(register) /* {{{ */
{
	zend_function *function;
	char *lcname = zend_str_tolower_dup(param->str, param->len);
	size_t lcname_len = param->len;

	if (!zend_hash_str_exists(&PHPDBG_G(registered), lcname, lcname_len)) {
		if ((function = zend_hash_str_find_ptr(EG(function_table), lcname, lcname_len))) {
			zend_hash_str_update_ptr(&PHPDBG_G(registered), lcname, lcname_len, function);

			phpdbg_notice("Registered %s", lcname);
		} else {
			phpdbg_error("The requested function (%s) could not be found", param->str);
		}
	} else {
		phpdbg_error("The requested name (%s) is already in use", lcname);
	}

	efree(lcname);
	return SUCCESS;
} /* }}} */

PHPDBG_COMMAND(quit) /* {{{ */
{
	PHPDBG_G(flags) |= PHPDBG_IS_QUITTING;
	PHPDBG_G(flags) &= ~PHPDBG_IS_CLEANING;

	return SUCCESS;
} /* }}} */

PHPDBG_COMMAND(clean) /* {{{ */
{
	if (PHPDBG_G(in_execution)) {
		if (phpdbg_ask_user_permission("Do you really want to clean your current environment?") == FAILURE) {
			return SUCCESS;
		}
	}

	phpdbg_out("Cleaning Execution Environment\n");

	phpdbg_writeln("Classes    %d", zend_hash_num_elements(EG(class_table)));
	phpdbg_writeln("Functions  %d", zend_hash_num_elements(EG(function_table)));
	phpdbg_writeln("Constants  %d", zend_hash_num_elements(EG(zend_constants)));
	phpdbg_writeln("Includes   %d", zend_hash_num_elements(&EG(included_files)));

	phpdbg_clean(1, 0);

	return SUCCESS;
} /* }}} */

PHPDBG_COMMAND(clear) /* {{{ */
{
	phpdbg_out("Clearing Breakpoints\n");

	phpdbg_writeln("File              %d", zend_hash_num_elements(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE]));
	phpdbg_writeln("Functions         %d", zend_hash_num_elements(&PHPDBG_G(bp)[PHPDBG_BREAK_SYM]));
	phpdbg_writeln("Methods           %d", zend_hash_num_elements(&PHPDBG_G(bp)[PHPDBG_BREAK_METHOD]));
	phpdbg_writeln("Oplines           %d", zend_hash_num_elements(&PHPDBG_G(bp)[PHPDBG_BREAK_OPLINE]));
	phpdbg_writeln("File oplines      %d", zend_hash_num_elements(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE_OPLINE]));
	phpdbg_writeln("Function oplines  %d", zend_hash_num_elements(&PHPDBG_G(bp)[PHPDBG_BREAK_FUNCTION_OPLINE]));
	phpdbg_writeln("Method oplines    %d", zend_hash_num_elements(&PHPDBG_G(bp)[PHPDBG_BREAK_METHOD_OPLINE]));
	phpdbg_writeln("Conditionals      %d", zend_hash_num_elements(&PHPDBG_G(bp)[PHPDBG_BREAK_COND]));

	phpdbg_clear_breakpoints();

	return SUCCESS;
} /* }}} */

PHPDBG_COMMAND(list) /* {{{ */
{
	if (!param) {
		return PHPDBG_LIST_HANDLER(lines)(PHPDBG_COMMAND_ARGS);
	} else switch (param->type) {
		case NUMERIC_PARAM:
			return PHPDBG_LIST_HANDLER(lines)(PHPDBG_COMMAND_ARGS);

		case FILE_PARAM:
			return PHPDBG_LIST_HANDLER(lines)(PHPDBG_COMMAND_ARGS);

		case STR_PARAM:
			phpdbg_list_function_byname(param->str, param->len);
			break;

		case METHOD_PARAM:
			return PHPDBG_LIST_HANDLER(method)(PHPDBG_COMMAND_ARGS);

		phpdbg_default_switch_case();
	}

	return SUCCESS;
} /* }}} */

PHPDBG_COMMAND(watch) /* {{{ */
{
	if (!param || param->type == EMPTY_PARAM) {
		phpdbg_list_watchpoints();
	} else switch (param->type) {
		case STR_PARAM:
			phpdbg_create_var_watchpoint(param->str, param->len);
			break;

		phpdbg_default_switch_case();
	}

	return SUCCESS;
} /* }}} */

int phpdbg_interactive(bool allow_async_unsafe, char *input) /* {{{ */
{
	int ret = SUCCESS;
	phpdbg_param_t stack;

	PHPDBG_G(flags) |= PHPDBG_IS_INTERACTIVE;

	while (ret == SUCCESS || ret == FAILURE) {
		if (PHPDBG_G(flags) & PHPDBG_IS_STOPPING) {
			zend_bailout();
		}

		if (!input && !(input = phpdbg_read_input(NULL))) {
			break;
		}


		phpdbg_init_param(&stack, STACK_PARAM);

		if (phpdbg_do_parse(&stack, input) <= 0) {
			phpdbg_activate_err_buf(1);

			zend_try {
				ret = phpdbg_stack_execute(&stack, allow_async_unsafe);
			} zend_catch {
				phpdbg_stack_free(&stack);
				phpdbg_destroy_input(&input);
				/* TODO: should use proper unwinding instead of bailing out */
				zend_bailout();
			} zend_end_try();

			switch (ret) {
				case FAILURE:
					if (!(PHPDBG_G(flags) & PHPDBG_IS_STOPPING)) {
						if (!allow_async_unsafe || phpdbg_call_register(&stack) == FAILURE) {
							if (PHPDBG_G(err_buf).active) {
							    phpdbg_output_err_buf("%s", PHPDBG_G(err_buf).msg);
							}
						}
					}
				break;

				case PHPDBG_LEAVE:
				case PHPDBG_FINISH:
				case PHPDBG_UNTIL:
				case PHPDBG_NEXT: {
					phpdbg_activate_err_buf(0);
					phpdbg_free_err_buf();
					if (!PHPDBG_G(in_execution) && !(PHPDBG_G(flags) & PHPDBG_IS_STOPPING)) {
						phpdbg_error("Not running");
					}
					break;
				}
			}

			phpdbg_activate_err_buf(0);
			phpdbg_free_err_buf();
		}

		phpdbg_stack_free(&stack);
		phpdbg_destroy_input(&input);
		PHPDBG_G(req_id) = 0;
		input = NULL;
	}

	if (input) {
		phpdbg_stack_free(&stack);
		phpdbg_destroy_input(&input);
		PHPDBG_G(req_id) = 0;
	}

	if (PHPDBG_G(in_execution)) {
		phpdbg_restore_frame();
	}

	PHPDBG_G(flags) &= ~PHPDBG_IS_INTERACTIVE;

	phpdbg_print_changed_zvals();

	return ret;
} /* }}} */

static inline void list_code(void) {
	if (!(PHPDBG_G(flags) & PHPDBG_IN_EVAL)) {
		const char *file_char = zend_get_executed_filename();
		zend_string *file = zend_string_init(file_char, strlen(file_char), 0);
		phpdbg_list_file(file, 3, zend_get_executed_lineno()-1, zend_get_executed_lineno());
		efree(file);
	}
}

/* code may behave weirdly if EG(exception) is set; thus backup it */
#define DO_INTERACTIVE(allow_async_unsafe) do { \
	if (exception) { \
		const zend_op *before_ex = EG(opline_before_exception); \
		const zend_op *backup_opline = NULL; \
		if (EG(current_execute_data) && EG(current_execute_data)->func && ZEND_USER_CODE(EG(current_execute_data)->func->common.type)) { \
			backup_opline = EG(current_execute_data)->opline; \
		} \
		GC_ADDREF(exception); \
		zend_clear_exception(); \
		list_code(); \
		switch (phpdbg_interactive(allow_async_unsafe, NULL)) { \
			case PHPDBG_LEAVE: \
			case PHPDBG_FINISH: \
			case PHPDBG_UNTIL: \
			case PHPDBG_NEXT: \
				if (backup_opline \
				 && (backup_opline->opcode == ZEND_HANDLE_EXCEPTION || backup_opline->opcode == ZEND_CATCH)) { \
					EG(current_execute_data)->opline = backup_opline; \
					EG(exception) = exception; \
				} else { \
					zend_throw_exception_internal(exception); \
				} \
				EG(opline_before_exception) = before_ex; \
		} \
	} else { \
		list_code(); \
		phpdbg_interactive(allow_async_unsafe, NULL); \
	} \
	goto next; \
} while (0)

void phpdbg_execute_ex(zend_execute_data *execute_data) /* {{{ */
{
	bool original_in_execution = PHPDBG_G(in_execution);

	if ((PHPDBG_G(flags) & PHPDBG_IS_STOPPING) && !(PHPDBG_G(flags) & PHPDBG_IS_RUNNING)) {
		zend_bailout();
	}

	PHPDBG_G(in_execution) = 1;

#ifdef ZEND_CHECK_STACK_LIMIT
	if (UNEXPECTED(zend_call_stack_overflowed(EG(stack_limit)))) {
		zend_call_stack_size_error();
		/* No opline was executed before exception */
		EG(opline_before_exception) = NULL;
		/* Fall through to handle exception below. */
	}
#endif /* ZEND_CHECK_STACK_LIMIT */

	while (1) {
		zend_object *exception = EG(exception);

		if ((PHPDBG_G(flags) & PHPDBG_BP_RESOLVE_MASK)) {
			/* resolve nth opline breakpoints */
			phpdbg_resolve_op_array_breaks(&execute_data->func->op_array);
		}

#ifdef ZEND_WIN32
		if (zend_atomic_bool_load_ex(&EG(timed_out))) {
			zend_timeout();
		}
#endif

		if (exception && zend_is_unwind_exit(exception)) {
			/* Restore bailout based exit. */
			zend_bailout();
		}

		if (PHPDBG_G(flags) & PHPDBG_PREVENT_INTERACTIVE) {
			phpdbg_print_opline(execute_data, 0);
			goto next;
		}

		/* check for uncaught exceptions */
		if (exception && PHPDBG_G(handled_exception) != exception && !(PHPDBG_G(flags) & PHPDBG_IN_EVAL)) {
			zend_execute_data *prev_ex = execute_data;

			do {
				prev_ex = zend_generator_check_placeholder_frame(prev_ex);
				/* assuming that no internal functions will silently swallow exceptions ... */
				if (!prev_ex->func || !ZEND_USER_CODE(prev_ex->func->common.type)) {
					continue;
				}

				if (phpdbg_check_caught_ex(prev_ex, exception)) {
					goto ex_is_caught;
				}
			} while ((prev_ex = prev_ex->prev_execute_data));

			PHPDBG_G(handled_exception) = exception;

			zval rv;
			zend_string *file = zval_get_string(zend_read_property_ex(zend_get_exception_base(exception), exception, ZSTR_KNOWN(ZEND_STR_FILE), /* silent */ true, &rv));
			zend_long line = zval_get_long(zend_read_property_ex(zend_get_exception_base(exception), exception, ZSTR_KNOWN(ZEND_STR_LINE), /* silent */ true, &rv));
			zend_string *msg = zval_get_string(zend_read_property_ex(zend_get_exception_base(exception), exception, ZSTR_KNOWN(ZEND_STR_MESSAGE), /* silent */ true, &rv));

			phpdbg_error("Uncaught %s in %s on line " ZEND_LONG_FMT ": %.*s",
				ZSTR_VAL(exception->ce->name), ZSTR_VAL(file), line,
				ZSTR_LEN(msg) < 80 ? (int) ZSTR_LEN(msg) : 80, ZSTR_VAL(msg));
			zend_string_release(msg);
			zend_string_release(file);

			DO_INTERACTIVE(1);
		}
ex_is_caught:

		/* allow conditional breakpoints and initialization to access the vm uninterrupted */
		if (PHPDBG_G(flags) & (PHPDBG_IN_COND_BP | PHPDBG_IS_INITIALIZING)) {
			/* skip possible breakpoints */
			goto next;
		}

		/* not while in conditionals */
		phpdbg_print_opline(execute_data, 0);

		/* perform seek operation */
		if ((PHPDBG_G(flags) & PHPDBG_SEEK_MASK) && !(PHPDBG_G(flags) & PHPDBG_IN_EVAL)) {
			/* current address */
			zend_ulong address = (zend_ulong) execute_data->opline;

			if (PHPDBG_G(seek_ex) != execute_data) {
				if (PHPDBG_G(flags) & PHPDBG_IS_STEPPING) {
					goto stepping;
				}
				goto next;
			}

#define INDEX_EXISTS_CHECK (zend_hash_index_exists(&PHPDBG_G(seek), address) || (exception && phpdbg_check_caught_ex(execute_data, exception) == 0))

			/* run to next line */
			if (PHPDBG_G(flags) & PHPDBG_IN_UNTIL) {
				if (INDEX_EXISTS_CHECK) {
					PHPDBG_G(flags) &= ~PHPDBG_IN_UNTIL;
					zend_hash_clean(&PHPDBG_G(seek));
				} else {
					/* skip possible breakpoints */
					goto next;
				}
			}

			/* run to finish */
			if (PHPDBG_G(flags) & PHPDBG_IN_FINISH) {
				if (INDEX_EXISTS_CHECK) {
					PHPDBG_G(flags) &= ~PHPDBG_IN_FINISH;
					zend_hash_clean(&PHPDBG_G(seek));
				}
				/* skip possible breakpoints */
				goto next;
			}

			/* break for leave */
			if (PHPDBG_G(flags) & PHPDBG_IN_LEAVE) {
				if (INDEX_EXISTS_CHECK) {
					PHPDBG_G(flags) &= ~PHPDBG_IN_LEAVE;
					zend_hash_clean(&PHPDBG_G(seek));
					phpdbg_notice("Breaking for leave at %s:%u",
						zend_get_executed_filename(),
						zend_get_executed_lineno()
					);
					DO_INTERACTIVE(1);
				} else {
					/* skip possible breakpoints */
					goto next;
				}
			}
		}

		if (PHPDBG_G(flags) & PHPDBG_IS_STEPPING && (PHPDBG_G(flags) & PHPDBG_STEP_OPCODE || execute_data->opline->lineno != PHPDBG_G(last_line))) {
stepping:
			PHPDBG_G(flags) &= ~PHPDBG_IS_STEPPING;
			DO_INTERACTIVE(1);
		}

		/* check if some watchpoint was hit */
		{
			if (phpdbg_print_changed_zvals() == SUCCESS) {
				DO_INTERACTIVE(1);
			}
		}

		/* search for breakpoints */
		{
			phpdbg_breakbase_t *brake;

			if ((PHPDBG_G(flags) & PHPDBG_BP_MASK)
			    && (brake = phpdbg_find_breakpoint(execute_data))
			    && (brake->type != PHPDBG_BREAK_FILE || execute_data->opline->lineno != PHPDBG_G(last_line))) {
				phpdbg_hit_breakpoint(brake, 1);
				DO_INTERACTIVE(1);
			}
		}

		if (PHPDBG_G(flags) & PHPDBG_IS_SIGNALED) {
			PHPDBG_G(flags) &= ~PHPDBG_IS_SIGNALED;

			phpdbg_out("\n");
			phpdbg_notice("Program received signal SIGINT");
			DO_INTERACTIVE(1);
		}

next:

		PHPDBG_G(last_line) = execute_data->opline->lineno;

		/* stupid hack to make zend_do_fcall_common_helper return ZEND_VM_ENTER() instead of recursively calling zend_execute() and eventually segfaulting */
		if ((execute_data->opline->opcode == ZEND_DO_FCALL ||
		     execute_data->opline->opcode == ZEND_DO_UCALL ||
		     execute_data->opline->opcode == ZEND_DO_FCALL_BY_NAME) &&
		     execute_data->call->func->type == ZEND_USER_FUNCTION) {
			zend_execute_ex = execute_ex;
		}
		PHPDBG_G(vmret) = zend_vm_call_opcode_handler(execute_data);
		zend_execute_ex = phpdbg_execute_ex;

		if (PHPDBG_G(vmret) != 0) {
			if (PHPDBG_G(vmret) < 0) {
				PHPDBG_G(in_execution) = original_in_execution;
				return;
			} else {
				execute_data = EG(current_execute_data);
			}
		}
	}
	zend_error_noreturn(E_ERROR, "Arrived at end of main loop which shouldn't happen");
} /* }}} */

/* only if *not* interactive and while executing */
void phpdbg_force_interruption(void) /* {{{ */ {
	zend_object *exception = EG(exception);
	zend_execute_data *data = EG(current_execute_data); /* should be always readable if not NULL */

	PHPDBG_G(flags) |= PHPDBG_IN_SIGNAL_HANDLER;

	if (data) {
		if (data->func) {
			if (ZEND_USER_CODE(data->func->type)) {
				phpdbg_notice("Current opline: %p (op #%u) in %s:%u",
				    data->opline,
				    (uint32_t) (data->opline - data->func->op_array.opcodes),
				    data->func->op_array.filename->val,
				    data->opline->lineno);
			} else if (data->func->internal_function.function_name) {
				phpdbg_notice("Current opline: in internal function %s",
				    data->func->internal_function.function_name->val);
			} else {
				phpdbg_notice("Current opline: executing internal code");
			}
		} else {
			phpdbg_notice("Current opline: %p (op_array information unavailable)",
			    data->opline);
		}
	} else {
		phpdbg_notice("No information available about executing context");
	}

	DO_INTERACTIVE(0);

next:
	PHPDBG_G(flags) &= ~PHPDBG_IN_SIGNAL_HANDLER;

	if (PHPDBG_G(flags) & PHPDBG_IS_STOPPING) {
		zend_bailout();
	}
}
/* }}} */
