/*

    espec - Sinclair Spectrum emulator

    Copyright (C) 2003  Ian Cowburn (ianc@noddybox.demon.co.uk)

    This program 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; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    -------------------------------------------------------------------------

    Provides the memory menu

*/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>

#include "memmenu.h"
#include "spec.h"
#include "gfx.h"
#include "gui.h"
#include "util.h"
#include "expr.h"

#include <SDL.h>

#ifndef TRUE
#define TRUE		1
#endif

#ifndef FALSE
#define FALSE		0
#endif

#define WHITE		GFXRGB(255,255,255)
#define BLACK		GFXRGB(0,0,0)
#define RED		GFXRGB(255,100,100)
#define GREEN		GFXRGB(100,255,100)
#define BLUE		GFXRGB(100,100,255)

#define TRACE		"trace"
#define TRACEMEM_WIN	10

#define HI(w)		(((w)&0xff00)>>8)
#define LO(w)		((w)&0xff)


/* ---------------------------------------- TYPES
*/
typedef struct
{
    int		no;
    int		*active;
    char	**expr;
} Breakpoint;


typedef struct
{
    Z80Word	addr;
    Z80Word	val;
} MemTrace;


typedef struct
{
    Z80State	s;
    MemTrace	hl[TRACEMEM_WIN];
    MemTrace	de[TRACEMEM_WIN];
    MemTrace	sp[TRACEMEM_WIN];
} Trace;


/* ---------------------------------------- STATIC DATA
*/
static FILE		*trace=NULL;
static Breakpoint	bpoint={0,NULL,NULL};
static const char	*brk=NULL;
static int		lodged=FALSE;


/* ---------------------------------------- PROTOS
*/
static int		Instruction(Z80 *z80, Z80Val data);
static int		Address(Z80 *z80, const char *p, Z80Word *addr);
static int		Expand(void *client, const char *p, long *res);


/* ---------------------------------------- PRIVATE FUNCTIONS
*/
static int StrEq(const char *a, const char *b)
{
    while(*a && *b && tolower(*a)==tolower(*b))
    {
        a++;
        b++;
    }

    if (*a || *b)
        return FALSE;
    else
        return TRUE;
}


static int Address(Z80 *z80, const char *p, Z80Word *addr)
{
    long e=0;

    if (ExprEval(p,&e,Expand,z80))
    {
    	*addr=e;
	return TRUE;
    }
    else
    {
    	return FALSE;
    }
}

static int Expand(void *client, const char *p, long *res)
{
    Z80State s;
    int ok=TRUE;

    Z80GetState(client,&s);

    if (StrEq(p,"AF"))
    	*res=s.AF;
    else if (StrEq(p,"BC"))
    	*res=s.BC;
    else if (StrEq(p,"DE"))
    	*res=s.DE;
    else if (StrEq(p,"HL"))
    	*res=s.HL;
    else if (StrEq(p,"IX"))
    	*res=s.IX;
    else if (StrEq(p,"IY"))
    	*res=s.IY;
    else if (StrEq(p,"SP"))
    	*res=s.SP;
    else if (StrEq(p,"PC"))
    	*res=s.PC;
    else if (StrEq(p,"A"))
    	*res=HI(s.AF);
    else if (StrEq(p,"F"))
    	*res=LO(s.AF);
    else if (StrEq(p,"B"))
    	*res=HI(s.BC);
    else if (StrEq(p,"C"))
    	*res=LO(s.BC);
    else if (StrEq(p,"D"))
    	*res=HI(s.DE);
    else if (StrEq(p,"E"))
    	*res=LO(s.DE);
    else if (StrEq(p,"H"))
    	*res=HI(s.HL);
    else if (StrEq(p,"L"))
    	*res=LO(s.HL);
    else if (StrEq(p,"AF_"))
    	*res=s.AF_;
    else if (StrEq(p,"BC_"))
    	*res=s.BC_;
    else if (StrEq(p,"DE_"))
    	*res=s.DE_;
    else if (StrEq(p,"HL_"))
    	*res=s.HL_;
    else if (StrEq(p,"A_"))
    	*res=HI(s.AF_);
    else if (StrEq(p,"F_"))
    	*res=LO(s.AF_);
    else if (StrEq(p,"B_"))
    	*res=HI(s.BC_);
    else if (StrEq(p,"C_"))
    	*res=LO(s.BC_);
    else if (StrEq(p,"D_"))
    	*res=HI(s.DE_);
    else if (StrEq(p,"E_"))
    	*res=LO(s.DE_);
    else if (StrEq(p,"H_"))
    	*res=HI(s.HL_);
    else if (StrEq(p,"L_"))
	*res=LO(s.HL_);
    else if (StrEq(p,"IM"))
	*res=s.IM;
    else if (StrEq(p,"R"))
	*res=s.R;
    else if (StrEq(p,"IFF1"))
	*res=s.IFF1;
    else if (StrEq(p,"IFF2"))
	*res=s.IFF2;
    else if (p[0]=='@')
    {
	Z80Word n;

	if (Address(client,p+1,&n))
	{
	    *res=SPECDisPeek(client,n);
	}
	else
	{
	    ok=FALSE;
	}
    }

    return ok;
}


