Index: trunk/src/VBox/Debugger/DBGCInternal.h
===================================================================
--- trunk/src/VBox/Debugger/DBGCInternal.h	(revision 5681)
+++ trunk/src/VBox/Debugger/DBGCInternal.h	(revision 5685)
@@ -328,4 +328,8 @@
 *   Internal Functions                                                         *
 *******************************************************************************/
+int     dbgcCreate(PDBGC *ppDbgc, PDBGCBACK pBack, unsigned fFlags);
+int     dbgcRun(PDBGC pDbgc);
+void    dbgcDestroy(PDBGC pDbgc);
+
 int     dbgcBpAdd(PDBGC pDbgc, RTUINT iBp, const char *pszCmd);
 int     dbgcBpUpdate(PDBGC pDbgc, RTUINT iBp, const char *pszCmd);
Index: trunk/src/VBox/Debugger/DBGConsole.cpp
===================================================================
--- trunk/src/VBox/Debugger/DBGConsole.cpp	(revision 5681)
+++ trunk/src/VBox/Debugger/DBGConsole.cpp	(revision 5685)
@@ -1820,32 +1820,95 @@
 
 /**
- * Make a console instance.
- *
- * This will not return until either an 'exit' command is issued or a error code
- * indicating connection loss is encountered.
- *
- * @returns VINF_SUCCESS if console termination caused by the 'exit' command.
- * @returns The VBox status code causing the console termination.
- *
- * @param   pVM         VM Handle.
- * @param   pBack       Pointer to the backend structure. This must contain
- *                      a full set of function pointers to service the console.
- * @param   fFlags      Reserved, must be zero.
- * @remark  A forced termination of the console is easiest done by forcing the
- *          callbacks to return fatal failures.
- */
-DBGDECL(int) DBGCCreate(PVM pVM, PDBGCBACK pBack, unsigned fFlags)
+ * Run the debugger console.
+ *
+ * @returns VBox status.
+ * @param   pDbgc   Pointer to the debugger console instance data.
+ */
+int dbgcRun(PDBGC pDbgc)
+{
+    /*
+     * Main Debugger Loop.
+     *
+     * This loop will either block on waiting for input or on waiting on
+     * debug events. If we're forwarding the log we cannot wait for long
+     * before we must flush the log.
+     */
+    int rc = VINF_SUCCESS;
+    for (;;)
+    {
+        if (pDbgc->pVM && DBGFR3CanWait(pDbgc->pVM))
+        {
+            /*
+             * Wait for a debug event.
+             */
+            PCDBGFEVENT pEvent;
+            rc = DBGFR3EventWait(pDbgc->pVM, pDbgc->fLog ? 1 : 32, &pEvent);
+            if (VBOX_SUCCESS(rc))
+            {
+                rc = dbgcProcessEvent(pDbgc, pEvent);
+                if (VBOX_FAILURE(rc))
+                    break;
+            }
+            else if (rc != VERR_TIMEOUT)
+                break;
+
+            /*
+             * Check for input.
+             */
+            if (pDbgc->pBack->pfnInput(pDbgc->pBack, 0))
+            {
+                rc = dbgcProcessInput(pDbgc);
+                if (VBOX_FAILURE(rc))
+                    break;
+            }
+        }
+        else
+        {
+            /*
+             * Wait for input. If Logging is enabled we'll only wait very briefly.
+             */
+            if (pDbgc->pBack->pfnInput(pDbgc->pBack, pDbgc->fLog ? 1 : 1000))
+            {
+                rc = dbgcProcessInput(pDbgc);
+                if (VBOX_FAILURE(rc))
+                    break;
+            }
+        }
+
+        /*
+         * Forward log output.
+         */
+        if (pDbgc->fLog)
+        {
+            rc = dbgcProcessLog(pDbgc);
+            if (VBOX_FAILURE(rc))
+                break;
+        }
+    }
+
+    return rc;
+}
+
+
+/**
+ * Creates a a new instance.
+ *
+ * @returns VBox status code.
+ * @param   ppDbgc      Where to store the pointer to the instance data.
+ * @param   pBack       Pointer to the backend.
+ * @param   fFlags      The flags.
+ */
+int dbgcCreate(PDBGC *ppDbgc, PDBGCBACK pBack, unsigned fFlags)
 {
     /*
      * Validate input.
      */
-    AssertReturn(VALID_PTR(pVM), VERR_INVALID_PARAMETER);
-    AssertReturn(VALID_PTR(pBack), VERR_INVALID_PARAMETER);
+    AssertPtrReturn(pBack, VERR_INVALID_POINTER);
     AssertMsgReturn(!fFlags, ("%#x", fFlags), VERR_INVALID_PARAMETER);
 
     /*
-     * Allocate and initialize instance data
-     */
-    PDBGC   pDbgc = (PDBGC)RTMemAllocZ(sizeof(*pDbgc));
+     * Allocate and initialize.
+     */
+    PDBGC pDbgc = (PDBGC)RTMemAllocZ(sizeof(*pDbgc));
     if (!pDbgc)
         return VERR_NO_MEMORY;
@@ -1879,97 +1942,17 @@
     dbgcInitOpCharBitMap();
 
-    /*
-     * Print welcome message.
-     */
-    int rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL,
-        "Welcome to the VirtualBox Debugger!\n");
-    if (VBOX_FAILURE(rc))
-        goto l_failure;
-
-    /*
-     * Attach to the VM.
-     */
-    rc = DBGFR3Attach(pVM);
-    if (VBOX_FAILURE(rc))
-    {
-        rc = pDbgc->CmdHlp.pfnVBoxError(&pDbgc->CmdHlp, rc, "When trying to attach to VM %p\n", pDbgc->pVM);
-        goto l_failure;
-    }
-    pDbgc->pVM = pVM;
-
-    /*
-     * Print commandline and auto select result.
-     */
-    rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL,
-        "Current VM is %08x\n" /** @todo get and print the VM name! */
-        "VBoxDbg> ",
-        pDbgc->pVM);
-    if (VBOX_FAILURE(rc))
-        goto l_failure;
-
-    /*
-     * Main Debugger Loop.
-     *
-     * This loop will either block on waiting for input or on waiting on
-     * debug events. If we're forwarding the log we cannot wait for long
-     * before we must flush the log.
-     */
-    for (rc = 0;;)
-    {
-        if (pDbgc->pVM && DBGFR3CanWait(pDbgc->pVM))
-        {
-            /*
-             * Wait for a debug event.
-             */
-            PCDBGFEVENT pEvent;
-            rc = DBGFR3EventWait(pDbgc->pVM, pDbgc->fLog ? 1 : 32, &pEvent);
-            if (VBOX_SUCCESS(rc))
-            {
-                rc = dbgcProcessEvent(pDbgc, pEvent);
-                if (VBOX_FAILURE(rc))
-                    break;
-            }
-            else if (rc != VERR_TIMEOUT)
-                break;
-
-            /*
-             * Check for input.
-             */
-            if (pBack->pfnInput(pDbgc->pBack, 0))
-            {
-                rc = dbgcProcessInput(pDbgc);
-                if (VBOX_FAILURE(rc))
-                    break;
-            }
-        }
-        else
-        {
-            /*
-             * Wait for input. If Logging is enabled we'll only wait very briefly.
-             */
-            if (pBack->pfnInput(pDbgc->pBack, pDbgc->fLog ? 1 : 1000))
-            {
-                rc = dbgcProcessInput(pDbgc);
-                if (VBOX_FAILURE(rc))
-                    break;
-            }
-        }
-
-        /*
-         * Forward log output.
-         */
-        if (pDbgc->fLog)
-        {
-            rc = dbgcProcessLog(pDbgc);
-            if (VBOX_FAILURE(rc))
-                break;
-        }
-    }
-
-
-l_failure:
-    /*
-     * Cleanup console debugger session.
-     */
+    *ppDbgc = pDbgc;
+    return VINF_SUCCESS;
+}
+
+/**
+ * Destroys a DBGC instance created by dbgcCreate.
+ *
+ * @param   pDbgc   Pointer to the debugger console instance data.
+ */
+void dbgcDestroy(PDBGC pDbgc)
+{
+    AssertPtr(pDbgc);
+
     /* Disable log hook. */
     if (pDbgc->fLog)
@@ -1984,5 +1967,75 @@
     /* finally, free the instance memory. */
     RTMemFree(pDbgc);
-
+}
+
+
+/**
+ * Make a console instance.
+ *
+ * This will not return until either an 'exit' command is issued or a error code
+ * indicating connection loss is encountered.
+ *
+ * @returns VINF_SUCCESS if console termination caused by the 'exit' command.
+ * @returns The VBox status code causing the console termination.
+ *
+ * @param   pVM         VM Handle.
+ * @param   pBack       Pointer to the backend structure. This must contain
+ *                      a full set of function pointers to service the console.
+ * @param   fFlags      Reserved, must be zero.
+ * @remark  A forced termination of the console is easiest done by forcing the
+ *          callbacks to return fatal failures.
+ */
+DBGDECL(int) DBGCCreate(PVM pVM, PDBGCBACK pBack, unsigned fFlags)
+{
+    /*
+     * Validate input.
+     */
+    AssertPtrNullReturn(pVM, VERR_INVALID_POINTER);
+
+    /*
+     * Allocate and initialize instance data
+     */
+    PDBGC pDbgc;
+    int rc = dbgcCreate(&pDbgc, pBack, fFlags);
+    if (RT_FAILURE(rc))
+        return rc;
+
+    /*
+     * Print welcome message.
+     */
+    rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL,
+                                 "Welcome to the VirtualBox Debugger!\n");
+
+    /*
+     * Attach to the specified VM.
+     */
+    if (RT_SUCCESS(rc) && pVM)
+    {
+        rc = DBGFR3Attach(pVM);
+        if (RT_SUCCESS(rc))
+        {
+            pDbgc->pVM = pVM;
+            rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL,
+                                         "Current VM is %08x\n" /** @todo get and print the VM name! */
+                                         "VBoxDbg> ",
+                                         pDbgc->pVM);
+        }
+        else
+            rc = pDbgc->CmdHlp.pfnVBoxError(&pDbgc->CmdHlp, rc, "When trying to attach to VM %p\n", pDbgc->pVM);
+    }
+    else
+        rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL,
+                                     "VBoxDbg> ");
+
+    /*
+     * Run the main loop.
+     */
+    if (RT_SUCCESS(rc))
+        rc = dbgcRun(pDbgc);
+
+    /*
+     * Cleanup console debugger session.
+     */
+    dbgcDestroy(pDbgc);
     return rc;
 }
