Klasse BppDebugger ist kein echter Debugger, sondern ein Hilfsmittel zur Dekodierung von Bytecode in Textform;
benutzt vom Compiler und im Trace-Modus.

Anbindung eines "echten" (Quellcode-)Debuggers geht ber die VM.
In der VM-Schnittstelle gibt es dazu:
   /// install debug wait procedure 
   BppDbgWaitProc setDbgWaitProc(BppDbgWaitProc dbgWaitProc);
   /// install debug break request procedure
   BppBreakRequestProc setBreakRequestProc(BppBreakRequestProc breakRequestProc);
   /// install debug line changed notification procedure
   BppLineChangedProc setLineChangedProc(BppLineChangedProc lineChangedProc);
   /// cancel running byte code interpreter
   void cancel();

mit 
typedef bool (BPPAPI *BppDbgWaitProc)(BppVirtualMachine* pVM);
typedef bool (BPPAPI *BppBreakRequestProc)(BppVirtualMachine* pVM);
typedef bool (BPPAPI *BppLineChangedProc)(BppVirtualMachine* pVM,const char* srcName, BppInt lineNumber);

DebugWaitProc wird vom Interpreter jeweils vor der Abarbeitung des nchsten Opcodes aufgerufen, falls der Schrittbetrieb (Step-Mode oder Trace-Mode) aktiv ist und keine Abbruchanforderung (_requestCancel) vorliegt. Ihr Zweck ist die Steuerung, ob der Schrittbetrieb bei der nchsten Anweisung fortgesetzt werden soll (Ergebnis true) oder nicht (Ergenbis false)
(effektiv wird das _step-Flag auf das Ergebnis des Aufrufs gesetzt).
Unter Windows kann alternativ mit setDbgWindow das Handle eines Debug-Fensters gesetzt werden. Ist keine DebugWaitProc installiert, wird dann _dbgWaitMsg mit dem Zeiger auf die VM ber SendMessage an das Fenster geschickt; der SendMessage-Aufruf sollte dann _dbgWaitMsg fr true oder einen anderen Wert fr false zurckliefern.

BreakRequestProc wird ebenfalls vor der Abarbeitung eines Opcodes aufgerufen (noch vor DebugWait), falls der Schrittbetrieb gerade nicht aktiv ist.
Somit kann ein Halt vor der nchsten Instruktion angefordert werden. Intern wird ebenfalls das _step-Flag entsprechend dem Aufrufergebnis gesetzt; auch gibt es eine entsprechende Aufrufvariante ber Windows-Messages.

LineChangedProc wird bei jedem Zeilenwechsel des Source-Codes aufgerufen, falls eine bersetzung mit Zeileninformationen erfolgt ist.
Das Ergebnis setzt ebenfalls das _step-Flag der VM. Damit hat ein externer Debugger z.B. die Mglichkeit, Haltepunkte zu verwalten und darber Unterbrechungen des Programmablaufs zu steuern oder in Verbindung mit BreakRequestProc und DebugWaitProc eine zeilenweise Abarbeitung zu organisieren.

Debug-relevante Methoden:
   /// get current source line while bytecode interpreter is running
   long getCurrentLine() const;
   /// Get bytecode interpreter instance.
   BppInterpreter* interpreter() const;
   /// cancel running byte code interpreter
   void cancel();
   /// Access to class table.
   BppDictionary& classes();
   /// Access to symbol table.
   BppDictionary& symbols();

BppInterpreter:
	/// Gets information about current procedure
	inline BppProcInfo* getProcInfo() const BPPNOEXCEPT
	{
		return _procStack;
	}

BppProcInfo:
/** Gets access to part of Bytecode vector by index.
	@param idx Index of part to get, where IDX_CODE (0) is the code buffer, IDX_CLASS (1) the class,
			 IDX_NAME (2) the function name and IDX_DEFAULTARGS (4) vector of default argument values.
	@return Constant reference to part.
	@see BppByteCodeIndex
	*/
	inline const BppValue& operator[](unsigned idx) const
	{
		return (*_bytecode)[idx];
	}
	/// Gets declared name of <i>idx</i>th argument.
	inline const BppChar* getArgumentName(unsigned idx) const { return getLocalVarName(idx, LVT_ARG); }
	/// Gets declared name of <i>idx</i>th local (temporary) variable.
	inline const BppChar* getLocalVarName(unsigned idx) const { return getLocalVarName(idx, LVT_VAR); }
	/// Gets declared name of <i>idx</i>th local static variable.
	inline const BppChar* getLocalStaticVarName(unsigned idx) const { return getLocalVarName(idx, LVT_STATIC); }
	/// Gets access to local variables info vector (if any).
	const BppVector* getLocalVarInfo() const;
	/** Gets Descriptor of function calling the current one.
	@return Pointer to caller function descriptor or 0, if current function has no caller.
	@note Function behaves similary to getParent function. The only difference is checking a flag signaling
	that there is no caller.
	*/
	inline BppProcInfo* getCaller() const BPPNOEXCEPT
	{
		return _nocaller ? 0 : _parent;
	}

	/** Gets parent item of function in call stack.
	@return Pointer to parent item or 0, if there is no parent.
	*/
	inline BppProcInfo* getParent() const BPPNOEXCEPT
	{
		return _parent;
	}