static int BreaksActive(void)
{
    int f;
    int ret=FALSE;

    for(f=0;f<bpoint.no && !ret;f++)
    	ret|=bpoint.active[f];

    return ret;
}


static void SetCallback(Z80 *z80)
{
    if ((trace || BreaksActive()) && !lodged)
    {
	Z80LodgeCallback(z80,eZ80_Instruction,Instruction);
	lodged=TRUE;
    }
}


static void ClearCallback(Z80 *z80)
{
    if (!trace && !BreaksActive() && lodged)
    {
	Z80RemoveCallback(z80,eZ80_Instruction,Instruction);
	lodged=FALSE;
    }
}


static int AddBreak(Z80 *z80, const char *expr)
{
    bpoint.no++;
    bpoint.expr=Realloc(bpoint.expr,bpoint.no * sizeof(*bpoint.expr));
    bpoint.active=Realloc(bpoint.active,bpoint.no * sizeof(*bpoint.active));

    bpoint.expr[bpoint.no-1]=StrCopy(expr);
    bpoint.active[bpoint.no-1]=TRUE;

    SetCallback(z80);

    return bpoint.no-1;
}


static void DeleteBreak(Z80 *z80, int no)
{
    int f;

    if (no>=bpoint.no)
    	return;

    free(bpoint.expr[no]);

    for(f=no;f<bpoint.no-1;f++)
    {
	bpoint.expr[f]=bpoint.expr[f+1];
	bpoint.active[f]=bpoint.active[f+1];
    }

    bpoint.no--;

    if (bpoint.no==0)
    {
	free(bpoint.expr);
	bpoint.expr=NULL;
	bpoint.active=NULL;
    }
    else
    {
	bpoint.expr=Realloc(bpoint.expr,
			    bpoint.no * sizeof(*bpoint.expr));
	bpoint.active=Realloc(bpoint.active,
			      bpoint.no * sizeof(*bpoint.active));
    }

    ClearCallback(z80);
}


static void Centre(const char *p, int y, Uint32 col)
{
    GFXPrint((GFX_WIDTH-strlen(p)*8)/2,y,col,"%s",p);
}


static void CentrePaper(const char *p, int y, Uint32 pen, Uint32 paper)
{
    GFXPrintPaper((GFX_WIDTH-strlen(p)*8)/2,y,pen,paper,"%s",p);
}


