/*
	bp.c
	Breakpoint handling

	bp  NUMBER set ADDRESS		set break at address
	bp  NUMBER rem
	bp  NUMBER dis			disable break
	bp  NUMBER en			enable break
	bp  clear			clear all bp:s
	bp				show bp:s
	
*/

#include	"defs.h"
#define	BPOPCODE		0xBE00		// BKPT #0

typedef struct bp_entry{
	unsigned short * address;
	unsigned short opcode;	/* 16 bits of opcode */
	char	active;
}BP_ENTRY;

static struct bp_entry bp_tab[MAXBP];

/* peek/poke are used to insert and remove BP opcodes */
#define peek( x ) *((unsigned short *)(x))	
#define poke( x , y) (*((unsigned short *)(x))	= y)

void	atbreak()
{
	smallprintf( "\nBREAKPOINT:\n%X ",alregs.pc);
	Instruction( alregs.pc, 1 );
}

void inibp( void )	/* called from "init" */
{
static int	valbp;	/* "magic" flag, for reset clear of BP-tab */
int i;
	if(valbp==0x7322) return;	/* bp_table already cleared */
	for(i=0;i<MAXBP;i++){
		bp_tab[i].address = 0;
		bp_tab[i].opcode = 0;
		bp_tab[i].active = 0;
	}
	valbp=0x7322;
}

int isbreak( unsigned short * address )
{	/* returns 1 if "address" holds an active breakpoint, 0 otherwise */
int i;
	for(i=0;i<MAXBP;i++){
	  if( bp_tab[i].address == address){
		/* breakpoint exists */
		if(bp_tab[i].active)
			return 1;
		else
			return 0;	/* it's there but Inactive */
	  }
	}
	return 0;
}

void enbreak( unsigned short *  address )
{	/* enables actives breaks by writing them into code skips 'address' */
int i;
	for(i=0;i<MAXBP;i++){
	  if( (bp_tab[i].address != 0L)&&(bp_tab[i].address!= address) ){
		if(bp_tab[i].active){
		 //bp_tab[i].opcode = (unsigned short) ( bp_tab[i].address );
		 bp_tab[i].opcode =  peek( bp_tab[i].address );
		 poke( bp_tab[i].address ,(unsigned short) BPOPCODE );
		}
	  }
	}
}

void disbreak( void )
{	/* disables breaks by removing them from code */
int i;
unsigned int code;
	for(i=0;i<MAXBP;i++){
	  if( bp_tab[i].address != 0L){
		/* make sure breakpoint resides in code before subst. */
		 code =  peek( bp_tab[i].address );
		 if( code == BPOPCODE )
		 	poke( bp_tab[i].address ,bp_tab[i].opcode );		 
	  }
	}
}

int	setbp( unsigned short * address , int new)

{
int	i;
	if( address == 0L){
		smallprintf("Can't set break at address 0"); return -1;
	}
	if( new == -1 )
	{
		// a temporary break
		for(i=0;i<MAXBP;i++){
	  		if( bp_tab[i].address == 0L){
				(void) setbp( address, i );
				return i;
			}
		}
		return -1;
	}

  	/* set a breakpoint 
	 * check for duplicates
	 */
	for(i=0;i<MAXBP;i++){
	  if( bp_tab[i].address == address){
		/* breakpoint already exists */
		 bp_tab[i].opcode = (unsigned char) peek(  bp_tab[i].address );
		smallprintf("\nBreakpoint exist (%d), table updated",(short)i);
		return -1;
	  }
	}
	bp_tab[new].address = address;
	bp_tab[new].opcode = peek( address );
	bp_tab[new].active = 1;	/* by default */
	return new;
}



void rembp( int new )
{
  	/* remove one breakpoint restore opcode if it's valid */
	if( bp_tab[new].address != 0L){
		if( peek( bp_tab[new].address ) == BPOPCODE )
		{
			poke( bp_tab[new].address , (bp_tab[new].opcode) );	
		}
		bp_tab[new].address = 0; 
		bp_tab[new].opcode = 0;
		bp_tab[new].active = 0;
		return;
	}
	smallprintf("\nNo breakpoint to remove");
}

static void clearbp(void)
{
int	i;
  	/* clear all breakpoints */
	for(i=0;i<MAXBP;i++){
	  if( bp_tab[i].address != 0L){
		/* if valid break, remove from code */
		if( peek( bp_tab[i].address ) == BPOPCODE )
		{
			poke( bp_tab[i].address , ( bp_tab[i].opcode) );	
		}

		bp_tab[i].address = 0L;
		bp_tab[i].opcode = 0;
		bp_tab[i].active = 0;
	  }
	}
}

static void	showbreak(void)
{
int	i;
  	/* Print out breakpoint table */
	smallprintf("\n    BREAKPOINT TABLE:");
	smallprintf("\n    NO: ADDRESS  STATUS");
	for(i=0;i<MAXBP;i++){
	  smallprintf("\n    %d",i);
	  if(i<10) smallprintf("   ");
	  else smallprintf("  ");

	  if( bp_tab[i].address != 0L){
		smallprintf("%X    ",bp_tab[i].address );
		if( bp_tab[i].active)
			smallprintf(" (Active)");
		else
			smallprintf(" (InActive)");
	  }
	  else
		smallprintf("         (Not Used)");
	}
}

void	breaks( int argc , char **argv )
{
unsigned short * address;
int number, page;
	if( argc == 1 ){
		showbreak(); 
		return;
	}
 	if( argc == 2 ){
		if ( !strcmpi("clear",argv[1]) ){
			clearbp();
			return;
		}
		help_bp();
		return;
	}
	if( argc == 3 ){  /* bp NUMBER rem/dis/en */
	  (void) strtoint( argv[1] , 10 ,1, &number,&page);
	  if ( !strcmpi("rem",argv[2]) ){ 
		rembp(number);
		return;
	  }
	  else if ( !strcmpi("dis",argv[2]) ){
		if( bp_tab[number].address != 0L){
			bp_tab[number].active=0;
		}
		else{
			smallprintf("\nInvalid breakpoint (can't disable)");
		}
	  }
	  else if ( !strcmpi("en",argv[2]) ){
		if( bp_tab[number].address != 0L){
			bp_tab[number].active=1;
		}
		else{
			smallprintf("\nInvalid breakpoint (can't enable)");
		}
	  }
	  else{
		(void) help_bp();
		return;
	  }
	  return;

	}
	if( argc==4){ /* bp NUMBER set ADDRESS */
	  (void) strtoint( argv[1] , 10 ,1 ,&number,&page);
	  if ( !strcmpi("set",argv[2]) ){
	  	(void) strtoint( argv[3] , 16 ,1, (int *) &address, &page);
		// check for valid address range (TODO)
		
		
		
		(void) setbp(address,number);
		return;
	  }
	  else{
		(void) help_bp();
		return;
	  }
	}
}