Revert phpdbg changes for PHP-5.6.3

55 files changed, 2829 insertions, 8235 deletions

diff --git a/sapi/phpdbg/.travis.yml b/sapi/phpdbg/.travis.yml
index 2e777fbe13..d5b492e7cf 100644
--- a/sapi/phpdbg/.travis.yml
+++ b/sapi/phpdbg/.travis.yml
@@ -4,6 +4,7 @@ env:
 - PHP="PHP-5.4"
 - PHP="PHP-5.5"
 - PHP="PHP-5.6"
+- PHP="master"
 
 before_script: ./travis/ci.sh
 
diff --git a/sapi/phpdbg/README.md b/sapi/phpdbg/README.md
index a2a84deb7b..e7e5c731a8 100644
--- a/sapi/phpdbg/README.md
+++ b/sapi/phpdbg/README.md
@@ -1,7 +1,7 @@
 The interactive PHP debugger
 ============================
 
-Implemented as a SAPI module, phpdbg can exert complete control over the environment without impacting the functionality or performance of your code.
+Implemented as a SAPI module, phpdbg can excert complete control over the environment without impacting the functionality or performance of your code.
 
 phpdbg aims to be a lightweight, powerful, easy to use debugging platform for PHP 5.4+
 
diff --git a/sapi/phpdbg/config.m4 b/sapi/phpdbg/config.m4
index 87d38ea8c5..d78a439af0 100644
--- a/sapi/phpdbg/config.m4
+++ b/sapi/phpdbg/config.m4
@@ -3,15 +3,12 @@ dnl $Id$
 dnl
 
 PHP_ARG_ENABLE(phpdbg, for phpdbg support,
-[  --enable-phpdbg            Build phpdbg], no, no)
-
-PHP_ARG_ENABLE(phpdbg-webhelper, for phpdbg web SAPI support,
-[  --enable-phpdbg-webhelper  Build phpdbg web SAPI support], yes, yes)
+[  --enable-phpdbg         Build phpdbg], no, no)
 
 PHP_ARG_ENABLE(phpdbg-debug, for phpdbg debug build,
-[  --enable-phpdbg-debug      Build phpdbg in debug mode], no, no)
+[  --enable-phpdbg-debug   Build phpdbg in debug mode], no, no)
 
-if test "$BUILD_PHPDBG" == "" && test "$PHP_PHPDBG" != "no"; then
+if test "$PHP_PHPDBG" != "no"; then
   AC_HEADER_TIOCGWINSZ
   AC_DEFINE(HAVE_PHPDBG, 1, [ ])
 
@@ -21,15 +18,8 @@ if test "$BUILD_PHPDBG" == "" && test "$PHP_PHPDBG" != "no"; then
     AC_DEFINE(PHPDBG_DEBUG, 0, [ ])
   fi
 
-  if test "$PHP_PHPDBG_WEBHELPER" != "no"; then
-    if ! test -d $abs_srcdir/ext/phpdbg_webhelper; then
-      ln -s ../sapi/phpdbg $abs_srcdir/ext/phpdbg_webhelper
-    fi
-    PHP_NEW_EXTENSION(phpdbg_webhelper, phpdbg_rinit_hook.c phpdbg_webdata_transfer.c, $ext_shared)
-  fi
-
   PHP_PHPDBG_CFLAGS="-D_GNU_SOURCE"
-  PHP_PHPDBG_FILES="phpdbg.c phpdbg_parser.c phpdbg_lexer.c phpdbg_prompt.c phpdbg_help.c phpdbg_break.c phpdbg_print.c phpdbg_bp.c phpdbg_opcode.c phpdbg_list.c phpdbg_utils.c phpdbg_info.c phpdbg_cmd.c phpdbg_set.c phpdbg_frame.c phpdbg_watch.c phpdbg_btree.c phpdbg_sigsafe.c phpdbg_wait.c phpdbg_io.c phpdbg_eol.c phpdbg_out.c"
+  PHP_PHPDBG_FILES="phpdbg.c phpdbg_parser.c phpdbg_lexer.c phpdbg_prompt.c phpdbg_help.c phpdbg_break.c phpdbg_print.c phpdbg_bp.c phpdbg_opcode.c phpdbg_list.c phpdbg_utils.c phpdbg_info.c phpdbg_cmd.c phpdbg_set.c phpdbg_frame.c phpdbg_watch.c phpdbg_btree.c"
 
   if test "$PHP_READLINE" != "no" -o  "$PHP_LIBEDIT" != "no"; then
   	PHPDBG_EXTRA_LIBS="$PHP_READLINE_LIBS"
diff --git a/sapi/phpdbg/config.w32 b/sapi/phpdbg/config.w32
index 8a685d3347..17e15b6ced 100644
--- a/sapi/phpdbg/config.w32
+++ b/sapi/phpdbg/config.w32
@@ -1,12 +1,7 @@
 ARG_ENABLE('phpdbg', 'Build phpdbg', 'no');
 ARG_ENABLE('phpdbgs', 'Build phpdbg shared', 'no');
-ARG_ENABLE('phpdbg-webhelper', 'Build phpdbg webhelper', 'yes');
 
-PHPDBG_SOURCES='phpdbg.c phpdbg_prompt.c phpdbg_cmd.c phpdbg_info.c phpdbg_help.c phpdbg_break.c ' +
-		'phpdbg_print.c phpdbg_bp.c phpdbg_opcode.c phpdbg_list.c phpdbg_utils.c ' +
-		'phpdbg_set.c phpdbg_frame.c phpdbg_watch.c phpdbg_win.c phpdbg_btree.c '+
-		'phpdbg_parser.c phpdbg_lexer.c phpdbg_sigsafe.c phpdbg_wait.c phpdbg_io.c ' +
-		'phpdbg_sigio_win32.c phpdbg_eol.c phpdbg_out.c';
+PHPDBG_SOURCES='phpdbg.c phpdbg_prompt.c phpdbg_cmd.c phpdbg_info.c phpdbg_help.c phpdbg_break.c phpdbg_print.c phpdbg_bp.c phpdbg_opcode.c phpdbg_list.c phpdbg_utils.c phpdbg_set.c phpdbg_frame.c phpdbg_watch.c phpdbg_win.c phpdbg_btree.c phpdbg_parser.c phpdbg_lexer.c';
 PHPDBG_DLL='php' + PHP_VERSION + 'phpdbg.dll';
 PHPDBG_EXE='phpdbg.exe';
 
@@ -14,11 +9,6 @@ if (PHP_PHPDBG == "yes") {
 	SAPI('phpdbg', PHPDBG_SOURCES, PHPDBG_EXE);
 	ADD_FLAG("LIBS_PHPDBG", "ws2_32.lib user32.lib");
 	ADD_FLAG("CFLAGS_PHPDBG", "/D YY_NO_UNISTD_H");
-	ADD_FLAG("LDFLAGS_PHPDBG", "/stack:8388608");
-
-	if (PHP_PHPDBG_WEBHELPER == "yes") {
-		EXTENSION('phpdbg_webhelper', 'phpdbg_rinit_hook.c phpdbg_webdata_transfer.c');
-	}
 }
 
 if (PHP_PHPDBGS == "yes") {
diff --git a/sapi/phpdbg/phpdbg.c b/sapi/phpdbg/phpdbg.c
index 7ca7997297..c881559e6e 100644
--- a/sapi/phpdbg/phpdbg.c
+++ b/sapi/phpdbg/phpdbg.c
@@ -28,9 +28,7 @@
 #include "phpdbg_list.h"
 #include "phpdbg_utils.h"
 #include "phpdbg_set.h"
-#include "phpdbg_io.h"
 #include "zend_alloc.h"
-#include "phpdbg_eol.h"
 
 /* {{{ remote console headers */
 #ifndef _WIN32
@@ -38,28 +36,12 @@
 #	include <sys/select.h>
 #	include <sys/time.h>
 #	include <sys/types.h>
-#	include <sys/poll.h>
 #	include <netinet/in.h>
 #	include <unistd.h>
 #	include <arpa/inet.h>
 #endif /* }}} */
 
 ZEND_DECLARE_MODULE_GLOBALS(phpdbg);
-int phpdbg_startup_run = 0;
-
-static PHP_INI_MH(OnUpdateEol)
-{
-	if (!new_value) {
-		return FAILURE;
-	}
-
-	return phpdbg_eol_global_update(new_value TSRMLS_CC);
-}
-
-PHP_INI_BEGIN()
-	STD_PHP_INI_ENTRY("phpdbg.path", "", PHP_INI_SYSTEM | PHP_INI_PERDIR, OnUpdateString, socket_path, zend_phpdbg_globals, phpdbg_globals)
-	STD_PHP_INI_ENTRY("phpdbg.eol", "2", PHP_INI_ALL, OnUpdateEol, socket_path, zend_phpdbg_globals, phpdbg_globals)
-PHP_INI_END()
 
 static zend_bool phpdbg_booted = 0;
 
@@ -81,39 +63,20 @@ static inline void php_phpdbg_globals_ctor(zend_phpdbg_globals *pg) /* {{{ */
 	pg->exec = NULL;
 	pg->exec_len = 0;
 	pg->buffer = NULL;
-	pg->last_was_newline = 1;
 	pg->ops = NULL;
 	pg->vmret = 0;
 	pg->bp_count = 0;
 	pg->flags = PHPDBG_DEFAULT_FLAGS;
 	pg->oplog = NULL;
-	memset(pg->io, 0, sizeof(pg->io));
+	pg->io[PHPDBG_STDIN] = NULL;
+	pg->io[PHPDBG_STDOUT] = NULL;
+	pg->io[PHPDBG_STDERR] = NULL;
 	pg->frame.num = 0;
-	pg->sapi_name_ptr = NULL;
-	pg->socket_fd = -1;
-	pg->socket_server_fd = -1;
-
-	pg->req_id = 0;
-	pg->err_buf.active = 0;
-	pg->err_buf.type = 0;
-
-	pg->input_buflen = 0;
-	pg->sigsafe_mem.mem = NULL;
-	pg->sigsegv_bailout = NULL;
-
-#ifdef PHP_WIN32
-	pg->sigio_watcher_thread = INVALID_HANDLE_VALUE;
-	memset(&pg->swd, 0, sizeof(struct win32_sigio_watcher_data));
-#endif
-
-	pg->eol = PHPDBG_EOL_LF;
 } /* }}} */
 
 static PHP_MINIT_FUNCTION(phpdbg) /* {{{ */
 {
 	ZEND_INIT_MODULE_GLOBALS(phpdbg, php_phpdbg_globals_ctor, NULL);
-	REGISTER_INI_ENTRIES();
-
 #if PHP_VERSION_ID >= 50500
 	zend_execute_old = zend_execute_ex;
 	zend_execute_ex = phpdbg_execute_ex;
@@ -123,7 +86,7 @@ static PHP_MINIT_FUNCTION(phpdbg) /* {{{ */
 #endif
 
 	REGISTER_STRINGL_CONSTANT("PHPDBG_VERSION", PHPDBG_VERSION, sizeof(PHPDBG_VERSION)-1, CONST_CS|CONST_PERSISTENT);
-
+	
 	REGISTER_LONG_CONSTANT("PHPDBG_FILE",   FILE_PARAM, CONST_CS|CONST_PERSISTENT);
 	REGISTER_LONG_CONSTANT("PHPDBG_METHOD", METHOD_PARAM, CONST_CS|CONST_PERSISTENT);
 	REGISTER_LONG_CONSTANT("PHPDBG_LINENO", NUMERIC_PARAM, CONST_CS|CONST_PERSISTENT);
@@ -185,8 +148,7 @@ static void php_phpdbg_destroy_registered(void *data) /* {{{ */
 
 static PHP_RINIT_FUNCTION(phpdbg) /* {{{ */
 {
-	zend_hash_init(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE], 8, NULL, php_phpdbg_destroy_bp_file, 0);
-	zend_hash_init(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE_PENDING], 8, NULL, php_phpdbg_destroy_bp_file, 0);
+	zend_hash_init(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE],   8, NULL, php_phpdbg_destroy_bp_file, 0);
 	zend_hash_init(&PHPDBG_G(bp)[PHPDBG_BREAK_SYM], 8, NULL, php_phpdbg_destroy_bp_symbol, 0);
 	zend_hash_init(&PHPDBG_G(bp)[PHPDBG_BREAK_FUNCTION_OPLINE], 8, NULL, php_phpdbg_destroy_bp_methods, 0);
 	zend_hash_init(&PHPDBG_G(bp)[PHPDBG_BREAK_METHOD_OPLINE], 8, NULL, php_phpdbg_destroy_bp_methods, 0);
@@ -216,7 +178,6 @@ static PHP_RSHUTDOWN_FUNCTION(phpdbg) /* {{{ */
 	zend_hash_destroy(&PHPDBG_G(bp)[PHPDBG_BREAK_COND]);
 	zend_hash_destroy(&PHPDBG_G(bp)[PHPDBG_BREAK_MAP]);
 	zend_hash_destroy(&PHPDBG_G(seek));
-	zend_hash_destroy(&PHPDBG_G(file_sources));
 	zend_hash_destroy(&PHPDBG_G(registered));
 	zend_hash_destroy(&PHPDBG_G(watchpoints));
 	zend_llist_destroy(&PHPDBG_G(watchlist_mem));
@@ -225,7 +186,7 @@ static PHP_RSHUTDOWN_FUNCTION(phpdbg) /* {{{ */
 		efree(PHPDBG_G(buffer));
 		PHPDBG_G(buffer) = NULL;
 	}
-
+	
 	if (PHPDBG_G(exec)) {
 		efree(PHPDBG_G(exec));
 		PHPDBG_G(exec) = NULL;
@@ -265,7 +226,7 @@ static PHP_FUNCTION(phpdbg_exec)
 {
 	char *exec = NULL;
 	int exec_len = 0;
-
+	
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &exec, &exec_len) == FAILURE) {
 		return;
 	}
@@ -301,12 +262,24 @@ static PHP_FUNCTION(phpdbg_exec)
 	}
 } /* }}} */
 
-/* {{{ proto void phpdbg_break_next()
+/* {{{ proto void phpdbg_break([integer type, string expression])
     instructs phpdbg to insert a breakpoint at the next opcode */
-static PHP_FUNCTION(phpdbg_break_next)
+static PHP_FUNCTION(phpdbg_break)
 {
-	if (zend_parse_parameters_none() != SUCCESS) {
-		return;
+	if (ZEND_NUM_ARGS() > 0) {
+		long type = 0;
+		char *expr = NULL;
+		int expr_len = 0;
+		phpdbg_param_t param;
+
+		if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ls", &type, &expr, &expr_len) == FAILURE) {
+			return;
+		}
+
+		phpdbg_parse_param(expr, expr_len, &param TSRMLS_CC);
+		phpdbg_do_break(&param TSRMLS_CC);
+		phpdbg_clear_param(&param TSRMLS_CC);
+
 	} else if (EG(current_execute_data) && EG(active_op_array)) {
 		zend_ulong opline_num = (EG(current_execute_data)->opline -
 				EG(active_op_array)->opcodes);
@@ -316,54 +289,11 @@ static PHP_FUNCTION(phpdbg_break_next)
 	}
 } /* }}} */
 
-/* {{{ proto void phpdbg_break_file(string file, integer line) */
-static PHP_FUNCTION(phpdbg_break_file)
-{
-    char    *file = NULL;
-    int      flen = 0;
-    long     line;
-    
-    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sl", &file, &flen, &line) == FAILURE) {
-        return;
-    }
-
-    phpdbg_set_breakpoint_file(file, line TSRMLS_CC);
-} /* }}} */
-
-/* {{{ proto void phpdbg_break_method(string class, string method) */
-static PHP_FUNCTION(phpdbg_break_method)
-{
-    char *class = NULL,
-         *method = NULL;
-    int clen = 0, 
-        mlen = 0;
-
-    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &class, &clen, &method, &mlen) == FAILURE) {
-    return;
-    }
-
-    phpdbg_set_breakpoint_method(class, method TSRMLS_CC);
-} /* }}} */
-
-/* {{{ proto void phpdbg_break_function(string function) */
-static PHP_FUNCTION(phpdbg_break_function)
-{
-    char *function = NULL;
-    int   function_len;
-
-    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &function, &function_len) == FAILURE) {
-           return;
-    }
-
-    phpdbg_set_breakpoint_symbol(function, function_len TSRMLS_CC);
-} /* }}} */
-
 /* {{{ proto void phpdbg_clear(void)
    instructs phpdbg to clear breakpoints */
 static PHP_FUNCTION(phpdbg_clear)
 {
 	zend_hash_clean(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE]);
-	zend_hash_clean(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE_PENDING]);
 	zend_hash_clean(&PHPDBG_G(bp)[PHPDBG_BREAK_SYM]);
 	zend_hash_clean(&PHPDBG_G(bp)[PHPDBG_BREAK_FUNCTION_OPLINE]);
 	zend_hash_clean(&PHPDBG_G(bp)[PHPDBG_BREAK_METHOD_OPLINE]);
@@ -378,7 +308,7 @@ static PHP_FUNCTION(phpdbg_color)
 {
 	long element = 0L;
 	char *color = NULL;
-	size_t color_len = 0;
+	int color_len = 0;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ls", &element, &color, &color_len) == FAILURE) {
 		return;
@@ -399,7 +329,7 @@ static PHP_FUNCTION(phpdbg_color)
 static PHP_FUNCTION(phpdbg_prompt)
 {
 	char *prompt = NULL;
-	size_t prompt_len = 0;
+	int prompt_len = 0;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &prompt, &prompt_len) == FAILURE) {
 		return;
@@ -408,21 +338,9 @@ static PHP_FUNCTION(phpdbg_prompt)
 	phpdbg_set_prompt(prompt TSRMLS_CC);
 } /* }}} */
 
-ZEND_BEGIN_ARG_INFO_EX(phpdbg_break_next_arginfo, 0, 0, 0)
-ZEND_END_ARG_INFO()
-
-ZEND_BEGIN_ARG_INFO_EX(phpdbg_break_file_arginfo, 0, 0, 2)
-    ZEND_ARG_INFO(0, file)
-    ZEND_ARG_INFO(0, line)
-ZEND_END_ARG_INFO()
-
-ZEND_BEGIN_ARG_INFO_EX(phpdbg_break_method_arginfo, 0, 0, 2)
-    ZEND_ARG_INFO(0, class)
-    ZEND_ARG_INFO(0, method)
-ZEND_END_ARG_INFO()
-
-ZEND_BEGIN_ARG_INFO_EX(phpdbg_break_function_arginfo, 0, 0, 1)
-    ZEND_ARG_INFO(0, function)
+ZEND_BEGIN_ARG_INFO_EX(phpdbg_break_arginfo, 0, 0, 0)
+	ZEND_ARG_INFO(0, type)
+	ZEND_ARG_INFO(0, expression)
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_INFO_EX(phpdbg_color_arginfo, 0, 0, 0)
@@ -443,10 +361,7 @@ ZEND_END_ARG_INFO()
 
 zend_function_entry phpdbg_user_functions[] = {
 	PHP_FE(phpdbg_clear, phpdbg_clear_arginfo)
-	PHP_FE(phpdbg_break_next, phpdbg_break_next_arginfo)
-	PHP_FE(phpdbg_break_file, phpdbg_break_file_arginfo)
-	PHP_FE(phpdbg_break_method, phpdbg_break_method_arginfo)
-	PHP_FE(phpdbg_break_function, phpdbg_break_function_arginfo)
+	PHP_FE(phpdbg_break, phpdbg_break_arginfo)
 	PHP_FE(phpdbg_exec,  phpdbg_exec_arginfo)
 	PHP_FE(phpdbg_color, phpdbg_color_arginfo)
 	PHP_FE(phpdbg_prompt, phpdbg_prompt_arginfo)
@@ -511,12 +426,7 @@ static void php_sapi_phpdbg_log_message(char *message TSRMLS_DC) /* {{{ */
 	* We must not request TSRM before being boot
 	*/
 	if (phpdbg_booted) {
-		if (PHPDBG_G(flags) & PHPDBG_IN_EVAL) {
-			phpdbg_error("eval", "msg=\"%s\"", "%s", message);
-			return;
-		}
-
-		phpdbg_error("php", "msg=\"%s\"", "%s", message);
+		phpdbg_error("%s", message);
 
 		switch (PG(last_error_type)) {
 			case E_ERROR:
@@ -525,17 +435,25 @@ static void php_sapi_phpdbg_log_message(char *message TSRMLS_DC) /* {{{ */
 			case E_USER_ERROR:
 			case E_PARSE:
 			case E_RECOVERABLE_ERROR:
-				phpdbg_list_file(zend_get_executed_filename(TSRMLS_C), 3, zend_get_executed_lineno(TSRMLS_C)-1, zend_get_executed_lineno(TSRMLS_C) TSRMLS_CC);
+				if (!(PHPDBG_G(flags) & PHPDBG_IN_EVAL)) {
+					phpdbg_list_file(
+						zend_get_executed_filename(TSRMLS_C),
+						3,
+						zend_get_executed_lineno(TSRMLS_C)-1,
+						zend_get_executed_lineno(TSRMLS_C)
+						TSRMLS_CC
+					);
+				}
 
 				do {
-					switch (phpdbg_interactive(1 TSRMLS_CC)) {
+					switch (phpdbg_interactive(TSRMLS_C)) {
 						case PHPDBG_LEAVE:
 						case PHPDBG_FINISH:
 						case PHPDBG_UNTIL:
 						case PHPDBG_NEXT:
 							return;
 					}
-				} while (!(PHPDBG_G(flags) & PHPDBG_IS_STOPPING));
+				} while (!(PHPDBG_G(flags) & PHPDBG_IS_QUITTING));
 
 		}
 	} else fprintf(stdout, "%s\n", message);
@@ -544,27 +462,11 @@ static void php_sapi_phpdbg_log_message(char *message TSRMLS_DC) /* {{{ */
 
 static int php_sapi_phpdbg_deactivate(TSRMLS_D) /* {{{ */
 {
-	if ((PHPDBG_G(flags) & PHPDBG_IS_STOPPING) == PHPDBG_IS_CLEANING) {
-		zend_phpdbg_globals *pg = PHPDBG_G(backup) = calloc(1, sizeof(zend_phpdbg_globals));
-
-		php_phpdbg_globals_ctor(pg);
-
-		pg->exec = zend_strndup(PHPDBG_G(exec), PHPDBG_G(exec_len));
-		pg->exec_len = PHPDBG_G(exec_len);
-		pg->oplog = PHPDBG_G(oplog);
-		pg->prompt[0] = PHPDBG_G(prompt)[0];
-		pg->prompt[1] = PHPDBG_G(prompt)[1];
-		memcpy(pg->colors, PHPDBG_G(colors), sizeof(pg->colors));
-		pg->eol = PHPDBG_G(eol);
-		pg->flags = PHPDBG_G(flags) & PHPDBG_PRESERVE_FLAGS_MASK;
-	}
-
 	fflush(stdout);
 	if(SG(request_info).argv0) {
 		free(SG(request_info).argv0);
 		SG(request_info).argv0 = NULL;
 	}
-
 	return SUCCESS;
 }
 /* }}} */
@@ -614,42 +516,9 @@ static void php_sapi_phpdbg_register_vars(zval *track_vars_array TSRMLS_DC) /* {
 
 static inline int php_sapi_phpdbg_ub_write(const char *message, unsigned int length TSRMLS_DC) /* {{{ */
 {
-	if (PHPDBG_G(socket_fd) != -1 && !(PHPDBG_G(flags) & PHPDBG_IS_INTERACTIVE)) {
-		send(PHPDBG_G(socket_fd), message, length, 0);
-	}
-	return phpdbg_script(P_STDOUT, "%.*s", length, message);
+	return phpdbg_write("%s", message);
 } /* }}} */
 
-/* beginning of struct, see main/streams/plain_wrapper.c line 111 */
-typedef struct {
-	FILE *file;
-	int fd;
-} php_stdio_stream_data;
-
-static size_t phpdbg_stdiop_write(php_stream *stream, const char *buf, size_t count TSRMLS_DC) {
-	php_stdio_stream_data *data = (php_stdio_stream_data*)stream->abstract;
-
-	while (data->fd >= 0) {
-		struct stat stat[3];
-		memset(stat, 0, sizeof(stat));
-		if (((fstat(fileno(stderr), &stat[2]) < 0) & (fstat(fileno(stdout), &stat[0]) < 0)) | (fstat(data->fd, &stat[1]) < 0)) {
-			break;
-		}
-
-		if (stat[0].st_dev == stat[1].st_dev && stat[0].st_ino == stat[1].st_ino) {
-			phpdbg_script(P_STDOUT, "%.*s", (int) count, buf);
-			return count;
-		}
-		if (stat[2].st_dev == stat[1].st_dev && stat[2].st_ino == stat[1].st_ino) {
-			phpdbg_script(P_STDERR, "%.*s", (int) count, buf);
-			return count;
-		}
-		break;
-	}
-
-	return PHPDBG_G(php_stdiop_write)(stream, buf, count TSRMLS_CC);
-}
-
 #if PHP_VERSION_ID >= 50700
 static inline void php_sapi_phpdbg_flush(void *context TSRMLS_DC)  /* {{{ */
 {
@@ -659,9 +528,7 @@ static inline void php_sapi_phpdbg_flush(void *context)  /* {{{ */
 	TSRMLS_FETCH();
 #endif
 
-	if (!phpdbg_active_sigsafe_mem(TSRMLS_C)) {
-		fflush(PHPDBG_G(io)[PHPDBG_STDOUT].ptr);
-	}
+	fflush(PHPDBG_G(io)[PHPDBG_STDOUT]);
 } /* }}} */
 
 /* copied from sapi/cli/php_cli.c cli_register_file_handles */
@@ -777,9 +644,10 @@ const opt_struct OPTIONS[] = { /* {{{ */
 	{'r', 0, "run"},
 	{'E', 0, "step-through-eval"},
 	{'S', 1, "sapi-name"},
+#ifndef _WIN32
 	{'l', 1, "listen"},
 	{'a', 1, "address-or-any"},
-	{'x', 0, "xml output"},
+#endif
 	{'V', 0, "version"},
 	{'-', 0, NULL}
 }; /* }}} */
@@ -792,8 +660,7 @@ const char phpdbg_ini_hardcoded[] =
 "log_errors=On\n"
 "max_execution_time=0\n"
 "max_input_time=-1\n"
-"error_log=\n"
-"output_buffering=off\0";
+"error_log=\n\0";
 
 /* overwriteable ini defaults must be set in phpdbg_ini_defaults() */
 #define INI_DEFAULT(name, value) \
@@ -812,25 +679,17 @@ static void phpdbg_welcome(zend_bool cleaning TSRMLS_DC) /* {{{ */
 {
 	/* print blurb */
 	if (!cleaning) {
-		phpdbg_xml("<intros>");
-		phpdbg_notice("intro", "version=\"%s\"", "Welcome to phpdbg, the interactive PHP debugger, v%s", PHPDBG_VERSION);
-		phpdbg_writeln("intro", "help=\"help\"", "To get help using phpdbg type \"help\" and press enter");
-		phpdbg_notice("intro", "report=\"%s\"", "Please report bugs to <%s>", PHPDBG_ISSUES);
-		phpdbg_xml("</intros>");
-	} else if (phpdbg_startup_run == 0) {
-		if (!(PHPDBG_G(flags) & PHPDBG_WRITE_XML)) {
-			phpdbg_notice(NULL, NULL, "Clean Execution Environment");
-		}
+		phpdbg_notice("Welcome to phpdbg, the interactive PHP debugger, v%s",
+				PHPDBG_VERSION);
+		phpdbg_writeln("To get help using phpdbg type \"help\" and press enter");
+		phpdbg_notice("Please report bugs to <%s>", PHPDBG_ISSUES);
+	} else {
+		phpdbg_notice("Clean Execution Environment");
 
-		phpdbg_write("cleaninfo", "classes=\"%d\" functions=\"%d\" constants=\"%d\" includes=\"%d\"",
-			"Classes              %d\n"
-			"Functions            %d\n"
-			"Constants            %d\n"
-			"Includes             %d\n",
-			zend_hash_num_elements(EG(class_table)),
-			zend_hash_num_elements(EG(function_table)),
-			zend_hash_num_elements(EG(zend_constants)),
-			zend_hash_num_elements(&EG(included_files)));
+		phpdbg_writeln("Classes\t\t\t%d", zend_hash_num_elements(EG(class_table)));
+		phpdbg_writeln("Functions\t\t%d", zend_hash_num_elements(EG(function_table)));
+		phpdbg_writeln("Constants\t\t%d", zend_hash_num_elements(EG(zend_constants)));
+		phpdbg_writeln("Includes\t\t%d",  zend_hash_num_elements(&EG(included_files)));
 	}
 } /* }}} */
 
@@ -838,130 +697,163 @@ static inline void phpdbg_sigint_handler(int signo) /* {{{ */
 {
 	TSRMLS_FETCH();
 
-	if (PHPDBG_G(flags) & PHPDBG_IS_INTERACTIVE) {
-		/* we quit remote consoles on recv SIGINT */
-		if (PHPDBG_G(flags) & PHPDBG_IS_REMOTE) {
-			PHPDBG_G(flags) |= PHPDBG_IS_STOPPING;
-			zend_bailout();
-		}
-	} else {
+	if (EG(in_execution)) {
 		/* set signalled only when not interactive */
 		if (!(PHPDBG_G(flags) & PHPDBG_IS_INTERACTIVE)) {
-			if (PHPDBG_G(flags) & PHPDBG_IS_SIGNALED) {
-				char mem[PHPDBG_SIGSAFE_MEM_SIZE + 1];
-
-				phpdbg_set_sigsafe_mem(mem TSRMLS_CC);
-				zend_try {
-					phpdbg_force_interruption(TSRMLS_C);
-				} zend_end_try()
-				phpdbg_clear_sigsafe_mem(TSRMLS_C);
-				return;
-			}
 			PHPDBG_G(flags) |= PHPDBG_IS_SIGNALED;
 		}
+	} else {
+		/* we quit remote consoles on recv SIGINT */
+		if (PHPDBG_G(flags) & PHPDBG_IS_REMOTE) {
+			PHPDBG_G(flags) |= PHPDBG_IS_QUITTING;
+			zend_bailout();
+		}
 	}
 } /* }}} */
 
+#ifndef _WIN32
+int phpdbg_open_socket(const char *interface, short port) /* {{{ */
+{
+	int fd = socket(AF_INET, SOCK_STREAM, 0);
+
+	switch (fd) {
+		case -1:
+			return -1;
+
+		default: {
+			int reuse = 1;
+
+			switch (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (char*) &reuse, sizeof(reuse))) {
+				case -1:
+					close(fd);
+					return -2;
+
+				default: {
+					struct sockaddr_in address;
+
+					memset(&address, 0, sizeof(address));
+
+					address.sin_port = htons(port);
+					address.sin_family = AF_INET;
 
-static void phpdbg_remote_close(int socket, FILE *stream) {
-	if (socket >= 0) {
-		phpdbg_close_socket(socket);
+					if ((*interface == '*')) {
+						address.sin_addr.s_addr = htonl(INADDR_ANY);
+					} else if (!inet_pton(AF_INET, interface, &address.sin_addr)) {
+						close(fd);
+						return -3;
+					}
+
+					switch (bind(fd, (struct sockaddr *)&address, sizeof(address))) {
+						case -1:
+							close(fd);
+							return -4;
+
+						default: {
+							listen(fd, 5);
+						}
+					}
+				}
+			}
+		}
 	}
 
-	if (stream) {
-		fclose(stream);
+	return fd;
+} /* }}} */
+
+static inline void phpdbg_close_sockets(int (*socket)[2], FILE *streams[2]) /* {{{ */
+{
+	if ((*socket)[0] >= 0) {
+		shutdown(
+			(*socket)[0], SHUT_RDWR);
+		close((*socket)[0]);
 	}
-}
 
-/* don't inline this, want to debug it easily, will inline when done */
-static int phpdbg_remote_init(const char* address, unsigned short port, int server, int *socket, FILE **stream TSRMLS_DC) {
-	phpdbg_remote_close(*socket, *stream);
+	if (streams[0]) {
+		fclose(streams[0]);
+	}
 
-	if (server < 0) {
-		phpdbg_rlog(fileno(stderr), "Initializing connection on %s:%u failed", address, port);
+	if ((*socket)[1] >= 0) {
+		shutdown(
+			(*socket)[1], SHUT_RDWR);
+		close((*socket)[1]);
+	}
 
-		return FAILURE;
+	if (streams[1]) {
+		fclose(streams[1]);
 	}
+} /* }}} */
 
-	phpdbg_rlog(fileno(stderr), "accepting connections on %s:%u", address, port);
-	{
-		struct sockaddr_storage address;
-		socklen_t size = sizeof(address);
-		char buffer[20] = {0};
-		/* XXX error checks */
-		memset(&address, 0, size);
-		*socket = accept(server, (struct sockaddr *) &address, &size);
-		inet_ntop(AF_INET, &(((struct sockaddr_in *)&address)->sin_addr), buffer, sizeof(buffer));
+/* don't inline this, want to debug it easily, will inline when done */
 
-		phpdbg_rlog(fileno(stderr), "connection established from %s", buffer);
+int phpdbg_open_sockets(char *address, int port[2], int (*listen)[2], int (*socket)[2], FILE* streams[2]) /* {{{ */
+{
+	if (((*listen)[0]) < 0 && ((*listen)[1]) < 0) {
+		((*listen)[0]) = phpdbg_open_socket(address, (short)port[0]);
+		((*listen)[1]) = phpdbg_open_socket(address, (short)port[1]);
 	}
 
-#ifndef _WIN32
-	dup2(*socket, fileno(stdout));
-	dup2(*socket, fileno(stdin));
+	streams[0] = NULL;
+	streams[1] = NULL;
 
-	setbuf(stdout, NULL);
+	if ((*listen)[0] < 0 || (*listen)[1] < 0) {
+		if ((*listen)[0] < 0) {
+			phpdbg_rlog(stderr,
+				"console failed to initialize (stdin) on %s:%d", address, port[0]);
+		}
 
-	*stream = fdopen(*socket, "r+");
+		if ((*listen)[1] < 0) {
+			phpdbg_rlog(stderr,
+				"console failed to initialize (stdout) on %s:%d", address, port[1]);
+		}
 
-	phpdbg_set_async_io(*socket);
-#endif
-	return SUCCESS;
-}
+		if ((*listen)[0] >= 0) {
+			close((*listen)[0]);
+		}
 
-#ifndef _WIN32
-/* This function *strictly* assumes that SIGIO is *only* used on the remote connection stream */
-void phpdbg_sigio_handler(int sig, siginfo_t *info, void *context) /* {{{ */
-{
-	int flags;
-	size_t newlen;
-	size_t i/*, last_nl*/;
-	TSRMLS_FETCH();
+		if ((*listen)[1] >= 0) {
+			close((*listen)[1]);
+		}
 
-//	if (!(info->si_band & POLLIN)) {
-//		return; /* Not interested in writeablility etc., just interested in incoming data */
-//	}
+		return FAILURE;
+	}
 
-	/* only non-blocking reading, avoid non-blocking writing */
-	flags = fcntl(PHPDBG_G(io)[PHPDBG_STDIN].fd, F_GETFL, 0);
-	fcntl(PHPDBG_G(io)[PHPDBG_STDIN].fd, F_SETFL, flags | O_NONBLOCK);
+	phpdbg_close_sockets(socket, streams);
 
-	do {
-		char mem[PHPDBG_SIGSAFE_MEM_SIZE + 1];
-		size_t off = 0;
+	phpdbg_rlog(stderr,
+		"accepting connections on %s:%d/%d", address, port[0], port[1]);
+	{
+		struct sockaddr_in address;
+		socklen_t size = sizeof(address);
+		char buffer[20] = {0};
 
-		if ((newlen = recv(PHPDBG_G(io)[PHPDBG_STDIN].fd, mem, PHPDBG_SIGSAFE_MEM_SIZE, MSG_PEEK)) == (size_t) -1) {
-			break;
+		{
+			memset(&address, 0, size);
+			(*socket)[0] = accept(
+				(*listen)[0], (struct sockaddr *) &address, &size);
+			inet_ntop(AF_INET, &address.sin_addr, buffer, sizeof(buffer));
+
+			phpdbg_rlog(stderr, "connection (stdin) from %s", buffer);
 		}
-		for (i = 0; i < newlen; i++) {
-			switch (mem[off + i]) {
-				case '\x03': /* ^C char */
-					if (PHPDBG_G(flags) & PHPDBG_IS_INTERACTIVE) {
-						break; /* or quit ??? */
-					}
-					if (PHPDBG_G(flags) & PHPDBG_IS_SIGNALED) {
-						phpdbg_set_sigsafe_mem(mem TSRMLS_CC);
-						zend_try {
-							phpdbg_force_interruption(TSRMLS_C);
-						} zend_end_try();
-						phpdbg_clear_sigsafe_mem(TSRMLS_C);
-						break;
-					}
-					if (!(PHPDBG_G(flags) & PHPDBG_IS_INTERACTIVE)) {
-						PHPDBG_G(flags) |= PHPDBG_IS_SIGNALED;
-					}
-					break;
-/*				case '\n':
-					zend_llist_add_element(PHPDBG_G(stdin), strndup()
-					last_nl = PHPDBG_G(stdin_buf).len + i;
-					break;
-*/			}
+
+		{
+			memset(&address, 0, size);
+			(*socket)[1] = accept(
+				(*listen)[1], (struct sockaddr *) &address, &size);
+		    inet_ntop(AF_INET, &address.sin_addr, buffer, sizeof(buffer));
+
+			phpdbg_rlog(stderr, "connection (stdout) from %s", buffer);
 		}
-		off += i;
-	} while (0);
+	}
+
+	dup2((*socket)[0], fileno(stdin));
+	dup2((*socket)[1], fileno(stdout));
+
+	setbuf(stdout, NULL);
 
+	streams[0] = fdopen((*socket)[0], "r");
+	streams[1] = fdopen((*socket)[1], "w");
 
-	fcntl(PHPDBG_G(io)[PHPDBG_STDIN].fd, F_SETFL, flags);
+	return SUCCESS;
 } /* }}} */
 
 void phpdbg_signal_handler(int sig, siginfo_t *info, void *context) /* {{{ */
@@ -972,9 +864,6 @@ void phpdbg_signal_handler(int sig, siginfo_t *info, void *context) /* {{{ */
 	switch (sig) {
 		case SIGBUS:
 		case SIGSEGV:
-			if (PHPDBG_G(sigsegv_bailout)) {
-				LONGJMP(*PHPDBG_G(sigsegv_bailout), FAILURE);
-			}
 			is_handled = phpdbg_watchpoint_segfault_handler(info, context TSRMLS_CC);
 			if (is_handled == FAILURE) {
 #ifdef ZEND_SIGNALS
@@ -1026,7 +915,8 @@ int main(int argc, char **argv) /* {{{ */
 	zend_ulong zend_extensions_len = 0L;
 	zend_bool ini_ignore;
 	char *ini_override;
-	char *exec = NULL;
+	char *exec;
+	size_t exec_len;
 	char *init_file;
 	size_t init_file_len;
 	zend_bool init_file_default;
@@ -1035,31 +925,44 @@ int main(int argc, char **argv) /* {{{ */
 	zend_ulong flags;
 	char *php_optarg;
 	int php_optind, opt, show_banner = 1;
-	long cleaning = -1;
+	long cleaning = 0;
 	zend_bool remote = 0;
+	int run = 0;
 	int step = 0;
-	zend_phpdbg_globals *settings = NULL;
-	char *bp_tmp = NULL;
+
+#ifdef _WIN32
+	char *bp_tmp_file = NULL;
+#else
+	char bp_tmp_file[] = "/tmp/phpdbg.XXXXXX";
+#endif
+
+#ifndef _WIN32
 	char *address;
-	int listen = -1;
-	int server = -1;
-	int socket = -1;
-	FILE* stream = NULL;
+	int listen[2];
+	int server[2];
+	int socket[2];
+	FILE* streams[2] = {NULL, NULL};
+#endif
 
 #ifdef ZTS
 	void ***tsrm_ls;
 #endif
 
 #ifndef _WIN32
-	struct sigaction sigio_struct;
 	struct sigaction signal_struct;
 	signal_struct.sa_sigaction = phpdbg_signal_handler;
 	signal_struct.sa_flags = SA_SIGINFO | SA_NODEFER;
-	sigio_struct.sa_sigaction = phpdbg_sigio_handler;
-	sigio_struct.sa_flags = SA_SIGINFO;
-#endif
 
 	address = strdup("127.0.0.1");
+	socket[0] = -1;
+	socket[1] = -1;
+	listen[0] = -1;
+	listen[1] = -1;
+	server[0] = -1;
+	server[1] = -1;
+	streams[0] = NULL;
+	streams[1] = NULL;
+#endif
 
 #ifdef PHP_WIN32
 	_fmode = _O_BINARY;                 /* sets default for file streams to binary */
@@ -1075,12 +978,37 @@ int main(int argc, char **argv) /* {{{ */
 #endif
 
 phpdbg_main:
+	if (!cleaning) {
+	
+#ifdef _WIN32
+		bp_tmp_file = malloc(L_tmpnam);
+
+		if (bp_tmp_file) {
+			if (!tmpnam(bp_tmp_file)) {
+				free(bp_tmp_file);
+				bp_tmp_file = NULL;
+			}
+		}
+
+		if (!bp_tmp_file) {
+			phpdbg_error("Unable to create temporary file");
+			return 1;
+		}
+#else
+		if (!mkstemp(bp_tmp_file)) {
+			memset(bp_tmp_file, 0, sizeof(bp_tmp_file));
+		}
+#endif
+
+	}
 	ini_entries = NULL;
 	ini_entries_len = 0;
 	ini_ignore = 0;
 	ini_override = NULL;
 	zend_extensions = NULL;
 	zend_extensions_len = 0L;
+	exec = NULL;
+	exec_len = 0;
 	init_file = NULL;
 	init_file_len = 0;
 	init_file_default = 1;
@@ -1090,16 +1018,14 @@ phpdbg_main:
 	php_optarg = NULL;
 	php_optind = 1;
 	opt = 0;
+	run = 0;
 	step = 0;
 	sapi_name = NULL;
-	if (settings) {
-		exec = settings->exec;
-	}
 
 	while ((opt = php_getopt(argc, argv, OPTIONS, &php_optarg, &php_optind, 0, 2)) != -1) {
 		switch (opt) {
 			case 'r':
-				phpdbg_startup_run++;
+				run++;
 				break;
 			case 'n':
 				ini_ignore = 1;
@@ -1199,12 +1125,21 @@ phpdbg_main:
 				show_banner = 0;
 			break;
 
-			/* if you pass a listen port, we will read and write on listen port */
-			case 'l': /* set listen ports */
-				if (sscanf(php_optarg, "%d", &listen) != 1) {
-					listen = 8000;
+#ifndef _WIN32
+			/* if you pass a listen port, we will accept input on listen port */
+			/* and write output to listen port * 2 */
+
+			case 'l': { /* set listen ports */
+				if (sscanf(php_optarg, "%d/%d", &listen[0], &listen[1]) != 2) {
+					if (sscanf(php_optarg, "%d", &listen[0]) != 1) {
+						/* default to hardcoded ports */
+						listen[0] = 4000;
+						listen[1] = 8000;
+					} else {
+						listen[1] = (listen[0] * 2);
+					}
 				}
-				break;
+			} break;
 
 			case 'a': { /* set bind address */
 				free(address);
@@ -1212,10 +1147,7 @@ phpdbg_main:
 					address = strdup("*");
 				} else address = strdup(php_optarg);
 			} break;
-
-			case 'x':
-				flags |= PHPDBG_WRITE_XML;
-			break;
+#endif
 
 			case 'V': {
 				sapi_startup(phpdbg);
@@ -1236,8 +1168,10 @@ phpdbg_main:
 	}
 	
 	/* set exec if present on command line */
-	if (!exec && (argc > php_optind) && (strcmp(argv[php_optind-1], "--") != SUCCESS)) {
-		if (strlen(argv[php_optind])) {
+	if ((argc > php_optind) && (strcmp(argv[php_optind-1],"--") != SUCCESS))
+	{
+		exec_len = strlen(argv[php_optind]);
+		if (exec_len) {
 			if (exec) {
 				free(exec);
 			}
@@ -1246,6 +1180,19 @@ phpdbg_main:
 		php_optind++;
 	}
 
+#ifndef _WIN32
+	/* setup remote server if necessary */
+	if (!cleaning &&
+		(listen[0] > 0 && listen[1] > 0)) {
+		if (phpdbg_open_sockets(address, listen, &server, &socket, streams) == FAILURE) {
+			remote = 0;
+			exit(0);
+		}
+		/* set remote flag to stop service shutting down upon quit */
+		remote = 1;
+	}
+#endif
+
 	if (sapi_name) {
 		phpdbg->name = sapi_name;
 	}
@@ -1300,35 +1247,7 @@ phpdbg_main:
     EXCEPTION_POINTERS *xp;
     __try {
 #endif
-		zend_mm_heap *mm_heap;
-
-		/* set flags from command line */
-		PHPDBG_G(flags) = flags;
-
-		if (settings) {
-#ifdef ZTS
-			*((zend_phpdbg_globals *) (*((void ***) tsrm_ls))[TSRM_UNSHUFFLE_RSRC_ID(phpdbg_globals_id)]) = *settings;
-#else
-			phpdbg_globals = *settings;
-#endif
-		}
-
-		/* setup remote server if necessary */
-		if (cleaning <= 0 && listen > 0) {
-			server = phpdbg_open_socket(address, listen TSRMLS_CC);
-				if (-1 > server || phpdbg_remote_init(address, listen, server, &socket, &stream TSRMLS_CC) == FAILURE) {
-				exit(0);
-			}
-
-#ifndef _WIN32
-			sigaction(SIGIO, &sigio_struct, NULL);
-#endif
-
-			/* set remote flag to stop service shutting down upon quit */
-			remote = 1;
-		}
-
-		mm_heap = phpdbg_mm_get_heap();
+		zend_mm_heap *mm_heap = phpdbg_mm_get_heap();
 
 		if (mm_heap->use_zend_alloc) {
 			mm_heap->_malloc = phpdbg_malloc_wrapper;
@@ -1339,8 +1258,6 @@ phpdbg_main:
 
 		zend_activate(TSRMLS_C);
 
-		phpdbg_init_list(TSRMLS_C);
-
 		PHPDBG_G(original_free_function) = mm_heap->_free;
 		mm_heap->_free = phpdbg_watch_efree;
 
@@ -1360,30 +1277,27 @@ phpdbg_main:
 		sigaction(SIGBUS, &signal_struct, &PHPDBG_G(old_sigsegv_signal));
 #endif
 
-		PHPDBG_G(sapi_name_ptr) = sapi_name;
-
-		php_output_activate(TSRMLS_C);
-		php_output_deactivate(TSRMLS_C);
-
-		php_output_activate(TSRMLS_C);
-
 		if (php_request_startup(TSRMLS_C) == SUCCESS) {
 			int i;
-
-			SG(request_info).argc = argc - php_optind + 1;
+		
+			SG(request_info).argc = argc - php_optind + 1;		
 			SG(request_info).argv = emalloc(SG(request_info).argc * sizeof(char *));
 			for (i = SG(request_info).argc; --i;) {
 				SG(request_info).argv[i] = estrdup(argv[php_optind - 1 + i]);
 			}
-			SG(request_info).argv[i] = exec ? estrdup(exec) : estrdup("");
+			SG(request_info).argv[i] = exec ? estrndup(exec, exec_len) : estrdup("");
 
 			php_hash_environment(TSRMLS_C);
 		}
 
+		/* make sure to turn off buffer for ev command */
+		php_output_activate(TSRMLS_C);
+		php_output_deactivate(TSRMLS_C);
+		
 		/* do not install sigint handlers for remote consoles */
 		/* sending SIGINT then provides a decent way of shutting down the server */
 #ifndef _WIN32
-		if (listen < 0) {
+		if (listen[0] < 0) {
 #endif
 #if defined(ZEND_SIGNALS) && !defined(_WIN32)
 			zend_try { zend_signal(SIGINT, phpdbg_sigint_handler TSRMLS_CC); } zend_end_try();
@@ -1396,57 +1310,34 @@ phpdbg_main:
 
 		PG(modules_activated) = 0;
 
+		/* set flags from command line */
+		PHPDBG_G(flags) = flags;
+
+#ifndef _WIN32
 		/* setup io here */
-		if (remote) {
+		if (streams[0] && streams[1]) {
 			PHPDBG_G(flags) |= PHPDBG_IS_REMOTE;
-#ifndef _WIN32
-			signal(SIGPIPE, SIG_IGN);
-#endif
-		}
 
-#ifndef _WIN32
-		PHPDBG_G(io)[PHPDBG_STDIN].ptr = stdin;
-		PHPDBG_G(io)[PHPDBG_STDIN].fd = fileno(stdin);
-		PHPDBG_G(io)[PHPDBG_STDOUT].ptr = stdout;
-		PHPDBG_G(io)[PHPDBG_STDOUT].fd = fileno(stdout);
-#else
-		/* XXX this is a complete mess here with FILE/fd/SOCKET,
-			we should let only one to survive probably. Need 
-			a clean separation whether it's a remote or local
-			prompt. And what is supposed to go as user interaction,
-			error log, etc. */
-		if (remote) {
-			PHPDBG_G(io)[PHPDBG_STDIN].ptr = stdin;
-			PHPDBG_G(io)[PHPDBG_STDIN].fd = socket;
-			PHPDBG_G(io)[PHPDBG_STDOUT].ptr = stdout;
-			PHPDBG_G(io)[PHPDBG_STDOUT].fd = socket;
-		} else {
-			PHPDBG_G(io)[PHPDBG_STDIN].ptr = stdin;
-			PHPDBG_G(io)[PHPDBG_STDIN].fd = fileno(stdin);
-			PHPDBG_G(io)[PHPDBG_STDOUT].ptr = stdout;
-			PHPDBG_G(io)[PHPDBG_STDOUT].fd = fileno(stdout);
+			signal(SIGPIPE, SIG_IGN);
 		}
 #endif
-		PHPDBG_G(io)[PHPDBG_STDERR].ptr = stderr;
-		PHPDBG_G(io)[PHPDBG_STDERR].fd = fileno(stderr);
 
-#ifndef _WIN32
-		PHPDBG_G(php_stdiop_write) = php_stream_stdio_ops.write;
-		php_stream_stdio_ops.write = phpdbg_stdiop_write;
-#endif
+		PHPDBG_G(io)[PHPDBG_STDIN] = stdin;
+		PHPDBG_G(io)[PHPDBG_STDOUT] = stdout;
+		PHPDBG_G(io)[PHPDBG_STDERR] = stderr;
 
 		if (exec) { /* set execution context */
 			PHPDBG_G(exec) = phpdbg_resolve_path(exec TSRMLS_CC);
-			PHPDBG_G(exec_len) = PHPDBG_G(exec) ? strlen(PHPDBG_G(exec)) : 0;
+			PHPDBG_G(exec_len) = strlen(PHPDBG_G(exec));
 
 			free(exec);
-			exec = NULL;
 		}
 
 		if (oplog_file) { /* open oplog */
 			PHPDBG_G(oplog) = fopen(oplog_file, "w+");
 			if (!PHPDBG_G(oplog)) {
-				phpdbg_error("oplog", "path=\"%s\"", "Failed to open oplog %s", oplog_file);
+				phpdbg_error(
+						"Failed to open oplog %s", oplog_file);
 			}
 			free(oplog_file);
 		}
@@ -1457,29 +1348,26 @@ phpdbg_main:
 		phpdbg_set_color_ex(PHPDBG_COLOR_NOTICE,  PHPDBG_STRL("green") TSRMLS_CC);
 
 		/* set default prompt */
-		phpdbg_set_prompt(PHPDBG_DEFAULT_PROMPT TSRMLS_CC);
+		phpdbg_set_prompt(PROMPT TSRMLS_CC);
 
 		/* Make stdin, stdout and stderr accessible from PHP scripts */
 		phpdbg_register_file_handles(TSRMLS_C);
 
-		if (show_banner && cleaning < 2) {
+		if (show_banner) {
 			/* print blurb */
-			phpdbg_welcome(cleaning == 1 TSRMLS_CC);
+			phpdbg_welcome((cleaning > 0) TSRMLS_CC);
 		}
 
-		cleaning = -1;
+		/* auto compile */
+		if (PHPDBG_G(exec)) {
+			phpdbg_compile(TSRMLS_C);
+		}
 
 		/* initialize from file */
 		PHPDBG_G(flags) |= PHPDBG_IS_INITIALIZING;
 		zend_try {
 			phpdbg_init(init_file, init_file_len, init_file_default TSRMLS_CC);
-			if (bp_tmp) {
-				PHPDBG_G(flags) |= PHPDBG_DISCARD_OUTPUT;
-				phpdbg_string_init(bp_tmp TSRMLS_CC);
-				free(bp_tmp);
-				bp_tmp = NULL;
-				PHPDBG_G(flags) &= ~PHPDBG_DISCARD_OUTPUT;
-			}
+			phpdbg_try_file_init(bp_tmp_file, strlen(bp_tmp_file), 0 TSRMLS_CC);
 		} zend_end_try();
 		PHPDBG_G(flags) &= ~PHPDBG_IS_INITIALIZING;
 		
@@ -1488,61 +1376,50 @@ phpdbg_main:
 			goto phpdbg_out;
 		}
 
-		/* auto compile */
-		if (PHPDBG_G(exec)) {
-			if (settings) {
-				PHPDBG_G(flags) |= PHPDBG_DISCARD_OUTPUT;
-			}
-			phpdbg_compile(TSRMLS_C);
-			PHPDBG_G(flags) &= ~PHPDBG_DISCARD_OUTPUT;
-		}
-
 		/* step from here, not through init */
 		if (step) {
 			PHPDBG_G(flags) |= PHPDBG_IS_STEPPING;
 		}
 
+		if (run) {
+			/* no need to try{}, run does it ... */
+			PHPDBG_COMMAND_HANDLER(run)(NULL TSRMLS_CC);
+			if (run > 1) {
+				/* if -r is on the command line more than once just quit */
+				goto phpdbg_out;
+			}
+		}
+
+/* #ifndef for making compiler shutting up */
+#ifndef _WIN32
 phpdbg_interact:
+#endif
 		/* phpdbg main() */
 		do {
 			zend_try {
-				if (phpdbg_startup_run) {
-					zend_bool quit_immediately = phpdbg_startup_run > 1;
-					phpdbg_startup_run = 0;
-					PHPDBG_COMMAND_HANDLER(run)(NULL TSRMLS_CC);
-					if (quit_immediately) {
-						/* if -r is on the command line more than once just quit */
-						EG(bailout) = __orig_bailout; /* reset zend_try */
-						break;
-					}
-				}
-
-				phpdbg_interactive(1 TSRMLS_CC);
+				phpdbg_interactive(TSRMLS_C);
 			} zend_catch {
 				if ((PHPDBG_G(flags) & PHPDBG_IS_CLEANING)) {
-					char *bp_tmp_str;
-					PHPDBG_G(flags) |= PHPDBG_DISCARD_OUTPUT;
-					phpdbg_export_breakpoints_to_string(&bp_tmp_str TSRMLS_CC);
-					PHPDBG_G(flags) &= ~PHPDBG_DISCARD_OUTPUT;
-					if (bp_tmp_str) {
-						bp_tmp = strdup(bp_tmp_str);
-						efree(bp_tmp_str);
-					}
+					FILE *bp_tmp_fp = fopen(bp_tmp_file, "w");
+					phpdbg_export_breakpoints(bp_tmp_fp TSRMLS_CC);
+					fclose(bp_tmp_fp);
 					cleaning = 1;
 				} else {
 					cleaning = 0;
 				}
 
+#ifndef _WIN32
 				if (!cleaning) {
 					/* remote client disconnected */
 					if ((PHPDBG_G(flags) & PHPDBG_IS_DISCONNECTED)) {
 					
 						if (PHPDBG_G(flags) & PHPDBG_IS_REMOTE) {
 							/* renegociate connections */
-							phpdbg_remote_init(address, listen, server, &socket, &stream TSRMLS_CC);
+							phpdbg_open_sockets(
+								address, listen, &server, &socket, streams);
 				
 							/* set streams */
-							if (stream) {
+							if (streams[0] && streams[1]) {
 								PHPDBG_G(flags) &= ~PHPDBG_IS_QUITTING;
 							}
 				
@@ -1554,37 +1431,31 @@ phpdbg_interact:
 						}
 					}
 				}
+#endif
 			} zend_end_try();
-		} while (!(PHPDBG_G(flags) & PHPDBG_IS_STOPPING));
-
-
-		if (PHPDBG_G(exec) && (PHPDBG_G(flags) & PHPDBG_IS_CLEANING)) {
-			exec = strdup(PHPDBG_G(exec)); /* preserve exec, don't reparse that from cmd */
-		}
-
+		} while(!cleaning && !(PHPDBG_G(flags) & PHPDBG_IS_QUITTING));
+		
 		/* this must be forced */
 		CG(unclean_shutdown) = 0;
 		
 		/* this is just helpful */
 		PG(report_memleaks) = 0;
 		
+#ifndef _WIN32
 phpdbg_out:
 		if ((PHPDBG_G(flags) & PHPDBG_IS_DISCONNECTED)) {
 			PHPDBG_G(flags) &= ~PHPDBG_IS_DISCONNECTED;
 			goto phpdbg_interact;
 		}
+#endif
 
 #ifdef _WIN32
 	} __except(phpdbg_exception_handler_win32(xp = GetExceptionInformation())) {
-		phpdbg_error("segfault", "", "Access violation (Segementation fault) encountered\ntrying to abort cleanly...");
+		phpdbg_error("Access violation (Segementation fault) encountered\ntrying to abort cleanly...");
 	}
+phpdbg_out:
 #endif
-
-		if (cleaning <= 0) {
-			PHPDBG_G(flags) &= ~PHPDBG_IS_CLEANING;
-			cleaning = -1;
-		}
-
+	
 		{
 			int i;
 			/* free argv */
@@ -1594,15 +1465,11 @@ phpdbg_out:
 			efree(SG(request_info).argv);
 		}
 
-#ifndef _WIN32
-		/* reset it... else we risk a stack overflow upon next run (when clean'ing) */
-		php_stream_stdio_ops.write = PHPDBG_G(php_stdiop_write);
-#endif
-
 #ifndef ZTS
 		/* force cleanup of auto and core globals */
 		zend_hash_clean(CG(auto_globals));
-		memset(	&core_globals, 0, sizeof(php_core_globals));
+		memset(
+			&core_globals, 0, sizeof(php_core_globals));
 #endif
 		if (ini_entries) {
 			free(ini_entries);
@@ -1611,34 +1478,14 @@ phpdbg_out:
 		if (ini_override) {
 			free(ini_override);
 		}
-
+		
 		/* this must be forced */
 		CG(unclean_shutdown) = 0;
-
+		
 		/* this is just helpful */
 		PG(report_memleaks) = 0;
 
-		if ((PHPDBG_G(flags) & (PHPDBG_IS_CLEANING | PHPDBG_IS_RUNNING)) == PHPDBG_IS_CLEANING) {
-			php_free_shutdown_functions(TSRMLS_C);
-			zend_objects_store_mark_destructed(&EG(objects_store) TSRMLS_CC);
-		}
-
-		/* sapi_module.deactivate is where to backup things, last chance before mm_shutdown... */
-
-		zend_try {
-			php_request_shutdown(NULL);
-		} zend_end_try();
-
-		if ((PHPDBG_G(flags) & (PHPDBG_IS_QUITTING | PHPDBG_IS_RUNNING)) == PHPDBG_IS_RUNNING) {
-			phpdbg_notice("stop", "type=\"normal\"", "Script ended normally");
-			cleaning++;
-		}
-
-		if ((PHPDBG_G(flags) & PHPDBG_IS_STOPPING) == PHPDBG_IS_CLEANING) {
-			settings = PHPDBG_G(backup);
-		}
-
-		php_output_deactivate(TSRMLS_C);
+		php_request_shutdown((void*)0);
 
 		zend_try {
 			php_module_shutdown(TSRMLS_C);
@@ -1648,10 +1495,10 @@ phpdbg_out:
 
 	}
 
-	if (cleaning > 0 || remote) {
+	if (cleaning || remote) {
 		goto phpdbg_main;
 	}
-
+	
 #ifdef ZTS
 	/* bugggy */
 	/* tsrm_shutdown(); */
@@ -1663,9 +1510,15 @@ phpdbg_out:
 	}
 #endif
 
-	if (PHPDBG_G(sapi_name_ptr)) {
-		free(PHPDBG_G(sapi_name_ptr));
+	if (sapi_name) {
+		free(sapi_name);
 	}
+	
+#ifdef _WIN32
+	free(bp_tmp_file);
+#else
+	unlink(bp_tmp_file);
+#endif
 
 	return 0;
 } /* }}} */
diff --git a/sapi/phpdbg/phpdbg.h b/sapi/phpdbg/phpdbg.h
index a9be80436e..eb4faf1f94 100644
--- a/sapi/phpdbg/phpdbg.h
+++ b/sapi/phpdbg/phpdbg.h
@@ -29,12 +29,6 @@
 # define PHPDBG_API
 #endif
 
-#ifndef PHP_WIN32
-#	include <stdint.h>
-#	include <stddef.h>
-#else
-#	include "win32/php_stdint.h"
-#endif
 #include "php.h"
 #include "php_globals.h"
 #include "php_variables.h"
@@ -46,20 +40,20 @@
 #include "zend_ini_scanner.h"
 #include "zend_stream.h"
 #ifndef _WIN32
-#	include "zend_signal.h"
+# include "zend_signal.h"
 #endif
 #include "SAPI.h"
 #include <fcntl.h>
 #include <sys/types.h>
 #if defined(_WIN32) && !defined(__MINGW32__)
-#	include <windows.h>
-#	include "config.w32.h"
-#	undef  strcasecmp
-#	undef  strncasecmp
-#	define strcasecmp _stricmp 
-#	define strncasecmp _strnicmp 
+# include <windows.h>
+# include "config.w32.h"
+# undef  strcasecmp
+# undef  strncasecmp
+# define strcasecmp _stricmp 
+# define strncasecmp _strnicmp 
 #else
-#	include "php_config.h"
+# include "php_config.h"
 #endif
 #ifndef O_BINARY
 #	define O_BINARY 0
@@ -70,62 +64,28 @@
 # include "TSRM.h"
 #endif
 
-#ifdef HAVE_LIBREADLINE
-#	include <readline/readline.h>
-#	include <readline/history.h>
+#ifdef LIBREADLINE
+#   include <readline/readline.h>
+#   include <readline/history.h>
 #endif
 #ifdef HAVE_LIBEDIT
-#	include <editline/readline.h>
+#   include <editline/readline.h>
 #endif
 
-/* {{{ remote console headers */
-#ifndef _WIN32
-#	include <sys/socket.h>
-#	include <sys/un.h>
-#	include <sys/select.h>
-#	include <sys/types.h>
-#	include <netdb.h>
-#endif /* }}} */
-
-/* {{{ strings */
-#define PHPDBG_NAME "phpdbg"
-#define PHPDBG_AUTHORS "Felipe Pena, Joe Watkins and Bob Weinand" /* Ordered by last name */
-#define PHPDBG_URL "http://phpdbg.com"
-#define PHPDBG_ISSUES "http://github.com/krakjoe/phpdbg/issues"
-#define PHPDBG_VERSION "0.4.0"
-#define PHPDBG_INIT_FILENAME ".phpdbginit"
-#define PHPDBG_DEFAULT_PROMPT "prompt>"
-/* }}} */
-
-/* Hey, apple. One shouldn't define *functions* from the standard C library as marcos. */
-#ifdef memcpy
-#define memcpy_tmp(...) memcpy(__VA_ARGS__)
-#undef memcpy
-#define memcpy(...) memcpy_tmp(__VA_ARGS__)
-#endif
-
-#if !defined(PHPDBG_WEBDATA_TRANSFER_H) && !defined(PHPDBG_WEBHELPER_H)
-
-#ifdef ZTS
-# define PHPDBG_G(v) TSRMG(phpdbg_globals_id, zend_phpdbg_globals *, v)
-#else
-# define PHPDBG_G(v) (phpdbg_globals.v)
-#endif
-
-#include "phpdbg_sigsafe.h"
-#include "phpdbg_out.h"
 #include "phpdbg_lexer.h"
 #include "phpdbg_cmd.h"
 #include "phpdbg_utils.h"
 #include "phpdbg_btree.h"
 #include "phpdbg_watch.h"
-#include "phpdbg_bp.h"
-#ifdef PHP_WIN32
-# include "phpdbg_sigio_win32.h"
-#endif
 
 int phpdbg_do_parse(phpdbg_param_t *stack, char *input TSRMLS_DC);
 
+#ifdef ZTS
+# define PHPDBG_G(v) TSRMG(phpdbg_globals_id, zend_phpdbg_globals *, v)
+#else
+# define PHPDBG_G(v) (phpdbg_globals.v)
+#endif
+
 #define PHPDBG_NEXT   2
 #define PHPDBG_UNTIL  3
 #define PHPDBG_FINISH 4
@@ -135,87 +95,84 @@ int phpdbg_do_parse(phpdbg_param_t *stack, char *input TSRMLS_DC);
  BEGIN: DO NOT CHANGE DO NOT CHANGE DO NOT CHANGE
 */
 
+/* {{{ tables */
+#define PHPDBG_BREAK_FILE            0
+#define PHPDBG_BREAK_SYM             1
+#define PHPDBG_BREAK_OPLINE          2
+#define PHPDBG_BREAK_METHOD          3
+#define PHPDBG_BREAK_COND            4
+#define PHPDBG_BREAK_OPCODE          5
+#define PHPDBG_BREAK_FUNCTION_OPLINE 6
+#define PHPDBG_BREAK_METHOD_OPLINE   7
+#define PHPDBG_BREAK_FILE_OPLINE     8
+#define PHPDBG_BREAK_MAP             9
+#define PHPDBG_BREAK_TABLES          10 /* }}} */
+
 /* {{{ flags */
-#define PHPDBG_HAS_FILE_BP            (1ULL<<1)
-#define PHPDBG_HAS_PENDING_FILE_BP    (1ULL<<2)
-#define PHPDBG_HAS_SYM_BP             (1ULL<<3)
-#define PHPDBG_HAS_OPLINE_BP          (1ULL<<4)
-#define PHPDBG_HAS_METHOD_BP          (1ULL<<5)
-#define PHPDBG_HAS_COND_BP            (1ULL<<6)
-#define PHPDBG_HAS_OPCODE_BP          (1ULL<<7)
-#define PHPDBG_HAS_FUNCTION_OPLINE_BP (1ULL<<8)
-#define PHPDBG_HAS_METHOD_OPLINE_BP   (1ULL<<9)
-#define PHPDBG_HAS_FILE_OPLINE_BP     (1ULL<<10) /* }}} */
+#define PHPDBG_HAS_FILE_BP            (1<<1)
+#define PHPDBG_HAS_SYM_BP             (1<<2)
+#define PHPDBG_HAS_OPLINE_BP          (1<<3)
+#define PHPDBG_HAS_METHOD_BP          (1<<4)
+#define PHPDBG_HAS_COND_BP            (1<<5)
+#define PHPDBG_HAS_OPCODE_BP          (1<<6)
+#define PHPDBG_HAS_FUNCTION_OPLINE_BP (1<<7)
+#define PHPDBG_HAS_METHOD_OPLINE_BP   (1<<8)
+#define PHPDBG_HAS_FILE_OPLINE_BP     (1<<9) /* }}} */
 
 /*
  END: DO NOT CHANGE DO NOT CHANGE DO NOT CHANGE
 */
 
-#define PHPDBG_IN_COND_BP             (1ULL<<11)
-#define PHPDBG_IN_EVAL                (1ULL<<12)
-
-#define PHPDBG_IS_STEPPING            (1ULL<<13)
-#define PHPDBG_STEP_OPCODE            (1ULL<<14)
-#define PHPDBG_IS_QUIET               (1ULL<<15)
-#define PHPDBG_IS_QUITTING            (1ULL<<16)
-#define PHPDBG_IS_COLOURED            (1ULL<<17)
-#define PHPDBG_IS_CLEANING            (1ULL<<18)
-#define PHPDBG_IS_RUNNING             (1ULL<<19)
-
-#define PHPDBG_IN_UNTIL               (1ULL<<20)
-#define PHPDBG_IN_FINISH              (1ULL<<21)
-#define PHPDBG_IN_LEAVE               (1ULL<<22)
+#define PHPDBG_IN_COND_BP             (1<<10)
+#define PHPDBG_IN_EVAL                (1<<11)
 
-#define PHPDBG_IS_REGISTERED          (1ULL<<23)
-#define PHPDBG_IS_STEPONEVAL          (1ULL<<24)
-#define PHPDBG_IS_INITIALIZING        (1ULL<<25)
-#define PHPDBG_IS_SIGNALED            (1ULL<<26)
-#define PHPDBG_IS_INTERACTIVE         (1ULL<<27)
-#define PHPDBG_IS_BP_ENABLED          (1ULL<<28)
-#define PHPDBG_IS_REMOTE              (1ULL<<29)
-#define PHPDBG_IS_DISCONNECTED        (1ULL<<30)
-#define PHPDBG_WRITE_XML              (1ULL<<31)
+#define PHPDBG_IS_STEPPING            (1<<12)
+#define PHPDBG_STEP_OPCODE            (1<<13)
+#define PHPDBG_IS_QUIET               (1<<14)
+#define PHPDBG_IS_QUITTING            (1<<15)
+#define PHPDBG_IS_COLOURED            (1<<16)
+#define PHPDBG_IS_CLEANING            (1<<17)
 
-#define PHPDBG_SHOW_REFCOUNTS         (1ULL<<32)
+#define PHPDBG_IN_UNTIL               (1<<18)
+#define PHPDBG_IN_FINISH              (1<<19)
+#define PHPDBG_IN_LEAVE               (1<<20)
 
-#define PHPDBG_IN_SIGNAL_HANDLER      (1ULL<<33)
+#define PHPDBG_IS_REGISTERED          (1<<21)
+#define PHPDBG_IS_STEPONEVAL          (1<<22)
+#define PHPDBG_IS_INITIALIZING        (1<<23)
+#define PHPDBG_IS_SIGNALED            (1<<24)
+#define PHPDBG_IS_INTERACTIVE         (1<<25)
+#define PHPDBG_IS_BP_ENABLED          (1<<26)
+#define PHPDBG_IS_REMOTE              (1<<27)
+#define PHPDBG_IS_DISCONNECTED        (1<<28)
 
-#define PHPDBG_DISCARD_OUTPUT         (1ULL<<34)
+#define PHPDBG_SHOW_REFCOUNTS         (1<<29)
 
-#define PHPDBG_SEEK_MASK              (PHPDBG_IN_UNTIL | PHPDBG_IN_FINISH | PHPDBG_IN_LEAVE)
-#define PHPDBG_BP_RESOLVE_MASK	      (PHPDBG_HAS_FUNCTION_OPLINE_BP | PHPDBG_HAS_METHOD_OPLINE_BP | PHPDBG_HAS_FILE_OPLINE_BP)
-#define PHPDBG_BP_MASK                (PHPDBG_HAS_FILE_BP | PHPDBG_HAS_SYM_BP | PHPDBG_HAS_METHOD_BP | PHPDBG_HAS_OPLINE_BP | PHPDBG_HAS_COND_BP | PHPDBG_HAS_OPCODE_BP | PHPDBG_HAS_FUNCTION_OPLINE_BP | PHPDBG_HAS_METHOD_OPLINE_BP | PHPDBG_HAS_FILE_OPLINE_BP)
-#define PHPDBG_IS_STOPPING            (PHPDBG_IS_QUITTING | PHPDBG_IS_CLEANING)
-
-#define PHPDBG_PRESERVE_FLAGS_MASK    (PHPDBG_SHOW_REFCOUNTS | PHPDBG_IS_STEPONEVAL | PHPDBG_IS_BP_ENABLED | PHPDBG_STEP_OPCODE | PHPDBG_IS_QUIET | PHPDBG_IS_COLOURED | PHPDBG_IS_REMOTE | PHPDBG_WRITE_XML | PHPDBG_IS_DISCONNECTED)
+#define PHPDBG_SEEK_MASK              (PHPDBG_IN_UNTIL|PHPDBG_IN_FINISH|PHPDBG_IN_LEAVE)
+#define PHPDBG_BP_RESOLVE_MASK		  (PHPDBG_HAS_FUNCTION_OPLINE_BP|PHPDBG_HAS_METHOD_OPLINE_BP|PHPDBG_HAS_FILE_OPLINE_BP)
+#define PHPDBG_BP_MASK                (PHPDBG_HAS_FILE_BP|PHPDBG_HAS_SYM_BP|PHPDBG_HAS_METHOD_BP|PHPDBG_HAS_OPLINE_BP|PHPDBG_HAS_COND_BP|PHPDBG_HAS_OPCODE_BP|PHPDBG_HAS_FUNCTION_OPLINE_BP|PHPDBG_HAS_METHOD_OPLINE_BP|PHPDBG_HAS_FILE_OPLINE_BP)
 
 #ifndef _WIN32
-#	define PHPDBG_DEFAULT_FLAGS (PHPDBG_IS_QUIET | PHPDBG_IS_COLOURED | PHPDBG_IS_BP_ENABLED)
+#	define PHPDBG_DEFAULT_FLAGS (PHPDBG_IS_QUIET|PHPDBG_IS_COLOURED|PHPDBG_IS_BP_ENABLED)
 #else
-#	define PHPDBG_DEFAULT_FLAGS (PHPDBG_IS_QUIET | PHPDBG_IS_BP_ENABLED)
+#	define PHPDBG_DEFAULT_FLAGS (PHPDBG_IS_QUIET|PHPDBG_IS_BP_ENABLED)
 #endif /* }}} */
 
+/* {{{ strings */
+#define PHPDBG_NAME "phpdbg"
+#define PHPDBG_AUTHORS "Felipe Pena, Joe Watkins and Bob Weinand" /* Ordered by last name */
+#define PHPDBG_URL "http://phpdbg.com"
+#define PHPDBG_ISSUES "http://github.com/krakjoe/phpdbg/issues"
+#define PHPDBG_VERSION "0.4.0"
+#define PHPDBG_INIT_FILENAME ".phpdbginit"
+/* }}} */
+
 /* {{{ output descriptors */
 #define PHPDBG_STDIN 			0
 #define PHPDBG_STDOUT			1
 #define PHPDBG_STDERR			2
 #define PHPDBG_IO_FDS 			3 /* }}} */
 
-#define phpdbg_try_access \
-	{                                                            \
-		JMP_BUF *__orig_bailout = PHPDBG_G(sigsegv_bailout); \
-		JMP_BUF __bailout;                                   \
-                                                                     \
-		PHPDBG_G(sigsegv_bailout) = &__bailout;              \
-		if (SETJMP(__bailout) == 0) {
-#define phpdbg_catch_access \
-		} else {                                             \
-			PHPDBG_G(sigsegv_bailout) = __orig_bailout;
-#define phpdbg_end_try_access() \
-		}                                                    \
-			PHPDBG_G(sigsegv_bailout) = __orig_bailout;  \
-	}
-
 
 /* {{{ structs */
 ZEND_BEGIN_MODULE_GLOBALS(phpdbg)
@@ -245,54 +202,29 @@ ZEND_BEGIN_MODULE_GLOBALS(phpdbg)
 	int bp_count;                                /* breakpoint count */
 	int vmret;                                   /* return from last opcode handler execution */
 
-	zend_op_array *(*compile_file)(zend_file_handle *file_handle, int type TSRMLS_DC);
-	HashTable file_sources;
-
 	FILE *oplog;                                 /* opline log */
-	struct {
-		FILE *ptr;
-		int fd;
-	} io[PHPDBG_IO_FDS];                         /* io */
-	int eol;                                     /* type of line ending to use */
-	size_t (*php_stdiop_write)(php_stream *, const char *, size_t TSRMLS_DC);
-	int in_script_xml;                           /* in <stream> output mode */
-	struct {
-		zend_bool active;
-		int type;
-		int fd;
-		char *tag;
-		char *msg;
-		int msglen;
-		char *xml;
-		int xmllen;
-	} err_buf;                                   /* error buffer */
-	zend_ulong req_id;                           /* "request id" to keep track of commands */
+	FILE *io[PHPDBG_IO_FDS];                     /* io */
 
 	char *prompt[2];                             /* prompt */
 	const phpdbg_color_t *colors[PHPDBG_COLORS]; /* colors */
 	char *buffer;                                /* buffer */
-	zend_bool last_was_newline;                  /* check if we don't need to output a newline upon next phpdbg_error or phpdbg_notice */
-
-	char input_buffer[PHPDBG_MAX_CMD];           /* stdin input buffer */
-	int input_buflen;                            /* length of stdin input buffer */
-	phpdbg_signal_safe_mem sigsafe_mem;          /* memory to use in async safe environment (only once!) */
 
-	JMP_BUF *sigsegv_bailout;                    /* bailout address for accesibility probing */
-
-	uint64_t flags;                              /* phpdbg flags */
-
-	char *socket_path;                           /* phpdbg.path ini setting */
-	char *sapi_name_ptr;                         /* store sapi name to free it if necessary to not leak memory */
-	int socket_fd;                               /* file descriptor to socket (wait command) (-1 if unused) */
-	int socket_server_fd;                        /* file descriptor to master socket (wait command) (-1 if unused) */
-#ifdef PHP_WIN32
-	HANDLE sigio_watcher_thread;                 /* sigio watcher thread handle */
-	struct win32_sigio_watcher_data swd;
-#endif
-
-	struct _zend_phpdbg_globals *backup;         /* backup of data to store */
+	zend_ulong flags;                            /* phpdbg flags */
 ZEND_END_MODULE_GLOBALS(phpdbg) /* }}} */
 
-#endif
+/* the beginning (= the important part) of the _zend_mm_heap struct defined in Zend/zend_alloc.c
+   Needed for realizing watchpoints */
+struct _zend_mm_heap {
+	int   use_zend_alloc;
+	void *(*_malloc)(size_t);
+	void  (*_free)(void *);
+	void *(*_realloc)(void *, size_t);
+	size_t              free_bitmap;
+	size_t              large_free_bitmap;
+	size_t              block_size;
+	size_t              compact_size;
+	zend_mm_segment    *segments_list;
+	zend_mm_storage    *storage;
+};
 
 #endif /* PHPDBG_H */
diff --git a/sapi/phpdbg/phpdbg_bp.c b/sapi/phpdbg/phpdbg_bp.c
index 85dc12a3e5..a18316a228 100644
--- a/sapi/phpdbg/phpdbg_bp.c
+++ b/sapi/phpdbg/phpdbg_bp.c
@@ -43,7 +43,8 @@ static inline phpdbg_breakbase_t *phpdbg_find_conditional_breakpoint(zend_execut
 */
 static inline void _phpdbg_break_mapping(int id, HashTable *table TSRMLS_DC)
 {
-	zend_hash_index_update(&PHPDBG_G(bp)[PHPDBG_BREAK_MAP], (id), (void**) &table, sizeof(void*), NULL);
+	zend_hash_index_update(
+		&PHPDBG_G(bp)[PHPDBG_BREAK_MAP], (id), (void**) &table, sizeof(void*), NULL);
 }
 
 #define PHPDBG_BREAK_MAPPING(id, table) _phpdbg_break_mapping(id, table TSRMLS_CC)
@@ -96,8 +97,8 @@ PHPDBG_API void phpdbg_reset_breakpoints(TSRMLS_D) /* {{{ */
 		HashTable **table = NULL;
 
 		for (zend_hash_internal_pointer_reset_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_MAP], &position[0]);
-		     zend_hash_get_current_data_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_MAP], (void **) &table, &position[0]) == SUCCESS;
-		     zend_hash_move_forward_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_MAP], &position[0])) {
+			zend_hash_get_current_data_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_MAP], (void**)&table, &position[0]) == SUCCESS;
+			zend_hash_move_forward_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_MAP], &position[0])) {
 			phpdbg_breakbase_t *brake;
 
 			for (zend_hash_internal_pointer_reset_ex((*table), &position[1]);
@@ -111,81 +112,72 @@ PHPDBG_API void phpdbg_reset_breakpoints(TSRMLS_D) /* {{{ */
 
 PHPDBG_API void phpdbg_export_breakpoints(FILE *handle TSRMLS_DC) /* {{{ */
 {
-	char *string;
-	phpdbg_export_breakpoints_to_string(&string TSRMLS_CC);
-	fputs(string, handle);
-}
-
-PHPDBG_API void phpdbg_export_breakpoints_to_string(char **str TSRMLS_DC) /* {{{ */
-{
 	HashPosition position[2];
 	HashTable **table = NULL;
 	zend_ulong id = 0L;
 
-	*str = "";
-
 	if (zend_hash_num_elements(&PHPDBG_G(bp)[PHPDBG_BREAK_MAP])) {
-		phpdbg_notice("exportbreakpoint", "count=\"%d\"", "Exporting %d breakpoints", zend_hash_num_elements(&PHPDBG_G(bp)[PHPDBG_BREAK_MAP]));
+		phpdbg_notice(
+			"Exporting %d breakpoints",
+			zend_hash_num_elements(&PHPDBG_G(bp)[PHPDBG_BREAK_MAP]));
 		/* this only looks like magic, it isn't */
 		for (zend_hash_internal_pointer_reset_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_MAP], &position[0]);
-		     zend_hash_get_current_data_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_MAP], (void **) &table, &position[0]) == SUCCESS;
-		     zend_hash_move_forward_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_MAP], &position[0])) {
+			zend_hash_get_current_data_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_MAP], (void**)&table, &position[0]) == SUCCESS;
+			zend_hash_move_forward_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_MAP], &position[0])) {
 			phpdbg_breakbase_t *brake;
 
 			zend_hash_get_current_key_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_MAP], NULL, NULL, &id, 0, &position[0]);
 
 			for (zend_hash_internal_pointer_reset_ex((*table), &position[1]);
-			     zend_hash_get_current_data_ex((*table), (void**)&brake, &position[1]) == SUCCESS;
-			     zend_hash_move_forward_ex((*table), &position[1])) {
+				zend_hash_get_current_data_ex((*table), (void**)&brake, &position[1]) == SUCCESS;
+				zend_hash_move_forward_ex((*table), &position[1])) {
 				if (brake->id == id) {
-					char *new_str = NULL;
-
 					switch (brake->type) {
 						case PHPDBG_BREAK_FILE: {
-							phpdbg_asprintf(&new_str,
-								"%sbreak %s:%lu\n", *str,
+							fprintf(handle,
+								"break %s:%lu\n",
 								((phpdbg_breakfile_t*)brake)->filename,
 								((phpdbg_breakfile_t*)brake)->line);
 						} break;
 
 						case PHPDBG_BREAK_SYM: {
-							phpdbg_asprintf(&new_str,
-								"%sbreak %s\n", *str,
+							fprintf(handle,
+								"break %s\n",
 								((phpdbg_breaksymbol_t*)brake)->symbol);
 						} break;
 
 						case PHPDBG_BREAK_METHOD: {
-							phpdbg_asprintf(&new_str,
-								"%sbreak %s::%s\n", *str,
+							fprintf(handle,
+								"break %s::%s\n",
 								((phpdbg_breakmethod_t*)brake)->class_name,
 								((phpdbg_breakmethod_t*)brake)->func_name);
 						} break;
 
 						case PHPDBG_BREAK_METHOD_OPLINE: {
-							phpdbg_asprintf(&new_str,
-								"%sbreak %s::%s#%ld\n", *str,
+							fprintf(handle,
+								"break %s::%s#%ld\n",
 								((phpdbg_breakopline_t*)brake)->class_name,
 								((phpdbg_breakopline_t*)brake)->func_name,
 								((phpdbg_breakopline_t*)brake)->opline_num);
 						} break;
 
 						case PHPDBG_BREAK_FUNCTION_OPLINE: {
-							phpdbg_asprintf(&new_str,
-								"%sbreak %s#%ld\n", *str,
+							fprintf(handle,
+								"break %s#%ld\n",
 								((phpdbg_breakopline_t*)brake)->func_name,
 								((phpdbg_breakopline_t*)brake)->opline_num);
 						} break;
 
 						case PHPDBG_BREAK_FILE_OPLINE: {
-							phpdbg_asprintf(&new_str,
-								"%sbreak %s:#%ld\n", *str,
+							fprintf(handle,
+								"break %s:#%ld\n",
 								((phpdbg_breakopline_t*)brake)->class_name,
 								((phpdbg_breakopline_t*)brake)->opline_num);
 						} break;
 
 						case PHPDBG_BREAK_OPCODE: {
-							phpdbg_asprintf(&new_str,
-								"%sbreak %s\n", *str,
+							fprintf(handle,
+								"break %s\n",
 								((phpdbg_breakop_t*)brake)->name);
 						} break;
 
@@ -195,20 +187,20 @@ PHPDBG_API void phpdbg_export_breakpoints_to_string(char **str TSRMLS_DC) /* {{{
 							if (conditional->paramed) {
 								switch (conditional->param.type) {
 									case STR_PARAM:
-										phpdbg_asprintf(&new_str,
-											"%sbreak at %s if %s\n", *str, conditional->param.str, conditional->code);
+										fprintf(handle,
+											"break at %s if %s\n", conditional->param.str, conditional->code);
 									break;
 
 									case METHOD_PARAM:
-										phpdbg_asprintf(&new_str,
-											"%sbreak at %s::%s if %s\n", *str,
+										fprintf(handle,
+											"break at %s::%s if %s\n",
 											conditional->param.method.class, conditional->param.method.name,
 											conditional->code);
 									break;
 
 									case FILE_PARAM:
-										phpdbg_asprintf(&new_str,
-											"%sbreak at %s:%lu if %s\n", *str,
+										fprintf(handle,
+											"break at %s:%lu if %s\n",
 											conditional->param.file.name, conditional->param.file.line,
 											conditional->code);
 									break;
@@ -216,179 +208,70 @@ PHPDBG_API void phpdbg_export_breakpoints_to_string(char **str TSRMLS_DC) /* {{{
 									default: { /* do nothing */ } break;
 								}
 							} else {
-								phpdbg_asprintf(&new_str, "%sbreak if %s\n", str, conditional->code);
+								fprintf(
+									handle, "break if %s\n", conditional->code);
 							}
 						} break;
 					}
-
-					if ((*str)[0]) {
-						efree(*str);
-					}
-					*str = new_str;
 				}
 			}
 		}
 	}
-
-	if (!(*str)[0]) {
-		*str = NULL;
-	}
 } /* }}} */
 
 PHPDBG_API void phpdbg_set_breakpoint_file(const char *path, long line_num TSRMLS_DC) /* {{{ */
 {
 	php_stream_statbuf ssb;
 	char realpath[MAXPATHLEN];
-	const char *original_path = path;
-	zend_bool pending = 0;
-
-	HashTable *broken, *file_breaks =  &PHPDBG_G(bp)[PHPDBG_BREAK_FILE];
-	phpdbg_breakfile_t new_break;
-	size_t path_len = 0L;
-
-	if (VCWD_REALPATH(path, realpath)) {
-		path = realpath;
-	}
-	path_len = strlen(path);
-
-	phpdbg_debug("file path: %s, resolved path: %s, was compiled: %d\n", original_path, path, zend_hash_exists(&PHPDBG_G(file_sources), path, path_len));
-
-	if (!zend_hash_exists(&PHPDBG_G(file_sources), path, path_len)) {
-		if (php_stream_stat_path(path, &ssb) == FAILURE) {
-			if (original_path[0] == '/') {
-				phpdbg_error("breakpoint", "type=\"nofile\" add=\"fail\" file=\"%s\"", "Cannot stat %s, it does not exist", original_path);
-				return;
+	
+	if (php_stream_stat_path(path, &ssb) != FAILURE) {
+		if (ssb.sb.st_mode & (S_IFREG|S_IFLNK)) {
+			HashTable *broken;
+			phpdbg_breakfile_t new_break;
+			size_t path_len = 0L;
+			
+			if (VCWD_REALPATH(path, realpath)) {
+				path = realpath;
 			}
-
-			file_breaks = &PHPDBG_G(bp)[PHPDBG_BREAK_FILE_PENDING];
-			path = original_path;
 			path_len = strlen(path);
-			pending = 1;
-		} else if (!(ssb.sb.st_mode & (S_IFREG|S_IFLNK))) {
-			phpdbg_error("breakpoint", "type=\"notregular\" add=\"fail\" file=\"%s\"", "Cannot set breakpoint in %s, it is not a regular file", path);
-			return;
-		} else {
-			phpdbg_debug("File exists, but not compiled\n");
-		}
-	}
+			
+			if (zend_hash_find(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE],
+				path, path_len, (void**)&broken) == FAILURE) {
+				HashTable breaks;
 
-	if (zend_hash_find(file_breaks, path, path_len, (void **) &broken) == FAILURE) {
-		HashTable breaks;
-		zend_hash_init(&breaks, 8, NULL, phpdbg_file_breaks_dtor, 0);
-
-		zend_hash_add(file_breaks, path, path_len, &breaks, sizeof(HashTable), (void **) &broken);
-	}
+				zend_hash_init(&breaks, 8, NULL, phpdbg_file_breaks_dtor, 0);
 
-	if (!zend_hash_index_exists(broken, line_num)) {
-		HashPosition position;
-		char *file;
-		uint filelen;
-
-		PHPDBG_BREAK_INIT(new_break, PHPDBG_BREAK_FILE);
-		new_break.filename = estrndup(path, path_len);
-		new_break.line = line_num;
+				zend_hash_update(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE],
+					path, path_len, &breaks, sizeof(HashTable),
+					(void**)&broken);
+			}
 
-		zend_hash_index_update(broken, line_num, (void **) &new_break, sizeof(phpdbg_breakfile_t), NULL);
+			if (!zend_hash_index_exists(broken, line_num)) {
+				PHPDBG_G(flags) |= PHPDBG_HAS_FILE_BP;
 
-		PHPDBG_BREAK_MAPPING(new_break.id, broken);
+				PHPDBG_BREAK_INIT(new_break, PHPDBG_BREAK_FILE);
+				new_break.filename = estrndup(path, path_len);
+				new_break.line = line_num;
 
-		if (pending) {
-			for (zend_hash_internal_pointer_reset_ex(&PHPDBG_G(file_sources), &position);
-			     zend_hash_get_current_key_ex(&PHPDBG_G(file_sources), &file, &filelen, NULL, 0, &position) == HASH_KEY_IS_STRING;
-			     zend_hash_move_forward_ex(&PHPDBG_G(file_sources), &position)) {
-				HashTable *fileht;
+				zend_hash_index_update(
+					broken, line_num, (void**)&new_break, sizeof(phpdbg_breakfile_t), NULL);
 
-				phpdbg_debug("Compare against loaded %s\n", file);
+				phpdbg_notice("Breakpoint #%d added at %s:%ld",
+					new_break.id, new_break.filename, new_break.line);
 
-				if (!(pending = ((fileht = phpdbg_resolve_pending_file_break_ex(file, filelen, path, path_len, broken TSRMLS_CC)) == NULL))) {
-					phpdbg_breakfile_t *brake;
-					zend_hash_index_find(fileht, line_num, (void **) &brake);
-					new_break = *brake;
-					break;
-				}
+				PHPDBG_BREAK_MAPPING(new_break.id, broken);
+			} else {
+				phpdbg_error("Breakpoint at %s:%ld exists", path, line_num);
 			}
-		}
-
-		if (pending) {
-			PHPDBG_G(flags) |= PHPDBG_HAS_PENDING_FILE_BP;
 
-			phpdbg_notice("breakpoint", "add=\"success\" id=\"%d\" file=\"%s\" line=\"%ld\" pending=\"pending\"", "Pending breakpoint #%d added at %s:%ld", new_break.id, new_break.filename, new_break.line);
 		} else {
-			PHPDBG_G(flags) |= PHPDBG_HAS_FILE_BP;
-
-			phpdbg_notice("breakpoint", "add=\"success\" id=\"%d\" file=\"%s\" line=\"%ld\"", "Breakpoint #%d added at %s:%ld", new_break.id, new_break.filename, new_break.line);
+			phpdbg_error("Cannot set breakpoint in %s, it is not a regular file", path);
 		}
 	} else {
-		phpdbg_error("breakpoint", "type=\"exists\" add=\"fail\" file=\"%s\" line=\"%ld\"", "Breakpoint at %s:%ld exists", path, line_num);
+		phpdbg_error("Cannot stat %s, it does not exist", path);
 	}
 } /* }}} */
 
-PHPDBG_API HashTable *phpdbg_resolve_pending_file_break_ex(const char *file, uint filelen, const char *cur, uint curlen, HashTable *fileht TSRMLS_DC) /* {{{ */
-{
-	phpdbg_debug("file: %s, filelen: %u, cur: %s, curlen %u, pos: %c, memcmp: %d\n", file, filelen, cur, curlen, filelen > curlen ? file[filelen - curlen - 1] : '?', filelen > curlen ? memcmp(file + filelen - curlen, cur, curlen) : 0);
-
-	if (((curlen < filelen && file[filelen - curlen - 1] == '/') || filelen == curlen) && !memcmp(file + filelen - curlen, cur, curlen)) {
-		phpdbg_breakfile_t *brake, new_brake;
-		HashTable *master = NULL;
-		HashPosition position;
-
-		PHPDBG_G(flags) |= PHPDBG_HAS_FILE_BP;
-
-		if (zend_hash_find(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE], file, filelen, (void **) &master) == FAILURE) {
-			HashTable new_ht;
-			zend_hash_init(&new_ht, 8, NULL, phpdbg_file_breaks_dtor, 0);
-			zend_hash_add(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE], file, filelen, &new_ht, sizeof(HashTable), (void **) &master);
-		}
-
-		for (zend_hash_internal_pointer_reset_ex(fileht, &position);
-		     zend_hash_get_current_data_ex(fileht, (void**)&brake, &position) == SUCCESS;
-		     zend_hash_move_forward_ex(fileht, &position)) {
-			new_brake = *brake;
-			new_brake.filename = estrndup(file, filelen);
-			PHPDBG_BREAK_UNMAPPING(brake->id);
-
-			if (master) {
-				zend_hash_index_update(master, brake->line, (void **) &new_brake, sizeof(phpdbg_breakfile_t), NULL);
-				PHPDBG_BREAK_MAPPING(brake->id, master);
-			}
-		}
-
-		zend_hash_del(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE_PENDING], cur, curlen);
-
-		if (!zend_hash_num_elements(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE_PENDING])) {
-			PHPDBG_G(flags) &= ~PHPDBG_HAS_PENDING_FILE_BP;
-		}
-
-		phpdbg_debug("compiled file: %s, cur bp file: %s\n", file, cur);
-
-		return master;
-	}
-
-	return NULL;
-} /* }}} */
-
-PHPDBG_API void phpdbg_resolve_pending_file_break(const char *file TSRMLS_DC) /* {{{ */
-{
-	HashPosition position;
-	HashTable *fileht;
-	uint filelen = strlen(file);
-
-	phpdbg_debug("was compiled: %s\n", file);
-
-	zend_hash_internal_pointer_reset_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE_PENDING], &position);
-	while (zend_hash_get_current_data_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE_PENDING], (void**) &fileht, &position) == SUCCESS) {
-		const char *cur;
-		uint curlen;
-
-		zend_hash_get_current_key_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE_PENDING], (char **) &cur, &curlen, NULL, 0, &position);
-		zend_hash_move_forward_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE_PENDING], &position);
-
-		phpdbg_debug("check bp: %s\n", cur);
-
-		phpdbg_resolve_pending_file_break_ex(file, filelen, cur, curlen, fileht TSRMLS_CC);
-	}
-}
-
 PHPDBG_API void phpdbg_set_breakpoint_symbol(const char *name, size_t name_len TSRMLS_DC) /* {{{ */
 {
 	if (!zend_hash_exists(&PHPDBG_G(bp)[PHPDBG_BREAK_SYM], name, name_len)) {
@@ -402,12 +285,12 @@ PHPDBG_API void phpdbg_set_breakpoint_symbol(const char *name, size_t name_len T
 		zend_hash_update(&PHPDBG_G(bp)[PHPDBG_BREAK_SYM], new_break.symbol,
 			name_len, &new_break, sizeof(phpdbg_breaksymbol_t), NULL);
 
-		phpdbg_notice("breakpoint", "add=\"success\" id=\"%d\" function=\"%s\"", "Breakpoint #%d added at %s",
+		phpdbg_notice("Breakpoint #%d added at %s",
 			new_break.id, new_break.symbol);
 
 		PHPDBG_BREAK_MAPPING(new_break.id, &PHPDBG_G(bp)[PHPDBG_BREAK_SYM]);
 	} else {
-		phpdbg_error("breakpoint", "type=\"exists\" add=\"fail\" function=\"%s\"", "Breakpoint exists at %s", name);
+		phpdbg_notice("Breakpoint exists at %s", name);
 	}
 } /* }}} */
 
@@ -441,12 +324,12 @@ PHPDBG_API void phpdbg_set_breakpoint_method(const char *class_name, const char
 		zend_hash_update(class_table, lcname, func_len,
 			&new_break, sizeof(phpdbg_breakmethod_t), NULL);
 
-		phpdbg_notice("breakpoint", "add=\"success\" id=\"%d\" method=\"%s::%s\"", "Breakpoint #%d added at %s::%s",
+		phpdbg_notice("Breakpoint #%d added at %s::%s",
 			new_break.id, class_name, func_name);
 
 		PHPDBG_BREAK_MAPPING(new_break.id, class_table);
 	} else {
-		phpdbg_error("breakpoint", "type=\"exists\" add=\"fail\" method=\"%s::%s\"", "Breakpoint exists at %s::%s", class_name, func_name);
+		phpdbg_notice("Breakpoint exists at %s::%s", class_name, func_name);
 	}
 
 	efree(lcname);
@@ -467,11 +350,11 @@ PHPDBG_API void phpdbg_set_breakpoint_opline(zend_ulong opline TSRMLS_DC) /* {{{
 		zend_hash_index_update(&PHPDBG_G(bp)[PHPDBG_BREAK_OPLINE], opline,
 			&new_break, sizeof(phpdbg_breakline_t), NULL);
 
-		phpdbg_notice("breakpoint", "add=\"success\" id=\"%d\" opline=\"%#lx\"", "Breakpoint #%d added at %#lx",
+		phpdbg_notice("Breakpoint #%d added at %#lx",
 			new_break.id, new_break.opline);
 		PHPDBG_BREAK_MAPPING(new_break.id, &PHPDBG_G(bp)[PHPDBG_BREAK_OPLINE]);
 	} else {
-		phpdbg_error("breakpoint", "type=\"exists\" add=\"fail\" opline=\"%#lx\"", "Breakpoint exists at %#lx", opline);
+		phpdbg_notice("Breakpoint exists at %#lx", opline);
 	}
 } /* }}} */
 
@@ -480,11 +363,11 @@ PHPDBG_API int phpdbg_resolve_op_array_break(phpdbg_breakopline_t *brake, zend_o
 	phpdbg_breakline_t opline_break;
 	if (op_array->last <= brake->opline_num) {
 		if (brake->class_name == NULL) {
-			phpdbg_error("breakpoint", "type=\"maxoplines\" add=\"fail\" maxoplinenum=\"%d\" function=\"%s\" usedoplinenum=\"%ld\"", "There are only %d oplines in function %s (breaking at opline %ld impossible)", op_array->last, brake->func_name, brake->opline_num);
+			phpdbg_error("There are only %d oplines in function %s (breaking at opline %ld impossible)", op_array->last, brake->func_name, brake->opline_num);
 		} else if (brake->func_name == NULL) {
-			phpdbg_error("breakpoint", "type=\"maxoplines\" add=\"fail\" maxoplinenum=\"%d\" file=\"%s\" usedoplinenum=\"%ld\"", "There are only %d oplines in file %s (breaking at opline %ld impossible)", op_array->last, brake->class_name, brake->opline_num);
+			phpdbg_error("There are only %d oplines in file %s (breaking at opline %ld impossible)", op_array->last, brake->class_name, brake->opline_num);
 		} else {
-			phpdbg_error("breakpoint", "type=\"maxoplines\" add=\"fail\" maxoplinenum=\"%d\" method=\"%s::%s\" usedoplinenum=\"%ld\"", "There are only %d oplines in method %s::%s (breaking at opline %ld impossible)", op_array->last, brake->class_name, brake->func_name, brake->opline_num);
+			phpdbg_error("There are only %d oplines in method %s::%s (breaking at opline %ld impossible)", op_array->last, brake->class_name, brake->func_name, brake->opline_num);
 		}
 
 		return FAILURE;
@@ -540,7 +423,7 @@ PHPDBG_API void phpdbg_resolve_op_array_breaks(zend_op_array *op_array TSRMLS_DC
 			zend_hash_internal_pointer_end(&PHPDBG_G(bp)[PHPDBG_BREAK_OPLINE]);
 			zend_hash_get_current_data(&PHPDBG_G(bp)[PHPDBG_BREAK_OPLINE], (void **)&opline_break);
 
-			phpdbg_notice("breakpoint", "add=\"success\" id=\"%d\" symbol=\"%s\" num=\"%ld\" opline=\"%#lx\"", "Breakpoint #%d resolved at %s%s%s#%ld (opline %#lx)",
+			phpdbg_notice("Breakpoint #%d resolved at %s%s%s#%ld (opline %#lx)",
 				brake->id,
 				brake->class_name?brake->class_name:"",
 				brake->class_name&&brake->func_name?"::":"",
@@ -591,7 +474,7 @@ PHPDBG_API int phpdbg_resolve_opline_break(phpdbg_breakopline_t *new_break TSRML
 
 	if (zend_hash_find(func_table, zend_str_tolower_dup(new_break->func_name, new_break->func_len), new_break->func_len + 1, (void **)&func) == FAILURE) {
 		if (new_break->class_name != NULL && new_break->func_name != NULL) {
-			phpdbg_error("breakpoint", "type=\"nomethod\" method=\"%s::%s\"", "Method %s doesn't exist in class %s", new_break->func_name, new_break->class_name);
+			phpdbg_error("Method %s doesn't exist in class %s", new_break->func_name, new_break->class_name);
 			return 2;
 		}
 		return FAILURE;
@@ -599,9 +482,9 @@ PHPDBG_API int phpdbg_resolve_opline_break(phpdbg_breakopline_t *new_break TSRML
 
 	if (func->type != ZEND_USER_FUNCTION) {
 		if (new_break->class_name == NULL) {
-			phpdbg_error("breakpoint", "type=\"internalfunction\" function=\"%s\"", "%s is not an user defined function, no oplines exist", new_break->func_name);
+			phpdbg_error("%s is not an user defined function, no oplines exist", new_break->func_name);
 		} else {
-			phpdbg_error("breakpoint", "type=\"internalfunction\" method=\"%s::%s\"", "%s::%s is not an user defined method, no oplines exist", new_break->class_name, new_break->func_name);
+			phpdbg_error("%s::%s is not an user defined method, no oplines exist", new_break->class_name, new_break->func_name);
 		}
 		return 2;
 	}
@@ -629,11 +512,11 @@ PHPDBG_API void phpdbg_set_breakpoint_method_opline(const char *class, const cha
 
 	switch (phpdbg_resolve_opline_break(&new_break TSRMLS_CC)) {
 		case FAILURE:
-			phpdbg_notice("breakpoint", "pending=\"pending\" id=\"%d\" method=\"%::%s\" num=\"%ld\"", "Pending breakpoint #%d at %s::%s#%ld", new_break.id, new_break.class_name, new_break.func_name, opline);
+			phpdbg_notice("Pending breakpoint #%d at %s::%s#%ld", new_break.id, new_break.class_name, new_break.func_name, opline);
 			break;
 
 		case SUCCESS:
-			phpdbg_notice("breakpoint", "id=\"%d\" method=\"%::%s\" num=\"%ld\"", "Breakpoint #%d added at %s::%s#%ld", new_break.id, new_break.class_name, new_break.func_name, opline);
+			phpdbg_notice("Breakpoint #%d added at %s::%s#%ld", new_break.id, new_break.class_name, new_break.func_name, opline);
 			break;
 
 		case 2:
@@ -659,7 +542,7 @@ PHPDBG_API void phpdbg_set_breakpoint_method_opline(const char *class, const cha
 	}
 
 	if (zend_hash_index_exists(method_table, opline)) {
-		phpdbg_error("breakpoint", "type=\"exists\" method=\"%s\" num=\"%ld\"", "Breakpoint already exists for %s::%s#%ld", new_break.class_name, new_break.func_name, opline);
+		phpdbg_notice("Breakpoint already exists for %s::%s#%ld", new_break.class_name, new_break.func_name, opline);
 		efree((char*)new_break.func_name);
 		efree((char*)new_break.class_name);
 		PHPDBG_G(bp_count)--;
@@ -688,11 +571,11 @@ PHPDBG_API void phpdbg_set_breakpoint_function_opline(const char *function, zend
 
 	switch (phpdbg_resolve_opline_break(&new_break TSRMLS_CC)) {
 		case FAILURE:
-			phpdbg_notice("breakpoint", "pending=\"pending\" id=\"%d\" function=\"%s\" num=\"%ld\"", "Pending breakpoint #%d at %s#%ld", new_break.id, new_break.func_name, opline);
+			phpdbg_notice("Pending breakpoint #%d at %s#%ld", new_break.id, new_break.func_name, opline);
 			break;
 
 		case SUCCESS:
-			phpdbg_notice("breakpoint", "id=\"%d\" function=\"%s\" num=\"%ld\"", "Breakpoint #%d added at %s#%ld", new_break.id, new_break.func_name, opline);
+			phpdbg_notice("Breakpoint #%d added at %s#%ld", new_break.id, new_break.func_name, opline);
 			break;
 
 		case 2:
@@ -709,7 +592,7 @@ PHPDBG_API void phpdbg_set_breakpoint_function_opline(const char *function, zend
 	}
 
 	if (zend_hash_index_exists(func_table, opline)) {
-		phpdbg_error("breakpoint", "type=\"exists\" function=\"%s\" num=\"%ld\"", "Breakpoint already exists for %s#%ld", new_break.func_name, opline);
+		phpdbg_notice("Breakpoint already exists for %s#%ld", new_break.func_name, opline);
 		efree((char*)new_break.func_name);
 		PHPDBG_G(bp_count)--;
 		return;
@@ -737,11 +620,11 @@ PHPDBG_API void phpdbg_set_breakpoint_file_opline(const char *file, zend_ulong o
 
 	switch (phpdbg_resolve_opline_break(&new_break TSRMLS_CC)) {
 		case FAILURE:
-			phpdbg_notice("breakpoint", "pending=\"pending\" id=\"%d\" file=\"%s\" num=\"%ld\"", "Pending breakpoint #%d at %s:%ld", new_break.id, new_break.class_name, opline);
+			phpdbg_notice("Pending breakpoint #%d at %s:%ld", new_break.id, new_break.class_name, opline);
 			break;
 
 		case SUCCESS:
-			phpdbg_notice("breakpoint", "id=\"%d\" file=\"%s\" num=\"%ld\"", "Breakpoint #%d added at %s:%ld", new_break.id, new_break.class_name, opline);
+			phpdbg_notice("Breakpoint #%d added at %s:%ld", new_break.id, new_break.class_name, opline);
 			break;
 
 		case 2:
@@ -758,7 +641,7 @@ PHPDBG_API void phpdbg_set_breakpoint_file_opline(const char *file, zend_ulong o
 	}
 
 	if (zend_hash_index_exists(file_table, opline)) {
-		phpdbg_error("breakpoint", "type=\"exists\" file=\"%s\" num=\"%d\"", "Breakpoint already exists for %s:%ld", new_break.class_name, opline);
+		phpdbg_notice("Breakpoint already exists for %s:%ld", new_break.class_name, opline);
 		efree((char*)new_break.class_name);
 		PHPDBG_G(bp_count)--;
 		return;
@@ -777,7 +660,8 @@ PHPDBG_API void phpdbg_set_breakpoint_opcode(const char *name, size_t name_len T
 	zend_ulong hash = zend_hash_func(name, name_len);
 
 	if (zend_hash_index_exists(&PHPDBG_G(bp)[PHPDBG_BREAK_OPCODE], hash)) {
-		phpdbg_error("breakpoint", "type=\"exists\" opcode=\"%s\"", "Breakpoint exists for %s", name);
+		phpdbg_notice(
+			"Breakpoint exists for %s", name);
 		return;
 	}
 
@@ -790,7 +674,7 @@ PHPDBG_API void phpdbg_set_breakpoint_opcode(const char *name, size_t name_len T
 
 	PHPDBG_G(flags) |= PHPDBG_HAS_OPCODE_BP;
 
-	phpdbg_notice("breakpoint", "id=\"%d\" opcode=\"%s\"", "Breakpoint #%d added at %s", new_break.id, name);
+	phpdbg_notice("Breakpoint #%d added at %s", new_break.id, name);
 	PHPDBG_BREAK_MAPPING(new_break.id, &PHPDBG_G(bp)[PHPDBG_BREAK_OPCODE]);
 } /* }}} */
 
@@ -807,10 +691,9 @@ PHPDBG_API void phpdbg_set_breakpoint_opline_ex(phpdbg_opline_ptr_t opline TSRML
 		zend_hash_index_update(&PHPDBG_G(bp)[PHPDBG_BREAK_OPLINE],
 			(zend_ulong) opline, &new_break, sizeof(phpdbg_breakline_t), NULL);
 
-		phpdbg_notice("breakpoint", "id=\"%d\" opline=\"%#lx\"", "Breakpoint #%d added at %#lx", new_break.id, new_break.opline);
+		phpdbg_notice("Breakpoint #%d added at %#lx",
+			new_break.id, new_break.opline);
 		PHPDBG_BREAK_MAPPING(new_break.id, &PHPDBG_G(bp)[PHPDBG_BREAK_OPLINE]);
-	} else {
-		phpdbg_error("breakpoint", "type=\"exists\" opline=\"%#lx\"", "Breakpoint exists for opline %#lx", (zend_ulong) opline);
 	}
 } /* }}} */
 
@@ -846,7 +729,8 @@ static inline void phpdbg_create_conditional_break(phpdbg_breakcond_t *brake, co
 	Z_STRVAL(pv)[Z_STRLEN(pv)] = '\0';
 	Z_TYPE(pv) = IS_STRING;
 
-	new_break.ops = zend_compile_string(&pv, "Conditional Breakpoint Code" TSRMLS_CC);
+	new_break.ops = zend_compile_string(
+		&pv, "Conditional Breakpoint Code" TSRMLS_CC);
 
 	zval_dtor(&pv);
 
@@ -855,12 +739,14 @@ static inline void phpdbg_create_conditional_break(phpdbg_breakcond_t *brake, co
 			&PHPDBG_G(bp)[PHPDBG_BREAK_COND], hash, &new_break,
 			sizeof(phpdbg_breakcond_t), (void**)&brake);
 
-		phpdbg_notice("breakpoint", "id=\"%d\" expression=\"%s\" ptr=\"%p\"", "Conditional breakpoint #%d added %s/%p", brake->id, brake->code, brake->ops);
+		phpdbg_notice("Conditional breakpoint #%d added %s/%p",
+			brake->id, brake->code, brake->ops);
 
 		PHPDBG_G(flags) |= PHPDBG_HAS_COND_BP;
 		PHPDBG_BREAK_MAPPING(new_break.id, &PHPDBG_G(bp)[PHPDBG_BREAK_COND]);
 	} else {
-		 phpdbg_error("compile", "expression=\"%s\"", "Failed to compile code for expression %s", expr);
+		 phpdbg_error(
+			"Failed to compile code for expression %s", expr);
 		 efree((char*)new_break.code);
 		 PHPDBG_G(bp_count)--;
 	}
@@ -876,7 +762,7 @@ PHPDBG_API void phpdbg_set_breakpoint_expression(const char *expr, size_t expr_l
 		phpdbg_create_conditional_break(
 			&new_break, NULL, expr, expr_len, expr_hash TSRMLS_CC);
 	} else {
-		phpdbg_error("breakpoint", "type=\"exists\" expression=\"%s\"", "Conditional break %s exists", expr);
+		phpdbg_notice("Conditional break %s exists", expr);
 	}
 } /* }}} */
 
@@ -885,39 +771,31 @@ PHPDBG_API void phpdbg_set_breakpoint_at(const phpdbg_param_t *param TSRMLS_DC)
 	phpdbg_breakcond_t new_break;
 	phpdbg_param_t *condition;
 	zend_ulong hash = 0L;
-
+	
 	if (param->next) {
 		condition = param->next;
 		hash = zend_inline_hash_func(condition->str, condition->len);
-
+		
 		if (!zend_hash_index_exists(&PHPDBG_G(bp)[PHPDBG_BREAK_COND], hash)) {
-			phpdbg_create_conditional_break(&new_break, param, condition->str, condition->len, hash TSRMLS_CC);
+			phpdbg_create_conditional_break(
+				&new_break, param, 
+					condition->str, condition->len, hash TSRMLS_CC);
 		} else {
-			phpdbg_notice("breakpoint", "type=\"exists\" arg=\"%s\"", "Conditional break %s exists at the specified location", condition->str);
-		}
+			phpdbg_notice(
+				"Conditional break %s exists at the specified location", condition->str);
+		}	
 	}
-
+	
 } /* }}} */
 
 static inline phpdbg_breakbase_t *phpdbg_find_breakpoint_file(zend_op_array *op_array TSRMLS_DC) /* {{{ */
 {
 	HashTable *breaks;
 	phpdbg_breakbase_t *brake;
-	size_t path_len;
-	char realpath[MAXPATHLEN];
-	const char *path = op_array->filename;
-
-	if (VCWD_REALPATH(path, realpath)) {
-		path = realpath;
-	}
-
-	path_len = strlen(path);
-
-#if 0
-	phpdbg_debug("Op at: %.*s %d\n", path_len, path, (*EG(opline_ptr))->lineno);
-#endif
+	size_t name_len = strlen(op_array->filename);
 
-	if (zend_hash_find(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE], path, path_len, (void**)&breaks) == FAILURE) {
+	if (zend_hash_find(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE], op_array->filename,
+		name_len, (void**)&breaks) == FAILURE) {
 		return NULL;
 	}
 
@@ -1092,6 +970,7 @@ static inline phpdbg_breakbase_t *phpdbg_find_conditional_breakpoint(zend_execut
 	     zend_hash_get_current_data_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_COND], (void*)&bp, &position) == SUCCESS;
 	     zend_hash_move_forward_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_COND], &position)) {
 		zval *retval = NULL;
+		int orig_interactive = CG(interactive);
 		zval **orig_retval = EG(return_value_ptr_ptr);
 		zend_op_array *orig_ops = EG(active_op_array);
 		zend_op **orig_opline = EG(opline_ptr);
@@ -1116,6 +995,8 @@ static inline phpdbg_breakbase_t *phpdbg_find_conditional_breakpoint(zend_execut
 			zend_rebuild_symbol_table(TSRMLS_C);
 		}
 
+		CG(interactive) = 0;
+
 		zend_try {
 			PHPDBG_G(flags) |= PHPDBG_IN_COND_BP;
 			zend_execute(EG(active_op_array) TSRMLS_CC);
@@ -1127,6 +1008,8 @@ static inline phpdbg_breakbase_t *phpdbg_find_conditional_breakpoint(zend_execut
 				breakpoint = SUCCESS;
 			}
 		} zend_catch {
+			CG(interactive) = orig_interactive;
+
 			EG(no_extensions)=1;
 			EG(return_value_ptr_ptr) = orig_retval;
 			EG(active_op_array) = orig_ops;
@@ -1134,6 +1017,8 @@ static inline phpdbg_breakbase_t *phpdbg_find_conditional_breakpoint(zend_execut
 			PHPDBG_G(flags) &= ~PHPDBG_IN_COND_BP;
  		} zend_end_try();
 
+		CG(interactive) = orig_interactive;
+
 		EG(no_extensions)=1;
 		EG(return_value_ptr_ptr) = orig_retval;
 		EG(active_op_array) = orig_ops;
@@ -1263,17 +1148,16 @@ PHPDBG_API void phpdbg_delete_breakpoint(zend_ulong num TSRMLS_DC) /* {{{ */
 			break;
 		}
 
-		phpdbg_notice("breakpoint", "deleted=\"success\" id=\"%ld\"", "Deleted breakpoint #%ld", num);
+		phpdbg_notice("Deleted breakpoint #%ld", num);
 		PHPDBG_BREAK_UNMAPPING(num);
 	} else {
-		phpdbg_error("breakpoint", "type=\"nobreakpoint\" deleted=\"fail\" id=\"%ld\"", "Failed to find breakpoint #%ld", num);
+		phpdbg_error("Failed to find breakpoint #%ld", num);
 	}
 } /* }}} */
 
 PHPDBG_API void phpdbg_clear_breakpoints(TSRMLS_D) /* {{{ */
 {
 	zend_hash_clean(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE]);
-	zend_hash_clean(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE_PENDING]);
 	zend_hash_clean(&PHPDBG_G(bp)[PHPDBG_BREAK_SYM]);
 	zend_hash_clean(&PHPDBG_G(bp)[PHPDBG_BREAK_OPLINE]);
 	zend_hash_clean(&PHPDBG_G(bp)[PHPDBG_BREAK_METHOD_OPLINE]);
@@ -1305,7 +1189,7 @@ PHPDBG_API void phpdbg_print_breakpoint(phpdbg_breakbase_t *brake TSRMLS_DC) /*
 
 	switch (brake->type) {
 		case PHPDBG_BREAK_FILE: {
-			phpdbg_notice("breakpoint", "id=\"%d\" file=\"%s\" line=\"%ld\" hits=\"%lu\"", "Breakpoint #%d at %s:%ld, hits: %lu",
+			phpdbg_notice("Breakpoint #%d at %s:%ld, hits: %lu",
 				((phpdbg_breakfile_t*)brake)->id,
 				((phpdbg_breakfile_t*)brake)->filename,
 				((phpdbg_breakfile_t*)brake)->line,
@@ -1313,7 +1197,7 @@ PHPDBG_API void phpdbg_print_breakpoint(phpdbg_breakbase_t *brake TSRMLS_DC) /*
 		} break;
 
 		case PHPDBG_BREAK_SYM: {
-			phpdbg_notice("breakpoint", "id=\"%d\" function=\"%s\" file=\"%s\" line=\"%ld\" hits=\"%lu\"", "Breakpoint #%d in %s() at %s:%u, hits: %lu",
+			phpdbg_notice("Breakpoint #%d in %s() at %s:%u, hits: %lu",
 				((phpdbg_breaksymbol_t*)brake)->id,
 				((phpdbg_breaksymbol_t*)brake)->symbol,
 				zend_get_executed_filename(TSRMLS_C),
@@ -1322,7 +1206,7 @@ PHPDBG_API void phpdbg_print_breakpoint(phpdbg_breakbase_t *brake TSRMLS_DC) /*
 		} break;
 
 		case PHPDBG_BREAK_OPLINE: {
-			phpdbg_notice("breakpoint", "id=\"%d\" opline=\"%#lx\" file=\"%s\" line=\"%ld\" hits=\"%lu\"", "Breakpoint #%d in %#lx at %s:%u, hits: %lu",
+			phpdbg_notice("Breakpoint #%d in %#lx at %s:%u, hits: %lu",
 				((phpdbg_breakline_t*)brake)->id,
 				((phpdbg_breakline_t*)brake)->opline,
 				zend_get_executed_filename(TSRMLS_C),
@@ -1331,7 +1215,7 @@ PHPDBG_API void phpdbg_print_breakpoint(phpdbg_breakbase_t *brake TSRMLS_DC) /*
 		} break;
 
 		case PHPDBG_BREAK_METHOD_OPLINE: {
-			 phpdbg_notice("breakpoint", "id=\"%d\" method=\"%s::%s\" num=\"%lu\" file=\"%s\" line=\"%ld\" hits=\"%lu\"", "Breakpoint #%d in %s::%s()#%lu at %s:%u, hits: %lu",
+			 phpdbg_notice("Breakpoint #%d in %s::%s()#%lu at %s:%u, hits: %lu",
 				((phpdbg_breakopline_t*)brake)->id,
 				((phpdbg_breakopline_t*)brake)->class_name,
 				((phpdbg_breakopline_t*)brake)->func_name,
@@ -1342,7 +1226,7 @@ PHPDBG_API void phpdbg_print_breakpoint(phpdbg_breakbase_t *brake TSRMLS_DC) /*
 		} break;
 
 		case PHPDBG_BREAK_FUNCTION_OPLINE: {
-			 phpdbg_notice("breakpoint", "id=\"%d\" num=\"%lu\" function=\"%s\" file=\"%s\" line=\"%ld\" hits=\"%lu\"", "Breakpoint #%d in %s()#%lu at %s:%u, hits: %lu",
+			 phpdbg_notice("Breakpoint #%d in %s()#%lu at %s:%u, hits: %lu",
 				((phpdbg_breakopline_t*)brake)->id,
 				((phpdbg_breakopline_t*)brake)->func_name,
 				((phpdbg_breakopline_t*)brake)->opline_num,
@@ -1352,8 +1236,9 @@ PHPDBG_API void phpdbg_print_breakpoint(phpdbg_breakbase_t *brake TSRMLS_DC) /*
 		} break;
 
 		case PHPDBG_BREAK_FILE_OPLINE: {
-			 phpdbg_notice("breakpoint", "id=\"%d\" num=\"%lu\" file=\"%s\" line=\"%ld\" hits=\"%lu\"", "Breakpoint #%d in #%lu at %s:%u, hits: %lu",
+			 phpdbg_notice("Breakpoint #%d in %s:%lu at %s:%u, hits: %lu",
 				((phpdbg_breakopline_t*)brake)->id,
+				((phpdbg_breakopline_t*)brake)->class_name,
 				((phpdbg_breakopline_t*)brake)->opline_num,
 				zend_get_executed_filename(TSRMLS_C),
 				zend_get_executed_lineno(TSRMLS_C),
@@ -1361,7 +1246,7 @@ PHPDBG_API void phpdbg_print_breakpoint(phpdbg_breakbase_t *brake TSRMLS_DC) /*
 		} break;
 
 		case PHPDBG_BREAK_OPCODE: {
-			 phpdbg_notice("breakpoint", "id=\"%d\" opcode=\"%s\" file=\"%s\" line=\"%ld\" hits=\"%lu\"", "Breakpoint #%d in %s at %s:%u, hits: %lu",
+			 phpdbg_notice("Breakpoint #%d in %s at %s:%u, hits: %lu",
 				((phpdbg_breakop_t*)brake)->id,
 				((phpdbg_breakop_t*)brake)->name,
 				zend_get_executed_filename(TSRMLS_C),
@@ -1370,7 +1255,7 @@ PHPDBG_API void phpdbg_print_breakpoint(phpdbg_breakbase_t *brake TSRMLS_DC) /*
 		} break;
 
 		case PHPDBG_BREAK_METHOD: {
-			 phpdbg_notice("breakpoint", "id=\"%d\" method=\"%s::%s\" file=\"%s\" line=\"%ld\" hits=\"%lu\"", "Breakpoint #%d in %s::%s() at %s:%u, hits: %lu",
+			 phpdbg_notice("Breakpoint #%d in %s::%s() at %s:%u, hits: %lu",
 				((phpdbg_breakmethod_t*)brake)->id,
 				((phpdbg_breakmethod_t*)brake)->class_name,
 				((phpdbg_breakmethod_t*)brake)->func_name,
@@ -1382,7 +1267,7 @@ PHPDBG_API void phpdbg_print_breakpoint(phpdbg_breakbase_t *brake TSRMLS_DC) /*
 		case PHPDBG_BREAK_COND: {
 			if (((phpdbg_breakcond_t*)brake)->paramed) {
 				char *param;
-				phpdbg_notice("breakpoint", "id=\"%d\" location=\"%s\" eval=\"%s\" file=\"%s\" line=\"%ld\" hits=\"%lu\"", "Conditional breakpoint #%d: at %s if %s at %s:%u, hits: %lu",
+				phpdbg_notice("Conditional breakpoint #%d: at %s if %s %s:%u, hits: %lu",
 					((phpdbg_breakcond_t*)brake)->id,
 					phpdbg_param_tostring(&((phpdbg_breakcond_t*)brake)->param, &param TSRMLS_CC),
 					((phpdbg_breakcond_t*)brake)->code,
@@ -1392,7 +1277,7 @@ PHPDBG_API void phpdbg_print_breakpoint(phpdbg_breakbase_t *brake TSRMLS_DC) /*
 				if (param)
 					free(param);
 			} else {
-				phpdbg_notice("breakpoint", "id=\"%d\" eval=\"%s\" file=\"%s\" line=\"%ld\" hits=\"%lu\"", "Conditional breakpoint #%d: on %s == true at %s:%u, hits: %lu",
+				phpdbg_notice("Conditional breakpoint #%d: on %s == true %s:%u, hits: %lu",
 					((phpdbg_breakcond_t*)brake)->id,
 					((phpdbg_breakcond_t*)brake)->code,
 					zend_get_executed_filename(TSRMLS_C),
@@ -1404,7 +1289,7 @@ PHPDBG_API void phpdbg_print_breakpoint(phpdbg_breakbase_t *brake TSRMLS_DC) /*
 
 		default: {
 unknown:
-			phpdbg_notice("breakpoint", "id=\"\" file=\"%s\" line=\"%ld\" hits=\"%lu\"", "Unknown breakpoint at %s:%u",
+			phpdbg_notice("Unknown breakpoint at %s:%u",
 				zend_get_executed_filename(TSRMLS_C),
 				zend_get_executed_lineno(TSRMLS_C));
 		}
@@ -1465,19 +1350,17 @@ PHPDBG_API phpdbg_breakbase_t *phpdbg_find_breakbase_ex(zend_ulong id, HashTable
 
 PHPDBG_API void phpdbg_print_breakpoints(zend_ulong type TSRMLS_DC) /* {{{ */
 {
-	phpdbg_xml("<breakpoints %r>");
-
 	switch (type) {
 		case PHPDBG_BREAK_SYM: if ((PHPDBG_G(flags) & PHPDBG_HAS_SYM_BP)) {
 			HashPosition position;
 			phpdbg_breaksymbol_t *brake;
 
-			phpdbg_out(SEPARATE "\n");
-			phpdbg_out("Function Breakpoints:\n");
+			phpdbg_writeln(SEPARATE);
+			phpdbg_writeln("Function Breakpoints:");
 			for (zend_hash_internal_pointer_reset_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_SYM], &position);
 			     zend_hash_get_current_data_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_SYM], (void**) &brake, &position) == SUCCESS;
 			     zend_hash_move_forward_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_SYM], &position)) {
-				phpdbg_writeln("function", "id=\"%d\" name=\"%s\" disabled=\"%s\"", "#%d\t\t%s%s",
+				phpdbg_writeln("#%d\t\t%s%s",
 					brake->id, brake->symbol,
 					((phpdbg_breakbase_t*)brake)->disabled ? " [disabled]" : "");
 			}
@@ -1490,8 +1373,8 @@ PHPDBG_API void phpdbg_print_breakpoints(zend_ulong type TSRMLS_DC) /* {{{ */
 			zend_uint class_len = 0;
 			zend_ulong class_idx = 0L;
 
-			phpdbg_out(SEPARATE "\n");
-			phpdbg_out("Method Breakpoints:\n");
+			phpdbg_writeln(SEPARATE);
+			phpdbg_writeln("Method Breakpoints:");
 			for (zend_hash_internal_pointer_reset_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_METHOD], &position[0]);
 			     zend_hash_get_current_data_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_METHOD], (void**) &class_table, &position[0]) == SUCCESS;
 			     zend_hash_move_forward_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_METHOD], &position[0])) {
@@ -1503,7 +1386,7 @@ PHPDBG_API void phpdbg_print_breakpoints(zend_ulong type TSRMLS_DC) /* {{{ */
 					for (zend_hash_internal_pointer_reset_ex(class_table, &position[1]);
 					     zend_hash_get_current_data_ex(class_table, (void**)&brake, &position[1]) == SUCCESS;
 					     zend_hash_move_forward_ex(class_table, &position[1])) {
-						phpdbg_writeln("method", "id=\"%d\" name=\"%s::%s\" disabled=\"%s\"", "#%d\t\t%s::%s%s",
+						phpdbg_writeln("#%d\t\t%s::%s%s",
 							brake->id, brake->class_name, brake->func_name,
 							((phpdbg_breakbase_t*)brake)->disabled ? " [disabled]" : "");
 					}
@@ -1516,8 +1399,8 @@ PHPDBG_API void phpdbg_print_breakpoints(zend_ulong type TSRMLS_DC) /* {{{ */
 			HashPosition position[2];
 			HashTable *points;
 
-			phpdbg_out(SEPARATE "\n");
-			phpdbg_out("File Breakpoints:\n");
+			phpdbg_writeln(SEPARATE);
+			phpdbg_writeln("File Breakpoints:");
 			for (zend_hash_internal_pointer_reset_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE], &position[0]);
 			     zend_hash_get_current_data_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE], (void**) &points, &position[0]) == SUCCESS;
 			     zend_hash_move_forward_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE], &position[0])) {
@@ -1526,26 +1409,7 @@ PHPDBG_API void phpdbg_print_breakpoints(zend_ulong type TSRMLS_DC) /* {{{ */
 				for (zend_hash_internal_pointer_reset_ex(points, &position[1]);
 				     zend_hash_get_current_data_ex(points, (void**)&brake, &position[1]) == SUCCESS;
 				     zend_hash_move_forward_ex(points, &position[1])) {
-					phpdbg_writeln("file", "id=\"%d\" name=\"%s\" line=\"%lu\" disabled=\"%s\"", "#%d\t\t%s:%lu%s",
-						brake->id, brake->filename, brake->line,
-						((phpdbg_breakbase_t*)brake)->disabled ? " [disabled]" : "");
-				}
-			}
-		}  if ((PHPDBG_G(flags) & PHPDBG_HAS_PENDING_FILE_BP)) {
-			HashPosition position[2];
-			HashTable *points;
-
-			phpdbg_out(SEPARATE "\n");
-			phpdbg_out("Pending File Breakpoints:\n");
-			for (zend_hash_internal_pointer_reset_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE_PENDING], &position[0]);
-			     zend_hash_get_current_data_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE_PENDING], (void**) &points, &position[0]) == SUCCESS;
-			     zend_hash_move_forward_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE_PENDING], &position[0])) {
-				phpdbg_breakfile_t *brake;
-
-				for (zend_hash_internal_pointer_reset_ex(points, &position[1]);
-				     zend_hash_get_current_data_ex(points, (void**)&brake, &position[1]) == SUCCESS;
-				     zend_hash_move_forward_ex(points, &position[1])) {
-					phpdbg_writeln("file", "id=\"%d\" name=\"%s\" line=\"%lu\" disabled=\"%s\" pending=\"pending\"", "#%d\t\t%s:%lu%s",
+					phpdbg_writeln("#%d\t\t%s:%lu%s",
 						brake->id, brake->filename, brake->line,
 						((phpdbg_breakbase_t*)brake)->disabled ? " [disabled]" : "");
 				}
@@ -1557,8 +1421,8 @@ PHPDBG_API void phpdbg_print_breakpoints(zend_ulong type TSRMLS_DC) /* {{{ */
 			HashPosition position;
 			phpdbg_breakline_t *brake;
 
-			phpdbg_out(SEPARATE "\n");
-			phpdbg_out("Opline Breakpoints:\n");
+			phpdbg_writeln(SEPARATE);
+			phpdbg_writeln("Opline Breakpoints:");
 			for (zend_hash_internal_pointer_reset_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_OPLINE], &position);
 			     zend_hash_get_current_data_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_OPLINE], (void**) &brake, &position) == SUCCESS;
 			     zend_hash_move_forward_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_OPLINE], &position)) {
@@ -1566,16 +1430,16 @@ PHPDBG_API void phpdbg_print_breakpoints(zend_ulong type TSRMLS_DC) /* {{{ */
 					case PHPDBG_BREAK_METHOD_OPLINE:
 					case PHPDBG_BREAK_FUNCTION_OPLINE:
 					case PHPDBG_BREAK_FILE_OPLINE:
-						phpdbg_writeln("opline", "id=\"%d\" num=\"%#lx\" type=\"%s\" disabled=\"%s\"", "#%d\t\t%#lx\t\t(%s breakpoint)%s", brake->id, brake->opline,
-							brake->type == PHPDBG_BREAK_METHOD_OPLINE ? "method" :
-								brake->type == PHPDBG_BREAK_FUNCTION_OPLINE ? "function" :
-									brake->type == PHPDBG_BREAK_FILE_OPLINE ? "file" :
+						phpdbg_writeln("#%d\t\t%#lx\t\t(%s breakpoint)%s", brake->id, brake->opline,
+							brake->type == PHPDBG_BREAK_METHOD_OPLINE?"method":
+								brake->type == PHPDBG_BREAK_FUNCTION_OPLINE?"function":
+									brake->type == PHPDBG_BREAK_FILE_OPLINE?"file":
 										"--- error ---",
 							((phpdbg_breakbase_t*)brake)->disabled ? " [disabled]" : "");
 						break;
 
 					default:
-						phpdbg_writeln("opline", "id=\"%d\" num=\"%#lx\" disabled=\"%s\"", "#%d\t\t%#lx%s", brake->id, brake->opline, ((phpdbg_breakbase_t*)brake)->disabled ? " [disabled]" : "");
+						phpdbg_writeln("#%d\t\t%#lx", brake->id, brake->opline);
 						break;
 				}
 			}
@@ -1588,8 +1452,8 @@ PHPDBG_API void phpdbg_print_breakpoints(zend_ulong type TSRMLS_DC) /* {{{ */
 			zend_uint class_len = 0, method_len = 0;
 			zend_ulong class_idx = 0L, method_idx = 0L;
 
-			phpdbg_out(SEPARATE "\n");
-			phpdbg_out("Method opline Breakpoints:\n");
+			phpdbg_writeln(SEPARATE);
+			phpdbg_writeln("Method opline Breakpoints:");
 			for (zend_hash_internal_pointer_reset_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_METHOD_OPLINE], &position[0]);
 			     zend_hash_get_current_data_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_METHOD_OPLINE], (void**) &class_table, &position[0]) == SUCCESS;
 			     zend_hash_move_forward_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_METHOD_OPLINE], &position[0])) {
@@ -1609,7 +1473,7 @@ PHPDBG_API void phpdbg_print_breakpoints(zend_ulong type TSRMLS_DC) /* {{{ */
 							for (zend_hash_internal_pointer_reset_ex(method_table, &position[2]);
 							     zend_hash_get_current_data_ex(method_table, (void**)&brake, &position[2]) == SUCCESS;
 							     zend_hash_move_forward_ex(method_table, &position[2])) {
-								phpdbg_writeln("methodopline", "id=\"%d\" name=\"%s::%s\" num=\"%ld\" disabled=\"%s\"", "#%d\t\t%s::%s opline %ld%s",
+								phpdbg_writeln("#%d\t\t%s::%s opline %ld%s",
 									brake->id, brake->class_name, brake->func_name, brake->opline_num,
 									((phpdbg_breakbase_t*)brake)->disabled ? " [disabled]" : "");
 							}
@@ -1627,8 +1491,8 @@ PHPDBG_API void phpdbg_print_breakpoints(zend_ulong type TSRMLS_DC) /* {{{ */
 			zend_uint function_len = 0;
 			zend_ulong function_idx = 0L;
 
-			phpdbg_out(SEPARATE "\n");
-			phpdbg_out("Function opline Breakpoints:\n");
+			phpdbg_writeln(SEPARATE);
+			phpdbg_writeln("Function opline Breakpoints:");
 			for (zend_hash_internal_pointer_reset_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_FUNCTION_OPLINE], &position[0]);
 			     zend_hash_get_current_data_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_FUNCTION_OPLINE], (void**) &function_table, &position[0]) == SUCCESS;
 			     zend_hash_move_forward_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_FUNCTION_OPLINE], &position[0])) {
@@ -1641,7 +1505,7 @@ PHPDBG_API void phpdbg_print_breakpoints(zend_ulong type TSRMLS_DC) /* {{{ */
 					for (zend_hash_internal_pointer_reset_ex(function_table, &position[1]);
 					     zend_hash_get_current_data_ex(function_table, (void**)&brake, &position[1]) == SUCCESS;
 					     zend_hash_move_forward_ex(function_table, &position[1])) {
-						phpdbg_writeln("functionopline", "id=\"%d\" name=\"%s\" num=\"%ld\" disabled=\"%s\"", "#%d\t\t%s opline %ld%s",
+						phpdbg_writeln("#%d\t\t%s opline %ld%s",
 							brake->id, brake->func_name, brake->opline_num,
 							((phpdbg_breakbase_t*)brake)->disabled ? " [disabled]" : "");
 					}
@@ -1657,8 +1521,8 @@ PHPDBG_API void phpdbg_print_breakpoints(zend_ulong type TSRMLS_DC) /* {{{ */
 			zend_uint file_len = 0;
 			zend_ulong file_idx = 0L;
 
-			phpdbg_out(SEPARATE "\n");
-			phpdbg_out("File opline Breakpoints:\n");
+			phpdbg_writeln(SEPARATE);
+			phpdbg_writeln("File opline Breakpoints:");
 			for (zend_hash_internal_pointer_reset_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE_OPLINE], &position[0]);
 			     zend_hash_get_current_data_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE_OPLINE], (void**) &file_table, &position[0]) == SUCCESS;
 			     zend_hash_move_forward_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE_OPLINE], &position[0])) {
@@ -1671,7 +1535,7 @@ PHPDBG_API void phpdbg_print_breakpoints(zend_ulong type TSRMLS_DC) /* {{{ */
 					for (zend_hash_internal_pointer_reset_ex(file_table, &position[1]);
 					     zend_hash_get_current_data_ex(file_table, (void**)&brake, &position[1]) == SUCCESS;
 					     zend_hash_move_forward_ex(file_table, &position[1])) {
-						phpdbg_writeln("fileopline", "id=\"%d\" name=\"%s\" num=\"%ld\" disabled=\"%s\"", "#%d\t\t%s opline %ld%s",
+						phpdbg_writeln("#%d\t\t%s opline %ld%s",
 							brake->id, brake->class_name, brake->opline_num,
 							((phpdbg_breakbase_t*)brake)->disabled ? " [disabled]" : "");
 					}
@@ -1683,15 +1547,15 @@ PHPDBG_API void phpdbg_print_breakpoints(zend_ulong type TSRMLS_DC) /* {{{ */
 			HashPosition position;
 			phpdbg_breakcond_t *brake;
 
-			phpdbg_out(SEPARATE "\n");
-			phpdbg_out("Conditional Breakpoints:\n");
+			phpdbg_writeln(SEPARATE);
+			phpdbg_writeln("Conditional Breakpoints:");
 			for (zend_hash_internal_pointer_reset_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_COND], &position);
 			     zend_hash_get_current_data_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_COND], (void**) &brake, &position) == SUCCESS;
 			     zend_hash_move_forward_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_COND], &position)) {
 				if (brake->paramed) {
 					switch (brake->param.type) {
 						case STR_PARAM:
-							phpdbg_writeln("evalfunction", "id=\"%d\" name=\"%s\" eval=\"%s\" disabled=\"%s\"", "#%d\t\tat %s if %s%s",
+							phpdbg_writeln("#%d\t\tat %s if %s%s",
 				 				brake->id,
 				 				brake->param.str,
 				 				brake->code,
@@ -1699,7 +1563,7 @@ PHPDBG_API void phpdbg_print_breakpoints(zend_ulong type TSRMLS_DC) /* {{{ */
 						break;
 
 						case NUMERIC_FUNCTION_PARAM:
-							phpdbg_writeln("evalfunctionopline", "id=\"%d\" name=\"%s\" num=\"%ld\" eval=\"%s\" disabled=\"%s\"", "#%d\t\tat %s#%ld if %s%s",
+							phpdbg_writeln("#%d\t\tat %s#%ld if %s%s",
 				 				brake->id,
 				 				brake->param.str,
 								brake->param.num,
@@ -1708,7 +1572,7 @@ PHPDBG_API void phpdbg_print_breakpoints(zend_ulong type TSRMLS_DC) /* {{{ */
 						break;
 
 						case METHOD_PARAM:
-							phpdbg_writeln("evalmethod", "id=\"%d\" name=\"%s::%s\" eval=\"%s\" disabled=\"%s\"", "#%d\t\tat %s::%s if %s%s",
+							phpdbg_writeln("#%d\t\tat %s::%s if %s%s",
 				 				brake->id,
 				 				brake->param.method.class,
 				 				brake->param.method.name,
@@ -1717,7 +1581,7 @@ PHPDBG_API void phpdbg_print_breakpoints(zend_ulong type TSRMLS_DC) /* {{{ */
 						break;
 
 						case NUMERIC_METHOD_PARAM:
-							phpdbg_writeln("evalmethodopline", "id=\"%d\" name=\"%s::%s\" num=\"%d\" eval=\"%s\" disabled=\"%s\"", "#%d\t\tat %s::%s#%ld if %s%s",
+							phpdbg_writeln("#%d\t\tat %s::%s#%ld if %s%s",
 				 				brake->id,
 				 				brake->param.method.class,
 				 				brake->param.method.name,
@@ -1727,7 +1591,7 @@ PHPDBG_API void phpdbg_print_breakpoints(zend_ulong type TSRMLS_DC) /* {{{ */
 						break;
 
 						case FILE_PARAM:
-							phpdbg_writeln("evalfile", "id=\"%d\" name=\"%s\" line=\"%d\" eval=\"%s\" disabled=\"%s\"", "#%d\t\tat %s:%lu if %s%s",
+							phpdbg_writeln("#%d\t\tat %s:%lu if %s%s",
 				 				brake->id,
 				 				brake->param.file.name,
 				 				brake->param.file.line,
@@ -1736,7 +1600,7 @@ PHPDBG_API void phpdbg_print_breakpoints(zend_ulong type TSRMLS_DC) /* {{{ */
 						break;
 
 						case ADDR_PARAM:
-							phpdbg_writeln("evalopline", "id=\"%d\" opline=\"%#lx\" eval=\"%s\" disabled=\"%s\"", "#%d\t\tat #%lx if %s%s",
+							phpdbg_writeln("#%d\t\tat #%lx if %s%s",
 				 				brake->id,
 				 				brake->param.addr,
 				 				brake->code,
@@ -1744,11 +1608,11 @@ PHPDBG_API void phpdbg_print_breakpoints(zend_ulong type TSRMLS_DC) /* {{{ */
 						break;
 
 						default:
-							phpdbg_error("eval", "type=\"invalidparameter\"", "Invalid parameter type for conditional breakpoint");
+							phpdbg_error("Invalid parameter type for conditional breakpoint");
 						return;
 					}
 				} else {
-					phpdbg_writeln("eval", "id=\"%d\" eval=\"%s\" disabled=\"%s\"", "#%d\t\tif %s%s",
+					phpdbg_writeln("#%d\t\tif %s%s",
 				 		brake->id, brake->code,
 				 		((phpdbg_breakbase_t*)brake)->disabled ? " [disabled]" : "");
 				}
@@ -1759,17 +1623,15 @@ PHPDBG_API void phpdbg_print_breakpoints(zend_ulong type TSRMLS_DC) /* {{{ */
 			HashPosition position;
 			phpdbg_breakop_t *brake;
 
-			phpdbg_out(SEPARATE "\n");
-			phpdbg_out("Opcode Breakpoints:\n");
+			phpdbg_writeln(SEPARATE);
+			phpdbg_writeln("Opcode Breakpoints:");
 			for (zend_hash_internal_pointer_reset_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_OPCODE], &position);
 			     zend_hash_get_current_data_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_OPCODE], (void**) &brake, &position) == SUCCESS;
 			     zend_hash_move_forward_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_OPCODE], &position)) {
-				phpdbg_writeln("opcode", "id=\"%d\" name=\"%s\" disabled=\"%s\"", "#%d\t\t%s%s",
+				phpdbg_writeln("#%d\t\t%s%s",
 					brake->id, brake->name,
 					((phpdbg_breakbase_t*)brake)->disabled ? " [disabled]" : "");
 			}
 		} break;
 	}
-
-	phpdbg_xml("</breakpoints>");
 } /* }}} */
diff --git a/sapi/phpdbg/phpdbg_bp.h b/sapi/phpdbg/phpdbg_bp.h
index 63a9961d2a..97980e7ed7 100644
--- a/sapi/phpdbg/phpdbg_bp.h
+++ b/sapi/phpdbg/phpdbg_bp.h
@@ -21,20 +21,6 @@
 #ifndef PHPDBG_BP_H
 #define PHPDBG_BP_H
 
-/* {{{ defines */
-#define PHPDBG_BREAK_FILE            0
-#define PHPDBG_BREAK_FILE_PENDING    1
-#define PHPDBG_BREAK_SYM             2
-#define PHPDBG_BREAK_OPLINE          3
-#define PHPDBG_BREAK_METHOD          4
-#define PHPDBG_BREAK_COND            5
-#define PHPDBG_BREAK_OPCODE          6
-#define PHPDBG_BREAK_FUNCTION_OPLINE 7
-#define PHPDBG_BREAK_METHOD_OPLINE   8
-#define PHPDBG_BREAK_FILE_OPLINE     9
-#define PHPDBG_BREAK_MAP             10
-#define PHPDBG_BREAK_TABLES          11 /* }}} */
-
 /* {{{ */
 typedef struct _zend_op *phpdbg_opline_ptr_t; /* }}} */
 
@@ -117,12 +103,10 @@ typedef struct _phpdbg_breakcond_t {
 	zend_op_array  *ops;
 } phpdbg_breakcond_t;
 
-/* {{{ Resolving breaks API */
+/* {{{ Opline breaks API */
 PHPDBG_API void phpdbg_resolve_op_array_breaks(zend_op_array *op_array TSRMLS_DC);
 PHPDBG_API int phpdbg_resolve_op_array_break(phpdbg_breakopline_t *brake, zend_op_array *op_array TSRMLS_DC);
-PHPDBG_API int phpdbg_resolve_opline_break(phpdbg_breakopline_t *new_break TSRMLS_DC);
-PHPDBG_API HashTable *phpdbg_resolve_pending_file_break_ex(const char *file, uint filelen, const char *cur, uint curlen, HashTable *fileht TSRMLS_DC);
-PHPDBG_API void phpdbg_resolve_pending_file_break(const char *file TSRMLS_DC); /* }}} */
+PHPDBG_API int phpdbg_resolve_opline_break(phpdbg_breakopline_t *new_break TSRMLS_DC); /* }}} */
 
 /* {{{ Breakpoint Creation API */
 PHPDBG_API void phpdbg_set_breakpoint_file(const char* filename, long lineno TSRMLS_DC);
@@ -157,7 +141,6 @@ PHPDBG_API phpdbg_breakbase_t *phpdbg_find_breakbase(zend_ulong id TSRMLS_DC);
 PHPDBG_API phpdbg_breakbase_t *phpdbg_find_breakbase_ex(zend_ulong id, HashTable ***table, HashPosition *position TSRMLS_DC); /* }}} */
 
 /* {{{ Breakpoint Exportation API */
-PHPDBG_API void phpdbg_export_breakpoints(FILE *handle TSRMLS_DC);
-PHPDBG_API void phpdbg_export_breakpoints_to_string(char **str TSRMLS_DC); /* }}} */
+PHPDBG_API void phpdbg_export_breakpoints(FILE *handle TSRMLS_DC); /* }}} */
 
 #endif /* PHPDBG_BP_H */
diff --git a/sapi/phpdbg/phpdbg_break.c b/sapi/phpdbg/phpdbg_break.c
index 386d4d9562..be76b22b05 100644
--- a/sapi/phpdbg/phpdbg_break.c
+++ b/sapi/phpdbg/phpdbg_break.c
@@ -28,15 +28,15 @@
 
 ZEND_EXTERN_MODULE_GLOBALS(phpdbg);
 
-#define PHPDBG_BREAK_COMMAND_D(f, h, a, m, l, s, flags) \
-	PHPDBG_COMMAND_D_EXP(f, h, a, m, l, s, &phpdbg_prompt_commands[10], flags)
+#define PHPDBG_BREAK_COMMAND_D(f, h, a, m, l, s) \
+	PHPDBG_COMMAND_D_EXP(f, h, a, m, l, s, &phpdbg_prompt_commands[10])
 
 /**
  * Commands
  */
 const phpdbg_command_t phpdbg_break_commands[] = {
-	PHPDBG_BREAK_COMMAND_D(at,         "specify breakpoint by location and condition",           '@', break_at,      NULL, "*c", 0),
-	PHPDBG_BREAK_COMMAND_D(del,        "delete breakpoint by identifier number",                 '~', break_del,     NULL, "n",  0),
+	PHPDBG_BREAK_COMMAND_D(at,         "specify breakpoint by location and condition",           '@', break_at,      NULL, "*c"),
+	PHPDBG_BREAK_COMMAND_D(del,        "delete breakpoint by identifier number",                 '~', break_del,     NULL, "n"),
 	PHPDBG_END_COMMAND
 };
 
diff --git a/sapi/phpdbg/phpdbg_cmd.c b/sapi/phpdbg/phpdbg_cmd.c
index a170d52955..a45513bee6 100644
--- a/sapi/phpdbg/phpdbg_cmd.c
+++ b/sapi/phpdbg/phpdbg_cmd.c
@@ -23,7 +23,6 @@
 #include "phpdbg_utils.h"
 #include "phpdbg_set.h"
 #include "phpdbg_prompt.h"
-#include "phpdbg_io.h"
 
 ZEND_EXTERN_MODULE_GLOBALS(phpdbg);
 
@@ -40,7 +39,7 @@ static inline const char *phpdbg_command_name(const phpdbg_command_t *command, c
 	memcpy(&buffer[pos], command->name, command->name_len);
 	pos += command->name_len;
 	buffer[pos] = 0;
-
+	
 	return buffer;
 }
 
@@ -70,6 +69,79 @@ PHPDBG_API const char *phpdbg_get_param_type(const phpdbg_param_t *param TSRMLS_
 	}
 }
 
+PHPDBG_API phpdbg_param_type phpdbg_parse_param(const char *str, size_t len, phpdbg_param_t *param TSRMLS_DC) /* {{{ */
+{
+	char *class_name, *func_name;
+
+	if (len == 0) {
+		param->type = EMPTY_PARAM;
+		goto parsed;
+	}
+
+	if (phpdbg_is_addr(str)) {
+		param->addr = strtoul(str, 0, 16);
+		param->type = ADDR_PARAM;
+		goto parsed;
+
+	} else if (phpdbg_is_numeric(str)) {
+		param->num = strtol(str, NULL, 0);
+		param->type = NUMERIC_PARAM;
+		goto parsed;
+
+	} else if (phpdbg_is_class_method(str, len+1, &class_name, &func_name)) {
+		param->method.class = class_name;
+		param->method.name = func_name;
+		param->type = METHOD_PARAM;
+		goto parsed;
+	} else {
+		char *line_pos = strrchr(str, ':');
+
+		if (line_pos && phpdbg_is_numeric(line_pos+1)) {
+			if (strchr(str, ':') == line_pos) {
+				char path[MAXPATHLEN];
+
+				memcpy(path, str, line_pos - str);
+				path[line_pos - str] = 0;
+				*line_pos = 0;
+				param->file.name = phpdbg_resolve_path(path TSRMLS_CC);
+				param->file.line = strtol(line_pos+1, NULL, 0);
+				param->type = FILE_PARAM;
+
+				goto parsed;
+			}
+		}
+
+		line_pos = strrchr(str, '#');
+
+		if (line_pos && phpdbg_is_numeric(line_pos+1)) {
+			if (strchr(str, '#') == line_pos) {
+				param->num = strtol(line_pos + 1, NULL, 0);
+
+				if (phpdbg_is_class_method(str, line_pos - str, &class_name, &func_name)) {
+					param->method.class = class_name;
+					param->method.name = func_name;
+					param->type = NUMERIC_METHOD_PARAM;
+				} else {
+					param->len = line_pos - str;
+					param->str = estrndup(str, param->len);
+					param->type = NUMERIC_FUNCTION_PARAM;
+				}
+
+				goto parsed;
+			}
+		}
+	}
+
+	param->str = estrndup(str, len);
+	param->len = len;
+	param->type = STR_PARAM;
+
+parsed:
+	phpdbg_debug("phpdbg_parse_param(\"%s\", %lu): %s",
+		str, len, phpdbg_get_param_type(param TSRMLS_CC));
+	return param->type;
+} /* }}} */
+
 PHPDBG_API void phpdbg_clear_param(phpdbg_param_t *param TSRMLS_DC) /* {{{ */
 {
 	if (param) {
@@ -159,12 +231,12 @@ PHPDBG_API void phpdbg_copy_param(const phpdbg_param_t* src, phpdbg_param_t* des
 		case STACK_PARAM:
 			/* nope */
 		break;
-
+		
 		case STR_PARAM:
 			dest->str = estrndup(src->str, src->len);
 			dest->len = src->len;
 		break;
-
+		
 		case OP_PARAM:
 			dest->str = estrndup(src->str, src->len);
 			dest->len = src->len;
@@ -204,7 +276,7 @@ PHPDBG_API void phpdbg_copy_param(const phpdbg_param_t* src, phpdbg_param_t* des
 		break;
 
 		case EMPTY_PARAM: { /* do nothing */ } break;
-
+		
 		default: {
 			/* not yet */
 		}
@@ -219,7 +291,7 @@ PHPDBG_API zend_ulong phpdbg_hash_param(const phpdbg_param_t *param TSRMLS_DC) /
 		case STACK_PARAM:
 			/* nope */
 		break;
-
+		
 		case STR_PARAM:
 			hash += zend_inline_hash_func(param->str, param->len);
 		break;
@@ -257,7 +329,7 @@ PHPDBG_API zend_ulong phpdbg_hash_param(const phpdbg_param_t *param TSRMLS_DC) /
 		break;
 
 		case EMPTY_PARAM: { /* do nothing */ } break;
-
+		
 		default: {
 			/* not yet */
 		}
@@ -275,7 +347,7 @@ PHPDBG_API zend_bool phpdbg_match_param(const phpdbg_param_t *l, const phpdbg_pa
 					/* nope, or yep */
 					return 1;
 				break;
-
+				
 				case NUMERIC_FUNCTION_PARAM:
 					if (l->num != r->num) {
 						break;
@@ -330,7 +402,7 @@ PHPDBG_API zend_bool phpdbg_match_param(const phpdbg_param_t *l, const phpdbg_pa
 
 				case EMPTY_PARAM:
 					return 1;
-
+					
 				default: {
 					/* not yet */
 				}
@@ -347,43 +419,43 @@ PHPDBG_API void phpdbg_param_debug(const phpdbg_param_t *param, const char *msg)
 			case STR_PARAM:
 				fprintf(stderr, "%s STR_PARAM(%s=%lu)\n", msg, param->str, param->len);
 			break;
-
+			
 			case ADDR_PARAM:
 				fprintf(stderr, "%s ADDR_PARAM(%lu)\n", msg, param->addr);
 			break;
-
+			
 			case NUMERIC_FILE_PARAM:
 				fprintf(stderr, "%s NUMERIC_FILE_PARAM(%s:#%lu)\n", msg, param->file.name, param->file.line);
 			break;
-
+			
 			case FILE_PARAM:
 				fprintf(stderr, "%s FILE_PARAM(%s:%lu)\n", msg, param->file.name, param->file.line);
 			break;
-
+			
 			case METHOD_PARAM:
 				fprintf(stderr, "%s METHOD_PARAM(%s::%s)\n", msg, param->method.class, param->method.name);
 			break;
-
+			
 			case NUMERIC_METHOD_PARAM:
 				fprintf(stderr, "%s NUMERIC_METHOD_PARAM(%s::%s)\n", msg, param->method.class, param->method.name);
 			break;
-
+			
 			case NUMERIC_FUNCTION_PARAM:
 				fprintf(stderr, "%s NUMERIC_FUNCTION_PARAM(%s::%ld)\n", msg, param->str, param->num);
 			break;
-
+			
 			case NUMERIC_PARAM:
 				fprintf(stderr, "%s NUMERIC_PARAM(%ld)\n", msg, param->num);
 			break;
-
+			
 			case COND_PARAM:
 				fprintf(stderr, "%s COND_PARAM(%s=%lu)\n", msg, param->str, param->len);
 			break;
-
+			
 			case OP_PARAM:
 				fprintf(stderr, "%s OP_PARAM(%s=%lu)\n", msg, param->str, param->len);
 			break;
-
+			
 			default: {
 				/* not yet */
 			}
@@ -395,13 +467,13 @@ PHPDBG_API void phpdbg_param_debug(const phpdbg_param_t *param, const char *msg)
 PHPDBG_API void phpdbg_stack_free(phpdbg_param_t *stack) {
 	if (stack && stack->next) {
 		phpdbg_param_t *remove = stack->next;
-
+		
 		while (remove) {
 			phpdbg_param_t *next = NULL;
-
+			
 			if (remove->next)
 				next = remove->next;
-
+			
 			switch (remove->type) {
 				case NUMERIC_METHOD_PARAM:
 				case METHOD_PARAM:
@@ -415,30 +487,29 @@ PHPDBG_API void phpdbg_stack_free(phpdbg_param_t *stack) {
 				case STR_PARAM:
 				case OP_PARAM:
 					if (remove->str)
-						free(remove->str);
+						free(remove->str);	
 				break;
-
+				
 				case NUMERIC_FILE_PARAM:
 				case FILE_PARAM:
 					if (remove->file.name)
 						free(remove->file.name);
 				break;
-
+				
 				default: {
 					/* nothing */
 				}
 			}
-
+			
 			free(remove);
 			remove = NULL;
-
+			
 			if (next)
-				remove = next;
+				remove = next; 
 			else break;
 		}
 	}
-
-
+	
 	stack->next = NULL;
 } /* }}} */
 
@@ -466,29 +537,30 @@ PHPDBG_API void phpdbg_stack_push(phpdbg_param_t *stack, phpdbg_param_t *param)
 	stack->len++;
 } /* }}} */
 
-PHPDBG_API int phpdbg_stack_verify(const phpdbg_command_t *command, phpdbg_param_t **stack TSRMLS_DC) {
+PHPDBG_API int phpdbg_stack_verify(const phpdbg_command_t *command, phpdbg_param_t **stack, char **why TSRMLS_DC) {
 	if (command) {
 		char buffer[128] = {0,};
 		const phpdbg_param_t *top = (stack != NULL) ? *stack : NULL;
 		const char *arg = command->args;
 		size_t least = 0L,
-		       received = 0L,
-		       current = 0L;
+			   received = 0L,
+			   current = 0L;
 		zend_bool optional = 0;
-
+		
 		/* check for arg spec */
 		if (!(arg) || !(*arg)) {
 			if (!top) {
 				return SUCCESS;
 			}
-
-			phpdbg_error("command", "type=\"toomanyargs\" command=\"%s\" expected=\"0\"", "The command \"%s\" expected no arguments", 
+			
+			asprintf(why,
+				"The command \"%s\" expected no arguments", 
 				phpdbg_command_name(command, buffer));
 			return FAILURE;
 		}
-
+		
 		least = 0L;
-
+		
 		/* count least amount of arguments */
 		while (arg && *arg) {
 			if (arg[0] == '|') {
@@ -497,19 +569,21 @@ PHPDBG_API int phpdbg_stack_verify(const phpdbg_command_t *command, phpdbg_param
 			least++;
 			arg++;
 		}
-
+		
 		arg = command->args;
 
 #define verify_arg(e, a, t) if (!(a)) { \
 	if (!optional) { \
-		phpdbg_error("command", "type=\"noarg\" command=\"%s\" expected=\"%s\" num=\"%lu\"", "The command \"%s\" expected %s and got nothing at parameter %lu", \
+		asprintf(why, \
+			"The command \"%s\" expected %s and got nothing at parameter %lu", \
 			phpdbg_command_name(command, buffer), \
 			(e), \
 			current); \
 		return FAILURE;\
 	} \
 } else if ((a)->type != (t)) { \
-	phpdbg_error("command", "type=\"wrongarg\" command=\"%s\" expected=\"%s\" got=\"%s\" num=\"%lu\"", "The command \"%s\" expected %s and got %s at parameter %lu", \
+	asprintf(why, \
+		"The command \"%s\" expected %s and got %s at parameter %lu", \
 		phpdbg_command_name(command, buffer), \
 		(e),\
 		phpdbg_get_param_type((a) TSRMLS_CC), \
@@ -519,14 +593,14 @@ PHPDBG_API int phpdbg_stack_verify(const phpdbg_command_t *command, phpdbg_param
 
 		while (arg && *arg) {
 			current++;
-
+			
 			switch (*arg) {
 				case '|': {
 					current--;
 					optional = 1;
 					arg++;
 				} continue;
-
+				
 				case 'i': verify_arg("raw input", top, STR_PARAM); break;
 				case 's': verify_arg("string", top, STR_PARAM); break;
 				case 'n': verify_arg("number", top, NUMERIC_PARAM); break;
@@ -536,14 +610,14 @@ PHPDBG_API int phpdbg_stack_verify(const phpdbg_command_t *command, phpdbg_param
 				case 'c': verify_arg("condition", top, COND_PARAM); break;
 				case 'o': verify_arg("opcode", top, OP_PARAM); break;
 				case 'b': verify_arg("boolean", top, NUMERIC_PARAM); break;
-
+				
 				case '*': { /* do nothing */ } break;
 			}
-
+			
 			if (top ) {
 				top = top->next;
 			} else break;
-
+			
 			received++;
 			arg++;
 		}
@@ -551,27 +625,28 @@ PHPDBG_API int phpdbg_stack_verify(const phpdbg_command_t *command, phpdbg_param
 #undef verify_arg
 
 		if ((received < least)) {
-			phpdbg_error("command", "type=\"toofewargs\" command=\"%s\" expected=\"%d\" argtypes=\"%s\" got=\"%d\"", "The command \"%s\" expected at least %lu arguments (%s) and received %lu",
+			asprintf(why,
+				"The command \"%s\" expected at least %lu arguments (%s) and received %lu",
 				phpdbg_command_name(command, buffer),
 				least,
-				command->args,
+				command->args, 
 				received);
 			return FAILURE;
 		}
 	}
-
+	
 	return SUCCESS;
 }
 
 /* {{{ */
-PHPDBG_API const phpdbg_command_t *phpdbg_stack_resolve(const phpdbg_command_t *commands, const phpdbg_command_t *parent, phpdbg_param_t **top TSRMLS_DC) {
+PHPDBG_API const phpdbg_command_t* phpdbg_stack_resolve(const phpdbg_command_t *commands, const phpdbg_command_t *parent, phpdbg_param_t **top, char **why) {
 	const phpdbg_command_t *command = commands;
 	phpdbg_param_t *name = *top;
 	const phpdbg_command_t *matched[3] = {NULL, NULL, NULL};
 	ulong matches = 0L;
-
+	
 	while (command && command->name && command->handler) {
-		if (name->len == 1 || command->name_len >= name->len) {
+		if ((name->len == 1) || (command->name_len >= name->len)) {
 			/* match single letter alias */
 			if (command->alias && (name->len == 1)) {
 				if (command->alias == (*name->str)) {
@@ -579,76 +654,85 @@ PHPDBG_API const phpdbg_command_t *phpdbg_stack_resolve(const phpdbg_command_t *
 					matches++;
 				}
 			} else {
+
 				/* match full, case insensitive, command name */
 				if (strncasecmp(command->name, name->str, name->len) == SUCCESS) {
 					if (matches < 3) {
+						
 						/* only allow abbreviating commands that can be aliased */
-						if ((name->len != command->name_len && command->alias) || name->len == command->name_len) {
+						if (((name->len != command->name_len) && command->alias) ||
+							(name->len == command->name_len)) {
 							matched[matches] = command;
 							matches++;
 						}
-
+						
+						
 						/* exact match */
-						if (name->len == command->name_len) {
+						if (name->len == command->name_len)
 							break;
-						}
-					} else {
-						break;
-					}
+					} else break;
 				}
 			}
 		}
-
+		
 		command++;
 	}
-
+	
 	switch (matches) {
-		case 0:
+		case 0: {
 			if (parent) {
-				phpdbg_error("command", "type=\"notfound\" command=\"%s\" subcommand=\"%s\"", "The command \"%s %s\" could not be found", parent->name, name->str);
-			} else {
-				phpdbg_error("command", "type=\"notfound\" command=\"%s\"", "The command \"%s\" could not be found", name->str);
-			}
-			return parent;
-
-		case 1:
+				asprintf(
+				why,
+				"The command \"%s %s\" could not be found", 
+				parent->name, name->str);
+			} else asprintf(
+				why,
+				"The command \"%s\" could not be found", 
+				name->str);
+		} return parent;
+		
+		case 1: {
 			(*top) = (*top)->next;
 
 			command = matched[0];
-			break;
-
+		} break;
+		
 		default: {
 			char *list = NULL;
 			zend_uint it = 0;
 			size_t pos = 0;
-
+			
 			while (it < matches) {
 				if (!list) {
-					list = emalloc(matched[it]->name_len + 1 + (it + 1 < matches ? sizeof(", ") - 1 : 0));
+					list = malloc(
+						matched[it]->name_len + 1 + 
+						((it+1) < matches ? sizeof(", ")-1 : 0));
 				} else {
-					list = erealloc(list, (pos + matched[it]->name_len) + 1 + (it + 1 < matches ? sizeof(", ") - 1 : 0));
+					list = realloc(list, 
+						(pos + matched[it]->name_len) + 1  + 
+						((it+1) < matches ? sizeof(", ")-1 : 0));
 				}
 				memcpy(&list[pos], matched[it]->name, matched[it]->name_len);
 				pos += matched[it]->name_len;
-				if ((it + 1) < matches) {
-					memcpy(&list[pos], ", ", sizeof(", ") - 1);
+				if ((it+1) < matches) {
+					memcpy(&list[pos], ", ", sizeof(", ")-1);
 					pos += (sizeof(", ") - 1);
 				}
-
+				
 				list[pos] = 0;
 				it++;
 			}
-
-			/* ", " separated matches */
-			phpdbg_error("command", "type=\"ambiguous\" command=\"%s\" matches=\"%lu\" matched=\"%s\"", "The command \"%s\" is ambigious, matching %lu commands (%s)", name->str, matches, list);
-			efree(list);
-
-			return NULL;
-		}
+			
+			asprintf(
+				why,
+				"The command \"%s\" is ambigious, matching %lu commands (%s)", 
+				name->str, matches, list);
+			free(list);
+		} return NULL;
 	}
 
 	if (command->subs && (*top) && ((*top)->type == STR_PARAM)) {
-		return phpdbg_stack_resolve(command->subs, command, top TSRMLS_CC);
+		return phpdbg_stack_resolve(command->subs, command, top, why);
 	} else {
 		return command;
 	}
@@ -657,98 +741,103 @@ PHPDBG_API const phpdbg_command_t *phpdbg_stack_resolve(const phpdbg_command_t *
 } /* }}} */
 
 /* {{{ */
-PHPDBG_API int phpdbg_stack_execute(phpdbg_param_t *stack, zend_bool allow_async_unsafe TSRMLS_DC) {
+PHPDBG_API int phpdbg_stack_execute(phpdbg_param_t *stack, char **why TSRMLS_DC) {
 	phpdbg_param_t *top = NULL;
 	const phpdbg_command_t *handler = NULL;
-
+	
 	if (stack->type != STACK_PARAM) {
-		phpdbg_error("command", "type=\"nostack\"", "The passed argument was not a stack !");
+		asprintf(
+			why, "The passed argument was not a stack !!");
 		return FAILURE;
 	}
-
+	
 	if (!stack->len) {
-		phpdbg_error("command", "type=\"emptystack\"", "The stack contains nothing !");
+		asprintf(
+			why, "The stack contains nothing !!");
 		return FAILURE;
 	}
-
-	top = (phpdbg_param_t *) stack->next;
-
+	
+	top = (phpdbg_param_t*) stack->next;
+	
 	switch (top->type) {
 		case EVAL_PARAM:
-			phpdbg_activate_err_buf(0 TSRMLS_CC);
-			phpdbg_free_err_buf(TSRMLS_C);
 			return PHPDBG_COMMAND_HANDLER(ev)(top TSRMLS_CC);
 
 		case RUN_PARAM:
-			if (!allow_async_unsafe) {
-				phpdbg_error("signalsegv", "command=\"run\"", "run command is disallowed during hard interrupt");
-			}
-			phpdbg_activate_err_buf(0 TSRMLS_CC);
-			phpdbg_free_err_buf(TSRMLS_C);
 			return PHPDBG_COMMAND_HANDLER(run)(top TSRMLS_CC);
-
+		
 		case SHELL_PARAM:
-			if (!allow_async_unsafe) {
-				phpdbg_error("signalsegv", "command=\"sh\"", "sh command is disallowed during hard interrupt");
-				return FAILURE;
-			}
-			phpdbg_activate_err_buf(0 TSRMLS_CC);
-			phpdbg_free_err_buf(TSRMLS_C);
 			return PHPDBG_COMMAND_HANDLER(sh)(top TSRMLS_CC);
-
+		
 		case STR_PARAM: {
-			handler = phpdbg_stack_resolve(phpdbg_prompt_commands, NULL, &top TSRMLS_CC);
-
+			handler = phpdbg_stack_resolve(
+				phpdbg_prompt_commands, NULL, &top, why);
+			
 			if (handler) {
-				if (!allow_async_unsafe && !(handler->flags & PHPDBG_ASYNC_SAFE)) {
-					phpdbg_error("signalsegv", "command=\"%s\"", "%s command is disallowed during hard interrupt", handler->name);
-					return FAILURE;
-				}
-
-				if (phpdbg_stack_verify(handler, &top TSRMLS_CC) == SUCCESS) {
-					phpdbg_activate_err_buf(0 TSRMLS_CC);
-					phpdbg_free_err_buf(TSRMLS_C);
+				if (phpdbg_stack_verify(handler, &top, why TSRMLS_CC) == SUCCESS) {
 					return handler->handler(top TSRMLS_CC);
 				}
 			}
 		} return FAILURE;
-
+		
 		default:
-			phpdbg_error("command", "type=\"invalidcommand\"", "The first parameter makes no sense !");
+			asprintf(
+				why, "The first parameter makes no sense !!");
 			return FAILURE;
 	}
-
+	
 	return SUCCESS;
 } /* }}} */
 
-PHPDBG_API char *phpdbg_read_input(char *buffered TSRMLS_DC) /* {{{ */
+PHPDBG_API char* phpdbg_read_input(char *buffered TSRMLS_DC) /* {{{ */
 {
-	char buf[PHPDBG_MAX_CMD];
 	char *cmd = NULL;
+#if !defined(HAVE_LIBREADLINE) && !defined(HAVE_LIBEDIT)
+	char buf[PHPDBG_MAX_CMD];
+#endif
 	char *buffer = NULL;
 
-	if ((PHPDBG_G(flags) & (PHPDBG_IS_STOPPING | PHPDBG_IS_RUNNING)) != PHPDBG_IS_STOPPING) {
-		if ((PHPDBG_G(flags) & PHPDBG_IS_REMOTE) && (buffered == NULL) && !phpdbg_active_sigsafe_mem(TSRMLS_C)) {
-			fflush(PHPDBG_G(io)[PHPDBG_STDOUT].ptr);
+	if (!(PHPDBG_G(flags) & PHPDBG_IS_QUITTING)) {
+		if ((PHPDBG_G(flags) & PHPDBG_IS_REMOTE) &&
+			(buffered == NULL)) {
+			fflush(PHPDBG_G(io)[PHPDBG_STDOUT]);
 		}
 
 		if (buffered == NULL) {
-#define USE_LIB_STAR (defined(HAVE_LIBREADLINE) || defined(HAVE_LIBEDIT))
-			/* note: EOF makes readline write prompt again in local console mode - and ignored if compiled without readline */
-#if USE_LIB_STAR
-readline:
-			if (PHPDBG_G(flags) & PHPDBG_IS_REMOTE)
-#endif
-			{
-				phpdbg_write("prompt", "", "%s", phpdbg_get_prompt(TSRMLS_C));
-				phpdbg_consume_stdin_line(cmd = buf TSRMLS_CC);
+disconnect:
+			if (0) {
+				PHPDBG_G(flags) |= (PHPDBG_IS_QUITTING|PHPDBG_IS_DISCONNECTED);
+				zend_bailout();
+				return NULL;
+			}
+
+#if !defined(HAVE_LIBREADLINE) && !defined(HAVE_LIBEDIT)
+			if (!(PHPDBG_G(flags) & PHPDBG_IS_REMOTE)) {
+				if (!phpdbg_write("%s", phpdbg_get_prompt(TSRMLS_C))) {
+					goto disconnect;
+				}
 			}
-#if USE_LIB_STAR
-			else {
-				cmd = readline(phpdbg_get_prompt(TSRMLS_C));
-				PHPDBG_G(last_was_newline) = 1;
+			
+			/* note: EOF is ignored */
+readline:	
+			if (!fgets(buf, PHPDBG_MAX_CMD, PHPDBG_G(io)[PHPDBG_STDIN])) {
+				/* the user has gone away */
+				if ((PHPDBG_G(flags) & PHPDBG_IS_REMOTE)) {
+					goto disconnect;
+				} else goto readline;
 			}
 
+			cmd = buf;
+#else
+			/* note: EOF makes readline write prompt again in local console mode */
+readline:
+			if ((PHPDBG_G(flags) & PHPDBG_IS_REMOTE)) {
+				char buf[PHPDBG_MAX_CMD];
+				if (fgets(buf, PHPDBG_MAX_CMD, PHPDBG_G(io)[PHPDBG_STDIN])) {
+					cmd = buf;
+				} else goto disconnect;
+			} else cmd = readline(phpdbg_get_prompt(TSRMLS_C));
+
 			if (!cmd) {
 				goto readline;
 			}
@@ -757,14 +846,13 @@ readline:
 				add_history(cmd);
 			}
 #endif
-		} else {
-			cmd = buffered;
-		}
-
+		} else cmd = buffered;
+		
 		buffer = estrdup(cmd);
 
-#if USE_LIB_STAR
-		if (!buffered && cmd &&	!(PHPDBG_G(flags) & PHPDBG_IS_REMOTE)) {
+#if defined(HAVE_LIBREADLINE) || defined(HAVE_LIBEDIT)
+		if (!buffered && cmd &&
+			!(PHPDBG_G(flags) & PHPDBG_IS_REMOTE)) {
 			free(cmd);
 		}
 #endif
@@ -790,7 +878,7 @@ readline:
 			buffer = estrdup(PHPDBG_G(buffer));
 		}
 	}
-
+	
 	return buffer;
 } /* }}} */
 
@@ -799,23 +887,3 @@ PHPDBG_API void phpdbg_destroy_input(char **input TSRMLS_DC) /*{{{ */
 	efree(*input);
 } /* }}} */
 
-PHPDBG_API int phpdbg_ask_user_permission(const char *question TSRMLS_DC) {
-	if (!(PHPDBG_G(flags) & PHPDBG_WRITE_XML)) {
-		char buf[PHPDBG_MAX_CMD];
-		phpdbg_out("%s", question);
-		phpdbg_out(" (type y or n): ");
-
-		while (1) {
-			phpdbg_consume_stdin_line(buf TSRMLS_CC);
-			if (buf[1] == '\n' && (buf[0] == 'y' || buf[0] == 'n')) {
-				if (buf[0] == 'y') {
-					return SUCCESS;
-				}
-				return FAILURE;
-			}
-			phpdbg_out("Please enter either y (yes) or n (no): ");
-		}
-	}
-
-	return SUCCESS;
-}
diff --git a/sapi/phpdbg/phpdbg_cmd.h b/sapi/phpdbg/phpdbg_cmd.h
index a79641c080..571d065f59 100644
--- a/sapi/phpdbg/phpdbg_cmd.h
+++ b/sapi/phpdbg/phpdbg_cmd.h
@@ -86,8 +86,6 @@ struct _phpdbg_param {
 #define YYSTYPE phpdbg_param_t
 #endif
 
-#define PHPDBG_ASYNC_SAFE 1
-
 typedef int (*phpdbg_command_handler_t)(const phpdbg_param_t* TSRMLS_DC);
 
 typedef struct _phpdbg_command_t phpdbg_command_t;
@@ -99,9 +97,8 @@ struct _phpdbg_command_t {
 	char alias;                         /* Alias */
 	phpdbg_command_handler_t handler;   /* Command handler */
 	const phpdbg_command_t *subs;       /* Sub Commands */
-	char *args;                         /* Argument Spec */
-	const phpdbg_command_t *parent;     /* Parent Command */
-	zend_bool flags;                    /* General flags */
+	char *args;							/* Argument Spec */
+	const phpdbg_command_t *parent;		/* Parent Command */							
 };
 /* }}} */
 
@@ -109,7 +106,7 @@ struct _phpdbg_command_t {
 #define PHPDBG_STRL(s) s, sizeof(s)-1
 #define PHPDBG_MAX_CMD 500
 #define PHPDBG_FRAME(v) (PHPDBG_G(frame).v)
-#define PHPDBG_EX(v) (EG(current_execute_data)->v)
+#define PHPDBG_EX(v) (EG(current_execute_data)->v) 
 
 typedef struct {
 	int num;
@@ -131,20 +128,20 @@ typedef struct {
 */
 PHPDBG_API char* phpdbg_read_input(char *buffered TSRMLS_DC);
 PHPDBG_API void phpdbg_destroy_input(char** TSRMLS_DC);
-PHPDBG_API int phpdbg_ask_user_permission(const char *question TSRMLS_DC);
 
 /**
  * Stack Management
  */
 PHPDBG_API void phpdbg_stack_push(phpdbg_param_t *stack, phpdbg_param_t *param);
-PHPDBG_API const phpdbg_command_t *phpdbg_stack_resolve(const phpdbg_command_t *commands, const phpdbg_command_t *parent, phpdbg_param_t **top TSRMLS_DC);
-PHPDBG_API int phpdbg_stack_verify(const phpdbg_command_t *command, phpdbg_param_t **stack TSRMLS_DC);
-PHPDBG_API int phpdbg_stack_execute(phpdbg_param_t *stack, zend_bool allow_async_unsafe TSRMLS_DC);
+PHPDBG_API const phpdbg_command_t* phpdbg_stack_resolve(const phpdbg_command_t *commands, const phpdbg_command_t *parent, phpdbg_param_t **top, char **why);
+PHPDBG_API int phpdbg_stack_verify(const phpdbg_command_t *command, phpdbg_param_t **stack, char **why TSRMLS_DC);
+PHPDBG_API int phpdbg_stack_execute(phpdbg_param_t *stack, char **why TSRMLS_DC);
 PHPDBG_API void phpdbg_stack_free(phpdbg_param_t *stack);
 
 /*
 * Parameter Management
 */
+PHPDBG_API phpdbg_param_type phpdbg_parse_param(const char*, size_t, phpdbg_param_t* TSRMLS_DC);
 PHPDBG_API void phpdbg_clear_param(phpdbg_param_t* TSRMLS_DC);
 PHPDBG_API void phpdbg_copy_param(const phpdbg_param_t*, phpdbg_param_t* TSRMLS_DC);
 PHPDBG_API zend_bool phpdbg_match_param(const phpdbg_param_t *, const phpdbg_param_t * TSRMLS_DC);
@@ -158,27 +155,27 @@ PHPDBG_API void phpdbg_param_debug(const phpdbg_param_t *param, const char *msg)
  */
 #define PHPDBG_COMMAND_HANDLER(name) phpdbg_do_##name
 
-#define PHPDBG_COMMAND_D_EXP(name, tip, alias, handler, children, args, parent, flags) \
-	{PHPDBG_STRL(#name), tip, sizeof(tip)-1, alias, phpdbg_do_##handler, children, args, parent, flags}
+#define PHPDBG_COMMAND_D_EXP(name, tip, alias, handler, children, args, parent) \
+	{PHPDBG_STRL(#name), tip, sizeof(tip)-1, alias, phpdbg_do_##handler, children, args, parent}
 
-#define PHPDBG_COMMAND_D_EX(name, tip, alias, handler, children, args, flags) \
-	{PHPDBG_STRL(#name), tip, sizeof(tip)-1, alias, phpdbg_do_##handler, children, args, NULL, flags}
+#define PHPDBG_COMMAND_D_EX(name, tip, alias, handler, children, args) \
+	{PHPDBG_STRL(#name), tip, sizeof(tip)-1, alias, phpdbg_do_##handler, children, args, NULL}
 
-#define PHPDBG_COMMAND_D(name, tip, alias, children, args, flags) \
-	{PHPDBG_STRL(#name), tip, sizeof(tip)-1, alias, phpdbg_do_##name, children, args, NULL, flags}
+#define PHPDBG_COMMAND_D(name, tip, alias, children, args) \
+	{PHPDBG_STRL(#name), tip, sizeof(tip)-1, alias, phpdbg_do_##name, children, args, NULL}
 
 #define PHPDBG_COMMAND(name) int phpdbg_do_##name(const phpdbg_param_t *param TSRMLS_DC)
 
 #define PHPDBG_COMMAND_ARGS param TSRMLS_CC
 
-#define PHPDBG_END_COMMAND {NULL, 0, NULL, 0, '\0', NULL, NULL, NULL, NULL, 0}
+#define PHPDBG_END_COMMAND {NULL, 0, NULL, 0, '\0', NULL, NULL, '\0', NULL}
 
 /*
 * Default Switch Case
 */
 #define phpdbg_default_switch_case() \
 	default: \
-		phpdbg_error("command", "type=\"wrongarg\" got=\"%s\"", "Unsupported parameter type (%s) for command", phpdbg_get_param_type(param TSRMLS_CC)); \
+		phpdbg_error("Unsupported parameter type (%s) for command", phpdbg_get_param_type(param TSRMLS_CC)); \
 	break
 
 #endif /* PHPDBG_CMD_H */
diff --git a/sapi/phpdbg/phpdbg_eol.c b/sapi/phpdbg/phpdbg_eol.c
deleted file mode 100644
index fc20d567bc..0000000000
--- a/sapi/phpdbg/phpdbg_eol.c
+++ /dev/null
@@ -1,172 +0,0 @@
-/*
-   +----------------------------------------------------------------------+
-   | PHP Version 5                                                        |
-   +----------------------------------------------------------------------+
-   | Copyright (c) 1997-2014 The PHP Group                                |
-   +----------------------------------------------------------------------+
-   | This source file is subject to version 3.01 of the PHP license,      |
-   | that is bundled with this package in the file LICENSE, and is        |
-   | available through the world-wide-web at the following url:           |
-   | http://www.php.net/license/3_01.txt                                  |
-   | If you did not receive a copy of the PHP license and are unable to   |
-   | obtain it through the world-wide-web, please send a note to          |
-   | license@php.net so we can mail you a copy immediately.               |
-   +----------------------------------------------------------------------+
-   | Authors: Anatol Belski <ab@php.net>                                  |
-   +----------------------------------------------------------------------+
-*/
-
-#ifdef HAVE_CONFIG_H
-#	include "config.h"
-#endif
-
-#include "phpdbg.h"
-#include "phpdbg_eol.h"
-
-ZEND_EXTERN_MODULE_GLOBALS(phpdbg);
-
-#define EOL_LIST_LEN 4
-struct phpdbg_eol_rep phpdbg_eol_list[EOL_LIST_LEN] = {
-	{"CRLF", "\r\n", PHPDBG_EOL_CRLF},
-/*	{"LFCR", "\n\r", PHPDBG_EOL_LFCR},*/
-	{"LF", "\n", PHPDBG_EOL_LF},
-	{"CR", "\r", PHPDBG_EOL_CR},
-};
-
-int phpdbg_eol_global_update(char *name TSRMLS_DC)
-{
-
-	if (0 == memcmp(name, "CRLF", 4) || 0 == memcmp(name, "crlf", 4) || 0 == memcmp(name, "DOS", 3) || 0 == memcmp(name, "dos", 3)) {
-		PHPDBG_G(eol) = PHPDBG_EOL_CRLF;
-	} else if (0 == memcmp(name, "LF", 2) || 0 == memcmp(name, "lf", 2) || 0 == memcmp(name, "UNIX", 4) || 0 == memcmp(name, "unix", 4)) {
-		PHPDBG_G(eol) = PHPDBG_EOL_LF;
-	} else if (0 == memcmp(name, "CR", 2) || 0 == memcmp(name, "cr", 2) || 0 == memcmp(name, "MAC", 3) || 0 == memcmp(name, "mac", 3)) {
-		PHPDBG_G(eol) = PHPDBG_EOL_CR;
-	} else {
-		return FAILURE;
-	}
-
-	return SUCCESS;
-}
-
-char *phpdbg_eol_name(int id)
-{
-	size_t i = 0;
-
-	while (i < EOL_LIST_LEN) {
-
-		if (id == phpdbg_eol_list[i].id) {
-			return phpdbg_eol_list[i].name;
-		}
-
-		i++;
-	}
-
-	return NULL;
-}
-
-char *phpdbg_eol_rep(int id)
-{
-	size_t i = 0;
-
-	while (i < EOL_LIST_LEN) {
-
-		if (id == phpdbg_eol_list[i].id) {
-			return phpdbg_eol_list[i].rep;
-		}
-
-		i++;
-	}
-
-	return NULL;
-}
-
-
-/* Inspired by https://ccrma.stanford.edu/~craig/utility/flip/flip.cpp */
-void phpdbg_eol_convert(char **str, int *len TSRMLS_DC)
-{
-	char *in = *str, *out ;
-	int in_len = *len, out_len, cursor, i;
-	char last, cur;
-
-	if ((PHPDBG_G(flags) & PHPDBG_IS_REMOTE) != PHPDBG_IS_REMOTE) {
-		return;
-	}
-
-	out_len = *len;
-	if (PHPDBG_EOL_CRLF == PHPDBG_G(eol)) { /* XXX add LFCR case if it's gonna be needed */
-		/* depending on the source EOL the out str will have all CR/LF duplicated */
-		for (i = 0; i < in_len; i++) {
-			if (0x0a == in[i] || 0x0d == in[i]) {
-				out_len++;
-			}
-		}
-		out = (char *)emalloc(out_len);
-
-		last = cur = in[0];
-		i = cursor = 0;
-		for (; i < in_len;) {
-			if (0x0a == cur && last != 0x0d) {
-				out[cursor] = 0x0d;
-				cursor++;
-				out[cursor] = cur;
-			} else if(0x0d == cur) {
-				if (i + 1 < in_len && 0x0a != in[i+1]) {
-					out[cursor] = cur;
-					cursor++;
-					out[cursor] = 0x0a;
-					last = 0x0a;
-				} else {
-					out[cursor] = 0x0d;
-					last = 0x0d;
-				}
-			} else {
-				out[cursor] = cur;
-				last = cur;
-			}
-			
-			i++;
-			cursor++;
-			cur = in[i];
-		}
-
-	} else if (PHPDBG_EOL_LF == PHPDBG_G(eol) || PHPDBG_EOL_CR == PHPDBG_G(eol)) {
-		char want, kick;
-
-		if (PHPDBG_EOL_LF == PHPDBG_G(eol)) {
-			want = 0x0a;
-			kick = 0x0d;
-		} else {
-			want = 0x0d;
-			kick = 0x0a;
-		}
-
-		/* We gonna have a smaller or equally long string, estimation is almost neglecting */
-		out = (char *)emalloc(out_len);
-
-		last = cur = in[0];
-		i = cursor = 0;
-		for (; cursor < in_len;) {
-			if (kick == cur) {
-				out[cursor] = want;
-			} else if (want == cur) {
-				if (kick != last) {
-					out[cursor] = want;
-				}
-			} else {
-				out[cursor] = cur;
-			}
-
-			last = cur;
-			cursor++;
-			cur = in[cursor];
-		}
-	} else {
-		return;
-	}
-
-	efree(*str);
-	*str = erealloc(out, cursor);
-	*len = cursor;
-	in = NULL;
-}
diff --git a/sapi/phpdbg/phpdbg_eol.h b/sapi/phpdbg/phpdbg_eol.h
deleted file mode 100644
index 68b54cbe34..0000000000
--- a/sapi/phpdbg/phpdbg_eol.h
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
-   +----------------------------------------------------------------------+
-   | PHP Version 5                                                        |
-   +----------------------------------------------------------------------+
-   | Copyright (c) 1997-2014 The PHP Group                                |
-   +----------------------------------------------------------------------+
-   | This source file is subject to version 3.01 of the PHP license,      |
-   | that is bundled with this package in the file LICENSE, and is        |
-   | available through the world-wide-web at the following url:           |
-   | http://www.php.net/license/3_01.txt                                  |
-   | If you did not receive a copy of the PHP license and are unable to   |
-   | obtain it through the world-wide-web, please send a note to          |
-   | license@php.net so we can mail you a copy immediately.               |
-   +----------------------------------------------------------------------+
-   | Authors: Anatol Belski <ab@php.net>                                  |
-   +----------------------------------------------------------------------+
-*/
-
-#ifndef PHPDBG_EOL_H
-#define PHPDBG_EOL_H
-
-#include "phpdbg.h"
-
-struct phpdbg_eol_rep {
-	char *name;
-	char *rep;
-	int id;
-};
-
-enum {
-	PHPDBG_EOL_CRLF, /* DOS */
-	/*PHPDBG_EOL_LFCR,*/ /* for Risc OS? */
-	PHPDBG_EOL_LF, /* UNIX */
-	PHPDBG_EOL_CR /* MAC */
-};
-
-int phpdbg_eol_global_update(char *name TSRMLS_DC);
-
-char *phpdbg_eol_name(int id);
-
-char *phpdbg_eol_rep(int id);
-
-void phpdbg_eol_convert(char **str, int *len TSRMLS_DC);
-
-#endif /* PHPDBG_EOL_H */
-
diff --git a/sapi/phpdbg/phpdbg_frame.c b/sapi/phpdbg/phpdbg_frame.c
index 0506c305dc..a235fe8cb0 100644
--- a/sapi/phpdbg/phpdbg_frame.c
+++ b/sapi/phpdbg/phpdbg_frame.c
@@ -52,27 +52,22 @@ void phpdbg_switch_frame(int frame TSRMLS_DC) /* {{{ */
 	int i = 0;
 
 	if (PHPDBG_FRAME(num) == frame) {
-		phpdbg_notice("frame", "id=\"%d\"", "Already in frame #%d", frame);
+		phpdbg_notice("Already in frame #%d", frame);
 		return;
 	}
 
-	phpdbg_try_access {
-		while (execute_data) {
-			if (i++ == frame) {
-				break;
-			}
-
-			do {
-				execute_data = execute_data->prev_execute_data;
-			} while (execute_data && execute_data->opline == NULL);
+	while (execute_data) {
+		if (i++ == frame) {
+			break;
 		}
-	} phpdbg_catch_access {
-		phpdbg_error("signalsegv", "", "Couldn't switch frames, invalid data source");
-		return;
-	} phpdbg_end_try_access();
+
+		do {
+			execute_data = execute_data->prev_execute_data;
+		} while (execute_data && execute_data->opline == NULL);
+	}
 
 	if (execute_data == NULL) {
-		phpdbg_error("frame", "type=\"maxnum\" id=\"%d\"", "No frame #%d", frame);
+		phpdbg_error("No frame #%d", frame);
 		return;
 	}
 
@@ -95,7 +90,7 @@ void phpdbg_switch_frame(int frame TSRMLS_DC) /* {{{ */
 		EG(called_scope) = PHPDBG_EX(current_called_scope);
 	}
 
-	phpdbg_notice("frame", "id=\"%d\"", "Switched to frame #%d", frame);
+	phpdbg_notice("Switched to frame #%d", frame);
 	phpdbg_list_file(
 		zend_get_executed_filename(TSRMLS_C),
 		3,
@@ -109,84 +104,61 @@ static void phpdbg_dump_prototype(zval **tmp TSRMLS_DC) /* {{{ */
 {
 	zval **funcname, **class, **type, **args, **argstmp;
 	char is_class;
-	int has_args = FAILURE;
 
-	zend_hash_find(Z_ARRVAL_PP(tmp), "function", sizeof("function"), (void **) &funcname);
+	zend_hash_find(Z_ARRVAL_PP(tmp), "function", sizeof("function"),
+		(void **)&funcname);
 
-	if ((is_class = zend_hash_find(Z_ARRVAL_PP(tmp), "object", sizeof("object"), (void **) &class)) == FAILURE) {
-		is_class = zend_hash_find(Z_ARRVAL_PP(tmp), "class", sizeof("class"), (void **)&class);
+	if ((is_class = zend_hash_find(Z_ARRVAL_PP(tmp),
+		"object", sizeof("object"), (void **)&class)) == FAILURE) {
+		is_class = zend_hash_find(Z_ARRVAL_PP(tmp), "class", sizeof("class"),
+			(void **)&class);
 	} else {
-		zend_get_object_classname(*class, (const char **) &Z_STRVAL_PP(class), (zend_uint *) &Z_STRLEN_PP(class) TSRMLS_CC);
+		zend_get_object_classname(*class, (const char **)&Z_STRVAL_PP(class),
+			(zend_uint *)&Z_STRLEN_PP(class) TSRMLS_CC);
 	}
 
 	if (is_class == SUCCESS) {
 		zend_hash_find(Z_ARRVAL_PP(tmp), "type", sizeof("type"), (void **)&type);
 	}
 
-	has_args = zend_hash_find(Z_ARRVAL_PP(tmp), "args", sizeof("args"), (void **)&args) == SUCCESS;
-
-	phpdbg_xml(" symbol=\"%s%s%s\"",
-		is_class == FAILURE?"":Z_STRVAL_PP(class),
-		is_class == FAILURE?"":Z_STRVAL_PP(type),
-		Z_STRVAL_PP(funcname)
-	);
-	if (has_args) {
-		phpdbg_xml(">");
-	} else {
-		phpdbg_xml(" />");
-	}
-
-	phpdbg_out("%s%s%s(",
+	phpdbg_write("%s%s%s(",
 		is_class == FAILURE?"":Z_STRVAL_PP(class),
 		is_class == FAILURE?"":Z_STRVAL_PP(type),
 		Z_STRVAL_PP(funcname)
 	);
 
-	if (has_args) {
+	if (zend_hash_find(Z_ARRVAL_PP(tmp), "args", sizeof("args"),
+		(void **)&args) == SUCCESS) {
 		HashPosition iterator;
-		const zend_function *func = NULL;
-		const zend_arg_info *arginfo = NULL;
-		int j = 0, m;
+		const zend_function *func = phpdbg_get_function(
+			Z_STRVAL_PP(funcname), is_class == FAILURE ? NULL : Z_STRVAL_PP(class) TSRMLS_CC);
+		const zend_arg_info *arginfo = func ? func->common.arg_info : NULL;
+		int j = 0, m = func ? func->common.num_args : 0;
 		zend_bool is_variadic = 0;
 
-		phpdbg_try_access {
-			/* assuming no autoloader call is necessary, class should have been loaded if it's in backtrace ... */
-			if ((func = phpdbg_get_function(Z_STRVAL_PP(funcname), is_class == FAILURE ? NULL : Z_STRVAL_PP(class) TSRMLS_CC))) {
-				arginfo = func->common.arg_info;
-			}
-		} phpdbg_end_try_access();
-
-		m = func ? func->common.num_args : 0;
-
 		zend_hash_internal_pointer_reset_ex(Z_ARRVAL_PP(args), &iterator);
-		while (zend_hash_get_current_data_ex(Z_ARRVAL_PP(args), (void **) &argstmp, &iterator) == SUCCESS) {
+		while (zend_hash_get_current_data_ex(Z_ARRVAL_PP(args),
+			(void **) &argstmp, &iterator) == SUCCESS) {
 			if (j) {
-				phpdbg_out(", ");
+				phpdbg_write(", ");
 			}
-			phpdbg_xml("<arg %r");
 			if (m && j < m) {
 #if PHP_VERSION_ID >= 50600
-				is_variadic = arginfo ? arginfo[j].is_variadic : 0;
+				is_variadic = arginfo[j].is_variadic;
 #endif
-				phpdbg_xml(" variadic=\"%s\" name=\"%s\">", is_variadic ? "variadic" : "", arginfo ? arginfo[j].name : "");
-				phpdbg_out("%s=%s", arginfo ? arginfo[j].name : "?", is_variadic ? "[": "");
-
-			} else {
-				phpdbg_xml(">");
+				phpdbg_write("%s=%s",
+					arginfo[j].name, is_variadic ? "[": "");
 			}
 			++j;
 
 			zend_print_flat_zval_r(*argstmp TSRMLS_CC);
 			zend_hash_move_forward_ex(Z_ARRVAL_PP(args), &iterator);
-
-			phpdbg_xml("</arg>");
 		}
 		if (is_variadic) {
-			phpdbg_out("]");
+			phpdbg_write("]");
 		}
-		phpdbg_xml("</frame>");
 	}
-	phpdbg_out(")");
+	phpdbg_write(")");
 }
 
 void phpdbg_dump_backtrace(size_t num TSRMLS_DC) /* {{{ */
@@ -198,54 +170,37 @@ void phpdbg_dump_backtrace(size_t num TSRMLS_DC) /* {{{ */
 	int i = 0, limit = num;
 	int user_defined;
 
-	PHPDBG_OUTPUT_BACKUP();
-
 	if (limit < 0) {
-		phpdbg_error("backtrace", "type=\"minnum\"", "Invalid backtrace size %d", limit);
-
-		PHPDBG_OUTPUT_BACKUP_RESTORE();
-		return;
+		phpdbg_error("Invalid backtrace size %d", limit);
 	}
 
-	phpdbg_try_access {
-		zend_fetch_debug_backtrace(&zbacktrace, 0, 0, limit TSRMLS_CC);
-	} phpdbg_catch_access {
-		phpdbg_error("signalsegv", "", "Couldn't fetch backtrace, invalid data source");
-		return;
-	} phpdbg_end_try_access();
-
-	phpdbg_xml("<backtrace %r>");
+	zend_fetch_debug_backtrace(
+		&zbacktrace, 0, 0, limit TSRMLS_CC);
 
 	zend_hash_internal_pointer_reset_ex(Z_ARRVAL(zbacktrace), &position);
-	zend_hash_get_current_data_ex(Z_ARRVAL(zbacktrace), (void **) &tmp, &position);
+	zend_hash_get_current_data_ex(Z_ARRVAL(zbacktrace), (void**)&tmp, &position);
 	while (1) {
-		user_defined = zend_hash_find(Z_ARRVAL_PP(tmp), "file", sizeof("file"), (void **) &file);
-		zend_hash_find(Z_ARRVAL_PP(tmp), "line", sizeof("line"), (void **) &line);
+		user_defined = zend_hash_find(Z_ARRVAL_PP(tmp), "file", sizeof("file"), (void **)&file);
+		zend_hash_find(Z_ARRVAL_PP(tmp), "line", sizeof("line"), (void **)&line);
 		zend_hash_move_forward_ex(Z_ARRVAL(zbacktrace), &position);
 
-		if (zend_hash_get_current_data_ex(Z_ARRVAL(zbacktrace), (void **) &tmp, &position) == FAILURE) {
-			phpdbg_write("frame", "id=\"%d\" symbol=\"{main}\" file=\"%s\" line=\"%d\"", "frame #%d: {main} at %s:%ld", i, Z_STRVAL_PP(file), Z_LVAL_PP(line));
+		if (zend_hash_get_current_data_ex(Z_ARRVAL(zbacktrace),
+			(void**)&tmp, &position) == FAILURE) {
+			phpdbg_write("frame #%d: {main} at %s:%ld", i, Z_STRVAL_PP(file), Z_LVAL_PP(line));
 			break;
 		}
 
 		if (user_defined == SUCCESS) {
-			phpdbg_out("frame #%d: ", i);
-			phpdbg_xml("<frame %r id=\"%d\" file=\"%s\" line=\"%d\"", i, Z_STRVAL_PP(file), Z_LVAL_PP(line));
+			phpdbg_write("frame #%d: ", i++);
 			phpdbg_dump_prototype(tmp TSRMLS_CC);
-			phpdbg_out(" at %s:%ld\n", Z_STRVAL_PP(file), Z_LVAL_PP(line));
-			i++;
+			phpdbg_writeln(" at %s:%ld", Z_STRVAL_PP(file), Z_LVAL_PP(line));
 		} else {
-			phpdbg_out(" => ");
-			phpdbg_xml("<frame %r id=\"%d\" internal=\"internal\"", i);
+			phpdbg_write(" => ");
 			phpdbg_dump_prototype(tmp TSRMLS_CC);
-			phpdbg_out(" (internal function)\n");
+			phpdbg_writeln(" (internal function)");
 		}
 	}
 
-	phpdbg_out("\n");
-	phpdbg_xml("</backtrace>");
-
+	phpdbg_writeln(EMPTY);
 	zval_dtor(&zbacktrace);
-
-	PHPDBG_OUTPUT_BACKUP_RESTORE();
 } /* }}} */
diff --git a/sapi/phpdbg/phpdbg_help.c b/sapi/phpdbg/phpdbg_help.c
index 652e170694..1e58dc69ca 100644
--- a/sapi/phpdbg/phpdbg_help.c
+++ b/sapi/phpdbg/phpdbg_help.c
@@ -22,7 +22,6 @@
 #include "phpdbg.h"
 #include "phpdbg_help.h"
 #include "phpdbg_prompt.h"
-#include "phpdbg_eol.h"
 #include "zend.h"
 
 ZEND_EXTERN_MODULE_GLOBALS(phpdbg);
@@ -62,11 +61,6 @@ void pretty_print(char *text TSRMLS_DC)
 	unsigned int last_blank_count = 0;    /* printable char offset of last blank char */
 	unsigned int line_count = 0;          /* number printable chars on current line */
 
-	if (PHPDBG_G(flags) & PHPDBG_WRITE_XML) {
-		phpdbg_xml("<help %r msg=\"%s\" />", text);
-		return;
-	}
-
 	/* First pass calculates a safe size for the pretty print version */
 	for (p = text; *p; p++) {
 		if (UNEXPECTED(p[0] == '*') && p[1] == '*') {
@@ -134,10 +128,10 @@ void pretty_print(char *text TSRMLS_DC)
 	*q++ = '\0';
 
 	if ((q-new)>size) {
-		phpdbg_error("help", "overrun=\"%lu\"", "Output overrun of %lu bytes", ((q - new) - size));
+		phpdbg_error("Output overrun of %lu bytes", ((q-new) - size));
 	}
 
-	phpdbg_out("%s\n", new);
+	phpdbg_write("%s\n", new);
 	efree(new);
 }  /* }}} */
 
@@ -207,7 +201,7 @@ static int get_command(
 
 	return num_matches;
 
-} /* }}} */
+} /* }}} */	
 
 PHPDBG_COMMAND(help) /* {{{ */
 {
@@ -237,7 +231,7 @@ PHPDBG_COMMAND(help) /* {{{ */
 				pretty_print(get_help("duplicate!" TSRMLS_CC) TSRMLS_CC);
 				return SUCCESS;
 			} else {
-				phpdbg_error("help", "type=\"ambiguousalias\" alias=\"%s\"", "Internal help error, non-unique alias \"%c\"", param->str[0]);
+				phpdbg_error("Internal help error, non-unique alias \"%c\"", param->str[0]);
 				return FAILURE;
 			}
 
@@ -265,41 +259,34 @@ PHPDBG_HELP(aliases) /* {{{ */
 	int len;
 
 	/* Print out aliases for all commands except help as this one comes last */
-	phpdbg_writeln("help", "", "Below are the aliased, short versions of all supported commands");
-	phpdbg_xml("<helpcommands %r>");
+	phpdbg_writeln("Below are the aliased, short versions of all supported commands");
 	for(c = phpdbg_prompt_commands; c->name; c++) {
 		if (c->alias && c->alias != 'h') {
-			phpdbg_writeln("command", "alias=\"%c\" name=\"%s\" tip=\"%s\"", " %c     %-20s  %s", c->alias, c->name, c->tip);
+			phpdbg_writeln(" %c     %-20s  %s", c->alias, c->name, c->tip);
 			if (c->subs) {
 				len = 20 - 1 - c->name_len;
 				for(c_sub = c->subs; c_sub->alias; c_sub++) {
 					if (c_sub->alias) {
-						phpdbg_writeln("subcommand", "parent_alias=\"%c\" alias=\"%c\" parent=\"%s\" name=\"%-*s\" tip=\"%s\"", " %c %c   %s %-*s  %s",
-							c->alias, c_sub->alias, c->name, len, c_sub->name, c_sub->tip);
+						phpdbg_writeln(" %c %c   %s %-*s  %s",
+							c->alias, c_sub->alias, (char *)c->name, len, c_sub->name, c_sub->tip);
 					}
 				}
 			}
 		}
 	}
 
-	phpdbg_xml("</helpcommands>");
-
 	/* Print out aliases for help as this one comes last, with the added text on how aliases are used */
 	get_command("h", 1, &c, phpdbg_prompt_commands TSRMLS_CC);
-	phpdbg_writeln("aliasinfo", "alias=\"%c\" name=\"%s\" tip=\"%s\"", " %c     %-20s  %s\n", c->alias, c->name, c->tip);
-
-	phpdbg_xml("<helpaliases>");
+	phpdbg_writeln(" %c     %-20s  %s\n", c->alias, c->name, c->tip);
 
 	len = 20 - 1 - c->name_len;
 	for(c_sub = c->subs; c_sub->alias; c_sub++) {
 		if (c_sub->alias) {
-			phpdbg_writeln("alias", "parent_alias=\"%c\" alias=\"%c\" parent=\"%s\" name=\"%-*s\" tip=\"%s\"", " %c %c   %s %-*s  %s",
+			phpdbg_writeln(" %c %c   %s %-*s  %s",
 				c->alias, c_sub->alias, c->name, len, c_sub->name, c_sub->tip);
 		}
 	}
 
-	phpdbg_xml("</helpaliases>");
-
 	pretty_print(get_help("aliases!" TSRMLS_CC) TSRMLS_CC);
 	return SUCCESS;
 } /* }}} */
@@ -320,7 +307,7 @@ PHPDBG_HELP(aliases) /* {{{ */
  * Also note the convention that help text not directly referenceable as a help param
  * has a key ending in !
  */
-#define CR "\n" 
+#define CR "\n"
 phpdbg_help_text_t phpdbg_help_text[] = {
 
 /******************************** General Help Topics ********************************/
@@ -375,7 +362,7 @@ phpdbg_help_text_t phpdbg_help_text[] = {
 "  **-c**      **-c**/my/php.ini       Set php.ini file to load" CR
 "  **-d**      **-d**memory_limit=4G   Set a php.ini directive" CR
 "  **-n**                          Disable default php.ini" CR
-"  **-q**                          Suppress welcome banner" CR
+"  **-q**                          Supress welcome banner" CR
 "  **-v**                          Enable oplog output" CR
 "  **-s**                          Enable stepping" CR
 "  **-b**                          Disable colour" CR
@@ -388,7 +375,6 @@ phpdbg_help_text_t phpdbg_help_text[] = {
 "  **-S**      **-S**cli               Override SAPI name, careful!" CR
 "  **-l**      **-l**4000              Setup remote console ports" CR
 "  **-a**      **-a**192.168.0.3       Setup remote console bind address" CR
-"  **-x**                          Enable xml output (instead of normal text output)" CR
 "  **-V**                          Print version number" CR
 "  **--**      **--** arg1 arg2        Use to delimit phpdbg arguments and php $argv; append any $argv "
 "argument after it" CR CR
@@ -400,7 +386,9 @@ phpdbg_help_text_t phpdbg_help_text[] = {
 "bind address using the **-a** option. If **-a** is specied without an argument, then phpdbg "
 "will bind to all available interfaces.  You should be aware of the security implications of "
 "doing this, so measures should be taken to secure this service if bound to a publicly accessible "
-"interface/port."
+"interface/port." CR CR
+
+"Specify both stdin and stdout with -lstdin/stdout; by default stdout is stdin * 2."
 },
 
 {"phpdbginit", CR
@@ -557,7 +545,7 @@ phpdbg_help_text_t phpdbg_help_text[] = {
 
 "    $P break ZEND_ADD" CR
 "    $P b ZEND_ADD" CR
-"    Break on any occurrence of the opcode ZEND_ADD" CR CR
+"    Break on any occurence of the opcode ZEND_ADD" CR CR
 
 "    $P break del 2" CR
 "    $P b ~ 2" CR
@@ -654,16 +642,14 @@ phpdbg_help_text_t phpdbg_help_text[] = {
 "Specific info commands are show below:" CR CR
 
 "  **Target**   **Alias**  **Purpose**" CR
-"  **break**      **b**      show current breakpoints" CR
-"  **files**      **F**      show included files" CR
-"  **classes**    **c**      show loaded classes" CR
-"  **funcs**      **f**      show loaded functions" CR
-"  **error**      **e**      show last error" CR
-"  **constants**  **d**      show user-defined constants" CR
-"  **vars**       **v**      show active variables" CR
-"  **globals**    **g**      show superglobal variables" CR
-"  **literal**    **l**      show active literal constants" CR
-"  **memory**     **m**      show memory manager stats"
+"  **break**    **b**      show current breakpoints" CR
+"  **files**    **F**      show included files" CR
+"  **classes**  **c**      show loaded classes" CR
+"  **funcs**    **f**      show loaded classes" CR
+"  **error**    **e**      show last error" CR
+"  **vars**     **v**      show active variables" CR
+"  **literal**  **l**      show active literal constants" CR
+"  **memory**   **m**      show memory manager stats"
 },
 
 // ******** same issue about breakpoints in called frames
diff --git a/sapi/phpdbg/phpdbg_help.h b/sapi/phpdbg/phpdbg_help.h
index 4a433fda6c..16a1e771e3 100644
--- a/sapi/phpdbg/phpdbg_help.h
+++ b/sapi/phpdbg/phpdbg_help.h
@@ -35,9 +35,9 @@ PHPDBG_HELP(aliases);
 extern const phpdbg_command_t phpdbg_help_commands[];
 
 #define phpdbg_help_header() \
-	phpdbg_notice("version", "version=\"%s\"", "Welcome to phpdbg, the interactive PHP debugger, v%s", PHPDBG_VERSION);
+	phpdbg_notice("Welcome to phpdbg, the interactive PHP debugger, v%s", PHPDBG_VERSION);
 #define phpdbg_help_footer() \
-	phpdbg_notice("issues", "url=\"%s\"", "Please report bugs to <%s>", PHPDBG_ISSUES);
+	phpdbg_notice("Please report bugs to <%s>", PHPDBG_ISSUES);
 
 typedef struct _phpdbg_help_text_t {
 	char *key;
diff --git a/sapi/phpdbg/phpdbg_info.c b/sapi/phpdbg/phpdbg_info.c
index 4774fa5a9e..97f88bfa1e 100644
--- a/sapi/phpdbg/phpdbg_info.c
+++ b/sapi/phpdbg/phpdbg_info.c
@@ -27,20 +27,18 @@
 
 ZEND_EXTERN_MODULE_GLOBALS(phpdbg);
 
-#define PHPDBG_INFO_COMMAND_D(f, h, a, m, l, s, flags) \
-	PHPDBG_COMMAND_D_EXP(f, h, a, m, l, s, &phpdbg_prompt_commands[14], flags)
+#define PHPDBG_INFO_COMMAND_D(f, h, a, m, l, s) \
+	PHPDBG_COMMAND_D_EXP(f, h, a, m, l, s, &phpdbg_prompt_commands[14])
 
 const phpdbg_command_t phpdbg_info_commands[] = {
-	PHPDBG_INFO_COMMAND_D(break,     "show breakpoints",              'b', info_break,     NULL, 0, PHPDBG_ASYNC_SAFE),
-	PHPDBG_INFO_COMMAND_D(files,     "show included files",           'F', info_files,     NULL, 0, PHPDBG_ASYNC_SAFE),
-	PHPDBG_INFO_COMMAND_D(classes,   "show loaded classes",           'c', info_classes,   NULL, 0, PHPDBG_ASYNC_SAFE),
-	PHPDBG_INFO_COMMAND_D(funcs,     "show loaded classes",           'f', info_funcs,     NULL, 0, PHPDBG_ASYNC_SAFE),
-	PHPDBG_INFO_COMMAND_D(error,     "show last error",               'e', info_error,     NULL, 0, PHPDBG_ASYNC_SAFE),
-	PHPDBG_INFO_COMMAND_D(constants, "show user defined constants",   'd', info_constants, NULL, 0, PHPDBG_ASYNC_SAFE),
-	PHPDBG_INFO_COMMAND_D(vars,      "show active variables",         'v', info_vars,      NULL, 0, PHPDBG_ASYNC_SAFE),
-	PHPDBG_INFO_COMMAND_D(globals,   "show superglobals",             'g', info_globals,   NULL, 0, PHPDBG_ASYNC_SAFE),
-	PHPDBG_INFO_COMMAND_D(literal,   "show active literal constants", 'l', info_literal,   NULL, 0, PHPDBG_ASYNC_SAFE),
-	PHPDBG_INFO_COMMAND_D(memory,    "show memory manager stats",     'm', info_memory,    NULL, 0, PHPDBG_ASYNC_SAFE),
+	PHPDBG_INFO_COMMAND_D(break,    "show breakpoints",              'b', info_break,   NULL, 0),
+	PHPDBG_INFO_COMMAND_D(files,    "show included files",           'F', info_files,   NULL, 0),
+	PHPDBG_INFO_COMMAND_D(classes,  "show loaded classes",           'c', info_classes, NULL, 0),
+	PHPDBG_INFO_COMMAND_D(funcs,    "show loaded classes",           'f', info_funcs,   NULL, 0),
+	PHPDBG_INFO_COMMAND_D(error,    "show last error",               'e', info_error,   NULL, 0),
+	PHPDBG_INFO_COMMAND_D(vars,     "show active variables",         'v', info_vars,    NULL, 0),
+	PHPDBG_INFO_COMMAND_D(literal,  "show active literal constants", 'l', info_literal, NULL, 0),
+	PHPDBG_INFO_COMMAND_D(memory,   "show memory manager stats",     'm', info_memory,  NULL, 0),
 	PHPDBG_END_COMMAND
 };
 
@@ -64,21 +62,15 @@ PHPDBG_INFO(files) /* {{{ */
 	HashPosition pos;
 	char *fname;
 
-	phpdbg_try_access {
-		phpdbg_notice("includedfilecount", "num=\"%d\"", "Included files: %d", zend_hash_num_elements(&EG(included_files)));
-	} phpdbg_catch_access {
-		phpdbg_error("signalsegv", "", "Could not fetch included file count, invalid data source");
-	} phpdbg_end_try_access();
-
-	phpdbg_try_access {
-		zend_hash_internal_pointer_reset_ex(&EG(included_files), &pos);
-		while (zend_hash_get_current_key_ex(&EG(included_files), &fname, NULL, NULL, 0, &pos) == HASH_KEY_IS_STRING) {
-			phpdbg_writeln("includedfile", "name=\"%s\"", "File: %s", fname);
-			zend_hash_move_forward_ex(&EG(included_files), &pos);
-		}
-	} phpdbg_catch_access {
-		phpdbg_error("signalsegv", "", "Could not fetch file name, invalid data source, aborting included file listing");
-	} phpdbg_end_try_access();
+	phpdbg_notice("Included files: %d",
+		zend_hash_num_elements(&EG(included_files)));
+
+	zend_hash_internal_pointer_reset_ex(&EG(included_files), &pos);
+	while (zend_hash_get_current_key_ex(&EG(included_files), &fname,
+		NULL, NULL, 0, &pos) == HASH_KEY_IS_STRING) {
+		phpdbg_writeln("File: %s", fname);
+		zend_hash_move_forward_ex(&EG(included_files), &pos);
+	}
 
 	return SUCCESS;
 } /* }}} */
@@ -86,98 +78,23 @@ PHPDBG_INFO(files) /* {{{ */
 PHPDBG_INFO(error) /* {{{ */
 {
 	if (PG(last_error_message)) {
-		phpdbg_try_access {
-			phpdbg_writeln("lasterror", "error=\"%s\" file=\"%s\" line=\"%d\"", "Last error: %s at %s line %d", PG(last_error_message), PG(last_error_file), PG(last_error_lineno));
-		} phpdbg_catch_access {
-			phpdbg_notice("lasterror", "error=\"\"", "No error found!");
-		} phpdbg_end_try_access();
+		phpdbg_writeln("Last error: %s at %s line %d",
+			PG(last_error_message), PG(last_error_file), PG(last_error_lineno));
 	} else {
-		phpdbg_notice("lasterror", "error=\"\"", "No error found!");
+		phpdbg_notice("No error found!");
 	}
 	return SUCCESS;
 } /* }}} */
 
-PHPDBG_INFO(constants) /* {{{ */
+PHPDBG_INFO(vars) /* {{{ */
 {
-	HashPosition pos;
-	HashTable consts;
-	zend_constant *data;
-
-	zend_hash_init(&consts, 8, NULL, NULL, 0);
-
-	if (EG(zend_constants)) {
-		phpdbg_try_access {
-			zend_hash_internal_pointer_reset_ex(EG(zend_constants), &pos);
-			while (zend_hash_get_current_data_ex(EG(zend_constants), (void **) &data, &pos) == SUCCESS) {
-				if (data->module_number == PHP_USER_CONSTANT) {
-					zend_hash_update(&consts, data->name, data->name_len, (void **) &data, sizeof(zend_constant *), NULL);
-				}
-				zend_hash_move_forward_ex(EG(zend_constants), &pos);
-			}
-		} phpdbg_catch_access {
-			phpdbg_error("signalsegv", "", "Cannot fetch all the constants, invalid data source");
-		} phpdbg_end_try_access();
-	}
-
-	phpdbg_notice("constantinfo", "num=\"%d\"", "User-defined constants (%d)", zend_hash_num_elements(&consts));
-
-	if (zend_hash_num_elements(&consts)) {
-		phpdbg_out("Address            Refs    Type      Constant\n");
-		for (zend_hash_internal_pointer_reset_ex(&consts, &pos);
-		     zend_hash_get_current_data_ex(&consts, (void **) &data, &pos) == SUCCESS;
-		     zend_hash_move_forward_ex(&consts, &pos)) {
-			data = *(zend_constant **) data;
-
-#define VARIABLEINFO(attrs, msg, ...) phpdbg_writeln("constant", "address=\"%p\" refcount=\"%d\" type=\"%s\" name=\"%.*s\" " attrs, "%-18p %-7d %-9s %.*s" msg, &data->value, Z_REFCOUNT(data->value), zend_zval_type_name(&data->value), data->name_len - 1, data->name, ##__VA_ARGS__)
-
-			switch (Z_TYPE(data->value)) {
-				case IS_STRING:
-					phpdbg_try_access {
-						VARIABLEINFO("length=\"%d\" value=\"%.*s\"", "\nstring (%d) \"%.*s%s\"", Z_STRLEN(data->value), Z_STRLEN(data->value) < 255 ? Z_STRLEN(data->value) : 255, Z_STRVAL(data->value), Z_STRLEN(data->value) > 255 ? "..." : "");
-					} phpdbg_catch_access {
-						VARIABLEINFO("", "");
-					} phpdbg_end_try_access();
-					break;
-				case IS_BOOL:
-					VARIABLEINFO("value=\"%s\"", "\nbool (%s)", Z_LVAL(data->value) ? "true" : "false");
-					break;
-				case IS_LONG:
-					VARIABLEINFO("value=\"%ld\"", "\nint (%ld)", Z_LVAL(data->value));
-					break;
-				case IS_DOUBLE:
-					VARIABLEINFO("value=\"%lf\"", "\ndouble (%lf)", Z_DVAL(data->value));
-					break;
-				default:
-					VARIABLEINFO("", "");
-
-#undef VARIABLEINFO
-			}
-		}
-	}
-
-	return SUCCESS;
-} /* }}} */
-
-static int phpdbg_arm_auto_global(zend_auto_global *auto_global TSRMLS_DC) {
-	if (auto_global->armed) {
-		if (PHPDBG_G(flags) & PHPDBG_IN_SIGNAL_HANDLER) {
-			phpdbg_notice("variableinfo", "unreachable=\"%.*s\"", "Cannot show information about superglobal variable %.*s", auto_global->name_len, auto_global->name);
-		} else {
-			auto_global->armed = auto_global->auto_global_callback(auto_global->name, auto_global->name_len TSRMLS_CC);
-		}
-	}
-
-	return 0;
-}
-
-static int phpdbg_print_symbols(zend_bool show_globals TSRMLS_DC) {
-	HashTable vars, *symtable;
+	HashTable vars;
 	HashPosition pos;
 	char *var;
 	zval **data;
 
 	if (!EG(active_op_array)) {
-		phpdbg_error("inactive", "type=\"op_array\"", "No active op array!");
+		phpdbg_error("No active op array!");
 		return SUCCESS;
 	}
 
@@ -185,112 +102,100 @@ static int phpdbg_print_symbols(zend_bool show_globals TSRMLS_DC) {
 		zend_rebuild_symbol_table(TSRMLS_C);
 
 		if (!EG(active_symbol_table)) {
-			phpdbg_error("inactive", "type=\"symbol_table\"", "No active symbol table!");
+			phpdbg_error("No active symbol table!");
 			return SUCCESS;
 		}
 	}
 
-
-	if (show_globals) {
-		/* that array should only be manipulated during init, so safe for async access during execution */
-		zend_hash_apply(CG(auto_globals), (apply_func_t) phpdbg_arm_auto_global TSRMLS_CC);
-		symtable = &EG(symbol_table);
-	} else {
-		symtable = EG(active_symbol_table);
-	}
-
 	zend_hash_init(&vars, 8, NULL, NULL, 0);
 
-	phpdbg_try_access {
-		zend_hash_internal_pointer_reset_ex(symtable, &pos);
-		while (zend_hash_get_current_key_ex(symtable, &var, NULL, NULL, 0, &pos) == HASH_KEY_IS_STRING) {
-			zend_hash_get_current_data_ex(symtable, (void **)&data, &pos);
-			if (zend_is_auto_global(var, strlen(var) TSRMLS_CC) ^ !show_globals) {
-				zend_hash_update(&vars, var, strlen(var)+1, (void**)data, sizeof(zval*), NULL);
-			}
-			zend_hash_move_forward_ex(symtable, &pos);
+	zend_hash_internal_pointer_reset_ex(EG(active_symbol_table), &pos);
+	while (zend_hash_get_current_key_ex(EG(active_symbol_table), &var,
+		NULL, NULL, 0, &pos) == HASH_KEY_IS_STRING) {
+		zend_hash_get_current_data_ex(EG(active_symbol_table), (void **)&data, &pos);
+		if (*var != '_') {
+			zend_hash_update(
+				&vars, var, strlen(var)+1, (void**)data, sizeof(zval*), NULL);
 		}
-	} phpdbg_catch_access {
-		phpdbg_error("signalsegv", "", "Cannot fetch all data from the symbol table, invalid data source");
-	} phpdbg_end_try_access();
+		zend_hash_move_forward_ex(EG(active_symbol_table), &pos);
+	}
 
-	if (show_globals) {
-		phpdbg_notice("variableinfo", "num=\"%d\"", "Superglobal variables (%d)", zend_hash_num_elements(&vars));
-	} else {
+	{
 		zend_op_array *ops = EG(active_op_array);
-
+		
 		if (ops->function_name) {
 			if (ops->scope) {
-				phpdbg_notice("variableinfo", "method=\"%s::%s\" num=\"%d\"", "Variables in %s::%s() (%d)", ops->scope->name, ops->function_name, zend_hash_num_elements(&vars));
+				phpdbg_notice(
+				"Variables in %s::%s() (%d)", ops->scope->name, ops->function_name, zend_hash_num_elements(&vars));
 			} else {
-				phpdbg_notice("variableinfo", "function=\"%s\" num=\"%d\"", "Variables in %s() (%d)", ops->function_name, zend_hash_num_elements(&vars));
+				phpdbg_notice(
+					"Variables in %s() (%d)", ops->function_name, zend_hash_num_elements(&vars));
 			}
 		} else {
 			if (ops->filename) {
-				phpdbg_notice("variableinfo", "file=\"%s\" num=\"%d\"", "Variables in %s (%d)", ops->filename, zend_hash_num_elements(&vars));
+				phpdbg_notice(
+				"Variables in %s (%d)", ops->filename, zend_hash_num_elements(&vars));
 			} else {
-				phpdbg_notice("variableinfo", "opline=\"%p\" num=\"%d\"", "Variables @ %p (%d)", ops, zend_hash_num_elements(&vars));
+				phpdbg_notice(
+					"Variables @ %p (%d)", ops, zend_hash_num_elements(&vars));
 			}
 		}
 	}
 
 	if (zend_hash_num_elements(&vars)) {
-		phpdbg_out("Address            Refs    Type      Variable\n");
+		phpdbg_writeln("Address\t\tRefs\tType\t\tVariable");
 		for (zend_hash_internal_pointer_reset_ex(&vars, &pos);
-		     zend_hash_get_current_data_ex(&vars, (void**) &data, &pos) == SUCCESS;
-		     zend_hash_move_forward_ex(&vars, &pos)) {
+			zend_hash_get_current_data_ex(&vars, (void**) &data, &pos) == SUCCESS;
+			zend_hash_move_forward_ex(&vars, &pos)) {
 			char *var;
-			zend_bool invalid_data = 1;
 
 			zend_hash_get_current_key_ex(&vars, &var, NULL, NULL, 0, &pos);
 
-			phpdbg_try_access {
-				if (!(invalid_data = !*data)) {
-#define VARIABLEINFO(attrs, msg, ...) phpdbg_writeln("variable", "address=\"%p\" refcount=\"%d\" type=\"%s\" refstatus=\"%s\" name=\"%s\" " attrs, "%-18p %-7d %-9s %s$%s" msg, *data, Z_REFCOUNT_PP(data), zend_zval_type_name(*data), Z_ISREF_PP(data) ? "&": "", var, ##__VA_ARGS__)
-
-					switch (Z_TYPE_PP(data)) {
-						case IS_RESOURCE:
-							phpdbg_try_access {
-								int type;
-								VARIABLEINFO("type=\"%s\"", "\n|-------(typeof)------> (%s)\n", zend_list_find(Z_RESVAL_PP(data), &type) ? zend_rsrc_list_get_rsrc_type(type TSRMLS_CC) : "unknown");
-							} phpdbg_catch_access {
-								VARIABLEINFO("type=\"unknown\"", "\n|-------(typeof)------> (unknown)\n");
-							} phpdbg_end_try_access();
-							break;
-						case IS_OBJECT:
-							phpdbg_try_access {
-								VARIABLEINFO("instanceof=\"%s\"", "\n|-----(instanceof)----> (%s)\n", Z_OBJCE_PP(data)->name);
-							} phpdbg_catch_access {
-								VARIABLEINFO("instanceof=\"%s\"", "\n|-----(instanceof)----> (unknown)\n");
-							} phpdbg_end_try_access();
-							break;
-						case IS_STRING:
-							phpdbg_try_access {
-								VARIABLEINFO("length=\"%d\" value=\"%.*s\"", "\nstring (%d) \"%.*s%s\"", Z_STRLEN_PP(data), Z_STRLEN_PP(data) < 255 ? Z_STRLEN_PP(data) : 255, Z_STRVAL_PP(data), Z_STRLEN_PP(data) > 255 ? "..." : "");
-							} phpdbg_catch_access {
-								VARIABLEINFO("", "");
-							} phpdbg_end_try_access();
-							break;
-						case IS_BOOL:
-							VARIABLEINFO("value=\"%s\"", "\nbool (%s)", Z_LVAL_PP(data) ? "true" : "false");
-							break;
-						case IS_LONG:
-							VARIABLEINFO("value=\"%ld\"", "\nint (%ld)", Z_LVAL_PP(data));
-							break;
-						case IS_DOUBLE:
-							VARIABLEINFO("value=\"%lf\"", "\ndouble (%lf)", Z_DVAL_PP(data));
-							break;
-						default:
-							VARIABLEINFO("", "");
-					}
+			if (*data) {
+				phpdbg_write(
+				"%p\t%d\t",
+					*data,
+					Z_REFCOUNT_PP(data));
+
+				switch (Z_TYPE_PP(data)) {
+					case IS_STRING: 	phpdbg_write("(string)\t"); 	break;
+					case IS_LONG: 		phpdbg_write("(integer)\t"); 	break;
+					case IS_DOUBLE: 	phpdbg_write("(float)\t"); 		break;
+					case IS_RESOURCE:	phpdbg_write("(resource)\t"); 	break;
+					case IS_ARRAY:		phpdbg_write("(array)\t"); 		break;
+					case IS_OBJECT:		phpdbg_write("(object)\t"); 	break;
+					case IS_NULL:		phpdbg_write("(null)\t"); 		break;
 				}
 
-#undef VARIABLEINFO
-			} phpdbg_end_try_access();
-
-			if (invalid_data) {
-				phpdbg_writeln("variable", "name=\"%s\"", "n/a\tn/a\tn/a\t$%s", var);
+				if (Z_TYPE_PP(data) == IS_RESOURCE) {
+					int type;
+
+					phpdbg_writeln(
+						"%s$%s", Z_ISREF_PP(data) ? "&": "", var);
+					if (zend_list_find(Z_RESVAL_PP(data), &type)) {
+						phpdbg_write(
+							"|-------(typeof)------> (%s)",
+							zend_rsrc_list_get_rsrc_type(type TSRMLS_CC));
+					} else {
+						phpdbg_write(
+							"|-------(typeof)------> (unknown)");
+					}
+					phpdbg_writeln(EMPTY);
+				} else if (Z_TYPE_PP(data) == IS_OBJECT) {
+					phpdbg_writeln(
+						"%s$%s", Z_ISREF_PP(data) ? "&": "", var);
+					phpdbg_write(
+						"|-----(instanceof)----> (%s)", Z_OBJCE_PP(data)->name);
+					phpdbg_writeln(EMPTY);
+				} else {
+					phpdbg_write(
+						"%s$%s", Z_ISREF_PP(data) ? "&": "", var);
+				}
+			} else {
+				phpdbg_write(
+					"n/a\tn/a\tn/a\t$%s", var);
 			}
+			phpdbg_writeln(EMPTY);
 		}
 	}
 
@@ -299,47 +204,42 @@ static int phpdbg_print_symbols(zend_bool show_globals TSRMLS_DC) {
 	return SUCCESS;
 } /* }}} */
 
-PHPDBG_INFO(vars) /* {{{ */
-{
-	return phpdbg_print_symbols(0 TSRMLS_CC);
-}
-
-PHPDBG_INFO(globals) /* {{{ */
-{
-	return phpdbg_print_symbols(1 TSRMLS_CC);
-}
-
 PHPDBG_INFO(literal) /* {{{ */
 {
-	/* literals are assumed to not be manipulated during executing of their op_array and as such async safe */
 	if ((EG(in_execution) && EG(active_op_array)) || PHPDBG_G(ops)) {
 		zend_op_array *ops = EG(active_op_array) ? EG(active_op_array) : PHPDBG_G(ops);
 		int literal = 0, count = ops->last_literal-1;
 
 		if (ops->function_name) {
 			if (ops->scope) {
-				phpdbg_notice("literalinfo", "method=\"%s::%s\" num=\"%d\"", "Literal Constants in %s::%s() (%d)", ops->scope->name, ops->function_name, count);
+				phpdbg_notice(
+				"Literal Constants in %s::%s() (%d)", ops->scope->name, ops->function_name, count);
 			} else {
-				phpdbg_notice("literalinfo", "function=\"%s\" num=\"%d\"", "Literal Constants in %s() (%d)", ops->function_name, count);
+				phpdbg_notice(
+					"Literal Constants in %s() (%d)", ops->function_name, count);
 			}
 		} else {
 			if (ops->filename) {
-				phpdbg_notice("literalinfo", "file=\"%s\" num=\"%d\"", "Literal Constants in %s (%d)", ops->filename, count);
+				phpdbg_notice(
+				"Literal Constants in %s (%d)", ops->filename, count);
 			} else {
-				phpdbg_notice("literalinfo", "opline=\"%p\" num=\"%d\"", "Literal Constants @ %p (%d)", ops, count);
+				phpdbg_notice(
+					"Literal Constants @ %p (%d)", ops, count);
 			}
 		}
 
 		while (literal < ops->last_literal) {
 			if (Z_TYPE(ops->literals[literal].constant) != IS_NULL) {
-				phpdbg_write("literal", "id=\"%u\"", "|-------- C%u -------> [", literal);
-				zend_print_zval(&ops->literals[literal].constant, 0);
-				phpdbg_out("]\n");
+				phpdbg_write("|-------- C%u -------> [", literal);
+				zend_print_zval(
+					&ops->literals[literal].constant, 0);
+				phpdbg_write("]");
+				phpdbg_writeln(EMPTY);
 			}
 			literal++;
 		}
 	} else {
-		phpdbg_error("inactive", "type=\"execution\"", "Not executing!");
+		phpdbg_error("Not executing!");
 	}
 
 	return SUCCESS;
@@ -347,40 +247,28 @@ PHPDBG_INFO(literal) /* {{{ */
 
 PHPDBG_INFO(memory) /* {{{ */
 {
-	size_t used, real, peak_used, peak_real;
-	zend_mm_heap *heap;
-	zend_bool is_mm;
-
-	if (PHPDBG_G(flags) & PHPDBG_IN_SIGNAL_HANDLER) {
-		heap = zend_mm_set_heap(phpdbg_original_heap_sigsafe_mem(TSRMLS_C) TSRMLS_CC);
-	}
-	if ((is_mm = is_zend_mm(TSRMLS_C))) {
-		used = zend_memory_usage(0 TSRMLS_CC);
-		real = zend_memory_usage(1 TSRMLS_CC);
-		peak_used = zend_memory_peak_usage(0 TSRMLS_CC);
-		peak_real = zend_memory_peak_usage(1 TSRMLS_CC);
-	}
-	if (PHPDBG_G(flags) & PHPDBG_IN_SIGNAL_HANDLER) {
-		zend_mm_set_heap(heap TSRMLS_CC);
-	}
-
-	if (is_mm) {
-		phpdbg_notice("meminfo", "", "Memory Manager Information");
-		phpdbg_notice("current", "", "Current");
-		phpdbg_writeln("used", "mem=\"%.3f\"", "|-------> Used:\t%.3f kB", (float) (used / 1024));
-		phpdbg_writeln("real", "mem=\"%.3f\"", "|-------> Real:\t%.3f kB", (float) (real / 1024));
-		phpdbg_notice("peak", "", "Peak");
-		phpdbg_writeln("used", "mem=\"%.3f\"", "|-------> Used:\t%.3f kB", (float) (peak_used / 1024));
-		phpdbg_writeln("real", "mem=\"%.3f\"", "|-------> Real:\t%.3f kB", (float) (peak_real / 1024));
+	if (is_zend_mm(TSRMLS_C)) {
+		phpdbg_notice("Memory Manager Information");
+		phpdbg_notice("Current");
+		phpdbg_writeln("|-------> Used:\t%.3f kB", 
+			(float) (zend_memory_usage(0 TSRMLS_CC)/1024));
+		phpdbg_writeln("|-------> Real:\t%.3f kB", 
+			(float) (zend_memory_usage(1 TSRMLS_CC)/1024));
+		phpdbg_notice("Peak");
+		phpdbg_writeln("|-------> Used:\t%.3f kB", 
+			(float) (zend_memory_peak_usage(0 TSRMLS_CC)/1024));
+		phpdbg_writeln("|-------> Real:\t%.3f kB", 
+			(float) (zend_memory_peak_usage(1 TSRMLS_CC)/1024));
 	} else {
-		phpdbg_error("inactive", "type=\"memory_manager\"", "Memory Manager Disabled!");
+		phpdbg_error("Memory Manager Disabled!");
 	}
 	return SUCCESS;
 } /* }}} */
 
 static inline void phpdbg_print_class_name(zend_class_entry **ce TSRMLS_DC) /* {{{ */
 {
-	phpdbg_writeln("class", "type=\"%s\" flags=\"%s\" name=\"%s\" methodcount=\"%d\"", "%s %s %s (%d)",
+	phpdbg_write(
+		"%s %s %s (%d)",
 		((*ce)->type == ZEND_USER_CLASS) ?
 			"User" : "Internal",
 		((*ce)->ce_flags & ZEND_ACC_INTERFACE) ?
@@ -399,44 +287,44 @@ PHPDBG_INFO(classes) /* {{{ */
 
 	zend_hash_init(&classes, 8, NULL, NULL, 0);
 
-	phpdbg_try_access {
-		for (zend_hash_internal_pointer_reset_ex(EG(class_table), &position);
-		     zend_hash_get_current_data_ex(EG(class_table), (void**)&ce, &position) == SUCCESS;
-		     zend_hash_move_forward_ex(EG(class_table), &position)) {
-			if ((*ce)->type == ZEND_USER_CLASS) {
-				zend_hash_next_index_insert(&classes, ce, sizeof(ce), NULL);
-			}
+	for (zend_hash_internal_pointer_reset_ex(EG(class_table), &position);
+		zend_hash_get_current_data_ex(EG(class_table), (void**)&ce, &position) == SUCCESS;
+		zend_hash_move_forward_ex(EG(class_table), &position)) {
+
+		if ((*ce)->type == ZEND_USER_CLASS) {
+			zend_hash_next_index_insert(
+				&classes, ce, sizeof(ce), NULL);
 		}
-	} phpdbg_catch_access {
-		phpdbg_notice("signalsegv", "", "Not all classes could be fetched, possibly invalid data source");
-	} phpdbg_end_try_access();
+	}
 
-	phpdbg_notice("classinfo", "num=\"%d\"", "User Classes (%d)", zend_hash_num_elements(&classes));
+	phpdbg_notice("User Classes (%d)",
+		zend_hash_num_elements(&classes));
 
-	/* once added, assume that classes are stable... until shutdown. */
 	for (zend_hash_internal_pointer_reset_ex(&classes, &position);
-	     zend_hash_get_current_data_ex(&classes, (void**)&ce, &position) == SUCCESS;
-	     zend_hash_move_forward_ex(&classes, &position)) {
+		zend_hash_get_current_data_ex(&classes, (void**)&ce, &position) == SUCCESS;
+		zend_hash_move_forward_ex(&classes, &position)) {
 
 		phpdbg_print_class_name(ce TSRMLS_CC);
+		phpdbg_writeln(EMPTY);
 
 		if ((*ce)->parent) {
-			zend_class_entry *pce;
-
-			phpdbg_xml("<parents %r>");
-			pce = (*ce)->parent;
+			zend_class_entry *pce = (*ce)->parent;
 			do {
-				phpdbg_out("|-------- ");
+				phpdbg_write("|-------- ");
 				phpdbg_print_class_name(&pce TSRMLS_CC);
+				phpdbg_writeln(EMPTY);
 			} while ((pce = pce->parent));
-			phpdbg_xml("</parents>");
 		}
 
 		if ((*ce)->info.user.filename) {
-			phpdbg_writeln("classsource", "file=\"%s\" line=\"%u\"", "|---- in %s on line %u", (*ce)->info.user.filename, (*ce)->info.user.line_start);
+			phpdbg_writeln(
+				"|---- in %s on line %u",
+				(*ce)->info.user.filename,
+				(*ce)->info.user.line_start);
 		} else {
-			phpdbg_writeln("classsource", "", "|---- no source code");
+			phpdbg_writeln("|---- no source code");
 		}
+	    	phpdbg_writeln(EMPTY);
 	}
 
 	zend_hash_destroy(&classes);
@@ -452,34 +340,29 @@ PHPDBG_INFO(funcs) /* {{{ */
 
 	zend_hash_init(&functions, 8, NULL, NULL, 0);
 
-	phpdbg_try_access {
-		for (zend_hash_internal_pointer_reset_ex(EG(function_table), &position);
-		     zend_hash_get_current_data_ex(EG(function_table), (void**)&zf, &position) == SUCCESS;
-		     zend_hash_move_forward_ex(EG(function_table), &position)) {
-			if (zf->type == ZEND_USER_FUNCTION) {
-				zend_hash_next_index_insert(&functions, (void**) &zf, sizeof(zend_function), NULL);
-			}
+	for (zend_hash_internal_pointer_reset_ex(EG(function_table), &position);
+		zend_hash_get_current_data_ex(EG(function_table), (void**)&zf, &position) == SUCCESS;
+		zend_hash_move_forward_ex(EG(function_table), &position)) {
+
+		if (zf->type == ZEND_USER_FUNCTION) {
+			zend_hash_next_index_insert(
+				&functions, (void**) &zf, sizeof(zend_function), NULL);
 		}
-	} phpdbg_catch_access {
-		phpdbg_notice("signalsegv", "", "Not all functions could be fetched, possibly invalid data source");
-	} phpdbg_end_try_access();
+	}
 
-	phpdbg_notice("functioninfo", "num=\"%d\"", "User Functions (%d)", zend_hash_num_elements(&functions));
+	phpdbg_notice("User Functions (%d)",
+		zend_hash_num_elements(&functions));
 
 	for (zend_hash_internal_pointer_reset_ex(&functions, &position);
 		zend_hash_get_current_data_ex(&functions, (void**)&pzf, &position) == SUCCESS;
 		zend_hash_move_forward_ex(&functions, &position)) {
 		zend_op_array *op_array = &((*pzf)->op_array);
 
-		phpdbg_write("function", "name=\"%s\"", "|-------- %s", op_array->function_name ? op_array->function_name : "{main}");
-
-		if (op_array->filename) {
-			phpdbg_writeln("functionsource", "file=\"%s\" line=\"%d\"", " in %s on line %d",
-				op_array->filename,
-				op_array->line_start);
-		} else {
-			phpdbg_writeln("functionsource", "", " (no source code)");
-		}
+		phpdbg_writeln(
+			"|-------- %s in %s on line %d",
+			op_array->function_name ? op_array->function_name : "{main}",
+			op_array->filename ? op_array->filename : "(no source code)",
+			op_array->line_start);
 	}
 
 	zend_hash_destroy(&functions);
diff --git a/sapi/phpdbg/phpdbg_info.h b/sapi/phpdbg/phpdbg_info.h
index aac9fa3ab3..c36e6bebd6 100644
--- a/sapi/phpdbg/phpdbg_info.h
+++ b/sapi/phpdbg/phpdbg_info.h
@@ -30,9 +30,7 @@ PHPDBG_INFO(break);
 PHPDBG_INFO(classes);
 PHPDBG_INFO(funcs);
 PHPDBG_INFO(error);
-PHPDBG_INFO(constants);
 PHPDBG_INFO(vars);
-PHPDBG_INFO(globals);
 PHPDBG_INFO(literal);
 PHPDBG_INFO(memory);
 
diff --git a/sapi/phpdbg/phpdbg_io.c b/sapi/phpdbg/phpdbg_io.c
deleted file mode 100644
index a2a5c5969f..0000000000
--- a/sapi/phpdbg/phpdbg_io.c
+++ /dev/null
@@ -1,321 +0,0 @@
-/*
-   +----------------------------------------------------------------------+
-   | PHP Version 5                                                        |
-   +----------------------------------------------------------------------+
-   | Copyright (c) 1997-2014 The PHP Group                                |
-   +----------------------------------------------------------------------+
-   | This source file is subject to version 3.01 of the PHP license,      |
-   | that is bundled with this package in the file LICENSE, and is        |
-   | available through the world-wide-web at the following url:           |
-   | http://www.php.net/license/3_01.txt                                  |
-   | If you did not receive a copy of the PHP license and are unable to   |
-   | obtain it through the world-wide-web, please send a note to          |
-   | license@php.net so we can mail you a copy immediately.               |
-   +----------------------------------------------------------------------+
-   | Authors: Anatol Belski <ab@php.net>                                  |
-   +----------------------------------------------------------------------+
-*/
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#include "phpdbg_io.h"
-
-#ifdef PHP_WIN32
-#undef UNICODE
-#include "win32/inet.h"
-#include <winsock2.h>
-#include <windows.h>
-#include <Ws2tcpip.h>
-#include "win32/sockets.h"
-
-#else
-
-#if HAVE_SYS_TYPES_H
-#include <sys/types.h>
-#endif
-#include <sys/socket.h>
-#include <netinet/in.h>
-#if HAVE_ARPA_INET_H
-#include <arpa/inet.h>
-#endif
-#include <netdb.h>
-#include <fcntl.h>
-#include <poll.h>
-#endif
-
-ZEND_EXTERN_MODULE_GLOBALS(phpdbg);
-
-/* is easy to generalize ... but not needed for now */
-PHPDBG_API int phpdbg_consume_stdin_line(char *buf TSRMLS_DC) {
-	int bytes = PHPDBG_G(input_buflen), len = 0;
-
-	if (PHPDBG_G(input_buflen)) {
-		memcpy(buf, PHPDBG_G(input_buffer), bytes);
-	}
-
-	PHPDBG_G(last_was_newline) = 1;
-
-	do {
-		int i;
-		if (bytes <= 0) { 
-			continue;
-		}
-
-		for (i = len; i < len + bytes; i++) {
-			if (buf[i] == '\x03') {
-				if (i != len + bytes - 1) {
-					memmove(buf + i, buf + i + 1, len + bytes - i - 1);
-				}
-				len--;
-				i--;
-				continue;
-			}
-			if (buf[i] == '\n') {
-				PHPDBG_G(input_buflen) = len + bytes - 1 - i;
-				if (PHPDBG_G(input_buflen)) {
-					memcpy(PHPDBG_G(input_buffer), buf + i + 1, PHPDBG_G(input_buflen));
-				}
-				if (i != PHPDBG_MAX_CMD - 1) {
-					buf[i + 1] = 0;
-				}
-				return i;
-			}
-		}
-
-		len += bytes;
-	} while ((bytes = phpdbg_mixed_read(PHPDBG_G(io)[PHPDBG_STDIN].fd, buf + len, PHPDBG_MAX_CMD - len, -1 TSRMLS_CC)) > 0);
-
-	if (bytes <= 0) {
-		PHPDBG_G(flags) |= PHPDBG_IS_QUITTING | PHPDBG_IS_DISCONNECTED;
-		zend_bailout();
-		return 0;
-	}
-
-	return bytes;
-}
-
-PHPDBG_API int phpdbg_consume_bytes(int sock, char *ptr, int len, int tmo TSRMLS_DC) {
-	int got_now, i = len, j;
-	char *p = ptr;
-#ifndef PHP_WIN32
-	struct pollfd pfd;
-
-	if (tmo < 0) goto recv_once;
-	pfd.fd = sock;
-	pfd.events = POLLIN;
-
-	j = poll(&pfd, 1, tmo);
-
-	if (j == 0) {
-#else
-	struct fd_set readfds;
-	struct timeval ttmo;
-
-	if (tmo < 0) goto recv_once;
-	FD_ZERO(&readfds);
-	FD_SET(sock, &readfds);
-
-	ttmo.tv_sec = 0;
-	ttmo.tv_usec = tmo*1000;
-
-	j = select(0, &readfds, NULL, NULL, &ttmo);
-
-	if (j <= 0) {
-#endif
-		return -1;
-	}
-
-recv_once:
-	while(i > 0) {
-		if (tmo < 0) {
-			/* There's something to read. Read what's available and proceed
-			disregarding whether len could be exhausted or not.*/
-			int can_read = recv(sock, p, i, MSG_PEEK);
-#ifndef _WIN32
-			if (can_read == -1 && errno == EINTR) {
-				continue;
-			}
-#endif
-			i = can_read;
-		}
-
-#ifdef _WIN32
-		got_now = recv(sock, p, i, 0);
-#else
-		do {
-			got_now = recv(sock, p, i, 0);
-		} while (got_now == -1 && errno == EINTR);
-#endif
-
-		if (got_now == -1) {
-			write(PHPDBG_G(io)[PHPDBG_STDERR].fd, ZEND_STRL("Read operation timed out!\n"));
-			return -1;
-		}
-		i -= got_now;
-		p += got_now;
-	}
-
-	return p - ptr;
-}
-
-PHPDBG_API int phpdbg_send_bytes(int sock, const char *ptr, int len) {
-	int sent, i = len;
-	const char *p = ptr;
-/* XXX poll/select needed here? */
-	while(i > 0) {
-		sent = send(sock, p, i, 0);
-		if (sent == -1) {
-			return -1;
-		}
-		i -= sent;
-		p += sent;
-	}
-
-	return len;
-}
-
-
-PHPDBG_API int phpdbg_mixed_read(int sock, char *ptr, int len, int tmo TSRMLS_DC) {
-	if (PHPDBG_G(flags) & PHPDBG_IS_REMOTE) {
-		return phpdbg_consume_bytes(sock, ptr, len, tmo TSRMLS_CC);
-	}
-
-	return read(sock, ptr, len);
-}
-
-
-PHPDBG_API int phpdbg_mixed_write(int sock, const char *ptr, int len TSRMLS_DC) {
-	if (PHPDBG_G(flags) & PHPDBG_IS_REMOTE) {
-		return phpdbg_send_bytes(sock, ptr, len);
-	}
-
-	return write(sock, ptr, len);
-}
-
-
-PHPDBG_API int phpdbg_open_socket(const char *interface, unsigned short port TSRMLS_DC) {
-	struct addrinfo res;
-	int fd = phpdbg_create_listenable_socket(interface, port, &res TSRMLS_CC);
-
-	if (fd == -1) {
-		return -1;
-	}
-
-	if (bind(fd, res.ai_addr, res.ai_addrlen) == -1) {
-		phpdbg_close_socket(fd);
-		return -4;
-	}
-
-	listen(fd, 5);
-
-	return fd;
-}
-
-
-PHPDBG_API int phpdbg_create_listenable_socket(const char *addr, unsigned short port, struct addrinfo *addr_res TSRMLS_DC) {
-	int sock = -1, rc;
-	int reuse = 1;
-	struct in6_addr serveraddr;
-	struct addrinfo hints, *res = NULL;
-	char port_buf[8];
-	int8_t any_addr = *addr == '*';
-
-	do {
-		memset(&hints, 0, sizeof hints);
-		if (any_addr) {
-			hints.ai_flags = AI_PASSIVE;
-		} else {
-			hints.ai_flags = AI_NUMERICSERV;
-		}
-		hints.ai_family = AF_UNSPEC;
-		hints.ai_socktype = SOCK_STREAM;
-
-		rc = inet_pton(AF_INET, addr, &serveraddr);
-		if (1 == rc) {
-			hints.ai_family = AF_INET;
-			if (!any_addr) {
-				hints.ai_flags |= AI_NUMERICHOST;
-			}
-		} else {
-			rc = inet_pton(AF_INET6, addr, &serveraddr);
-			if (1 == rc) {
-				hints.ai_family = AF_INET6;
-				if (!any_addr) {
-					hints.ai_flags |= AI_NUMERICHOST;
-				}
-			} else {
-				/* XXX get host by name ??? */
-			}
-		}
-
-		snprintf(port_buf, 7, "%u", port);
-		if (!any_addr) {
-			rc = getaddrinfo(addr, port_buf, &hints, &res);
-		} else {
-			rc = getaddrinfo(NULL, port_buf, &hints, &res);
-		}
-
-		if (0 != rc) {
-#ifndef PHP_WIN32
-			if (rc == EAI_SYSTEM) {
-				char buf[128];
-				int wrote;
-
-				wrote = snprintf(buf, 128, "Could not translate address '%s'", addr);
-				buf[wrote] = '\0';
-				write(PHPDBG_G(io)[PHPDBG_STDERR].fd, buf, strlen(buf));
-
-				return sock;
-			} else {
-#endif
-				char buf[256];
-				int wrote;
-
-				wrote = snprintf(buf, 256, "Host '%s' not found. %s", addr, estrdup(gai_strerror(rc)));
-				buf[wrote] = '\0';
-				write(PHPDBG_G(io)[PHPDBG_STDERR].fd, buf, strlen(buf));
-
-				return sock;
-#ifndef PHP_WIN32
-			}
-#endif
-			return sock;
-		}
-
-		if((sock = socket(res->ai_family, res->ai_socktype, res->ai_protocol)) == -1) {
-			char buf[128];
-			int wrote;
-
-			wrote = sprintf(buf, "Unable to create socket");
-			buf[wrote] = '\0';
-			write(PHPDBG_G(io)[PHPDBG_STDERR].fd, buf, strlen(buf));
-
-			return sock;
-		} 
-
-		if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (char*) &reuse, sizeof(reuse)) == -1) {
-			phpdbg_close_socket(sock);
-			return sock;
-		}
-
-
-	} while (0);
-
-	*addr_res = *res;
-
-	return sock;
-}
-
-PHPDBG_API void phpdbg_close_socket(int sock) {
-	if (socket >= 0) {
-#ifdef _WIN32
-		closesocket(sock);
-#else
-		shutdown(sock, SHUT_RDWR);
-		close(sock);
-#endif
-	}
-}
-
diff --git a/sapi/phpdbg/phpdbg_io.h b/sapi/phpdbg/phpdbg_io.h
deleted file mode 100644
index a5659e88c6..0000000000
--- a/sapi/phpdbg/phpdbg_io.h
+++ /dev/null
@@ -1,36 +0,0 @@
-/*
-   +----------------------------------------------------------------------+
-   | PHP Version 5                                                        |
-   +----------------------------------------------------------------------+
-   | Copyright (c) 1997-2014 The PHP Group                                |
-   +----------------------------------------------------------------------+
-   | This source file is subject to version 3.01 of the PHP license,      |
-   | that is bundled with this package in the file LICENSE, and is        |
-   | available through the world-wide-web at the following url:           |
-   | http://www.php.net/license/3_01.txt                                  |
-   | If you did not receive a copy of the PHP license and are unable to   |
-   | obtain it through the world-wide-web, please send a note to          |
-   | license@php.net so we can mail you a copy immediately.               |
-   +----------------------------------------------------------------------+
-   | Authors: Anatol Belski <ab@php.net>                                  |
-   +----------------------------------------------------------------------+
-*/
-
-#ifndef PHPDBG_IO_H
-#define PHPDBG_IO_H
-
-#include "phpdbg.h"
-
-PHPDBG_API int phpdbg_consume_stdin_line(char *buf TSRMLS_DC);
-
-PHPDBG_API int phpdbg_consume_bytes(int sock, char *ptr, int len, int tmo TSRMLS_DC);
-PHPDBG_API int phpdbg_send_bytes(int sock, const char *ptr, int len);
-PHPDBG_API int phpdbg_mixed_read(int sock, char *ptr, int len, int tmo TSRMLS_DC);
-PHPDBG_API int phpdbg_mixed_write(int sock, const char *ptr, int len TSRMLS_DC);
-
-PHPDBG_API int phpdbg_create_listenable_socket(const char *addr, unsigned short port, struct addrinfo *res TSRMLS_DC);
-PHPDBG_API int phpdbg_open_socket(const char *interface, unsigned short port TSRMLS_DC);
-PHPDBG_API void phpdbg_close_socket(int sock);
-
-#endif /* PHPDBG_IO_H */
-
diff --git a/sapi/phpdbg/phpdbg_lexer.c b/sapi/phpdbg/phpdbg_lexer.c
index 90f3a449da..3092dc396d 100644
--- a/sapi/phpdbg/phpdbg_lexer.c
+++ b/sapi/phpdbg/phpdbg_lexer.c
@@ -1,5 +1,5 @@
 /* Generated by re2c 0.13.5 */
-#line 1 "/Users/Bob/php-src-5.6/sapi/phpdbg/phpdbg_lexer.l"
+#line 1 "/var/root/php-src/sapi/phpdbg/phpdbg_lexer.l"
 /*
  * phpdbg_lexer.l
  */
@@ -23,9 +23,8 @@
 #define YYFILL(n)
 
 #define NORMAL 0
-#define PRE_RAW 1
-#define RAW 2
-#define INITIAL 3
+#define RAW 1
+#define INITIAL 2
 
 ZEND_EXTERN_MODULE_GLOBALS(phpdbg);
 
@@ -45,18 +44,14 @@ restart:
 	LEX(text) = YYCURSOR;
 
 
-#line 49 "/Users/Bob/php-src-5.6/sapi/phpdbg/phpdbg_lexer.c"
+#line 48 "/var/root/php-src/sapi/phpdbg/phpdbg_lexer.c"
 {
 	YYCTYPE yych;
 	unsigned int yyaccept = 0;
-	if (YYGETCONDITION() < 2) {
-		if (YYGETCONDITION() < 1) {
-			goto yyc_NORMAL;
-		} else {
-			goto yyc_PRE_RAW;
-		}
+	if (YYGETCONDITION() < 1) {
+		goto yyc_NORMAL;
 	} else {
-		if (YYGETCONDITION() < 3) {
+		if (YYGETCONDITION() < 2) {
 			goto yyc_RAW;
 		} else {
 			goto yyc_INITIAL;
@@ -67,10 +62,10 @@ yyc_INITIAL:
 	{
 		static const unsigned char yybm[] = {
 			  0,   0,   0,   0,   0,   0,   0,   0, 
-			  0, 192,  96,   0,   0, 192,   0,   0, 
+			  0, 128, 128,   0,   0, 128,   0,   0, 
 			  0,   0,   0,   0,   0,   0,   0,   0, 
 			  0,   0,   0,   0,   0,   0,   0,   0, 
-			192,   0,   0,   0,   0,   0,   0,   0, 
+			128,   0,   0,   0,   0,   0,   0,   0, 
 			  0,   0,   0,   0,   0,   0,   0,   0, 
 			  0,   0,   0,   0,   0,   0,   0,   0, 
 			  0,   0,   0,   0,   0,   0,   0,   0, 
@@ -103,1417 +98,1046 @@ yyc_INITIAL:
 		YYDEBUG(0, *YYCURSOR);
 		YYFILL(4);
 		yych = *YYCURSOR;
-		if (yybm[0+yych] & 32) {
-			goto yy4;
-		}
-		if (yych <= 'E') {
-			if (yych <= '\f') {
-				if (yych <= 0x00) goto yy7;
-				if (yych != '\t') goto yy12;
+		if (yych <= 'D') {
+			if (yych <= '\n') {
+				if (yych <= 0x00) goto yy6;
+				if (yych <= 0x08) goto yy11;
+				if (yych >= '\n') goto yy4;
 			} else {
-				if (yych <= 0x1F) {
-					if (yych >= 0x0E) goto yy12;
+				if (yych <= '\r') {
+					if (yych <= '\f') goto yy11;
 				} else {
-					if (yych <= ' ') goto yy2;
-					if (yych <= 'D') goto yy12;
-					goto yy8;
+					if (yych != ' ') goto yy11;
 				}
 			}
 		} else {
 			if (yych <= 'd') {
-				if (yych <= 'Q') goto yy12;
-				if (yych <= 'R') goto yy11;
-				if (yych <= 'S') goto yy9;
-				goto yy12;
+				if (yych <= 'Q') {
+					if (yych <= 'E') goto yy7;
+					goto yy11;
+				} else {
+					if (yych <= 'R') goto yy10;
+					if (yych <= 'S') goto yy8;
+					goto yy11;
+				}
 			} else {
 				if (yych <= 'q') {
-					if (yych <= 'e') goto yy8;
-					goto yy12;
+					if (yych <= 'e') goto yy7;
+					goto yy11;
 				} else {
-					if (yych <= 'r') goto yy10;
-					if (yych <= 's') goto yy9;
-					goto yy12;
+					if (yych <= 'r') goto yy9;
+					if (yych <= 's') goto yy8;
+					goto yy11;
 				}
 			}
 		}
-yy2:
 		YYDEBUG(2, *YYCURSOR);
 		++YYCURSOR;
 		if ((yych = *YYCURSOR) <= '\f') {
-			if (yych <= 0x00) goto yy29;
 			if (yych <= 0x08) goto yy3;
-			if (yych <= '\n') goto yy29;
+			if (yych <= '\n') goto yy26;
 		} else {
-			if (yych <= '\r') goto yy29;
-			if (yych == ' ') goto yy29;
+			if (yych <= '\r') goto yy26;
+			if (yych == ' ') goto yy26;
 		}
 yy3:
 		YYDEBUG(3, *YYCURSOR);
 		yyleng = (size_t) YYCURSOR - (size_t) yytext;
-#line 176 "/Users/Bob/php-src-5.6/sapi/phpdbg/phpdbg_lexer.l"
+#line 161 "/var/root/php-src/sapi/phpdbg/phpdbg_lexer.l"
 		{
 	YYSETCONDITION(NORMAL);
 
 	YYCURSOR = LEX(text);
 	goto restart;
 }
-#line 161 "/Users/Bob/php-src-5.6/sapi/phpdbg/phpdbg_lexer.c"
+#line 154 "/var/root/php-src/sapi/phpdbg/phpdbg_lexer.c"
 yy4:
 		YYDEBUG(4, *YYCURSOR);
 		++YYCURSOR;
-		YYFILL(1);
-		yych = *YYCURSOR;
-		YYDEBUG(5, *YYCURSOR);
-		if (yybm[0+yych] & 128) {
-			goto yy28;
+		if ((yych = *YYCURSOR) <= '\f') {
+			if (yych <= 0x08) goto yy5;
+			if (yych <= '\n') goto yy26;
+		} else {
+			if (yych <= '\r') goto yy26;
+			if (yych == ' ') goto yy26;
 		}
-		if (yych <= 0x00) goto yy27;
-		if (yych == '\n') goto yy4;
-yy6:
-		YYDEBUG(6, *YYCURSOR);
+yy5:
+		YYDEBUG(5, *YYCURSOR);
 		yyleng = (size_t) YYCURSOR - (size_t) yytext;
-#line 69 "/Users/Bob/php-src-5.6/sapi/phpdbg/phpdbg_lexer.l"
+#line 68 "/var/root/php-src/sapi/phpdbg/phpdbg_lexer.l"
 		{
 	return 0;
 }
-#line 180 "/Users/Bob/php-src-5.6/sapi/phpdbg/phpdbg_lexer.c"
+#line 172 "/var/root/php-src/sapi/phpdbg/phpdbg_lexer.c"
+yy6:
+		YYDEBUG(6, *YYCURSOR);
+		yych = *++YYCURSOR;
+		goto yy3;
 yy7:
 		YYDEBUG(7, *YYCURSOR);
-		yych = *++YYCURSOR;
+		yyaccept = 0;
+		yych = *(YYMARKER = ++YYCURSOR);
+		if (yych == 'V') goto yy22;
+		if (yych == 'v') goto yy22;
 		goto yy3;
 yy8:
 		YYDEBUG(8, *YYCURSOR);
 		yyaccept = 0;
 		yych = *(YYMARKER = ++YYCURSOR);
-		if (yych == 'V') goto yy23;
-		if (yych == 'v') goto yy23;
+		if (yych == 'H') goto yy18;
+		if (yych == 'h') goto yy18;
 		goto yy3;
 yy9:
 		YYDEBUG(9, *YYCURSOR);
 		yyaccept = 0;
 		yych = *(YYMARKER = ++YYCURSOR);
-		if (yych == 'H') goto yy19;
-		if (yych == 'h') goto yy19;
+		if (yybm[0+yych] & 128) {
+			goto yy15;
+		}
+		if (yych == 'U') goto yy12;
+		if (yych == 'u') goto yy12;
 		goto yy3;
 yy10:
 		YYDEBUG(10, *YYCURSOR);
 		yyaccept = 0;
 		yych = *(YYMARKER = ++YYCURSOR);
-		if (yybm[0+yych] & 64) {
-			goto yy16;
-		}
-		if (yych == 'U') goto yy13;
-		if (yych == 'u') goto yy13;
+		if (yych == 'U') goto yy12;
+		if (yych == 'u') goto yy12;
 		goto yy3;
 yy11:
 		YYDEBUG(11, *YYCURSOR);
-		yyaccept = 0;
-		yych = *(YYMARKER = ++YYCURSOR);
-		if (yych == 'U') goto yy13;
-		if (yych == 'u') goto yy13;
+		yych = *++YYCURSOR;
 		goto yy3;
 yy12:
 		YYDEBUG(12, *YYCURSOR);
 		yych = *++YYCURSOR;
-		goto yy3;
+		if (yych == 'N') goto yy14;
+		if (yych == 'n') goto yy14;
 yy13:
 		YYDEBUG(13, *YYCURSOR);
-		yych = *++YYCURSOR;
-		if (yych == 'N') goto yy15;
-		if (yych == 'n') goto yy15;
-yy14:
-		YYDEBUG(14, *YYCURSOR);
 		YYCURSOR = YYMARKER;
 		goto yy3;
-yy15:
-		YYDEBUG(15, *YYCURSOR);
+yy14:
+		YYDEBUG(14, *YYCURSOR);
 		yych = *++YYCURSOR;
-		if (yybm[0+yych] & 64) {
-			goto yy16;
+		if (yybm[0+yych] & 128) {
+			goto yy15;
 		}
-		goto yy14;
-yy16:
-		YYDEBUG(16, *YYCURSOR);
+		goto yy13;
+yy15:
+		YYDEBUG(15, *YYCURSOR);
 		++YYCURSOR;
 		YYFILL(1);
 		yych = *YYCURSOR;
-		YYDEBUG(17, *YYCURSOR);
-		if (yybm[0+yych] & 64) {
-			goto yy16;
+		YYDEBUG(16, *YYCURSOR);
+		if (yybm[0+yych] & 128) {
+			goto yy15;
 		}
-		YYDEBUG(18, *YYCURSOR);
+		YYDEBUG(17, *YYCURSOR);
 		yyleng = (size_t) YYCURSOR - (size_t) yytext;
-#line 163 "/Users/Bob/php-src-5.6/sapi/phpdbg/phpdbg_lexer.l"
+#line 155 "/var/root/php-src/sapi/phpdbg/phpdbg_lexer.l"
 		{
-	YYSETCONDITION(PRE_RAW);
+	YYSETCONDITION(RAW);
 	phpdbg_init_param(yylval, EMPTY_PARAM);
 	return T_RUN;
 }
-#line 253 "/Users/Bob/php-src-5.6/sapi/phpdbg/phpdbg_lexer.c"
-yy19:
-		YYDEBUG(19, *YYCURSOR);
+#line 245 "/var/root/php-src/sapi/phpdbg/phpdbg_lexer.c"
+yy18:
+		YYDEBUG(18, *YYCURSOR);
 		yych = *++YYCURSOR;
 		if (yych <= '\f') {
-			if (yych <= 0x08) goto yy14;
-			if (yych >= '\v') goto yy14;
+			if (yych <= 0x08) goto yy13;
+			if (yych >= '\v') goto yy13;
 		} else {
-			if (yych <= '\r') goto yy20;
-			if (yych != ' ') goto yy14;
+			if (yych <= '\r') goto yy19;
+			if (yych != ' ') goto yy13;
 		}
-yy20:
-		YYDEBUG(20, *YYCURSOR);
+yy19:
+		YYDEBUG(19, *YYCURSOR);
 		++YYCURSOR;
 		YYFILL(1);
 		yych = *YYCURSOR;
-		YYDEBUG(21, *YYCURSOR);
+		YYDEBUG(20, *YYCURSOR);
 		if (yych <= '\f') {
-			if (yych <= 0x08) goto yy22;
-			if (yych <= '\n') goto yy20;
+			if (yych <= 0x08) goto yy21;
+			if (yych <= '\n') goto yy19;
 		} else {
-			if (yych <= '\r') goto yy20;
-			if (yych == ' ') goto yy20;
+			if (yych <= '\r') goto yy19;
+			if (yych == ' ') goto yy19;
 		}
-yy22:
-		YYDEBUG(22, *YYCURSOR);
+yy21:
+		YYDEBUG(21, *YYCURSOR);
 		yyleng = (size_t) YYCURSOR - (size_t) yytext;
-#line 158 "/Users/Bob/php-src-5.6/sapi/phpdbg/phpdbg_lexer.l"
+#line 150 "/var/root/php-src/sapi/phpdbg/phpdbg_lexer.l"
 		{
-	YYSETCONDITION(PRE_RAW);
+	YYSETCONDITION(RAW);
 	phpdbg_init_param(yylval, EMPTY_PARAM);
 	return T_SHELL;
 }
-#line 286 "/Users/Bob/php-src-5.6/sapi/phpdbg/phpdbg_lexer.c"
-yy23:
-		YYDEBUG(23, *YYCURSOR);
+#line 278 "/var/root/php-src/sapi/phpdbg/phpdbg_lexer.c"
+yy22:
+		YYDEBUG(22, *YYCURSOR);
 		yych = *++YYCURSOR;
 		if (yych <= '\f') {
-			if (yych <= 0x08) goto yy14;
-			if (yych >= '\v') goto yy14;
+			if (yych <= 0x08) goto yy13;
+			if (yych >= '\v') goto yy13;
 		} else {
-			if (yych <= '\r') goto yy24;
-			if (yych != ' ') goto yy14;
+			if (yych <= '\r') goto yy23;
+			if (yych != ' ') goto yy13;
 		}
-yy24:
-		YYDEBUG(24, *YYCURSOR);
+yy23:
+		YYDEBUG(23, *YYCURSOR);
 		++YYCURSOR;
 		YYFILL(1);
 		yych = *YYCURSOR;
-		YYDEBUG(25, *YYCURSOR);
+		YYDEBUG(24, *YYCURSOR);
 		if (yych <= '\f') {
-			if (yych <= 0x08) goto yy26;
-			if (yych <= '\n') goto yy24;
+			if (yych <= 0x08) goto yy25;
+			if (yych <= '\n') goto yy23;
 		} else {
-			if (yych <= '\r') goto yy24;
-			if (yych == ' ') goto yy24;
+			if (yych <= '\r') goto yy23;
+			if (yych == ' ') goto yy23;
 		}
-yy26:
-		YYDEBUG(26, *YYCURSOR);
+yy25:
+		YYDEBUG(25, *YYCURSOR);
 		yyleng = (size_t) YYCURSOR - (size_t) yytext;
-#line 153 "/Users/Bob/php-src-5.6/sapi/phpdbg/phpdbg_lexer.l"
+#line 145 "/var/root/php-src/sapi/phpdbg/phpdbg_lexer.l"
 		{
-	YYSETCONDITION(PRE_RAW);
+	YYSETCONDITION(RAW);
 	phpdbg_init_param(yylval, EMPTY_PARAM);
 	return T_EVAL;
 }
-#line 319 "/Users/Bob/php-src-5.6/sapi/phpdbg/phpdbg_lexer.c"
-yy27:
-		YYDEBUG(27, *YYCURSOR);
-		yych = *++YYCURSOR;
-		goto yy6;
-yy28:
-		YYDEBUG(28, *YYCURSOR);
+#line 311 "/var/root/php-src/sapi/phpdbg/phpdbg_lexer.c"
+yy26:
+		YYDEBUG(26, *YYCURSOR);
 		++YYCURSOR;
 		YYFILL(1);
 		yych = *YYCURSOR;
-yy29:
-		YYDEBUG(29, *YYCURSOR);
-		if (yybm[0+yych] & 128) {
-			goto yy28;
+		YYDEBUG(27, *YYCURSOR);
+		if (yych <= '\f') {
+			if (yych <= 0x08) goto yy28;
+			if (yych <= '\n') goto yy26;
+		} else {
+			if (yych <= '\r') goto yy26;
+			if (yych == ' ') goto yy26;
 		}
-		if (yych <= 0x00) goto yy27;
-		if (yych == '\n') goto yy4;
-		YYDEBUG(30, *YYCURSOR);
+yy28:
+		YYDEBUG(28, *YYCURSOR);
 		yyleng = (size_t) YYCURSOR - (size_t) yytext;
-#line 147 "/Users/Bob/php-src-5.6/sapi/phpdbg/phpdbg_lexer.l"
+#line 139 "/var/root/php-src/sapi/phpdbg/phpdbg_lexer.l"
 		{
 	/* ignore whitespace */
 
 	goto restart;
 }
-#line 344 "/Users/Bob/php-src-5.6/sapi/phpdbg/phpdbg_lexer.c"
+#line 334 "/var/root/php-src/sapi/phpdbg/phpdbg_lexer.c"
 	}
 /* *********************************** */
 yyc_NORMAL:
 	{
 		static const unsigned char yybm[] = {
-			  0,   8,   8,   8,   8,   8,   8,   8, 
-			  8,  66,  68,   8,   8,  66,   8,   8, 
-			  8,   8,   8,   8,   8,   8,   8,   8, 
-			  8,   8,   8,   8,   8,   8,   8,   8, 
-			 66,   8,   8,   0,   8,   8,   8,   8, 
-			  8,   8,   8,   8,   8,   8,  24,   8, 
-			152, 152, 152, 152, 152, 152, 152, 152, 
-			152, 152,   0,   8,   8,   8,   8,   8, 
-			  8, 168, 168, 168, 168, 168, 168,  40, 
-			 40,  40,  40,  40,  40,  40,  40,  40, 
-			 40,  40,  40,  40,  40,  40,  40,  40, 
-			 40,  40,  40,   8,   8,   8,   8,   8, 
-			  8, 168, 168, 168, 168, 168, 168,  40, 
-			 40,  40,  40,  40,  40,  40,  40,  40, 
-			 40,  40,  40,  40,  40,  40,  40,  40, 
-			 40,  40,  40,   8,   8,   8,   8,   8, 
-			  8,   8,   8,   8,   8,   8,   8,   8, 
-			  8,   8,   8,   8,   8,   8,   8,   8, 
-			  8,   8,   8,   8,   8,   8,   8,   8, 
-			  8,   8,   8,   8,   8,   8,   8,   8, 
-			  8,   8,   8,   8,   8,   8,   8,   8, 
-			  8,   8,   8,   8,   8,   8,   8,   8, 
-			  8,   8,   8,   8,   8,   8,   8,   8, 
-			  8,   8,   8,   8,   8,   8,   8,   8, 
-			  8,   8,   8,   8,   8,   8,   8,   8, 
-			  8,   8,   8,   8,   8,   8,   8,   8, 
-			  8,   8,   8,   8,   8,   8,   8,   8, 
-			  8,   8,   8,   8,   8,   8,   8,   8, 
-			  8,   8,   8,   8,   8,   8,   8,   8, 
-			  8,   8,   8,   8,   8,   8,   8,   8, 
-			  8,   8,   8,   8,   8,   8,   8,   8, 
-			  8,   8,   8,   8,   8,   8,   8,   8, 
+			  0,  16,  16,  16,  16,  16,  16,  16, 
+			 16,   8,   8,  16,  16,   8,  16,  16, 
+			 16,  16,  16,  16,  16,  16,  16,  16, 
+			 16,  16,  16,  16,  16,  16,  16,  16, 
+			  8,  16,  16,   0,  16,  16,  16,  16, 
+			 16,  16,  16,  16,  16,  16,  48,  16, 
+			176, 176, 176, 176, 176, 176, 176, 176, 
+			176, 176,   0,  16,  16,  16,  16,  16, 
+			 16, 208, 208, 208, 208, 208, 208,  80, 
+			 80,  80,  80,  80,  80,  80,  80,  80, 
+			 80,  80,  80,  80,  80,  80,  80,  80, 
+			 80,  80,  80,  16,  16,  16,  16,  16, 
+			 16, 208, 208, 208, 208, 208, 208,  80, 
+			 80,  80,  80,  80,  80,  80,  80,  80, 
+			 80,  80,  80,  80,  80,  80,  80,  80, 
+			 80,  80,  80,  16,  16,  16,  16,  16, 
+			 16,  16,  16,  16,  16,  16,  16,  16, 
+			 16,  16,  16,  16,  16,  16,  16,  16, 
+			 16,  16,  16,  16,  16,  16,  16,  16, 
+			 16,  16,  16,  16,  16,  16,  16,  16, 
+			 16,  16,  16,  16,  16,  16,  16,  16, 
+			 16,  16,  16,  16,  16,  16,  16,  16, 
+			 16,  16,  16,  16,  16,  16,  16,  16, 
+			 16,  16,  16,  16,  16,  16,  16,  16, 
+			 16,  16,  16,  16,  16,  16,  16,  16, 
+			 16,  16,  16,  16,  16,  16,  16,  16, 
+			 16,  16,  16,  16,  16,  16,  16,  16, 
+			 16,  16,  16,  16,  16,  16,  16,  16, 
+			 16,  16,  16,  16,  16,  16,  16,  16, 
+			 16,  16,  16,  16,  16,  16,  16,  16, 
+			 16,  16,  16,  16,  16,  16,  16,  16, 
+			 16,  16,  16,  16,  16,  16,  16,  16, 
 		};
-		YYDEBUG(31, *YYCURSOR);
+		YYDEBUG(29, *YYCURSOR);
 		YYFILL(11);
 		yych = *YYCURSOR;
-		if (yybm[0+yych] & 2) {
-			goto yy33;
-		}
-		if (yych <= 'N') {
-			if (yych <= '0') {
-				if (yych <= '#') {
-					if (yych <= '\t') {
-						if (yych <= 0x00) goto yy39;
-						goto yy43;
-					} else {
-						if (yych <= '\n') goto yy36;
-						if (yych <= '"') goto yy43;
-						goto yy58;
-					}
-				} else {
-					if (yych <= '-') {
-						if (yych <= ',') goto yy43;
-						goto yy40;
-					} else {
-						if (yych <= '.') goto yy45;
-						if (yych <= '/') goto yy43;
-						goto yy48;
-					}
-				}
-			} else {
-				if (yych <= 'E') {
-					if (yych <= ':') {
-						if (yych <= '9') goto yy45;
-						goto yy60;
-					} else {
-						if (yych <= 'C') goto yy43;
-						if (yych <= 'D') goto yy49;
-						goto yy50;
-					}
-				} else {
-					if (yych <= 'H') {
-						if (yych <= 'F') goto yy51;
-						goto yy43;
-					} else {
-						if (yych <= 'I') goto yy42;
-						if (yych <= 'M') goto yy43;
-						goto yy52;
-					}
-				}
-			}
-		} else {
-			if (yych <= 'f') {
-				if (yych <= 'Y') {
-					if (yych <= 'S') {
-						if (yych <= 'O') goto yy53;
-						goto yy43;
-					} else {
-						if (yych <= 'T') goto yy54;
-						if (yych <= 'X') goto yy43;
-						goto yy55;
-					}
-				} else {
-					if (yych <= 'c') {
-						if (yych <= 'Z') goto yy56;
-						goto yy43;
-					} else {
-						if (yych <= 'd') goto yy49;
-						if (yych <= 'e') goto yy50;
-						goto yy51;
-					}
-				}
-			} else {
-				if (yych <= 'o') {
-					if (yych <= 'i') {
-						if (yych <= 'h') goto yy43;
-						goto yy42;
-					} else {
-						if (yych <= 'm') goto yy43;
-						if (yych <= 'n') goto yy52;
-						goto yy53;
-					}
-				} else {
-					if (yych <= 'x') {
-						if (yych == 't') goto yy54;
-						goto yy43;
-					} else {
-						if (yych <= 'y') goto yy55;
-						if (yych <= 'z') goto yy57;
-						goto yy43;
-					}
-				}
-			}
+		YYDEBUG(-1, yych);
+		switch (yych) {
+		case 0x00:	goto yy36;
+		case '\t':
+		case '\r':
+		case ' ':	goto yy31;
+		case '\n':	goto yy34;
+		case '#':	goto yy55;
+		case '-':	goto yy41;
+		case '.':
+		case '1':
+		case '2':
+		case '3':
+		case '4':
+		case '5':
+		case '6':
+		case '7':
+		case '8':
+		case '9':	goto yy42;
+		case '0':	goto yy45;
+		case ':':	goto yy57;
+		case 'D':
+		case 'd':	goto yy46;
+		case 'E':
+		case 'e':	goto yy47;
+		case 'F':
+		case 'f':	goto yy48;
+		case 'I':
+		case 'i':	goto yy37;
+		case 'N':
+		case 'n':	goto yy49;
+		case 'O':
+		case 'o':	goto yy50;
+		case 'T':
+		case 't':	goto yy51;
+		case 'Y':
+		case 'y':	goto yy52;
+		case 'Z':	goto yy53;
+		case 'z':	goto yy54;
+		default:	goto yy39;
 		}
-yy33:
-		YYDEBUG(33, *YYCURSOR);
+yy31:
+		YYDEBUG(31, *YYCURSOR);
 		++YYCURSOR;
 		YYFILL(1);
 		yych = *YYCURSOR;
-		YYDEBUG(34, *YYCURSOR);
-		if (yybm[0+yych] & 2) {
-			goto yy33;
+		YYDEBUG(32, *YYCURSOR);
+		if (yybm[0+yych] & 8) {
+			goto yy31;
 		}
-		if (yych <= 0x00) goto yy39;
-		if (yych == '\n') goto yy36;
-		YYDEBUG(35, *YYCURSOR);
+		YYDEBUG(33, *YYCURSOR);
 		yyleng = (size_t) YYCURSOR - (size_t) yytext;
-#line 147 "/Users/Bob/php-src-5.6/sapi/phpdbg/phpdbg_lexer.l"
+#line 139 "/var/root/php-src/sapi/phpdbg/phpdbg_lexer.l"
 		{
 	/* ignore whitespace */
 
 	goto restart;
 }
-#line 493 "/Users/Bob/php-src-5.6/sapi/phpdbg/phpdbg_lexer.c"
-yy36:
-		YYDEBUG(36, *YYCURSOR);
+#line 434 "/var/root/php-src/sapi/phpdbg/phpdbg_lexer.c"
+yy34:
+		YYDEBUG(34, *YYCURSOR);
 		++YYCURSOR;
-		YYFILL(1);
-		yych = *YYCURSOR;
-		YYDEBUG(37, *YYCURSOR);
-		if (yybm[0+yych] & 2) {
-			goto yy33;
+		if (yybm[0+(yych = *YYCURSOR)] & 8) {
+			goto yy31;
 		}
-		if (yych <= 0x00) goto yy39;
-		if (yych == '\n') goto yy36;
-yy38:
-		YYDEBUG(38, *YYCURSOR);
+yy35:
+		YYDEBUG(35, *YYCURSOR);
 		yyleng = (size_t) YYCURSOR - (size_t) yytext;
-#line 69 "/Users/Bob/php-src-5.6/sapi/phpdbg/phpdbg_lexer.l"
+#line 68 "/var/root/php-src/sapi/phpdbg/phpdbg_lexer.l"
 		{
 	return 0;
 }
-#line 512 "/Users/Bob/php-src-5.6/sapi/phpdbg/phpdbg_lexer.c"
-yy39:
-		YYDEBUG(39, *YYCURSOR);
+#line 448 "/var/root/php-src/sapi/phpdbg/phpdbg_lexer.c"
+yy36:
+		YYDEBUG(36, *YYCURSOR);
 		yych = *++YYCURSOR;
-		goto yy38;
-yy40:
-		YYDEBUG(40, *YYCURSOR);
+		goto yy35;
+yy37:
+		YYDEBUG(37, *YYCURSOR);
 		yyaccept = 0;
 		yych = *(YYMARKER = ++YYCURSOR);
-		if (yybm[0+yych] & 16) {
-			goto yy45;
-		}
-		if (yych == 'r') goto yy113;
-		goto yy44;
-yy41:
-		YYDEBUG(41, *YYCURSOR);
+		if (yych == 'F') goto yy106;
+		if (yych == 'f') goto yy106;
+		goto yy40;
+yy38:
+		YYDEBUG(38, *YYCURSOR);
 		yyleng = (size_t) YYCURSOR - (size_t) yytext;
-#line 133 "/Users/Bob/php-src-5.6/sapi/phpdbg/phpdbg_lexer.l"
+#line 125 "/var/root/php-src/sapi/phpdbg/phpdbg_lexer.l"
 		{
 	phpdbg_init_param(yylval, STR_PARAM);
 	yylval->str = zend_strndup(yytext, yyleng);
 	yylval->len = yyleng;
 	return T_ID; 
 }
-#line 536 "/Users/Bob/php-src-5.6/sapi/phpdbg/phpdbg_lexer.c"
-yy42:
-		YYDEBUG(42, *YYCURSOR);
-		yyaccept = 0;
-		yych = *(YYMARKER = ++YYCURSOR);
-		if (yych == 'F') goto yy109;
-		if (yych == 'f') goto yy109;
-		goto yy44;
-yy43:
-		YYDEBUG(43, *YYCURSOR);
+#line 470 "/var/root/php-src/sapi/phpdbg/phpdbg_lexer.c"
+yy39:
+		YYDEBUG(39, *YYCURSOR);
 		yyaccept = 0;
 		YYMARKER = ++YYCURSOR;
 		YYFILL(3);
 		yych = *YYCURSOR;
-yy44:
-		YYDEBUG(44, *YYCURSOR);
-		if (yybm[0+yych] & 8) {
-			goto yy43;
+yy40:
+		YYDEBUG(40, *YYCURSOR);
+		if (yybm[0+yych] & 16) {
+			goto yy39;
 		}
-		if (yych <= '9') goto yy41;
-		goto yy65;
-yy45:
-		YYDEBUG(45, *YYCURSOR);
+		if (yych <= '9') goto yy38;
+		goto yy62;
+yy41:
+		YYDEBUG(41, *YYCURSOR);
+		yyaccept = 0;
+		yych = *(YYMARKER = ++YYCURSOR);
+		if (yybm[0+yych] & 32) {
+			goto yy42;
+		}
+		goto yy40;
+yy42:
+		YYDEBUG(42, *YYCURSOR);
 		yyaccept = 1;
 		YYMARKER = ++YYCURSOR;
 		YYFILL(3);
 		yych = *YYCURSOR;
-		YYDEBUG(46, *YYCURSOR);
-		if (yybm[0+yych] & 16) {
-			goto yy45;
+		YYDEBUG(43, *YYCURSOR);
+		if (yybm[0+yych] & 32) {
+			goto yy42;
 		}
 		if (yych <= 0x1F) {
 			if (yych <= '\n') {
-				if (yych <= 0x00) goto yy47;
-				if (yych <= 0x08) goto yy43;
+				if (yych <= 0x00) goto yy44;
+				if (yych <= 0x08) goto yy39;
 			} else {
-				if (yych != '\r') goto yy43;
+				if (yych != '\r') goto yy39;
 			}
 		} else {
 			if (yych <= '#') {
-				if (yych <= ' ') goto yy47;
-				if (yych <= '"') goto yy43;
+				if (yych <= ' ') goto yy44;
+				if (yych <= '"') goto yy39;
 			} else {
-				if (yych == ':') goto yy65;
-				goto yy43;
+				if (yych == ':') goto yy62;
+				goto yy39;
 			}
 		}
-yy47:
-		YYDEBUG(47, *YYCURSOR);
+yy44:
+		YYDEBUG(44, *YYCURSOR);
 		yyleng = (size_t) YYCURSOR - (size_t) yytext;
-#line 114 "/Users/Bob/php-src-5.6/sapi/phpdbg/phpdbg_lexer.l"
+#line 106 "/var/root/php-src/sapi/phpdbg/phpdbg_lexer.l"
 		{
 	phpdbg_init_param(yylval, NUMERIC_PARAM);
 	yylval->num = atoi(yytext);
 	return T_DIGITS;
 }
-#line 592 "/Users/Bob/php-src-5.6/sapi/phpdbg/phpdbg_lexer.c"
-yy48:
-		YYDEBUG(48, *YYCURSOR);
+#line 527 "/var/root/php-src/sapi/phpdbg/phpdbg_lexer.c"
+yy45:
+		YYDEBUG(45, *YYCURSOR);
 		yyaccept = 1;
 		yych = *(YYMARKER = ++YYCURSOR);
-		if (yybm[0+yych] & 16) {
-			goto yy45;
+		if (yybm[0+yych] & 32) {
+			goto yy42;
 		}
 		if (yych <= 0x1F) {
 			if (yych <= '\n') {
-				if (yych <= 0x00) goto yy47;
-				if (yych <= 0x08) goto yy44;
-				goto yy47;
-			} else {
-				if (yych == '\r') goto yy47;
+				if (yych <= 0x00) goto yy44;
+				if (yych <= 0x08) goto yy40;
 				goto yy44;
+			} else {
+				if (yych == '\r') goto yy44;
+				goto yy40;
 			}
 		} else {
 			if (yych <= '#') {
-				if (yych <= ' ') goto yy47;
-				if (yych <= '"') goto yy44;
-				goto yy47;
-			} else {
-				if (yych == 'x') goto yy105;
+				if (yych <= ' ') goto yy44;
+				if (yych <= '"') goto yy40;
 				goto yy44;
+			} else {
+				if (yych == 'x') goto yy102;
+				goto yy40;
 			}
 		}
+yy46:
+		YYDEBUG(46, *YYCURSOR);
+		yyaccept = 0;
+		yych = *(YYMARKER = ++YYCURSOR);
+		if (yych == 'I') goto yy96;
+		if (yych == 'i') goto yy96;
+		goto yy40;
+yy47:
+		YYDEBUG(47, *YYCURSOR);
+		yyaccept = 0;
+		yych = *(YYMARKER = ++YYCURSOR);
+		if (yych == 'N') goto yy91;
+		if (yych == 'n') goto yy91;
+		goto yy40;
+yy48:
+		YYDEBUG(48, *YYCURSOR);
+		yyaccept = 0;
+		yych = *(YYMARKER = ++YYCURSOR);
+		if (yych == 'A') goto yy88;
+		if (yych == 'a') goto yy88;
+		goto yy40;
 yy49:
 		YYDEBUG(49, *YYCURSOR);
 		yyaccept = 0;
 		yych = *(YYMARKER = ++YYCURSOR);
-		if (yych == 'I') goto yy99;
-		if (yych == 'i') goto yy99;
-		goto yy44;
+		if (yych == 'O') goto yy84;
+		if (yych == 'o') goto yy84;
+		goto yy40;
 yy50:
 		YYDEBUG(50, *YYCURSOR);
 		yyaccept = 0;
 		yych = *(YYMARKER = ++YYCURSOR);
-		if (yych == 'N') goto yy94;
-		if (yych == 'n') goto yy94;
-		goto yy44;
+		if (yych <= 'N') {
+			if (yych == 'F') goto yy83;
+			if (yych <= 'M') goto yy40;
+			goto yy77;
+		} else {
+			if (yych <= 'f') {
+				if (yych <= 'e') goto yy40;
+				goto yy83;
+			} else {
+				if (yych == 'n') goto yy77;
+				goto yy40;
+			}
+		}
 yy51:
 		YYDEBUG(51, *YYCURSOR);
 		yyaccept = 0;
 		yych = *(YYMARKER = ++YYCURSOR);
-		if (yych == 'A') goto yy91;
-		if (yych == 'a') goto yy91;
-		goto yy44;
+		if (yych == 'R') goto yy81;
+		if (yych == 'r') goto yy81;
+		goto yy40;
 yy52:
 		YYDEBUG(52, *YYCURSOR);
 		yyaccept = 0;
 		yych = *(YYMARKER = ++YYCURSOR);
-		if (yych == 'O') goto yy87;
-		if (yych == 'o') goto yy87;
-		goto yy44;
+		if (yych == 'E') goto yy76;
+		if (yych == 'e') goto yy76;
+		goto yy40;
 yy53:
 		YYDEBUG(53, *YYCURSOR);
 		yyaccept = 0;
 		yych = *(YYMARKER = ++YYCURSOR);
-		if (yych <= 'N') {
-			if (yych == 'F') goto yy86;
-			if (yych <= 'M') goto yy44;
-			goto yy80;
-		} else {
-			if (yych <= 'f') {
-				if (yych <= 'e') goto yy44;
-				goto yy86;
-			} else {
-				if (yych == 'n') goto yy80;
-				goto yy44;
-			}
-		}
+		if (yych == 'E') goto yy73;
+		goto yy40;
 yy54:
 		YYDEBUG(54, *YYCURSOR);
 		yyaccept = 0;
 		yych = *(YYMARKER = ++YYCURSOR);
-		if (yych == 'R') goto yy84;
-		if (yych == 'r') goto yy84;
-		goto yy44;
+		if (yych == 'e') goto yy61;
+		goto yy40;
 yy55:
 		YYDEBUG(55, *YYCURSOR);
-		yyaccept = 0;
-		yych = *(YYMARKER = ++YYCURSOR);
-		if (yych == 'E') goto yy79;
-		if (yych == 'e') goto yy79;
-		goto yy44;
-yy56:
-		YYDEBUG(56, *YYCURSOR);
-		yyaccept = 0;
-		yych = *(YYMARKER = ++YYCURSOR);
-		if (yych == 'E') goto yy76;
-		goto yy44;
-yy57:
-		YYDEBUG(57, *YYCURSOR);
-		yyaccept = 0;
-		yych = *(YYMARKER = ++YYCURSOR);
-		if (yych == 'e') goto yy64;
-		goto yy44;
-yy58:
-		YYDEBUG(58, *YYCURSOR);
 		++YYCURSOR;
-		YYDEBUG(59, *YYCURSOR);
+		YYDEBUG(56, *YYCURSOR);
 		yyleng = (size_t) YYCURSOR - (size_t) yytext;
-#line 92 "/Users/Bob/php-src-5.6/sapi/phpdbg/phpdbg_lexer.l"
+#line 84 "/var/root/php-src/sapi/phpdbg/phpdbg_lexer.l"
 		{
 	return T_POUND;
 }
-#line 699 "/Users/Bob/php-src-5.6/sapi/phpdbg/phpdbg_lexer.c"
-yy60:
-		YYDEBUG(60, *YYCURSOR);
+#line 634 "/var/root/php-src/sapi/phpdbg/phpdbg_lexer.c"
+yy57:
+		YYDEBUG(57, *YYCURSOR);
 		++YYCURSOR;
-		if ((yych = *YYCURSOR) == ':') goto yy62;
-		YYDEBUG(61, *YYCURSOR);
+		if ((yych = *YYCURSOR) == ':') goto yy59;
+		YYDEBUG(58, *YYCURSOR);
 		yyleng = (size_t) YYCURSOR - (size_t) yytext;
-#line 98 "/Users/Bob/php-src-5.6/sapi/phpdbg/phpdbg_lexer.l"
+#line 90 "/var/root/php-src/sapi/phpdbg/phpdbg_lexer.l"
 		{
 	return T_COLON;
 }
-#line 710 "/Users/Bob/php-src-5.6/sapi/phpdbg/phpdbg_lexer.c"
-yy62:
-		YYDEBUG(62, *YYCURSOR);
+#line 645 "/var/root/php-src/sapi/phpdbg/phpdbg_lexer.c"
+yy59:
+		YYDEBUG(59, *YYCURSOR);
 		++YYCURSOR;
-		YYDEBUG(63, *YYCURSOR);
+		YYDEBUG(60, *YYCURSOR);
 		yyleng = (size_t) YYCURSOR - (size_t) yytext;
-#line 95 "/Users/Bob/php-src-5.6/sapi/phpdbg/phpdbg_lexer.l"
+#line 87 "/var/root/php-src/sapi/phpdbg/phpdbg_lexer.l"
 		{
 	return T_DCOLON;
 }
-#line 720 "/Users/Bob/php-src-5.6/sapi/phpdbg/phpdbg_lexer.c"
-yy64:
-		YYDEBUG(64, *YYCURSOR);
+#line 655 "/var/root/php-src/sapi/phpdbg/phpdbg_lexer.c"
+yy61:
+		YYDEBUG(61, *YYCURSOR);
 		yyaccept = 0;
 		yych = *(YYMARKER = ++YYCURSOR);
-		if (yych == 'n') goto yy70;
-		goto yy44;
-yy65:
-		YYDEBUG(65, *YYCURSOR);
+		if (yych == 'n') goto yy67;
+		goto yy40;
+yy62:
+		YYDEBUG(62, *YYCURSOR);
 		yych = *++YYCURSOR;
-		if (yych == '/') goto yy67;
-yy66:
-		YYDEBUG(66, *YYCURSOR);
+		if (yych == '/') goto yy64;
+yy63:
+		YYDEBUG(63, *YYCURSOR);
 		YYCURSOR = YYMARKER;
-		if (yyaccept <= 2) {
-			if (yyaccept <= 1) {
-				if (yyaccept <= 0) {
-					goto yy41;
-				} else {
-					goto yy47;
-				}
+		if (yyaccept <= 1) {
+			if (yyaccept <= 0) {
+				goto yy38;
 			} else {
-				goto yy75;
+				goto yy44;
 			}
 		} else {
-			if (yyaccept <= 3) {
-				goto yy108;
+			if (yyaccept <= 2) {
+				goto yy72;
 			} else {
-				goto yy119;
+				goto yy105;
 			}
 		}
-yy67:
-		YYDEBUG(67, *YYCURSOR);
+yy64:
+		YYDEBUG(64, *YYCURSOR);
 		yych = *++YYCURSOR;
-		if (yych != '/') goto yy66;
-		YYDEBUG(68, *YYCURSOR);
+		if (yych != '/') goto yy63;
+		YYDEBUG(65, *YYCURSOR);
 		++YYCURSOR;
-		YYDEBUG(69, *YYCURSOR);
+		YYDEBUG(66, *YYCURSOR);
 		yyleng = (size_t) YYCURSOR - (size_t) yytext;
-#line 86 "/Users/Bob/php-src-5.6/sapi/phpdbg/phpdbg_lexer.l"
+#line 78 "/var/root/php-src/sapi/phpdbg/phpdbg_lexer.l"
 		{
 	phpdbg_init_param(yylval, STR_PARAM);
 	yylval->str = zend_strndup(yytext, yyleng);
 	yylval->len = yyleng;
 	return T_PROTO;
 }
-#line 766 "/Users/Bob/php-src-5.6/sapi/phpdbg/phpdbg_lexer.c"
-yy70:
-		YYDEBUG(70, *YYCURSOR);
+#line 697 "/var/root/php-src/sapi/phpdbg/phpdbg_lexer.c"
+yy67:
+		YYDEBUG(67, *YYCURSOR);
 		yyaccept = 0;
 		yych = *(YYMARKER = ++YYCURSOR);
-		if (yych != 'd') goto yy44;
-		YYDEBUG(71, *YYCURSOR);
+		if (yych != 'd') goto yy40;
+		YYDEBUG(68, *YYCURSOR);
 		yyaccept = 0;
 		yych = *(YYMARKER = ++YYCURSOR);
-		if (yych != '_') goto yy44;
-yy72:
-		YYDEBUG(72, *YYCURSOR);
+		if (yych != '_') goto yy40;
+yy69:
+		YYDEBUG(69, *YYCURSOR);
 		yyaccept = 0;
 		yych = *(YYMARKER = ++YYCURSOR);
-		if (yybm[0+yych] & 32) {
-			goto yy73;
+		if (yybm[0+yych] & 64) {
+			goto yy70;
 		}
-		goto yy44;
-yy73:
-		YYDEBUG(73, *YYCURSOR);
+		goto yy40;
+yy70:
+		YYDEBUG(70, *YYCURSOR);
 		yyaccept = 2;
 		YYMARKER = ++YYCURSOR;
 		YYFILL(3);
 		yych = *YYCURSOR;
-		YYDEBUG(74, *YYCURSOR);
-		if (yybm[0+yych] & 32) {
-			goto yy73;
+		YYDEBUG(71, *YYCURSOR);
+		if (yybm[0+yych] & 64) {
+			goto yy70;
 		}
 		if (yych <= 0x1F) {
 			if (yych <= '\n') {
-				if (yych <= 0x00) goto yy75;
-				if (yych <= 0x08) goto yy43;
+				if (yych <= 0x00) goto yy72;
+				if (yych <= 0x08) goto yy39;
 			} else {
-				if (yych != '\r') goto yy43;
+				if (yych != '\r') goto yy39;
 			}
 		} else {
 			if (yych <= '#') {
-				if (yych <= ' ') goto yy75;
-				if (yych <= '"') goto yy43;
+				if (yych <= ' ') goto yy72;
+				if (yych <= '"') goto yy39;
 			} else {
-				if (yych == ':') goto yy65;
-				goto yy43;
+				if (yych == ':') goto yy62;
+				goto yy39;
 			}
 		}
-yy75:
-		YYDEBUG(75, *YYCURSOR);
+yy72:
+		YYDEBUG(72, *YYCURSOR);
 		yyleng = (size_t) YYCURSOR - (size_t) yytext;
-#line 126 "/Users/Bob/php-src-5.6/sapi/phpdbg/phpdbg_lexer.l"
+#line 118 "/var/root/php-src/sapi/phpdbg/phpdbg_lexer.l"
 		{
 	phpdbg_init_param(yylval, OP_PARAM);
 	yylval->str = zend_strndup(yytext, yyleng);
 	yylval->len = yyleng;
 	return T_OPCODE;
 }
-#line 820 "/Users/Bob/php-src-5.6/sapi/phpdbg/phpdbg_lexer.c"
-yy76:
-		YYDEBUG(76, *YYCURSOR);
+#line 751 "/var/root/php-src/sapi/phpdbg/phpdbg_lexer.c"
+yy73:
+		YYDEBUG(73, *YYCURSOR);
 		yyaccept = 0;
 		yych = *(YYMARKER = ++YYCURSOR);
-		if (yych != 'N') goto yy44;
-		YYDEBUG(77, *YYCURSOR);
+		if (yych != 'N') goto yy40;
+		YYDEBUG(74, *YYCURSOR);
 		yyaccept = 0;
 		yych = *(YYMARKER = ++YYCURSOR);
-		if (yych != 'D') goto yy44;
-		YYDEBUG(78, *YYCURSOR);
+		if (yych != 'D') goto yy40;
+		YYDEBUG(75, *YYCURSOR);
 		yyaccept = 0;
 		yych = *(YYMARKER = ++YYCURSOR);
-		if (yych == '_') goto yy72;
-		goto yy44;
-yy79:
-		YYDEBUG(79, *YYCURSOR);
+		if (yych == '_') goto yy69;
+		goto yy40;
+yy76:
+		YYDEBUG(76, *YYCURSOR);
 		yyaccept = 0;
 		yych = *(YYMARKER = ++YYCURSOR);
-		if (yych == 'S') goto yy80;
-		if (yych != 's') goto yy44;
-yy80:
-		YYDEBUG(80, *YYCURSOR);
+		if (yych == 'S') goto yy77;
+		if (yych != 's') goto yy40;
+yy77:
+		YYDEBUG(77, *YYCURSOR);
 		yyaccept = 0;
 		yych = *(YYMARKER = ++YYCURSOR);
-		if (yybm[0+yych] & 64) {
-			goto yy81;
+		if (yych <= '\f') {
+			if (yych <= 0x08) goto yy40;
+			if (yych >= '\v') goto yy40;
+		} else {
+			if (yych <= '\r') goto yy78;
+			if (yych != ' ') goto yy40;
 		}
-		goto yy44;
-yy81:
-		YYDEBUG(81, *YYCURSOR);
+yy78:
+		YYDEBUG(78, *YYCURSOR);
 		++YYCURSOR;
 		YYFILL(1);
 		yych = *YYCURSOR;
-		YYDEBUG(82, *YYCURSOR);
-		if (yybm[0+yych] & 64) {
-			goto yy81;
+		YYDEBUG(79, *YYCURSOR);
+		if (yych <= '\f') {
+			if (yych <= 0x08) goto yy80;
+			if (yych <= '\n') goto yy78;
+		} else {
+			if (yych <= '\r') goto yy78;
+			if (yych == ' ') goto yy78;
 		}
-		YYDEBUG(83, *YYCURSOR);
+yy80:
+		YYDEBUG(80, *YYCURSOR);
 		yyleng = (size_t) YYCURSOR - (size_t) yytext;
-#line 102 "/Users/Bob/php-src-5.6/sapi/phpdbg/phpdbg_lexer.l"
+#line 94 "/var/root/php-src/sapi/phpdbg/phpdbg_lexer.l"
 		{
 	phpdbg_init_param(yylval, NUMERIC_PARAM);
 	yylval->num = 1;		
 	return T_TRUTHY;
 }
-#line 866 "/Users/Bob/php-src-5.6/sapi/phpdbg/phpdbg_lexer.c"
-yy84:
-		YYDEBUG(84, *YYCURSOR);
+#line 805 "/var/root/php-src/sapi/phpdbg/phpdbg_lexer.c"
+yy81:
+		YYDEBUG(81, *YYCURSOR);
 		yyaccept = 0;
 		yych = *(YYMARKER = ++YYCURSOR);
-		if (yych == 'U') goto yy85;
-		if (yych != 'u') goto yy44;
-yy85:
-		YYDEBUG(85, *YYCURSOR);
+		if (yych == 'U') goto yy82;
+		if (yych != 'u') goto yy40;
+yy82:
+		YYDEBUG(82, *YYCURSOR);
 		yyaccept = 0;
 		yych = *(YYMARKER = ++YYCURSOR);
-		if (yych == 'E') goto yy80;
-		if (yych == 'e') goto yy80;
-		goto yy44;
-yy86:
-		YYDEBUG(86, *YYCURSOR);
+		if (yych == 'E') goto yy77;
+		if (yych == 'e') goto yy77;
+		goto yy40;
+yy83:
+		YYDEBUG(83, *YYCURSOR);
 		yyaccept = 0;
 		yych = *(YYMARKER = ++YYCURSOR);
-		if (yych == 'F') goto yy87;
-		if (yych != 'f') goto yy44;
-yy87:
-		YYDEBUG(87, *YYCURSOR);
+		if (yych == 'F') goto yy84;
+		if (yych != 'f') goto yy40;
+yy84:
+		YYDEBUG(84, *YYCURSOR);
 		yyaccept = 0;
 		yych = *(YYMARKER = ++YYCURSOR);
 		if (yych <= '\f') {
-			if (yych <= 0x08) goto yy44;
-			if (yych >= '\v') goto yy44;
+			if (yych <= 0x08) goto yy40;
+			if (yych >= '\v') goto yy40;
 		} else {
-			if (yych <= '\r') goto yy88;
-			if (yych != ' ') goto yy44;
+			if (yych <= '\r') goto yy85;
+			if (yych != ' ') goto yy40;
 		}
-yy88:
-		YYDEBUG(88, *YYCURSOR);
+yy85:
+		YYDEBUG(85, *YYCURSOR);
 		++YYCURSOR;
 		YYFILL(1);
 		yych = *YYCURSOR;
-		YYDEBUG(89, *YYCURSOR);
+		YYDEBUG(86, *YYCURSOR);
 		if (yych <= '\f') {
-			if (yych <= 0x08) goto yy90;
-			if (yych <= '\n') goto yy88;
+			if (yych <= 0x08) goto yy87;
+			if (yych <= '\n') goto yy85;
 		} else {
-			if (yych <= '\r') goto yy88;
-			if (yych == ' ') goto yy88;
+			if (yych <= '\r') goto yy85;
+			if (yych == ' ') goto yy85;
 		}
-yy90:
-		YYDEBUG(90, *YYCURSOR);
+yy87:
+		YYDEBUG(87, *YYCURSOR);
 		yyleng = (size_t) YYCURSOR - (size_t) yytext;
-#line 108 "/Users/Bob/php-src-5.6/sapi/phpdbg/phpdbg_lexer.l"
+#line 100 "/var/root/php-src/sapi/phpdbg/phpdbg_lexer.l"
 		{
 	phpdbg_init_param(yylval, NUMERIC_PARAM);
 	yylval->num = 0;
 	return T_FALSY;
 }
-#line 919 "/Users/Bob/php-src-5.6/sapi/phpdbg/phpdbg_lexer.c"
+#line 858 "/var/root/php-src/sapi/phpdbg/phpdbg_lexer.c"
+yy88:
+		YYDEBUG(88, *YYCURSOR);
+		yyaccept = 0;
+		yych = *(YYMARKER = ++YYCURSOR);
+		if (yych == 'L') goto yy89;
+		if (yych != 'l') goto yy40;
+yy89:
+		YYDEBUG(89, *YYCURSOR);
+		yyaccept = 0;
+		yych = *(YYMARKER = ++YYCURSOR);
+		if (yych == 'S') goto yy90;
+		if (yych != 's') goto yy40;
+yy90:
+		YYDEBUG(90, *YYCURSOR);
+		yyaccept = 0;
+		yych = *(YYMARKER = ++YYCURSOR);
+		if (yych == 'E') goto yy84;
+		if (yych == 'e') goto yy84;
+		goto yy40;
 yy91:
 		YYDEBUG(91, *YYCURSOR);
 		yyaccept = 0;
 		yych = *(YYMARKER = ++YYCURSOR);
-		if (yych == 'L') goto yy92;
-		if (yych != 'l') goto yy44;
+		if (yych == 'A') goto yy92;
+		if (yych != 'a') goto yy40;
 yy92:
 		YYDEBUG(92, *YYCURSOR);
 		yyaccept = 0;
 		yych = *(YYMARKER = ++YYCURSOR);
-		if (yych == 'S') goto yy93;
-		if (yych != 's') goto yy44;
+		if (yych == 'B') goto yy93;
+		if (yych != 'b') goto yy40;
 yy93:
 		YYDEBUG(93, *YYCURSOR);
 		yyaccept = 0;
 		yych = *(YYMARKER = ++YYCURSOR);
-		if (yych == 'E') goto yy87;
-		if (yych == 'e') goto yy87;
-		goto yy44;
+		if (yych == 'L') goto yy94;
+		if (yych != 'l') goto yy40;
 yy94:
 		YYDEBUG(94, *YYCURSOR);
 		yyaccept = 0;
 		yych = *(YYMARKER = ++YYCURSOR);
-		if (yych == 'A') goto yy95;
-		if (yych != 'a') goto yy44;
+		if (yych == 'E') goto yy95;
+		if (yych != 'e') goto yy40;
 yy95:
 		YYDEBUG(95, *YYCURSOR);
 		yyaccept = 0;
 		yych = *(YYMARKER = ++YYCURSOR);
-		if (yych == 'B') goto yy96;
-		if (yych != 'b') goto yy44;
+		if (yych == 'D') goto yy77;
+		if (yych == 'd') goto yy77;
+		goto yy40;
 yy96:
 		YYDEBUG(96, *YYCURSOR);
 		yyaccept = 0;
 		yych = *(YYMARKER = ++YYCURSOR);
-		if (yych == 'L') goto yy97;
-		if (yych != 'l') goto yy44;
+		if (yych == 'S') goto yy97;
+		if (yych != 's') goto yy40;
 yy97:
 		YYDEBUG(97, *YYCURSOR);
 		yyaccept = 0;
 		yych = *(YYMARKER = ++YYCURSOR);
-		if (yych == 'E') goto yy98;
-		if (yych != 'e') goto yy44;
+		if (yych == 'A') goto yy98;
+		if (yych != 'a') goto yy40;
 yy98:
 		YYDEBUG(98, *YYCURSOR);
 		yyaccept = 0;
 		yych = *(YYMARKER = ++YYCURSOR);
-		if (yych == 'D') goto yy80;
-		if (yych == 'd') goto yy80;
-		goto yy44;
+		if (yych == 'B') goto yy99;
+		if (yych != 'b') goto yy40;
 yy99:
 		YYDEBUG(99, *YYCURSOR);
 		yyaccept = 0;
 		yych = *(YYMARKER = ++YYCURSOR);
-		if (yych == 'S') goto yy100;
-		if (yych != 's') goto yy44;
+		if (yych == 'L') goto yy100;
+		if (yych != 'l') goto yy40;
 yy100:
 		YYDEBUG(100, *YYCURSOR);
 		yyaccept = 0;
 		yych = *(YYMARKER = ++YYCURSOR);
-		if (yych == 'A') goto yy101;
-		if (yych != 'a') goto yy44;
+		if (yych == 'E') goto yy101;
+		if (yych != 'e') goto yy40;
 yy101:
 		YYDEBUG(101, *YYCURSOR);
 		yyaccept = 0;
 		yych = *(YYMARKER = ++YYCURSOR);
-		if (yych == 'B') goto yy102;
-		if (yych != 'b') goto yy44;
+		if (yych == 'D') goto yy84;
+		if (yych == 'd') goto yy84;
+		goto yy40;
 yy102:
 		YYDEBUG(102, *YYCURSOR);
 		yyaccept = 0;
 		yych = *(YYMARKER = ++YYCURSOR);
-		if (yych == 'L') goto yy103;
-		if (yych != 'l') goto yy44;
-yy103:
-		YYDEBUG(103, *YYCURSOR);
-		yyaccept = 0;
-		yych = *(YYMARKER = ++YYCURSOR);
-		if (yych == 'E') goto yy104;
-		if (yych != 'e') goto yy44;
-yy104:
-		YYDEBUG(104, *YYCURSOR);
-		yyaccept = 0;
-		yych = *(YYMARKER = ++YYCURSOR);
-		if (yych == 'D') goto yy87;
-		if (yych == 'd') goto yy87;
-		goto yy44;
-yy105:
-		YYDEBUG(105, *YYCURSOR);
-		yyaccept = 0;
-		yych = *(YYMARKER = ++YYCURSOR);
 		if (yybm[0+yych] & 128) {
-			goto yy106;
+			goto yy103;
 		}
-		goto yy44;
-yy106:
-		YYDEBUG(106, *YYCURSOR);
+		goto yy40;
+yy103:
+		YYDEBUG(103, *YYCURSOR);
 		yyaccept = 3;
 		YYMARKER = ++YYCURSOR;
 		YYFILL(3);
 		yych = *YYCURSOR;
-		YYDEBUG(107, *YYCURSOR);
+		YYDEBUG(104, *YYCURSOR);
 		if (yybm[0+yych] & 128) {
-			goto yy106;
+			goto yy103;
 		}
 		if (yych <= 0x1F) {
 			if (yych <= '\n') {
-				if (yych <= 0x00) goto yy108;
-				if (yych <= 0x08) goto yy43;
+				if (yych <= 0x00) goto yy105;
+				if (yych <= 0x08) goto yy39;
 			} else {
-				if (yych != '\r') goto yy43;
+				if (yych != '\r') goto yy39;
 			}
 		} else {
 			if (yych <= '#') {
-				if (yych <= ' ') goto yy108;
-				if (yych <= '"') goto yy43;
+				if (yych <= ' ') goto yy105;
+				if (yych <= '"') goto yy39;
 			} else {
-				if (yych == ':') goto yy65;
-				goto yy43;
+				if (yych == ':') goto yy62;
+				goto yy39;
 			}
 		}
-yy108:
-		YYDEBUG(108, *YYCURSOR);
+yy105:
+		YYDEBUG(105, *YYCURSOR);
 		yyleng = (size_t) YYCURSOR - (size_t) yytext;
-#line 120 "/Users/Bob/php-src-5.6/sapi/phpdbg/phpdbg_lexer.l"
+#line 112 "/var/root/php-src/sapi/phpdbg/phpdbg_lexer.l"
 		{
 	phpdbg_init_param(yylval, ADDR_PARAM);
 	yylval->addr = strtoul(yytext, 0, 16);
 	return T_ADDR;
 }
-#line 1050 "/Users/Bob/php-src-5.6/sapi/phpdbg/phpdbg_lexer.c"
-yy109:
-		YYDEBUG(109, *YYCURSOR);
+#line 989 "/var/root/php-src/sapi/phpdbg/phpdbg_lexer.c"
+yy106:
+		YYDEBUG(106, *YYCURSOR);
 		yyaccept = 0;
 		yych = *(YYMARKER = ++YYCURSOR);
 		if (yych <= '\f') {
-			if (yych <= 0x08) goto yy44;
-			if (yych >= '\v') goto yy44;
+			if (yych <= 0x08) goto yy40;
+			if (yych >= '\v') goto yy40;
 		} else {
-			if (yych <= '\r') goto yy110;
-			if (yych != ' ') goto yy44;
+			if (yych <= '\r') goto yy107;
+			if (yych != ' ') goto yy40;
 		}
-yy110:
-		YYDEBUG(110, *YYCURSOR);
+yy107:
+		YYDEBUG(107, *YYCURSOR);
 		++YYCURSOR;
 		YYFILL(1);
 		yych = *YYCURSOR;
-		YYDEBUG(111, *YYCURSOR);
+		YYDEBUG(108, *YYCURSOR);
 		if (yych <= '\f') {
-			if (yych <= 0x08) goto yy112;
-			if (yych <= '\n') goto yy110;
+			if (yych <= 0x08) goto yy109;
+			if (yych <= '\n') goto yy107;
 		} else {
-			if (yych <= '\r') goto yy110;
-			if (yych == ' ') goto yy110;
+			if (yych <= '\r') goto yy107;
+			if (yych == ' ') goto yy107;
 		}
-yy112:
-		YYDEBUG(112, *YYCURSOR);
+yy109:
+		YYDEBUG(109, *YYCURSOR);
 		yyleng = (size_t) YYCURSOR - (size_t) yytext;
-#line 80 "/Users/Bob/php-src-5.6/sapi/phpdbg/phpdbg_lexer.l"
+#line 72 "/var/root/php-src/sapi/phpdbg/phpdbg_lexer.l"
 		{
 	YYSETCONDITION(RAW);
 	phpdbg_init_param(yylval, EMPTY_PARAM);
 	return T_IF;
 }
-#line 1084 "/Users/Bob/php-src-5.6/sapi/phpdbg/phpdbg_lexer.c"
-yy113:
-		YYDEBUG(113, *YYCURSOR);
-		yyaccept = 0;
-		yych = *(YYMARKER = ++YYCURSOR);
-		if (yych <= ' ') {
-			if (yych <= '\f') {
-				if (yych <= 0x08) goto yy44;
-				if (yych >= '\v') goto yy44;
-			} else {
-				if (yych <= '\r') goto yy114;
-				if (yych <= 0x1F) goto yy44;
-			}
-		} else {
-			if (yych <= '.') {
-				if (yych <= ',') goto yy44;
-				if (yych <= '-') goto yy116;
-				goto yy117;
-			} else {
-				if (yych <= '/') goto yy44;
-				if (yych <= '9') goto yy117;
-				goto yy44;
-			}
-		}
-yy114:
-		YYDEBUG(114, *YYCURSOR);
-		++YYCURSOR;
-		YYFILL(2);
-		yych = *YYCURSOR;
-		YYDEBUG(115, *YYCURSOR);
-		if (yych <= ' ') {
-			if (yych <= '\f') {
-				if (yych <= 0x08) goto yy66;
-				if (yych <= '\n') goto yy114;
-				goto yy66;
-			} else {
-				if (yych <= '\r') goto yy114;
-				if (yych <= 0x1F) goto yy66;
-				goto yy114;
-			}
-		} else {
-			if (yych <= '.') {
-				if (yych <= ',') goto yy66;
-				if (yych <= '-') goto yy120;
-				goto yy121;
-			} else {
-				if (yych <= '/') goto yy66;
-				if (yych <= '9') goto yy121;
-				goto yy66;
-			}
-		}
-yy116:
-		YYDEBUG(116, *YYCURSOR);
-		yyaccept = 0;
-		yych = *(YYMARKER = ++YYCURSOR);
-		if (yych == '.') goto yy117;
-		if (yych <= '/') goto yy44;
-		if (yych >= ':') goto yy44;
-yy117:
-		YYDEBUG(117, *YYCURSOR);
-		yyaccept = 4;
-		YYMARKER = ++YYCURSOR;
-		YYFILL(3);
-		yych = *YYCURSOR;
-		YYDEBUG(118, *YYCURSOR);
-		if (yych <= ' ') {
-			if (yych <= '\n') {
-				if (yych <= 0x00) goto yy119;
-				if (yych <= 0x08) goto yy43;
-			} else {
-				if (yych == '\r') goto yy119;
-				if (yych <= 0x1F) goto yy43;
-			}
-		} else {
-			if (yych <= '.') {
-				if (yych == '#') goto yy119;
-				if (yych <= '-') goto yy43;
-				goto yy117;
-			} else {
-				if (yych <= '/') goto yy43;
-				if (yych <= '9') goto yy117;
-				if (yych <= ':') goto yy65;
-				goto yy43;
-			}
-		}
-yy119:
-		YYDEBUG(119, *YYCURSOR);
-		yyleng = (size_t) YYCURSOR - (size_t) yytext;
-#line 73 "/Users/Bob/php-src-5.6/sapi/phpdbg/phpdbg_lexer.l"
-		{
-	char *text = yytext + 2;
-	while (*++text < '0');
-	yylval->num = atoi(text);
-	return T_REQ_ID;
-}
-#line 1179 "/Users/Bob/php-src-5.6/sapi/phpdbg/phpdbg_lexer.c"
-yy120:
-		YYDEBUG(120, *YYCURSOR);
-		yych = *++YYCURSOR;
-		if (yych == '.') goto yy121;
-		if (yych <= '/') goto yy66;
-		if (yych >= ':') goto yy66;
-yy121:
-		YYDEBUG(121, *YYCURSOR);
-		++YYCURSOR;
-		YYFILL(1);
-		yych = *YYCURSOR;
-		YYDEBUG(122, *YYCURSOR);
-		if (yych == '.') goto yy121;
-		if (yych <= '/') goto yy119;
-		if (yych <= '9') goto yy121;
-		goto yy119;
+#line 1023 "/var/root/php-src/sapi/phpdbg/phpdbg_lexer.c"
 	}
 /* *********************************** */
-yyc_PRE_RAW:
+yyc_RAW:
 	{
 		static const unsigned char yybm[] = {
-			  0,   0,   0,   0,   0,   0,   0,   0, 
-			  0, 160,  48,   0,   0, 160,   0,   0, 
-			  0,   0,   0,   0,   0,   0,   0,   0, 
-			  0,   0,   0,   0,   0,   0,   0,   0, 
-			160,   0,   0,   0,   0,   0,   0,   0, 
-			  0,   0,   0,   0,   0,   0,  64,   0, 
+			  0,  64,  64,  64,  64,  64,  64,  64, 
+			 64, 224, 128,  64,  64, 224,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			224,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
 			 64,  64,  64,  64,  64,  64,  64,  64, 
-			 64,  64,   0,   0,   0,   0,   0,   0, 
-			  0,   0,   0,   0,   0,   0,   0,   0, 
-			  0,   0,   0,   0,   0,   0,   0,   0, 
-			  0,   0,   0,   0,   0,   0,   0,   0, 
-			  0,   0,   0,   0,   0,   0,   0,   0, 
-			  0,   0,   0,   0,   0,   0,   0,   0, 
-			  0,   0,   0,   0,   0,   0,   0,   0, 
-			  0,   0,   0,   0,   0,   0,   0,   0, 
-			  0,   0,   0,   0,   0,   0,   0,   0, 
-			  0,   0,   0,   0,   0,   0,   0,   0, 
-			  0,   0,   0,   0,   0,   0,   0,   0, 
-			  0,   0,   0,   0,   0,   0,   0,   0, 
-			  0,   0,   0,   0,   0,   0,   0,   0, 
-			  0,   0,   0,   0,   0,   0,   0,   0, 
-			  0,   0,   0,   0,   0,   0,   0,   0, 
-			  0,   0,   0,   0,   0,   0,   0,   0, 
-			  0,   0,   0,   0,   0,   0,   0,   0, 
-			  0,   0,   0,   0,   0,   0,   0,   0, 
-			  0,   0,   0,   0,   0,   0,   0,   0, 
-			  0,   0,   0,   0,   0,   0,   0,   0, 
-			  0,   0,   0,   0,   0,   0,   0,   0, 
-			  0,   0,   0,   0,   0,   0,   0,   0, 
-			  0,   0,   0,   0,   0,   0,   0,   0, 
-			  0,   0,   0,   0,   0,   0,   0,   0, 
-			  0,   0,   0,   0,   0,   0,   0,   0, 
 		};
-		YYDEBUG(123, *YYCURSOR);
-		YYFILL(2);
-		yych = *YYCURSOR;
-		if (yybm[0+yych] & 16) {
-			goto yy127;
-		}
-		if (yych <= '\r') {
-			if (yych <= 0x08) {
-				if (yych <= 0x00) goto yy130;
-				goto yy132;
-			} else {
-				if (yych <= '\t') goto yy125;
-				if (yych <= '\f') goto yy132;
-			}
-		} else {
-			if (yych <= ' ') {
-				if (yych <= 0x1F) goto yy132;
-			} else {
-				if (yych == '-') goto yy131;
-				goto yy132;
-			}
-		}
-yy125:
-		YYDEBUG(125, *YYCURSOR);
-		++YYCURSOR;
-		if ((yych = *YYCURSOR) <= '\f') {
-			if (yych <= 0x00) goto yy142;
-			if (yych <= 0x08) goto yy126;
-			if (yych <= '\n') goto yy142;
-		} else {
-			if (yych <= '\r') goto yy142;
-			if (yych == ' ') goto yy142;
-		}
-yy126:
-		YYDEBUG(126, *YYCURSOR);
-		yyleng = (size_t) YYCURSOR - (size_t) yytext;
-#line 169 "/Users/Bob/php-src-5.6/sapi/phpdbg/phpdbg_lexer.l"
-		{
-	YYSETCONDITION(RAW);
-
-	YYCURSOR = LEX(text);
-	goto restart;
-}
-#line 1277 "/Users/Bob/php-src-5.6/sapi/phpdbg/phpdbg_lexer.c"
-yy127:
-		YYDEBUG(127, *YYCURSOR);
-		++YYCURSOR;
-		YYFILL(1);
-		yych = *YYCURSOR;
-		YYDEBUG(128, *YYCURSOR);
-		if (yybm[0+yych] & 128) {
-			goto yy141;
-		}
-		if (yych <= 0x00) goto yy140;
-		if (yych == '\n') goto yy127;
-yy129:
-		YYDEBUG(129, *YYCURSOR);
-		yyleng = (size_t) YYCURSOR - (size_t) yytext;
-#line 69 "/Users/Bob/php-src-5.6/sapi/phpdbg/phpdbg_lexer.l"
-		{
-	return 0;
-}
-#line 1296 "/Users/Bob/php-src-5.6/sapi/phpdbg/phpdbg_lexer.c"
-yy130:
-		YYDEBUG(130, *YYCURSOR);
-		yych = *++YYCURSOR;
-		goto yy126;
-yy131:
-		YYDEBUG(131, *YYCURSOR);
-		yyaccept = 0;
-		yych = *(YYMARKER = ++YYCURSOR);
-		if (yych == 'r') goto yy133;
-		goto yy126;
-yy132:
-		YYDEBUG(132, *YYCURSOR);
-		yych = *++YYCURSOR;
-		goto yy126;
-yy133:
-		YYDEBUG(133, *YYCURSOR);
-		++YYCURSOR;
+		YYDEBUG(110, *YYCURSOR);
 		YYFILL(2);
 		yych = *YYCURSOR;
-		YYDEBUG(134, *YYCURSOR);
-		if (yybm[0+yych] & 32) {
-			goto yy133;
-		}
-		if (yych <= '.') {
-			if (yych <= ',') goto yy135;
-			if (yych <= '-') goto yy136;
-			goto yy137;
-		} else {
-			if (yych <= '/') goto yy135;
-			if (yych <= '9') goto yy137;
-		}
-yy135:
-		YYDEBUG(135, *YYCURSOR);
-		YYCURSOR = YYMARKER;
-		goto yy126;
-yy136:
-		YYDEBUG(136, *YYCURSOR);
-		yych = *++YYCURSOR;
-		if (yybm[0+yych] & 64) {
-			goto yy137;
-		}
-		goto yy135;
-yy137:
-		YYDEBUG(137, *YYCURSOR);
-		++YYCURSOR;
-		YYFILL(1);
-		yych = *YYCURSOR;
-		YYDEBUG(138, *YYCURSOR);
-		if (yybm[0+yych] & 64) {
-			goto yy137;
-		}
-		YYDEBUG(139, *YYCURSOR);
-		yyleng = (size_t) YYCURSOR - (size_t) yytext;
-#line 73 "/Users/Bob/php-src-5.6/sapi/phpdbg/phpdbg_lexer.l"
-		{
-	char *text = yytext + 2;
-	while (*++text < '0');
-	yylval->num = atoi(text);
-	return T_REQ_ID;
-}
-#line 1357 "/Users/Bob/php-src-5.6/sapi/phpdbg/phpdbg_lexer.c"
-yy140:
-		YYDEBUG(140, *YYCURSOR);
-		yych = *++YYCURSOR;
-		goto yy129;
-yy141:
-		YYDEBUG(141, *YYCURSOR);
-		++YYCURSOR;
-		YYFILL(1);
-		yych = *YYCURSOR;
-yy142:
-		YYDEBUG(142, *YYCURSOR);
-		if (yybm[0+yych] & 128) {
-			goto yy141;
-		}
-		if (yych <= 0x00) goto yy140;
-		if (yych == '\n') goto yy127;
-		YYDEBUG(143, *YYCURSOR);
-		yyleng = (size_t) YYCURSOR - (size_t) yytext;
-#line 147 "/Users/Bob/php-src-5.6/sapi/phpdbg/phpdbg_lexer.l"
-		{
-	/* ignore whitespace */
-
-	goto restart;
-}
-#line 1382 "/Users/Bob/php-src-5.6/sapi/phpdbg/phpdbg_lexer.c"
-	}
-/* *********************************** */
-yyc_RAW:
-	{
-		static const unsigned char yybm[] = {
-			  0, 128, 128, 128, 128, 128, 128, 128, 
-			128, 160,  64, 128, 128, 160, 128, 128, 
-			128, 128, 128, 128, 128, 128, 128, 128, 
-			128, 128, 128, 128, 128, 128, 128, 128, 
-			160, 128, 128, 128, 128, 128, 128, 128, 
-			128, 128, 128, 128, 128, 128, 128, 128, 
-			128, 128, 128, 128, 128, 128, 128, 128, 
-			128, 128, 128, 128, 128, 128, 128, 128, 
-			128, 128, 128, 128, 128, 128, 128, 128, 
-			128, 128, 128, 128, 128, 128, 128, 128, 
-			128, 128, 128, 128, 128, 128, 128, 128, 
-			128, 128, 128, 128, 128, 128, 128, 128, 
-			128, 128, 128, 128, 128, 128, 128, 128, 
-			128, 128, 128, 128, 128, 128, 128, 128, 
-			128, 128, 128, 128, 128, 128, 128, 128, 
-			128, 128, 128, 128, 128, 128, 128, 128, 
-			128, 128, 128, 128, 128, 128, 128, 128, 
-			128, 128, 128, 128, 128, 128, 128, 128, 
-			128, 128, 128, 128, 128, 128, 128, 128, 
-			128, 128, 128, 128, 128, 128, 128, 128, 
-			128, 128, 128, 128, 128, 128, 128, 128, 
-			128, 128, 128, 128, 128, 128, 128, 128, 
-			128, 128, 128, 128, 128, 128, 128, 128, 
-			128, 128, 128, 128, 128, 128, 128, 128, 
-			128, 128, 128, 128, 128, 128, 128, 128, 
-			128, 128, 128, 128, 128, 128, 128, 128, 
-			128, 128, 128, 128, 128, 128, 128, 128, 
-			128, 128, 128, 128, 128, 128, 128, 128, 
-			128, 128, 128, 128, 128, 128, 128, 128, 
-			128, 128, 128, 128, 128, 128, 128, 128, 
-			128, 128, 128, 128, 128, 128, 128, 128, 
-			128, 128, 128, 128, 128, 128, 128, 128, 
-		};
-		YYDEBUG(144, *YYCURSOR);
-		YYFILL(1);
-		yych = *YYCURSOR;
 		if (yybm[0+yych] & 32) {
-			goto yy146;
+			goto yy112;
 		}
-		if (yych <= 0x00) goto yy152;
-		if (yych == '\n') goto yy149;
-		goto yy153;
-yy146:
-		YYDEBUG(146, *YYCURSOR);
+		if (yych <= 0x00) goto yy117;
+		if (yych == '\n') goto yy115;
+		goto yy118;
+yy112:
+		YYDEBUG(112, *YYCURSOR);
 		++YYCURSOR;
 		YYFILL(1);
 		yych = *YYCURSOR;
-		YYDEBUG(147, *YYCURSOR);
+		YYDEBUG(113, *YYCURSOR);
 		if (yybm[0+yych] & 32) {
-			goto yy146;
+			goto yy112;
 		}
-		if (yych <= 0x00) goto yy152;
-		if (yych == '\n') goto yy149;
-		goto yy153;
-yy148:
-		YYDEBUG(148, *YYCURSOR);
+		if (yych <= 0x00) goto yy114;
+		if (yych == '\n') goto yy120;
+		goto yy118;
+yy114:
+		YYDEBUG(114, *YYCURSOR);
 		yyleng = (size_t) YYCURSOR - (size_t) yytext;
-#line 140 "/Users/Bob/php-src-5.6/sapi/phpdbg/phpdbg_lexer.l"
+#line 132 "/var/root/php-src/sapi/phpdbg/phpdbg_lexer.l"
 		{
 	phpdbg_init_param(yylval, STR_PARAM);
 	yylval->str = zend_strndup(yytext, yyleng);
 	yylval->len = yyleng;
 	return T_INPUT;
 }
-#line 1452 "/Users/Bob/php-src-5.6/sapi/phpdbg/phpdbg_lexer.c"
-yy149:
-		YYDEBUG(149, *YYCURSOR);
+#line 1093 "/var/root/php-src/sapi/phpdbg/phpdbg_lexer.c"
+yy115:
+		YYDEBUG(115, *YYCURSOR);
 		++YYCURSOR;
-		YYFILL(1);
-		yych = *YYCURSOR;
-		YYDEBUG(150, *YYCURSOR);
-		if (yybm[0+yych] & 64) {
-			goto yy149;
-		}
-		if (yych <= '\f') {
-			if (yych <= 0x00) goto yy152;
-			if (yych == '\t') goto yy155;
-		} else {
-			if (yych <= '\r') goto yy155;
-			if (yych == ' ') goto yy155;
+		if (yybm[0+(yych = *YYCURSOR)] & 128) {
+			goto yy120;
 		}
-yy151:
-		YYDEBUG(151, *YYCURSOR);
+yy116:
+		YYDEBUG(116, *YYCURSOR);
 		yyleng = (size_t) YYCURSOR - (size_t) yytext;
-#line 69 "/Users/Bob/php-src-5.6/sapi/phpdbg/phpdbg_lexer.l"
+#line 68 "/var/root/php-src/sapi/phpdbg/phpdbg_lexer.l"
 		{
 	return 0;
 }
-#line 1476 "/Users/Bob/php-src-5.6/sapi/phpdbg/phpdbg_lexer.c"
-yy152:
-		YYDEBUG(152, *YYCURSOR);
+#line 1107 "/var/root/php-src/sapi/phpdbg/phpdbg_lexer.c"
+yy117:
+		YYDEBUG(117, *YYCURSOR);
 		yych = *++YYCURSOR;
-		goto yy151;
-yy153:
-		YYDEBUG(153, *YYCURSOR);
+		goto yy116;
+yy118:
+		YYDEBUG(118, *YYCURSOR);
 		++YYCURSOR;
 		YYFILL(1);
 		yych = *YYCURSOR;
-		YYDEBUG(154, *YYCURSOR);
-		if (yybm[0+yych] & 128) {
-			goto yy153;
+		YYDEBUG(119, *YYCURSOR);
+		if (yybm[0+yych] & 64) {
+			goto yy118;
 		}
-		goto yy148;
-yy155:
-		YYDEBUG(155, *YYCURSOR);
+		goto yy114;
+yy120:
+		YYDEBUG(120, *YYCURSOR);
 		++YYCURSOR;
 		YYFILL(1);
 		yych = *YYCURSOR;
-		YYDEBUG(156, *YYCURSOR);
-		if (yybm[0+yych] & 64) {
-			goto yy149;
-		}
-		if (yych <= '\f') {
-			if (yych <= 0x00) goto yy152;
-			if (yych == '\t') goto yy155;
-		} else {
-			if (yych <= '\r') goto yy155;
-			if (yych == ' ') goto yy155;
+		YYDEBUG(121, *YYCURSOR);
+		if (yybm[0+yych] & 128) {
+			goto yy120;
 		}
-		YYDEBUG(157, *YYCURSOR);
+		YYDEBUG(122, *YYCURSOR);
 		yyleng = (size_t) YYCURSOR - (size_t) yytext;
-#line 147 "/Users/Bob/php-src-5.6/sapi/phpdbg/phpdbg_lexer.l"
+#line 139 "/var/root/php-src/sapi/phpdbg/phpdbg_lexer.l"
 		{
 	/* ignore whitespace */
 
 	goto restart;
 }
-#line 1515 "/Users/Bob/php-src-5.6/sapi/phpdbg/phpdbg_lexer.c"
+#line 1139 "/var/root/php-src/sapi/phpdbg/phpdbg_lexer.c"
 	}
 }
-#line 183 "/Users/Bob/php-src-5.6/sapi/phpdbg/phpdbg_lexer.l"
+#line 168 "/var/root/php-src/sapi/phpdbg/phpdbg_lexer.l"
 
 }
diff --git a/sapi/phpdbg/phpdbg_lexer.l b/sapi/phpdbg/phpdbg_lexer.l
index 0c27fc22ac..7b3ce38c47 100644
--- a/sapi/phpdbg/phpdbg_lexer.l
+++ b/sapi/phpdbg/phpdbg_lexer.l
@@ -21,9 +21,8 @@
 #define YYFILL(n)
 
 #define NORMAL 0
-#define PRE_RAW 1
-#define RAW 2
-#define INITIAL 3
+#define RAW 1
+#define INITIAL 2
 
 ZEND_EXTERN_MODULE_GLOBALS(phpdbg);
 
@@ -66,17 +65,10 @@ INPUT       [^\n\000]+
 
 <!*> := yyleng = (size_t) YYCURSOR - (size_t) yytext;
 
-<*>{WS}?[\n\000] {
+<*>[\n\000] {
 	return 0;
 }
 
-<PRE_RAW, NORMAL>[-][r]{WS}?{DIGITS} {
-	char *text = yytext + 2;
-	while (*++text < '0');
-	yylval->num = atoi(text);
-	return T_REQ_ID;
-}
-
 <NORMAL>{T_IF}{WS} {
 	YYSETCONDITION(RAW);
 	phpdbg_init_param(yylval, EMPTY_PARAM);
@@ -151,28 +143,21 @@ INPUT       [^\n\000]+
 }
 
 <INITIAL>{T_EVAL}{WS} {
-	YYSETCONDITION(PRE_RAW);
+	YYSETCONDITION(RAW);
 	phpdbg_init_param(yylval, EMPTY_PARAM);
 	return T_EVAL;
 }
 <INITIAL>{T_SHELL}{WS} {
-	YYSETCONDITION(PRE_RAW);
+	YYSETCONDITION(RAW);
 	phpdbg_init_param(yylval, EMPTY_PARAM);
 	return T_SHELL;
 }
 <INITIAL>({T_RUN}|{T_RUN_SHORT}){WS} {
-	YYSETCONDITION(PRE_RAW);
+	YYSETCONDITION(RAW);
 	phpdbg_init_param(yylval, EMPTY_PARAM);
 	return T_RUN;
 }
 
-<PRE_RAW>. {
-	YYSETCONDITION(RAW);
-
-	YYCURSOR = LEX(text);
-	goto restart;
-}
-
 <INITIAL>. {
 	YYSETCONDITION(NORMAL);
 
diff --git a/sapi/phpdbg/phpdbg_list.c b/sapi/phpdbg/phpdbg_list.c
index 8ab4c8922a..e8db4e605c 100644
--- a/sapi/phpdbg/phpdbg_list.c
+++ b/sapi/phpdbg/phpdbg_list.c
@@ -34,21 +34,21 @@
 
 ZEND_EXTERN_MODULE_GLOBALS(phpdbg);
 
-#define PHPDBG_LIST_COMMAND_D(f, h, a, m, l, s, flags) \
-	PHPDBG_COMMAND_D_EXP(f, h, a, m, l, s, &phpdbg_prompt_commands[13], flags)
+#define PHPDBG_LIST_COMMAND_D(f, h, a, m, l, s) \
+	PHPDBG_COMMAND_D_EXP(f, h, a, m, l, s, &phpdbg_prompt_commands[13])
 
 const phpdbg_command_t phpdbg_list_commands[] = {
-	PHPDBG_LIST_COMMAND_D(lines,     "lists the specified lines",    'l', list_lines,  NULL, "l", PHPDBG_ASYNC_SAFE),
-	PHPDBG_LIST_COMMAND_D(class,     "lists the specified class",    'c', list_class,  NULL, "s", PHPDBG_ASYNC_SAFE),
-	PHPDBG_LIST_COMMAND_D(method,    "lists the specified method",   'm', list_method, NULL, "m", PHPDBG_ASYNC_SAFE),
-	PHPDBG_LIST_COMMAND_D(func,      "lists the specified function", 'f', list_func,   NULL, "s", PHPDBG_ASYNC_SAFE),
+	PHPDBG_LIST_COMMAND_D(lines,     "lists the specified lines",    'l', list_lines,  NULL, "l"),
+	PHPDBG_LIST_COMMAND_D(class,     "lists the specified class",    'c', list_class,  NULL, "s"),
+	PHPDBG_LIST_COMMAND_D(method,    "lists the specified method",   'm', list_method, NULL, "m"),
+	PHPDBG_LIST_COMMAND_D(func,      "lists the specified function", 'f', list_func,   NULL, "s"),
 	PHPDBG_END_COMMAND
 };
 
 PHPDBG_LIST(lines) /* {{{ */
 {
 	if (!PHPDBG_G(exec) && !zend_is_executing(TSRMLS_C)) {
-		phpdbg_error("inactive", "type=\"execution\"", "Not executing, and execution context not set");
+		phpdbg_error("Not executing, and execution context not set");
 		return SUCCESS;
 	}
 
@@ -59,7 +59,7 @@ PHPDBG_LIST(lines) /* {{{ */
 				(param->num < 0 ? param->num : 0) + zend_get_executed_lineno(TSRMLS_C),
 				0 TSRMLS_CC);
 			break;
-
+			
 		case FILE_PARAM:
 			phpdbg_list_file(param->file.name, param->file.line, 0, 0 TSRMLS_CC);
 			break;
@@ -81,19 +81,19 @@ PHPDBG_LIST(method) /* {{{ */
 {
 	zend_class_entry **ce;
 
-	if (phpdbg_safe_class_lookup(param->method.class, strlen(param->method.class), &ce TSRMLS_CC) == SUCCESS) {
+	if (zend_lookup_class(param->method.class, strlen(param->method.class), &ce TSRMLS_CC) == SUCCESS) {
 		zend_function *function;
 		char *lcname = zend_str_tolower_dup(param->method.name, strlen(param->method.name));
 
 		if (zend_hash_find(&(*ce)->function_table, lcname, strlen(lcname)+1, (void**) &function) == SUCCESS) {
 			phpdbg_list_function(function TSRMLS_CC);
 		} else {
-			phpdbg_error("list", "type=\"notfound\" method=\"%s::%s\"", "Could not find %s::%s", param->method.class, param->method.name);
+			phpdbg_error("Could not find %s::%s", param->method.class, param->method.name);
 		}
 
 		efree(lcname);
 	} else {
-		phpdbg_error("list", "type=\"notfound\" class=\"%s\"", "Could not find the class %s", param->method.class);
+		phpdbg_error("Could not find the class %s", param->method.class);
 	}
 
 	return SUCCESS;
@@ -103,7 +103,7 @@ PHPDBG_LIST(class) /* {{{ */
 {
 	zend_class_entry **ce;
 
-	if (phpdbg_safe_class_lookup(param->str, param->len, &ce TSRMLS_CC) == SUCCESS) {
+	if (zend_lookup_class(param->str, param->len, &ce TSRMLS_CC) == SUCCESS) {
 		if ((*ce)->type == ZEND_USER_CLASS) {
 			if ((*ce)->info.user.filename) {
 				phpdbg_list_file(
@@ -112,67 +112,71 @@ PHPDBG_LIST(class) /* {{{ */
 					(*ce)->info.user.line_start, 0 TSRMLS_CC
 				);
 			} else {
-				phpdbg_error("list", "type=\"nosource\" class=\"%s\"", "The source of the requested class (%s) cannot be found", (*ce)->name);
+				phpdbg_error("The source of the requested class (%s) cannot be found", (*ce)->name);
 			}
 		} else {
-			phpdbg_error("list", "type=\"internalclass\" class=\"%s\"", "The class requested (%s) is not user defined", (*ce)->name);
+			phpdbg_error("The class requested (%s) is not user defined", (*ce)->name);
 		}
 	} else {
-		phpdbg_error("list", "type=\"notfound\" class=\"%s\"", "The requested class (%s) could not be found", param->str);
+		phpdbg_error("The requested class (%s) could not be found", param->str);
 	}
 
 	return SUCCESS;
 } /* }}} */
 
-void phpdbg_list_file(const char *filename, uint count, int offset, uint highlight TSRMLS_DC) /* {{{ */
+void phpdbg_list_file(const char *filename, long count, long offset, int highlight TSRMLS_DC) /* {{{ */
 {
-	uint line, lastline;
-	phpdbg_file_source **data;
-	char resolved_path_buf[MAXPATHLEN];
-
-	if (VCWD_REALPATH(filename, resolved_path_buf)) {
-		filename = resolved_path_buf;
+	struct stat st;
+	char *opened = NULL;
+	char buffer[8096] = {0,};
+	long line = 0;
+
+	php_stream *stream = NULL;
+	
+	if (VCWD_STAT(filename, &st) == FAILURE) {
+		phpdbg_error("Failed to stat file %s", filename);
+		return;
 	}
 
-	if (zend_hash_find(&PHPDBG_G(file_sources), filename, strlen(filename), (void **) &data) == FAILURE) {
-		phpdbg_error("list", "type=\"unknownfile\"", "Could not find information about included file...");
+	stream = php_stream_open_wrapper(filename, "rb", USE_PATH, &opened);
+	
+	if (!stream) {
+		phpdbg_error("Failed to open file %s to list", filename);
 		return;
 	}
-
+	
 	if (offset < 0) {
 		count += offset;
 		offset = 0;
 	}
+	
+	while (php_stream_gets(stream, buffer, sizeof(buffer)) != NULL) {
+		long linelen = strlen(buffer);
 
-	lastline = offset + count;
-
-	if (lastline > (*data)->lines) {
-		lastline = (*data)->lines;
-	}
-
-	phpdbg_xml("<list %r file=\"%s\">", filename);
-
-	for (line = offset; line < lastline;) {
-		uint linestart = (*data)->line[line++];
-		uint linelen = (*data)->line[line] - linestart;
-		char *buffer = (*data)->buf + linestart;
-
-		if (!highlight) {
-			phpdbg_write("line", "line=\"%u\" code=\"%.*s\"", " %05u: %.*s", line, linelen, buffer);
-		} else {
-			if (highlight != line) {
-				phpdbg_write("line", "line=\"%u\" code=\"%.*s\"", " %05u: %.*s", line, linelen, buffer);
+		++line;
+		
+		if (offset <= line) {
+			if (!highlight) {
+				phpdbg_write("%05ld: %s", line, buffer);
 			} else {
-				phpdbg_write("line", "line=\"%u\" code=\"%.*s\" current=\"current\"", ">%05u: %.*s", line, linelen, buffer);
+				if (highlight != line) {
+					phpdbg_write(" %05ld: %s", line, buffer);
+				} else {
+					phpdbg_write(">%05ld: %s", line, buffer);
+				}
+			}
+
+			if (buffer[linelen - 1] != '\n') {
+				phpdbg_write("\n");
 			}
 		}
 
-		if (*(buffer + linelen - 1) != '\n' || !linelen) {
-			phpdbg_out("\n");
+		if (count > 0 && count + offset - 1 < line) {
+			break;
 		}
 	}
-
-	phpdbg_xml("</list>");
+	
+	php_stream_close(stream);
 } /* }}} */
 
 void phpdbg_list_function(const zend_function *fbc TSRMLS_DC) /* {{{ */
@@ -180,13 +184,14 @@ void phpdbg_list_function(const zend_function *fbc TSRMLS_DC) /* {{{ */
 	const zend_op_array *ops;
 
 	if (fbc->type != ZEND_USER_FUNCTION) {
-		phpdbg_error("list", "type=\"internalfunction\" function=\"%s\"", "The function requested (%s) is not user defined", fbc->common.function_name);
+		phpdbg_error("The function requested (%s) is not user defined", fbc->common.function_name);
 		return;
 	}
 
-	ops = (zend_op_array *)fbc;
+	ops = (zend_op_array*)fbc;
 
-	phpdbg_list_file(ops->filename, ops->line_end - ops->line_start + 1, ops->line_start, 0 TSRMLS_CC);
+	phpdbg_list_file(ops->filename,
+		ops->line_end - ops->line_start + 1, ops->line_start, 0 TSRMLS_CC);
 } /* }}} */
 
 void phpdbg_list_function_byname(const char *str, size_t len TSRMLS_DC) /* {{{ */
@@ -204,11 +209,11 @@ void phpdbg_list_function_byname(const char *str, size_t len TSRMLS_DC) /* {{{ *
 
 			func_table = &EG(scope)->function_table;
 		} else {
-			phpdbg_error("inactive", "type=\"noclasses\"", "No active class");
+			phpdbg_error("No active class");
 			return;
 		}
 	} else if (!EG(function_table)) {
-		phpdbg_error("inactive", "type=\"function_table\"", "No function table loaded");
+		phpdbg_error("No function table loaded");
 		return;
 	} else {
 		func_table = EG(function_table);
@@ -217,92 +222,12 @@ void phpdbg_list_function_byname(const char *str, size_t len TSRMLS_DC) /* {{{ *
 	/* use lowercase names, case insensitive */
 	func_name = zend_str_tolower_dup(func_name, func_name_len);
 
-	phpdbg_try_access {
-		if (zend_hash_find(func_table, func_name, func_name_len+1, (void**)&fbc) == SUCCESS) {
-			phpdbg_list_function(fbc TSRMLS_CC);
-		} else {
-			phpdbg_error("list", "type=\"nofunction\" function=\"%s\"", "Function %s not found", func_name);
-		}
-	} phpdbg_catch_access {
-		phpdbg_error("signalsegv", "function=\"%s\"", "Could not list function %s, invalid data source", func_name);
-	} phpdbg_end_try_access();
+	if (zend_hash_find(func_table, func_name, func_name_len+1, (void**)&fbc) == SUCCESS) {
+		phpdbg_list_function(fbc TSRMLS_CC);
+	} else {
+		phpdbg_error("Function %s not found", func_name);
+	}
 
 	efree(func_name);
 } /* }}} */
 
-zend_op_array *phpdbg_compile_file(zend_file_handle *file, int type TSRMLS_DC) {
-	phpdbg_file_source data, *dataptr;
-	zend_file_handle fake = {0};
-	zend_op_array *ret;
-	char *filename = (char *)(file->opened_path ? file->opened_path : file->filename);
-	uint line;
-	char *bufptr, *endptr;
-	char resolved_path_buf[MAXPATHLEN];
-
-	zend_stream_fixup(file, &data.buf, &data.len TSRMLS_CC);
-
-	data.filename = filename;
-	data.line[0] = 0;
-
-	if (file->handle.stream.mmap.old_closer) {
-		/* do not unmap */
-		file->handle.stream.closer = file->handle.stream.mmap.old_closer;
-	}
-
-#if HAVE_MMAP
-	if (file->handle.stream.mmap.map) {
-		data.map = file->handle.stream.mmap.map;
-	}
-#endif
-
-	fake.type = ZEND_HANDLE_MAPPED;
-	fake.handle.stream.mmap.buf = data.buf;
-	fake.handle.stream.mmap.len = data.len;
-	fake.free_filename = 0;
-	fake.opened_path = file->opened_path;
-	fake.filename = filename;
-	fake.opened_path = file->opened_path;
-
-	*(dataptr = emalloc(sizeof(phpdbg_file_source) + sizeof(uint) * data.len)) = data;
-	if (VCWD_REALPATH(filename, resolved_path_buf)) {
-		filename = resolved_path_buf;
-	}
-	zend_hash_add(&PHPDBG_G(file_sources), filename, strlen(filename), &dataptr, sizeof(phpdbg_file_source *), NULL);
-
-	for (line = 0, bufptr = data.buf - 1, endptr = data.buf + data.len; ++bufptr < endptr;) {
-		if (*bufptr == '\n') {
-			dataptr->line[++line] = (uint)(bufptr - data.buf) + 1;
-		}
-	}
-	dataptr->lines = ++line;
-	dataptr->line[line] = endptr - data.buf;
-	dataptr = erealloc(dataptr, sizeof(phpdbg_file_source) + sizeof(uint) * line);
-
-	phpdbg_resolve_pending_file_break(filename TSRMLS_CC);
-
-	ret = PHPDBG_G(compile_file)(&fake, type TSRMLS_CC);
-
-	fake.opened_path = NULL;
-	zend_file_handle_dtor(&fake TSRMLS_CC);
-
-	return ret;
-}
-
-void phpdbg_free_file_source(phpdbg_file_source *data) {
-#if HAVE_MMAP
-	if (data->map) {
-		munmap(data->map, data->len + ZEND_MMAP_AHEAD);
-	} else
-#endif
-	if (data->buf) {
-		efree(data->buf);
-	}
-
-	efree(data);
-}
-
-void phpdbg_init_list(TSRMLS_D) {
-	PHPDBG_G(compile_file) = zend_compile_file;
-	zend_hash_init(&PHPDBG_G(file_sources), 1, NULL, (dtor_func_t) phpdbg_free_file_source, 0);
-	zend_compile_file = phpdbg_compile_file;
-}
diff --git a/sapi/phpdbg/phpdbg_list.h b/sapi/phpdbg/phpdbg_list.h
index c88328bfea..14905f6567 100644
--- a/sapi/phpdbg/phpdbg_list.h
+++ b/sapi/phpdbg/phpdbg_list.h
@@ -34,21 +34,8 @@ PHPDBG_LIST(func);
 
 void phpdbg_list_function_byname(const char *, size_t TSRMLS_DC);
 void phpdbg_list_function(const zend_function* TSRMLS_DC);
-void phpdbg_list_file(const char*, uint, int, uint TSRMLS_DC);
+void phpdbg_list_file(const char*, long, long, int TSRMLS_DC);
 
 extern const phpdbg_command_t phpdbg_list_commands[];
 
-void phpdbg_init_list(TSRMLS_D);
-
-typedef struct {
-	char *filename;
-	char *buf;
-	size_t len;
-#if HAVE_MMAP
-	void *map;
-#endif
-	uint lines;
-	uint line[1];
-} phpdbg_file_source;
-
 #endif /* PHPDBG_LIST_H */
diff --git a/sapi/phpdbg/phpdbg_opcode.c b/sapi/phpdbg/phpdbg_opcode.c
index 331718accc..6b13625fc1 100644
--- a/sapi/phpdbg/phpdbg_opcode.c
+++ b/sapi/phpdbg/phpdbg_opcode.c
@@ -92,7 +92,8 @@ char *phpdbg_decode_opline(zend_op_array *ops, zend_op *op, HashTable *vars TSRM
 
 	case ZEND_JMPZNZ:
 			decode[1] = phpdbg_decode_op(ops, &op->op1, op->op1_type, vars TSRMLS_CC);
-			asprintf(&decode[2], "J%u or J%lu", op->op2.opline_num, op->extended_value);
+			asprintf(
+				&decode[2], "J%u or J%lu", op->op2.opline_num, op->extended_value);
 		goto result;
 
 	case ZEND_JMPZ:
@@ -103,8 +104,12 @@ char *phpdbg_decode_opline(zend_op_array *ops, zend_op *op, HashTable *vars TSRM
 #ifdef ZEND_JMP_SET
 	case ZEND_JMP_SET:
 #endif
+#ifdef ZEND_JMP_SET_VAR
+	case ZEND_JMP_SET_VAR:
+#endif
 		decode[1] = phpdbg_decode_op(ops, &op->op1, op->op1_type, vars TSRMLS_CC);
-		asprintf(&decode[2], "J%ld", op->op2.jmp_addr - ops->opcodes);
+		asprintf(
+			&decode[2], "J%ld", op->op2.jmp_addr - ops->opcodes);
 	goto result;
 
 	case ZEND_RECV_INIT:
@@ -116,7 +121,8 @@ char *phpdbg_decode_opline(zend_op_array *ops, zend_op *op, HashTable *vars TSRM
 result:
 			decode[3] = phpdbg_decode_op(ops, &op->result, op->result_type, vars TSRMLS_CC);
 format:
-			asprintf(&decode[0],
+			asprintf(
+				&decode[0],
 				"%-20s %-20s %-20s",
 				decode[1] ? decode[1] : "",
 				decode[2] ? decode[2] : "",
@@ -147,7 +153,7 @@ void phpdbg_print_opline_ex(zend_execute_data *execute_data, HashTable *vars, ze
 
 		if (ignore_flags || (!(PHPDBG_G(flags) & PHPDBG_IS_QUIET) || (PHPDBG_G(flags) & PHPDBG_IS_STEPPING))) {
 			/* output line info */
-			phpdbg_notice("opline", "line=\"%u\" opline=\"%p\" opcode=\"%s\" op=\"%s\" file=\"%s\"", "L%-5u %16p %-30s %s %s",
+			phpdbg_notice("L%-5u %16p %-30s %s %s",
 			   opline->lineno,
 			   opline,
 			   phpdbg_decode_opcode(opline->opcode),
@@ -156,7 +162,7 @@ void phpdbg_print_opline_ex(zend_execute_data *execute_data, HashTable *vars, ze
 		}
 
 		if (!ignore_flags && PHPDBG_G(oplog)) {
-			phpdbg_log_ex(fileno(PHPDBG_G(oplog)), "L%-5u %16p %-30s %s %s",
+			phpdbg_log_ex(PHPDBG_G(oplog), "L%-5u %16p %-30s %s %s",
 				opline->lineno,
 				opline,
 				phpdbg_decode_opcode(opline->opcode),
@@ -327,6 +333,12 @@ const char *phpdbg_decode_opcode(zend_uchar opcode) /* {{{ */
 #ifdef ZEND_SEPARATE
 		CASE(ZEND_SEPARATE);
 #endif
+#ifdef ZEND_QM_ASSIGN_VAR
+		CASE(ZEND_QM_ASSIGN_VAR);
+#endif
+#ifdef ZEND_JMP_SET_VAR
+		CASE(ZEND_JMP_SET_VAR);
+#endif
 #ifdef ZEND_DISCARD_EXCEPTION
 		CASE(ZEND_DISCARD_EXCEPTION);
 #endif
diff --git a/sapi/phpdbg/phpdbg_out.c b/sapi/phpdbg/phpdbg_out.c
deleted file mode 100644
index 7e1dc7b744..0000000000
--- a/sapi/phpdbg/phpdbg_out.c
+++ /dev/null
@@ -1,1323 +0,0 @@
-/*
-   +----------------------------------------------------------------------+
-   | PHP Version 5                                                        |
-   +----------------------------------------------------------------------+
-   | Copyright (c) 1997-2014 The PHP Group                                |
-   +----------------------------------------------------------------------+
-   | This source file is subject to version 3.01 of the PHP license,      |
-   | that is bundled with this package in the file LICENSE, and is        |
-   | available through the world-wide-web at the following url:           |
-   | http://www.php.net/license/3_01.txt                                  |
-   | If you did not receive a copy of the PHP license and are unable to   |
-   | obtain it through the world-wide-web, please send a note to          |
-   | license@php.net so we can mail you a copy immediately.               |
-   +----------------------------------------------------------------------+
-   | Authors: Felipe Pena <felipe@php.net>                                |
-   | Authors: Joe Watkins <joe.watkins@live.co.uk>                        |
-   | Authors: Bob Weinand <bwoebi@php.net>                                |
-   +----------------------------------------------------------------------+
-*/
-
-#include "zend.h"
-#include "php.h"
-#include "spprintf.h"
-#include "phpdbg.h"
-#include "phpdbg_io.h"
-#include "phpdbg_eol.h"
-#include "ext/standard/html.h"
-
-#ifdef _WIN32
-#	include "win32/time.h"
-#endif
-
-ZEND_EXTERN_MODULE_GLOBALS(phpdbg);
-
-/* copied from php-src/main/snprintf.c and slightly modified */
-/*
- * NUM_BUF_SIZE is the size of the buffer used for arithmetic conversions
- *
- * XXX: this is a magic number; do not decrease it
- * Emax = 1023
- * NDIG = 320
- * NUM_BUF_SIZE >= strlen("-") + Emax + strlrn(".") + NDIG + strlen("E+1023") + 1;
- */
-#define NUM_BUF_SIZE        2048
-
-/*
- * Descriptor for buffer area
- */
-struct buf_area {
-	char *buf_end;
-	char *nextb; /* pointer to next byte to read/write   */
-};
-
-typedef struct buf_area buffy;
-
-/*
- * The INS_CHAR macro inserts a character in the buffer and writes
- * the buffer back to disk if necessary
- * It uses the char pointers sp and bep:
- *      sp points to the next available character in the buffer
- *      bep points to the end-of-buffer+1
- * While using this macro, note that the nextb pointer is NOT updated.
- *
- * NOTE: Evaluation of the c argument should not have any side-effects
- */
-#define INS_CHAR(c, sp, bep, cc) \
-	{                            \
-		if (sp < bep)            \
-		{                        \
-			*sp++ = c;           \
-		}                        \
-		cc++;                    \
-	}
-
-#define NUM( c )			( c - '0' )
-
-#define STR_TO_DEC( str, num )		\
-    num = NUM( *str++ ) ;		\
-    while ( isdigit((int)*str ) )		\
-    {					\
-	num *= 10 ;			\
-	num += NUM( *str++ ) ;		\
-    }
-
-/*
- * This macro does zero padding so that the precision
- * requirement is satisfied. The padding is done by
- * adding '0's to the left of the string that is going
- * to be printed.
- */
-#define FIX_PRECISION( adjust, precision, s, s_len )	\
-    if ( adjust )					\
-	while ( s_len < precision )			\
-	{						\
-	    *--s = '0' ;				\
-	    s_len++ ;					\
-	}
-
-/*
- * Macro that does padding. The padding is done by printing
- * the character ch.
- */
-#define PAD( width, len, ch )	do		\
-	{					\
-	    INS_CHAR( ch, sp, bep, cc ) ;	\
-	    width-- ;				\
-	}					\
-	while ( width > len )
-
-/*
- * Prefix the character ch to the string str
- * Increase length
- * Set the has_prefix flag
- */
-#define PREFIX( str, length, ch )	 *--str = ch ; length++ ; has_prefix = YES
-
-
-#ifdef HAVE_LOCALE_H
-#include <locale.h>
-#define LCONV_DECIMAL_POINT (*lconv->decimal_point)
-#else
-#define LCONV_DECIMAL_POINT '.'
-#endif
-#define NUL '\0'
-#define S_NULL "(null)"
-#define S_NULL_LEN 6
-#define FLOAT_DIGITS 6
-
-/*
- * Do format conversion placing the output in buffer
- */
-static int format_converter(register buffy *odp, const char *fmt, zend_bool escape_xml, va_list ap TSRMLS_DC) {
-	char *sp;
-	char *bep;
-	int cc = 0;
-	int i;
-
-	char *s = NULL, *free_s = NULL;
-	int s_len, free_zcopy;
-	zval *zvp, zcopy;
-
-	int min_width = 0;
-	int precision = 0;
-	enum {
-		LEFT, RIGHT
-	} adjust;
-	char pad_char;
-	char prefix_char;
-
-	double fp_num;
-	wide_int i_num = (wide_int) 0;
-	u_wide_int ui_num;
-
-	char num_buf[NUM_BUF_SIZE];
-	char char_buf[2];			/* for printing %% and %<unknown> */
-
-#ifdef HAVE_LOCALE_H
-	struct lconv *lconv = NULL;
-#endif
-
-	/*
-	 * Flag variables
-	 */
-	length_modifier_e modifier;
-	boolean_e alternate_form;
-	boolean_e print_sign;
-	boolean_e print_blank;
-	boolean_e adjust_precision;
-	boolean_e adjust_width;
-	bool_int is_negative;
-
-	sp = odp->nextb;
-	bep = odp->buf_end;
-
-	while (*fmt) {
-		if (*fmt != '%') {
-			INS_CHAR(*fmt, sp, bep, cc);
-		} else {
-			/*
-			 * Default variable settings
-			 */
-			adjust = RIGHT;
-			alternate_form = print_sign = print_blank = NO;
-			pad_char = ' ';
-			prefix_char = NUL;
-			free_zcopy = 0;
-
-			fmt++;
-
-			/*
-			 * Try to avoid checking for flags, width or precision
-			 */
-			if (isascii((int)*fmt) && !islower((int)*fmt)) {
-				/*
-				 * Recognize flags: -, #, BLANK, +
-				 */
-				for (;; fmt++) {
-					if (*fmt == '-')
-						adjust = LEFT;
-					else if (*fmt == '+')
-						print_sign = YES;
-					else if (*fmt == '#')
-						alternate_form = YES;
-					else if (*fmt == ' ')
-						print_blank = YES;
-					else if (*fmt == '0')
-						pad_char = '0';
-					else
-						break;
-				}
-
-				/*
-				 * Check if a width was specified
-				 */
-				if (isdigit((int)*fmt)) {
-					STR_TO_DEC(fmt, min_width);
-					adjust_width = YES;
-				} else if (*fmt == '*') {
-					min_width = va_arg(ap, int);
-					fmt++;
-					adjust_width = YES;
-					if (min_width < 0) {
-						adjust = LEFT;
-						min_width = -min_width;
-					}
-				} else
-					adjust_width = NO;
-
-				/*
-				 * Check if a precision was specified
-				 */
-				if (*fmt == '.') {
-					adjust_precision = YES;
-					fmt++;
-					if (isdigit((int)*fmt)) {
-						STR_TO_DEC(fmt, precision);
-					} else if (*fmt == '*') {
-						precision = va_arg(ap, int);
-						fmt++;
-						if (precision < 0)
-							precision = 0;
-					} else
-						precision = 0;
-
-					if (precision > FORMAT_CONV_MAX_PRECISION && *fmt != 's' && *fmt != 'v' && *fmt != 'b') {
-						precision = FORMAT_CONV_MAX_PRECISION;
-					}
-				} else
-					adjust_precision = NO;
-			} else
-				adjust_precision = adjust_width = NO;
-
-			/*
-			 * Modifier check
-			 */
-			switch (*fmt) {
-				case 'L':
-					fmt++;
-					modifier = LM_LONG_DOUBLE;
-					break;
-				case 'I':
-					fmt++;
-#if SIZEOF_LONG_LONG
-					if (*fmt == '6' && *(fmt+1) == '4') {
-						fmt += 2;
-						modifier = LM_LONG_LONG;
-					} else
-#endif
-						if (*fmt == '3' && *(fmt+1) == '2') {
-							fmt += 2;
-							modifier = LM_LONG;
-						} else {
-#ifdef _WIN64
-							modifier = LM_LONG_LONG;
-#else
-							modifier = LM_LONG;
-#endif
-						}
-					break;
-				case 'l':
-					fmt++;
-#if SIZEOF_LONG_LONG
-					if (*fmt == 'l') {
-						fmt++;
-						modifier = LM_LONG_LONG;
-					} else
-#endif
-						modifier = LM_LONG;
-					break;
-					case 'z':
-					fmt++;
-					modifier = LM_SIZE_T;
-					break;
-				case 'j':
-					fmt++;
-#if SIZEOF_INTMAX_T
-					modifier = LM_INTMAX_T;
-#else
-					modifier = LM_SIZE_T;
-#endif
-					break;
-				case 't':
-					fmt++;
-#if SIZEOF_PTRDIFF_T
-					modifier = LM_PTRDIFF_T;
-#else
-					modifier = LM_SIZE_T;
-#endif
-					break;
-				case 'h':
-					fmt++;
-					if (*fmt == 'h') {
-						fmt++;
-					}
-					/* these are promoted to int, so no break */
-				default:
-					modifier = LM_STD;
-					break;
-			}
-
-			/*
-			 * Argument extraction and printing.
-			 * First we determine the argument type.
-			 * Then, we convert the argument to a string.
-			 * On exit from the switch, s points to the string that
-			 * must be printed, s_len has the length of the string
-			 * The precision requirements, if any, are reflected in s_len.
-			 *
-			 * NOTE: pad_char may be set to '0' because of the 0 flag.
-			 *   It is reset to ' ' by non-numeric formats
-			 */
-			switch (*fmt) {
-				case 'Z':
-					zvp = (zval*) va_arg(ap, zval*);
-					zend_make_printable_zval(zvp, &zcopy, &free_zcopy);
-					if (free_zcopy) {
-						zvp = &zcopy;
-					}
-					s_len = Z_STRLEN_P(zvp);
-					s = Z_STRVAL_P(zvp);
-					if (adjust_precision && precision < s_len) {
-						s_len = precision;
-					}
-					break;
-				case 'u':
-					switch(modifier) {
-						default:
-							i_num = (wide_int) va_arg(ap, unsigned int);
-							break;
-						case LM_LONG_DOUBLE:
-							goto fmt_error;
-						case LM_LONG:
-							i_num = (wide_int) va_arg(ap, unsigned long int);
-							break;
-						case LM_SIZE_T:
-							i_num = (wide_int) va_arg(ap, size_t);
-							break;
-#if SIZEOF_LONG_LONG
-						case LM_LONG_LONG:
-							i_num = (wide_int) va_arg(ap, u_wide_int);
-							break;
-#endif
-#if SIZEOF_INTMAX_T
-						case LM_INTMAX_T:
-							i_num = (wide_int) va_arg(ap, uintmax_t);
-							break;
-#endif
-#if SIZEOF_PTRDIFF_T
-						case LM_PTRDIFF_T:
-							i_num = (wide_int) va_arg(ap, ptrdiff_t);
-							break;
-#endif
-					}
-					/*
-					 * The rest also applies to other integer formats, so fall
-					 * into that case.
-					 */
-				case 'd':
-				case 'i':
-					/*
-					 * Get the arg if we haven't already.
-					 */
-					if ((*fmt) != 'u') {
-						switch(modifier) {
-							default:
-								i_num = (wide_int) va_arg(ap, int);
-								break;
-							case LM_LONG_DOUBLE:
-								goto fmt_error;
-							case LM_LONG:
-								i_num = (wide_int) va_arg(ap, long int);
-								break;
-							case LM_SIZE_T:
-#if SIZEOF_SSIZE_T
-								i_num = (wide_int) va_arg(ap, ssize_t);
-#else
-								i_num = (wide_int) va_arg(ap, size_t);
-#endif
-								break;
-#if SIZEOF_LONG_LONG
-							case LM_LONG_LONG:
-								i_num = (wide_int) va_arg(ap, wide_int);
-								break;
-#endif
-#if SIZEOF_INTMAX_T
-							case LM_INTMAX_T:
-								i_num = (wide_int) va_arg(ap, intmax_t);
-								break;
-#endif
-#if SIZEOF_PTRDIFF_T
-							case LM_PTRDIFF_T:
-								i_num = (wide_int) va_arg(ap, ptrdiff_t);
-								break;
-#endif
-						}
-					}
-					s = ap_php_conv_10(i_num, (*fmt) == 'u', &is_negative,
-								&num_buf[NUM_BUF_SIZE], &s_len);
-					FIX_PRECISION(adjust_precision, precision, s, s_len);
-
-					if (*fmt != 'u') {
-						if (is_negative) {
-							prefix_char = '-';
-						} else if (print_sign) {
-							prefix_char = '+';
-						} else if (print_blank) {
-							prefix_char = ' ';
-						}
-					}
-					break;
-
-
-				case 'o':
-					switch(modifier) {
-						default:
-							ui_num = (u_wide_int) va_arg(ap, unsigned int);
-							break;
-						case LM_LONG_DOUBLE:
-							goto fmt_error;
-						case LM_LONG:
-							ui_num = (u_wide_int) va_arg(ap, unsigned long int);
-							break;
-						case LM_SIZE_T:
-							ui_num = (u_wide_int) va_arg(ap, size_t);
-							break;
-#if SIZEOF_LONG_LONG
-						case LM_LONG_LONG:
-							ui_num = (u_wide_int) va_arg(ap, u_wide_int);
-							break;
-#endif
-#if SIZEOF_INTMAX_T
-						case LM_INTMAX_T:
-							ui_num = (u_wide_int) va_arg(ap, uintmax_t);
-							break;
-#endif
-#if SIZEOF_PTRDIFF_T
-						case LM_PTRDIFF_T:
-							ui_num = (u_wide_int) va_arg(ap, ptrdiff_t);
-							break;
-#endif
-					}
-					s = ap_php_conv_p2(ui_num, 3, *fmt, &num_buf[NUM_BUF_SIZE], &s_len);
-					FIX_PRECISION(adjust_precision, precision, s, s_len);
-					if (alternate_form && *s != '0') {
-						*--s = '0';
-						s_len++;
-					}
-					break;
-
-
-				case 'x':
-				case 'X':
-					switch(modifier) {
-						default:
-							ui_num = (u_wide_int) va_arg(ap, unsigned int);
-							break;
-						case LM_LONG_DOUBLE:
-							goto fmt_error;
-						case LM_LONG:
-							ui_num = (u_wide_int) va_arg(ap, unsigned long int);
-							break;
-						case LM_SIZE_T:
-							ui_num = (u_wide_int) va_arg(ap, size_t);
-							break;
-#if SIZEOF_LONG_LONG
-						case LM_LONG_LONG:
-							ui_num = (u_wide_int) va_arg(ap, u_wide_int);
-							break;
-#endif
-#if SIZEOF_INTMAX_T
-						case LM_INTMAX_T:
-							ui_num = (u_wide_int) va_arg(ap, uintmax_t);
-							break;
-#endif
-#if SIZEOF_PTRDIFF_T
-						case LM_PTRDIFF_T:
-							ui_num = (u_wide_int) va_arg(ap, ptrdiff_t);
-							break;
-#endif
-					}
-					s = ap_php_conv_p2(ui_num, 4, *fmt, &num_buf[NUM_BUF_SIZE], &s_len);
-					FIX_PRECISION(adjust_precision, precision, s, s_len);
-					if (alternate_form && i_num != 0) {
-						*--s = *fmt;	/* 'x' or 'X' */
-						*--s = '0';
-						s_len += 2;
-					}
-					break;
-
-
-				case 's':
-				case 'v':
-					s = va_arg(ap, char *);
-					if (s != NULL) {
-						if (adjust_precision) {
-							s_len = precision;
-						} else {
-							s_len = strlen(s);
-						}
-
-						if (escape_xml) {
-							/* added: support for xml escaping */
-
-							int old_slen = s_len, i = 0;
-							char *old_s = s, *s_ptr;
-							free_s = s_ptr = s = emalloc(old_slen * 6 + 1);
-							do {
-								if (old_s[i] == '&' || old_s[i] == '"' || old_s[i] == '<') {
-									*s_ptr++ = '&';
-									switch (old_s[i]) {
-										case '"':
-											s_len += 5;
-											*s_ptr++ = 'q';
-											*s_ptr++ = 'u';
-											*s_ptr++ = 'o';
-											*s_ptr++ = 't';
-											break;
-										case '<':
-											s_len += 3;
-											*s_ptr++ = 'l';
-											*s_ptr++ = 't';
-											break;
-										case '&':
-											s_len += 4;
-											*s_ptr++ = 'a';
-											*s_ptr++ = 'm';
-											*s_ptr++ = 'p';
-											break;
-									}
-									*s_ptr++ = ';';
-								} else {
-									*s_ptr++ = old_s[i];
-								}
-							} while (i++ < old_slen);
-						}
-					} else {
-						s = S_NULL;
-						s_len = S_NULL_LEN;
-					}
-					pad_char = ' ';
-					break;
-
-
-				case 'b':
-					if (escape_xml) {
-						s = PHPDBG_G(err_buf).xml;
-					} else {
-						s = PHPDBG_G(err_buf).msg;
-					}
-
-					if (s != NULL) {
-						if (escape_xml) {
-							s_len = PHPDBG_G(err_buf).xmllen;
-						} else {
-							s_len = PHPDBG_G(err_buf).msglen;
-						}
-
-						if (adjust_precision && precision != s_len) {
-							s_len = precision;
-						}
-					} else {
-						s = "";
-						s_len = 0;
-					}
-					pad_char = ' ';
-					break;
-
-
-				case 'r':
-					if (PHPDBG_G(req_id)) {
-						s_len = spprintf(&s, 0, "req=\"%lu\"", PHPDBG_G(req_id));
-						free_s = s;
-					} else {
-						s = "";
-						s_len = 0;
-					}
-					break;
-
-
-				case 'f':
-				case 'F':
-				case 'e':
-				case 'E':
-
-					switch(modifier) {
-						case LM_LONG_DOUBLE:
-							fp_num = (double) va_arg(ap, long double);
-							break;
-						case LM_STD:
-							fp_num = va_arg(ap, double);
-							break;
-						default:
-							goto fmt_error;
-					}
-
-					if (zend_isnan(fp_num)) {
-						s = "NAN";
-						s_len = 3;
-					} else if (zend_isinf(fp_num)) {
-						s = "INF";
-						s_len = 3;
-					} else {
-#ifdef HAVE_LOCALE_H
-						if (!lconv) {
-							lconv = localeconv();
-						}
-#endif
-						s = php_conv_fp((*fmt == 'f')?'F':*fmt, fp_num, alternate_form,
-						 (adjust_precision == NO) ? FLOAT_DIGITS : precision,
-						 (*fmt == 'f')?LCONV_DECIMAL_POINT:'.',
-									&is_negative, &num_buf[1], &s_len);
-						if (is_negative)
-							prefix_char = '-';
-						else if (print_sign)
-							prefix_char = '+';
-						else if (print_blank)
-							prefix_char = ' ';
-					}
-					break;
-
-
-				case 'g':
-				case 'k':
-				case 'G':
-				case 'H':
-					switch(modifier) {
-						case LM_LONG_DOUBLE:
-							fp_num = (double) va_arg(ap, long double);
-							break;
-						case LM_STD:
-							fp_num = va_arg(ap, double);
-							break;
-						default:
-							goto fmt_error;
-					}
-
-					if (zend_isnan(fp_num)) {
-						s = "NAN";
-						s_len = 3;
-						break;
-					} else if (zend_isinf(fp_num)) {
-						if (fp_num > 0) {
-							s = "INF";
-							s_len = 3;
-						} else {
-							s = "-INF";
-							s_len = 4;
-						}
-						break;
-					}
-
-					if (adjust_precision == NO) {
-						precision = FLOAT_DIGITS;
-					} else if (precision == 0) {
-						precision = 1;
-					}
-					/*
-					 * * We use &num_buf[ 1 ], so that we have room for the sign
-					 */
-#ifdef HAVE_LOCALE_H
-					if (!lconv) {
-						lconv = localeconv();
-					}
-#endif
-					s = php_gcvt(fp_num, precision, (*fmt=='H' || *fmt == 'k') ? '.' : LCONV_DECIMAL_POINT, (*fmt == 'G' || *fmt == 'H')?'E':'e', &num_buf[1]);
-					if (*s == '-') {
-						prefix_char = *s++;
-					} else if (print_sign) {
-						prefix_char = '+';
-					} else if (print_blank) {
-						prefix_char = ' ';
-					}
-
-					s_len = strlen(s);
-
-					if (alternate_form && (strchr(s, '.')) == NULL) {
-						s[s_len++] = '.';
-					}
-					break;
-
-
-				case 'c':
-					char_buf[0] = (char) (va_arg(ap, int));
-					s = &char_buf[0];
-					s_len = 1;
-					pad_char = ' ';
-					break;
-
-
-				case '%':
-					char_buf[0] = '%';
-					s = &char_buf[0];
-					s_len = 1;
-					pad_char = ' ';
-					break;
-
-
-				case 'n':
-					*(va_arg(ap, int *)) = cc;
-					goto skip_output;
-
-					/*
-					 * Always extract the argument as a "char *" pointer. We
-					 * should be using "void *" but there are still machines
-					 * that don't understand it.
-					 * If the pointer size is equal to the size of an unsigned
-					 * integer we convert the pointer to a hex number, otherwise
-					 * we print "%p" to indicate that we don't handle "%p".
-					 */
-				case 'p':
-					if (sizeof(char *) <= sizeof(u_wide_int)) {
-						ui_num = (u_wide_int)((size_t) va_arg(ap, char *));
-						s = ap_php_conv_p2(ui_num, 4, 'x',
-								&num_buf[NUM_BUF_SIZE], &s_len);
-						if (ui_num != 0) {
-							*--s = 'x';
-							*--s = '0';
-							s_len += 2;
-						}
-					} else {
-						s = "%p";
-						s_len = 2;
-					}
-					pad_char = ' ';
-					break;
-
-
-				case NUL:
-					/*
-					 * The last character of the format string was %.
-					 * We ignore it.
-					 */
-					continue;
-
-
-fmt_error:
-				php_error(E_ERROR, "Illegal length modifier specified '%c' in s[np]printf call", *fmt);
-					/*
-					 * The default case is for unrecognized %'s.
-					 * We print %<char> to help the user identify what
-					 * option is not understood.
-					 * This is also useful in case the user wants to pass
-					 * the output of format_converter to another function
-					 * that understands some other %<char> (like syslog).
-					 * Note that we can't point s inside fmt because the
-					 * unknown <char> could be preceded by width etc.
-					 */
-				default:
-					char_buf[0] = '%';
-					char_buf[1] = *fmt;
-					s = char_buf;
-					s_len = 2;
-					pad_char = ' ';
-					break;
-			}
-
-			if (prefix_char != NUL) {
-				*--s = prefix_char;
-				s_len++;
-			}
-			if (adjust_width && adjust == RIGHT && min_width > s_len) {
-				if (pad_char == '0' && prefix_char != NUL) {
-					INS_CHAR(*s, sp, bep, cc)
-						s++;
-					s_len--;
-					min_width--;
-				}
-				PAD(min_width, s_len, pad_char);
-			}
-			/*
-			 * Print the string s.
-			 */
-			for (i = s_len; i != 0; i--) {
-				INS_CHAR(*s, sp, bep, cc);
-				s++;
-			}
-
-			if (adjust_width && adjust == LEFT && min_width > s_len)
-				PAD(min_width, s_len, pad_char);
-			if (free_zcopy) {
-				zval_dtor(&zcopy);
-			}
-		}
-skip_output:
-		if (free_s) {
-			efree(free_s);
-			free_s = NULL;
-		}
-
-		fmt++;
-	}
-	odp->nextb = sp;
-	return (cc);
-}
-
-static void strx_printv(int *ccp, char *buf, size_t len, const char *format, zend_bool escape_xml, va_list ap TSRMLS_DC) {
-	buffy od;
-	int cc;
-
-	/*
-	 * First initialize the descriptor
-	 * Notice that if no length is given, we initialize buf_end to the
-	 * highest possible address.
-	 */
-	if (len == 0) {
-		od.buf_end = (char *) ~0;
-		od.nextb   = (char *) ~0;
-	} else {
-		od.buf_end = &buf[len-1];
-		od.nextb   = buf;
-	}
-
-	/*
-	 * Do the conversion
-	 */
-	cc = format_converter(&od, format, escape_xml, ap TSRMLS_CC);
-	if (len != 0 && od.nextb <= od.buf_end) {
-		*(od.nextb) = '\0';
-	}
-	if (ccp) {
-		*ccp = cc;
-	}
-}
-
-static int phpdbg_xml_vsnprintf(char *buf, size_t len, const char *format, zend_bool escape_xml, va_list ap TSRMLS_DC) {
-	int cc;
-
-	strx_printv(&cc, buf, len, format, escape_xml, ap TSRMLS_CC);
-	return (cc);
-}
-
-PHPDBG_API int phpdbg_xml_vasprintf(char **buf, const char *format, zend_bool escape_xml, va_list ap TSRMLS_DC) {
-	va_list ap2;
-	int cc;
-
-	va_copy(ap2, ap);
-	cc = phpdbg_xml_vsnprintf(NULL, 0, format, escape_xml, ap2 TSRMLS_CC);
-	va_end(ap2);
-
-	*buf = NULL;
-
-	if (cc >= 0) {
-		if ((*buf = emalloc(++cc)) != NULL) {
-			if ((cc = phpdbg_xml_vsnprintf(*buf, cc, format, escape_xml, ap TSRMLS_CC)) < 0) {
-				efree(*buf);
-				*buf = NULL;
-			}
-		}
-	}
-
-	return cc;
-}
-/* copy end */
-
-PHPDBG_API int _phpdbg_xml_asprintf(char **buf TSRMLS_DC, const char *format, zend_bool escape_xml, ...) {
-	int ret;
-	va_list va;
-
-	va_start(va, escape_xml);
-	ret = phpdbg_xml_vasprintf(buf, format, escape_xml, va TSRMLS_CC);
-	va_end(va);
-
-	return ret;
-}
-
-PHPDBG_API int _phpdbg_asprintf(char **buf TSRMLS_DC, const char *format, ...) {
-	int ret;
-	va_list va;
-
-	va_start(va, format);
-	ret = phpdbg_xml_vasprintf(buf, format, 0, va TSRMLS_CC);
-	va_end(va);
-
-	return ret;
-}
-
-static int phpdbg_encode_xml(char **buf, char *msg, int msglen, int from, char *to) {
-	int i;
-	int tolen = to ? strlen(to) : 5;
-	char *tmp = *buf = emalloc(msglen * tolen);
-	for (i = 0; i++ < msglen; msg++) {
-		if (*msg == '&') {
-			memcpy(tmp, ZEND_STRL("&amp;"));
-			tmp += sizeof("&amp;") - 1;
-		} else if (*msg == '<') {
-			memcpy(tmp, ZEND_STRL("&lt;"));
-			tmp += sizeof("&lt;") - 1;
-		} else if (((int) *msg) == from) {
-			memcpy(tmp, to, tolen);
-			tmp += tolen;
-		} else {
-			*tmp++ = *msg;
-		}
-	}
-
-	{
-		int len = tmp - *buf;
-		*buf = erealloc(*buf, len + 1);
-		return len;
-	}
-}
-
-static void phpdbg_encode_ctrl_chars(char **buf, int *buflen) {
-	char *tmp, *tmpptr;
-	int len;
-	int i;
-
-	tmp = tmpptr = emalloc(*buflen * 5);
-
-	for (i = 0; i < *buflen; i++) {
-		if ((*buf)[i] < 0x20) {
-			*tmpptr++ = '&';
-			*tmpptr++ = '#';
-			if ((unsigned int) ((*buf)[i]) > 9) {
-				*tmpptr++ = ((*buf)[i] / 10) + '0';
-			}
-			*tmpptr++ = ((*buf)[i] % 10) + '0';
-			*tmpptr++ = ';';
-		} else {
-			*tmpptr++ = (*buf)[i];
-		}
-	}
-
-	len = tmpptr - tmp;
-
-	efree(*buf);
-	*buf = erealloc(tmp, len + 1);
-	*buflen = len;
-}
-
-static int phpdbg_process_print(int fd, int type, const char *tag, const char *msg, int msglen, const char *xml, int xmllen TSRMLS_DC) {
-	char *msgout = NULL, *buf;
-	int msgoutlen, xmloutlen, buflen;
-	const char *severity;
-
-	if ((PHPDBG_G(flags) & PHPDBG_WRITE_XML) && PHPDBG_G(in_script_xml) && PHPDBG_G(in_script_xml) != type) {
-		phpdbg_mixed_write(fd, ZEND_STRL("</stream>") TSRMLS_CC);
-		PHPDBG_G(in_script_xml) = 0;
-	}
-
-	switch (type) {
-		case P_ERROR:
-			severity = "error";
-			if (!PHPDBG_G(last_was_newline)) {
-				if (PHPDBG_G(flags) & PHPDBG_WRITE_XML) {
-					phpdbg_mixed_write(fd, ZEND_STRL("<phpdbg>\n" "</phpdbg>") TSRMLS_CC);
-				} else {
-					phpdbg_mixed_write(fd, ZEND_STRL("\n") TSRMLS_CC);
-				}
-				PHPDBG_G(last_was_newline) = 1;
-			}
-			if (PHPDBG_G(flags) & PHPDBG_IS_COLOURED) {
-				msgoutlen = phpdbg_asprintf(&msgout, "\033[%sm[%.*s]\033[0m\n", PHPDBG_G(colors)[PHPDBG_COLOR_ERROR]->code, msglen, msg);
-			} else {
-				msgoutlen = phpdbg_asprintf(&msgout, "[%.*s]\n", msglen, msg);
-			}
-			break;
-
-		case P_NOTICE:
-			severity = "notice";
-			if (!PHPDBG_G(last_was_newline)) {
-				if (PHPDBG_G(flags) & PHPDBG_WRITE_XML) {
-					phpdbg_mixed_write(fd, ZEND_STRL("<phpdbg>\n" "</phpdbg>") TSRMLS_CC);
-				} else {
-					phpdbg_mixed_write(fd, ZEND_STRL("\n") TSRMLS_CC);
-				}
-				PHPDBG_G(last_was_newline) = 1;
-			}
-			if (PHPDBG_G(flags) & PHPDBG_IS_COLOURED) {
-				msgoutlen = phpdbg_asprintf(&msgout, "\033[%sm[%.*s]\033[0m\n", PHPDBG_G(colors)[PHPDBG_COLOR_NOTICE]->code, msglen, msg);
-			} else {
-				msgoutlen = phpdbg_asprintf(&msgout, "[%.*s]\n", msglen, msg);
-			}
-			break;
-
-		case P_WRITELN:
-			severity = "normal";
-			if (msg) {
-				msgoutlen = phpdbg_asprintf(&msgout, "%.*s\n", msglen, msg);
-			} else {
-				msgoutlen = 1;
-				msgout = estrdup("\n");
-			}
-			PHPDBG_G(last_was_newline) = 1;
-			break;
-
-		case P_WRITE:
-			severity = "normal";
-			if (msg) {
-				msgout = estrndup(msg, msglen);
-				msgoutlen = msglen;
-				PHPDBG_G(last_was_newline) = msg[msglen - 1] == '\n';
-			} else {
-				msgoutlen = 0;
-				msgout = estrdup("");
-			}
-			break;
-
-		case P_STDOUT:
-		case P_STDERR:
-			if (msg) {
-				PHPDBG_G(last_was_newline) = msg[msglen - 1] == '\n';
-				if (PHPDBG_G(flags) & PHPDBG_WRITE_XML) {
-					if (PHPDBG_G(in_script_xml) != type) {
-						char *stream_buf;
-						int stream_buflen = phpdbg_asprintf(&stream_buf, "<stream type=\"%s\">", type == P_STDERR ? "stderr" : "stdout");
-						phpdbg_mixed_write(fd, stream_buf, stream_buflen TSRMLS_CC);
-						efree(stream_buf);
-						PHPDBG_G(in_script_xml) = type;
-					}
-#if PHP_VERSION_ID >= 50600
-					buf = php_escape_html_entities((unsigned char *) msg, msglen, (size_t *) &buflen, 0, ENT_NOQUOTES, PG(internal_encoding) && PG(internal_encoding)[0] ? PG(internal_encoding) : (SG(default_charset) ? SG(default_charset) : "UTF-8") TSRMLS_CC);
-#else
-					buf = php_escape_html_entities((unsigned char *) msg, msglen, (size_t *) &buflen, 0, ENT_NOQUOTES, SG(default_charset) ? SG(default_charset) : "UTF-8" TSRMLS_CC);
-#endif
-					phpdbg_encode_ctrl_chars(&buf, &buflen);
-					phpdbg_mixed_write(fd, buf, buflen TSRMLS_CC);
-					efree(buf);
-				} else {
-					phpdbg_mixed_write(fd, msg, msglen TSRMLS_CC);
-				}
-				return msglen;
-			}
-		break;
-
-		/* no formatting on logging output */
-		case P_LOG:
-			severity = "log";
-			if (msg) {
-				struct timeval tp;
-				if (gettimeofday(&tp, NULL) == SUCCESS) {
-					msgoutlen = phpdbg_asprintf(&msgout, "[%ld %.8F]: %.*s\n", tp.tv_sec, tp.tv_usec / 1000000., msglen, msg);
-				} else {
-					msgoutlen = FAILURE;
-				}
-			}
-			break;
-	}
-
-	if (PHPDBG_G(flags) & PHPDBG_WRITE_XML) {
-		char *xmlout;
-
-		if (PHPDBG_G(req_id)) {
-			char *xmlbuf = NULL;
-			xmllen = phpdbg_asprintf(&xmlbuf, "req=\"%lu\" %.*s", PHPDBG_G(req_id), xmllen, xml);
-			xml = xmlbuf;
-		}
-		if (msgout) {
-			buflen = phpdbg_encode_xml(&buf, msgout, msgoutlen, '"', "&quot;");
-			xmloutlen = phpdbg_asprintf(&xmlout, "<%s severity=\"%s\" %.*s msgout=\"%.*s\" />", tag, severity, xmllen, xml, buflen, buf);
-
-			efree(buf);
-		} else {
-			xmloutlen = phpdbg_asprintf(&xmlout, "<%s severity=\"%s\" %.*s msgout=\"\" />", tag, severity, xmllen, xml);
-		}
-
-		phpdbg_encode_ctrl_chars(&xmlout, &xmloutlen);
-		phpdbg_eol_convert(&xmlout, &xmloutlen TSRMLS_CC);
-		phpdbg_mixed_write(fd, xmlout, xmloutlen TSRMLS_CC);
-		efree(xmlout);
-	} else if (msgout) {
-		phpdbg_eol_convert(&msgout, &msgoutlen TSRMLS_CC);
-		phpdbg_mixed_write(fd, msgout, msgoutlen TSRMLS_CC);
-	}
-
-	if (PHPDBG_G(req_id) && (PHPDBG_G(flags) & PHPDBG_WRITE_XML)) {
-		efree((char *) xml);
-	}
-
-	if (msgout) {
-		efree(msgout);
-	}
-
-	return msgout ? msgoutlen : xmloutlen;
-} /* }}} */
-
-PHPDBG_API int phpdbg_vprint(int type TSRMLS_DC, int fd, const char *tag, const char *xmlfmt, const char *strfmt, va_list args) {
-	char *msg = NULL, *xml = NULL;
-	int msglen = 0, xmllen = 0;
-	int len;
-	va_list argcpy;
-
-	if (strfmt != NULL && strlen(strfmt) > 0L) {
-		va_copy(argcpy, args);
-		msglen = phpdbg_xml_vasprintf(&msg, strfmt, 0, argcpy TSRMLS_CC);
-		va_end(argcpy);
-	}
-
-	if (PHPDBG_G(flags) & PHPDBG_WRITE_XML) {
-		if (xmlfmt != NULL && strlen(xmlfmt) > 0L) {
-			va_copy(argcpy, args);
-			xmllen = phpdbg_xml_vasprintf(&xml, xmlfmt, 1, argcpy TSRMLS_CC);
-			va_end(argcpy);
-		} else {
-			xml = estrdup("");
-		}
-	}
-
-	if (PHPDBG_G(err_buf).active && type != P_STDOUT && type != P_STDERR) {
-		phpdbg_free_err_buf(TSRMLS_C);
-
-		PHPDBG_G(err_buf).type = type;
-		PHPDBG_G(err_buf).fd = fd;
-		PHPDBG_G(err_buf).tag = estrdup(tag);
-		PHPDBG_G(err_buf).msg = msg;
-		PHPDBG_G(err_buf).msglen = msglen;
-		if (PHPDBG_G(flags) & PHPDBG_WRITE_XML) {
-			PHPDBG_G(err_buf).xml = xml;
-			PHPDBG_G(err_buf).xmllen = xmllen;
-		}
-
-		return msglen;
-	}
-
-	len = phpdbg_process_print(fd, type, tag, msg, msglen, xml, xmllen TSRMLS_CC);
-
-	if (msg) {
-		efree(msg);
-	}
-
-	if (xml) {
-		efree(xml);
-	}
-
-	return len;
-}
-
-PHPDBG_API void phpdbg_free_err_buf(TSRMLS_D) {
-	if (PHPDBG_G(err_buf).type == 0) {
-		return;
-	}
-
-	PHPDBG_G(err_buf).type = 0;
-
-	efree(PHPDBG_G(err_buf).tag);
-	efree(PHPDBG_G(err_buf).msg);
-	if (PHPDBG_G(flags) & PHPDBG_WRITE_XML) {
-		efree(PHPDBG_G(err_buf).xml);
-	}
-}
-
-PHPDBG_API void phpdbg_activate_err_buf(zend_bool active TSRMLS_DC) {
-	PHPDBG_G(err_buf).active = active;
-}
-
-PHPDBG_API int phpdbg_output_err_buf(const char *tag, const char *xmlfmt, const char *strfmt TSRMLS_DC, ...) {
-	int len;
-	va_list args;
-	int errbuf_active = PHPDBG_G(err_buf).active;
-
-	if (PHPDBG_G(flags) & PHPDBG_DISCARD_OUTPUT) {
-		return 0;
-	}
-
-	PHPDBG_G(err_buf).active = 0;
-
-#ifdef ZTS
-	va_start(args, tsrm_ls);
-#else
-	va_start(args, strfmt);
-#endif
-	len = phpdbg_vprint(PHPDBG_G(err_buf).type TSRMLS_CC, PHPDBG_G(err_buf).fd, tag ? tag : PHPDBG_G(err_buf).tag, xmlfmt, strfmt, args);
-	va_end(args);
-
-	PHPDBG_G(err_buf).active = errbuf_active;
-	phpdbg_free_err_buf(TSRMLS_C);
-
-	return len;
-}
-
-PHPDBG_API int phpdbg_print(int type TSRMLS_DC, int fd, const char *tag, const char *xmlfmt, const char *strfmt, ...) {
-	va_list args;
-	int len;
-
-	if (PHPDBG_G(flags) & PHPDBG_DISCARD_OUTPUT) {
-		return 0;
-	}
-
-	va_start(args, strfmt);
-	len = phpdbg_vprint(type TSRMLS_CC, fd, tag, xmlfmt, strfmt, args);
-	va_end(args);
-
-	return len;
-}
-
-PHPDBG_API int phpdbg_xml_internal(int fd TSRMLS_DC, const char *fmt, ...) {
-	int len = 0;
-
-	if (PHPDBG_G(flags) & PHPDBG_DISCARD_OUTPUT) {
-		return 0;
-	}
-
-	if (PHPDBG_G(flags) & PHPDBG_WRITE_XML) {
-		va_list args;
-		char *buffer;
-		int buflen;
-
-		va_start(args, fmt);
-		buflen = phpdbg_xml_vasprintf(&buffer, fmt, 1, args TSRMLS_CC);
-		va_end(args);
-
-		phpdbg_encode_ctrl_chars(&buffer, &buflen);
-
-		if (PHPDBG_G(in_script_xml)) {
-			phpdbg_mixed_write(fd, ZEND_STRL("</stream>") TSRMLS_CC);
-			PHPDBG_G(in_script_xml) = 0;
-		}
-
-		len = phpdbg_mixed_write(fd, buffer, buflen TSRMLS_CC);
-		efree(buffer);
-	}
-
-	return len;
-}
-
-PHPDBG_API int phpdbg_log_internal(int fd TSRMLS_DC, const char *fmt, ...) {
-	va_list args;
-	char *buffer;
-	int buflen;
-	int len = 0;
-
-	va_start(args, fmt);
-	buflen = phpdbg_xml_vasprintf(&buffer, fmt, 0, args TSRMLS_CC);
-	va_end(args);
-
-	len = phpdbg_mixed_write(fd, buffer, buflen TSRMLS_CC);
-	efree(buffer);
-
-	return len;
-}
-
-PHPDBG_API int phpdbg_out_internal(int fd TSRMLS_DC, const char *fmt, ...) {
-	va_list args;
-	char *buffer;
-	int buflen;
-	int len = 0;
-
-	if (PHPDBG_G(flags) & PHPDBG_DISCARD_OUTPUT) {
-		return 0;
-	}
-
-	va_start(args, fmt);
-	buflen = phpdbg_xml_vasprintf(&buffer, fmt, 0, args TSRMLS_CC);
-	va_end(args);
-
-	if (PHPDBG_G(flags) & PHPDBG_WRITE_XML) {
-		char *msg;
-		int msglen;
-
-		msglen = phpdbg_encode_xml(&msg, buffer, buflen, 256, NULL);
-		phpdbg_encode_ctrl_chars(&msg, &msglen);
-		phpdbg_eol_convert(&msg, &msglen TSRMLS_CC);
-
-		if (PHPDBG_G(in_script_xml)) {
-			phpdbg_mixed_write(fd, ZEND_STRL("</stream>") TSRMLS_CC);
-			PHPDBG_G(in_script_xml) = 0;
-		}
-
-		phpdbg_mixed_write(fd, ZEND_STRL("<phpdbg>") TSRMLS_CC);
-		len = phpdbg_mixed_write(fd, msg, msglen TSRMLS_CC);
-		phpdbg_mixed_write(fd, ZEND_STRL("</phpdbg>") TSRMLS_CC);
-	} else {
-		phpdbg_eol_convert(&buffer, &buflen TSRMLS_CC);
-		len = phpdbg_mixed_write(fd, buffer, buflen TSRMLS_CC);
-	}
-
-	return len;
-}
-
-
-PHPDBG_API int phpdbg_rlog_internal(int fd TSRMLS_DC, const char *fmt, ...) { /* {{{ */
-	int rc = 0;
-
-	va_list args;
-	struct timeval tp;
-
-	va_start(args, fmt);
-	if (gettimeofday(&tp, NULL) == SUCCESS) {
-		char friendly[100];
-		char *format = NULL, *buffer = NULL, *outbuf = NULL;
-		const time_t tt = tp.tv_sec;
-
-#ifdef PHP_WIN32
-		strftime(friendly, 100, "%a %b %d %H.%%04d %Y", localtime(&tt));
-#else
-		strftime(friendly, 100, "%a %b %d %T.%%04d %Y", localtime(&tt));
-#endif
-		phpdbg_asprintf(&buffer, friendly, tp.tv_usec/1000);
-		phpdbg_asprintf(&format, "[%s]: %s\n", buffer, fmt);
-		rc = phpdbg_xml_vasprintf(&outbuf, format, 0, args TSRMLS_CC);
-
-		if (outbuf) {
-			rc = phpdbg_mixed_write(fd, outbuf, rc TSRMLS_CC);
-			efree(outbuf);
-		}
-
-		efree(format);
-		efree(buffer);
-	}
-	va_end(args);
-
-	return rc;
-} /* }}} */
diff --git a/sapi/phpdbg/phpdbg_out.h b/sapi/phpdbg/phpdbg_out.h
deleted file mode 100644
index ea25b04279..0000000000
--- a/sapi/phpdbg/phpdbg_out.h
+++ /dev/null
@@ -1,93 +0,0 @@
-/*
-   +----------------------------------------------------------------------+
-   | PHP Version 5                                                        |
-   +----------------------------------------------------------------------+
-   | Copyright (c) 1997-2014 The PHP Group                                |
-   +----------------------------------------------------------------------+
-   | This source file is subject to version 3.01 of the PHP license,      |
-   | that is bundled with this package in the file LICENSE, and is        |
-   | available through the world-wide-web at the following url:           |
-   | http://www.php.net/license/3_01.txt                                  |
-   | If you did not receive a copy of the PHP license and are unable to   |
-   | obtain it through the world-wide-web, please send a note to          |
-   | license@php.net so we can mail you a copy immediately.               |
-   +----------------------------------------------------------------------+
-   | Authors: Felipe Pena <felipe@php.net>                                |
-   | Authors: Joe Watkins <joe.watkins@live.co.uk>                        |
-   | Authors: Bob Weinand <bwoebi@php.net>                                |
-   +----------------------------------------------------------------------+
-*/
-
-#ifndef PHPDBG_OUT_H
-#define PHPDBG_OUT_H
-
-/**
- * Error/notice/formatting helpers
- */
-enum {
-	P_ERROR  = 1,
-	P_NOTICE,
-	P_WRITELN,
-	P_WRITE,
-	P_STDOUT,
-	P_STDERR,
-	P_LOG
-};
-
-#ifdef ZTS
-PHPDBG_API int phpdbg_print(int severity TSRMLS_DC, int fd, const char *tag, const char *xmlfmt, const char *strfmt, ...) PHP_ATTRIBUTE_FORMAT(printf, 6, 7);
-PHPDBG_API int phpdbg_xml_internal(int fd TSRMLS_DC, const char *fmt, ...) PHP_ATTRIBUTE_FORMAT(printf, 3, 4);
-PHPDBG_API int phpdbg_log_internal(int fd TSRMLS_DC, const char *fmt, ...) PHP_ATTRIBUTE_FORMAT(printf, 3, 4);
-PHPDBG_API int phpdbg_out_internal(int fd TSRMLS_DC, const char *fmt, ...) PHP_ATTRIBUTE_FORMAT(printf, 3, 4);
-PHPDBG_API int phpdbg_rlog_internal(int fd TSRMLS_DC, const char *fmt, ...) PHP_ATTRIBUTE_FORMAT(printf, 3, 4);
-#else
-PHPDBG_API int phpdbg_print(int severity, int fd, const char *tag, const char *xmlfmt, const char *strfmt, ...) PHP_ATTRIBUTE_FORMAT(printf, 5, 6);
-PHPDBG_API int phpdbg_xml_internal(int fd, const char *fmt, ...) PHP_ATTRIBUTE_FORMAT(printf, 2, 3);
-PHPDBG_API int phpdbg_log_internal(int fd, const char *fmt, ...) PHP_ATTRIBUTE_FORMAT(printf, 2, 3);
-PHPDBG_API int phpdbg_out_internal(int fd, const char *fmt, ...) PHP_ATTRIBUTE_FORMAT(printf, 2, 3);
-PHPDBG_API int phpdbg_rlog_internal(int fd, const char *fmt, ...) PHP_ATTRIBUTE_FORMAT(printf, 2, 3);
-#endif
-
-
-#define phpdbg_error(tag, xmlfmt, strfmt, ...)              phpdbg_print(P_ERROR   TSRMLS_CC, PHPDBG_G(io)[PHPDBG_STDOUT].fd, tag,  xmlfmt, strfmt, ##__VA_ARGS__)
-#define phpdbg_notice(tag, xmlfmt, strfmt, ...)             phpdbg_print(P_NOTICE  TSRMLS_CC, PHPDBG_G(io)[PHPDBG_STDOUT].fd, tag,  xmlfmt, strfmt, ##__VA_ARGS__)
-#define phpdbg_writeln(tag, xmlfmt, strfmt, ...)            phpdbg_print(P_WRITELN TSRMLS_CC, PHPDBG_G(io)[PHPDBG_STDOUT].fd, tag,  xmlfmt, strfmt, ##__VA_ARGS__)
-#define phpdbg_write(tag, xmlfmt, strfmt, ...)              phpdbg_print(P_WRITE   TSRMLS_CC, PHPDBG_G(io)[PHPDBG_STDOUT].fd, tag,  xmlfmt, strfmt, ##__VA_ARGS__)
-#define phpdbg_script(type, fmt, ...)                       phpdbg_print(type      TSRMLS_CC, PHPDBG_G(io)[PHPDBG_STDOUT].fd, NULL, NULL,   fmt,    ##__VA_ARGS__)
-#define phpdbg_log(fmt, ...) phpdbg_log_internal(PHPDBG_G(io)[PHPDBG_STDOUT].fd TSRMLS_CC, fmt, ##__VA_ARGS__)
-#define phpdbg_xml(fmt, ...) phpdbg_xml_internal(PHPDBG_G(io)[PHPDBG_STDOUT].fd TSRMLS_CC, fmt, ##__VA_ARGS__)
-#define phpdbg_out(fmt, ...) phpdbg_out_internal(PHPDBG_G(io)[PHPDBG_STDOUT].fd TSRMLS_CC, fmt, ##__VA_ARGS__)
-
-#define phpdbg_error_ex(out, tag, xmlfmt, strfmt, ...)      phpdbg_print(P_ERROR   TSRMLS_CC, out, tag,  xmlfmt, strfmt, ##__VA_ARGS__)
-#define phpdbg_notice_ex(out, tag, xmlfmt, strfmt, ...)     phpdbg_print(P_NOTICE  TSRMLS_CC, out, tag,  xmlfmt, strfmt, ##__VA_ARGS__)
-#define phpdbg_writeln_ex(out, tag, xmlfmt, strfmt, ...)    phpdbg_print(P_WRITELN TSRMLS_CC, out, tag,  xmlfmt, strfmt, ##__VA_ARGS__)
-#define phpdbg_write_ex(out, tag, xmlfmt, strfmt, ...)      phpdbg_print(P_WRITE   TSRMLS_CC, out, tag,  xmlfmt, strfmt, ##__VA_ARGS__)
-#define phpdbg_script_ex(out, type, fmt, ...)               phpdbg_print(type      TSRMLS_CC, out, NULL, NULL,   fmt,    ##__VA_ARGS__)
-#define phpdbg_log_ex(out, fmt, ...) phpdbg_log_internal(PHPDBG_G(io)[PHPDBG_STDOUT].fd TSRMLS_CC, fmt, ##__VA_ARGS__)
-#define phpdbg_xml_ex(out, fmt, ...) phpdbg_xml_internal(PHPDBG_G(io)[PHPDBG_STDOUT].fd TSRMLS_CC, fmt, ##__VA_ARGS__)
-#define phpdbg_out_ex(out, fmt, ...) phpdbg_out_internal(PHPDBG_G(io)[PHPDBG_STDOUT].fd TSRMLS_CC, fmt, ##__VA_ARGS__)
-
-#define phpdbg_rlog(fd, fmt, ...) phpdbg_rlog_internal(fd TSRMLS_CC, fmt, ##__VA_ARGS__)
-
-#define phpdbg_xml_asprintf(buf, ...) _phpdbg_xml_asprintf(buf TSRMLS_CC, ##__VA_ARGS__)
-PHPDBG_API int _phpdbg_xml_asprintf(char **buf TSRMLS_DC, const char *format, zend_bool escape_xml, ...);
-
-#define phpdbg_asprintf(buf, ...) _phpdbg_asprintf(buf TSRMLS_CC, ##__VA_ARGS__)
-PHPDBG_API int _phpdbg_asprintf(char **buf TSRMLS_DC, const char *format, ...);
-
-
-#if PHPDBG_DEBUG
-#	define phpdbg_debug(fmt, ...) phpdbg_log_ex(PHPDBG_G(io)[PHPDBG_STDERR].fd TSRMLS_CC, fmt, ##__VA_ARGS__)
-#else
-#	define phpdbg_debug(fmt, ...)
-#endif
-
-PHPDBG_API void phpdbg_free_err_buf(TSRMLS_D);
-PHPDBG_API void phpdbg_activate_err_buf(zend_bool active TSRMLS_DC);
-PHPDBG_API int phpdbg_output_err_buf(const char *tag, const char *xmlfmt, const char *strfmt TSRMLS_DC, ...);
-
-
-/* {{{ For separation */
-#define SEPARATE "------------------------------------------------" /* }}} */
-
-#endif /* PHPDBG_OUT_H */
diff --git a/sapi/phpdbg/phpdbg_parser.c b/sapi/phpdbg/phpdbg_parser.c
index 433423db87..e34c2f48ff 100644
--- a/sapi/phpdbg/phpdbg_parser.c
+++ b/sapi/phpdbg/phpdbg_parser.c
@@ -1,4 +1,4 @@
-/* A Bison parser, made by GNU Bison 2.7.  */
+/* A Bison parser, made by GNU Bison 2.6.2.  */
 
 /* Bison implementation for Yacc-like parsers in C
    
@@ -44,7 +44,7 @@
 #define YYBISON 1
 
 /* Bison version.  */
-#define YYBISON_VERSION "2.7"
+#define YYBISON_VERSION "2.6.2"
 
 /* Skeleton name.  */
 #define YYSKELETON_NAME "yacc.c"
@@ -69,8 +69,8 @@
 #define yynerrs         phpdbg_nerrs
 
 /* Copy the first part of user declarations.  */
-/* Line 371 of yacc.c  */
-#line 1 "/usr/src/php-src/sapi/phpdbg/phpdbg_parser.y"
+/* Line 336 of yacc.c  */
+#line 1 "/var/root/php-src/sapi/phpdbg/phpdbg_parser.y"
 
  
 /*
@@ -97,7 +97,7 @@ static int yyerror(void ***tsrm_ls, const char *msg);
 ZEND_EXTERN_MODULE_GLOBALS(phpdbg);
 
 
-/* Line 371 of yacc.c  */
+/* Line 336 of yacc.c  */
 #line 102 "sapi/phpdbg/phpdbg_parser.c"
 
 # ifndef YY_NULL
@@ -118,8 +118,8 @@ ZEND_EXTERN_MODULE_GLOBALS(phpdbg);
 
 /* In a future release of Bison, this section will be replaced
    by #include "phpdbg_parser.h".  */
-#ifndef YY_PHPDBG_SAPI_PHPDBG_PHPDBG_PARSER_H_INCLUDED
-# define YY_PHPDBG_SAPI_PHPDBG_PHPDBG_PARSER_H_INCLUDED
+#ifndef PHPDBG_SAPI_PHPDBG_PHPDBG_PARSER_H
+# define PHPDBG_SAPI_PHPDBG_PHPDBG_PARSER_H
 /* Enabling traces.  */
 #ifndef YYDEBUG
 # define YYDEBUG 0
@@ -128,8 +128,8 @@ ZEND_EXTERN_MODULE_GLOBALS(phpdbg);
 extern int phpdbg_debug;
 #endif
 /* "%code requires" blocks.  */
-/* Line 387 of yacc.c  */
-#line 31 "/usr/src/php-src/sapi/phpdbg/phpdbg_parser.y"
+/* Line 350 of yacc.c  */
+#line 31 "/var/root/php-src/sapi/phpdbg/phpdbg_parser.y"
 
 #include "phpdbg.h"
 #ifndef YY_TYPEDEF_YY_SCANNER_T
@@ -138,7 +138,7 @@ typedef void* yyscan_t;
 #endif
 
 
-/* Line 387 of yacc.c  */
+/* Line 350 of yacc.c  */
 #line 143 "sapi/phpdbg/phpdbg_parser.c"
 
 /* Tokens.  */
@@ -164,8 +164,7 @@ typedef void* yyscan_t;
      T_OPCODE = 272,
      T_ID = 273,
      T_INPUT = 274,
-     T_UNEXPECTED = 275,
-     T_REQ_ID = 276
+     T_UNEXPECTED = 275
    };
 #endif
 /* Tokens.  */
@@ -187,7 +186,6 @@ typedef void* yyscan_t;
 #define T_ID 273
 #define T_INPUT 274
 #define T_UNEXPECTED 275
-#define T_REQ_ID 276
 
 
 
@@ -213,12 +211,12 @@ int phpdbg_parse ();
 #endif
 #endif /* ! YYPARSE_PARAM */
 
-#endif /* !YY_PHPDBG_SAPI_PHPDBG_PHPDBG_PARSER_H_INCLUDED  */
+#endif /* !PHPDBG_SAPI_PHPDBG_PHPDBG_PARSER_H  */
 
 /* Copy the second part of user declarations.  */
 
-/* Line 390 of yacc.c  */
-#line 222 "sapi/phpdbg/phpdbg_parser.c"
+/* Line 353 of yacc.c  */
+#line 220 "sapi/phpdbg/phpdbg_parser.c"
 
 #ifdef short
 # undef short
@@ -271,24 +269,24 @@ typedef short int yytype_int16;
 # if defined YYENABLE_NLS && YYENABLE_NLS
 #  if ENABLE_NLS
 #   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
-#   define YY_(Msgid) dgettext ("bison-runtime", Msgid)
+#   define YY_(msgid) dgettext ("bison-runtime", msgid)
 #  endif
 # endif
 # ifndef YY_
-#  define YY_(Msgid) Msgid
+#  define YY_(msgid) msgid
 # endif
 #endif
 
 /* Suppress unused-variable warnings by "using" E.  */
 #if ! defined lint || defined __GNUC__
-# define YYUSE(E) ((void) (E))
+# define YYUSE(e) ((void) (e))
 #else
-# define YYUSE(E) /* empty */
+# define YYUSE(e) /* empty */
 #endif
 
 /* Identity function, used to suppress warnings about constant conditions.  */
 #ifndef lint
-# define YYID(N) (N)
+# define YYID(n) (n)
 #else
 #if (defined __STDC__ || defined __C99__FUNC__ \
      || defined __cplusplus || defined _MSC_VER)
@@ -436,22 +434,22 @@ union yyalloc
 #endif /* !YYCOPY_NEEDED */
 
 /* YYFINAL -- State number of the termination state.  */
-#define YYFINAL  26
+#define YYFINAL  25
 /* YYLAST -- Last index in YYTABLE.  */
-#define YYLAST   48
+#define YYLAST   42
 
 /* YYNTOKENS -- Number of terminals.  */
-#define YYNTOKENS  22
+#define YYNTOKENS  21
 /* YYNNTS -- Number of nonterminals.  */
-#define YYNNTS  6
+#define YYNNTS  5
 /* YYNRULES -- Number of rules.  */
-#define YYNRULES  28
+#define YYNRULES  25
 /* YYNRULES -- Number of states.  */
-#define YYNSTATES  43
+#define YYNSTATES  38
 
 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
 #define YYUNDEFTOK  2
-#define YYMAXUTOK   276
+#define YYMAXUTOK   275
 
 #define YYTRANSLATE(YYX)						\
   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
@@ -486,7 +484,7 @@ static const yytype_uint8 yytranslate[] =
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
-      15,    16,    17,    18,    19,    20,    21
+      15,    16,    17,    18,    19,    20
 };
 
 #if YYDEBUG
@@ -494,31 +492,30 @@ static const yytype_uint8 yytranslate[] =
    YYRHS.  */
 static const yytype_uint8 yyprhs[] =
 {
-       0,     0,     3,     5,     7,     8,    10,    13,    16,    20,
-      25,    30,    36,    40,    46,    50,    53,    55,    57,    59,
-      61,    63,    65,    67,    69,    70,    74,    78,    81
+       0,     0,     3,     5,     7,     8,    10,    13,    17,    22,
+      27,    33,    37,    43,    47,    50,    52,    54,    56,    58,
+      60,    62,    64,    67,    70,    72
 };
 
 /* YYRHS -- A `-1'-separated list of the rules' RHS.  */
 static const yytype_int8 yyrhs[] =
 {
-      23,     0,    -1,    24,    -1,    27,    -1,    -1,    25,    -1,
-      24,    25,    -1,    24,    26,    -1,    18,    10,    14,    -1,
-      18,    10,    12,    14,    -1,    13,    18,    10,    14,    -1,
-      13,    18,    10,    12,    14,    -1,    18,    11,    18,    -1,
-      18,    11,    18,    12,    14,    -1,    18,    12,    14,    -1,
-       6,    19,    -1,    17,    -1,    16,    -1,    15,    -1,     7,
-      -1,     8,    -1,    14,    -1,    18,    -1,    21,    -1,    -1,
-       3,    26,    19,    -1,     5,    26,    19,    -1,     4,    26,
-      -1,     4,    26,    19,    -1
+      22,     0,    -1,    23,    -1,    25,    -1,    -1,    24,    -1,
+      23,    24,    -1,    18,    10,    14,    -1,    18,    10,    12,
+      14,    -1,    13,    18,    10,    14,    -1,    13,    18,    10,
+      12,    14,    -1,    18,    11,    18,    -1,    18,    11,    18,
+      12,    14,    -1,    18,    12,    14,    -1,     6,    19,    -1,
+      17,    -1,    16,    -1,    15,    -1,     7,    -1,     8,    -1,
+      14,    -1,    18,    -1,     3,    19,    -1,     5,    19,    -1,
+       4,    -1,     4,    19,    -1
 };
 
 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
 static const yytype_uint8 yyrline[] =
 {
-       0,    67,    67,    68,    69,    73,    74,    75,    79,    84,
-      89,    99,   109,   114,   120,   126,   131,   132,   133,   134,
-     135,   136,   137,   141,   142,   146,   151,   156,   160
+       0,    66,    66,    67,    68,    72,    73,    77,    82,    87,
+      97,   107,   112,   118,   124,   129,   130,   131,   132,   133,
+     134,   135,   139,   144,   149,   153
 };
 #endif
 
@@ -534,9 +531,8 @@ static const char *const yytname[] =
   "\":: (double colon)\"", "\"# (pound sign)\"", "\"protocol (file://)\"",
   "\"digits (numbers)\"", "\"literal (string)\"", "\"address\"",
   "\"opcode\"", "\"identifier (command or function name)\"",
-  "\"input (input string or data)\"", "\"input\"",
-  "\"request id (-r %d)\"", "$accept", "input", "parameters", "parameter",
-  "req_id", "full_expression", YY_NULL
+  "\"input (input string or data)\"", "\"input\"", "$accept", "input",
+  "parameters", "parameter", "full_expression", YY_NULL
 };
 #endif
 
@@ -547,24 +543,24 @@ static const yytype_uint16 yytoknum[] =
 {
        0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
      265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
-     275,   276
+     275
 };
 # endif
 
 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
 static const yytype_uint8 yyr1[] =
 {
-       0,    22,    23,    23,    23,    24,    24,    24,    25,    25,
-      25,    25,    25,    25,    25,    25,    25,    25,    25,    25,
-      25,    25,    25,    26,    26,    27,    27,    27,    27
+       0,    21,    22,    22,    22,    23,    23,    24,    24,    24,
+      24,    24,    24,    24,    24,    24,    24,    24,    24,    24,
+      24,    24,    25,    25,    25,    25
 };
 
 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
 static const yytype_uint8 yyr2[] =
 {
-       0,     2,     1,     1,     0,     1,     2,     2,     3,     4,
-       4,     5,     3,     5,     3,     2,     1,     1,     1,     1,
-       1,     1,     1,     1,     0,     3,     3,     2,     3
+       0,     2,     1,     1,     0,     1,     2,     3,     4,     4,
+       5,     3,     5,     3,     2,     1,     1,     1,     1,     1,
+       1,     1,     2,     2,     1,     2
 };
 
 /* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM.
@@ -572,35 +568,33 @@ static const yytype_uint8 yyr2[] =
    means the default is an error.  */
 static const yytype_uint8 yydefact[] =
 {
-       4,    24,    24,    24,     0,    19,    20,     0,    21,    18,
-      17,    16,    22,     0,     2,     5,     3,    23,     0,    27,
-       0,    15,     0,     0,     0,     0,     1,     6,     7,    25,
-      28,    26,     0,     0,     8,    12,    14,     0,    10,     9,
-       0,    11,    13
+       4,     0,    24,     0,     0,    18,    19,     0,    20,    17,
+      16,    15,    21,     0,     2,     5,     3,    22,    25,    23,
+      14,     0,     0,     0,     0,     1,     6,     0,     0,     7,
+      11,    13,     0,     9,     8,     0,    10,    12
 };
 
 /* YYDEFGOTO[NTERM-NUM].  */
 static const yytype_int8 yydefgoto[] =
 {
-      -1,    13,    14,    15,    18,    16
+      -1,    13,    14,    15,    16
 };
 
 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
    STATE-NUM.  */
-#define YYPACT_NINF -16
+#define YYPACT_NINF -11
 static const yytype_int8 yypact[] =
 {
-      -3,   -15,   -15,   -15,   -10,   -16,   -16,     3,   -16,   -16,
-     -16,   -16,    22,    29,    10,   -16,   -16,   -16,    11,    17,
-      19,   -16,    30,     8,    21,    27,   -16,   -16,   -16,   -16,
-     -16,   -16,    23,    28,   -16,    31,   -16,    32,   -16,   -16,
-      33,   -16,   -16
+      -3,   -10,    11,    12,    13,   -11,   -11,    15,   -11,   -11,
+     -11,   -11,    -4,    29,    10,   -11,   -11,   -11,   -11,   -11,
+     -11,    24,     7,    17,    22,   -11,   -11,     8,    23,   -11,
+      26,   -11,    25,   -11,   -11,    27,   -11,   -11
 };
 
 /* YYPGOTO[NTERM-NUM].  */
 static const yytype_int8 yypgoto[] =
 {
-     -16,   -16,   -16,    34,     5,   -16
+     -11,   -11,   -11,    28,   -11
 };
 
 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
@@ -609,26 +603,26 @@ static const yytype_int8 yypgoto[] =
 #define YYTABLE_NINF -1
 static const yytype_uint8 yytable[] =
 {
-       1,     2,     3,     4,     5,     6,    17,    19,    20,    21,
+       1,     2,     3,     4,     5,     6,    22,    23,    24,    17,
        7,     8,     9,    10,    11,    12,     4,     5,     6,    28,
-      33,    22,    34,     7,     8,     9,    10,    11,    12,    26,
-      29,    17,    23,    24,    25,    37,    30,    38,    31,    35,
-      32,    36,    39,    40,     0,     0,    41,    42,    27
+      32,    29,    33,     7,     8,     9,    10,    11,    12,    25,
+      18,    19,    20,    21,    27,    30,    31,    34,    35,    36,
+       0,    37,    26
 };
 
-#define yypact_value_is_default(Yystate) \
-  (!!((Yystate) == (-16)))
+#define yypact_value_is_default(yystate) \
+  ((yystate) == (-11))
 
-#define yytable_value_is_error(Yytable_value) \
+#define yytable_value_is_error(yytable_value) \
   YYID (0)
 
 static const yytype_int8 yycheck[] =
 {
-       3,     4,     5,     6,     7,     8,    21,     2,     3,    19,
-      13,    14,    15,    16,    17,    18,     6,     7,     8,    14,
-      12,    18,    14,    13,    14,    15,    16,    17,    18,     0,
-      19,    21,    10,    11,    12,    12,    19,    14,    19,    18,
-      10,    14,    14,    12,    -1,    -1,    14,    14,    14
+       3,     4,     5,     6,     7,     8,    10,    11,    12,    19,
+      13,    14,    15,    16,    17,    18,     6,     7,     8,    12,
+      12,    14,    14,    13,    14,    15,    16,    17,    18,     0,
+      19,    19,    19,    18,    10,    18,    14,    14,    12,    14,
+      -1,    14,    14
 };
 
 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
@@ -636,10 +630,9 @@ static const yytype_int8 yycheck[] =
 static const yytype_uint8 yystos[] =
 {
        0,     3,     4,     5,     6,     7,     8,    13,    14,    15,
-      16,    17,    18,    23,    24,    25,    27,    21,    26,    26,
-      26,    19,    18,    10,    11,    12,     0,    25,    26,    19,
-      19,    19,    10,    12,    14,    18,    14,    12,    14,    14,
-      12,    14,    14
+      16,    17,    18,    22,    23,    24,    25,    19,    19,    19,
+      19,    18,    10,    11,    12,     0,    24,    10,    12,    14,
+      18,    14,    12,    14,    14,    12,    14,    14
 };
 
 #define yyerrok		(yyerrstatus = 0)
@@ -686,18 +679,47 @@ do                                                              \
     }								\
 while (YYID (0))
 
-/* Error token number */
+
 #define YYTERROR	1
 #define YYERRCODE	256
 
+/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
+   If N is 0, then set CURRENT to the empty location which ends
+   the previous symbol: RHS[0] (always defined).  */
+
+#ifndef YYLLOC_DEFAULT
+# define YYLLOC_DEFAULT(Current, Rhs, N)                                \
+    do                                                                  \
+      if (YYID (N))                                                     \
+        {                                                               \
+          (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;        \
+          (Current).first_column = YYRHSLOC (Rhs, 1).first_column;      \
+          (Current).last_line    = YYRHSLOC (Rhs, N).last_line;         \
+          (Current).last_column  = YYRHSLOC (Rhs, N).last_column;       \
+        }                                                               \
+      else                                                              \
+        {                                                               \
+          (Current).first_line   = (Current).last_line   =              \
+            YYRHSLOC (Rhs, 0).last_line;                                \
+          (Current).first_column = (Current).last_column =              \
+            YYRHSLOC (Rhs, 0).last_column;                              \
+        }                                                               \
+    while (YYID (0))
+#endif
+
+#define YYRHSLOC(Rhs, K) ((Rhs)[K])
+
+
 
 /* This macro is provided for backward compatibility. */
+
 #ifndef YY_LOCATION_PRINT
 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
 #endif
 
 
 /* YYLEX -- calling `yylex' with the right arguments.  */
+
 #ifdef YYLEX_PARAM
 # define YYLEX yylex (&yylval, YYLEX_PARAM)
 #else
@@ -762,7 +784,7 @@ yy_symbol_value_print (yyoutput, yytype, yyvaluep, tsrm_ls)
   switch (yytype)
     {
       default:
-        break;
+	break;
     }
 }
 
@@ -1006,6 +1028,7 @@ yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
 {
   YYSIZE_T yysize0 = yytnamerr (YY_NULL, yytname[yytoken]);
   YYSIZE_T yysize = yysize0;
+  YYSIZE_T yysize1;
   enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
   /* Internationalized format string. */
   const char *yyformat = YY_NULL;
@@ -1068,13 +1091,11 @@ yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
                     break;
                   }
                 yyarg[yycount++] = yytname[yyx];
-                {
-                  YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULL, yytname[yyx]);
-                  if (! (yysize <= yysize1
-                         && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
-                    return 2;
-                  yysize = yysize1;
-                }
+                yysize1 = yysize + yytnamerr (YY_NULL, yytname[yyx]);
+                if (! (yysize <= yysize1
+                       && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
+                  return 2;
+                yysize = yysize1;
               }
         }
     }
@@ -1094,12 +1115,10 @@ yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
 # undef YYCASE_
     }
 
-  {
-    YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
-    if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
-      return 2;
-    yysize = yysize1;
-  }
+  yysize1 = yysize + yystrlen (yyformat);
+  if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
+    return 2;
+  yysize = yysize1;
 
   if (*yymsg_alloc < yysize)
     {
@@ -1161,7 +1180,7 @@ yydestruct (yymsg, yytype, yyvaluep, tsrm_ls)
     {
 
       default:
-        break;
+	break;
     }
 }
 
@@ -1197,31 +1216,8 @@ yyparse (tsrm_ls)
 /* The lookahead symbol.  */
 int yychar;
 
-
-#if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
-/* Suppress an incorrect diagnostic about yylval being uninitialized.  */
-# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
-    _Pragma ("GCC diagnostic push") \
-    _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\
-    _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
-# define YY_IGNORE_MAYBE_UNINITIALIZED_END \
-    _Pragma ("GCC diagnostic pop")
-#else
-/* Default value used for initialization, for pacifying older GCCs
-   or non-GCC compilers.  */
-static YYSTYPE yyval_default;
-# define YY_INITIAL_VALUE(Value) = Value
-#endif
-#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
-# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
-# define YY_IGNORE_MAYBE_UNINITIALIZED_END
-#endif
-#ifndef YY_INITIAL_VALUE
-# define YY_INITIAL_VALUE(Value) /* Nothing. */
-#endif
-
 /* The semantic value of the lookahead symbol.  */
-YYSTYPE yylval YY_INITIAL_VALUE(yyval_default);
+YYSTYPE yylval;
 
     /* Number of syntax errors so far.  */
     int yynerrs;
@@ -1252,7 +1248,7 @@ YYSTYPE yylval YY_INITIAL_VALUE(yyval_default);
   int yyn;
   int yyresult;
   /* Lookahead token as an internal (translated) token number.  */
-  int yytoken = 0;
+  int yytoken;
   /* The variables used to return semantic value and location from the
      action routines.  */
   YYSTYPE yyval;
@@ -1270,8 +1266,9 @@ YYSTYPE yylval YY_INITIAL_VALUE(yyval_default);
      Keep to zero when no symbol should be popped.  */
   int yylen = 0;
 
-  yyssp = yyss = yyssa;
-  yyvsp = yyvs = yyvsa;
+  yytoken = 0;
+  yyss = yyssa;
+  yyvs = yyvsa;
   yystacksize = YYINITDEPTH;
 
   YYDPRINTF ((stderr, "Starting parse\n"));
@@ -1280,6 +1277,13 @@ YYSTYPE yylval YY_INITIAL_VALUE(yyval_default);
   yyerrstatus = 0;
   yynerrs = 0;
   yychar = YYEMPTY; /* Cause a token to be read.  */
+
+  /* Initialize stack pointers.
+     Waste one element of value and location stack
+     so that they stay on the same level as the state stack.
+     The wasted elements are never initialized.  */
+  yyssp = yyss;
+  yyvsp = yyvs;
   goto yysetstate;
 
 /*------------------------------------------------------------.
@@ -1420,9 +1424,7 @@ yybackup:
   yychar = YYEMPTY;
 
   yystate = yyn;
-  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
   *++yyvsp = yylval;
-  YY_IGNORE_MAYBE_UNINITIALIZED_END
 
   goto yynewstate;
 
@@ -1459,32 +1461,26 @@ yyreduce:
   switch (yyn)
     {
         case 3:
-/* Line 1792 of yacc.c  */
-#line 68 "/usr/src/php-src/sapi/phpdbg/phpdbg_parser.y"
+/* Line 1802 of yacc.c  */
+#line 67 "/var/root/php-src/sapi/phpdbg/phpdbg_parser.y"
     { phpdbg_stack_push(PHPDBG_G(parser_stack), &(yyvsp[(1) - (1)])); }
     break;
 
   case 5:
-/* Line 1792 of yacc.c  */
-#line 73 "/usr/src/php-src/sapi/phpdbg/phpdbg_parser.y"
+/* Line 1802 of yacc.c  */
+#line 72 "/var/root/php-src/sapi/phpdbg/phpdbg_parser.y"
     { phpdbg_stack_push(PHPDBG_G(parser_stack), &(yyvsp[(1) - (1)])); }
     break;
 
   case 6:
-/* Line 1792 of yacc.c  */
-#line 74 "/usr/src/php-src/sapi/phpdbg/phpdbg_parser.y"
+/* Line 1802 of yacc.c  */
+#line 73 "/var/root/php-src/sapi/phpdbg/phpdbg_parser.y"
     { phpdbg_stack_push(PHPDBG_G(parser_stack), &(yyvsp[(2) - (2)])); }
     break;
 
   case 7:
-/* Line 1792 of yacc.c  */
-#line 75 "/usr/src/php-src/sapi/phpdbg/phpdbg_parser.y"
-    { (yyval) = (yyvsp[(1) - (2)]); }
-    break;
-
-  case 8:
-/* Line 1792 of yacc.c  */
-#line 79 "/usr/src/php-src/sapi/phpdbg/phpdbg_parser.y"
+/* Line 1802 of yacc.c  */
+#line 77 "/var/root/php-src/sapi/phpdbg/phpdbg_parser.y"
     { 	
 		(yyval).type = FILE_PARAM;
 		(yyval).file.name = (yyvsp[(2) - (3)]).str;
@@ -1492,9 +1488,9 @@ yyreduce:
 	}
     break;
 
-  case 9:
-/* Line 1792 of yacc.c  */
-#line 84 "/usr/src/php-src/sapi/phpdbg/phpdbg_parser.y"
+  case 8:
+/* Line 1802 of yacc.c  */
+#line 82 "/var/root/php-src/sapi/phpdbg/phpdbg_parser.y"
     {
 		(yyval).type = NUMERIC_FILE_PARAM;
 		(yyval).file.name = (yyvsp[(1) - (4)]).str;
@@ -1502,9 +1498,9 @@ yyreduce:
 	}
     break;
 
-  case 10:
-/* Line 1792 of yacc.c  */
-#line 89 "/usr/src/php-src/sapi/phpdbg/phpdbg_parser.y"
+  case 9:
+/* Line 1802 of yacc.c  */
+#line 87 "/var/root/php-src/sapi/phpdbg/phpdbg_parser.y"
     {
 		(yyval).type = FILE_PARAM;
 		(yyval).file.name = malloc((yyvsp[(1) - (4)]).len + (yyvsp[(2) - (4)]).len + 1);
@@ -1517,9 +1513,9 @@ yyreduce:
 	}
     break;
 
-  case 11:
-/* Line 1792 of yacc.c  */
-#line 99 "/usr/src/php-src/sapi/phpdbg/phpdbg_parser.y"
+  case 10:
+/* Line 1802 of yacc.c  */
+#line 97 "/var/root/php-src/sapi/phpdbg/phpdbg_parser.y"
     {
 		(yyval).type = NUMERIC_FILE_PARAM;
 		(yyval).file.name = malloc((yyvsp[(1) - (5)]).len + (yyvsp[(2) - (5)]).len + 1);
@@ -1532,9 +1528,9 @@ yyreduce:
 	}
     break;
 
-  case 12:
-/* Line 1792 of yacc.c  */
-#line 109 "/usr/src/php-src/sapi/phpdbg/phpdbg_parser.y"
+  case 11:
+/* Line 1802 of yacc.c  */
+#line 107 "/var/root/php-src/sapi/phpdbg/phpdbg_parser.y"
     { 
 		(yyval).type = METHOD_PARAM;
 		(yyval).method.class = (yyvsp[(1) - (3)]).str;
@@ -1542,9 +1538,9 @@ yyreduce:
 	}
     break;
 
-  case 13:
-/* Line 1792 of yacc.c  */
-#line 114 "/usr/src/php-src/sapi/phpdbg/phpdbg_parser.y"
+  case 12:
+/* Line 1802 of yacc.c  */
+#line 112 "/var/root/php-src/sapi/phpdbg/phpdbg_parser.y"
     { 
 		(yyval).type = NUMERIC_METHOD_PARAM;
 		(yyval).method.class = (yyvsp[(1) - (5)]).str;
@@ -1553,9 +1549,9 @@ yyreduce:
 	}
     break;
 
-  case 14:
-/* Line 1792 of yacc.c  */
-#line 120 "/usr/src/php-src/sapi/phpdbg/phpdbg_parser.y"
+  case 13:
+/* Line 1802 of yacc.c  */
+#line 118 "/var/root/php-src/sapi/phpdbg/phpdbg_parser.y"
     {
 		(yyval).type = NUMERIC_FUNCTION_PARAM;
 		(yyval).str = (yyvsp[(1) - (3)]).str;
@@ -1564,9 +1560,9 @@ yyreduce:
 	}
     break;
 
-  case 15:
-/* Line 1792 of yacc.c  */
-#line 126 "/usr/src/php-src/sapi/phpdbg/phpdbg_parser.y"
+  case 14:
+/* Line 1802 of yacc.c  */
+#line 124 "/var/root/php-src/sapi/phpdbg/phpdbg_parser.y"
     {
 		(yyval).type = COND_PARAM; 
 		(yyval).str = (yyvsp[(2) - (2)]).str;
@@ -1574,96 +1570,90 @@ yyreduce:
 	}
     break;
 
+  case 15:
+/* Line 1802 of yacc.c  */
+#line 129 "/var/root/php-src/sapi/phpdbg/phpdbg_parser.y"
+    { (yyval) = (yyvsp[(1) - (1)]); }
+    break;
+
   case 16:
-/* Line 1792 of yacc.c  */
-#line 131 "/usr/src/php-src/sapi/phpdbg/phpdbg_parser.y"
+/* Line 1802 of yacc.c  */
+#line 130 "/var/root/php-src/sapi/phpdbg/phpdbg_parser.y"
     { (yyval) = (yyvsp[(1) - (1)]); }
     break;
 
   case 17:
-/* Line 1792 of yacc.c  */
-#line 132 "/usr/src/php-src/sapi/phpdbg/phpdbg_parser.y"
+/* Line 1802 of yacc.c  */
+#line 131 "/var/root/php-src/sapi/phpdbg/phpdbg_parser.y"
     { (yyval) = (yyvsp[(1) - (1)]); }
     break;
 
   case 18:
-/* Line 1792 of yacc.c  */
-#line 133 "/usr/src/php-src/sapi/phpdbg/phpdbg_parser.y"
+/* Line 1802 of yacc.c  */
+#line 132 "/var/root/php-src/sapi/phpdbg/phpdbg_parser.y"
     { (yyval) = (yyvsp[(1) - (1)]); }
     break;
 
   case 19:
-/* Line 1792 of yacc.c  */
-#line 134 "/usr/src/php-src/sapi/phpdbg/phpdbg_parser.y"
+/* Line 1802 of yacc.c  */
+#line 133 "/var/root/php-src/sapi/phpdbg/phpdbg_parser.y"
     { (yyval) = (yyvsp[(1) - (1)]); }
     break;
 
   case 20:
-/* Line 1792 of yacc.c  */
-#line 135 "/usr/src/php-src/sapi/phpdbg/phpdbg_parser.y"
+/* Line 1802 of yacc.c  */
+#line 134 "/var/root/php-src/sapi/phpdbg/phpdbg_parser.y"
     { (yyval) = (yyvsp[(1) - (1)]); }
     break;
 
   case 21:
-/* Line 1792 of yacc.c  */
-#line 136 "/usr/src/php-src/sapi/phpdbg/phpdbg_parser.y"
+/* Line 1802 of yacc.c  */
+#line 135 "/var/root/php-src/sapi/phpdbg/phpdbg_parser.y"
     { (yyval) = (yyvsp[(1) - (1)]); }
     break;
 
   case 22:
-/* Line 1792 of yacc.c  */
-#line 137 "/usr/src/php-src/sapi/phpdbg/phpdbg_parser.y"
-    { (yyval) = (yyvsp[(1) - (1)]); }
-    break;
-
-  case 23:
-/* Line 1792 of yacc.c  */
-#line 141 "/usr/src/php-src/sapi/phpdbg/phpdbg_parser.y"
-    { PHPDBG_G(req_id) = (yyvsp[(1) - (1)]).num; }
-    break;
-
-  case 25:
-/* Line 1792 of yacc.c  */
-#line 146 "/usr/src/php-src/sapi/phpdbg/phpdbg_parser.y"
+/* Line 1802 of yacc.c  */
+#line 139 "/var/root/php-src/sapi/phpdbg/phpdbg_parser.y"
     { 
 		(yyval).type = EVAL_PARAM; 
-		(yyval).str = (yyvsp[(3) - (3)]).str;
-		(yyval).len = (yyvsp[(3) - (3)]).len;
+		(yyval).str = (yyvsp[(2) - (2)]).str;
+		(yyval).len = (yyvsp[(2) - (2)]).len;
 	}
     break;
 
-  case 26:
-/* Line 1792 of yacc.c  */
-#line 151 "/usr/src/php-src/sapi/phpdbg/phpdbg_parser.y"
+  case 23:
+/* Line 1802 of yacc.c  */
+#line 144 "/var/root/php-src/sapi/phpdbg/phpdbg_parser.y"
     { 	
 		(yyval).type = SHELL_PARAM; 
-		(yyval).str = (yyvsp[(3) - (3)]).str;
-		(yyval).len = (yyvsp[(3) - (3)]).len;
+		(yyval).str = (yyvsp[(2) - (2)]).str;
+		(yyval).len = (yyvsp[(2) - (2)]).len;
 	}
     break;
 
-  case 27:
-/* Line 1792 of yacc.c  */
-#line 156 "/usr/src/php-src/sapi/phpdbg/phpdbg_parser.y"
+  case 24:
+/* Line 1802 of yacc.c  */
+#line 149 "/var/root/php-src/sapi/phpdbg/phpdbg_parser.y"
     {
 		(yyval).type = RUN_PARAM;
 		(yyval).len = 0;
 	}
     break;
 
-  case 28:
-/* Line 1792 of yacc.c  */
-#line 160 "/usr/src/php-src/sapi/phpdbg/phpdbg_parser.y"
+  case 25:
+/* Line 1802 of yacc.c  */
+#line 153 "/var/root/php-src/sapi/phpdbg/phpdbg_parser.y"
     { 	
 		(yyval).type = RUN_PARAM; 
-		(yyval).str = (yyvsp[(3) - (3)]).str;
-		(yyval).len = (yyvsp[(3) - (3)]).len;
+		(yyval).str = (yyvsp[(2) - (2)]).str;
+		(yyval).len = (yyvsp[(2) - (2)]).len;
 	}
     break;
 
 
-/* Line 1792 of yacc.c  */
-#line 1667 "sapi/phpdbg/phpdbg_parser.c"
+/* Line 1802 of yacc.c  */
+#line 1657 "sapi/phpdbg/phpdbg_parser.c"
       default: break;
     }
   /* User semantic actions sometimes alter yychar, and that requires
@@ -1826,9 +1816,7 @@ yyerrlab1:
       YY_STACK_PRINT (yyss, yyssp);
     }
 
-  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
   *++yyvsp = yylval;
-  YY_IGNORE_MAYBE_UNINITIALIZED_END
 
 
   /* Shift the error token.  */
@@ -1894,12 +1882,12 @@ yyreturn:
 }
 
 
-/* Line 2055 of yacc.c  */
-#line 167 "/usr/src/php-src/sapi/phpdbg/phpdbg_parser.y"
+/* Line 2048 of yacc.c  */
+#line 160 "/var/root/php-src/sapi/phpdbg/phpdbg_parser.y"
 
 
 static int yyerror(void ***tsrm_ls, const char *msg) {
-	phpdbg_error("command", "type=\"parseerror\" msg=\"%s\"", "Parse Error: %s", msg);
+	phpdbg_error("Parse Error: %s", msg);
 
 	{
 		const phpdbg_param_t *top = PHPDBG_G(parser_stack);
diff --git a/sapi/phpdbg/phpdbg_parser.h b/sapi/phpdbg/phpdbg_parser.h
index 4cd8ed6d00..b3aadb9c62 100644
--- a/sapi/phpdbg/phpdbg_parser.h
+++ b/sapi/phpdbg/phpdbg_parser.h
@@ -1,4 +1,4 @@
-/* A Bison parser, made by GNU Bison 2.7.  */
+/* A Bison parser, made by GNU Bison 2.6.2.  */
 
 /* Bison interface for Yacc-like parsers in C
    
@@ -30,8 +30,8 @@
    This special exception was added by the Free Software Foundation in
    version 2.2 of Bison.  */
 
-#ifndef YY_PHPDBG_SAPI_PHPDBG_PHPDBG_PARSER_H_INCLUDED
-# define YY_PHPDBG_SAPI_PHPDBG_PHPDBG_PARSER_H_INCLUDED
+#ifndef PHPDBG_SAPI_PHPDBG_PHPDBG_PARSER_H
+# define PHPDBG_SAPI_PHPDBG_PHPDBG_PARSER_H
 /* Enabling traces.  */
 #ifndef YYDEBUG
 # define YYDEBUG 0
@@ -40,8 +40,8 @@
 extern int phpdbg_debug;
 #endif
 /* "%code requires" blocks.  */
-/* Line 2058 of yacc.c  */
-#line 31 "/usr/src/php-src/sapi/phpdbg/phpdbg_parser.y"
+/* Line 2055 of yacc.c  */
+#line 31 "/var/root/php-src/sapi/phpdbg/phpdbg_parser.y"
 
 #include "phpdbg.h"
 #ifndef YY_TYPEDEF_YY_SCANNER_T
@@ -50,7 +50,7 @@ typedef void* yyscan_t;
 #endif
 
 
-/* Line 2058 of yacc.c  */
+/* Line 2055 of yacc.c  */
 #line 55 "sapi/phpdbg/phpdbg_parser.h"
 
 /* Tokens.  */
@@ -76,8 +76,7 @@ typedef void* yyscan_t;
      T_OPCODE = 272,
      T_ID = 273,
      T_INPUT = 274,
-     T_UNEXPECTED = 275,
-     T_REQ_ID = 276
+     T_UNEXPECTED = 275
    };
 #endif
 /* Tokens.  */
@@ -99,7 +98,6 @@ typedef void* yyscan_t;
 #define T_ID 273
 #define T_INPUT 274
 #define T_UNEXPECTED 275
-#define T_REQ_ID 276
 
 
 
@@ -125,4 +123,4 @@ int phpdbg_parse ();
 #endif
 #endif /* ! YYPARSE_PARAM */
 
-#endif /* !YY_PHPDBG_SAPI_PHPDBG_PHPDBG_PARSER_H_INCLUDED  */
+#endif /* !PHPDBG_SAPI_PHPDBG_PHPDBG_PARSER_H  */
diff --git a/sapi/phpdbg/phpdbg_parser.y b/sapi/phpdbg/phpdbg_parser.y
index e4353976f3..702bf78455 100644
--- a/sapi/phpdbg/phpdbg_parser.y
+++ b/sapi/phpdbg/phpdbg_parser.y
@@ -59,7 +59,6 @@ typedef void* yyscan_t;
 %token T_ID         "identifier (command or function name)"
 %token T_INPUT      "input (input string or data)"
 %token T_UNEXPECTED "input"
-%token T_REQ_ID     "request id (-r %d)"
 
 %% /* Rules */
 
@@ -72,7 +71,6 @@ input
 parameters
 	: parameter { phpdbg_stack_push(PHPDBG_G(parser_stack), &$1); }
 	| parameters parameter { phpdbg_stack_push(PHPDBG_G(parser_stack), &$2); }
-	| parameters req_id { $$ = $1; }
 	;
 
 parameter
@@ -137,37 +135,32 @@ parameter
 	| T_ID { $$ = $1; }
 	;
 
-req_id
-	: T_REQ_ID { PHPDBG_G(req_id) = $1.num; }
-	| /* empty */
-;
-
 full_expression
-	: T_EVAL req_id T_INPUT { 
+	: T_EVAL T_INPUT { 
 		$$.type = EVAL_PARAM; 
-		$$.str = $3.str;
-		$$.len = $3.len;
+		$$.str = $2.str;
+		$$.len = $2.len;
 	}
-	| T_SHELL req_id T_INPUT { 	
+	| T_SHELL T_INPUT { 	
 		$$.type = SHELL_PARAM; 
-		$$.str = $3.str;
-		$$.len = $3.len;
+		$$.str = $2.str;
+		$$.len = $2.len;
 	}
-	| T_RUN req_id {
+	| T_RUN {
 		$$.type = RUN_PARAM;
 		$$.len = 0;
 	}
-	| T_RUN req_id T_INPUT { 	
+	| T_RUN T_INPUT { 	
 		$$.type = RUN_PARAM; 
-		$$.str = $3.str;
-		$$.len = $3.len;
+		$$.str = $2.str;
+		$$.len = $2.len;
 	}
 	;
 
 %%
 
 static int yyerror(void ***tsrm_ls, const char *msg) {
-	phpdbg_error("command", "type=\"parseerror\" msg=\"%s\"", "Parse Error: %s", msg);
+	phpdbg_error("Parse Error: %s", msg);
 
 	{
 		const phpdbg_param_t *top = PHPDBG_G(parser_stack);
diff --git a/sapi/phpdbg/phpdbg_print.c b/sapi/phpdbg/phpdbg_print.c
index 80eeddb39d..76321a5042 100644
--- a/sapi/phpdbg/phpdbg_print.c
+++ b/sapi/phpdbg/phpdbg_print.c
@@ -26,16 +26,16 @@
 
 ZEND_EXTERN_MODULE_GLOBALS(phpdbg);
 
-#define PHPDBG_PRINT_COMMAND_D(f, h, a, m, l, s, flags) \
-	PHPDBG_COMMAND_D_EXP(f, h, a, m, l, s, &phpdbg_prompt_commands[9], flags)
+#define PHPDBG_PRINT_COMMAND_D(f, h, a, m, l, s) \
+	PHPDBG_COMMAND_D_EXP(f, h, a, m, l, s, &phpdbg_prompt_commands[9])
 
 const phpdbg_command_t phpdbg_print_commands[] = {
-	PHPDBG_PRINT_COMMAND_D(exec,       "print out the instructions in the execution context",  'e', print_exec,   NULL, 0, PHPDBG_ASYNC_SAFE),
-	PHPDBG_PRINT_COMMAND_D(opline,     "print out the instruction in the current opline",      'o', print_opline, NULL, 0, PHPDBG_ASYNC_SAFE),
-	PHPDBG_PRINT_COMMAND_D(class,      "print out the instructions in the specified class",    'c', print_class,  NULL, "s", PHPDBG_ASYNC_SAFE),
-	PHPDBG_PRINT_COMMAND_D(method,     "print out the instructions in the specified method",   'm', print_method, NULL, "m", PHPDBG_ASYNC_SAFE),
-	PHPDBG_PRINT_COMMAND_D(func,       "print out the instructions in the specified function", 'f', print_func,   NULL, "s", PHPDBG_ASYNC_SAFE),
-	PHPDBG_PRINT_COMMAND_D(stack,      "print out the instructions in the current stack",      's', print_stack,  NULL, 0, PHPDBG_ASYNC_SAFE),
+	PHPDBG_PRINT_COMMAND_D(exec,       "print out the instructions in the execution context",  'e', print_exec,   NULL, 0),
+	PHPDBG_PRINT_COMMAND_D(opline,     "print out the instruction in the current opline",      'o', print_opline, NULL, 0),
+	PHPDBG_PRINT_COMMAND_D(class,      "print out the instructions in the specified class",    'c', print_class,  NULL, "s"),
+	PHPDBG_PRINT_COMMAND_D(method,     "print out the instructions in the specified method",   'm', print_method, NULL, "m"),
+	PHPDBG_PRINT_COMMAND_D(func,       "print out the instructions in the specified function", 'f', print_func,   NULL, "s"),
+	PHPDBG_PRINT_COMMAND_D(stack,      "print out the instructions in the current stack",      's', print_stack,  NULL, 0),
 	PHPDBG_END_COMMAND
 };
 
@@ -44,7 +44,7 @@ PHPDBG_PRINT(opline) /* {{{ */
 	if (EG(in_execution) && EG(current_execute_data)) {
 		phpdbg_print_opline(EG(current_execute_data), 1 TSRMLS_CC);
 	} else {
-		phpdbg_error("inactive", "type=\"execution\"", "Not Executing!");
+		phpdbg_error("Not Executing!");
 	}
 
 	return SUCCESS;
@@ -56,22 +56,21 @@ static inline void phpdbg_print_function_helper(zend_function *method TSRMLS_DC)
 		case ZEND_USER_FUNCTION: {
 			zend_op_array* op_array = &(method->op_array);
 			HashTable vars;
-
+			
 			if (op_array) {
 				zend_op *opline = &(op_array->opcodes[0]);
 				zend_uint opcode = 0,
 				end = op_array->last-1;
 
 				if (method->common.scope) {
-					phpdbg_writeln("printoplineinfo", "type=\"User\" startline=\"%d\" endline=\"%d\" method=\"%s::%s\" file=\"%s\"", "\tL%d-%d %s::%s() %s",
-						op_array->line_start,
-						op_array->line_end,
+					phpdbg_writeln("\tL%d-%d %s::%s() %s",
+						op_array->line_start, op_array->line_end,
 						method->common.scope->name,
 						method->common.function_name,
 						op_array->filename ? op_array->filename : "unknown");
 				} else {
-					phpdbg_writeln("printoplineinfo", "type=\"User\" startline=\"%d\" endline=\"%d\" function=\"%s\" file=\"%s\"", "\tL%d-%d %s() %s",
-						method->common.function_name ? op_array->line_start : 0,
+					phpdbg_writeln("\tL%d-%d %s() %s",
+						method->common.function_name ? op_array->line_start : 0, 
 						method->common.function_name ? op_array->line_end : 0,
 						method->common.function_name ? method->common.function_name : "{main}",
 						op_array->filename ? op_array->filename : "unknown");
@@ -81,14 +80,14 @@ static inline void phpdbg_print_function_helper(zend_function *method TSRMLS_DC)
 				do {
 					char *decode = phpdbg_decode_opline(op_array, opline, &vars TSRMLS_CC);
 					if (decode != NULL) {
-						phpdbg_writeln("print", "line=\"%u\" opline=\"%p\" opcode=\"%s\" op=\"%s\"", "\t\tL%u\t%p %-30s %s",
+						phpdbg_writeln("\t\tL%u\t%p %-30s %s", 
 							opline->lineno,
-							opline,
+							opline, 
 							phpdbg_decode_opcode(opline->opcode),
 							decode);
 						free(decode);
 					} else {
-						phpdbg_error("print", "type=\"decodefailure\" opline=\"%16p\"", "\tFailed to decode opline %16p", opline);
+						phpdbg_error("\tFailed to decode opline %16p", opline);
 					}
 					opline++;
 				} while (opcode++ < end);
@@ -98,9 +97,9 @@ static inline void phpdbg_print_function_helper(zend_function *method TSRMLS_DC)
 
 		default: {
 			if (method->common.scope) {
-				phpdbg_writeln("printoplineinfo", "type=\"Internal\" method=\"%s::%s\"", "Internal %s::%s()", method->common.scope->name, method->common.function_name);
+				phpdbg_writeln("\tInternal %s::%s()", method->common.scope->name, method->common.function_name);
 			} else {
-				phpdbg_writeln("printoplineinfo", "type=\"Internal\" function=\"%s\"", "\tInternal %s()", method->common.function_name);
+				phpdbg_writeln("\tInternal %s()", method->common.function_name);
 			}
 		}
 	}
@@ -109,17 +108,17 @@ static inline void phpdbg_print_function_helper(zend_function *method TSRMLS_DC)
 PHPDBG_PRINT(exec) /* {{{ */
 {
 	if (PHPDBG_G(exec)) {
-		if (!PHPDBG_G(ops) && !(PHPDBG_G(flags) & PHPDBG_IN_SIGNAL_HANDLER)) {
+		if (!PHPDBG_G(ops)) {
 			phpdbg_compile(TSRMLS_C);
 		}
 
 		if (PHPDBG_G(ops)) {
-			phpdbg_notice("printinfo", "file=\"%s\" num=\"%d\"", "Context %s (%d ops)", PHPDBG_G(exec), PHPDBG_G(ops)->last);
+			phpdbg_notice("Context %s", PHPDBG_G(exec));
 
 			phpdbg_print_function_helper((zend_function*) PHPDBG_G(ops) TSRMLS_CC);
 		}
 	} else {
-		phpdbg_error("inactive", "type=\"nocontext\"", "No execution context set");
+		phpdbg_error("No execution context set");
 	}
 
 return SUCCESS;
@@ -128,24 +127,24 @@ return SUCCESS;
 PHPDBG_PRINT(stack) /* {{{ */
 {
 	zend_op_array *ops = EG(active_op_array);
-
+	
 	if (EG(in_execution) && ops) {
 		if (ops->function_name) {
 			if (ops->scope) {
-				phpdbg_notice("printinfo", "method=\"%s::%s\" num=\"%d\"", "Stack in %s::%s() (%d ops)", ops->scope->name, ops->function_name, ops->last);
+				phpdbg_notice("Stack in %s::%s()", ops->scope->name, ops->function_name);
 			} else {
-				phpdbg_notice("printinfo", "function=\"%s\" num=\"%d\"", "Stack in %s() (%d ops)", ops->function_name, ops->last);
+				phpdbg_notice("Stack in %s()", ops->function_name);
 			}
 		} else {
 			if (ops->filename) {
-				phpdbg_notice("printinfo", "file=\"%s\" num=\"%d\"", "Stack in %s (%d ops)", ops->filename, ops->last);
+				phpdbg_notice("Stack in %s", ops->filename);
 			} else {
-				phpdbg_notice("printinfo", "opline=\"%p\" num=\"%d\"", "Stack @ %p (%d ops)", ops, ops->last);
+				phpdbg_notice("Stack @ %p", ops);
 			}
 		}
 		phpdbg_print_function_helper((zend_function*) ops TSRMLS_CC);
 	} else {
-		phpdbg_error("inactive", "type=\"execution\"", "Not Executing!");
+		phpdbg_error("Not Executing!");
 	}
 
 	return SUCCESS;
@@ -155,8 +154,8 @@ PHPDBG_PRINT(class) /* {{{ */
 {
 	zend_class_entry **ce;
 
-	if (phpdbg_safe_class_lookup(param->str, param->len, &ce TSRMLS_CC) == SUCCESS) {
-		phpdbg_notice("printinfo", "type=\"%s\" flag=\"%s\" class=\"%s\" num=\"%d\"", "%s %s: %s (%d methods)",
+	if (zend_lookup_class(param->str, param->len, &ce TSRMLS_CC) == SUCCESS) {
+		phpdbg_notice("%s %s: %s",
 			((*ce)->type == ZEND_USER_CLASS) ?
 				"User" : "Internal",
 			((*ce)->ce_flags & ZEND_ACC_INTERFACE) ?
@@ -164,11 +163,9 @@ PHPDBG_PRINT(class) /* {{{ */
 				((*ce)->ce_flags & ZEND_ACC_ABSTRACT) ?
 					"Abstract Class" :
 					"Class",
-			(*ce)->name,
-			zend_hash_num_elements(&(*ce)->function_table));
-
-		phpdbg_xml("<printmethods %r>");
+			(*ce)->name);
 
+		phpdbg_writeln("Methods (%d):", zend_hash_num_elements(&(*ce)->function_table));
 		if (zend_hash_num_elements(&(*ce)->function_table)) {
 			HashPosition position;
 			zend_function *method;
@@ -179,10 +176,8 @@ PHPDBG_PRINT(class) /* {{{ */
 				phpdbg_print_function_helper(method TSRMLS_CC);
 			}
 		}
-
-		phpdbg_xml("</printmethods>");
 	} else {
-		phpdbg_error("print", "type=\"noclass\" class=\"%s\"", "The class %s could not be found", param->str);
+		phpdbg_error("The class %s could not be found", param->str);
 	}
 
 	return SUCCESS;
@@ -192,24 +187,23 @@ PHPDBG_PRINT(method) /* {{{ */
 {
 	zend_class_entry **ce;
 
-	if (phpdbg_safe_class_lookup(param->method.class, strlen(param->method.class), &ce TSRMLS_CC) == SUCCESS) {
+	if (zend_lookup_class(param->method.class, strlen(param->method.class), &ce TSRMLS_CC) == SUCCESS) {
 		zend_function *fbc;
 		char *lcname = zend_str_tolower_dup(param->method.name, strlen(param->method.name));
 
 		if (zend_hash_find(&(*ce)->function_table, lcname, strlen(lcname)+1, (void**)&fbc) == SUCCESS) {
-			phpdbg_notice("printinfo", "type=\"%s\" flags=\"Method\" symbol=\"%s\" num=\"%d\"", "%s Method %s (%d ops)",
+			phpdbg_notice("%s Method %s",
 				(fbc->type == ZEND_USER_FUNCTION) ? "User" : "Internal",
-				fbc->common.function_name,
-				(fbc->type == ZEND_USER_FUNCTION) ? fbc->op_array.last : 0);
+				fbc->common.function_name);
 
 			phpdbg_print_function_helper(fbc TSRMLS_CC);
 		} else {
-			phpdbg_error("print", "type=\"nomethod\" method=\"%s::%s\"", "The method %s::%s could not be found", param->method.class, param->method.name);
+			phpdbg_error("The method %s could not be found", param->method.name);
 		}
 
 		efree(lcname);
 	} else {
-		phpdbg_error("print", "type=\"noclass\" class=\"%s\"", "The class %s could not be found", param->method.class);
+		phpdbg_error("The class %s could not be found", param->method.class);
 	}
 
 	return SUCCESS;
@@ -230,33 +224,28 @@ PHPDBG_PRINT(func) /* {{{ */
 
 			func_table = &EG(scope)->function_table;
 		} else {
-			phpdbg_error("inactive", "type=\"noclasses\"", "No active class");
+			phpdbg_error("No active class");
 			return SUCCESS;
 		}
 	} else if (!EG(function_table)) {
-		phpdbg_error("inactive", "type=\"function_table\"", "No function table loaded");
+		phpdbg_error("No function table loaded");
 		return SUCCESS;
 	} else {
 		func_table = EG(function_table);
 	}
 
-	lcname = zend_str_tolower_dup(func_name, func_name_len);
+	lcname  = zend_str_tolower_dup(func_name, func_name_len);
 
-	phpdbg_try_access {
-		if (zend_hash_find(func_table, lcname, func_name_len + 1, (void **) &fbc) == SUCCESS) {
-			phpdbg_notice("printinfo", "type=\"%s\" flags=\"%s\" symbol=\"%s\" num=\"%d\"", "%s %s %s (%d ops)",
-				(fbc->type == ZEND_USER_FUNCTION) ? "User" : "Internal",
-				(fbc->common.scope) ? "Method" : "Function",
-				fbc->common.function_name,
-				(fbc->type == ZEND_USER_FUNCTION) ? fbc->op_array.last : 0);
+	if (zend_hash_find(func_table, lcname, strlen(lcname)+1, (void**)&fbc) == SUCCESS) {
+		phpdbg_notice("%s %s %s",
+			(fbc->type == ZEND_USER_FUNCTION) ? "User" : "Internal",
+			(fbc->common.scope) ? "Method" : "Function",
+			fbc->common.function_name);
 
-			phpdbg_print_function_helper(fbc TSRMLS_CC);
-		} else {
-			phpdbg_error("print", "type=\"nofunction\" function=\"%s\"", "The function %s could not be found", func_name);
-		}
-	} phpdbg_catch_access {
-		phpdbg_error("signalsegv", "function=\"%.*s\"", "Couldn't fetch function %.*s, invalid data source", (int) func_name_len, func_name);
-	} phpdbg_end_try_access();
+		phpdbg_print_function_helper(fbc TSRMLS_CC);
+	} else {
+		phpdbg_error("The function %s could not be found", func_name);
+	}
 
 	efree(lcname);
 
diff --git a/sapi/phpdbg/phpdbg_prompt.c b/sapi/phpdbg/phpdbg_prompt.c
index 915bccfa69..d91ef3f3f5 100644
--- a/sapi/phpdbg/phpdbg_prompt.c
+++ b/sapi/phpdbg/phpdbg_prompt.c
@@ -23,11 +23,11 @@
 #include "zend.h"
 #include "zend_compile.h"
 #include "phpdbg.h"
-
 #include "phpdbg_help.h"
 #include "phpdbg_print.h"
 #include "phpdbg_info.h"
 #include "phpdbg_break.h"
+#include "phpdbg_bp.h"
 #include "phpdbg_opcode.h"
 #include "phpdbg_list.h"
 #include "phpdbg_utils.h"
@@ -37,77 +37,56 @@
 #include "phpdbg_frame.h"
 #include "phpdbg_lexer.h"
 #include "phpdbg_parser.h"
-#include "phpdbg_wait.h"
-#include "phpdbg_eol.h"
-
-ZEND_EXTERN_MODULE_GLOBALS(phpdbg);
-extern int phpdbg_startup_run;
-
-#ifdef HAVE_LIBDL
-#ifdef PHP_WIN32
-#include "win32/param.h"
-#include "win32/winutil.h"
-#define GET_DL_ERROR()  php_win_err()
-#elif defined(NETWARE)
-#include <sys/param.h>
-#define GET_DL_ERROR()  dlerror()
-#else
-#include <sys/param.h>
-#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(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(print,   "print something",                          'p', phpdbg_print_commands, 0, 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 informations",               '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 function",                      '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(wait,    "wait for other process",                   'W', NULL, 0, 0),
-	PHPDBG_COMMAND_D(watch,   "set watchpoint",                           'w', phpdbg_watch_commands, "|ss", 0),
-	PHPDBG_COMMAND_D(eol,     "set EOL",                                  'E', NULL, "|s", 0),
+	PHPDBG_COMMAND_D(exec,    "set execution context",                    'e', NULL, "s"),
+	PHPDBG_COMMAND_D(step,    "step through execution",                   's', NULL, 0),
+	PHPDBG_COMMAND_D(continue,"continue execution",                       'c', NULL, 0),
+	PHPDBG_COMMAND_D(run,     "attempt execution",                        'r', NULL, "|s"),
+	PHPDBG_COMMAND_D(ev,      "evaluate some code",                        0, NULL, "i"),
+	PHPDBG_COMMAND_D(until,   "continue past the current line",           'u', NULL, 0),
+	PHPDBG_COMMAND_D(finish,  "continue past the end of the stack",       'F', NULL, 0),
+	PHPDBG_COMMAND_D(leave,   "continue until the end of the stack",      'L', NULL, 0),
+	PHPDBG_COMMAND_D(print,   "print something",                          'p', phpdbg_print_commands, 0),
+	PHPDBG_COMMAND_D(break,   "set breakpoint",                           'b', phpdbg_break_commands, "|*c"),
+	PHPDBG_COMMAND_D(back,    "show trace",                               't', NULL, "|n"),
+	PHPDBG_COMMAND_D(frame,   "switch to a frame",                        'f', NULL, "|n"),
+	PHPDBG_COMMAND_D(list,    "lists some code",                          'l', phpdbg_list_commands, "*"),
+	PHPDBG_COMMAND_D(info,    "displays some informations",               'i', phpdbg_info_commands, "s"),
+	PHPDBG_COMMAND_D(clean,   "clean the execution environment",          'X', NULL, 0),
+	PHPDBG_COMMAND_D(clear,   "clear breakpoints",                        'C', NULL, 0),
+	PHPDBG_COMMAND_D(help,    "show help menu",                           'h', phpdbg_help_commands, "|s"),
+	PHPDBG_COMMAND_D(set,     "set phpdbg configuration",                 'S', phpdbg_set_commands,   "s"),
+	PHPDBG_COMMAND_D(register,"register a function",                      'R', NULL, "s"),
+	PHPDBG_COMMAND_D(source,  "execute a phpdbginit",                     '<', NULL, "s"),
+	PHPDBG_COMMAND_D(export,  "export breaks to a .phpdbginit script",    '>', NULL, "s"),
+	PHPDBG_COMMAND_D(sh,   	  "shell a command",                           0, NULL, "i"),
+	PHPDBG_COMMAND_D(quit,    "exit phpdbg",                              'q', NULL, 0),
+	PHPDBG_COMMAND_D(watch,   "set watchpoint",                           'w', phpdbg_watch_commands, "|ss"),
 	PHPDBG_END_COMMAND
 }; /* }}} */
 
+ZEND_EXTERN_MODULE_GLOBALS(phpdbg);
+
 static inline int phpdbg_call_register(phpdbg_param_t *stack TSRMLS_DC) /* {{{ */
 {
 	phpdbg_param_t *name = NULL;
 
 	if (stack->type == STACK_PARAM) {
-		char *lc_name;
-
 		name = stack->next;
-
+		
 		if (!name || name->type != STR_PARAM) {
 			return FAILURE;
 		}
+		
+		if (zend_hash_exists(
+				&PHPDBG_G(registered), name->str, name->len+1)) {
 
-		lc_name = zend_str_tolower_dup(name->str, name->len);
-
-		if (zend_hash_exists(&PHPDBG_G(registered), lc_name, name->len+1)) {
 			zval fname, *fretval;
 			zend_fcall_info fci;
 
-			ZVAL_STRINGL(&fname, lc_name, name->len, 1);
+			ZVAL_STRINGL(&fname, name->str, name->len, 1);
 
 			memset(&fci, 0, sizeof(zend_fcall_info));
 
@@ -122,59 +101,62 @@ static inline int phpdbg_call_register(phpdbg_param_t *stack TSRMLS_DC) /* {{{ *
 			if (name->next) {
 				zval params;
 				phpdbg_param_t *next = name->next;
-
+				
 				array_init(&params);
 
 				while (next) {
 					char *buffered = NULL;
-
+					
 					switch (next->type) {
 						case OP_PARAM:
 						case COND_PARAM:
 						case STR_PARAM:
-							add_next_index_stringl(&params, next->str, next->len, 1);
+							add_next_index_stringl(
+								&params,
+								next->str,
+								next->len, 1);
 						break;
-
+						
 						case NUMERIC_PARAM:
 							add_next_index_long(&params, next->num);
 						break;
-
+						
 						case METHOD_PARAM:
 							spprintf(&buffered, 0, "%s::%s",
 								next->method.class, next->method.name);
 							add_next_index_string(&params, buffered, 0);
 						break;
-
+						
 						case NUMERIC_METHOD_PARAM:
 							spprintf(&buffered, 0, "%s::%s#%ld",
 								next->method.class, next->method.name, next->num);
 							add_next_index_string(&params, buffered, 0);
 						break;
-
+						
 						case NUMERIC_FUNCTION_PARAM:
 							spprintf(&buffered, 0, "%s#%ld",
 								next->str, next->num);
 							add_next_index_string(&params, buffered, 0);
 						break;
-
+							
 						case FILE_PARAM:
-							spprintf(&buffered, 0, "%s:%ld",
+							spprintf(&buffered, 0, "%s:%ld", 
 								next->file.name, next->file.line);
 							add_next_index_string(&params, buffered, 0);
 						break;
-
+						
 						case NUMERIC_FILE_PARAM:
-							spprintf(&buffered, 0, "%s:#%ld",
+							spprintf(&buffered, 0, "%s:#%ld", 
 								next->file.name, next->file.line);
 							add_next_index_string(&params, buffered, 0);
 						break;
-
+						
 						default: {
 							/* not yet */
 						}
 					}
-
-					next = next->next;
+					
+					next = next->next;	
 				}
 
 				zend_fcall_info_args(&fci, &params TSRMLS_CC);
@@ -183,157 +165,125 @@ static inline int phpdbg_call_register(phpdbg_param_t *stack TSRMLS_DC) /* {{{ *
 				fci.param_count = 0;
 			}
 
-			phpdbg_activate_err_buf(0 TSRMLS_CC);
-			phpdbg_free_err_buf(TSRMLS_C);
-
-			phpdbg_debug("created %d params from arguments", fci.param_count);
+			phpdbg_debug(
+				"created %d params from arguments",
+				fci.param_count);
 
 			zend_call_function(&fci, NULL TSRMLS_CC);
 
 			if (fretval) {
-				zend_print_zval_r(fretval, 0 TSRMLS_CC);
-				phpdbg_out("\n");
+				zend_print_zval_r(
+					fretval, 0 TSRMLS_CC);
+				phpdbg_writeln(EMPTY);
 			}
 
 			zval_dtor(&fname);
-			efree(lc_name);
 
 			return SUCCESS;
-		}
-
-		efree(lc_name);
+		}	
 	}
 
 	return FAILURE;
 } /* }}} */
 
-struct phpdbg_init_state {
-	int line;
-	zend_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 TSRMLS_DC) {
-	size_t cmd_len = strlen(cmd);
-
-	state->line++;
-
-	while (cmd_len > 0L && isspace(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" TSRMLS_CC);
-					free(state->code);
-					state->code = NULL;
-					return;
-				}
-			}
-		}
-
-		if (state->in_code) {
-			if (state->code == NULL) {
-				state->code = malloc(cmd_len + 1);
-			} else {
-				state->code = realloc(state->code, state->code_len + cmd_len + 1);
-			}
-
-			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 TSRMLS_CC);
-			phpdbg_param_t stack;
-
-			phpdbg_init_param(&stack, STACK_PARAM);
-
-			phpdbg_activate_err_buf(1 TSRMLS_CC);
-
-			if (phpdbg_do_parse(&stack, input TSRMLS_CC) <= 0) {
-				switch (phpdbg_stack_execute(&stack, 1 /* allow_async_unsafe == 1 */ TSRMLS_CC)) {
-					case FAILURE:
-						phpdbg_activate_err_buf(0 TSRMLS_CC);
-						if (phpdbg_call_register(&stack TSRMLS_CC) == FAILURE) {
-							if (state->init_file) {
-								phpdbg_output_err_buf("initfailure", "%b file=\"%s\" line=\"%d\" input=\"%s\"", "Unrecognized command in %s:%d: %s, %b!" TSRMLS_CC, state->init_file, state->line, input);
-							} else {
-								phpdbg_output_err_buf("initfailure", "%b line=\"%d\" input=\"%s\"", "Unrecognized command on line %d: %s, %b!" TSRMLS_CC, state->line, input);
-							}
-						}
-					break;
-				}
-			}
-
-			phpdbg_activate_err_buf(0 TSRMLS_CC);
-			phpdbg_free_err_buf(TSRMLS_C);
-
-			phpdbg_stack_free(&stack);
-			phpdbg_destroy_input(&input TSRMLS_CC);
-		} 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 TSRMLS_DC) {
-	struct phpdbg_init_state state = {0};
-	char *str = strtok(buffer, "\n");
-
-	while (str) {
-		phpdbg_line_init(str, &state TSRMLS_CC);
-
-		str = strtok(NULL, "\n");
-	}
-
-	if (state.code) {
-		free(state.code);
-	}
-}
-
 void phpdbg_try_file_init(char *init_file, size_t init_file_len, zend_bool free_init TSRMLS_DC) /* {{{ */
 {
 	struct stat sb;
-
+	
 	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};
+			int line = 1;
 
-			state.init_file = init_file;
+			char cmd[PHPDBG_MAX_CMD];
+			size_t cmd_len = 0L;
+			char *code = NULL;
+			size_t code_len = 0L;
+			zend_bool in_code = 0;
 
 			while (fgets(cmd, PHPDBG_MAX_CMD, fp) != NULL) {
-				phpdbg_line_init(cmd, &state TSRMLS_CC);
+				cmd_len = strlen(cmd)-1;
+
+				while (cmd_len > 0L && isspace(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) {
+							in_code = 1;
+							goto next_line;
+						} else {
+							if (memcmp(cmd, ":>", sizeof(":>")-1) == SUCCESS) {
+								in_code = 0;
+								code[code_len] = '\0';
+								{
+									zend_eval_stringl(
+										code, code_len, NULL, "phpdbginit code" TSRMLS_CC);
+								}
+								free(code);
+								code = NULL;
+								goto next_line;
+							}
+						}
+					}
+
+					if (in_code) {
+						if (code == NULL) {
+							code = malloc(cmd_len + 1);
+						} else code = realloc(code, code_len + cmd_len + 1);
+
+						if (code) {
+							memcpy(
+								&code[code_len], cmd, cmd_len);
+							code_len += cmd_len;
+						}
+						goto next_line;
+					}
+
+					{
+						char *why = NULL;
+						char *input = phpdbg_read_input(cmd TSRMLS_CC);
+						phpdbg_param_t stack;
+
+						phpdbg_init_param(&stack, STACK_PARAM);
+
+						if (phpdbg_do_parse(&stack, input TSRMLS_CC) <= 0) {
+							switch (phpdbg_stack_execute(&stack, &why TSRMLS_CC)) {
+								case FAILURE:
+//									if (!(PHPDBG_G(flags) & PHPDBG_IS_QUITTING)) {
+										if (phpdbg_call_register(&stack TSRMLS_CC) == FAILURE) {
+											phpdbg_error(
+												"Unrecognized command in %s:%d: %s, %s!", 
+												init_file, line, input, why);
+										}
+//									}
+								break;
+							}
+						}
+
+						if (why) {
+							free(why);
+							why = NULL;
+						}
+
+						phpdbg_stack_free(&stack);
+						phpdbg_destroy_input(&input TSRMLS_CC);
+					}
+				}
+next_line:
+				line++;
 			}
 
-			if (state.code) {
-				free(state.code);
+			if (code) {
+				free(code);
 			}
 
 			fclose(fp);
 		} else {
-			phpdbg_error("initfailure", "type=\"openfile\" file=\"%s\"", "Failed to open %s for initialization", init_file);
+			phpdbg_error(
+				"Failed to open %s for initialization", init_file);
 		}
 
 		if (free_init) {
@@ -365,7 +315,8 @@ void phpdbg_init(char *init_file, size_t init_file_len, zend_bool use_default TS
 				scan_dir[i] = 0;
 			}
 
-			asprintf(&init_file, "%s/%s", scan_dir, PHPDBG_INIT_FILENAME);
+			asprintf(
+				&init_file, "%s/%s", scan_dir, PHPDBG_INIT_FILENAME);
 			phpdbg_try_file_init(init_file, strlen(init_file), 1 TSRMLS_CC);
 			if (i == -1) {
 				break;
@@ -389,47 +340,38 @@ PHPDBG_COMMAND(exec) /* {{{ */
 			size_t res_len = strlen(res);
 
 			if ((res_len != PHPDBG_G(exec_len)) || (memcmp(res, PHPDBG_G(exec), res_len) != SUCCESS)) {
-				if (EG(in_execution)) {
-					if (phpdbg_ask_user_permission("Do you really want to stop execution to set a new execution context?" TSRMLS_CC) == FAILURE) {
-						return FAILURE;
-					}
-				}
 
 				if (PHPDBG_G(exec)) {
-					phpdbg_notice("exec", "type=\"unset\" context=\"%s\"", "Unsetting old execution context: %s", PHPDBG_G(exec));
+					phpdbg_notice("Unsetting old execution context: %s", PHPDBG_G(exec));
 					efree(PHPDBG_G(exec));
 					PHPDBG_G(exec) = NULL;
 					PHPDBG_G(exec_len) = 0L;
 				}
 
 				if (PHPDBG_G(ops)) {
-					phpdbg_notice("exec", "type=\"unsetops\"", "Destroying compiled opcodes");
+					phpdbg_notice("Destroying compiled opcodes");
 					phpdbg_clean(0 TSRMLS_CC);
 				}
 
 				PHPDBG_G(exec) = res;
 				PHPDBG_G(exec_len) = res_len;
-
-				VCWD_CHDIR_FILE(res);
-
+				
 				*SG(request_info).argv = PHPDBG_G(exec);
 				php_hash_environment(TSRMLS_C);
 
-				phpdbg_notice("exec", "type=\"set\" context=\"%s\"", "Set execution context: %s", PHPDBG_G(exec));
+				phpdbg_notice("Set execution context: %s", PHPDBG_G(exec));
 
-				if (EG(in_execution)) {
-					phpdbg_clean(1 TSRMLS_CC);
+				if (phpdbg_compile(TSRMLS_C) == FAILURE) {
+					phpdbg_error("Failed to compile %s", PHPDBG_G(exec));
 				}
-
-				phpdbg_compile(TSRMLS_C);
 			} else {
-				phpdbg_notice("exec", "type=\"unchanged\"", "Execution context not changed");
+				phpdbg_notice("Execution context not changed");
 			}
 		} else {
-			phpdbg_error("exec", "type=\"invalid\" context=\"%s\"", "Cannot use %s as execution context, not a valid file or symlink", param->str);
+			phpdbg_error("Cannot use %s as execution context, not a valid file or symlink", param->str);
 		}
 	} else {
-		phpdbg_error("exec", "type=\"notfound\" context=\"%s\"", "Cannot stat %s, ensure the file exists", param->str);
+		phpdbg_error("Cannot stat %s, ensure the file exists", param->str);
 	}
 	return SUCCESS;
 } /* }}} */
@@ -439,19 +381,27 @@ int phpdbg_compile(TSRMLS_D) /* {{{ */
 	zend_file_handle fh;
 
 	if (!PHPDBG_G(exec)) {
-		phpdbg_error("inactive", "type=\"nocontext\"", "No execution context");
+		phpdbg_error("No execution context");
+		return SUCCESS;
+	}
+
+	if (EG(in_execution)) {
+		phpdbg_error("Cannot compile while in execution");
 		return FAILURE;
 	}
 
-	if (php_stream_open_for_zend_ex(PHPDBG_G(exec), &fh, USE_PATH|STREAM_OPEN_FOR_INCLUDE TSRMLS_CC) == SUCCESS) {
+	phpdbg_notice("Attempting compilation of %s", PHPDBG_G(exec));
+
+	if (php_stream_open_for_zend_ex(PHPDBG_G(exec), &fh,
+		USE_PATH|STREAM_OPEN_FOR_INCLUDE TSRMLS_CC) == SUCCESS) {
+
 		PHPDBG_G(ops) = zend_compile_file(&fh, ZEND_INCLUDE TSRMLS_CC);
 		zend_destroy_file_handle(&fh TSRMLS_CC);
 
-		phpdbg_notice("compile", "context=\"%s\"", "Successful compilation of %s", PHPDBG_G(exec));
-
+		phpdbg_notice("Success");
 		return SUCCESS;
 	} else {
-		phpdbg_error("compile", "type=\"openfailure\" context=\"%s\"", "Could not open file %s", PHPDBG_G(exec));
+		phpdbg_error("Could not open file %s", PHPDBG_G(exec));
 	}
 
 	return FAILURE;
@@ -474,18 +424,23 @@ PHPDBG_COMMAND(continue) /* {{{ */
 PHPDBG_COMMAND(until) /* {{{ */
 {
 	if (!EG(in_execution)) {
-		phpdbg_error("inactive", "type=\"noexec\"", "Not executing");
+		phpdbg_error("Not executing");
 		return SUCCESS;
 	}
 
 	PHPDBG_G(flags) |= PHPDBG_IN_UNTIL;
 	{
-		zend_uint next = 0, self = (EG(current_execute_data)->opline - EG(active_op_array)->opcodes);
+		zend_uint next = 0,
+				  self = (EG(current_execute_data)->opline - EG(active_op_array)->opcodes);
 		zend_op  *opline = &EG(active_op_array)->opcodes[self];
 
 		for (next = self; next < EG(active_op_array)->last; next++) {
 			if (EG(active_op_array)->opcodes[next].lineno != opline->lineno) {
-				zend_hash_index_update(&PHPDBG_G(seek), (zend_ulong) &EG(active_op_array)->opcodes[next], &EG(active_op_array)->opcodes[next], sizeof(zend_op), NULL);
+				zend_hash_index_update(
+					&PHPDBG_G(seek),
+					(zend_ulong) &EG(active_op_array)->opcodes[next],
+					&EG(active_op_array)->opcodes[next],
+					sizeof(zend_op), NULL);
 				break;
 			}
 		}
@@ -497,13 +452,14 @@ PHPDBG_COMMAND(until) /* {{{ */
 PHPDBG_COMMAND(finish) /* {{{ */
 {
 	if (!EG(in_execution)) {
-		phpdbg_error("inactive", "type=\"noexec\"", "Not executing");
+		phpdbg_error("Not executing");
 		return SUCCESS;
 	}
 
 	PHPDBG_G(flags) |= PHPDBG_IN_FINISH;
 	{
-		zend_uint next = 0, self = (EG(current_execute_data)->opline - EG(active_op_array)->opcodes);
+		zend_uint next = 0,
+				  self = (EG(current_execute_data)->opline - EG(active_op_array)->opcodes);
 
 		for (next = self; next < EG(active_op_array)->last; next++) {
 			switch (EG(active_op_array)->opcodes[next].opcode) {
@@ -513,7 +469,11 @@ PHPDBG_COMMAND(finish) /* {{{ */
 #ifdef ZEND_YIELD
 				case ZEND_YIELD:
 #endif
-					zend_hash_index_update(&PHPDBG_G(seek), (zend_ulong) &EG(active_op_array)->opcodes[next], &EG(active_op_array)->opcodes[next], sizeof(zend_op), NULL);
+					zend_hash_index_update(
+						&PHPDBG_G(seek),
+						(zend_ulong) &EG(active_op_array)->opcodes[next],
+						&EG(active_op_array)->opcodes[next],
+						sizeof(zend_op), NULL);
 				break;
 			}
 		}
@@ -525,13 +485,14 @@ PHPDBG_COMMAND(finish) /* {{{ */
 PHPDBG_COMMAND(leave) /* {{{ */
 {
 	if (!EG(in_execution)) {
-		phpdbg_error("inactive", "type=\"noexec\"", "Not executing");
+		phpdbg_error("Not executing");
 		return SUCCESS;
 	}
 
 	PHPDBG_G(flags) |= PHPDBG_IN_LEAVE;
 	{
-		zend_uint next = 0, self = (EG(current_execute_data)->opline - EG(active_op_array)->opcodes);
+		zend_uint next = 0,
+				  self = (EG(current_execute_data)->opline - EG(active_op_array)->opcodes);
 
 		for (next = self; next < EG(active_op_array)->last; next++) {
 			switch (EG(active_op_array)->opcodes[next].opcode) {
@@ -541,7 +502,11 @@ PHPDBG_COMMAND(leave) /* {{{ */
 #ifdef ZEND_YIELD
 				case ZEND_YIELD:
 #endif
-					zend_hash_index_update(&PHPDBG_G(seek), (zend_ulong) &EG(active_op_array)->opcodes[next], &EG(active_op_array)->opcodes[next], sizeof(zend_op), NULL);
+					zend_hash_index_update(
+						&PHPDBG_G(seek),
+						(zend_ulong) &EG(active_op_array)->opcodes[next],
+						&EG(active_op_array)->opcodes[next],
+						sizeof(zend_op), NULL);
 				break;
 			}
 		}
@@ -553,10 +518,8 @@ PHPDBG_COMMAND(leave) /* {{{ */
 PHPDBG_COMMAND(frame) /* {{{ */
 {
 	if (!param) {
-		phpdbg_notice("frame", "id=\"%d\"", "Currently in frame #%d", PHPDBG_G(frame).num);
-	} else {
-		phpdbg_switch_frame(param->num TSRMLS_CC);
-	}
+		phpdbg_notice("Currently in frame #%d", PHPDBG_G(frame).num);
+	} else phpdbg_switch_frame(param->num TSRMLS_CC);
 
 	return SUCCESS;
 } /* }}} */
@@ -565,7 +528,9 @@ static inline void phpdbg_handle_exception(TSRMLS_D) /* }}} */
 {
 	zend_fcall_info fci;
 
-	zval fname, *trace, exception;
+	zval fname,
+		 *trace,
+		 exception;
 
 	/* get filename and linenumber before unsetting exception */
 	const char *filename = zend_get_executed_filename(TSRMLS_C);
@@ -576,6 +541,10 @@ static inline void phpdbg_handle_exception(TSRMLS_D) /* }}} */
 	zval_copy_ctor(&exception);
 	EG(exception) = NULL;
 
+	phpdbg_error(
+		"Uncaught %s!",
+		Z_OBJCE(exception)->name);
+
 	/* call __toString */
 	ZVAL_STRINGL(&fname, "__tostring", sizeof("__tostring")-1, 1);
 	fci.size = sizeof(fci);
@@ -590,15 +559,16 @@ static inline void phpdbg_handle_exception(TSRMLS_D) /* }}} */
 	zend_call_function(&fci, NULL TSRMLS_CC);
 
 	if (trace) {
-		phpdbg_writeln("exception", "name=\"%s\" trace=\"%.*s\"", "Uncaught %s!\n%.*s", Z_OBJCE(exception)->name, Z_STRLEN_P(trace), Z_STRVAL_P(trace));
-
+		phpdbg_writeln(
+			"Uncaught %s", Z_STRVAL_P(trace));
+		/* remember to dtor trace */
 		zval_ptr_dtor(&trace);
-	} else {
-		phpdbg_error("exception", "name=\"%s\"", "Uncaught %s!", Z_OBJCE(exception)->name);
 	}
 
 	/* output useful information about address */
-	phpdbg_writeln("exception", "opline=\"%p\" file=\"%s\" line=\"%u\"", "Stack entered at %p in %s on line %u", EG(active_op_array)->opcodes, filename, lineno);
+	phpdbg_writeln(
+		"Stacked entered at %p in %s on line %u",
+		EG(active_op_array)->opcodes, filename, lineno);
 
 	zval_dtor(&fname);
 	zval_dtor(&exception);
@@ -606,24 +576,21 @@ static inline void phpdbg_handle_exception(TSRMLS_D) /* }}} */
 
 PHPDBG_COMMAND(run) /* {{{ */
 {
+	if (EG(in_execution)) {
+		phpdbg_error("Cannot start another execution while one is in progress");
+		return SUCCESS;
+	}
+
 	if (PHPDBG_G(ops) || PHPDBG_G(exec)) {
 		zend_op **orig_opline = EG(opline_ptr);
 		zend_op_array *orig_op_array = EG(active_op_array);
 		zval **orig_retval_ptr = EG(return_value_ptr_ptr);
 		zend_bool restore = 1;
 		zend_execute_data *ex = EG(current_execute_data);
-
-		if (EG(in_execution)) {
-			if (phpdbg_ask_user_permission("Do you really want to restart execution?" TSRMLS_CC) == SUCCESS) {
-				phpdbg_startup_run++;
-				phpdbg_clean(1 TSRMLS_CC);
-			}
-			return SUCCESS;
-		}
-
+		
 		if (!PHPDBG_G(ops)) {
 			if (phpdbg_compile(TSRMLS_C) == FAILURE) {
-				phpdbg_error("compile", "type=\"compilefailure\" context=\"%s\"", "Failed to compile %s, cannot run", PHPDBG_G(exec));
+				phpdbg_error("Failed to compile %s, cannot run", PHPDBG_G(exec));
 				goto out;
 			}
 		}
@@ -652,7 +619,7 @@ PHPDBG_COMMAND(run) /* {{{ */
 			int argc = 0;
 			int i;
 			char *argv_str = strtok(param->str, " ");
-
+			
 			while (argv_str) {
 				if (argc >= 4 && argc == (argc & -argc)) {
 					argv = erealloc(argv, (argc * 2 + 1) * sizeof(char *));
@@ -668,35 +635,27 @@ PHPDBG_COMMAND(run) /* {{{ */
 			efree(SG(request_info).argv);
 			SG(request_info).argv = erealloc(argv, ++argc * sizeof(char *));
 			SG(request_info).argc = argc;
-
+			
 			php_hash_environment(TSRMLS_C);
 		}
 
 		zend_try {
-			PHPDBG_G(flags) &= ~PHPDBG_IS_INTERACTIVE;
-			PHPDBG_G(flags) |= PHPDBG_IS_RUNNING;
+			php_output_activate(TSRMLS_C);
+			PHPDBG_G(flags) ^= PHPDBG_IS_INTERACTIVE;
 			zend_execute(EG(active_op_array) TSRMLS_CC);
-			PHPDBG_G(flags) |= PHPDBG_IS_INTERACTIVE;
+			PHPDBG_G(flags) ^= PHPDBG_IS_INTERACTIVE;
+			php_output_deactivate(TSRMLS_C);
 		} zend_catch {
 			EG(active_op_array) = orig_op_array;
 			EG(opline_ptr) = orig_opline;
 			EG(return_value_ptr_ptr) = orig_retval_ptr;
 
-			if (PHPDBG_G(flags) & PHPDBG_IS_QUITTING) {
-				zend_bailout();
-			}
-
-			if (!(PHPDBG_G(flags) & PHPDBG_IS_STOPPING)) {
-				phpdbg_error("stop", "type=\"bailout\"", "Caught exit/error from VM");
+			if (!(PHPDBG_G(flags) & PHPDBG_IS_QUITTING)) {
+				phpdbg_error("Caught exit/error from VM");
 				restore = 0;
 			}
 		} zend_end_try();
 
-		if (PHPDBG_G(socket_fd) != -1) {
-			close(PHPDBG_G(socket_fd));
-			PHPDBG_G(socket_fd) = -1;
-		}
-
 		if (restore) {
 			if (EG(exception)) {
 				phpdbg_handle_exception(TSRMLS_C);
@@ -706,12 +665,8 @@ PHPDBG_COMMAND(run) /* {{{ */
 			EG(opline_ptr) = orig_opline;
 			EG(return_value_ptr_ptr) = orig_retval_ptr;
 		}
-
-		phpdbg_clean(1 TSRMLS_CC);
-
-		PHPDBG_G(flags) &= ~PHPDBG_IS_RUNNING;
 	} else {
-		phpdbg_error("inactive", "type=\"nocontext\"", "Nothing to execute!");
+		phpdbg_error("Nothing to execute!");
 	}
 
 out:
@@ -719,94 +674,43 @@ out:
 	return SUCCESS;
 } /* }}} */
 
-int phpdbg_output_ev_variable(char *name, size_t len, char *keyname, size_t keylen, HashTable *parent, zval **zv TSRMLS_DC) {
-	phpdbg_notice("eval", "variable=\"%.*s\"", "Printing variable %.*s", (int) len, name);
-	phpdbg_xml("<eval %r>");
-	zend_print_zval_r(*zv, 0 TSRMLS_CC);
-	phpdbg_xml("</eval>");
-	phpdbg_out("\n");
-
-	efree(name);
-	efree(keyname);
-
-	return SUCCESS;
-}
-
 PHPDBG_COMMAND(ev) /* {{{ */
 {
-	zend_bool stepping = ((PHPDBG_G(flags) & PHPDBG_IS_STEPPING) == PHPDBG_IS_STEPPING);
+	zend_bool stepping = ((PHPDBG_G(flags) & PHPDBG_IS_STEPPING)==PHPDBG_IS_STEPPING);
 	zval retval;
 
-	zend_op **orig_opline = EG(opline_ptr);
-	zend_op_array *orig_op_array = EG(active_op_array);
-	zval **orig_retval_ptr = EG(return_value_ptr_ptr);
-	zend_execute_data *ex = EG(current_execute_data);
-	HashTable *original_active_symbol_table = EG(active_symbol_table);
-	zval *original_This = EG(This);
-	zend_class_entry *original_scope = EG(scope);
-	zend_class_entry *original_called_scope = EG(called_scope);
-	zend_vm_stack original_stack = EG(argument_stack);
-
-	PHPDBG_OUTPUT_BACKUP();
-
-	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 TSRMLS_CC);
-		} phpdbg_catch_access {
-			phpdbg_error("signalsegv", "", "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;
+		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" TSRMLS_CC) == SUCCESS) {
-			phpdbg_xml("<eval %r>");
-			if (PHPDBG_G(flags) & PHPDBG_WRITE_XML) {
-				zval *zvp = &retval;
-				phpdbg_xml_var_dump(&zvp TSRMLS_CC);
-			}
-			zend_print_zval_r(&retval, 0 TSRMLS_CC);
-			phpdbg_xml("</eval>");
-			phpdbg_out("\n");
+		if (zend_eval_stringl(param->str, param->len,
+			&retval, "eval()'d code" TSRMLS_CC) == SUCCESS) {
+			zend_print_zval_r(
+				&retval, 0 TSRMLS_CC);
+			phpdbg_writeln(EMPTY);
 			zval_dtor(&retval);
 		}
-	} zend_catch {
-		EG(active_op_array) = orig_op_array;
-		EG(opline_ptr) = orig_opline;
-		EG(return_value_ptr_ptr) = orig_retval_ptr;
-		EG(current_execute_data) = ex;
-		EG(active_symbol_table) = original_active_symbol_table;
-		EG(This) = original_This;
-		EG(scope) = original_scope;
-		EG(called_scope) = original_called_scope;
-		EG(argument_stack) = original_stack;
 	} zend_end_try();
 	PHPDBG_G(flags) &= ~PHPDBG_IN_EVAL;
 
 	/* switch stepping back on */
-	if (stepping && !(PHPDBG_G(flags) & PHPDBG_IS_STEPONEVAL)) {
+	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 (!EG(in_execution)) {
-		phpdbg_error("inactive", "type=\"noexec\"", "Not executing!");
+		phpdbg_error("Not executing!");
 		return SUCCESS;
 	}
 
@@ -821,54 +725,62 @@ PHPDBG_COMMAND(back) /* {{{ */
 
 PHPDBG_COMMAND(print) /* {{{ */
 {
-	phpdbg_out("Execution Context Information\n\n");
-	phpdbg_xml("<printinfo %r>");
+	phpdbg_writeln(SEPARATE);
+	phpdbg_notice("Execution Context Information");
 #ifdef HAVE_LIBREADLINE
-	phpdbg_writeln("print", "readline=\"yes\"", "Readline   yes");
+	phpdbg_writeln("Readline\tyes");
 #else
-	phpdbg_writeln("print", "readline=\"no\"", "Readline   no");
+	phpdbg_writeln("Readline\tno");
 #endif
 #ifdef HAVE_LIBEDIT
-	phpdbg_writeln("print", "libedit=\"yes\"", "Libedit    yes");
+	phpdbg_writeln("Libedit\t\tyes");
 #else
-	phpdbg_writeln("print", "libedit=\"no\"", "Libedit    no");
+	phpdbg_writeln("Libedit\t\tno");
 #endif
 
-	phpdbg_writeln("print", "context=\"%s\"", "Exec       %s", PHPDBG_G(exec) ? PHPDBG_G(exec) : "none");
-	phpdbg_writeln("print", "compiled=\"%s\"", "Compiled   %s", PHPDBG_G(ops) ? "yes" : "no");
-	phpdbg_writeln("print", "stepping=\"%s\"", "Stepping   %s", (PHPDBG_G(flags) & PHPDBG_IS_STEPPING) ? "on" : "off");
-	phpdbg_writeln("print", "quiet=\"%s\"", "Quietness  %s", (PHPDBG_G(flags) & PHPDBG_IS_QUIET) ? "on" : "off");
-	phpdbg_writeln("print", "oplog=\"%s\"", "Oplog      %s", PHPDBG_G(oplog) ? "on" : "off");
+	phpdbg_writeln("Exec\t\t%s", PHPDBG_G(exec) ? PHPDBG_G(exec) : "none");
+	phpdbg_writeln("Compiled\t%s", PHPDBG_G(ops) ? "yes" : "no");
+	phpdbg_writeln("Stepping\t%s", (PHPDBG_G(flags) & PHPDBG_IS_STEPPING) ? "on" : "off");
+	phpdbg_writeln("Quietness\t%s", (PHPDBG_G(flags) & PHPDBG_IS_QUIET) ? "on" : "off");
+	phpdbg_writeln("Oplog\t\t%s", PHPDBG_G(oplog) ? "on" : "off");
 
 	if (PHPDBG_G(ops)) {
-		phpdbg_writeln("print", "ops=\"%d\"", "Opcodes    %d", PHPDBG_G(ops)->last);
-		phpdbg_writeln("print", "vars=\"%d\"", "Variables  %d", PHPDBG_G(ops)->last_var ? PHPDBG_G(ops)->last_var - 1 : 0);
+		phpdbg_writeln("Opcodes\t\t%d", PHPDBG_G(ops)->last);
+
+		if (PHPDBG_G(ops)->last_var) {
+			phpdbg_writeln("Variables\t%d", PHPDBG_G(ops)->last_var-1);
+		} else {
+			phpdbg_writeln("Variables\tNone");
+		}
 	}
 
-	phpdbg_writeln("print", "executing=\"%d\"", "Executing  %s", EG(in_execution) ? "yes" : "no");
+	phpdbg_writeln("Executing\t%s", EG(in_execution) ? "yes" : "no");
 	if (EG(in_execution)) {
-		phpdbg_writeln("print", "vmret=\"%d\"", "VM Return  %d", PHPDBG_G(vmret));
+		phpdbg_writeln("VM Return\t%d", PHPDBG_G(vmret));
 	}
 
-	phpdbg_writeln("print", "classes=\"%d\"", "Classes    %d", zend_hash_num_elements(EG(class_table)));
-	phpdbg_writeln("print", "functions=\"%d\"", "Functions  %d", zend_hash_num_elements(EG(function_table)));
-	phpdbg_writeln("print", "constants=\"%d\"", "Constants  %d", zend_hash_num_elements(EG(zend_constants)));
-	phpdbg_writeln("print", "includes=\"%d\"", "Included   %d", zend_hash_num_elements(&EG(included_files)));
-	phpdbg_xml("</printinfo>");
+	phpdbg_writeln("Classes\t\t%d", zend_hash_num_elements(EG(class_table)));
+	phpdbg_writeln("Functions\t%d", zend_hash_num_elements(EG(function_table)));
+	phpdbg_writeln("Constants\t%d", zend_hash_num_elements(EG(zend_constants)));
+	phpdbg_writeln("Included\t%d", zend_hash_num_elements(&EG(included_files)));
+
+	phpdbg_writeln(SEPARATE);
 
 	return SUCCESS;
 } /* }}} */
 
 PHPDBG_COMMAND(info) /* {{{ */
 {
-	phpdbg_error("info", "type=\"toofewargs\" expected=\"1\"", "No information command selected!");
+	phpdbg_error(
+		"No information command selected!");
 
 	return SUCCESS;
 } /* }}} */
 
 PHPDBG_COMMAND(set) /* {{{ */
 {
-	phpdbg_error("set", "type=\"toofewargs\" expected=\"1\"", "No set command selected!");
+	phpdbg_error(
+		"No set command selected!");
 
 	return SUCCESS;
 } /* }}} */
@@ -877,8 +789,8 @@ PHPDBG_COMMAND(break) /* {{{ */
 {
 	if (!param) {
 		phpdbg_set_breakpoint_file(
-			zend_get_executed_filename(TSRMLS_C),
-			zend_get_executed_lineno(TSRMLS_C) TSRMLS_CC);
+				zend_get_executed_filename(TSRMLS_C),
+				zend_get_executed_lineno(TSRMLS_C) TSRMLS_CC);
 	} else switch (param->type) {
 		case ADDR_PARAM:
 			phpdbg_set_breakpoint_opline(param->addr TSRMLS_CC);
@@ -887,7 +799,7 @@ PHPDBG_COMMAND(break) /* {{{ */
 			if (PHPDBG_G(exec)) {
 				phpdbg_set_breakpoint_file(phpdbg_current_file(TSRMLS_C), param->num TSRMLS_CC);
 			} else {
-				phpdbg_error("inactive", "type=\"noexec\"", "Execution context not set!");
+				phpdbg_error("Execution context not set!");
 			}
 			break;
 		case METHOD_PARAM:
@@ -925,226 +837,42 @@ PHPDBG_COMMAND(sh) /* {{{ */
 {
 	FILE *fd = NULL;
 	if ((fd=VCWD_POPEN((char*)param->str, "w"))) {
-		/* TODO: do something perhaps ?? do we want input ?? */
+		/* do something perhaps ?? do we want input ?? */
 		fclose(fd);
 	} else {
-		phpdbg_error("sh", "type=\"failure\" smd=\"%s\"", "Failed to execute %s", param->str);
-	}
-
-	return SUCCESS;
-} /* }}} */
-
-static int add_module_info(zend_module_entry *module TSRMLS_DC) {
-	phpdbg_write("module", "name=\"%s\"", "%s\n", module->name);
-	return 0;
-}
-
-static int add_zendext_info(zend_extension *ext TSRMLS_DC) {
-	phpdbg_write("extension", "name=\"%s\"", "%s\n", ext->name);
-	return 0;
-}
-
-PHPDBG_API const char *phpdbg_load_module_or_extension(char **path, char **name TSRMLS_DC) {
-	DL_HANDLE handle;
-	char *extension_dir;
-
-	extension_dir = INI_STR("extension_dir");
-
-	if (strchr(*path, '/') != NULL || strchr(*path, DEFAULT_SLASH) != NULL) {
-		/* path is fine */
-	} else if (extension_dir && extension_dir[0]) {
-		char *libpath;
-		int extension_dir_len = strlen(extension_dir);
-		if (IS_SLASH(extension_dir[extension_dir_len-1])) {
-			spprintf(&libpath, 0, "%s%s", extension_dir, *path); /* SAFE */
-		} else {
-			spprintf(&libpath, 0, "%s%c%s", extension_dir, DEFAULT_SLASH, *path); /* SAFE */
-		}
-		efree(*path);
-		*path = libpath;
-	} else {
-		phpdbg_error("dl", "type=\"relpath\"", "Not a full path given or extension_dir ini setting is not set");
-
-		return NULL;
-	}
-
-	handle = DL_LOAD(*path);
-
-	if (!handle) {
-#if PHP_WIN32
-		char *err = GET_DL_ERROR();
-		if (err && *err != "") {
-			phpdbg_error("dl", "type=\"unknown\"", "%s", err);
-			LocalFree(err);
-		} else {
-			phpdbg_error("dl", "type=\"unknown\"", "Unknown reason");
-		}
-#else
-		phpdbg_error("dl", "type=\"unknown\"", "%s", GET_DL_ERROR());
-#endif
-		return NULL;
-	}
-
-#if ZEND_EXTENSIONS_SUPPORT
-	do {
-		zend_extension *new_extension;
-		zend_extension_version_info *extension_version_info;
-
-		extension_version_info = (zend_extension_version_info *) DL_FETCH_SYMBOL(handle, "extension_version_info");
-		if (!extension_version_info) {
-			extension_version_info = (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("dl", "type=\"wrongapi\" extension=\"%s\" apineeded=\"%d\" apiinstalled=\"%d\"", "%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("dl", "type=\"wrongbuild\" extension=\"%s\" buildneeded=\"%s\" buildinstalled=\"%s\"", "%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("dl", "type=\"startupfailure\" extension=\"%s\"", "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 = (char *) module_entry->name;
-
-		if (strcmp(ZEND_EXTENSION_BUILD_ID, module_entry->build_id)) {
-			phpdbg_error("dl", "type=\"wrongbuild\" module=\"%s\" buildneeded=\"%s\" buildinstalled=\"%s\"",  "%s was built with configuration %s, whereas running engine is %s", module_entry->name, module_entry->build_id, ZEND_EXTENSION_BUILD_ID);
-
-			goto quit;
-		}
-
-		module_entry->type = MODULE_PERSISTENT;
-		module_entry->module_number = zend_next_free_module();
-		module_entry->handle = handle;
-
-		if ((module_entry = zend_register_module_ex(module_entry TSRMLS_CC)) == NULL) {
-			phpdbg_error("dl", "type=\"registerfailure\" module=\"%s\"", "Unable to register module %s", module_entry->name);
-
-			goto quit;
-		}
-
-		if (zend_startup_module_ex(module_entry TSRMLS_CC) == FAILURE) {
-			phpdbg_error("dl", "type=\"startupfailure\" module=\"%s\"", "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 TSRMLS_CC) == FAILURE) {
-				phpdbg_error("dl", "type=\"initfailure\" module=\"%s\"", "Unable to initialize module %s", module_entry->name);
-
-				goto quit;
-			}
-		}
-
-		return "module";
-	} while (0);
-
-	phpdbg_error("dl", "type=\"nophpso\"", "This shared object is nor a Zend extension nor a module");
-
-quit:
-	DL_UNLOAD(handle);
-	return NULL;
-}
-
-PHPDBG_COMMAND(dl) /* {{{ */
-{
-	const char *type;
-	char *name, *path;
-
-	if (!param || param->type == EMPTY_PARAM) {
-		phpdbg_notice("dl", "extensiontype=\"Zend extension\"", "Zend extensions");
-		zend_llist_apply(&zend_extensions, (llist_apply_func_t) add_zendext_info TSRMLS_CC);
-		phpdbg_out("\n");
-		phpdbg_notice("dl", "extensiontype=\"module\"", "Modules");
-		zend_hash_apply(&module_registry, (apply_func_t) add_module_info TSRMLS_CC);
-	} else switch (param->type) {
-		case STR_PARAM:
-#ifdef HAVE_LIBDL
-			path = estrndup(param->str, param->len);
-
-			phpdbg_activate_err_buf(1 TSRMLS_CC);
-			if ((type = phpdbg_load_module_or_extension(&path, &name TSRMLS_CC)) == NULL) {
-				phpdbg_error("dl", "path=\"%s\" %b", "Could not load %s, not found or invalid zend extension / module: %b", path);
-				efree(name);
-			} else {
-				phpdbg_notice("dl", "extensiontype=\"%s\" name=\"%s\" path=\"%s\"", "Successfully loaded the %s %s at path %s", type, name, path);
-			}
-			phpdbg_activate_err_buf(0 TSRMLS_CC);
-			phpdbg_free_err_buf(TSRMLS_C);
-			efree(path);
-#else
-			phpdbg_error("dl", "type=\"unsupported\" path=\"%.*s\"", "Cannot dynamically load %.*s - dynamic modules are not supported", (int) param->len, param->str);
-#endif
-			break;
-
-		phpdbg_default_switch_case();
+		phpdbg_error(
+			"Failed to execute %s", param->str);
 	}
-
+	
 	return SUCCESS;
 } /* }}} */
 
 PHPDBG_COMMAND(source) /* {{{ */
 {
 	struct stat sb;
-
+	
 	if (VCWD_STAT(param->str, &sb) != -1) {
 		phpdbg_try_file_init(param->str, param->len, 0 TSRMLS_CC);
 	} else {
-		phpdbg_error("source", "type=\"notfound\" file=\"%s\"", "Failed to stat %s, file does not exist", param->str);
+		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 TSRMLS_CC);
 		fclose(handle);
 	} else {
-		phpdbg_error("export", "type=\"openfailure\" file=\"%s\"", "Failed to open or create %s, check path and permissions", param->str);
+		phpdbg_error(
+			"Failed to open or create %s, check path and permissions", param->str);
 	}
-
+	
 	return SUCCESS;
 } /* }}} */
 
@@ -1156,15 +884,18 @@ PHPDBG_COMMAND(register) /* {{{ */
 
 	if (!zend_hash_exists(&PHPDBG_G(registered), lcname, lcname_len+1)) {
 		if (zend_hash_find(EG(function_table), lcname, lcname_len+1, (void**) &function) == SUCCESS) {
-			zend_hash_update(&PHPDBG_G(registered), lcname, lcname_len+1, (void*)&function, sizeof(zend_function), NULL);
+			zend_hash_update(
+				&PHPDBG_G(registered), lcname, lcname_len+1, (void*)&function, sizeof(zend_function), NULL);
 			function_add_ref(function);
 
-			phpdbg_notice("register", "function=\"%s\"", "Registered %s", lcname);
+			phpdbg_notice(
+				"Registered %s", lcname);
 		} else {
-			phpdbg_error("register", "type=\"notfound\" function=\"%s\"", "The requested function (%s) could not be found", param->str);
+			phpdbg_error("The requested function (%s) could not be found", param->str);
 		}
 	} else {
-		phpdbg_error("register", "type=\"inuse\" function=\"%s\"", "The requested name (%s) is already in use", lcname);
+		phpdbg_error(
+			"The requested name (%s) is already in use", lcname);
 	}
 
 	efree(lcname);
@@ -1174,9 +905,8 @@ PHPDBG_COMMAND(register) /* {{{ */
 PHPDBG_COMMAND(quit) /* {{{ */
 {
 	/* don't allow this to loop, ever ... */
-	if (!(PHPDBG_G(flags) & PHPDBG_IS_STOPPING)) {
+	if (!(PHPDBG_G(flags) & PHPDBG_IS_QUITTING)) {
 		PHPDBG_G(flags) |= PHPDBG_IS_QUITTING;
-		PHPDBG_G(flags) &= ~(PHPDBG_IS_RUNNING | PHPDBG_IS_CLEANING);
 		zend_bailout();
 	}
 
@@ -1186,45 +916,36 @@ PHPDBG_COMMAND(quit) /* {{{ */
 PHPDBG_COMMAND(clean) /* {{{ */
 {
 	if (EG(in_execution)) {
-		if (phpdbg_ask_user_permission("Do you really want to clean your current environment?" TSRMLS_CC) == FAILURE) {
-			return SUCCESS;
-		}
+		phpdbg_error("Cannot clean environment while executing");
+		return SUCCESS;
 	}
 
-	phpdbg_out("Cleaning Execution Environment\n");
-	phpdbg_xml("<cleaninfo %r>");
+	phpdbg_notice("Cleaning Execution Environment");
 
-	phpdbg_writeln("clean", "classes=\"%d\"", "Classes    %d", zend_hash_num_elements(EG(class_table)));
-	phpdbg_writeln("clean", "functions=\"%d\"", "Functions  %d", zend_hash_num_elements(EG(function_table)));
-	phpdbg_writeln("clean", "constants=\"%d\"", "Constants  %d", zend_hash_num_elements(EG(zend_constants)));
-	phpdbg_writeln("clean", "includes=\"%d\"", "Includes   %d", zend_hash_num_elements(&EG(included_files)));
-
-	PHPDBG_G(flags) &= ~PHPDBG_IS_RUNNING;
+	phpdbg_writeln("Classes\t\t\t%d", zend_hash_num_elements(EG(class_table)));
+	phpdbg_writeln("Functions\t\t%d", zend_hash_num_elements(EG(function_table)));
+	phpdbg_writeln("Constants\t\t%d", zend_hash_num_elements(EG(zend_constants)));
+	phpdbg_writeln("Includes\t\t%d", zend_hash_num_elements(&EG(included_files)));
 
 	phpdbg_clean(1 TSRMLS_CC);
 
-	phpdbg_xml("</cleaninfo>");
-
 	return SUCCESS;
 } /* }}} */
 
 PHPDBG_COMMAND(clear) /* {{{ */
 {
-	phpdbg_out("Clearing Breakpoints\n");
-	phpdbg_xml("<clearinfo %r>");
-
-	phpdbg_writeln("clear", "files=\"%d\"", "File              %d", zend_hash_num_elements(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE]));
-	phpdbg_writeln("clear", "functions=\"%d\"", "Functions         %d", zend_hash_num_elements(&PHPDBG_G(bp)[PHPDBG_BREAK_SYM]));
-	phpdbg_writeln("clear", "methods=\"%d\"", "Methods           %d", zend_hash_num_elements(&PHPDBG_G(bp)[PHPDBG_BREAK_METHOD]));
-	phpdbg_writeln("clear", "oplines=\"%d\"", "Oplines           %d", zend_hash_num_elements(&PHPDBG_G(bp)[PHPDBG_BREAK_OPLINE]));
-	phpdbg_writeln("clear", "fileoplines=\"%d\"", "File oplines      %d", zend_hash_num_elements(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE_OPLINE]));
-	phpdbg_writeln("clear", "functionoplines=\"%d\"", "Function oplines  %d", zend_hash_num_elements(&PHPDBG_G(bp)[PHPDBG_BREAK_FUNCTION_OPLINE]));
-	phpdbg_writeln("clear", "methodoplines=\"%d\"", "Method oplines    %d", zend_hash_num_elements(&PHPDBG_G(bp)[PHPDBG_BREAK_METHOD_OPLINE]));
-	phpdbg_writeln("clear", "eval=\"%d\"", "Conditionals      %d", zend_hash_num_elements(&PHPDBG_G(bp)[PHPDBG_BREAK_COND]));
+	phpdbg_notice("Clearing Breakpoints");
 
-	phpdbg_clear_breakpoints(TSRMLS_C);
+	phpdbg_writeln("File\t\t\t%d", zend_hash_num_elements(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE]));
+	phpdbg_writeln("Functions\t\t%d", zend_hash_num_elements(&PHPDBG_G(bp)[PHPDBG_BREAK_SYM]));
+	phpdbg_writeln("Methods\t\t\t%d", zend_hash_num_elements(&PHPDBG_G(bp)[PHPDBG_BREAK_METHOD]));
+	phpdbg_writeln("Oplines\t\t\t%d", zend_hash_num_elements(&PHPDBG_G(bp)[PHPDBG_BREAK_OPLINE]));
+	phpdbg_writeln("File oplines\t\t\t%d", zend_hash_num_elements(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE_OPLINE]));
+	phpdbg_writeln("Function oplines\t\t\t%d", zend_hash_num_elements(&PHPDBG_G(bp)[PHPDBG_BREAK_FUNCTION_OPLINE]));
+	phpdbg_writeln("Method oplines\t\t\t%d", zend_hash_num_elements(&PHPDBG_G(bp)[PHPDBG_BREAK_METHOD_OPLINE]));
+	phpdbg_writeln("Conditionals\t\t%d", zend_hash_num_elements(&PHPDBG_G(bp)[PHPDBG_BREAK_COND]));
 
-	phpdbg_xml("</clearinfo>");
+	phpdbg_clear_breakpoints(TSRMLS_C);
 
 	return SUCCESS;
 } /* }}} */
@@ -1260,7 +981,7 @@ PHPDBG_COMMAND(watch) /* {{{ */
 	} else switch (param->type) {
 		case STR_PARAM:
 			if (phpdbg_create_var_watchpoint(param->str, param->len TSRMLS_CC) != FAILURE) {
-				phpdbg_notice("watch", "variable=\"%.*s\"", "Set watchpoint on %.*s", (int) param->len, param->str);
+				phpdbg_notice("Set watchpoint on %.*s", (int)param->len, param->str);
 			}
 			break;
 
@@ -1270,77 +991,69 @@ PHPDBG_COMMAND(watch) /* {{{ */
 	return SUCCESS;
 } /* }}} */
 
-int phpdbg_interactive(zend_bool allow_async_unsafe TSRMLS_DC) /* {{{ */
+int phpdbg_interactive(TSRMLS_D) /* {{{ */
 {
 	int ret = SUCCESS;
+	char *why = NULL;
 	char *input = NULL;
 	phpdbg_param_t stack;
 
 	PHPDBG_G(flags) |= PHPDBG_IS_INTERACTIVE;
 
-	while (ret == SUCCESS || ret == FAILURE) {
-		if ((PHPDBG_G(flags) & (PHPDBG_IS_STOPPING | PHPDBG_IS_RUNNING)) == PHPDBG_IS_STOPPING) {
-			zend_bailout();
-		}
-
-		if (!(input = phpdbg_read_input(NULL TSRMLS_CC))) {
-			break;
-		}
+	input = phpdbg_read_input(NULL TSRMLS_CC);
 
+	if (input) {
+		do {
+			phpdbg_init_param(&stack, STACK_PARAM);
 
-		phpdbg_init_param(&stack, STACK_PARAM);
-
-		if (phpdbg_do_parse(&stack, input TSRMLS_CC) <= 0) {
-			phpdbg_activate_err_buf(1 TSRMLS_CC);
+			if (phpdbg_do_parse(&stack, input TSRMLS_CC) <= 0) {
+				switch (ret = phpdbg_stack_execute(&stack, &why TSRMLS_CC)) {
+					case FAILURE:
+						if (!(PHPDBG_G(flags) & PHPDBG_IS_QUITTING)) {
+							if (phpdbg_call_register(&stack TSRMLS_CC) == FAILURE) {
+								if (why) {
+									phpdbg_error("%s", why);
+								}
+							}
+						}
 
-#ifdef PHP_WIN32
-#define PARA ((phpdbg_param_t *)stack.next)->type
-			if (PHPDBG_G(flags) & PHPDBG_IS_REMOTE && (RUN_PARAM == PARA || EVAL_PARAM == PARA)) {
-				sigio_watcher_start();
-			}
-#endif
-			switch (ret = phpdbg_stack_execute(&stack, allow_async_unsafe TSRMLS_CC)) {
-				case FAILURE:
-					if (!(PHPDBG_G(flags) & PHPDBG_IS_STOPPING)) {
-						if (!allow_async_unsafe || phpdbg_call_register(&stack TSRMLS_CC) == FAILURE) {
-							phpdbg_output_err_buf(NULL, "%b", "%b" TSRMLS_CC);
+						if (why) {
+							free(why);
+							why = NULL;
 						}
-					}
-				break;
+					break;
 
-				case PHPDBG_LEAVE:
-				case PHPDBG_FINISH:
-				case PHPDBG_UNTIL:
-				case PHPDBG_NEXT: {
-					phpdbg_activate_err_buf(0 TSRMLS_CC);
-					phpdbg_free_err_buf(TSRMLS_C);
-					if (!EG(in_execution) && !(PHPDBG_G(flags) & PHPDBG_IS_STOPPING)) {
-						phpdbg_error("command", "type=\"noexec\"", "Not running");
+					case PHPDBG_LEAVE:
+					case PHPDBG_FINISH:
+					case PHPDBG_UNTIL:
+					case PHPDBG_NEXT: {
+						if (!EG(in_execution) && !(PHPDBG_G(flags) & PHPDBG_IS_QUITTING)) {
+							phpdbg_error("Not running");
+						}
+						goto out;
 					}
-					break;
 				}
 			}
 
-			phpdbg_activate_err_buf(0 TSRMLS_CC);
-			phpdbg_free_err_buf(TSRMLS_C);
-#ifdef PHP_WIN32
-			if (PHPDBG_G(flags) & PHPDBG_IS_REMOTE && (RUN_PARAM == PARA || EVAL_PARAM == PARA)) {
-				sigio_watcher_stop();
+			if (why) {
+				free(why);
+				why = NULL;
 			}
-#undef PARA
-#endif
-		}
 
-		phpdbg_stack_free(&stack);
-		phpdbg_destroy_input(&input TSRMLS_CC);
-		PHPDBG_G(req_id) = 0;
-		input = NULL;
+			phpdbg_stack_free(&stack);
+			phpdbg_destroy_input(&input TSRMLS_CC);
+
+		} while ((input = phpdbg_read_input(NULL TSRMLS_CC)));
 	}
 
+out:
 	if (input) {
 		phpdbg_stack_free(&stack);
 		phpdbg_destroy_input(&input TSRMLS_CC);
-		PHPDBG_G(req_id) = 0;
+	}
+
+	if (why) {
+		free(why);
 	}
 
 	if (EG(in_execution)) {
@@ -1392,9 +1105,9 @@ static inline zend_execute_data *phpdbg_create_execute_data(zend_op_array *op_ar
 		ZEND_MM_ALIGNED_SIZE(sizeof(zval**) * op_array->last_var * (EG(active_symbol_table) ? 1 : 2)) +
 		ZEND_MM_ALIGNED_SIZE(sizeof(temp_variable)) * op_array->T TSRMLS_CC);
 
-	EX(CVs) = (zval ***)((char *)execute_data + ZEND_MM_ALIGNED_SIZE(sizeof(zend_execute_data)));
-	memset(EX(CVs), 0, sizeof(zval **) * op_array->last_var);
-	EX(Ts) = (temp_variable *)(((char *) EX(CVs)) + ZEND_MM_ALIGNED_SIZE(sizeof(zval **) * op_array->last_var * (EG(active_symbol_table) ? 1 : 2)));
+	EX(CVs) = (zval***)((char*)execute_data + ZEND_MM_ALIGNED_SIZE(sizeof(zend_execute_data)));
+	memset(EX(CVs), 0, sizeof(zval**) * op_array->last_var);
+	EX(Ts) = (temp_variable *)(((char*)EX(CVs)) + ZEND_MM_ALIGNED_SIZE(sizeof(zval**) * op_array->last_var * (EG(active_symbol_table) ? 1 : 2)));
 	EX(fbc) = NULL;
 	EX(called_scope) = NULL;
 	EX(object) = NULL;
@@ -1412,16 +1125,16 @@ static inline zend_execute_data *phpdbg_create_execute_data(zend_op_array *op_ar
 	if (op_array->this_var != -1 && EG(This)) {
  		Z_ADDREF_P(EG(This)); /* For $this pointer */
 		if (!EG(active_symbol_table)) {
-			EX_CV(op_array->this_var) = (zval**) EX_CVs() + (op_array->last_var + op_array->this_var);
+			EX_CV(op_array->this_var) = (zval**)EX_CVs() + (op_array->last_var + op_array->this_var);
 			*EX_CV(op_array->this_var) = EG(This);
 		} else {
-			if (zend_hash_add(EG(active_symbol_table), "this", sizeof("this"), &EG(This), sizeof(zval *), (void **) &EX_CV(op_array->this_var))==FAILURE) {
+			if (zend_hash_add(EG(active_symbol_table), "this", sizeof("this"), &EG(This), sizeof(zval *), (void**)&EX_CV(op_array->this_var))==FAILURE) {
 				Z_DELREF_P(EG(This));
 			}
 		}
 	}
 
-	EX(opline) = op_array->opcodes;
+	EX(opline) = UNEXPECTED((op_array->fn_flags & ZEND_ACC_INTERACTIVE) != 0) && EG(start_op) ? EG(start_op) : op_array->opcodes;
 	EG(opline_ptr) = &EX(opline);
 
 	EX(function_state).function = (zend_function *) op_array;
@@ -1431,27 +1144,6 @@ static inline zend_execute_data *phpdbg_create_execute_data(zend_op_array *op_ar
 #endif
 } /* }}} */
 
-#define DO_INTERACTIVE(allow_async_unsafe) do { \
-	if (!(PHPDBG_G(flags) & PHPDBG_IN_EVAL)) { \
-		phpdbg_list_file( \
-			zend_get_executed_filename(TSRMLS_C), \
-			3, \
-			zend_get_executed_lineno(TSRMLS_C)-1, \
-			zend_get_executed_lineno(TSRMLS_C) \
-			TSRMLS_CC \
-		); \
-	} \
-	\
-	switch (phpdbg_interactive(allow_async_unsafe TSRMLS_CC)) { \
-		case PHPDBG_LEAVE: \
-		case PHPDBG_FINISH: \
-		case PHPDBG_UNTIL: \
-		case PHPDBG_NEXT:{ \
-			goto next; \
-		} \
-	} \
-} while (0)
-
 #if PHP_VERSION_ID >= 50500
 void phpdbg_execute_ex(zend_execute_data *execute_data TSRMLS_DC) /* {{{ */
 {
@@ -1472,10 +1164,6 @@ void phpdbg_execute_ex(zend_op_array *op_array TSRMLS_DC) /* {{{ */
 	}
 #endif
 
-	if ((PHPDBG_G(flags) & PHPDBG_IS_STOPPING) && !(PHPDBG_G(flags) & PHPDBG_IS_RUNNING)) {
-		zend_bailout();
-	}
-
 	EG(in_execution) = 1;
 
 #if PHP_VERSION_ID >= 50500
@@ -1492,17 +1180,41 @@ zend_vm_enter:
 #endif
 
 	while (1) {
+	
 		if ((PHPDBG_G(flags) & PHPDBG_BP_RESOLVE_MASK)) {
 			/* resolve nth opline breakpoints */
 			phpdbg_resolve_op_array_breaks(EG(active_op_array) TSRMLS_CC);
 		}
-
+		
 #ifdef ZEND_WIN32
 		if (EG(timed_out)) {
 			zend_timeout(0);
 		}
 #endif
 
+#define DO_INTERACTIVE() do { \
+	if (!(PHPDBG_G(flags) & PHPDBG_IN_EVAL)) { \
+		phpdbg_list_file( \
+			zend_get_executed_filename(TSRMLS_C), \
+			3, \
+			zend_get_executed_lineno(TSRMLS_C)-1, \
+			zend_get_executed_lineno(TSRMLS_C) \
+			TSRMLS_CC \
+		); \
+	} \
+	\
+/*	do { */\
+		switch (phpdbg_interactive(TSRMLS_C)) { \
+			case PHPDBG_LEAVE: \
+			case PHPDBG_FINISH: \
+			case PHPDBG_UNTIL: \
+			case PHPDBG_NEXT:{ \
+				goto next; \
+			} \
+		} \
+/*	} while (!(PHPDBG_G(flags) & PHPDBG_IS_QUITTING)); */\
+} while (0)
+
 		/* allow conditional breakpoints and
 			initialization to access the vm uninterrupted */
 		if ((PHPDBG_G(flags) & PHPDBG_IN_COND_BP) ||
@@ -1520,7 +1232,8 @@ zend_vm_enter:
 			if (PHPDBG_G(flags) & PHPDBG_IN_UNTIL) {
 				if (zend_hash_index_exists(&PHPDBG_G(seek), address)) {
 					PHPDBG_G(flags) &= ~PHPDBG_IN_UNTIL;
-					zend_hash_clean(&PHPDBG_G(seek));
+					zend_hash_clean(
+						&PHPDBG_G(seek));
 				} else {
 					/* skip possible breakpoints */
 					goto next;
@@ -1531,7 +1244,8 @@ zend_vm_enter:
 			if (PHPDBG_G(flags) & PHPDBG_IN_FINISH) {
 				if (zend_hash_index_exists(&PHPDBG_G(seek), address)) {
 					PHPDBG_G(flags) &= ~PHPDBG_IN_FINISH;
-					zend_hash_clean(&PHPDBG_G(seek));
+					zend_hash_clean(
+						&PHPDBG_G(seek));
 				}
 				/* skip possible breakpoints */
 				goto next;
@@ -1541,12 +1255,14 @@ zend_vm_enter:
 			if (PHPDBG_G(flags) & PHPDBG_IN_LEAVE) {
 				if (zend_hash_index_exists(&PHPDBG_G(seek), address)) {
 					PHPDBG_G(flags) &= ~PHPDBG_IN_LEAVE;
-					zend_hash_clean(&PHPDBG_G(seek));
-					phpdbg_notice("breakpoint", "id=\"leave\" file=\"%s\" line=\"%u\"", "Breaking for leave at %s:%u",
+					zend_hash_clean(
+						&PHPDBG_G(seek));
+					phpdbg_notice(
+						"Breaking for leave at %s:%u",
 						zend_get_executed_filename(TSRMLS_C),
 						zend_get_executed_lineno(TSRMLS_C)
 					);
-					DO_INTERACTIVE(1);
+					DO_INTERACTIVE();
 				} else {
 					/* skip possible breakpoints */
 					goto next;
@@ -1555,17 +1271,18 @@ zend_vm_enter:
 		}
 
 		/* not while in conditionals */
-		phpdbg_print_opline_ex(execute_data, &vars, 0 TSRMLS_CC);
+		phpdbg_print_opline_ex(
+			execute_data, &vars, 0 TSRMLS_CC);
 
 		if (PHPDBG_G(flags) & PHPDBG_IS_STEPPING && (PHPDBG_G(flags) & PHPDBG_STEP_OPCODE || execute_data->opline->lineno != PHPDBG_G(last_line))) {
 			PHPDBG_G(flags) &= ~PHPDBG_IS_STEPPING;
-			DO_INTERACTIVE(1);
+			DO_INTERACTIVE();
 		}
 
 		/* check if some watchpoint was hit */
 		{
 			if (phpdbg_print_changed_zvals(TSRMLS_C) == SUCCESS) {
-				DO_INTERACTIVE(1);
+				DO_INTERACTIVE();
 			}
 		}
 
@@ -1577,36 +1294,21 @@ zend_vm_enter:
 			    && (brake = phpdbg_find_breakpoint(execute_data TSRMLS_CC))
 			    && (brake->type != PHPDBG_BREAK_FILE || execute_data->opline->lineno != PHPDBG_G(last_line))) {
 				phpdbg_hit_breakpoint(brake, 1 TSRMLS_CC);
-				DO_INTERACTIVE(1);
+				DO_INTERACTIVE();
 			}
 		}
 
+next:
 		if (PHPDBG_G(flags) & PHPDBG_IS_SIGNALED) {
+			phpdbg_writeln(EMPTY);
+			phpdbg_notice("Program received signal SIGINT");
 			PHPDBG_G(flags) &= ~PHPDBG_IS_SIGNALED;
-
-			phpdbg_out("\n");
-			phpdbg_notice("signal", "type=\"SIGINT\"", "Program received signal SIGINT");
-			DO_INTERACTIVE(1);
+			DO_INTERACTIVE();
 		}
 
-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_BY_NAME || execute_data->opline->opcode == ZEND_DO_FCALL) && execute_data->function_state.function->type == ZEND_USER_FUNCTION) {
-#if PHP_VERSION_ID < 50500
-			zend_execute = execute;
-#else
-			zend_execute_ex = execute_ex;
-#endif
-		}
 		PHPDBG_G(vmret) = execute_data->opline->handler(execute_data TSRMLS_CC);
-#if PHP_VERSION_ID < 50500
-		zend_execute = phpdbg_execute_ex;
-#else
-		zend_execute_ex = phpdbg_execute_ex;
-#endif
 
 		if (PHPDBG_G(vmret) > 0) {
 			switch (PHPDBG_G(vmret)) {
@@ -1631,47 +1333,3 @@ next:
 	}
 	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(TSRMLS_D) {
-	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->op_array) {
-			phpdbg_notice("hardinterrupt", "opline=\"%p\" num=\"%lu\" file=\"%s\" line=\"%u\"", "Current opline: %p (op #%lu) in %s:%u", data->opline, (data->opline - data->op_array->opcodes) / sizeof(data->opline), data->op_array->filename, data->opline->lineno);
-		} else {
-			phpdbg_notice("hardinterrupt", "opline=\"%p\"", "Current opline: %p (op_array information unavailable)", data->opline);
-		}
-	} else {
-		phpdbg_notice("hardinterrupt", "", "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();
-	}
-}
-
-PHPDBG_COMMAND(eol) /* {{{ */
-{
-	if (!param || param->type == EMPTY_PARAM) {
-		phpdbg_notice("eol", "argument required", "argument required");
-	} else switch (param->type) {
-		case STR_PARAM:
-			if (FAILURE == phpdbg_eol_global_update(param->str TSRMLS_CC)) {
-				phpdbg_notice("eol", "unknown EOL name '%s', give crlf, lf, cr", "unknown EOL name '%s', give  crlf, lf, cr", param->str);
-			}
-			break;
-
-		phpdbg_default_switch_case();
-	}
-
-	return SUCCESS;
-} /* }}} */
-
diff --git a/sapi/phpdbg/phpdbg_prompt.h b/sapi/phpdbg/phpdbg_prompt.h
index f583f2cdcd..ef648aabeb 100644
--- a/sapi/phpdbg/phpdbg_prompt.h
+++ b/sapi/phpdbg/phpdbg_prompt.h
@@ -22,14 +22,11 @@
 #define PHPDBG_PROMPT_H
 
 /* {{{ */
-void phpdbg_string_init(char *buffer TSRMLS_DC);
 void phpdbg_init(char *init_file, size_t init_file_len, zend_bool use_default TSRMLS_DC);
 void phpdbg_try_file_init(char *init_file, size_t init_file_len, zend_bool free_init TSRMLS_DC);
-int phpdbg_interactive(zend_bool allow_async_unsafe TSRMLS_DC);
+int phpdbg_interactive(TSRMLS_D);
 int phpdbg_compile(TSRMLS_D);
-void phpdbg_clean(zend_bool full TSRMLS_DC);
-void phpdbg_force_interruption(TSRMLS_D);
-/* }}} */
+void phpdbg_clean(zend_bool full TSRMLS_DC); /* }}} */
 
 /* {{{ phpdbg command handlers */
 PHPDBG_COMMAND(exec);
@@ -50,15 +47,12 @@ PHPDBG_COMMAND(clean);
 PHPDBG_COMMAND(clear);
 PHPDBG_COMMAND(help);
 PHPDBG_COMMAND(sh);
-PHPDBG_COMMAND(dl);
 PHPDBG_COMMAND(set);
 PHPDBG_COMMAND(source);
 PHPDBG_COMMAND(export);
 PHPDBG_COMMAND(register);
 PHPDBG_COMMAND(quit);
-PHPDBG_COMMAND(watch);
-PHPDBG_COMMAND(eol);
-PHPDBG_COMMAND(wait); /* }}} */
+PHPDBG_COMMAND(watch); /* }}} */
 
 /* {{{ prompt commands */
 extern const phpdbg_command_t phpdbg_prompt_commands[]; /* }}} */
diff --git a/sapi/phpdbg/phpdbg_rinit_hook.c b/sapi/phpdbg/phpdbg_rinit_hook.c
deleted file mode 100644
index acbdfb6f25..0000000000
--- a/sapi/phpdbg/phpdbg_rinit_hook.c
+++ /dev/null
@@ -1,105 +0,0 @@
-/*
-   +----------------------------------------------------------------------+
-   | PHP Version 5                                                        |
-   +----------------------------------------------------------------------+
-   | Copyright (c) 1997-2014 The PHP Group                                |
-   +----------------------------------------------------------------------+
-   | This source file is subject to version 3.01 of the PHP license,      |
-   | that is bundled with this package in the file LICENSE, and is        |
-   | available through the world-wide-web at the following url:           |
-   | http://www.php.net/license/3_01.txt                                  |
-   | If you did not receive a copy of the PHP license and are unable to   |
-   | obtain it through the world-wide-web, please send a note to          |
-   | license@php.net so we can mail you a copy immediately.               |
-   +----------------------------------------------------------------------+
-   | Authors: Bob Weinand <bwoebi@php.net>                                |
-   +----------------------------------------------------------------------+
-*/
-
-#include "phpdbg_rinit_hook.h"
-#include "php_ini.h"
-#include <errno.h>
-
-ZEND_DECLARE_MODULE_GLOBALS(phpdbg_webhelper);
-
-PHP_INI_BEGIN()
-	STD_PHP_INI_ENTRY("phpdbg.auth", "", PHP_INI_SYSTEM | PHP_INI_PERDIR, OnUpdateString, auth, zend_phpdbg_webhelper_globals, phpdbg_webhelper_globals)
-	STD_PHP_INI_ENTRY("phpdbg.path", "", PHP_INI_SYSTEM | PHP_INI_PERDIR, OnUpdateString, path, zend_phpdbg_webhelper_globals, phpdbg_webhelper_globals)
-PHP_INI_END()
-
-static inline void php_phpdbg_webhelper_globals_ctor(zend_phpdbg_webhelper_globals *pg) /* {{{ */
-{
-} /* }}} */
-
-static PHP_MINIT_FUNCTION(phpdbg_webhelper) /* {{{ */
-{
-	if (!strcmp(sapi_module.name, PHPDBG_NAME)) {
-		return SUCCESS;
-	}
-
-	ZEND_INIT_MODULE_GLOBALS(phpdbg_webhelper, php_phpdbg_webhelper_globals_ctor, NULL);
-	REGISTER_INI_ENTRIES();
-
-	return SUCCESS;
-} /* }}} */
-
-static PHP_RINIT_FUNCTION(phpdbg_webhelper) /* {{{ */
-{
-	zval *cookies = PG(http_globals)[TRACK_VARS_COOKIE];
-	zval **auth;
-
-	if (!cookies || zend_hash_find(Z_ARRVAL_P(cookies), PHPDBG_NAME "_AUTH_COOKIE", sizeof(PHPDBG_NAME "_AUTH_COOKIE"), (void **) &auth) == FAILURE || Z_STRLEN_PP(auth) != strlen(PHPDBG_WG(auth)) || strcmp(Z_STRVAL_PP(auth), PHPDBG_WG(auth))) {
-		return SUCCESS;
-	}
-
-#ifndef _WIN32
-	{
-		struct sockaddr_un sock;
-		int s = socket(AF_UNIX, SOCK_STREAM, 0);
-		int len = strlen(PHPDBG_WG(path)) + sizeof(sock.sun_family);
-		char buf[(1 << 8) + 1];
-		int buflen;
-		sock.sun_family = AF_UNIX;
-		strcpy(sock.sun_path, PHPDBG_WG(path));
-
-		if (connect(s, (struct sockaddr *)&sock, len) == -1) {
-			zend_error(E_ERROR, "Unable to connect to UNIX domain socket at %s defined by phpdbg.path ini setting. Reason: %s", PHPDBG_WG(path), strerror(errno));
-		}
-
-		char *msg = NULL;
-		char msglen[5] = {0};
-		phpdbg_webdata_compress(&msg, (int *)msglen TSRMLS_CC);
-
-		send(s, msglen, 4, 0);
-		send(s, msg, *(int *) msglen, 0);
-
-		while ((buflen = recv(s, buf, sizeof(buf) - 1, 0)) > 0) {
-			php_write(buf, buflen TSRMLS_CC);
-		}
-
-		close(s);
-
-		php_output_flush_all(TSRMLS_C);
-		zend_bailout();
-	}
-#endif
-
-	return SUCCESS;
-} /* }}} */
-
-zend_module_entry phpdbg_webhelper_module_entry = {
-	STANDARD_MODULE_HEADER,
-	"phpdbg_webhelper",
-	NULL,
-	PHP_MINIT(phpdbg_webhelper),
-	NULL,
-	PHP_RINIT(phpdbg_webhelper),
-	NULL,
-	NULL,
-	PHPDBG_VERSION,
-	STANDARD_MODULE_PROPERTIES
-};
-
-#ifdef COMPILE_DL_PHPDBG_WEBHELPER
-ZEND_GET_MODULE(phpdbg_webhelper)
-#endif
diff --git a/sapi/phpdbg/phpdbg_rinit_hook.h b/sapi/phpdbg/phpdbg_rinit_hook.h
deleted file mode 100644
index d28be10f8c..0000000000
--- a/sapi/phpdbg/phpdbg_rinit_hook.h
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
-   +----------------------------------------------------------------------+
-   | PHP Version 5                                                        |
-   +----------------------------------------------------------------------+
-   | Copyright (c) 1997-2014 The PHP Group                                |
-   +----------------------------------------------------------------------+
-   | This source file is subject to version 3.01 of the PHP license,      |
-   | that is bundled with this package in the file LICENSE, and is        |
-   | available through the world-wide-web at the following url:           |
-   | http://www.php.net/license/3_01.txt                                  |
-   | If you did not receive a copy of the PHP license and are unable to   |
-   | obtain it through the world-wide-web, please send a note to          |
-   | license@php.net so we can mail you a copy immediately.               |
-   +----------------------------------------------------------------------+
-   | Authors: Felipe Pena <felipe@php.net>                                |
-   | Authors: Joe Watkins <joe.watkins@live.co.uk>                        |
-   | Authors: Bob Weinand <bwoebi@php.net>                                |
-   +----------------------------------------------------------------------+
-*/
-
-#ifndef PHPDBG_WEBHELPER_H
-#define PHPDBG_WEBHELPER_H
-
-#include "phpdbg_webdata_transfer.h"
-
-extern zend_module_entry phpdbg_webhelper_module_entry;
-#define phpext_phpdbg_webhelper_ptr &phpdbg_webhelper_module_entry
-
-#ifdef ZTS
-# define PHPDBG_WG(v) TSRMG(phpdbg_webhelper_globals_id, zend_phpdbg_webhelper_globals *, v)
-#else
-# define PHPDBG_WG(v) (phpdbg_webhelper_globals.v)
-#endif
-
-/* {{{ structs */
-ZEND_BEGIN_MODULE_GLOBALS(phpdbg_webhelper)
-	char *auth;
-	char *path;
-ZEND_END_MODULE_GLOBALS(phpdbg_webhelper) /* }}} */
-
-#endif /* PHPDBG_WEBHELPER_H */
diff --git a/sapi/phpdbg/phpdbg_set.c b/sapi/phpdbg/phpdbg_set.c
index fc7e788fa0..54269a8193 100644
--- a/sapi/phpdbg/phpdbg_set.c
+++ b/sapi/phpdbg/phpdbg_set.c
@@ -27,32 +27,30 @@
 
 ZEND_EXTERN_MODULE_GLOBALS(phpdbg);
 
-#define PHPDBG_SET_COMMAND_D(f, h, a, m, l, s, flags) \
-	PHPDBG_COMMAND_D_EXP(f, h, a, m, l, s, &phpdbg_prompt_commands[18], flags)
+#define PHPDBG_SET_COMMAND_D(f, h, a, m, l, s) \
+	PHPDBG_COMMAND_D_EXP(f, h, a, m, l, s, &phpdbg_prompt_commands[18])
 
 const phpdbg_command_t phpdbg_set_commands[] = {
-	PHPDBG_SET_COMMAND_D(prompt,       "usage: set prompt [<string>]",            'p', set_prompt,       NULL, "|s", 0),
+	PHPDBG_SET_COMMAND_D(prompt,       "usage: set prompt [<string>]",            'p', set_prompt,       NULL, "|s"),
 #ifndef _WIN32
-	PHPDBG_SET_COMMAND_D(color,        "usage: set color  <element> <color>",     'c', set_color,        NULL, "ss", PHPDBG_ASYNC_SAFE),
-	PHPDBG_SET_COMMAND_D(colors,       "usage: set colors [<on|off>]",            'C', set_colors,       NULL, "|b", PHPDBG_ASYNC_SAFE),
+	PHPDBG_SET_COMMAND_D(color,        "usage: set color  <element> <color>",     'c', set_color,        NULL, "ss"),
+	PHPDBG_SET_COMMAND_D(colors,       "usage: set colors [<on|off>]",            'C', set_colors,       NULL, "|b"),
 #endif
-	PHPDBG_SET_COMMAND_D(oplog,        "usage: set oplog  [<output>]",            'O', set_oplog,        NULL, "|s", 0),
-	PHPDBG_SET_COMMAND_D(break,        "usage: set break id [<on|off>]",          'b', set_break,        NULL, "l|b", PHPDBG_ASYNC_SAFE),
-	PHPDBG_SET_COMMAND_D(breaks,       "usage: set breaks [<on|off>]",            'B', set_breaks,       NULL, "|b", PHPDBG_ASYNC_SAFE),
-	PHPDBG_SET_COMMAND_D(quiet,        "usage: set quiet [<on|off>]",             'q', set_quiet,        NULL, "|b", PHPDBG_ASYNC_SAFE),
-	PHPDBG_SET_COMMAND_D(stepping,     "usage: set stepping [<line|op>]",         's', set_stepping,     NULL, "|s", PHPDBG_ASYNC_SAFE),
-	PHPDBG_SET_COMMAND_D(refcount,     "usage: set refcount [<on|off>]",          'r', set_refcount,     NULL, "|b", PHPDBG_ASYNC_SAFE),
+	PHPDBG_SET_COMMAND_D(oplog,        "usage: set oplog  [<output>]",            'O', set_oplog,        NULL, "|s"),
+	PHPDBG_SET_COMMAND_D(break,        "usage: set break id [<on|off>]",          'b', set_break,        NULL, "l|b"),
+	PHPDBG_SET_COMMAND_D(breaks,       "usage: set breaks [<on|off>]",            'B', set_breaks,       NULL, "|b"),
+	PHPDBG_SET_COMMAND_D(quiet,        "usage: set quiet [<on|off>]",             'q', set_quiet,        NULL, "|b"),
+	PHPDBG_SET_COMMAND_D(stepping,     "usage: set stepping [<line|op>]",         's', set_stepping,     NULL, "|s"),
+	PHPDBG_SET_COMMAND_D(refcount,     "usage: set refcount [<on|off>]",          'r', set_refcount,     NULL, "|b"),
 	PHPDBG_END_COMMAND
 };
 
 PHPDBG_SET(prompt) /* {{{ */
 {
 	if (!param || param->type == EMPTY_PARAM) {
-		phpdbg_writeln("setprompt", "str=\"%s\"", "Current prompt: %s", phpdbg_get_prompt(TSRMLS_C));
-	} else {
-		phpdbg_set_prompt(param->str TSRMLS_CC);
-	}
-
+		phpdbg_writeln("%s", phpdbg_get_prompt(TSRMLS_C));
+	} else phpdbg_set_prompt(param->str TSRMLS_CC);
+	
 	return SUCCESS;
 } /* }}} */
 
@@ -63,21 +61,21 @@ PHPDBG_SET(break) /* {{{ */
 			if (param->next) {
 				if (param->next->num) {
 					phpdbg_enable_breakpoint(param->num TSRMLS_CC);
-				} else {
-					phpdbg_disable_breakpoint(param->num TSRMLS_CC);
-				}
+				} else phpdbg_disable_breakpoint(param->num TSRMLS_CC);
 			} else {
 				phpdbg_breakbase_t *brake = phpdbg_find_breakbase(param->num TSRMLS_CC);
 				if (brake) {
-					phpdbg_writeln("setbreak", "id=\"%ld\" active=\"%s\"", "Breakpoint #%ld %s", param->num, brake->disabled ? "off" : "on");
+					phpdbg_writeln(
+						"%s", brake->disabled ? "off" : "on");
 				} else {
-					phpdbg_error("setbreak", "type=\"nobreak\" id=\"%ld\"", "Failed to find breakpoint #%ld", param->num);
+					phpdbg_error("Failed to find breakpoint #%ld", param->num);
 				}
 			}
 		} break;
 
 		default:
-			phpdbg_error("setbreak", "type=\"wrongargs\"", "set break used incorrectly: set break [id] <on|off>");
+			phpdbg_error(
+				"set break used incorrectly: set break [id] <on|off>");
 	}
 
 	return SUCCESS;
@@ -86,18 +84,18 @@ PHPDBG_SET(break) /* {{{ */
 PHPDBG_SET(breaks) /* {{{ */
 {
 	if (!param || param->type == EMPTY_PARAM) {
-		phpdbg_writeln("setbreaks", "active=\"%s\"", "Breakpoints %s",PHPDBG_G(flags) & PHPDBG_IS_BP_ENABLED ? "on" : "off");
-	} else switch (param->type) {
+		phpdbg_writeln("%s",
+			PHPDBG_G(flags) & PHPDBG_IS_BP_ENABLED ? "on" : "off");
+	} else switch (param->type) {	
 		case NUMERIC_PARAM: {
 			if (param->num) {
 				phpdbg_enable_breakpoints(TSRMLS_C);
-			} else {
-				phpdbg_disable_breakpoints(TSRMLS_C);
-			}
+			} else phpdbg_disable_breakpoints(TSRMLS_C);
 		} break;
 
 		default:
-			phpdbg_error("setbreaks", "type=\"wrongargs\"", "set breaks used incorrectly: set breaks <on|off>");
+			phpdbg_error(
+				"set break used incorrectly: set break [id] <on|off>");
 	}
 
 	return SUCCESS;
@@ -106,35 +104,41 @@ PHPDBG_SET(breaks) /* {{{ */
 #ifndef _WIN32
 PHPDBG_SET(color) /* {{{ */
 {
-	const phpdbg_color_t *color = phpdbg_get_color(param->next->str, param->next->len TSRMLS_CC);
-
+	const phpdbg_color_t *color = phpdbg_get_color(
+			param->next->str, param->next->len TSRMLS_CC);
+	
 	if (!color) {
-		phpdbg_error("setcolor", "type=\"nocolor\"", "Failed to find the requested color (%s)", param->next->str);
+		phpdbg_error(
+			"Failed to find the requested color (%s)", param->next->str);
 		return SUCCESS;
 	}
-
+	
 	switch (phpdbg_get_element(param->str, param->len TSRMLS_CC)) {
 		case PHPDBG_COLOR_PROMPT:
-			phpdbg_notice("setcolor", "type=\"prompt\" color=\"%s\" code=\"%s\"", "setting prompt color to %s (%s)", color->name, color->code);
+			phpdbg_notice(
+				"setting prompt color to %s (%s)", color->name, color->code);
 			if (PHPDBG_G(prompt)[1]) {
 				free(PHPDBG_G(prompt)[1]);
 				PHPDBG_G(prompt)[1]=NULL;
 			}
 			phpdbg_set_color(PHPDBG_COLOR_PROMPT, color TSRMLS_CC);
 		break;
-
+		
 		case PHPDBG_COLOR_ERROR:
-			phpdbg_notice("setcolor", "type=\"error\" color=\"%s\" code=\"%s\"", "setting error color to %s (%s)", color->name, color->code);
+			phpdbg_notice(
+				"setting error color to %s (%s)", color->name, color->code);
 			phpdbg_set_color(PHPDBG_COLOR_ERROR, color TSRMLS_CC);
 		break;
-
+		
 		case PHPDBG_COLOR_NOTICE:
-			phpdbg_notice("setcolor", "type=\"notice\" color=\"%s\" code=\"%s\"", "setting notice color to %s (%s)", color->name, color->code);
+			phpdbg_notice(
+				"setting notice color to %s (%s)", color->name, color->code);
 			phpdbg_set_color(PHPDBG_COLOR_NOTICE, color TSRMLS_CC);
 		break;
-
+		
 		default:
-			phpdbg_error("setcolor", "type=\"invalidtype\"", "Failed to find the requested element (%s)", param->str);
+			phpdbg_error(
+				"Failed to find the requested element (%s)", param->str);
 	}
 
 	return SUCCESS;
@@ -143,7 +147,7 @@ PHPDBG_SET(color) /* {{{ */
 PHPDBG_SET(colors) /* {{{ */
 {
 	if (!param || param->type == EMPTY_PARAM) {
-		phpdbg_writeln("setcolors", "active=\"%s\"", "Colors %s", PHPDBG_G(flags) & PHPDBG_IS_COLOURED ? "on" : "off");
+		phpdbg_writeln("%s", PHPDBG_G(flags) & PHPDBG_IS_COLOURED ? "on" : "off");
 	} else switch (param->type) {
 		case NUMERIC_PARAM: {
 			if (param->num) {
@@ -152,9 +156,10 @@ PHPDBG_SET(colors) /* {{{ */
 				PHPDBG_G(flags) &= ~PHPDBG_IS_COLOURED;
 			}
 		} break;
-
+		
 		default:
-			phpdbg_error("setcolors", "type=\"wrongargs\"", "set colors used incorrectly: set colors <on|off>");
+			phpdbg_error(
+				"set colors used incorrectly: set colors <on|off>");
 	}
 
 	return SUCCESS;
@@ -164,7 +169,7 @@ PHPDBG_SET(colors) /* {{{ */
 PHPDBG_SET(oplog) /* {{{ */
 {
 	if (!param || param->type == EMPTY_PARAM) {
-		phpdbg_notice("setoplog", "active=\"%s\"", "Oplog %s", PHPDBG_G(oplog) ? "on" : "off");
+		phpdbg_notice("Oplog %s", PHPDBG_G(oplog) ? "enabled" : "disabled");
 	} else switch (param->type) {
 		case STR_PARAM: {
 			/* open oplog */
@@ -172,15 +177,14 @@ PHPDBG_SET(oplog) /* {{{ */
 
 			PHPDBG_G(oplog) = fopen(param->str, "w+");
 			if (!PHPDBG_G(oplog)) {
-				phpdbg_error("setoplog", "type=\"openfailure\" file=\"%s\"", "Failed to open %s for oplog", param->str);
+				phpdbg_error("Failed to open %s for oplog", param->str);
 				PHPDBG_G(oplog) = old;
 			} else {
 				if (old) {
-					phpdbg_notice("setoplog", "type=\"closingold\"", "Closing previously open oplog");
+					phpdbg_notice("Closing previously open oplog");
 					fclose(old);
 				}
-
-				phpdbg_notice("setoplog", "file=\"%s\"", "Successfully opened oplog %s", param->str);
+				phpdbg_notice("Successfully opened oplog %s", param->str);
 			}
 		} break;
 
@@ -193,7 +197,8 @@ PHPDBG_SET(oplog) /* {{{ */
 PHPDBG_SET(quiet) /* {{{ */
 {
 	if (!param || param->type == EMPTY_PARAM) {
-		phpdbg_writeln("setquiet", "active=\"%s\"", "Quietness %s", PHPDBG_G(flags) & PHPDBG_IS_QUIET ? "on" : "off");
+		phpdbg_writeln("Quietness %s", 
+			PHPDBG_G(flags) & PHPDBG_IS_QUIET ? "on" : "off");
 	} else switch (param->type) {
 		case NUMERIC_PARAM: {
 			if (param->num) {
@@ -212,15 +217,18 @@ PHPDBG_SET(quiet) /* {{{ */
 PHPDBG_SET(stepping) /* {{{ */
 {
 	if (!param || param->type == EMPTY_PARAM) {
-		phpdbg_writeln("setstepping", "type=\"%s\"", "Stepping %s", PHPDBG_G(flags) & PHPDBG_STEP_OPCODE ? "opcode" : "line");
+		phpdbg_writeln("Stepping %s",
+			PHPDBG_G(flags) & PHPDBG_STEP_OPCODE ? "opcode" : "line");
 	} else switch (param->type) {
-		case STR_PARAM: {
-			if ((param->len == sizeof("opcode") - 1) && memcmp(param->str, "opcode", sizeof("opcode")) == SUCCESS) {
+		case STR_PARAM: {	
+			if ((param->len == sizeof("opcode")-1) &&
+				(memcmp(param->str, "opcode", sizeof("opcode")) == SUCCESS)) {
 				PHPDBG_G(flags) |= PHPDBG_STEP_OPCODE;
-			} else if ((param->len == sizeof("line")-1) && memcmp(param->str, "line", sizeof("line")) == SUCCESS) {
+			} else if ((param->len == sizeof("line")-1) &&
+				(memcmp(param->str, "line", sizeof("line")) == SUCCESS)) {
 				PHPDBG_G(flags) &= ~PHPDBG_STEP_OPCODE;
 			} else {
-				phpdbg_error("setstepping", "type=\"wrongargs\"", "usage set stepping [<opcode|line>]");
+				phpdbg_error("usage set stepping [<opcode|line>]");
 			}
 		} break;
 
@@ -233,7 +241,7 @@ PHPDBG_SET(stepping) /* {{{ */
 PHPDBG_SET(refcount) /* {{{ */
 {
 	if (!param || param->type == EMPTY_PARAM) {
-		phpdbg_writeln("setrefcount", "active=\"%s\"", "Showing refcounts %s", PHPDBG_G(flags) & PHPDBG_IS_QUIET ? "on" : "off");
+		phpdbg_writeln("Refcount %s", PHPDBG_G(flags) & PHPDBG_IS_QUIET ? "on" : "off");
 	} else switch (param->type) {
 		case NUMERIC_PARAM: {
 			if (param->num) {
diff --git a/sapi/phpdbg/phpdbg_sigio_win32.c b/sapi/phpdbg/phpdbg_sigio_win32.c
deleted file mode 100644
index 158e034872..0000000000
--- a/sapi/phpdbg/phpdbg_sigio_win32.c
+++ /dev/null
@@ -1,117 +0,0 @@
-/*
-   +----------------------------------------------------------------------+
-   | PHP Version 5                                                        |
-   +----------------------------------------------------------------------+
-   | Copyright (c) 7-4 The PHP Group                                      |
-   +----------------------------------------------------------------------+
-   | This source file is subject to version 3.01 of the PHP license,      |
-   | that is bundled with this package in the file LICENSE, and is        |
-   | available through the world-wide-web at the following url:           |
-   | http://www.php.net/license/3_01.txt                                  |
-   | If you did not receive a copy of the PHP license and are unable to   |
-   | obtain it through the world-wide-web, please send a note to          |
-   | license@php.net so we can mail you a copy immediately.               |
-   +----------------------------------------------------------------------+
-   | Authors: Anatol Belski <ab@php.net>                                  |
-   +----------------------------------------------------------------------+
-*/
-
-
-#include <signal.h>
-
-#include "phpdbg.h"
-#include "phpdbg_sigio_win32.h"
-
-
-ZEND_EXTERN_MODULE_GLOBALS(phpdbg);
-
-
-VOID
-SigIoWatcherThread(VOID *p)
-{
-	zend_uchar sig;
-	struct win32_sigio_watcher_data *swd = (struct win32_sigio_watcher_data *)p;
-#ifdef ZTS
-	void ***tsrm_ls = swd->tsrm_ls;
-#endif
-
-top:
-	(void)phpdbg_consume_bytes(swd->fd, &sig, 1, -1 TSRMLS_CC);
-
-
-	if (3 == sig) {
-		/* XXX completely not sure it is done right here */
-		if (PHPDBG_G(flags) & PHPDBG_IS_INTERACTIVE) {
-			if (raise(sig)) {
-				goto top;
-			}
-		}
-		if (PHPDBG_G(flags) & PHPDBG_IS_SIGNALED) {
-			phpdbg_set_sigsafe_mem(&sig TSRMLS_CC);
-			zend_try {
-				phpdbg_force_interruption(TSRMLS_C);
-			} zend_end_try();
-			phpdbg_clear_sigsafe_mem(TSRMLS_C);
-			goto end;
-		}
-		if (!(PHPDBG_G(flags) & PHPDBG_IS_INTERACTIVE)) {
-			PHPDBG_G(flags) |= PHPDBG_IS_SIGNALED;
-		}
-end:
-		/* XXX set signaled flag to the caller thread, question is - whether it's needed */
-		ExitThread(sig);
-	} else {
-		goto top;
-	}
-}
-
-
-/* Start this only for the time of the run or eval command,
-for so long that the main thread is busy serving some debug
-session. */
-void
-sigio_watcher_start(void)
-{
-	TSRMLS_FETCH();
-
-	PHPDBG_G(swd).fd = PHPDBG_G(io)[PHPDBG_STDIN].fd;
-#ifdef ZTS
-	PHPDBG_G(swd).tsrm_ls = tsrm_ls;
-#endif
-
-	PHPDBG_G(sigio_watcher_thread) = CreateThread(
-		NULL,
-		0,
-		(LPTHREAD_START_ROUTINE)SigIoWatcherThread,
-		&PHPDBG_G(swd),
-		0,
-		NULL);
-}
-
-void
-sigio_watcher_stop(void)
-{
-	DWORD waited;
-	TSRMLS_FETCH();
-
-	if (INVALID_HANDLE_VALUE == PHPDBG_G(sigio_watcher_thread)) {
-		/* it probably did bail out already */
-		return;
-	}
-
-	waited = WaitForSingleObject(PHPDBG_G(sigio_watcher_thread), 300);
-
-	if (WAIT_OBJECT_0 != waited) {
-		if (!CancelSynchronousIo(PHPDBG_G(sigio_watcher_thread))) {
-			/* error out */
-		}
-
-		if (!TerminateThread(PHPDBG_G(sigio_watcher_thread), 0)) {
-			/* error out */
-		}
-	}
-
-	PHPDBG_G(swd).fd = -1;
-	PHPDBG_G(sigio_watcher_thread) = INVALID_HANDLE_VALUE;
-}
-
diff --git a/sapi/phpdbg/phpdbg_sigio_win32.h b/sapi/phpdbg/phpdbg_sigio_win32.h
deleted file mode 100644
index 8c8a381d64..0000000000
--- a/sapi/phpdbg/phpdbg_sigio_win32.h
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
-   +----------------------------------------------------------------------+
-   | PHP Version 5                                                        |
-   +----------------------------------------------------------------------+
-   | Copyright (c) 7-4 The PHP Group                                      |
-   +----------------------------------------------------------------------+
-   | This source file is subject to version 3.01 of the PHP license,      |
-   | that is bundled with this package in the file LICENSE, and is        |
-   | available through the world-wide-web at the following url:           |
-   | http://www.php.net/license/3_01.txt                                  |
-   | If you did not receive a copy of the PHP license and are unable to   |
-   | obtain it through the world-wide-web, please send a note to          |
-   | license@php.net so we can mail you a copy immediately.               |
-   +----------------------------------------------------------------------+
-   | Authors: Anatol Belski <ab@php.net>                                  |
-   +----------------------------------------------------------------------+
-*/
-
-
-#ifndef PHPDBG_SIGIO_WIN32_H
-#define PHPDBG_SIGIO_WIN32_H
-
-#include "phpdbg.h"
-#include "phpdbg_prompt.h"
-#include "phpdbg_io.h"
-
-struct win32_sigio_watcher_data {
-#ifdef ZTS
-	void ***tsrm_ls;
-#endif
-	int fd;
-};
-
-void
-sigio_watcher_start(void);
-
-void
-sigio_watcher_stop(void);
-
-#endif /* PHPDBG_SIGIO_WIN32_H */
diff --git a/sapi/phpdbg/phpdbg_sigsafe.c b/sapi/phpdbg/phpdbg_sigsafe.c
deleted file mode 100644
index 7238ad102f..0000000000
--- a/sapi/phpdbg/phpdbg_sigsafe.c
+++ /dev/null
@@ -1,111 +0,0 @@
-#include "phpdbg_sigsafe.h"
-#include "phpdbg.h"
-
-ZEND_EXTERN_MODULE_GLOBALS(phpdbg);
-
-static inline void zend_mm_init(zend_mm_heap *heap) {
-	zend_mm_free_block *p;
-	int i;
-
-	heap->free_bitmap = 0;
-	heap->large_free_bitmap = 0;
-#if ZEND_MM_CACHE
-	heap->cached = 0;
-	memset(heap->cache, 0, sizeof(heap->cache));
-#endif
-#if ZEND_MM_CACHE_STAT
-	for (i = 0; i < ZEND_MM_NUM_BUCKETS; i++) {
-		heap->cache_stat[i].count = 0;
-	}
-#endif
-	p = ZEND_MM_SMALL_FREE_BUCKET(heap, 0);
-	for (i = 0; i < ZEND_MM_NUM_BUCKETS; i++) {
-		p->next_free_block = p;
-		p->prev_free_block = p;
-		p = (zend_mm_free_block *)((char *)p + sizeof(zend_mm_free_block *) * 2);
-		heap->large_free_buckets[i] = NULL;
-	}
-	heap->rest_buckets[0] = heap->rest_buckets[1] = ZEND_MM_REST_BUCKET(heap);
-	heap->rest_count = 0;
-}
-
-static zend_mm_storage* zend_mm_mem_init(void *params) {
-	TSRMLS_FETCH();
-
-	return &PHPDBG_G(sigsafe_mem).storage;
-}
-
-static void zend_mm_mem_dummy(zend_mm_storage *storage) {
-}
-
-#define STR(x) #x
-#define EXP_STR(x) STR(x)
-
-static zend_mm_segment* zend_mm_mem_alloc(zend_mm_storage *storage, size_t size) {
-	TSRMLS_FETCH();
-
-	if (EXPECTED(size == PHPDBG_SIGSAFE_MEM_SIZE && !PHPDBG_G(sigsafe_mem).allocated)) {
-		PHPDBG_G(sigsafe_mem).allocated = 1;
-		return (zend_mm_segment *) PHPDBG_G(sigsafe_mem).mem;
-	}
-
-	write(PHPDBG_G(io)[PHPDBG_STDERR].fd, ZEND_STRL("Tried to allocate more than " EXP_STR(PHPDBG_SIGSAFE_MEM_SIZE) " bytes from stack memory in signal handler ... bailing out of signal handler\n"));
-
-	if (*EG(bailout)) {
-		LONGJMP(*EG(bailout), FAILURE);
-	}
-
-	write(PHPDBG_G(io)[PHPDBG_STDERR].fd, ZEND_STRL("Bailed out without a bailout address in signal handler!\n"));
-
-	return NULL;
-}
-
-static zend_mm_segment* zend_mm_mem_realloc(zend_mm_storage *storage, zend_mm_segment *ptr, size_t size) {
-	return zend_mm_mem_alloc(storage, size);
-}
-
-static void zend_mm_mem_free(zend_mm_storage *storage, zend_mm_segment *ptr) {
-}
-
-static const zend_mm_mem_handlers phpdbg_handlers_sigsafe_mem = { "stack", zend_mm_mem_init, zend_mm_mem_dummy, zend_mm_mem_dummy, zend_mm_mem_alloc, zend_mm_mem_realloc, zend_mm_mem_free };
-
-void phpdbg_set_sigsafe_mem(char *buffer TSRMLS_DC) {
-	phpdbg_signal_safe_mem *mem = &PHPDBG_G(sigsafe_mem);
-	mem->old_heap = zend_mm_set_heap(&mem->heap TSRMLS_CC);
-	mem->mem = buffer;
-	mem->allocated = 0;
-
-	mem->storage.handlers = &phpdbg_handlers_sigsafe_mem;
-	mem->heap.storage = &mem->storage;
-	mem->heap.block_size = PHPDBG_SIGSAFE_MEM_SIZE;
-	mem->heap.compact_size = 0;
-	mem->heap.segments_list = NULL;
-	zend_mm_init(&mem->heap);
-#if ZEND_MM_CACHE_STAT
-	memset(mem->heap.cache_stat, 0, sizeof(mem->heap.cache_stat));
-#endif
-	mem->heap.use_zend_alloc = 1;
-	mem->heap.real_size = 0;
-	mem->heap.overflow = 0;
-	mem->heap.real_peak = 0;
-	mem->heap.limit = PHPDBG_SIGSAFE_MEM_SIZE;
-	mem->heap.size = 0;
-	mem->heap.peak = 0;
-	mem->heap.internal = 0;
-	mem->heap.reserve = NULL;
-	mem->heap.reserve_size = 0;
-}
-
-zend_mm_heap *phpdbg_original_heap_sigsafe_mem(TSRMLS_D) {
-	return PHPDBG_G(sigsafe_mem).old_heap;
-}
-
-void phpdbg_clear_sigsafe_mem(TSRMLS_D) {
-	zend_mm_set_heap(phpdbg_original_heap_sigsafe_mem(TSRMLS_C) TSRMLS_CC);
-	PHPDBG_G(sigsafe_mem).mem = NULL;
-}
-
-zend_bool phpdbg_active_sigsafe_mem(TSRMLS_D) {
-	return !!PHPDBG_G(sigsafe_mem).mem;
-}
-
diff --git a/sapi/phpdbg/phpdbg_sigsafe.h b/sapi/phpdbg/phpdbg_sigsafe.h
deleted file mode 100644
index 6ed74f53db..0000000000
--- a/sapi/phpdbg/phpdbg_sigsafe.h
+++ /dev/null
@@ -1,25 +0,0 @@
-#ifndef PHPDBG_SIGSAFE_H
-#define PHPDBG_SIGSAFE_H
-
-#include "zend_mm_structs.h"
-
-#define PHPDBG_SIGSAFE_MEM_SIZE (1 << 20)
-
-typedef struct {
-	char *mem;
-	zend_bool allocated;
-	zend_mm_heap heap;
-	zend_mm_heap *old_heap;
-	zend_mm_storage storage;
-} phpdbg_signal_safe_mem;
-
-#include "phpdbg.h"
-
-zend_bool phpdbg_active_sigsafe_mem(TSRMLS_D);
-
-void phpdbg_set_sigsafe_mem(char *mem TSRMLS_DC);
-void phpdbg_clear_sigsafe_mem(TSRMLS_D);
-
-zend_mm_heap *phpdbg_original_heap_sigsafe_mem(TSRMLS_D);
-
-#endif
diff --git a/sapi/phpdbg/phpdbg_utils.c b/sapi/phpdbg/phpdbg_utils.c
index 85b6eeb3b5..3ce2fade17 100644
--- a/sapi/phpdbg/phpdbg_utils.c
+++ b/sapi/phpdbg/phpdbg_utils.c
@@ -18,14 +18,19 @@
    +----------------------------------------------------------------------+
 */
 
+#include <stdio.h>
+#include <ctype.h>
+#include <string.h>
 #include "zend.h"
-
 #include "php.h"
+#include "spprintf.h"
 #include "phpdbg.h"
 #include "phpdbg_opcode.h"
 #include "phpdbg_utils.h"
 
-#if defined(HAVE_SYS_IOCTL_H)
+#ifdef _WIN32
+#	include "win32/time.h"
+#elif defined(HAVE_SYS_IOCTL_H) 
 #	include "sys/ioctl.h"
 #	ifndef GWINSZ_IN_SYS_IOCTL
 #		include <termios.h>
@@ -123,12 +128,12 @@ PHPDBG_API int phpdbg_is_class_method(const char *str, size_t len, char **class,
 	}
 
 	if (class != NULL) {
-
+	
 		if (str[0] == '\\') {
 			str++;
 			len--;
 		}
-
+		
 		*class = estrndup(str, sep - str);
 		(*class)[sep - str] = 0;
 	}
@@ -219,6 +224,103 @@ PHPDBG_API char *phpdbg_trim(const char *str, size_t len, size_t *new_len) /* {{
 
 } /* }}} */
 
+PHPDBG_API int phpdbg_print(int type TSRMLS_DC, FILE *fp, const char *format, ...) /* {{{ */
+{
+	int rc = 0;
+	char *buffer = NULL;
+	va_list args;
+
+	if (format != NULL && strlen(format) > 0L) {
+		va_start(args, format);
+		vspprintf(&buffer, 0, format, args);
+		va_end(args);
+	}
+
+	/* TODO(anyone) colours */
+
+	switch (type) {
+		case P_ERROR:
+			if (PHPDBG_G(flags) & PHPDBG_IS_COLOURED) {
+				rc = fprintf(fp,
+						"\033[%sm[%s]\033[0m\n",
+						PHPDBG_G(colors)[PHPDBG_COLOR_ERROR]->code, buffer);
+			} else {
+				rc = fprintf(fp, "[%s]\n", buffer);
+			}
+		break;
+
+		case P_NOTICE:
+			if (PHPDBG_G(flags) & PHPDBG_IS_COLOURED) {
+				rc = fprintf(fp,
+						"\033[%sm[%s]\033[0m\n",
+						PHPDBG_G(colors)[PHPDBG_COLOR_NOTICE]->code, buffer);
+			} else {
+				rc = fprintf(fp, "[%s]\n", buffer);
+			}
+		break;
+
+		case P_WRITELN: {
+			if (buffer) {
+				rc = fprintf(fp, "%s\n", buffer);
+			} else {
+				rc = fprintf(fp, "\n");
+			}
+		} break;
+
+		case P_WRITE:
+			if (buffer) {
+				rc = fprintf(fp, "%s", buffer);
+			}
+		break;
+
+		/* no formatting on logging output */
+		case P_LOG:
+			if (buffer) {
+				struct timeval tp;
+				if (gettimeofday(&tp, NULL) == SUCCESS) {
+					rc = fprintf(fp, "[%ld %.8F]: %s\n", tp.tv_sec, tp.tv_usec / 1000000.00, buffer);
+				} else {
+					rc = FAILURE;
+				}
+			}
+			break;
+	}
+
+	if (buffer) {
+		efree(buffer);
+	}
+
+	return rc;
+} /* }}} */
+
+PHPDBG_API int phpdbg_rlog(FILE *fp, const char *fmt, ...) { /* {{{ */
+	int rc = 0;
+
+	va_list args;
+	struct timeval tp;
+
+	va_start(args, fmt);
+	if (gettimeofday(&tp, NULL) == SUCCESS) {
+		char friendly[100];
+		char *format = NULL, *buffer = NULL;
+		const time_t tt = tp.tv_sec;
+
+		strftime(friendly, 100, "%a %b %d %T.%%04d %Y", localtime(&tt));
+		asprintf(
+			&buffer, friendly, tp.tv_usec/1000);
+		asprintf(
+			&format, "[%s]: %s\n", buffer, fmt);
+		rc = vfprintf(
+			fp, format, args);
+
+		free(format);
+		free(buffer);
+	}
+	va_end(args);
+
+	return rc;
+} /* }}} */
+
 PHPDBG_API const phpdbg_color_t *phpdbg_get_color(const char *name, size_t name_length TSRMLS_DC) /* {{{ */
 {
 	const phpdbg_color_t *color = colors;
@@ -226,13 +328,15 @@ PHPDBG_API const phpdbg_color_t *phpdbg_get_color(const char *name, size_t name_
 	while (color && color->name) {
 		if (name_length == color->name_length &&
 			memcmp(name, color->name, name_length) == SUCCESS) {
-			phpdbg_debug("phpdbg_get_color(%s, %lu): %s", name, name_length, color->code);
+			phpdbg_debug(
+				"phpdbg_get_color(%s, %lu): %s", name, name_length, color->code);
 			return color;
 		}
 		++color;
 	}
 
-	phpdbg_debug("phpdbg_get_color(%s, %lu): failed", name, name_length);
+	phpdbg_debug(
+		"phpdbg_get_color(%s, %lu): failed", name, name_length);
 
 	return NULL;
 } /* }}} */
@@ -258,7 +362,7 @@ PHPDBG_API const phpdbg_color_t* phpdbg_get_colors(TSRMLS_D) /* {{{ */
 
 PHPDBG_API int phpdbg_get_element(const char *name, size_t len TSRMLS_DC) {
 	const phpdbg_element_t *element = elements;
-
+	
 	while (element && element->name) {
 		if (len == element->name_length) {
 			if (strncasecmp(name, element->name, len) == SUCCESS) {
@@ -267,7 +371,7 @@ PHPDBG_API int phpdbg_get_element(const char *name, size_t len TSRMLS_DC) {
 		}
 		element++;
 	}
-
+	
 	return PHPDBG_COLOR_INVALID;
 }
 
@@ -316,7 +420,7 @@ PHPDBG_API const char *phpdbg_get_prompt(TSRMLS_D) /* {{{ */
 
 int phpdbg_rebuild_symtable(TSRMLS_D) {
 	if (!EG(active_op_array)) {
-		phpdbg_error("inactive", "type=\"op_array\"", "No active op array!");
+		phpdbg_error("No active op array!");
 		return FAILURE;
 	}
 
@@ -324,7 +428,7 @@ int phpdbg_rebuild_symtable(TSRMLS_D) {
 		zend_rebuild_symbol_table(TSRMLS_C);
 
 		if (!EG(active_symbol_table)) {
-			phpdbg_error("inactive", "type=\"symbol_table\"", "No active symbol table!");
+			phpdbg_error("No active symbol table!");
 			return FAILURE;
 		}
 	}
@@ -334,13 +438,13 @@ int phpdbg_rebuild_symtable(TSRMLS_D) {
 
 PHPDBG_API int phpdbg_get_terminal_width(TSRMLS_D) /* {{{ */
 {
-	int columns;
+	int columns;	
 #ifdef _WIN32
 	CONSOLE_SCREEN_BUFFER_INFO csbi;
 
 	GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &csbi);
 	columns = csbi.srWindow.Right - csbi.srWindow.Left + 1;
-#elif defined(HAVE_SYS_IOCTL_H) && defined(TIOCGWINSZ)
+#elif defined(HAVE_SYS_IOCTL_H) && defined (TIOCGWINSZ)
 	struct winsize w;
 
 	columns = ioctl(fileno(stdout), TIOCGWINSZ, &w) == 0 ? w.ws_col : 80;
@@ -349,294 +453,3 @@ PHPDBG_API int phpdbg_get_terminal_width(TSRMLS_D) /* {{{ */
 #endif
 	return columns;
 } /* }}} */
-
-PHPDBG_API void phpdbg_set_async_io(int fd) {
-#ifndef _WIN32
-	int flags;
-	fcntl(STDIN_FILENO, F_SETOWN, getpid());
-	flags = fcntl(STDIN_FILENO, F_GETFL);
-	fcntl(STDIN_FILENO, F_SETFL, flags | FASYNC);
-#endif
-}
-
-int phpdbg_safe_class_lookup(const char *name, int name_length, zend_class_entry ***ce TSRMLS_DC) {
-	if (PHPDBG_G(flags) & PHPDBG_IN_SIGNAL_HANDLER) {
-		char *lc_name, *lc_free;
-		int lc_length, ret = FAILURE;
-
-		if (name == NULL || !name_length) {
-			return FAILURE;
-		}
-
-		lc_free = lc_name = emalloc(name_length + 1);
-		zend_str_tolower_copy(lc_name, name, name_length);
-		lc_length = name_length + 1;
-
-		if (lc_name[0] == '\\') {
-			lc_name += 1;
-			lc_length -= 1;
-		}
-
-		phpdbg_try_access {
-			ret = zend_hash_find(EG(class_table), lc_name, lc_length, (void **) &ce);
-		} phpdbg_catch_access {
-			phpdbg_error("signalsegv", "class=\"%.*s\"", "Could not fetch class %.*s, invalid data source", name_length, name);
-		} phpdbg_end_try_access();
-
-		efree(lc_free);
-		return ret;
-	} else {
-		return zend_lookup_class(name, name_length, ce TSRMLS_CC);
-	}
-}
-
-char *phpdbg_get_property_key(char *key) {
-	if (*key != 0) {
-		return key;
-	}
-	return strchr(key + 1, 0) + 1;
-}
-
-static int phpdbg_parse_variable_arg_wrapper(char *name, size_t len, char *keyname, size_t keylen, HashTable *parent, zval **zv, phpdbg_parse_var_func callback TSRMLS_DC) {
-	return callback(name, len, keyname, keylen, parent, zv TSRMLS_CC);
-}
-
-PHPDBG_API int phpdbg_parse_variable(char *input, size_t len, HashTable *parent, size_t i, phpdbg_parse_var_func callback, zend_bool silent TSRMLS_DC) {
-	return phpdbg_parse_variable_with_arg(input, len, parent, i, (phpdbg_parse_var_with_arg_func) phpdbg_parse_variable_arg_wrapper, silent, callback TSRMLS_CC);
-}
-
-PHPDBG_API int phpdbg_parse_variable_with_arg(char *input, size_t len, HashTable *parent, size_t i, phpdbg_parse_var_with_arg_func callback, zend_bool silent, void *arg TSRMLS_DC) {
-	int ret = FAILURE;
-	zend_bool new_index = 1;
-	char *last_index;
-	size_t index_len = 0;
-	zval **zv;
-
-	if (len < 2 || *input != '$') {
-		goto error;
-	}
-
-	while (i++ < len) {
-		if (i == len) {
-			new_index = 1;
-		} else {
-			switch (input[i]) {
-				case '[':
-					new_index = 1;
-					break;
-				case ']':
-					break;
-				case '>':
-					if (last_index[index_len - 1] == '-') {
-						new_index = 1;
-						index_len--;
-					}
-					break;
-
-				default:
-					if (new_index) {
-						last_index = input + i;
-						new_index = 0;
-					}
-					if (input[i - 1] == ']') {
-						goto error;
-					}
-					index_len++;
-			}
-		}
-
-		if (new_index && index_len == 0) {
-			HashPosition position;
-			for (zend_hash_internal_pointer_reset_ex(parent, &position);
-			     zend_hash_get_current_data_ex(parent, (void **)&zv, &position) == SUCCESS;
-			     zend_hash_move_forward_ex(parent, &position)) {
-				if (i == len || (i == len - 1 && input[len - 1] == ']')) {
-					zval *key = emalloc(sizeof(zval));
-					size_t namelen;
-					char *name;
-					char *keyname = estrndup(last_index, index_len);
-					zend_hash_get_current_key_zval_ex(parent, key, &position);
-					convert_to_string(key);
-					name = emalloc(i + Z_STRLEN_P(key) + 2);
-					namelen = sprintf(name, "%.*s%s%s", (int)i, input, phpdbg_get_property_key(Z_STRVAL_P(key)), input[len - 1] == ']'?"]":"");
-					efree(key);
-
-					ret = callback(name, namelen, keyname, index_len, parent, zv, arg TSRMLS_CC) == SUCCESS || ret == SUCCESS?SUCCESS:FAILURE;
-				} else if (Z_TYPE_PP(zv) == IS_OBJECT) {
-					phpdbg_parse_variable_with_arg(input, len, Z_OBJPROP_PP(zv), i, callback, silent, arg TSRMLS_CC);
-				} else if (Z_TYPE_PP(zv) == IS_ARRAY) {
-					phpdbg_parse_variable_with_arg(input, len, Z_ARRVAL_PP(zv), i, callback, silent, arg TSRMLS_CC);
-				} else {
-					/* Ignore silently */
-				}
-			}
-			return ret;
-		} else if (new_index) {
-			char last_chr = last_index[index_len];
-			last_index[index_len] = 0;
-			if (zend_symtable_find(parent, last_index, index_len + 1, (void **)&zv) == FAILURE) {
-				if (!silent) {
-					phpdbg_error("variable", "type=\"undefined\" variable=\"%.*s\"", "%.*s is undefined", (int) i, input);
-				}
-				return FAILURE;
-			}
-			last_index[index_len] = last_chr;
-			if (i == len) {
-				char *name = estrndup(input, len);
-				char *keyname = estrndup(last_index, index_len);
-
-				ret = callback(name, len, keyname, index_len, parent, zv, arg TSRMLS_CC) == SUCCESS || ret == SUCCESS?SUCCESS:FAILURE;
-			} else if (Z_TYPE_PP(zv) == IS_OBJECT) {
-				parent = Z_OBJPROP_PP(zv);
-			} else if (Z_TYPE_PP(zv) == IS_ARRAY) {
-				parent = Z_ARRVAL_PP(zv);
-			} else {
-				phpdbg_error("variable", "type=\"notiterable\" variable=\"%.*s\"", "%.*s is nor an array nor an object", (int) i, input);
-				return FAILURE;
-			}
-			index_len = 0;
-		}
-	}
-
-	return ret;
-	error:
-		phpdbg_error("variable", "type=\"invalidinput\"", "Malformed input");
-		return FAILURE;
-}
-
-static int phpdbg_xml_array_element_dump(zval **zv TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key) {
-	phpdbg_xml("<element");
-
-	phpdbg_try_access {
-		if (hash_key->nKeyLength == 0) { /* numeric key */
-			phpdbg_xml(" name=\"%ld\"", hash_key->h);
-		} else { /* string key */
-			phpdbg_xml(" name=\"%.*s\"", hash_key->nKeyLength - 1, hash_key->arKey);
-		}
-	} phpdbg_catch_access {
-		phpdbg_xml(" severity=\"error\" ></element>");
-		return 0;
-	} phpdbg_end_try_access();
-
-	phpdbg_xml(">");
-
-	phpdbg_xml_var_dump(zv TSRMLS_CC);
-
-	phpdbg_xml("</element>");
-
-	return 0;
-}
-
-static int phpdbg_xml_object_property_dump(zval **zv TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key) {
-	phpdbg_xml("<property");
-
-	phpdbg_try_access {
-		if (hash_key->nKeyLength == 0) { /* numeric key */
-			phpdbg_xml(" name=\"%ld\"", hash_key->h);
-		} else { /* string key */
-			const char *prop_name, *class_name;
-			int unmangle = zend_unmangle_property_name(hash_key->arKey, hash_key->nKeyLength - 1, &class_name, &prop_name);
-
-			if (class_name && unmangle == SUCCESS) {
-				phpdbg_xml(" name=\"%s\"", prop_name);
-				if (class_name[0] == '*') {
-					phpdbg_xml(" protection=\"protected\"");
-				} else {
-					phpdbg_xml(" class=\"%s\" protection=\"private\"", class_name);
-				}
-			} else {
-				phpdbg_xml(" name=\"%.*s\" protection=\"public\"", hash_key->nKeyLength - 1, hash_key->arKey);
-			}
-		}
-	} phpdbg_catch_access {
-		phpdbg_xml(" severity=\"error\" ></property>");
-		return 0;
-	} phpdbg_end_try_access();
-
-	phpdbg_xml(">");
-
-	phpdbg_xml_var_dump(zv TSRMLS_CC);
-
-	phpdbg_xml("</property>");
-
-	return 0;
-}
-
-#define COMMON (Z_ISREF_PP(zv) ? "&" : "")
-
-PHPDBG_API void phpdbg_xml_var_dump(zval **zv TSRMLS_DC) {
-	HashTable *myht;
-	const char *class_name;
-	zend_uint class_name_len;
-	int (*element_dump_func)(zval** TSRMLS_DC, int, va_list, zend_hash_key*);
-	int is_temp;
-
-	phpdbg_try_access {
-		switch (Z_TYPE_PP(zv)) {
-			case IS_BOOL:
-				phpdbg_xml("<bool refstatus=\"%s\" value=\"%s\" />", COMMON, Z_LVAL_PP(zv) ? "true" : "false");
-				break;
-			case IS_NULL:
-				phpdbg_xml("<null refstatus=\"%s\" />", COMMON);
-				break;
-			case IS_LONG:
-				phpdbg_xml("<int refstatus=\"%s\" value=\"%ld\" />", COMMON, Z_LVAL_PP(zv));
-				break;
-			case IS_DOUBLE:
-				phpdbg_xml("<float refstatus=\"%s\" value=\"%.*G\" />", COMMON, (int) EG(precision), Z_DVAL_PP(zv));
-				break;
-			case IS_STRING:
-				phpdbg_xml("<string refstatus=\"%s\" length=\"%d\" value=\"%.*s\" />", COMMON, Z_STRLEN_PP(zv), Z_STRLEN_PP(zv), Z_STRVAL_PP(zv));
-					break;
-			case IS_ARRAY:
-				myht = Z_ARRVAL_PP(zv);
-				if (++myht->nApplyCount > 1) {
-					phpdbg_xml("<recursion />");
-					--myht->nApplyCount;
-					break;
-				}
-				phpdbg_xml("<array refstatus=\"%s\" num=\"%d\">", COMMON, zend_hash_num_elements(myht));
-				element_dump_func = phpdbg_xml_array_element_dump;
-				is_temp = 0;
-				goto head_done;
-			case IS_OBJECT:
-				myht = Z_OBJDEBUG_PP(zv, is_temp);
-				if (myht && ++myht->nApplyCount > 1) {
-					phpdbg_xml("<recursion />");
-					--myht->nApplyCount;
-					break;
-				}
-	
-				if (Z_OBJ_HANDLER(**zv, get_class_name)) {
-					Z_OBJ_HANDLER(**zv, get_class_name)(*zv, &class_name, &class_name_len, 0 TSRMLS_CC);
-					phpdbg_xml("<object refstatus=\"%s\" class=\"%s\" id=\"%d\" num=\"%d\">", COMMON, class_name, Z_OBJ_HANDLE_PP(zv), myht ? zend_hash_num_elements(myht) : 0);
-					efree((char*)class_name);
-				} else {
-					phpdbg_xml("<object refstatus=\"%s\" class=\"\" id=\"%d\" num=\"%d\">", COMMON, Z_OBJ_HANDLE_PP(zv), myht ? zend_hash_num_elements(myht) : 0);
-				}
-				element_dump_func = phpdbg_xml_object_property_dump;
-head_done:
-				if (myht) {
-					zend_hash_apply_with_arguments(myht TSRMLS_CC, (apply_func_args_t) element_dump_func, 0);
-					--myht->nApplyCount;
-					if (is_temp) {
-						zend_hash_destroy(myht);
-						efree(myht);
-					}
-				}
-				if (Z_TYPE_PP(zv) == IS_ARRAY) {
-					phpdbg_xml("</array>");
-				} else {
-					phpdbg_xml("</object>");
-				}
-				break;
-			case IS_RESOURCE: {
-				const char *type_name = zend_rsrc_list_get_rsrc_type(Z_LVAL_PP(zv) TSRMLS_CC);
-				phpdbg_xml("<resource refstatus=\"%s\" id=\"%ld\" type=\"%ld\" />", COMMON, Z_LVAL_PP(zv), type_name ? type_name : "unknown");
-				break;
-			}
-			default:
-				break;
-		}
-	} phpdbg_end_try_access();
-}
diff --git a/sapi/phpdbg/phpdbg_utils.h b/sapi/phpdbg/phpdbg_utils.h
index 9038aa7457..56bacfc459 100644
--- a/sapi/phpdbg/phpdbg_utils.h
+++ b/sapi/phpdbg/phpdbg_utils.h
@@ -33,6 +33,52 @@ PHPDBG_API char *phpdbg_resolve_path(const char* TSRMLS_DC);
 PHPDBG_API char *phpdbg_trim(const char*, size_t, size_t*);
 PHPDBG_API const zend_function *phpdbg_get_function(const char*, const char* TSRMLS_DC);
 
+/**
+ * Error/notice/formatting helpers
+ */
+enum {
+	P_ERROR  = 1,
+	P_NOTICE,
+	P_WRITELN,
+	P_WRITE,
+	P_LOG
+};
+
+#ifdef ZTS
+PHPDBG_API int phpdbg_print(int TSRMLS_DC, FILE*, const char*, ...) PHP_ATTRIBUTE_FORMAT(printf, 4, 5);
+#else
+PHPDBG_API int phpdbg_print(int TSRMLS_DC, FILE*, const char*, ...) PHP_ATTRIBUTE_FORMAT(printf, 3, 4);
+#endif
+
+PHPDBG_API int phpdbg_rlog(FILE *stream, const char *fmt, ...);
+
+#define phpdbg_error(fmt, ...)              phpdbg_print(P_ERROR   TSRMLS_CC, PHPDBG_G(io)[PHPDBG_STDOUT], fmt, ##__VA_ARGS__)
+#define phpdbg_notice(fmt, ...)             phpdbg_print(P_NOTICE  TSRMLS_CC, PHPDBG_G(io)[PHPDBG_STDOUT], fmt, ##__VA_ARGS__)
+#define phpdbg_writeln(fmt, ...)            phpdbg_print(P_WRITELN TSRMLS_CC, PHPDBG_G(io)[PHPDBG_STDOUT], fmt, ##__VA_ARGS__)
+#define phpdbg_write(fmt, ...)              phpdbg_print(P_WRITE   TSRMLS_CC, PHPDBG_G(io)[PHPDBG_STDOUT], fmt, ##__VA_ARGS__)
+#define phpdbg_log(fmt, ...)                phpdbg_print(P_LOG     TSRMLS_CC, PHPDBG_G(io)[PHPDBG_STDOUT], fmt, ##__VA_ARGS__)
+
+#define phpdbg_error_ex(out, fmt, ...)      phpdbg_print(P_ERROR   TSRMLS_CC, out, fmt, ##__VA_ARGS__)
+#define phpdbg_notice_ex(out, fmt, ...)     phpdbg_print(P_NOTICE  TSRMLS_CC, out, fmt, ##__VA_ARGS__)
+#define phpdbg_writeln_ex(out, fmt, ...)    phpdbg_print(P_WRITELN TSRMLS_CC, out, fmt, ##__VA_ARGS__)
+#define phpdbg_write_ex(out, fmt, ...)      phpdbg_print(P_WRITE   TSRMLS_CC, out, fmt, ##__VA_ARGS__)
+#define phpdbg_log_ex(out, fmt, ...)        phpdbg_print(P_LOG     TSRMLS_CC, out, fmt, ##__VA_ARGS__)
+
+#if PHPDBG_DEBUG
+#	define phpdbg_debug(fmt, ...) phpdbg_print(P_LOG   TSRMLS_CC, PHPDBG_G(io)[PHPDBG_STDERR], fmt, ##__VA_ARGS__)
+#else
+#	define phpdbg_debug(fmt, ...)
+#endif
+
+/* {{{ For writing blank lines */
+#define EMPTY NULL /* }}} */
+
+/* {{{ For prompt lines */
+#define PROMPT "phpdbg>" /* }}} */
+
+/* {{{ For separation */
+#define SEPARATE "------------------------------------------------" /* }}} */
+
 /* {{{ Color Management */
 #define PHPDBG_COLOR_LEN 12
 #define PHPDBG_COLOR_D(color, code) \
@@ -66,7 +112,7 @@ typedef struct _phpdbg_element_t {
 PHPDBG_API const phpdbg_color_t *phpdbg_get_color(const char *name, size_t name_length TSRMLS_DC);
 PHPDBG_API void phpdbg_set_color(int element, const phpdbg_color_t *color TSRMLS_DC);
 PHPDBG_API void phpdbg_set_color_ex(int element, const char *name, size_t name_length TSRMLS_DC);
-PHPDBG_API const phpdbg_color_t *phpdbg_get_colors(TSRMLS_D);
+PHPDBG_API const phpdbg_color_t* phpdbg_get_colors(TSRMLS_D); 
 PHPDBG_API int phpdbg_get_element(const char *name, size_t len TSRMLS_DC); /* }}} */
 
 /* {{{ Prompt Management */
@@ -76,8 +122,6 @@ PHPDBG_API const char *phpdbg_get_prompt(TSRMLS_D); /* }}} */
 /* {{{ Console Width */
 PHPDBG_API int phpdbg_get_terminal_width(TSRMLS_D); /* }}} */
 
-PHPDBG_API void phpdbg_set_async_io(int fd);
-
 int phpdbg_rebuild_symtable(TSRMLS_D);
 
 #if PHP_VERSION_ID < 50500
@@ -100,41 +144,4 @@ static void zend_hash_get_current_key_zval_ex(const HashTable *ht, zval *key, Ha
 }
 #endif
 
-int phpdbg_safe_class_lookup(const char *name, int name_length, zend_class_entry ***ce TSRMLS_DC);
-
-char *phpdbg_get_property_key(char *key);
-
-typedef int (*phpdbg_parse_var_func)(char *name, size_t len, char *keyname, size_t keylen, HashTable *parent, zval **zv TSRMLS_DC);
-typedef int (*phpdbg_parse_var_with_arg_func)(char *name, size_t len, char *keyname, size_t keylen, HashTable *parent, zval **zv, void *arg TSRMLS_DC);
-
-PHPDBG_API int phpdbg_parse_variable(char *input, size_t len, HashTable *parent, size_t i, phpdbg_parse_var_func callback, zend_bool silent TSRMLS_DC);
-PHPDBG_API int phpdbg_parse_variable_with_arg(char *input, size_t len, HashTable *parent, size_t i, phpdbg_parse_var_with_arg_func callback, zend_bool silent, void *arg TSRMLS_DC);
-
-PHPDBG_API void phpdbg_xml_var_dump(zval **zv TSRMLS_DC);
-
-#ifdef ZTS
-#define PHPDBG_OUTPUT_BACKUP_DEFINES() \
-	zend_output_globals *output_globals_ptr; \
-	zend_output_globals original_output_globals; \
-	output_globals_ptr = (zend_output_globals *) (*((void ***) tsrm_ls))[TSRM_UNSHUFFLE_RSRC_ID(output_globals_id)];
-#else
-#define PHPDBG_OUTPUT_BACKUP_DEFINES() \
-	zend_output_globals *output_globals_ptr; \
-	zend_output_globals original_output_globals; \
-	output_globals_ptr = &output_globals;
-#endif
-
-#define PHPDBG_OUTPUT_BACKUP_SWAP() \
-	original_output_globals = *output_globals_ptr; \
-	memset(output_globals_ptr, 0, sizeof(zend_output_globals)); \
-	php_output_activate(TSRMLS_C);
-
-#define PHPDBG_OUTPUT_BACKUP() \
-	PHPDBG_OUTPUT_BACKUP_DEFINES() \
-	PHPDBG_OUTPUT_BACKUP_SWAP()
-
-#define PHPDBG_OUTPUT_BACKUP_RESTORE() \
-	php_output_deactivate(TSRMLS_C); \
-	*output_globals_ptr = original_output_globals;
-
 #endif /* PHPDBG_UTILS_H */
diff --git a/sapi/phpdbg/phpdbg_wait.c b/sapi/phpdbg/phpdbg_wait.c
deleted file mode 100644
index 6f9eea90e3..0000000000
--- a/sapi/phpdbg/phpdbg_wait.c
+++ /dev/null
@@ -1,421 +0,0 @@
-/*
-   +----------------------------------------------------------------------+
-   | PHP Version 5                                                        |
-   +----------------------------------------------------------------------+
-   | Copyright (c) 1997-2014 The PHP Group                                |
-   +----------------------------------------------------------------------+
-   | This source file is subject to version 3.01 of the PHP license,      |
-   | that is bundled with this package in the file LICENSE, and is        |
-   | available through the world-wide-web at the following url:           |
-   | http://www.php.net/license/3_01.txt                                  |
-   | If you did not receive a copy of the PHP license and are unable to   |
-   | obtain it through the world-wide-web, please send a note to          |
-   | license@php.net so we can mail you a copy immediately.               |
-   +----------------------------------------------------------------------+
-   | Authors: Bob Weinand <bwoebi@php.net>                                |
-   +----------------------------------------------------------------------+
-*/
-
-#include "phpdbg_wait.h"
-#include "phpdbg_prompt.h"
-#include "ext/standard/php_var.h"
-#include "ext/standard/basic_functions.h"
-
-ZEND_EXTERN_MODULE_GLOBALS(phpdbg);
-
-static void phpdbg_rebuild_http_globals_array(int type, const char *name TSRMLS_DC) {
-	zval **zvpp;
-	if (PG(http_globals)[type]) {
-		zval_dtor(PG(http_globals)[type]);
-	}
-	if (zend_hash_find(&EG(symbol_table), name, strlen(name) + 1, (void **) &zvpp) == SUCCESS) {
-		Z_SET_REFCOUNT_PP(zvpp, 2);
-		PG(http_globals)[type] = *zvpp;
-	}
-}
-
-
-static int phpdbg_dearm_autoglobals(zend_auto_global *auto_global TSRMLS_DC) {
-	if (auto_global->name_len != sizeof("GLOBALS") - 1 || memcmp(auto_global->name, "GLOBALS", sizeof("GLOBALS") - 1)) {
-		auto_global->armed = 0;
-	}
-
-	return ZEND_HASH_APPLY_KEEP;
-}
-
-typedef struct {
-	HashTable *ht[2];
-	HashPosition pos[2];
-} phpdbg_intersect_ptr;
-
-static int phpdbg_array_data_compare(const void *a, const void *b TSRMLS_DC) {
-	Bucket *f, *s;
-	zval result;
-	zval *first, *second;
-
-	f = *((Bucket **) a);
-	s = *((Bucket **) b);
-
-	first = *((zval **) f->pData);
-	second = *((zval **) s->pData);
-
-	if (string_compare_function(&result, first, second TSRMLS_CC) == FAILURE) {
-		return 0;
-	}
-
-	if (Z_LVAL(result) < 0) {
-		return -1;
-	} else if (Z_LVAL(result) > 0) {
-		return 1;
-	}
-
-	return 0;
-}
-
-static void phpdbg_array_intersect_init(phpdbg_intersect_ptr *info, HashTable *ht1, HashTable *ht2 TSRMLS_DC) {
-	info->ht[0] = ht1;
-	info->ht[1] = ht2;
-
-	zend_hash_sort(info->ht[0], zend_qsort, (compare_func_t) phpdbg_array_data_compare, 0 TSRMLS_CC);
-	zend_hash_sort(info->ht[1], zend_qsort, (compare_func_t) phpdbg_array_data_compare, 0 TSRMLS_CC);
-
-	zend_hash_internal_pointer_reset_ex(info->ht[0], &info->pos[0]);
-	zend_hash_internal_pointer_reset_ex(info->ht[1], &info->pos[1]);
-}
-
-/* -1 => first array, 0 => both arrays equal, 1 => second array */
-static int phpdbg_array_intersect(phpdbg_intersect_ptr *info, zval ***ptr) {
-	int ret;
-	zval **zvpp[2];
-	int invalid = !info->ht[0] + !info->ht[1];
-
-	if (invalid > 0) {
-		invalid = !info->ht[0];
-
-		if (zend_hash_get_current_data_ex(info->ht[invalid], (void **) ptr, &info->pos[invalid]) == FAILURE) {
-			*ptr = NULL;
-			return 0;
-		}
-
-		zend_hash_move_forward_ex(info->ht[invalid], &info->pos[invalid]);
-
-		return invalid ? 1 : -1;
-	}
-
-	if (zend_hash_get_current_data_ex(info->ht[0], (void **) &zvpp[0], &info->pos[0]) == FAILURE) {
-		info->ht[0] = NULL;
-		return phpdbg_array_intersect(info, ptr);
-	}
-	if (zend_hash_get_current_data_ex(info->ht[1], (void **) &zvpp[1], &info->pos[1]) == FAILURE) {
-		info->ht[1] = NULL;
-		return phpdbg_array_intersect(info, ptr);
-	}
-
-	ret = zend_binary_zval_strcmp(*zvpp[0], *zvpp[1]);
-
-	if (ret <= 0) {
-		*ptr = zvpp[0];
-		zend_hash_move_forward_ex(info->ht[0], &info->pos[0]);
-	}
-	if (ret >= 0) {
-		*ptr = zvpp[1];
-		zend_hash_move_forward_ex(info->ht[1], &info->pos[1]);
-	}
-
-	return ret;
-}
-
-void phpdbg_webdata_decompress(char *msg, int len TSRMLS_DC) {
-	zval *free_zv = NULL;
-	zval zv, *zvp = &zv, **zvpp;
-	HashTable *ht;
-	php_unserialize_data_t var_hash;
-
-	PHP_VAR_UNSERIALIZE_INIT(var_hash);
-	if (!php_var_unserialize(&zvp, (const unsigned char **) &msg, (unsigned char *) msg + len, &var_hash TSRMLS_CC)) {
-		PHP_VAR_UNSERIALIZE_DESTROY(var_hash);
-		phpdbg_error("wait", "type=\"invaliddata\" import=\"fail\"", "Malformed serialized was sent to this socket, arborting");
-		return;
-	}
-	PHP_VAR_UNSERIALIZE_DESTROY(var_hash);
-
-	ht = Z_ARRVAL(zv);
-
-	/* Reapply symbol table */
-	if (zend_hash_find(ht, "GLOBALS", sizeof("GLOBALS"), (void **) &zvpp) == SUCCESS && Z_TYPE_PP(zvpp) == IS_ARRAY) {
-		{
-			zval **srv;
-			if (zend_hash_find(Z_ARRVAL_PP(zvpp), "_SERVER", sizeof("_SERVER"), (void **) &srv) == SUCCESS && Z_TYPE_PP(srv) == IS_ARRAY) {
-				zval **script;
-				if (zend_hash_find(Z_ARRVAL_PP(srv), "SCRIPT_FILENAME", sizeof("SCRIPT_FILENAME"), (void **) &script) == SUCCESS && Z_TYPE_PP(script) == IS_STRING) {
-					phpdbg_param_t param;
-					param.str = Z_STRVAL_PP(script);
-					PHPDBG_COMMAND_HANDLER(exec)(&param TSRMLS_CC);
-				}
-			}
-		}
-
-		PG(auto_globals_jit) = 0;
-		zend_hash_apply(CG(auto_globals), (apply_func_t) phpdbg_dearm_autoglobals TSRMLS_CC);
-
-		zend_hash_clean(&EG(symbol_table));
-		EG(symbol_table) = *Z_ARRVAL_PP(zvpp);
-
-		/* Rebuild cookies, env vars etc. from GLOBALS (PG(http_globals)) */
-		phpdbg_rebuild_http_globals_array(TRACK_VARS_POST, "_POST" TSRMLS_CC);
-		phpdbg_rebuild_http_globals_array(TRACK_VARS_GET, "_GET" TSRMLS_CC);
-		phpdbg_rebuild_http_globals_array(TRACK_VARS_COOKIE, "_COOKIE" TSRMLS_CC);
-		phpdbg_rebuild_http_globals_array(TRACK_VARS_SERVER, "_SERVER" TSRMLS_CC);
-		phpdbg_rebuild_http_globals_array(TRACK_VARS_ENV, "_ENV" TSRMLS_CC);
-		phpdbg_rebuild_http_globals_array(TRACK_VARS_FILES, "_FILES" TSRMLS_CC);
-
-		Z_ADDREF_PP(zvpp);
-		free_zv = *zvpp;
-	}
-
-#if PHP_VERSION_ID >= 50600
-	if (zend_hash_find(ht, "input", sizeof("input"), (void **) &zvpp) == SUCCESS && Z_TYPE_PP(zvpp) == IS_STRING) {
-		if (SG(request_info).request_body) {
-			php_stream_close(SG(request_info).request_body);
-		}
-		SG(request_info).request_body = php_stream_temp_create_ex(TEMP_STREAM_DEFAULT, SAPI_POST_BLOCK_SIZE, PG(upload_tmp_dir));
-		php_stream_truncate_set_size(SG(request_info).request_body, 0);
-		php_stream_write(SG(request_info).request_body, Z_STRVAL_PP(zvpp), Z_STRLEN_PP(zvpp));
-	}
-#endif
-
-	if (zend_hash_find(ht, "cwd", sizeof("cwd"), (void **) &zvpp) == SUCCESS && Z_TYPE_PP(zvpp) == IS_STRING) {
-		if (VCWD_CHDIR(Z_STRVAL_PP(zvpp)) == SUCCESS) {
-			if (BG(CurrentStatFile) && !IS_ABSOLUTE_PATH(BG(CurrentStatFile), strlen(BG(CurrentStatFile)))) {
-				efree(BG(CurrentStatFile));
-				BG(CurrentStatFile) = NULL;
-			}
-			if (BG(CurrentLStatFile) && !IS_ABSOLUTE_PATH(BG(CurrentLStatFile), strlen(BG(CurrentLStatFile)))) {
-				efree(BG(CurrentLStatFile));
-				BG(CurrentLStatFile) = NULL;
-			}
-		}
-	}
-
-	if (zend_hash_find(ht, "sapi_name", sizeof("sapi_name"), (void **) &zvpp) == SUCCESS && (Z_TYPE_PP(zvpp) == IS_STRING || Z_TYPE_PP(zvpp) == IS_NULL)) {
-		if (PHPDBG_G(sapi_name_ptr)) {
-			free(PHPDBG_G(sapi_name_ptr));
-		}
-		if (Z_TYPE_PP(zvpp) == IS_STRING) {
-			PHPDBG_G(sapi_name_ptr) = sapi_module.name = strdup(Z_STRVAL_PP(zvpp));
-		} else {
-			PHPDBG_G(sapi_name_ptr) = sapi_module.name = NULL;
-		}
-	}
-
-	if (zend_hash_find(ht, "modules", sizeof("modules"), (void **) &zvpp) == SUCCESS && Z_TYPE_PP(zvpp) == IS_ARRAY) {
-		HashPosition position;
-		phpdbg_intersect_ptr pos;
-		zval **module;
-		zend_module_entry *mod;
-		HashTable zv_registry;
-
-		/* intersect modules, unregister modules loaded "too much", announce not yet registered modules (phpdbg_notice) */
-
-		zend_hash_init(&zv_registry, zend_hash_num_elements(&module_registry), 0, ZVAL_PTR_DTOR, 0);
-		for (zend_hash_internal_pointer_reset_ex(&module_registry, &position);
-		     zend_hash_get_current_data_ex(&module_registry, (void **) &mod, &position) == SUCCESS;
-		     zend_hash_move_forward_ex(&module_registry, &position)) {
-			if (mod->name) {
-				zval **value = emalloc(sizeof(zval *));
-				MAKE_STD_ZVAL(*value);
-				ZVAL_STRING(*value, mod->name, 1);
-				zend_hash_next_index_insert(&zv_registry, value, sizeof(zval *), NULL);
-			}
-		}
-
-		phpdbg_array_intersect_init(&pos, &zv_registry, Z_ARRVAL_PP(zvpp) TSRMLS_CC);
-		do {
-			int mode = phpdbg_array_intersect(&pos, &module);
-			if (mode < 0) {
-				// loaded module, but not needed
-				if (strcmp(PHPDBG_NAME, Z_STRVAL_PP(module))) {
-					zend_hash_del(&module_registry, Z_STRVAL_PP(module), Z_STRLEN_PP(module) + 1);
-				}
-			} else if (mode > 0) {
-				// not loaded module
-				if (!sapi_module.name || strcmp(sapi_module.name, Z_STRVAL_PP(module))) {
-					phpdbg_notice("wait", "missingmodule=\"%.*s\"", "The module %.*s isn't present in " PHPDBG_NAME ", you still can load via dl /path/to/module/%.*s.so", Z_STRLEN_PP(module), Z_STRVAL_PP(module), Z_STRLEN_PP(module), Z_STRVAL_PP(module));
-				}
-			}
-		} while (module);
-
-		zend_hash_clean(&zv_registry);
-	}
-
-	if (zend_hash_find(ht, "extensions", sizeof("extensions"), (void **) &zvpp) == SUCCESS && Z_TYPE_PP(zvpp) == IS_ARRAY) {
-		zend_extension *extension;
-		zend_llist_position pos;
-		HashPosition hpos;
-		zval **name, key;
-
-		extension = (zend_extension *) zend_llist_get_first_ex(&zend_extensions, &pos);
-		while (extension) {
-			extension = (zend_extension *) zend_llist_get_next_ex(&zend_extensions, &pos);
-
-			/* php_serach_array() body should be in some ZEND_API function */
-			for (zend_hash_internal_pointer_reset_ex(Z_ARRVAL_PP(zvpp), &hpos);
-			     zend_hash_get_current_data_ex(Z_ARRVAL_PP(zvpp), (void **) &name, &hpos) == SUCCESS;
-			     zend_hash_move_forward_ex(Z_ARRVAL_PP(zvpp), &hpos)) {
-				if (Z_TYPE_PP(name) == IS_STRING && !zend_binary_strcmp(extension->name, strlen(extension->name), Z_STRVAL_PP(name), Z_STRLEN_PP(name))) {
-					break;
-				}
-			}
-
-			if (zend_hash_get_current_data_ex(Z_ARRVAL_PP(zvpp), (void **) &zvpp, &hpos) == FAILURE) {
-				/* sigh, breaking the encapsulation, there aren't any functions manipulating the llist at the place of the zend_llist_position */
-				zend_llist_element *elm = pos;
-				if (elm->prev) {
-					elm->prev->next = elm->next;
-				} else {
-					zend_extensions.head = elm->next;
-				}
-				if (elm->next) {
-					elm->next->prev = elm->prev;
-				} else {
-					zend_extensions.tail = elm->prev;
-				}
-#if ZEND_EXTENSIONS_SUPPORT
-				if (extension->shutdown) {
-					extension->shutdown(extension);
-				}
-#endif
-				if (zend_extensions.dtor) {
-					zend_extensions.dtor(elm->data);
-				}
-				pefree(elm, zend_extensions.persistent);
-				zend_extensions.count--;
-			} else {
-				zend_hash_get_current_key_zval_ex(Z_ARRVAL_PP(zvpp), &key, &hpos);
-				if (Z_TYPE(key) == IS_LONG) {
-					zend_hash_index_del(Z_ARRVAL_PP(zvpp), Z_LVAL(key));
-				}
-			}
-
-			for (zend_hash_internal_pointer_reset_ex(Z_ARRVAL_PP(zvpp), &hpos);
-			     zend_hash_get_current_data_ex(Z_ARRVAL_PP(zvpp), (void **) &name, &hpos) == SUCCESS;
-			     zend_hash_move_forward_ex(Z_ARRVAL_PP(zvpp), &hpos)) {
-				phpdbg_notice("wait", "missingextension=\"%.*s\"", "The Zend extension %.*s isn't present in " PHPDBG_NAME ", you still can load via dl /path/to/extension.so", Z_STRLEN_PP(name), Z_STRVAL_PP(name));
-			}
-		}
-	}
-
-	zend_ini_deactivate(TSRMLS_C);
-
-	if (zend_hash_find(ht, "systemini", sizeof("systemini"), (void **) &zvpp) == SUCCESS && Z_TYPE_PP(zvpp) == IS_ARRAY) {
-		HashPosition position;
-		zval **ini_entry;
-		zend_ini_entry *original_ini;
-		zval key;
-
-		for (zend_hash_internal_pointer_reset_ex(Z_ARRVAL_PP(zvpp), &position);
-		     zend_hash_get_current_data_ex(Z_ARRVAL_PP(zvpp), (void**) &ini_entry, &position) == SUCCESS;
-		     zend_hash_move_forward_ex(Z_ARRVAL_PP(zvpp), &position)) {
-			zend_hash_get_current_key_zval_ex(Z_ARRVAL_PP(zvpp), &key, &position);
-			if (Z_TYPE(key) == IS_STRING) {
-				if (Z_TYPE_PP(ini_entry) == IS_STRING) {
-					if (zend_hash_find(EG(ini_directives), Z_STRVAL(key), Z_STRLEN(key) + 1, (void **) &original_ini) == SUCCESS) {
-						if (!original_ini->on_modify || original_ini->on_modify(original_ini, Z_STRVAL_PP(ini_entry), Z_STRLEN_PP(ini_entry), original_ini->mh_arg1, original_ini->mh_arg2, original_ini->mh_arg3, ZEND_INI_STAGE_ACTIVATE TSRMLS_CC) == SUCCESS) {
-							if (original_ini->modified && original_ini->orig_value != original_ini->value) {
-								efree(original_ini->value);
-							}
-							original_ini->value = Z_STRVAL_PP(ini_entry);
-							original_ini->value_length = Z_STRLEN_PP(ini_entry);
-							Z_TYPE_PP(ini_entry) = IS_NULL; /* don't free the value */
-						}
-					}
-				}
-				efree(Z_STRVAL(key));
-			}
-		}
-	}
-
-	if (zend_hash_find(ht, "userini", sizeof("userini"), (void **) &zvpp) == SUCCESS && Z_TYPE_PP(zvpp) == IS_ARRAY) {
-		HashPosition position;
-		zval **ini_entry;
-		zval key;
-
-		for (zend_hash_internal_pointer_reset_ex(Z_ARRVAL_PP(zvpp), &position);
-		     zend_hash_get_current_data_ex(Z_ARRVAL_PP(zvpp), (void**) &ini_entry, &position) == SUCCESS;
-		     zend_hash_move_forward_ex(Z_ARRVAL_PP(zvpp), &position)) {
-			zend_hash_get_current_key_zval_ex(Z_ARRVAL_PP(zvpp), &key, &position);
-			if (Z_TYPE(key) == IS_STRING) {
-				if (Z_TYPE_PP(ini_entry) == IS_STRING) {
-					zend_alter_ini_entry_ex(Z_STRVAL(key), Z_STRLEN(key) + 1, Z_STRVAL_PP(ini_entry), Z_STRLEN_PP(ini_entry), ZEND_INI_PERDIR, ZEND_INI_STAGE_HTACCESS, 1 TSRMLS_CC);
-				}
-				efree(Z_STRVAL(key));
-			}
-		}
-	}
-
-	zval_dtor(&zv);
-	if (free_zv) {
-		/* separate freeing to not dtor the symtable too, just the container zval... */
-		efree(free_zv);
-	}
-
-	/* Reapply raw input */
-	/* ??? */
-}
-
-PHPDBG_COMMAND(wait) /* {{{ */
-{
-#ifndef PHP_WIN32
-	struct sockaddr_un local, remote;
-	int rlen, sr, sl;
-	unlink(PHPDBG_G(socket_path));
-	if (PHPDBG_G(socket_server_fd) == -1) {
-		int len;
-		PHPDBG_G(socket_server_fd) = sl = socket(AF_UNIX, SOCK_STREAM, 0);
-
-		local.sun_family = AF_UNIX;
-		strcpy(local.sun_path, PHPDBG_G(socket_path));
-		len = strlen(local.sun_path) + sizeof(local.sun_family);
-		if (bind(sl, (struct sockaddr *)&local, len) == -1) {
-			phpdbg_error("wait", "type=\"nosocket\" import=\"fail\"", "Unable to connect to UNIX domain socket at %s defined by phpdbg.path ini setting", PHPDBG_G(socket_path));
-			return FAILURE;
-		}
-
-		chmod(PHPDBG_G(socket_path), 0666);
-
-		listen(sl, 2);
-	} else {
-		sl = PHPDBG_G(socket_server_fd);
-	}
-
-	rlen = sizeof(remote);
-	sr = accept(sl, (struct sockaddr *) &remote, (socklen_t *) &rlen);
-
-	char msglen[5];
-	int recvd = 4;
-
-	do {
-		recvd -= recv(sr, &(msglen[4 - recvd]), recvd, 0);
-	} while (recvd > 0);
-
-	recvd = *(size_t *) msglen;
-	char *data = emalloc(recvd);
-
-	do {
-		recvd -= recv(sr, &(data[(*(int *) msglen) - recvd]), recvd, 0);
-	} while (recvd > 0);
-
-	phpdbg_webdata_decompress(data, *(int *) msglen TSRMLS_CC);
-
-	if (PHPDBG_G(socket_fd) != -1) {
-		close(PHPDBG_G(socket_fd));
-	}
-	PHPDBG_G(socket_fd) = sr;
-
-	efree(data);
-
-	phpdbg_notice("wait", "import=\"success\"", "Successfully imported request data, stopped before executing");
-#endif
-
-	return SUCCESS;
-} /* }}} */
diff --git a/sapi/phpdbg/phpdbg_wait.h b/sapi/phpdbg/phpdbg_wait.h
deleted file mode 100644
index 7cf95919cc..0000000000
--- a/sapi/phpdbg/phpdbg_wait.h
+++ /dev/null
@@ -1,29 +0,0 @@
-/*
-   +----------------------------------------------------------------------+
-   | PHP Version 5                                                        |
-   +----------------------------------------------------------------------+
-   | Copyright (c) 1997-2014 The PHP Group                                |
-   +----------------------------------------------------------------------+
-   | This source file is subject to version 3.01 of the PHP license,      |
-   | that is bundled with this package in the file LICENSE, and is        |
-   | available through the world-wide-web at the following url:           |
-   | http://www.php.net/license/3_01.txt                                  |
-   | If you did not receive a copy of the PHP license and are unable to   |
-   | obtain it through the world-wide-web, please send a note to          |
-   | license@php.net so we can mail you a copy immediately.               |
-   +----------------------------------------------------------------------+
-   | Authors: Bob Weinand <bwoebi@php.net>                                |
-   +----------------------------------------------------------------------+
-*/
-
-#ifndef PHPDBG_WAIT_H
-#define PHPDBG_WAIT_H
-
-#include "zend.h"
-#include "phpdbg.h"
-
-PHPDBG_COMMAND(wait);
-
-void phpdbg_webdata_decompress(char *msg, int len TSRMLS_DC);
-
-#endif /* PHPDBG_WAIT_H */
diff --git a/sapi/phpdbg/phpdbg_watch.c b/sapi/phpdbg/phpdbg_watch.c
index de6cddf5b3..e88622444b 100644
--- a/sapi/phpdbg/phpdbg_watch.c
+++ b/sapi/phpdbg/phpdbg_watch.c
@@ -30,6 +30,7 @@
 
 ZEND_EXTERN_MODULE_GLOBALS(phpdbg);
 
+
 typedef struct {
 	void *page;
 	size_t size;
@@ -137,6 +138,13 @@ static int phpdbg_create_array_watchpoint(phpdbg_watchpoint_t *watch TSRMLS_DC)
 	return SUCCESS;
 }
 
+static char *phpdbg_get_property_key(char *key) {
+	if (*key != 0) {
+		return key;
+	}
+	return strchr(key + 1, 0) + 1;
+}
+
 static int phpdbg_create_recursive_watchpoint(phpdbg_watchpoint_t *watch TSRMLS_DC) {
 	HashTable *ht;
 
@@ -182,7 +190,7 @@ static int phpdbg_create_recursive_watchpoint(phpdbg_watchpoint_t *watch TSRMLS_
 			}
 
 			new_watch->str = NULL;
-			new_watch->str_len = asprintf(&new_watch->str, "%.*s%s%s%s", (int) watch->str_len, watch->str, Z_TYPE_P(watch->addr.zv) == IS_ARRAY ? "[" : "->", phpdbg_get_property_key(new_watch->name_in_parent), Z_TYPE_P(watch->addr.zv) == IS_ARRAY ? "]" : "");
+			new_watch->str_len = asprintf(&new_watch->str, "%.*s%s%s%s", (int)watch->str_len, watch->str, Z_TYPE_P(watch->addr.zv) == IS_ARRAY?"[":"->", phpdbg_get_property_key(new_watch->name_in_parent), Z_TYPE_P(watch->addr.zv) == IS_ARRAY?"]":"");
 
 			phpdbg_create_zval_watchpoint(*zv, new_watch);
 			phpdbg_create_recursive_watchpoint(new_watch TSRMLS_CC);
@@ -228,9 +236,9 @@ static int phpdbg_delete_watchpoint_recursive(phpdbg_watchpoint_t *watch, zend_b
 				zend_hash_get_current_key_zval_ex(ht, &key, &position);
 				str = NULL;
 				if (Z_TYPE(key) == IS_STRING) {
-					str_len = asprintf(&str, "%.*s%s%s%s", (int) watch->parent->str_len, watch->parent->str, Z_TYPE_P(watch->parent->addr.zv) == IS_ARRAY ? "[" : "->", phpdbg_get_property_key(Z_STRVAL(key)), Z_TYPE_P(watch->parent->addr.zv) == IS_ARRAY ? "]" : "");
+					str_len = asprintf(&str, "%.*s%s%s%s", (int)watch->parent->str_len, watch->parent->str, Z_TYPE_P(watch->parent->addr.zv) == IS_ARRAY?"[":"->", phpdbg_get_property_key(Z_STRVAL(key)), Z_TYPE_P(watch->parent->addr.zv) == IS_ARRAY?"]":"");
 				} else {
-					str_len = asprintf(&str, "%.*s%s%li%s", (int) watch->parent->str_len, watch->parent->str, Z_TYPE_P(watch->parent->addr.zv) == IS_ARRAY ? "[" : "->", Z_LVAL(key), Z_TYPE_P(watch->parent->addr.zv) == IS_ARRAY ? "]" : "");
+					str_len = asprintf(&str, "%.*s%s%li%s", (int)watch->parent->str_len, watch->parent->str, Z_TYPE_P(watch->parent->addr.zv) == IS_ARRAY?"[":"->", Z_LVAL(key), Z_TYPE_P(watch->parent->addr.zv) == IS_ARRAY?"]":"");
 				}
 
 				if (zend_hash_find(&PHPDBG_G(watchpoints), str, str_len, (void **) &watchpoint) == SUCCESS) {
@@ -273,37 +281,118 @@ static int phpdbg_delete_watchpoint(phpdbg_watchpoint_t *tmp_watch TSRMLS_DC) {
 		ret = zend_hash_del(&PHPDBG_G(watchpoints), watch->str, watch->str_len);
 	}
 
-	efree(tmp_watch->str);
-	efree(tmp_watch->name_in_parent);
+	free(tmp_watch->str);
 	efree(tmp_watch);
 
 	return ret;
 }
 
-static int phpdbg_watchpoint_parse_wrapper(char *name, size_t len, char *keyname, size_t keylen, HashTable *parent, zval **zv, int (*callback)(phpdbg_watchpoint_t * TSRMLS_DC) TSRMLS_DC) {
-	int ret;
-	phpdbg_watchpoint_t *watch = emalloc(sizeof(phpdbg_watchpoint_t));
-	watch->flags = 0;
-	watch->str = name;
-	watch->str_len = len;
-	watch->name_in_parent = keyname;
-	watch->name_in_parent_len = keylen;
-	watch->parent_container = parent;
-	phpdbg_create_zval_watchpoint(*zv, watch);
-
-	ret = callback(watch TSRMLS_CC);
-
-	if (ret != SUCCESS) {
-		efree(watch);
-		efree(name);
-		efree(keyname);
+static int phpdbg_watchpoint_parse_input(char *input, size_t len, HashTable *parent, size_t i, int (*callback)(phpdbg_watchpoint_t * TSRMLS_DC), zend_bool silent TSRMLS_DC) {
+	int ret = FAILURE;
+	zend_bool new_index = 1;
+	char *last_index;
+	int index_len = 0;
+	zval **zv;
+
+	if (len < 2 || *input != '$') {
+		goto error;
 	}
 
-	return ret;
-}
+	while (i++ < len) {
+		if (i == len) {
+			new_index = 1;
+		} else {
+			switch (input[i]) {
+				case '[':
+					new_index = 1;
+					break;
+				case ']':
+					break;
+				case '>':
+					if (last_index[index_len - 1] == '-') {
+						new_index = 1;
+						index_len--;
+					}
+					break;
+
+				default:
+					if (new_index) {
+						last_index = input + i;
+						new_index = 0;
+					}
+					if (input[i - 1] == ']') {
+						goto error;
+					}
+					index_len++;
+			}
+		}
 
-PHPDBG_API int phpdbg_watchpoint_parse_input(char *input, size_t len, HashTable *parent, size_t i, int (*callback)(phpdbg_watchpoint_t * TSRMLS_DC), zend_bool silent TSRMLS_DC) {
-	return phpdbg_parse_variable_with_arg(input, len, parent, i, (phpdbg_parse_var_with_arg_func) phpdbg_watchpoint_parse_wrapper, 0, callback TSRMLS_CC);
+		if (new_index && index_len == 0) {
+			HashPosition position;
+			for (zend_hash_internal_pointer_reset_ex(parent, &position);
+			     zend_hash_get_current_data_ex(parent, (void **)&zv, &position) == SUCCESS;
+			     zend_hash_move_forward_ex(parent, &position)) {
+				if (i == len || (i == len - 1 && input[len - 1] == ']')) {
+					zval *key = emalloc(sizeof(zval));
+					phpdbg_watchpoint_t *watch = emalloc(sizeof(phpdbg_watchpoint_t));
+					watch->flags = 0;
+					zend_hash_get_current_key_zval_ex(parent, key, &position);
+					convert_to_string(key);
+					watch->str = malloc(i + Z_STRLEN_P(key) + 2);
+					watch->str_len = sprintf(watch->str, "%.*s%s%s", (int)i, input, phpdbg_get_property_key(Z_STRVAL_P(key)), input[len - 1] == ']'?"]":"");
+					efree(key);
+					watch->name_in_parent = zend_strndup(last_index, index_len);
+					watch->name_in_parent_len = index_len;
+					watch->parent_container = parent;
+					phpdbg_create_zval_watchpoint(*zv, watch);
+
+					ret = callback(watch TSRMLS_CC) == SUCCESS || ret == SUCCESS?SUCCESS:FAILURE;
+				} else if (Z_TYPE_PP(zv) == IS_OBJECT) {
+					phpdbg_watchpoint_parse_input(input, len, Z_OBJPROP_PP(zv), i, callback, silent TSRMLS_CC);
+				} else if (Z_TYPE_PP(zv) == IS_ARRAY) {
+					phpdbg_watchpoint_parse_input(input, len, Z_ARRVAL_PP(zv), i, callback, silent TSRMLS_CC);
+				} else {
+					/* Ignore silently */
+				}
+			}
+			return ret;
+		} else if (new_index) {
+			char last_chr = last_index[index_len];
+			last_index[index_len] = 0;
+			if (zend_symtable_find(parent, last_index, index_len + 1, (void **)&zv) == FAILURE) {
+				if (!silent) {
+					phpdbg_error("%.*s is undefined", (int)i, input);
+				}
+				return FAILURE;
+			}
+			last_index[index_len] = last_chr;
+			if (i == len) {
+				phpdbg_watchpoint_t *watch = emalloc(sizeof(phpdbg_watchpoint_t));
+				watch->flags = 0;
+				watch->str = zend_strndup(input, len);
+				watch->str_len = len;
+				watch->name_in_parent = zend_strndup(last_index, index_len);
+				watch->name_in_parent_len = index_len;
+				watch->parent_container = parent;
+				phpdbg_create_zval_watchpoint(*zv, watch);
+
+				ret = callback(watch TSRMLS_CC) == SUCCESS || ret == SUCCESS?SUCCESS:FAILURE;
+			} else if (Z_TYPE_PP(zv) == IS_OBJECT) {
+				parent = Z_OBJPROP_PP(zv);
+			} else if (Z_TYPE_PP(zv) == IS_ARRAY) {
+				parent = Z_ARRVAL_PP(zv);
+			} else {
+				phpdbg_error("%.*s is nor an array nor an object", (int)i, input);
+				return FAILURE;
+			}
+			index_len = 0;
+		}
+	}
+
+	return ret;
+	error:
+		phpdbg_error("Malformed input");
+		return FAILURE;
 }
 
 static int phpdbg_watchpoint_parse_symtables(char *input, size_t len, int (*callback)(phpdbg_watchpoint_t * TSRMLS_DC) TSRMLS_DC) {
@@ -323,9 +412,9 @@ PHPDBG_WATCH(delete) /* {{{ */
 	switch (param->type) {
 		case STR_PARAM:
 			if (phpdbg_delete_var_watchpoint(param->str, param->len TSRMLS_CC) == FAILURE) {
-				phpdbg_error("watchdelete", "type=\"nowatch\"", "Nothing was deleted, no corresponding watchpoint found");
+				phpdbg_error("Nothing was deleted, no corresponding watchpoint found");
 			} else {
-				phpdbg_notice("watchdelete", "variable=\"%.*s\"", "Removed watchpoint %.*s", (int) param->len, param->str);
+				phpdbg_notice("Removed watchpoint %.*s", (int)param->len, param->str);
 			}
 			break;
 
@@ -344,7 +433,7 @@ PHPDBG_WATCH(recursive) /* {{{ */
 	switch (param->type) {
 		case STR_PARAM:
 			if (phpdbg_watchpoint_parse_symtables(param->str, param->len, phpdbg_create_recursive_watchpoint TSRMLS_CC) != FAILURE) {
-				phpdbg_notice("watchrecursive", "variable=\"%.*s\"", "Set recursive watchpoint on %.*s", (int)param->len, param->str);
+				phpdbg_notice("Set recursive watchpoint on %.*s", (int)param->len, param->str);
 			}
 			break;
 
@@ -363,7 +452,7 @@ PHPDBG_WATCH(array) /* {{{ */
 	switch (param->type) {
 		case STR_PARAM:
 			if (phpdbg_watchpoint_parse_symtables(param->str, param->len, phpdbg_create_array_watchpoint TSRMLS_CC) != FAILURE) {
-				phpdbg_notice("watcharray", "variable=\"%.*s\"", "Set array watchpoint on %.*s", (int)param->len, param->str);
+				phpdbg_notice("Set array watchpoint on %.*s", (int)param->len, param->str);
 			}
 			break;
 
@@ -384,7 +473,7 @@ void phpdbg_watch_HashTable_dtor(zval **zv) {
 
 		PHPDBG_G(watchpoint_hit) = 1;
 
-		phpdbg_notice("watchdelete", "variable=\"%.*s\" recursive=\"%s\"", "%.*s was removed, removing watchpoint%s", (int)watch->str_len, watch->str, watch->flags & PHPDBG_WATCH_RECURSIVE ? " recursively" : "");
+		phpdbg_notice("%.*s was removed, removing watchpoint%s", (int)watch->str_len, watch->str, (watch->flags & PHPDBG_WATCH_RECURSIVE)?" recursively":"");
 
 		if (watch->flags & PHPDBG_WATCH_RECURSIVE) {
 			phpdbg_delete_watchpoint_recursive(watch, 0 TSRMLS_CC);
@@ -461,8 +550,8 @@ static void phpdbg_watch_dtor(void *pDest) {
 	phpdbg_deactivate_watchpoint(watch TSRMLS_CC);
 	phpdbg_remove_watchpoint(watch TSRMLS_CC);
 
-	efree(watch->str);
-	efree(watch->name_in_parent);
+	free(watch->str);
+	free(watch->name_in_parent);
 	efree(watch);
 }
 
@@ -496,7 +585,7 @@ void phpdbg_setup_watchpoints(TSRMLS_D) {
 
 static void phpdbg_print_changed_zval(phpdbg_watch_memdump *dump TSRMLS_DC) {
 	/* fetch all changes between dump->page and dump->page + dump->size */
-	phpdbg_btree_position pos = phpdbg_btree_find_between(&PHPDBG_G(watchpoint_tree), (zend_ulong) dump->page, (zend_ulong) dump->page + dump->size);
+	phpdbg_btree_position pos = phpdbg_btree_find_between(&PHPDBG_G(watchpoint_tree), (zend_ulong)dump->page, (zend_ulong)dump->page + dump->size);
 	phpdbg_btree_result *result, *htresult;
 	int elementDiff;
 	void *curTest;
@@ -508,7 +597,7 @@ static void phpdbg_print_changed_zval(phpdbg_watch_memdump *dump TSRMLS_DC) {
 		void *oldPtr = (char *)&dump->data + ((size_t)watch->addr.ptr - (size_t)dump->page);
 		char reenable = 1;
 
-		if ((size_t)watch->addr.ptr < (size_t)dump->page || (size_t)watch->addr.ptr + watch->size > (size_t) dump->page + dump->size) {
+		if ((size_t)watch->addr.ptr < (size_t)dump->page || (size_t)watch->addr.ptr + watch->size > (size_t)dump->page + dump->size) {
 			continue;
 		}
 
@@ -540,17 +629,14 @@ static void phpdbg_print_changed_zval(phpdbg_watch_memdump *dump TSRMLS_DC) {
 
 		/* Show to the user what changed and delete watchpoint upon removal */
 		if (memcmp(oldPtr, watch->addr.ptr, watch->size) != SUCCESS) {
-			zend_bool do_break = PHPDBG_G(flags) & PHPDBG_SHOW_REFCOUNTS || (watch->type == WATCH_ON_ZVAL && memcmp(oldPtr, watch->addr.zv, sizeof(zvalue_value))) || (watch->type == WATCH_ON_HASHTABLE
+			if (PHPDBG_G(flags) & PHPDBG_SHOW_REFCOUNTS || (watch->type == WATCH_ON_ZVAL && memcmp(oldPtr, watch->addr.zv, sizeof(zvalue_value))) || (watch->type == WATCH_ON_HASHTABLE
 #if ZEND_DEBUG
 			    && !watch->addr.ht->inconsistent
 #endif
-			    && zend_hash_num_elements((HashTable *)oldPtr) != zend_hash_num_elements(watch->addr.ht));
-
-			if (do_break) {
+			    && zend_hash_num_elements((HashTable *)oldPtr) != zend_hash_num_elements(watch->addr.ht))) {
 				PHPDBG_G(watchpoint_hit) = 1;
 
-				phpdbg_notice("watchhit", "variable=\"%s\"", "Breaking on watchpoint %.*s", (int) watch->str_len, watch->str);
-				phpdbg_xml("<watchdata %r>");
+				phpdbg_notice("Breaking on watchpoint %s", watch->str);
 			}
 
 			switch (watch->type) {
@@ -560,28 +646,26 @@ static void phpdbg_print_changed_zval(phpdbg_watch_memdump *dump TSRMLS_DC) {
 					int show_ref = ((zval *)oldPtr)->refcount__gc != watch->addr.zv->refcount__gc || ((zval *)oldPtr)->is_ref__gc != watch->addr.zv->is_ref__gc;
 
 					if (removed || show_value) {
+						phpdbg_write("Old value: ");
 						if ((Z_TYPE_P((zval *)oldPtr) == IS_ARRAY || Z_TYPE_P((zval *)oldPtr) == IS_OBJECT) && removed) {
-							phpdbg_writeln("watchvalue", "type=\"old\" inaccessible=\"inaccessible\"", "Old value inaccessible, array or object (HashTable) already destroyed");
+							phpdbg_writeln("Value inaccessible, HashTable already destroyed");
 						} else {
-							phpdbg_out("Old value: ");
-							phpdbg_xml("<watchvalue %r type=\"old\">");
-							zend_print_flat_zval_r((zval *) oldPtr TSRMLS_CC);
-							phpdbg_xml("</watchvalue>");
-							phpdbg_out("\n");
+							zend_print_flat_zval_r((zval *)oldPtr TSRMLS_CC);
+							phpdbg_writeln("");
 						}
 					}
 					if (PHPDBG_G(flags) & PHPDBG_SHOW_REFCOUNTS && (removed || show_ref)) {
-						phpdbg_write("watchrefcount", "type=\"old\" refcount=\"%d\" isref=\"%d\"", "Old refcount: %d; Old is_ref: %d", ((zval *) oldPtr)->refcount__gc, ((zval *) oldPtr)->is_ref__gc);
+						phpdbg_writeln("Old refcount: %d; Old is_ref: %d", ((zval *)oldPtr)->refcount__gc, ((zval *)oldPtr)->is_ref__gc);
 					}
 
 					/* check if zval was removed */
 					if (removed) {
-						phpdbg_notice("watchdelete", "variable=\"%.*s\"", "Watchpoint %.*s was unset, removing watchpoint", (int) watch->str_len, watch->str);
+						phpdbg_notice("Watchpoint %s was unset, removing watchpoint", watch->str);
 						zend_hash_del(&PHPDBG_G(watchpoints), watch->str, watch->str_len);
 
 						reenable = 0;
 
-						if (Z_TYPE_P((zval *) oldPtr) == IS_ARRAY || Z_TYPE_P((zval *) oldPtr) == IS_OBJECT) {
+						if (Z_TYPE_P((zval *)oldPtr) == IS_ARRAY || Z_TYPE_P((zval *)oldPtr) == IS_OBJECT) {
 							goto remove_ht_watch;
 						}
 
@@ -589,24 +673,22 @@ static void phpdbg_print_changed_zval(phpdbg_watch_memdump *dump TSRMLS_DC) {
 					}
 
 					if (show_value) {
-						phpdbg_out("New value: ");
-						phpdbg_xml("<watchvalue %r type=\"new\">");
+						phpdbg_write("New value: ");
 						zend_print_flat_zval_r(watch->addr.zv TSRMLS_CC);
-						phpdbg_xml("</watchvalue>");
-						phpdbg_out("\n");
+						phpdbg_writeln("");
 					}
 					if (PHPDBG_G(flags) & PHPDBG_SHOW_REFCOUNTS && show_ref) {
-						phpdbg_writeln("watchrefcount", "type=\"new\" refcount=\"%d\" isref=\"%d\"", "New refcount: %d; New is_ref: %d", watch->addr.zv->refcount__gc, watch->addr.zv->is_ref__gc);
+						phpdbg_writeln("New refcount: %d; New is_ref: %d", watch->addr.zv->refcount__gc, watch->addr.zv->is_ref__gc);
 					}
 
-					if ((Z_TYPE_P(watch->addr.zv) == IS_ARRAY && Z_ARRVAL_P(watch->addr.zv) != Z_ARRVAL_P((zval *) oldPtr)) || (Z_TYPE_P(watch->addr.zv) != IS_OBJECT && Z_OBJ_HANDLE_P(watch->addr.zv) == Z_OBJ_HANDLE_P((zval *) oldPtr))) {
+					if ((Z_TYPE_P(watch->addr.zv) == IS_ARRAY && Z_ARRVAL_P(watch->addr.zv) != Z_ARRVAL_P((zval *)oldPtr)) || (Z_TYPE_P(watch->addr.zv) != IS_OBJECT && Z_OBJ_HANDLE_P(watch->addr.zv) == Z_OBJ_HANDLE_P((zval *)oldPtr))) {
 						/* add new watchpoints if necessary */
 						if (watch->flags & PHPDBG_WATCH_RECURSIVE) {
 							phpdbg_create_recursive_watchpoint(watch TSRMLS_CC);
 						}
 					}
 
-					if ((Z_TYPE_P((zval *) oldPtr) != IS_ARRAY || Z_ARRVAL_P(watch->addr.zv) == Z_ARRVAL_P((zval *) oldPtr)) && (Z_TYPE_P((zval *)oldPtr) != IS_OBJECT || Z_OBJ_HANDLE_P(watch->addr.zv) == Z_OBJ_HANDLE_P((zval *) oldPtr))) {
+					if ((Z_TYPE_P((zval *)oldPtr) != IS_ARRAY || Z_ARRVAL_P(watch->addr.zv) == Z_ARRVAL_P((zval *)oldPtr)) && (Z_TYPE_P((zval *)oldPtr) != IS_OBJECT || Z_OBJ_HANDLE_P(watch->addr.zv) == Z_OBJ_HANDLE_P((zval *)oldPtr))) {
 						break;
 					}
 
@@ -622,7 +704,7 @@ remove_ht_watch:
 
 #if ZEND_DEBUG
 					if (watch->addr.ht->inconsistent) {
-						phpdbg_notice("watchdelete", "variable=\"%.*s\"", "Watchpoint %.*s was unset, removing watchpoint", (int) watch->str_len, watch->str);
+						phpdbg_notice("Watchpoint %s was unset, removing watchpoint", watch->str);
 						zend_hash_del(&PHPDBG_G(watchpoints), watch->str, watch->str_len);
 
 						reenable = 0;
@@ -631,12 +713,12 @@ remove_ht_watch:
 					}
 #endif
 
-					elementDiff = zend_hash_num_elements((HashTable *) oldPtr) - zend_hash_num_elements(watch->addr.ht);
+					elementDiff = zend_hash_num_elements((HashTable *)oldPtr) - zend_hash_num_elements(watch->addr.ht);
 					if (elementDiff) {
 						if (elementDiff > 0) {
-							phpdbg_writeln("watchsize", "removed=\"%d\"", "%d elements were removed from the array", elementDiff);
+							phpdbg_writeln("%d elements were removed from the array", elementDiff);
 						} else {
-							phpdbg_writeln("watchsize", "added=\"%d\"", "%d elements were added to the array", -elementDiff);
+							phpdbg_writeln("%d elements were added to the array", -elementDiff);
 
 							/* add new watchpoints if necessary */
 							if (watch->flags & PHPDBG_WATCH_RECURSIVE) {
@@ -644,15 +726,11 @@ remove_ht_watch:
 							}
 						}
 					}
-					if (((HashTable *) oldPtr)->pInternalPointer != watch->addr.ht->pInternalPointer) {
-						phpdbg_writeln("watcharrayptr", "", "Internal pointer of array was changed");
+					if (((HashTable *)oldPtr)->pInternalPointer != watch->addr.ht->pInternalPointer) {
+						phpdbg_writeln("Internal pointer of array was changed");
 					}
 					break;
 			}
-
-			if (do_break) {
-				phpdbg_xml("</watchdata>");
-			}
 		}
 
 		dump->reenable_writing = dump->reenable_writing | reenable;
@@ -668,15 +746,15 @@ int phpdbg_print_changed_zvals(TSRMLS_D) {
 		return FAILURE;
 	}
 
-	dump = (phpdbg_watch_memdump **) zend_llist_get_last_ex(&PHPDBG_G(watchlist_mem), &pos);
+	dump = (phpdbg_watch_memdump **)zend_llist_get_last_ex(&PHPDBG_G(watchlist_mem), &pos);
 
 	do {
 		phpdbg_print_changed_zval(*dump TSRMLS_CC);
-	} while ((dump = (phpdbg_watch_memdump **) zend_llist_get_prev_ex(&PHPDBG_G(watchlist_mem), &pos)));
+	} while ((dump = (phpdbg_watch_memdump **)zend_llist_get_prev_ex(&PHPDBG_G(watchlist_mem), &pos)));
 
 	zend_llist_clean(&PHPDBG_G(watchlist_mem));
 
-	ret = PHPDBG_G(watchpoint_hit) ? SUCCESS : FAILURE;
+	ret = PHPDBG_G(watchpoint_hit)?SUCCESS:FAILURE;
 	PHPDBG_G(watchpoint_hit) = 0;
 
 	return ret;
@@ -686,27 +764,23 @@ void phpdbg_list_watchpoints(TSRMLS_D) {
 	HashPosition position;
 	phpdbg_watchpoint_t **watch;
 
-	phpdbg_xml("<watchlist %r>");
-
 	for (zend_hash_internal_pointer_reset_ex(&PHPDBG_G(watchpoints), &position);
 	     zend_hash_get_current_data_ex(&PHPDBG_G(watchpoints), (void**) &watch, &position) == SUCCESS;
 	     zend_hash_move_forward_ex(&PHPDBG_G(watchpoints), &position)) {
-		phpdbg_writeln("watchvariable", "variable=\"%.*s\" on=\"%s\" type=\"%s\"", "%.*s (%s, %s)", (int) (*watch)->str_len, (*watch)->str, (*watch)->type == WATCH_ON_HASHTABLE ? "array" : "variable", (*watch)->flags == PHPDBG_WATCH_RECURSIVE ? "recursive" : "simple");
+		phpdbg_writeln("%.*s", (int)(*watch)->str_len, (*watch)->str);
 	}
-
-	phpdbg_xml("</watchlist>");
 }
 
 void phpdbg_watch_efree(void *ptr) {
 	phpdbg_btree_result *result;
 	TSRMLS_FETCH();
 
-	result = phpdbg_btree_find_closest(&PHPDBG_G(watchpoint_tree), (zend_ulong) ptr);
+	result = phpdbg_btree_find_closest(&PHPDBG_G(watchpoint_tree), (zend_ulong)ptr);
 
 	if (result) {
 		phpdbg_watchpoint_t *watch = result->ptr;
 
-		if ((size_t)watch->addr.ptr + watch->size > (size_t) ptr) {
+		if ((size_t)watch->addr.ptr + watch->size > (size_t)ptr) {
 			zend_hash_del(&PHPDBG_G(watchpoints), watch->str, watch->str_len);
 		}
 	}
diff --git a/sapi/phpdbg/phpdbg_watch.h b/sapi/phpdbg/phpdbg_watch.h
index 5c0079057c..d00bcff77e 100644
--- a/sapi/phpdbg/phpdbg_watch.h
+++ b/sapi/phpdbg/phpdbg_watch.h
@@ -42,9 +42,9 @@ PHPDBG_WATCH(recursive);
  */
 
 static const phpdbg_command_t phpdbg_watch_commands[] = {
-	PHPDBG_COMMAND_D_EX(array,      "create watchpoint on an array", 'a', watch_array,     NULL, "s", 0),
-	PHPDBG_COMMAND_D_EX(delete,     "delete watchpoint",             'd', watch_delete,    NULL, "s", 0),
-	PHPDBG_COMMAND_D_EX(recursive,  "create recursive watchpoints",  'r', watch_recursive, NULL, "s", 0),
+	PHPDBG_COMMAND_D_EX(array,      "create watchpoint on an array", 'a', watch_array,     NULL, "s"),
+	PHPDBG_COMMAND_D_EX(delete,     "delete watchpoint",             'd', watch_delete,    NULL, "s"),
+	PHPDBG_COMMAND_D_EX(recursive,  "create recursive watchpoints",  'r', watch_recursive, NULL, "s"),
 	PHPDBG_END_COMMAND
 };
 
diff --git a/sapi/phpdbg/phpdbg_webdata_transfer.c b/sapi/phpdbg/phpdbg_webdata_transfer.c
deleted file mode 100644
index 7c169ee113..0000000000
--- a/sapi/phpdbg/phpdbg_webdata_transfer.c
+++ /dev/null
@@ -1,193 +0,0 @@
-/*
-   +----------------------------------------------------------------------+
-   | PHP Version 5                                                        |
-   +----------------------------------------------------------------------+
-   | Copyright (c) 1997-2014 The PHP Group                                |
-   +----------------------------------------------------------------------+
-   | This source file is subject to version 3.01 of the PHP license,      |
-   | that is bundled with this package in the file LICENSE, and is        |
-   | available through the world-wide-web at the following url:           |
-   | http://www.php.net/license/3_01.txt                                  |
-   | If you did not receive a copy of the PHP license and are unable to   |
-   | obtain it through the world-wide-web, please send a note to          |
-   | license@php.net so we can mail you a copy immediately.               |
-   +----------------------------------------------------------------------+
-   | Authors: Bob Weinand <bwoebi@php.net>                                |
-   +----------------------------------------------------------------------+
-*/
-
-#include "phpdbg_webdata_transfer.h"
-#include "ext/standard/php_var.h"
-
-PHPDBG_API void phpdbg_webdata_compress(char **msg, int *len TSRMLS_DC) {
-	zval array;
-	HashTable *ht;
-	/* I really need to change that to an array of zvals... */
-	zval zv1 = {{0}}, *zvp1 = &zv1;
-	zval zv2 = {{0}}, *zvp2 = &zv2;
-	zval zv3 = {{0}}, *zvp3 = &zv3;
-	zval zv4 = {{0}}, *zvp4 = &zv4;
-	zval zv5 = {{0}}, *zvp5 = &zv5;
-	zval zv6 = {{0}}, *zvp6 = &zv6;
-	zval zv7 = {{0}}, *zvp7 = &zv7;
-	zval zv8 = {{0}}, *zvp8 = &zv8;
-
-	array_init(&array);
-	ht = Z_ARRVAL(array);
-
-	/* fetch superglobals */
-	{
-		zend_is_auto_global(ZEND_STRL("GLOBALS") TSRMLS_CC);
-		/* might be JIT */
-		zend_is_auto_global(ZEND_STRL("_ENV") TSRMLS_CC);
-		zend_is_auto_global(ZEND_STRL("_SERVER") TSRMLS_CC);
-		zend_is_auto_global(ZEND_STRL("_REQUEST") TSRMLS_CC);
-		array_init(&zv1);
-		zend_hash_copy(Z_ARRVAL(zv1), &EG(symbol_table), NULL, (void *) NULL, sizeof(zval *));
-		Z_ARRVAL(zv1)->pDestructor = NULL; /* we're operating on a copy! Don't double free zvals */
-		zend_hash_del(Z_ARRVAL(zv1), "GLOBALS", sizeof("GLOBALS")); /* do not use the reference to itself in json */
-		zend_hash_add(ht, "GLOBALS", sizeof("GLOBALS"), &zvp1, sizeof(zval *), NULL);
-	}
-
-#if PHP_VERSION_ID >= 50600
-	/* save php://input */
-	{
-		php_stream *stream;
-		int len;
-		char *contents;
-
-		stream = php_stream_temp_create_ex(TEMP_STREAM_DEFAULT, SAPI_POST_BLOCK_SIZE, PG(upload_tmp_dir));
-		if ((len = php_stream_copy_to_mem(stream, &contents, PHP_STREAM_COPY_ALL, 0)) > 0) {
-			ZVAL_STRINGL(&zv2, contents, len, 0);
-		} else {
-			ZVAL_EMPTY_STRING(&zv2);
-		}
-		Z_SET_REFCOUNT(zv2, 2);
-		zend_hash_add(ht, "input", sizeof("input"), &zvp2, sizeof(zval *), NULL);
-	}
-#endif
-
-	/* change sapi name */
-	{
-		if (sapi_module.name) {
-			ZVAL_STRING(&zv6, sapi_module.name, 0);
-		} else {
-			Z_TYPE(zv6) = IS_NULL;
-		}
-		Z_SET_REFCOUNT(zv6, 2);
-		zend_hash_add(ht, "sapi_name", sizeof("sapi_name"), &zvp6, sizeof(zval *), NULL);
-	}
-
-	/* handle modules / extensions */
-	{
-		HashPosition position;
-		zend_module_entry *module;
-		zend_extension *extension;
-		zend_llist_position pos;
-
-		array_init(&zv7);
-		for (zend_hash_internal_pointer_reset_ex(&module_registry, &position);
-		     zend_hash_get_current_data_ex(&module_registry, (void**) &module, &position) == SUCCESS;
-		     zend_hash_move_forward_ex(&module_registry, &position)) {
-			zval **value = emalloc(sizeof(zval *));
-			ALLOC_ZVAL(*value);
-			ZVAL_STRING(*value, module->name, 1);
-			zend_hash_next_index_insert(Z_ARRVAL(zv7), value, sizeof(zval *), NULL);
-		}
-		zend_hash_add(ht, "modules", sizeof("modules"), &zvp7, sizeof(zval *), NULL);
-
-		array_init(&zv8);
-		extension = (zend_extension *) zend_llist_get_first_ex(&zend_extensions, &pos);
-		while (extension) {
-			zval **value = emalloc(sizeof(zval *));
-			ALLOC_ZVAL(*value);
-			ZVAL_STRING(*value, extension->name, 1);
-			zend_hash_next_index_insert(Z_ARRVAL(zv8), value, sizeof(zval *), NULL);
-			extension = (zend_extension *) zend_llist_get_next_ex(&zend_extensions, &pos);
-		}
-		zend_hash_add(ht, "extensions", sizeof("extensions"), &zvp8, sizeof(zval *), NULL);
-	}
-
-	/* switch cwd */
-	if (SG(options) & SAPI_OPTION_NO_CHDIR) {
-		char *ret = NULL;
-		char path[MAXPATHLEN];
-
-#if HAVE_GETCWD
-		ret = VCWD_GETCWD(path, MAXPATHLEN);
-#elif HAVE_GETWD
-		ret = VCWD_GETWD(path);
-#endif
-		if (ret) {
-			ZVAL_STRING(&zv5, path, 1);
-			Z_SET_REFCOUNT(zv5, 1);
-			zend_hash_add(ht, "cwd", sizeof("cwd"), &zvp5, sizeof(zval *), NULL);
-		}
-	}
-
-	/* get system ini entries */
-	{
-		HashPosition position;
-		zend_ini_entry *ini_entry;
-
-		array_init(&zv3);
-		for (zend_hash_internal_pointer_reset_ex(EG(ini_directives), &position);
-		     zend_hash_get_current_data_ex(EG(ini_directives), (void**) &ini_entry, &position) == SUCCESS;
-		     zend_hash_move_forward_ex(EG(ini_directives), &position)) {
-			zval **value = emalloc(sizeof(zval *));
-			if (ini_entry->modified) {
-				if (!ini_entry->orig_value) {
-					efree(value);
-					continue;
-				}
-				ALLOC_ZVAL(*value);
-				ZVAL_STRINGL(*value, ini_entry->orig_value, ini_entry->orig_value_length, 1);
-			} else {
-				if (!ini_entry->value) {
-					efree(value);
-					continue;
-				}
-				ALLOC_ZVAL(*value);
-				ZVAL_STRINGL(*value, ini_entry->value, ini_entry->value_length, 1);
-			}
-			zend_hash_add(Z_ARRVAL(zv3), ini_entry->name, ini_entry->name_length, value, sizeof(zval *), NULL);
-		}
-		zend_hash_add(ht, "systemini", sizeof("systemini"), &zvp3, sizeof(zval *), NULL);
-	}
-
-	/* get perdir ini entries */
-	if (EG(modified_ini_directives)) {
-		HashPosition position;
-		zend_ini_entry *ini_entry;
-
-		array_init(&zv4);
-		for (zend_hash_internal_pointer_reset_ex(EG(modified_ini_directives), &position);
-		     zend_hash_get_current_data_ex(EG(modified_ini_directives), (void**) &ini_entry, &position) == SUCCESS;
-		     zend_hash_move_forward_ex(EG(modified_ini_directives), &position)) {
-			zval **value = emalloc(sizeof(zval *));
-			if (!ini_entry->value) {
-				efree(value);
-				continue;
-			}
-			ALLOC_ZVAL(*value);
-			ZVAL_STRINGL(*value, ini_entry->value, ini_entry->value_length, 1);
-			zend_hash_add(Z_ARRVAL(zv4), ini_entry->name, ini_entry->name_length, value, sizeof(zval *), NULL);
-		}
-		zend_hash_add(ht, "userini", sizeof("userini"), &zvp4, sizeof(zval *), NULL);
-	}
-
-	/* encode data */
-	{
-		php_serialize_data_t var_hash;
-		smart_str buf = {0};
-		zval *arrayptr = &array;
-
-		PHP_VAR_SERIALIZE_INIT(var_hash);
-		php_var_serialize(&buf, &arrayptr, &var_hash TSRMLS_CC);
-		PHP_VAR_SERIALIZE_DESTROY(var_hash);
-		*msg = buf.c;
-		*len = buf.len;
-	}
-
-	zval_dtor(&array);
-}
diff --git a/sapi/phpdbg/phpdbg_webdata_transfer.h b/sapi/phpdbg/phpdbg_webdata_transfer.h
deleted file mode 100644
index d70175ad99..0000000000
--- a/sapi/phpdbg/phpdbg_webdata_transfer.h
+++ /dev/null
@@ -1,27 +0,0 @@
-/*
-   +----------------------------------------------------------------------+
-   | PHP Version 5                                                        |
-   +----------------------------------------------------------------------+
-   | Copyright (c) 1997-2014 The PHP Group                                |
-   +----------------------------------------------------------------------+
-   | This source file is subject to version 3.01 of the PHP license,      |
-   | that is bundled with this package in the file LICENSE, and is        |
-   | available through the world-wide-web at the following url:           |
-   | http://www.php.net/license/3_01.txt                                  |
-   | If you did not receive a copy of the PHP license and are unable to   |
-   | obtain it through the world-wide-web, please send a note to          |
-   | license@php.net so we can mail you a copy immediately.               |
-   +----------------------------------------------------------------------+
-   | Authors: Bob Weinand <bwoebi@php.net>                                |
-   +----------------------------------------------------------------------+
-*/
-
-#ifndef PHPDBG_WEBDATA_TRANSFER_H
-#define PHPDBG_WEBDATA_TRANSFER_H
-
-#include "zend.h"
-#include "phpdbg.h"
-
-PHPDBG_API void phpdbg_webdata_compress(char **msg, int *len TSRMLS_DC);
-
-#endif /* PHPDBG_WEBDATA_TRANSFER_H */
diff --git a/sapi/phpdbg/tests/commands/0002_set.test b/sapi/phpdbg/tests/commands/0002_set.test
index 6a14a15adc..468ac6d9ea 100644
--- a/sapi/phpdbg/tests/commands/0002_set.test
+++ b/sapi/phpdbg/tests/commands/0002_set.test
@@ -8,7 +8,7 @@
 # setting error color
 # setting notice color
 # Failed to find breakpoint #0
-# [Oplog off]
+# oplog disabled
 # opened oplog test.log
 # nothing
 #################################################
diff --git a/sapi/phpdbg/tests/commands/0102_print.test b/sapi/phpdbg/tests/commands/0102_print.test
index c174564e07..de4acb7651 100644
--- a/sapi/phpdbg/tests/commands/0102_print.test
+++ b/sapi/phpdbg/tests/commands/0102_print.test
@@ -4,14 +4,15 @@
 # expect: TEST::FORMAT
 # options: -rr
 #################################################
-#[User Class: test (3 methods)]
+#[User Class: test]
+#Methods (3):
 #L%d-%d test::testMethod() %s
 #		L%d	%s ZEND_RETURN                    C%d                   <unused>             <unused>            
 #	L%d-%d test::testPrivateMethod() %s
 #		L%d	%s ZEND_RETURN                    C%d                   <unused>             <unused>            
 #	L%d-%d test::testProtectedMethod() %s
 #		L%d	%s ZEND_RETURN                    C%d                   <unused>             <unused>            
-#[User Method testMethod (1 ops)]
+#[User Method testMethod]
 #	L%d-%d test::testMethod() %s
 #		L%d	%s ZEND_RETURN                    C%d                   <unused>             <unused>   
 #################################################
diff --git a/sapi/phpdbg/tests/commands/0104_clean.test b/sapi/phpdbg/tests/commands/0104_clean.test
index 2c7660ad60..c7a579be17 100644
--- a/sapi/phpdbg/tests/commands/0104_clean.test
+++ b/sapi/phpdbg/tests/commands/0104_clean.test
@@ -4,11 +4,12 @@
 # expect: TEST::FORMAT
 # options: -rr
 #################################################
-#Cleaning Execution Environment
-#Classes    %d
-#Functions  %d
-#Constants  %d
-#Includes   %d
+#[Cleaning Execution Environment]
+#Classes			%d
+#Functions		%d
+#Constants		%d
+#Includes		%d
+#[Nothing to execute!]
 #################################################
 clean
 quit
diff --git a/sapi/phpdbg/tests/commands/0105_clear.test b/sapi/phpdbg/tests/commands/0105_clear.test
index 8ce1002491..b547b0d6ba 100644
--- a/sapi/phpdbg/tests/commands/0105_clear.test
+++ b/sapi/phpdbg/tests/commands/0105_clear.test
@@ -4,7 +4,7 @@
 # expect: TEST::FORMAT
 # options: -rr
 #################################################
-#Clearing Breakpoints
+#[Clearing Breakpoints]
 #File%w%d
 #Functions%w%d
 #Methods%w%d
diff --git a/sapi/phpdbg/tests/commands/0106_compile.test b/sapi/phpdbg/tests/commands/0106_compile.test
index b4d801670b..7193600ea3 100644
--- a/sapi/phpdbg/tests/commands/0106_compile.test
+++ b/sapi/phpdbg/tests/commands/0106_compile.test
@@ -4,9 +4,9 @@
 # expect: TEST::FORMAT
 # options: -rr
 #################################################
-#[Successful compilation of %s]
+#[Attempting compilation of %s]
+#[Success]
 #Hello World
-#[Script ended normally]
 #################################################
 <:
 define('OUT', 
diff --git a/sapi/phpdbg/xml.md b/sapi/phpdbg/xml.md
deleted file mode 100644
index 0556fb2415..0000000000
--- a/sapi/phpdbg/xml.md
+++ /dev/null
@@ -1,759 +0,0 @@
-phpdbg XML format
-=================
-
-Common attributes
-=================
-
-severity
---------
-
-- indicates the genre of phpdbg system output
-- usually one of these values:
- - normal
- - notice
- - error
-
-msgout
-------
-
-- text message output related to the xml data (e.g. &lt;intro severity="normal" help="help" msgout="To get help using phpdbg type &amp;quot;help&amp;quot; and press enter" />)
-
-req
----
-
-- the request id, if one was passed to the last command (via -r %d, where %d is the id) (and the output is related to that message)
-
-file
-----
-
-- refers to a filename
-
-method
-------
-
-- format classname::methodname
-- refers to a method
-
-function
---------
-
-- refers to a function
-
-symbol
-------
-
-- either function or method (is method if "::" are present)
-
-opline
-------
-
-- in hexadecimal format
-- refers to a specific pointer to a (zend_)op
-
-opcode
-------
-
-- refers to an opcode (ZEND_*)
-
-type
-----
-
-- general attribute for most errors, describes the genre of the error
-
-
-General tags
-============
-
-intro
------
-
-- appears on startup if -q flag wasn't provided as command line arg
-- before any input possibility
-- attributes may be spread over multiple tags
-- wrapped in &lt;intros> tag
-
-### attributes ###
-
-- version: current phpdbg version (as string)
-- help: command name for help
-- report: URL for bug reporting
-
-prompt
-------
-
-- msg tag contains the text prompt
-- indicates that a new command may be accepted
-
-phpdbg
-------
-
-- general text message output from phpdbg system
-
-stream
-------
-
-- any output by PHP itself (e.g. &lt;stream type="stdout">test&lt;/stream>)
-
-### attributes ###
-
-- type: stderr or stdout
-
-php
----
-
-- php error output
-
-### attributes ###
-
-- msg: the error message
-
-
-General error tags
-==================
-
-command
--------
-
-- general errors about commands
-
-### possible attributes ###
-
-- type
- - toomanyargs: more arguments than allowed
- - noarg: argument missing
- - wrongarg: wrong type of argument (e.g. letters instead of integer)
- - toofewargs: not enough arguments
- - notfound: command (or subcommand) doesn't exist
- - ambiguous: command was ambiguous
- - invalidcommand: command input is totally invalid
- - (nostack: should not happen: is an internal error)
- - (emptystack: should not happen: is an internal error)
-- command: passed command
-- subcommand: passed subcommand (present if the error is related to the subcommand)
-- expected: count of expected arguments
-- got: type of argument for type "wrongarg"
-- num: if possible, information about which parameter had a wrong argument
-
-inactive
---------
-
-- by type
- - op_array: nothing was yet compiled (probably because no execution context set)
- - symbol_table: no symbol table present (not yet initiailized or already destructed)
- - noexec: not in execution
- - memory_manager: using the native memory manager (malloc, free, realloc) instead of e.g. the Zend MM
- - notfound: file not found
- - nocontext: execution context was not set (or compilation had failed)
- - isrunning: command requires no running script
-
-
-Commands
-========
-
-export
-------
-
-- tag: &lt;exportbreakpoint />
-- usually triggered by successful export command
-- may appear when cleaning to temporary store breakpoints
-- errors by type
- - openfailure: could not create file
-
-### attributes ###
-
-- count: number of exported breakpoints
-
-break / info break
-------------------
-
-- General tag for breakpoint creation, deletion and hits is "&lt;breakpoint />"
-
-### possible attributes ###
-
-- id: the breakpoint id (if the leave command was executed, the id has the value "leave")
-- num: the nth opline of a function/method/file
-- add: has value "success"/"fail": a brekpoint was successfully/not added
-- pending: the breakpoint is waiting for resolving (e.g. a file opline on a not yet loaded file)
-- deleted: has value "success"/"fail": a breakpoint was successfully/not deleted
-- eval: the condition on conditional breakpoints
-- file
-- opline
-- opcode
-- symbol
-- function
-- method
-- line
-
-
-- listing breakpoints always in a container element "&lt;breakpoints>"
- - Child nodes:
-  - function
-  - method
-  - file
-  - opline
-  - methodopline
-  - functionopline
-  - fileopline
-  - evalfunction
-  - evalfunctionopline
-  - evalmethod
-  - evalmethodopline
-  - evalfile
-  - evalopline
-  - eval
-  - opcode
- - attributes:
-  - name: name of the symbol (function/method/file/opcode)
-  - disabled: empty value if enabled, non-empty if enabled
-
-- errors (by type)
- - exists: the breakpoint already exists
- - maxoplines: tries to break at an opline (usedoplinenum) higher than the number of present oplines (in maxoplinenum)
- - nomethod: method doesn't exist
- - internalfunction: one cannot break on an opline of an internal function
- - notregular: tries to set a breakpoint in not a regular file
- - (invalidparameter: should not happen: is an internal error)
-
-frame
------
-
-- General tag for frames is "&lt;frame>"
-- always has id attribute; if it only has id attribute, it just indicates current frame number, no other elements follow
-- may contain other elements (of type &lt;arg>) when contained in &lt;backtrace> tag
-- &lt;arg> always contains a &lt;stream> element, the value of the variable
-
-### possible attributes ###
-
-- id: the frame id, current frame has id 0 (frames with internal function calls have the same id than their called frame)
-- symbol ("{main}" is root frame)
-- file
-- line
-- internal: has value "internal" when being an internal function call (one cannot inspect that frame)
-
-- being an error: (by type)
- - maxnum: tried to access a frame with a number heigher than existing (or &lt; 0)
-
-### attributes on &lt;arg> ###
-
-- variadic: has a non-empty value if the argument is variadic
-- name: variable name of parameter
-
-info (subcommands)
-------------------
-
-### break ###
-
-- See above ("break / info break")
-
-### files ###
-
-- lists included files
-- &lt;includedfileinfo num="" /> with num having an integer value, indicating the number of included files
-- &lt;includedfile name=""/>: one per file, with name being the file path of the included file
-
-### error ###
-
-- gets last error
-- &lt;lasterror error="" (file="" line="") />
-- error attribute contains the last error as a string, is empty if there's no last error
-
-### constants ###
-
-- &lt;constantinfo num="" /> with num having an integer value, indicating the number of (local or superglobal) variables
-- if info vars was used it'll have also one of these attributes:
- - method
- - function
- - file
- - opline
-- for each variable there is a &lt;constant> element
-- &lt;constant address="" refcount="" type="" name="" />
- - address: pointer to zval (hexadecimal)
- - refcount: refcount of zval
- - type: the variable type (long, string, ...). If the value is "unknown", the other attributes are meaningless
- - name: the name of the variable
- - value: the value of primitive types (scalars) => string/int/bool/double
- - length: if string, then the length of that string
-
-### vars / globals ###
-
-- &lt;variableinfo num="" /> with num having an integer value, indicating the number of (local or superglobal) variables
-- if info vars was used it'll have also one of these attributes:
- - method
- - function
- - file
- - opline
-- for each variable there is a &lt;variable> element
-- &lt;variable address="" refcount="" type="" name="" />
- - address: pointer to zval (hexadecimal)
- - refcount: refcount of zval
- - type: the variable type (long, string, ...). If the value is "unknown", the other attributes are meaningless
- - name: the name of the variable
- - refstatus: empty if the zval is not a reference
- - class: the class the object in the zval is an instance of
- - resource: the type of the resource in the zval
- - value: the value of primitive types (scalars) => string/int/bool/double
- - length: if string, then the length of that string
-
-### literal ###
-
-- &lt;literalinfo num="" /> with num having an integer value, indicating the number of literals, optional arguments are:
- - method
- - function
- - file
- - opline
-- for each literal there is a &lt;literal> followed by a &lt;stream type="stdout"> which prints the value of the literal
-- &lt;literal id="" />: where id is the internal identifier of the literal
-
-### memory ###
-
-- Format:
-
-    &lt;meminfo />
-    &lt;current />
-    &lt;used mem="" />
-    &lt;real mem="" />
-    &lt;peak />
-    &lt;used mem="" />
-    &lt;real mem="" />
-
-- mem is an attribute whose value is a float. The memory is given in kilobytes (1 kB == 1024 bytes)
-
-### classes ###
-
-- &lt;classinfo num="" /> with num having an integer value, indicating the number of loaded user-defined classes
-- Each class is enumerated with first a &lt;class>, then an optional &lt;parents> container and then a &lt;classsource> element
-- The &lt;parents> container contains the &lt;class> elements of the parent of the last &lt;class> element. 
-- &lt;class type="" flags="" name="" methodcount="" />
- - type: either "User" or "Internal"
- - flags: either "Interface", "Class" or "Abstract Class"
-- &lt;classsource /> where the class was defined, if there are no attributes, location is unknown, usually defined by
- - file
- - line
-
-### funcs ###
-
-- &lt;functioninfo num="" /> with num having an integer value, indicating the number of loaded user-defined functions
-- Each class is enumerated with first a &lt;function> and then a &lt;functionsource> element
-- &lt;function name="" />
-- &lt;functionsource /> where the function was defined, if there are no attributes, location is unknown, usually defined by
- - file
- - line
-
-list
-----
-
-- consists of &lt;line> elements wrapped in a &lt;list> container
-- &lt;list file=""> is the container element with file being the filename
-- &lt;line line="" code="" /> with value of code being the whole line of code in the line specified in the line attribute
- - current: this attribute is set to "current" if that line is the line where the executor currently is
-
-print
------
-
-### without a subcommand ###
-
-- &lt;print> elements are wrapped in a &lt;printinfo> element
-- there may be a variable number of &lt;print> elements with a variable count of args inside the &lt;printinfo> element
-- possible args are:
- - readline: yes/no - readline enabled or disabled
- - libedit: yes/no - libedit enabled or disabled
- - context: current executing context
- - compiled: yes/no - are there actual compiled ops?
- - stepping: @@ TODO (meaningless for now) @@
- - quiet: on/off - should it always print the opline being currently executed?
- - oplog: on/off - are oplines logged in a file?
- - ops: number of opcodes in current executing context
- - vars: number of compiled variables (CV)
- - executing: yes/no - in executor?
- - vmret: the return value of the last executed opcode
-  - default: continue
-  - 1: return from vm
-  - 2: enter stack frame
-  - 3: leave stack frame
- - classes: number of classes
- - functions: number of functions
- - constants: number of constants
- - includes: number of included files
-
-### with a subcommand ###
-
-- introduced by &lt;printinfo num="" /> (except for print opline) with num being the number of opcodes and one of these args:
- - file
- - method
- - function
- - class (then also type and flags attributes, see info classes command for their meanings)
- - symbol (also type and flags attributes; here the value of flags is either "Method" or "Function")
-- if there is a class method, the methods are all wrapped in a &lt;printmethods> container
-- then comes a &lt;printoplineinfo type="" /> where type is either "User" or "Internal"
-- the &lt;printoplineinfo> has either a method or a function attribute
-- if the type is "Internal"
- - there are no oplines, it's an internal method or function
-- if the type is "User"
- - it has these attributes
-   - startline: the first line of code where the method or function is defined
-   - endline: the lastt line of code where the method or function is defined
-   - file: the file of code where the method or function is defined
- - is followed by the oplines of that method or function (&lt;print> elements)
-- &lt;print line="%u" opline="%p" opcode="%s" op="%s" />
-- in case of print opline it emits a single &lt;opline line="" opline="" opcode="" op="" file="" />
-
-exec
-----
-
-- command executing and compiling a given file
- - &lt;exec type="unset" context="" />: indicates unsetting of the old context
- - &lt;exec type="unsetops" />: indicates unsetting of the old compiled opcodes
- - &lt;exec type="unchanged" />: same execution context choosen again
- - &lt;exec type="set" context="" />: indicates setting of the new context
-- errors by tag
- - &lt;compile>
-  - openfailure: couldn't open file
-  - compilefailure: The file indicated in context couldn't be compiled
- - &lt;exec>
-  - invalid: given context (attribute) is not matching a valid file or symlink
-  - notfound: given context (attribute) does not exist
-
-run / &lt;stop> tag
--------------------
-
-- runs the script (set via exec command)
-- &lt;stop type="end" />: script execution ended normally
-- (error) &lt;stop type="bailout" /> the VM bailed out (usually because there was some error)
-- compile failures see under exec, errors, &lt;compile>
-
-step
-----
-
-- steps by one line or opcode (as defined via set stepping) default is one line
-- returns back to the executor
-
-continue
---------
-
-- returns back to the executor
-
-until
------
-
-- temporarily disables all the breakpoints on that line until that line was left once
-- returns back to the executor
-
-finish
-------
-
-- temporarily disables all the breakpoints until the end of the current frame
-- returns back to the executor
-
-leave
-------
-
-- temporarily disables all the breakpoints past the end of the current frame and then stops
-- returns back to the executor
-
-back
-----
-
-- prints backtrace
-- see frame command
-
-ev
---
-
-- eval()uates some code
-- output wrapped in &lt;eval> tags
-- output is here first a dump of xml tags (see "Variable Dump" section), then a dump wrapped in <stream> tags
-- if there's an error, the tag will be <eval>, instead of the usual <php> tag
-
-sh
---
-
-- executes shell command
-- still pipes to stdout ... without wrapping &lt;stream> !!! (@@ TODO @@)
-
-source
-------
-
-- executes a file in .phpdbginit format
-- errors by type
- - notfound: file not found
-
-register
---------
-
-- registers a function to be used like a command
-- &lt;register function="" />: successfully registered function
-- errors by type
- - notfound: no such function
- - inuse: function already registered
-
-quit
-----
-
-- quits phpdbg
-- if successful connection will be closed...
-
-clean
------
-
-- cleans environment (basically a shutdown + new startup)
-- &lt;clean> tags wrapped in a &lt;cleaninfo> container
-- possible attributes of &lt;clean> tag
- - classes: number of classes
- - functions: number of functions
- - constants: number of constants
- - includes: number of included files
-
-clear
------
-
-- removes all breakpoints
-- &lt;clear> tags wrapped in a &lt;clearinfo> container
-- possible attributes of &lt;clear> tag (value is always the number of defined breakpoints of that type)
- - files
- - functions
- - methods
- - oplines
- - fileoplines
- - functionoplines
- - methodoplines
- - eval
-
-watch
------
-
-- watchpoints generally are identified by a variable (one may need to switch frames first...)
-- &lt;watch variable="" />, &lt;watchrecursive variable="" /> and &lt;watcharray variable="" /> (normal, array, recursive)
-- &lt;watch> if error, by type:
- - undefined: tried to set a watchpoint on a not (yet) defined variable
- - notiterable: element which is tried to be accessed as an object or array is nor array nor object
- - invalidinput: generally malformed input
-- &lt;watchdelete variable="" />: when "watch delete" was used on a watchpoint
-- (error) &lt;watchdelete type="nowatch" />: that watchpoint doesn't exist, so couldn't be deleted
-- for hit watchpoints etc., see Other tags, &lt;watch*>
-- when using watch list, &lt;watchvariable> elements are wrapped in a &lt;watchlist> container
- - &lt;watchvariable variable="" on="" type="" />
-  - variable: watched variable (may be a variable of another scope!)
-  - on: values are array or variable, depending on what is watched
-  - type: values are recursive or simple, depending on whether the watchpoint is checked recursively or not
-
-set
----
-
-- a general error is type="wrongargs" where a wrong argument was passed to a subcommand; tag is then &lt;set*>
-
-### prompt ###
-
-- without other args, a &lt;setpromt str="" /> tag is emitted where the value of the str attribue is the value of the prompt
-- when there is another arg, the prompt is changed to that arg, no further xml answer
-
-### break ###
-
-- enables / disables a given breakpoint silently with no further xml answer
-- if the boolean switch is omitted, it emits current state in a &lt;setbreak id="" active="" /> where active is on or off
-- error with type="nobreak", when no breakpoint with the given id exists
-
-### breaks ###
-
-- generally enables / disables breakpoint functionality silently with no futher xml answer
-- if the boolean switch is omitted, it emits current state in a &lt;setbreaks active="" /> where active is on or off
-
-### color ###
-
-- sets the color on prompt, error or notices
-- &lt;setcolor type="" color="" code="" />: code is the color code of color, type is either:
- - prompt
- - error
- - notice
-- errors by type:
- - nocolor: color doesn't exist
- - invalidtype: type wasn't one of the three allowed types
-
-### colors ###
-
-- generally enables / disables colors silently with no further xml answer
-- if the boolean switch is omitted, it emits current state in a &lt;setcolors active="" /> where active is on or off
-
-### oplog ###
-
-- sets oplog
-- (error) &lt;setoplog type="openfailure" file="" /> when it couldn't open the passed file path
-- &lt;setoplog type="closingold" /> is emitted when there was a previous open oplog (and a file is passed)
-- if no further argument is passed, it emits current state in a &lt;setoplog active="" /> where active is on or off
-
-### quiet ###
-
-- generally enables / disables quietness silently with no further xml answer
-- if the boolean switch is omitted, it emits current state in a &lt;setquiet active="" /> where active is on or off
-
-### setpping ###
-
-- sets stepping to either opcode or line (so a step command will either advance one op or one line)
-- if no further argument is passed, it emits current state in a &lt;setoplog type="" /> where active is opcode or line
-
-### refcount ###
-
-- generally enables / disables showing of refcount in watchpoint breaks silently with no further xml answer
-- if the boolean switch is omitted, it emits current state in a &lt;setrefcount active="" /> where active is on or off
-
-wait
-----
-
-- internally executes exec, so exec will output first (if binding to socket worked)
-
-### attributes ###
-
-- import: has value "success"/"fail"
-- missingmodule/missingextension: modules/extensions loaded in the target SAPI, but not in phpdbg
-
-### errors (by type) ###
-
-- nosocket: couldn't establish socket
-- invaliddata: invalid JSON passed to socket
-
-dl
---
-
-- loads a module or Zend extension at a given path
-- if a relative path is passed, it's relative to the extension_dir ini setting
-
-### attributes ###
-
-- extensiontype: "Zend extension" or "module"
-- name: the extension name
-- path: the path where it was loaded
-
-### errors (by type) ###
-
-- unsupported: dynamic extension loading is unsupported
-- relpath: relative path given, but no extension_dir defined
-- unknown: general error with internal DL_LOAD() (for message see msg attribute)
-- wrongapi: wrong Zend engine version (apineeded / apiinstalled attributes give information about the API versions)
-- wrongbuild: unmatched build versions (buildneeded / buildinstalled attributes give information about the build versions)
-- registerfailure: registering module failed
-- startupfailure: couldn't startup Zend extension / module
-- initfailure: couldn't initialize module
-- nophpso: passed shared object is not a valid Zend extension nor module
-
-- errors may have the module or extension attribute when their name is already known at the point of failure
-
-
-Other tags
-==========
-
-&lt;signal>
------------
-
-- received caught signal
-
-### attributes ###
-
-- type: type of signal (e.g. SIGINT)
-
-### by type ###
-
-- SIGINT: interactive mode is entered...
-
-&lt;watch*>
------------
-
-- generally emitted on hit watchpoint
-- &lt;watchdelete variable="" />: when a variable was unset, the watchpoint is removed too
-- &lt;watchhit variable="" />: when ever a watched variable is changed, followed by a &lt;watchdata> container
-- &lt;watchdata> may contain
- - for watchpoints on variables:
-  - each of these &lt;watch*> tags conatins a type attribute whose value is either "old" or "new")
-  - &lt;watchvalue type="" inaccessible="inaccessible" />: old value is inaccessible
-  - &lt;watchvalue type=""> may contain a &lt;stream> element which indicates the old/new (type attribute) value of the variable
-  - &lt;watchrefcount type="" refcount="" isref="" />: old/new (type attribute) refcount and isref, both numbers
-   - isref: if the value is 0, it's not a reference, else it is one
- - for watchpoints on arrays:
-  - &lt;watchsize> inspects size variations of an array (the sum):
-   - removed: number of elements removed
-   - added: number of elements added
-  - &lt;watcharrayptr>: if this tag appears, the internal pointer of the array way changed
-
-&lt;signalsegv>
----------------
-
-- generally emitted when data couldn't be fetched (e.g. by accessing inconsistent data); only used in hard interrupt mode
-- it might mean that data couldn't be fetched at all, or that only incomplete data was fetched (e.g. when a fixed number of following attributes are fetched, this tag will mark a stop of fetching if none or not all tags were printed)
-
-
-Variable Dump
-=============
-
-- all except property and element tags have a refstatus attribute, is set to non-empty if it's a reference
-
-object properties
------------------
-
-- wrapped in a property tag &lt;property name="" protection="">
- - name: name of key
- - protection: one of these three values: public / protected / private
- - class: only present if protection attribute is set to "private", contains the name of the class to which the property belongs
-- if the property tag contains any serverity="error" attribute, there was some crucial error to read it, just skip it
-
-array elements
---------------
-- wrapped in an element tag &lt;property name="" protection="">
- - name: name of key
-- if the element tag contains any serverity="error" attribute, there was some crucial error to read it, jsut skip it
-
-int
----
-
-- &lt;int refstatus="" value="" />
- - value is the integer
-
-float
------
-
-- &lt;float refstatus="" value="" />
- - value is the float
-
-bool
-----
-
-- &lt;bool refstatus="" value="" />
- -value: true or false
-
-string
-------
-
-- &lt;string refstatus="" length="" value="" />
- - length: length or string
- - value: the string
-
-null
-----
-
-- &lt;null refstatus="" />
-
-array
------
-
-- &lt;array refstatus="" num="">
- - num: number of elements
- - contains &lt;element> tags
- 
-object
-------
-
-- &lt;object refstatus="" class="" id="" num="">
- - class: name of the class the object is an instance of (may be empty if unknown)
- - id: id of the object
- - num: number of properties
- - contains &lt;property> tags
-
-resource
---------
-
-- &lt;resource refstatus="" id="" type="" />
- - id: resource id
- - type: type of resource
-
-recursion
----------
-
-- &lt;recursion />
-- if that tag appears, there's a recursive reference inside the value to be printed
diff --git a/sapi/phpdbg/zend_mm_structs.h b/sapi/phpdbg/zend_mm_structs.h
deleted file mode 100644
index ca64069e0f..0000000000
--- a/sapi/phpdbg/zend_mm_structs.h
+++ /dev/null
@@ -1,102 +0,0 @@
-#ifndef ZEND_MM_STRUCTS_H
-#define ZEND_MM_STRUCTS_H
-
-/* structs and macros defined in Zend/zend_alloc.c
-   Needed for realizing watchpoints and sigsafe memory */
-
-#include "zend.h"
-
-#ifndef ZEND_MM_COOKIES
-#	define ZEND_MM_COOKIES ZEND_DEBUG
-#endif
-
-#define ZEND_MM_CACHE 1
-#ifndef ZEND_MM_CACHE_STAT
-#	define ZEND_MM_CACHE_STAT 0
-#endif
-
-typedef struct _zend_mm_block_info {
-#if ZEND_MM_COOKIES
-	size_t _cookie;
-#endif
-	size_t _size;
-	size_t _prev;
-} zend_mm_block_info;
-
-typedef struct _zend_mm_small_free_block {
-	zend_mm_block_info info;
-#if ZEND_DEBUG
-	unsigned int magic;
-#ifdef ZTS
-	THREAD_T thread_id;
-#endif
-#endif
-	struct _zend_mm_free_block *prev_free_block;
-	struct _zend_mm_free_block *next_free_block;
-} zend_mm_small_free_block;
-
-typedef struct _zend_mm_free_block {
-	zend_mm_block_info info;
-#if ZEND_DEBUG
-	unsigned int magic;
-#ifdef ZTS
-	THREAD_T thread_id;
-#endif
-#endif
-	struct _zend_mm_free_block *prev_free_block;
-	struct _zend_mm_free_block *next_free_block;
-
-	struct _zend_mm_free_block **parent;
-	struct _zend_mm_free_block *child[2];
-} zend_mm_free_block;
-
-#define ZEND_MM_SMALL_FREE_BUCKET(heap, index) \
-	(zend_mm_free_block *) ((char *)&heap->free_buckets[index * 2] + \
-		sizeof(zend_mm_free_block *) * 2 - \
-		sizeof(zend_mm_small_free_block))
-
-#define ZEND_MM_REST_BUCKET(heap) \
-	(zend_mm_free_block *)((char *)&heap->rest_buckets[0] + \
-		sizeof(zend_mm_free_block *) * 2 - \
-		sizeof(zend_mm_small_free_block))
-
-#define ZEND_MM_NUM_BUCKETS (sizeof(size_t) << 3)
-struct _zend_mm_heap {
-	int   use_zend_alloc;
-	void *(*_malloc)(size_t);
-	void  (*_free)(void *);
-	void *(*_realloc)(void *, size_t);
-	size_t              free_bitmap;
-	size_t              large_free_bitmap;
-	size_t              block_size;
-	size_t              compact_size;
-	zend_mm_segment    *segments_list;
-	zend_mm_storage    *storage;
-	size_t              real_size;
-	size_t              real_peak;
-	size_t              limit;
-	size_t              size;
-	size_t              peak;
-	size_t              reserve_size;
-	void               *reserve;
-	int                 overflow;
-	int                 internal;
-#if ZEND_MM_CACHE
-	unsigned int        cached;
-	zend_mm_free_block *cache[ZEND_MM_NUM_BUCKETS];
-#endif
-	zend_mm_free_block *free_buckets[ZEND_MM_NUM_BUCKETS*2];
-	zend_mm_free_block *large_free_buckets[ZEND_MM_NUM_BUCKETS];
-	zend_mm_free_block *rest_buckets[2];
-	int                 rest_count;
-#if ZEND_MM_CACHE_STAT
-	struct {
-		int count;
-		int max_count;
-		int hit;
-		int miss;
-	} cache_stat[ZEND_MM_NUM_BUCKETS+1];
-#endif
-};
-
-#endif