static void DisplayMenu(void)
{
    static const char *menu[]=
    {
    	"1   - Disassemble/Hex dump  ",
    	"2   - Disassemble to file   ",
	"3   - Start/Stop trace log  ",
	"4   - Playback trace log    ",
	"5   - Add a new breakpoint  ",
	"6   - Set active breakpoints",
	"7   - Remove a breakpoint   ",
	"8   - Clear all breakpoints ",
	"9   - Monitor               ",
	"R   - Reset                 ",
	"X   - Exit (without confirm)",
    	"ESC - Return                ",
	NULL
    };

    int f;

    GFXClear(BLACK);

    Centre("MEMORY MENU",0,WHITE);
    Centre("Select an option",10,RED);

    f=0;

    while(menu[f])
    {
    	Centre(menu[f],25+f*10,WHITE);
	f++;
    }
}


static const char *FlagString(Z80Byte flag)
{
    static char s[]="76543210";
    static char c[]="SZ5H3PNC";
    int f;

    for(f=0;f<8;f++)
        if (flag&(1<<(7-f)))
            s[f]=c[f];
        else
            s[f]='-';

    return s;
}


void DisplayZ80State(Z80State *s, int y, Uint32 col)
{
    GFXPrintPaper(0,y,col,BLACK,
		  "PC=%4.4x  A=%2.2x     F=%s",
		  s->PC,s->AF>>8,FlagString(s->AF&0xff));
    y+=8;
    GFXPrintPaper(0,y,col,BLACK,
    		  "BC=%4.4x  DE=%4.4x  HL=%4.4x",
		  s->BC,s->DE,s->HL);
    y+=8;
    GFXPrintPaper(0,y,col,BLACK,
    		  "IX=%4.4x  IY=%4.4x  SP=%4.4x",
		  s->IX,s->IY,s->SP);
    y+=8;
    GFXPrintPaper(0,y,col,BLACK,
    		  "AF'=%4.4x BC'=%4.4x DE'=%4.4x HL'=%4.4x",
		  s->AF_,s->BC_,s->DE_,s->HL_);
    y+=8;
    GFXPrintPaper(0,y,col,BLACK,
    		  "I=%2.2x     IM=%2.2x    R=%2.2x",
		  s->I,s->IM,s->R);
    y+=8;
    GFXPrintPaper(0,y,col,BLACK,
    		  "IFF1=%2.2x  IFF2=%2.2x",
		  s->IFF1,s->IFF2);
}


static int EnterAddress(const char *prompt, Z80 *z80, Z80Word *w)
{
    const char *p;
    long l;

    p=GUIInputString(prompt ? prompt : "Address?","");

    if (*p)
    {
	if (ExprEval(p,&l,Expand,z80))
	{
	    *w=(Z80Word)l;
	    return TRUE;
	}
	else
	{
	    GUIMessage(eMessageBox,"ERROR","%s",ExprError());
	}
    }

    return FALSE;
}


static void EnterLong(const char *prompt, long *l)
{
    const char *p;

    p=GUIInputString(prompt ? prompt : "Value?","");

    if (*p)
    	*l=strtol(p,NULL,0);
}