Index: trunk/src/VBox/Debugger/Makefile.kmk
===================================================================
--- trunk/src/VBox/Debugger/Makefile.kmk	(revision 5681)
+++ trunk/src/VBox/Debugger/Makefile.kmk	(revision 5685)
@@ -59,7 +59,9 @@
 # This stubs all the VBoxVMM APIs.
 #
-tstDBGCParser_TEMPLATE = VBOXR3EXE
+tstDBGCParser_TEMPLATE = VBOXR3TSTEXE
+tstDBGCParser_DEFS = IN_DBGF_R3 IN_CPUM_R3 IN_MM_R3 IN_PGM_R3 IN_SELM_R3
 tstDBGCParser_SOURCES = \
-	testcase/tstDBGCParser.cpp
+	testcase/tstDBGCParser.cpp \
+	testcase/tstDBGCStubs.cpp
 tstDBGCParser_LIBS = \
 	$(TARGET_Debugger) \
@@ -73,5 +75,4 @@
 VBoxDbg_DEFS = IN_DBG_R3
 VBoxDbg_CXXFLAGS.linux = $(TEMPLATE_VBOXQTGUI_CXXFLAGS.linux) -O2
-VBoxDbg_CXXFLAGS.win = -wd4244
 VBoxDbg_INCS = \
 	. \
