I am looking for a version of an emulator that is driven from the debugger side. This is ideally having a windows based debugger that uses the emulator engine to execute the Z80 code or by adding the debugger features into a current emulator.

DLL based emulation
This option could be to have an existing emulator ( or even new one ) be controlled by another external program without displaying itself. The emulator could exist as a DLL which exposes functions something like the following.

Added Features 
Debug Commands

Registers Window
Traditional view of registers and flags.

Memory Windows
View memory by setting location, optional format and element size.

Disassembly Window
This window can be viewed RAW as straight code or FORMATTED using the Labels file.

The disassembly window should be able to scroll up and down through and view any part of the program. Interaction with the output would allow for keyboard setting of commands. Eg. Set Breakpoints, Clear Breakpoint, Run to Cursor.

Symbols Window
In my Z80 disassembler I use a file that contains symbols from the program. It is in the format;

Either a version of this file should be supported or the ability to create this information during the sessions should be added. All symbols that are within this system can then be typed in place of memory addresses anywhere in the debugger.

Watch Windows
Set watches on addresses and registers. if a register is watched then putting the register in brackets uses the address that the register points to.

Variable Windows
Like the watch window but automatically shows all variables that have be set in the symbol file.

Breakpoints
Breakpoints can be set at a location.
Breakpoints can be set if a memory address is changed or accessed.
Breakpoints can be set if any byte within a memory range is changed or accessed.

typedef struct {
	break_t	type;
	u16		start;
	u16		end;
} beakpoint_t ;

types might be;

enum break_t {
	BRK_NONE,			/* unused */
	BRK_SINGLE,		/* break at address start*/
	BRK_SINGLE_WRITE, 		/* break if data address written to */
	BRK_SINGLE_READ,		/* break if data address read */
	BRK_SINGLE_READWRITE,	/* break if data address read or written */
	BRK_RANGE,		/* as above for address between start-end */
	BRK_RANGE_READ,
	BRK_RANGE_WRITE,
	BRK_RANGE_READWRITE,
};

View Output
View the screen output in a window while in the debuggers. This window can have attributes turned on or off and can also have a optional memory address assigned to it. This allows the viewing of secondary buffers.

Search
Search for bytes or sequence of bytes. These can be typed in as hex or ascii.

Analysis
An extended function would be to analyse the executing program and add information to the Symbols Table. A quick execution would allow a memory map to be created and then worked on. Eg any memory addresses access are likely to be data whereas address execute are code.

Bookmarks
Bookmarks are a structure that points to a memory snapshot. This snapshot is identical to the emulators native snapshot format ie. .z80 .sna. This data could then be written to a file or reloaded from memory by the emulator. This gives the option for quick load/saving or remembering the machine state during execution.

The Bookmark structure would look something like;

typedef struct {
	void*	data;
	int	size;
} bookmark_t;