static void DoDisassem(Z80 *z80, const Z80State *s)
{
    static int hexmode=FALSE;
    Z80Word pc=s->PC;
    int quit=FALSE;

    while(!quit)
    {
	SDL_Event *e;
	Z80Word curr=0;
	Z80Word next=0;
	int f;

	GFXClear(BLACK);

    	Centre("DISASSEMBLY",0,WHITE);
    	Centre("Press F1 for help",9,RED);

	curr=pc;

	for(f=0;f<GFX_HEIGHT/8-8;f++)
	{
	    char s[80];
	    char *p;
	    int y;

	    y=24+f*8;

	    GFXPrint(0,y,GREEN,"%4.4x",curr);

	    if (hexmode)
	    {
		int n;
		char asc[9];

	    	for(n=0;n<8;n++)
		{
		    Z80Byte b;

		    b=SPECDisPeek(z80,curr);

		    GFXPrint(40+n*24,y,WHITE,"%2.2x",(int)b);

		    curr++;

		    if (isprint(b))
		    	asc[n]=b;
		    else
		    	asc[n]='.';
		}

		asc[8]=0;

		GFXPrint(40+8*24,y,RED,"%s",asc);
	    }
	    else
	    {
		strcpy(s,Z80Disassemble(z80,&curr));

		p=strtok(s,";");
		GFXPrint(40,y,WHITE,"%s",p);
	    }

	    if (f==0)
		next=curr;
	}

	GFXEndFrame(FALSE);

	e=GFXWaitKey();

	switch(e->key.keysym.sym)
	{
	    case SDLK_F1:
		GUIMessage
		    (eMessageBox, "DISASSEMBLY HELP","%s",
		       "ESC         - Exit              \n"
		       "H           - Disassembly/hex   \n"
		       "Enter       - Enter address     \n"
		       "Up          - Prev byte         \n"
		       "Down        - Next op           \n"
		       "Page Up     - Back 1 page       \n"
		       "Page Down   - Forward 1 page    \n"
		       "Left        - Forward 1024 bytes\n"
		       "Right       - Back 1024 bytes   ");
		break;

	    case SDLK_ESCAPE:
	    	quit=TRUE;
		break;

	    case SDLK_h:
		hexmode=!hexmode;
	    	break;

	    case SDLK_RETURN:
	    case SDLK_KP_ENTER:
		EnterAddress(NULL,z80,&pc);
	    	break;

	    case SDLK_UP:
		if (hexmode)
		    pc-=8;
		else
		    pc--;
	    	break;

	    case SDLK_DOWN:
		pc=next;
	    	break;

	    case SDLK_PAGEUP:
		if (hexmode)
		    pc-=21*8;
		else
		    pc-=21;
		break;

	    case SDLK_PAGEDOWN:
	    	pc=curr;
		break;

	    case SDLK_LEFT:
	    	pc-=1024;
		break;

	    case SDLK_RIGHT:
	    	pc+=1024;
		break;

	    default:
	    	break;
	}
    }
}


static void DoDisassemFile(Z80 *z80, const Z80State *s)
{
    static char fname[FILENAME_MAX]="";
    FILE *fp;
    Z80Word start;
    Z80Word len;
    Z80Word prev;
    const char *p;

    EnterAddress("Disassemble from?",z80,&start);
    EnterAddress("For how many bytes?",z80,&len);

    p=GUIInputString("To file?",fname);

    if (!strlen(p))
    	return;

    strcpy(fname,p);

    if (!(fp=fopen(fname,"w")))
    {
    	GUIMessage(eMessageBox,"ERROR","Couldn't create file:\n%s",fname);
	return;
    }

    prev=len;

    while(len<=prev)
    {
    	Z80Word orig=start;

	fprintf(fp,"%4.4x: %s\n",orig,Z80Disassemble(z80,&start));
	prev=len;
	len-=(start-orig);
    }

    fclose(fp);
}


static void GetMemTrace(Z80 *z80, MemTrace *t, Z80Word from, int count)
{
    int f;

    f=0;

    while(f<count)
    {
	Z80Word w;

	w=(Z80Word)SPECDisPeek(z80,from)|
	  (Z80Word)SPECDisPeek(z80,from+1)<<8;

	t[f].addr=from;
	t[f].val=w;

    	from+=2;
	f++;
    }
}


static int Instruction(Z80 *z80, Z80Val data)
{
    int f;

    if (trace)
    {
	Trace t;

	Z80GetState(z80,&t.s);

	GetMemTrace(z80,t.hl,t.s.HL-(TRACEMEM_WIN/2+1),TRACEMEM_WIN);
	GetMemTrace(z80,t.de,t.s.DE-(TRACEMEM_WIN/2+1),TRACEMEM_WIN);
	GetMemTrace(z80,t.sp,t.s.SP-(TRACEMEM_WIN/2+1),TRACEMEM_WIN);

	fwrite(&t,sizeof t,1,trace);
    }

    for(f=0;f<bpoint.no;f++)
	if (bpoint.active[f])
	{
	    long l;

	    if (ExprEval(bpoint.expr[f],&l,Expand,z80))
	    {
		if (l)
		    brk=bpoint.expr[f];
	    }
	}

    return TRUE;
}