Index: trunk/src/VBox/Debugger/testcase/tstDBGCParser.cpp
===================================================================
--- trunk/src/VBox/Debugger/testcase/tstDBGCParser.cpp	(revision 5681)
+++ trunk/src/VBox/Debugger/testcase/tstDBGCParser.cpp	(revision 5685)
@@ -29,8 +29,109 @@
 
 /*******************************************************************************
+*   Internal Functions                                                         *
+*******************************************************************************/
+static DECLCALLBACK(bool) tstDBGCBackInput(PDBGCBACK pBack, uint32_t cMillies);
+static DECLCALLBACK(int) tstDBGCBackRead(PDBGCBACK pBack, void *pvBuf, size_t cbBuf, size_t *pcbRead);
+static DECLCALLBACK(int) tstDBGCBackWrite(PDBGCBACK pBack, const void *pvBuf, size_t cbBuf, size_t *pcbWritten);
+
+
+/*******************************************************************************
 *   Global Variables                                                           *
 *******************************************************************************/
 /** Global error counter. */
 static unsigned g_cErrors = 0;
+/** The DBGC backend structure for use in this testcase. */
+static DBGCBACK g_tstBack =
+{
+    tstDBGCBackInput,
+    tstDBGCBackRead,
+    tstDBGCBackWrite
+};
+/** For keeping track of output prefixing. */
+static bool g_fPendingPrefix = true;
+
+
+/**
+ * Checks if there is input.
+ *
+ * @returns true if there is input ready.
+ * @returns false if there not input ready.
+ * @param   pBack       Pointer to the backend structure supplied by
+ *                      the backend. The backend can use this to find
+ *                      it's instance data.
+ * @param   cMillies    Number of milliseconds to wait on input data.
+ */
+static DECLCALLBACK(bool) tstDBGCBackInput(PDBGCBACK pBack, uint32_t cMillies)
+{
+    RTPrintf("tstDBGCParser: tstDBGCBackInput was called!\n");
+    g_cErrors++;
+    return false;
+}
+
+
+/**
+ * Read input.
+ *
+ * @returns VBox status code.
+ * @param   pBack       Pointer to the backend structure supplied by
+ *                      the backend. The backend can use this to find
+ *                      it's instance data.
+ * @param   pvBuf       Where to put the bytes we read.
+ * @param   cbBuf       Maximum nymber of bytes to read.
+ * @param   pcbRead     Where to store the number of bytes actually read.
+ *                      If NULL the entire buffer must be filled for a
+ *                      successful return.
+ */
+static DECLCALLBACK(int) tstDBGCBackRead(PDBGCBACK pBack, void *pvBuf, size_t cbBuf, size_t *pcbRead)
+{
+    RTPrintf("tstDBGCParser: tstDBGCBackRead was called!\n");
+    g_cErrors++;
+    return VERR_INTERNAL_ERROR;
+}
+
+
+/**
+ * Write (output).
+ *
+ * @returns VBox status code.
+ * @param   pBack       Pointer to the backend structure supplied by
+ *                      the backend. The backend can use this to find
+ *                      it's instance data.
+ * @param   pvBuf       What to write.
+ * @param   cbBuf       Number of bytes to write.
+ * @param   pcbWritten  Where to store the number of bytes actually written.
+ *                      If NULL the entire buffer must be successfully written.
+ */
+static DECLCALLBACK(int) tstDBGCBackWrite(PDBGCBACK pBack, const void *pvBuf, size_t cbBuf, size_t *pcbWritten)
+{
+    const char *pch = (const char *)pvBuf;
+    *pcbWritten = cbBuf;
+    while (cbBuf-- > 0)
+    {
+        if (g_fPendingPrefix)
+        {
+            RTPrintf("tstDBGCParser: OUTPUT: ");
+            g_fPendingPrefix = false;
+        }
+        if (*pch == '\n')
+            g_fPendingPrefix = true;
+        RTPrintf("%c", *pch);
+        pch++;
+    }
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * Completes the output, making sure that we're in
+ * the 1 position of a new line.
+ */
+static void tstCompleteOutput(void)
+{
+    if (!g_fPendingPrefix)
+        RTPrintf("\n");
+    g_fPendingPrefix = true;
+}
+
 
 
@@ -45,6 +146,13 @@
 
     /*
-     *
+     * Create a DBGC instance.
      */
+    PDBGC pDbgc;
+    int rc = dbgcCreate(&pDbgc, &g_tstBack, 0);
+    if (RT_SUCCESS(rc))
+    {
+
+        dbgcDestroy(pDbgc);
+    }
 
 
Index: trunk/src/VBox/Debugger/testcase/tstDBGCStubs.cpp
===================================================================
--- trunk/src/VBox/Debugger/testcase/tstDBGCStubs.cpp	(revision 5685)
+++ trunk/src/VBox/Debugger/testcase/tstDBGCStubs.cpp	(revision 5685)
@@ -0,0 +1,277 @@
+/* $Id$ */
+/** @file
+ * DBGC Testcase - Command Parser, VMM Stub Functions.
+ */
+
+/*
+ * Copyright (c) 2007 knut st. osmundsen <bird-kStuff-spam@anduin.net>
+ *
+ * This file is part of VirtualBox Open Source Edition (OSE), as
+ * available from http://www.virtualbox.org. This file is free software;
+ * you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License as published by the Free Software Foundation,
+ * in version 2 as it comes in the "COPYING" file of the VirtualBox OSE
+ * distribution. VirtualBox OSE is distributed in the hope that it will
+ * be useful, but WITHOUT ANY WARRANTY of any kind.
+ *
+ */
+
+#include <VBox/err.h>
+#include <VBox/cpum.h>
+
+CPUMDECL(uint32_t) CPUMGetGuestCR3(PVM pVM)
+{
+    return 0;
+}
+
+CPUMDECL(uint32_t) CPUMGetGuestCR4(PVM pVM)
+{
+    return 0;
+}
+
+CPUMDECL(RTSEL) CPUMGetGuestCS(PVM pVM)
+{
+    return 0;
+}
+
+CPUMDECL(PCCPUMCTXCORE) CPUMGetGuestCtxCore(PVM pVM)
+{
+    return NULL;
+}
+
+CPUMDECL(uint32_t) CPUMGetGuestEIP(PVM pVM)
+{
+    return 0;
+}
+
+CPUMDECL(uint32_t) CPUMGetGuestIDTR(PVM pVM, uint16_t *pcbLimit)
+{
+    return 0;
+}
+
+CPUMDECL(CPUMMODE) CPUMGetGuestMode(PVM pVM)
+{
+    return CPUMMODE_INVALID;
+}
+
+CPUMDECL(RTSEL) CPUMGetHyperCS(PVM pVM)
+{
+    return 0xfff8;
+}
+
+CPUMDECL(PCCPUMCTXCORE) CPUMGetHyperCtxCore(PVM pVM)
+{
+    return NULL;
+}
+
+CPUMDECL(uint32_t) CPUMGetHyperEIP(PVM pVM)
+{
+    return 0;
+}
+
+CPUMDECL(int) CPUMQueryGuestCtxPtr(PVM pVM, PCPUMCTX *ppCtx)
+{
+    return VERR_INTERNAL_ERROR;
+}
+
+CPUMDECL(int) CPUMQueryHyperCtxPtr(PVM pVM, PCPUMCTX *ppCtx)
+{
+    return VERR_INTERNAL_ERROR;
+}
+
+
+#include <VBox/mm.h>
+
+MMR3DECL(int) MMR3HCPhys2HCVirt(PVM pVM, RTHCPHYS HCPhys, void **ppv)
+{
+    return VERR_INTERNAL_ERROR;
+}
+
+MMR3DECL(int) MMR3ReadGCVirt(PVM pVM, void *pvDst, RTGCPTR GCPtr, size_t cb)
+{
+    return VERR_INTERNAL_ERROR;
+}
+
+
+#include <VBox/selm.h>
+
+SELMR3DECL(int) SELMR3GetSelectorInfo(PVM pVM, RTSEL Sel, PSELMSELINFO pSelInfo)
+{
+    return VERR_INTERNAL_ERROR;
+}
+
+
+#include <VBox/pgm.h>
+
+PGMDECL(uint32_t) PGMGetHyperCR3(PVM pVM)
+{
+    return 0;
+}
+
+PGMDECL(PGMMODE) PGMGetShadowMode(PVM pVM)
+{
+    return PGMMODE_INVALID;
+}
+
+PGMDECL(int) PGMPhysGCPhys2HCPhys(PVM pVM, RTGCPHYS GCPhys, PRTHCPHYS pHCPhys)
+{
+    return VERR_INTERNAL_ERROR;
+}
+
+PGMDECL(int) PGMPhysGCPhys2HCPtr(PVM pVM, RTGCPHYS GCPhys, RTUINT cbRange, PRTHCPTR pHCPtr)
+{
+    return VERR_INTERNAL_ERROR;
+}
+
+PGMDECL(int) PGMPhysGCPtr2GCPhys(PVM pVM, RTGCPTR GCPtr, PRTGCPHYS pGCPhys)
+{
+    return VERR_INTERNAL_ERROR;
+}
+
+PGMDECL(int) PGMPhysGCPtr2HCPhys(PVM pVM, RTGCPTR GCPtr, PRTHCPHYS pHCPhys)
+{
+    return VERR_INTERNAL_ERROR;
+}
+
+PGMDECL(int) PGMPhysGCPtr2HCPtr(PVM pVM, RTGCPTR GCPtr, PRTHCPTR pHCPtr)
+{
+    return VERR_INTERNAL_ERROR;
+}
+
+PGMDECL(int) PGMPhysReadGCPhys(PVM pVM, void *pvDst, RTGCPHYS GCPhysSrc, size_t cb)
+{
+    return VERR_INTERNAL_ERROR;
+}
+
+PGMR3DECL(int) PGMR3DbgHCPtr2GCPhys(PVM pVM, RTHCPTR HCPtr, PRTGCPHYS pGCPhys)
+{
+    return VERR_INTERNAL_ERROR;
+}
+
+PGMR3DECL(int) PGMR3DbgHCPtr2HCPhys(PVM pVM, RTHCPTR HCPtr, PRTHCPHYS pHCPhys)
+{
+    return VERR_INTERNAL_ERROR;
+}
+
+
+#include <VBox/dbgf.h>
+DBGFR3DECL(void) DBGFR3AddrFromFlat(PVM pVM, PDBGFADDRESS pAddress, RTGCUINTPTR FlatPtr)
+{
+}
+
+DBGFR3DECL(int) DBGFR3AddrFromSelOff(PVM pVM, PDBGFADDRESS pAddress, RTSEL Sel, RTUINTPTR off)
+{
+    return VERR_INTERNAL_ERROR;
+}
+
+DBGFR3DECL(int) DBGFR3Attach(PVM pVM)
+{
+    return VERR_INTERNAL_ERROR;
+}
+
+DBGFR3DECL(int) DBGFR3BpClear(PVM pVM, RTUINT iBp)
+{
+    return VERR_INTERNAL_ERROR;
+}
+DBGFR3DECL(int) DBGFR3BpDisable(PVM pVM, RTUINT iBp)
+{
+    return VERR_INTERNAL_ERROR;
+}
+DBGFR3DECL(int) DBGFR3BpEnable(PVM pVM, RTUINT iBp)
+{
+    return VERR_INTERNAL_ERROR;
+}
+DBGFR3DECL(int) DBGFR3BpEnum(PVM pVM, PFNDBGFBPENUM pfnCallback, void *pvUser)
+{
+    return VERR_INTERNAL_ERROR;
+}
+DBGFR3DECL(int) DBGFR3BpSet(PVM pVM, PCDBGFADDRESS pAddress, uint64_t iHitTrigger, uint64_t iHitDisable, PRTUINT piBp)
+{
+    return VERR_INTERNAL_ERROR;
+}
+DBGFR3DECL(int) DBGFR3BpSetReg(PVM pVM, PCDBGFADDRESS pAddress, uint64_t iHitTrigger, uint64_t iHitDisable,
+                               uint8_t fType, uint8_t cb, PRTUINT piBp)
+{
+    return VERR_INTERNAL_ERROR;
+}
+DBGFR3DECL(int) DBGFR3BpSetREM(PVM pVM, PCDBGFADDRESS pAddress, uint64_t iHitTrigger, uint64_t iHitDisable, PRTUINT piBp)
+{
+    return VERR_INTERNAL_ERROR;
+}
+DBGFR3DECL(bool) DBGFR3CanWait(PVM pVM)
+{
+    return true;
+}
+DBGFR3DECL(int) DBGFR3Detach(PVM pVM)
+{
+    return VERR_INTERNAL_ERROR;
+}
+DBGFR3DECL(int) DBGFR3DisasInstrEx(PVM pVM, RTSEL Sel, RTGCPTR GCPtr, unsigned fFlags, char *pszOutput, uint32_t cchOutput, uint32_t *pcbInstr)
+{
+    return VERR_INTERNAL_ERROR;
+}
+DBGFR3DECL(int) DBGFR3EventWait(PVM pVM, unsigned cMillies, PCDBGFEVENT *ppEvent)
+{
+    return VERR_INTERNAL_ERROR;
+}
+DBGFR3DECL(int) DBGFR3Halt(PVM pVM)
+{
+    return VERR_INTERNAL_ERROR;
+}
+DBGFR3DECL(int) DBGFR3Info(PVM pVM, const char *pszName, const char *pszArgs, PCDBGFINFOHLP pHlp)
+{
+    return VERR_INTERNAL_ERROR;
+}
+DBGFR3DECL(bool) DBGFR3IsHalted(PVM pVM)
+{
+    return true;
+}
+DBGFR3DECL(int) DBGFR3LineByAddr(PVM pVM, RTGCUINTPTR Address, PRTGCINTPTR poffDisplacement, PDBGFLINE pLine)
+{
+    return VERR_INTERNAL_ERROR;
+}
+DBGFR3DECL(int) DBGFR3LogModifyDestinations(PVM pVM, const char *pszDestSettings)
+{
+    return VERR_INTERNAL_ERROR;
+}
+DBGFR3DECL(int) DBGFR3LogModifyFlags(PVM pVM, const char *pszFlagSettings)
+{
+    return VERR_INTERNAL_ERROR;
+}
+DBGFR3DECL(int) DBGFR3LogModifyGroups(PVM pVM, const char *pszGroupSettings)
+{
+    return VERR_INTERNAL_ERROR;
+}
+DBGFR3DECL(int) DBGFR3ModuleLoad(PVM pVM, const char *pszFilename, RTGCUINTPTR AddressDelta, const char *pszName, RTGCUINTPTR ModuleAddress, unsigned cbImage)
+{
+    return VERR_INTERNAL_ERROR;
+}
+DBGFR3DECL(int) DBGFR3Resume(PVM pVM)
+{
+    return VERR_INTERNAL_ERROR;
+}
+DBGFR3DECL(int) DBGFR3StackWalkBeginGuest(PVM pVM, PDBGFSTACKFRAME pFrame)
+{
+    return VERR_INTERNAL_ERROR;
+}
+DBGFR3DECL(int) DBGFR3StackWalkBeginHyper(PVM pVM, PDBGFSTACKFRAME pFrame)
+{
+    return VERR_INTERNAL_ERROR;
+}
+DBGFR3DECL(int) DBGFR3StackWalkNext(PVM pVM, PDBGFSTACKFRAME pFrame)
+{
+    return VERR_INTERNAL_ERROR;
+}
+DBGFR3DECL(int) DBGFR3Step(PVM pVM)
+{
+    return VERR_INTERNAL_ERROR;
+}
+DBGFR3DECL(int) DBGFR3SymbolByAddr(PVM pVM, RTGCUINTPTR Address, PRTGCINTPTR poffDisplacement, PDBGFSYMBOL pSymbol)
+{
+    return VERR_INTERNAL_ERROR;
+}
+DBGFR3DECL(int) DBGFR3SymbolByName(PVM pVM, const char *pszSymbol, PDBGFSYMBOL pSymbol)
+{
+    return VERR_INTERNAL_ERROR;
+}
+