static void EnableTrace(Z80 *z80, Z80State *s)
{
    if (!trace)
    {
    	trace=fopen(TRACE,"wb");

	if (trace)
	{
	    GUIMessage(eMessageBox,"NOTICE","Created trace log");
	    SetCallback(z80);
	}
	else
	{
	    GUIMessage(eMessageBox,"ERROR","Failed to create trace log");
	}
    }
}


static void DisableTrace(Z80 *z80)
{
    if (trace)
    {
	GUIMessage(eMessageBox,"NOTICE","Closing current trace log");
    	fclose(trace);
	trace=NULL;
	ClearCallback(z80);
    }
}


static void DisplayTraceMem(int x, int y, const char *name,
			    MemTrace *m, Z80Word expect)
{
    int f;

    GFXPrint(x,y,GREEN,"%s",name);

    for(f=0;f<TRACEMEM_WIN;f++)
    {
	Uint32 paper;

	if (m[f].addr==expect)
	    paper=RED;
	else
	    paper=BLACK;

    	GFXPrintPaper(x,y+f*8+12,GREEN,paper,"%4.4x",m[f].addr);
    	GFXPrintPaper(x+32,y+f*8+12,WHITE,paper," %4.4x",m[f].val);
    }
}

static void PlaybackTrace(Z80 *z80)
{
    FILE *fp;
    int quit;
    long prev_pos;
    long pos;
    long max_pos;
    Z80Word pc;
    Trace t;

    fp=fopen(TRACE,"rb");

    if (!fp)
    {
	GUIMessage(eMessageBox,"ERROR","Couldn't open trace file");
	return;
    }

    fseek(fp,0,SEEK_END);

    max_pos=ftell(fp)/sizeof t;

    if (max_pos==0)
    {
	GUIMessage(eMessageBox,"ERROR","Empty trace file");
	fclose(fp);
	return;
    }

    pos=0;
    prev_pos=pos;
    pc=0;
    quit=FALSE;

    while(!quit)
    {
	SDL_Event *e;
	size_t rd;
	int f;

	GFXClear(BLACK);

    	Centre("TRACE PLAYBACK",0,WHITE);
    	Centre("Press F1 for help",9,RED);

	fseek(fp,pos*sizeof t,SEEK_SET);
	fread(&t,sizeof t,1,fp);

	DisplayZ80State(&t.s,136,WHITE);

	DisplayTraceMem(0,192,"MEM (SP)",t.sp,t.s.SP);
	DisplayTraceMem(100,192,"MEM (HL)",t.hl,t.s.HL);
	DisplayTraceMem(200,192,"MEM (DE)",t.de,t.s.DE);

	for(f=0;f<10;f++)
	{
	    char str[80];
	    char *p;
	    int paper;
	    int y;

	    y=24+f*8;

	    if (f==0)
		paper=RED;
	    else
		paper=BLACK;

	    GFXPrintPaper(0,y,GREEN,paper,"%4.4x ",t.s.PC);

	    strcpy(str,Z80Disassemble(z80,&t.s.PC));
	    p=strtok(str,";");
	    GFXPrintPaper(40,y,WHITE,paper,"%s",str);
	}

	GFXPrint(0,112,GREEN,"Current step: %ld",pos+1);
	GFXPrint(0,120,GREEN,"Total steps : %ld",max_pos);

	prev_pos=pos;

	GFXEndFrame(FALSE);

	e=GFXWaitKey();

	switch(e->key.keysym.sym)
	{
	    case SDLK_F1:
		GUIMessage
		    (eMessageBox,"PLAYBACK HELP","%s",
		       "ESC       - Exit                     \n"
		       "Enter     - Step number              \n"
		       "P         - Search for PC            \n"
		       "Up        - Prev step                \n"
		       "Down      - Next step                \n"
		       "Page Up   - Back 50 steps            \n"
		       "Page Down - Forward 50 steps         \n"
		       "Left      - Back 1000 steps          \n"
		       "Right     - Forward 1000 steps       \n \n"
		       "NOTE: Disassembly is as memory is NOW");
		break;

	    case SDLK_ESCAPE:
	    	quit=TRUE;
		break;

	    case SDLK_RETURN:
	    case SDLK_KP_ENTER:
		EnterLong("Step number?",&pos);
		pos--;
		break;

	    case SDLK_p:
		if (EnterAddress("PC to search for?",z80,&pc))
		{
		    while((rd=fread(&t,sizeof t,1,fp))==1)
		    {
			pos++;
			if (t.s.PC==pc)
			    break;
		    }

		    if (rd!=1)
		    {
		    	GUIMessage(eMessageBox,"NOTICE","Address not found");
			pos=prev_pos;
		    }
		}
	    	break;

	    case SDLK_UP:
		pos--;
	    	break;

	    case SDLK_DOWN:
		pos++;
	    	break;

	    case SDLK_PAGEUP:
		pos-=50;
		break;

	    case SDLK_PAGEDOWN:
	    	pos+=50;
		break;

	    case SDLK_LEFT:
	    	pos-=1000;
		break;

	    case SDLK_RIGHT:
	    	pos+=1000;
		break;

	    default:
	    	break;
	}

	/* Check position before next loop
	*/
	if (pos<0)
	    pos=0;

	if (pos>=max_pos)
	    pos=max_pos-1;
    }

    fclose(fp);
}


static int DoAddBreakpoint(Z80 *z80)
{
    const char *expr;
    long l;

    expr=GUIInputString("Expression?","");

    if (!*expr)
    	return -1;

    if (ExprEval(expr,&l,Expand,z80))
    {
	return AddBreak(z80,expr);
    }
    else
    {
	GUIMessage(eMessageBox,"INVALID EXPRESSION","%s",ExprError());
	return -1;
    }
}


static void DoActiveBreakpoint(Z80 *z80)
{
    if (bpoint.no==0)
    {
	GUIMessage(eMessageBox,"NOTICE","No breakpoints to set");
	return;
    }

    GFXClear(BLACK);

    GUIListOption("SELECT ACTIVE BREAKPOINTS",
		  bpoint.no,bpoint.expr,bpoint.active);
}


static void DoRemoveBreakpoint(Z80 *z80)
{
    int sel;

    if (bpoint.no==0)
    {
	GUIMessage(eMessageBox,"NOTICE","No breakpoints to delete");
	return;
    }

    GFXClear(BLACK);

    sel=GUIListSelect("BREAKPOINT TO DELETE",bpoint.no,bpoint.expr);

    while (sel!=-1)
    {
	DeleteBreak(z80,sel);
	sel=GUIListSelect("BREAKPOINT TO DELETE",bpoint.no,bpoint.expr);
    }
}


static void DoClearBreakpoint(Z80 *z80)
{
    if (GUIMessage(eYesNoBox,"BREAKPOINTS","Clear all breakpoints"))
    {
	int f;

	for(f=0;f<bpoint.no;f++)
	    free(bpoint.expr[f]);

	free(bpoint.expr);
	bpoint.expr=NULL;
	bpoint.no=0;

	ClearCallback(z80);
    }
}


static void DoMonitor(Z80 *z80)
{
    static int overlay=FALSE;
    int quit=FALSE;
    int running=FALSE;
    int update=TRUE;
    int step=FALSE;
    int trigger=-1;
    int regdisp=0;

    SPECEnableScreen(FALSE);

    while(!quit)
    {
	MemTrace mt[TRACEMEM_WIN];
	const char *brk;
	SDL_Event *e;
	Z80State s;
	int f;

	step=FALSE;

	if (update)
	{
	    if (overlay)
		SPECShowScreen();
	    else
		GFXClear(BLACK);

	    CentrePaper("MONITOR",0,WHITE,BLACK);
	    CentrePaper("Press F1 for help",9,RED,BLACK);

	    Z80GetState(z80,&s);

	    DisplayZ80State(&s,136,WHITE);

	    GetMemTrace(z80,mt,s.SP-(TRACEMEM_WIN/2+1),TRACEMEM_WIN);
	    DisplayTraceMem(0,192,"MEM (SP)",mt,s.SP);
	    GetMemTrace(z80,mt,s.HL-(TRACEMEM_WIN/2+1),TRACEMEM_WIN);
	    DisplayTraceMem(100,192,"MEM (HL)",mt,s.HL);

	    switch(regdisp)
	    {
	    	case 0:
		    GetMemTrace(z80,mt,s.DE-(TRACEMEM_WIN/2+1),TRACEMEM_WIN);
		    DisplayTraceMem(200,192,"MEM (DE)",mt,s.DE);
		    break;
	    	case 1:
		    GetMemTrace(z80,mt,s.IX-(TRACEMEM_WIN/2+1),TRACEMEM_WIN);
		    DisplayTraceMem(200,192,"MEM (IX)",mt,s.IX);
		    break;
	    	case 2:
		    GetMemTrace(z80,mt,s.IY-(TRACEMEM_WIN/2+1),TRACEMEM_WIN);
		    DisplayTraceMem(200,192,"MEM (IY)",mt,s.IY);
		    break;
	    	case 3:
		    GetMemTrace(z80,mt,s.BC-(TRACEMEM_WIN/2+1),TRACEMEM_WIN);
		    DisplayTraceMem(200,192,"MEM (BC)",mt,s.BC);
		    break;
	    }

	    for(f=0;f<10;f++)
	    {
		char str[80];
		char *p;
		int paper;
		int y;

		y=24+f*8;

		if (f==0)
		    paper=RED;
		else
		    paper=BLACK;

		GFXPrintPaper(0,y,GREEN,paper,"%4.4x ",s.PC);

		strcpy(str,Z80Disassemble(z80,&s.PC));
		p=strtok(str,";");
		GFXPrintPaper(40,y,WHITE,paper,"%s",str);
	    }

	    GFXEndFrame(FALSE);
	}

	if (running)
	{
	    e=GFXGetKey();

	    if (e && e->key.state!=SDL_PRESSED)
	    	e=NULL;
	}
	else
	    e=GFXWaitKey();

	if (e)
	{
	    switch(e->key.keysym.sym)
	    {
		case SDLK_F1:
		    GUIMessage
			(eMessageBox,"PLAYBACK HELP","%s",
			   "ESC   - Exit                    \n"
			   "ENTER - Single step processor   \n"
			   "R     - Run till break or stop  \n"
			   "W     - Watch till break or stop\n"
			   "T     - Add temp breakpoint     \n"
			   "SPACE - Stop running            \n"
			   "O     - Toggle overlay mode     \n"
			   "5     - Add a new breakpoint    \n"
			   "6     - Set active breakpoints  \n"
			   "7     - Remove a breakpoint     \n"
			   "8     - Clear all breakpoints   \n"
			   "H     - Alter reg index display \n"
			   "S     - Display current screen  ");
		    break;

		case SDLK_RETURN:
		case SDLK_KP_ENTER:
		    step=TRUE;
		    break;

		case SDLK_ESCAPE:
		    quit=TRUE;
		    break;

		case SDLK_r:
		    running=TRUE;
		    update=FALSE;
		    GFXClear(BLACK);
		    CentrePaper("MONITOR",0,WHITE,BLACK);
		    CentrePaper("Press F1 for help",9,RED,BLACK);
		    CentrePaper("Running...",27,RED,BLACK);
		    GFXEndFrame(FALSE);
		    break;

		case SDLK_w:
		    running=TRUE;
		    break;

		case SDLK_SPACE:
		    running=FALSE;
		    update=TRUE;
		    break;

		case SDLK_o:
		    if (update)
		    {
			overlay=!overlay;
		    }
		    break;

		case SDLK_5:
		    DoAddBreakpoint(z80);
		    break;

		case SDLK_6:
		    DoActiveBreakpoint(z80);
		    break;

		case SDLK_7:
		    DoRemoveBreakpoint(z80);
		    break;

		case SDLK_8:
		    DoClearBreakpoint(z80);
		    break;

		case SDLK_s:
		    if (update)
		    {
			SPECShowScreen();
			GFXEndFrame(FALSE);
			GFXWaitKey();
		    }
		    break;

		case SDLK_h:
		    regdisp=(regdisp+1)%4;
		    break;

		case SDLK_t:
		    if (trigger!=-1)
		    {
		    	DeleteBreak(z80,trigger);
			trigger=-1;
		    }

		    trigger=DoAddBreakpoint(z80);
		    break;

		default:
		    break;
	    }
	}

	if (running || step)
	    Z80SingleStep(z80);

	if (running && (brk=Break()))
	{
	    GUIMessage(eMessageBox,"BREAKPOINT","%s",brk);
	    running=FALSE;
	    update=TRUE;

	    if (trigger!=-1)
	    {
	    	DeleteBreak(z80,trigger);
		trigger=-1;
	    }
	}
    }

    if (trigger!=-1)
    {
	DeleteBreak(z80,trigger);
    }

    SPECEnableScreen(TRUE);
}


/* ---------------------------------------- EXPORTED INTERFACES
*/
int MemoryMenu(Z80 *z80)
{
    SDL_Event *e;
    int done=FALSE;
    int quit=FALSE;
    Z80State s;

    Z80GetState(z80,&s);

    while(!done)
    {
	DisplayMenu();
	DisplayZ80State(&s,GFX_HEIGHT-70,RED);
	GFXEndFrame(FALSE);

	e=GFXWaitKey();

	switch(e->key.keysym.sym)
	{
	    case SDLK_1:
	    	DoDisassem(z80,&s);
		break;

	    case SDLK_2:
	    	DoDisassemFile(z80,&s);
	    	break;

	    case SDLK_3:
		if (!trace)
		    EnableTrace(z80,&s);
		else
		    DisableTrace(z80);
	    	break;

	    case SDLK_4:
		DisableTrace(z80);
	    	PlaybackTrace(z80);
		break;

	    case SDLK_5:
		DoAddBreakpoint(z80);
	    	break;

	    case SDLK_6:
		DoActiveBreakpoint(z80);
	    	break;

	    case SDLK_7:
		DoRemoveBreakpoint(z80);
	    	break;

	    case SDLK_8:
		DoClearBreakpoint(z80);
	    	break;

	    case SDLK_9:
		DoMonitor(z80);
	    	break;

	    case SDLK_r:
	    	if (GUIMessage(eYesNoBox,"RESET","Sure?"))
		{
		    Z80Reset(z80);
		    SPECReset(z80);
		}
		break;

	    case SDLK_x:
	    	done=TRUE;
	    	quit=TRUE;
		break;

	    case SDLK_ESCAPE:
	    	done=TRUE;
		break;

	    default:
	    	break;
	}
    }

    return quit;
}


void DisplayState(Z80 *z80)
{
    Z80State s;

    Z80GetState(z80,&s);
    DisplayZ80State(&s,GFX_HEIGHT/2,RED);
}


const char *Break(void)
{
    const char *ret;

    ret=brk;
    brk=NULL;

    return ret;
}


/* END OF FILE */