/*************************************************************************
**
** o5_Memory.c
** Copyright (c) 1995,1996 Daniel Kahlin <tlr@stacken.kth.se>
**
** Commands: WRITEMEM, READMEM, SYS, RUN, RESET
**
** NOT MACHINE DEPENDENT
**
******/

#include <dos.h>
#include <stdio.h>
#include <stdlib.h>
#include <error.h>
#include <string.h>

#include "Main_rev.h"

#include "Block.h"
#include "Protocol.h"
#include "Main.h"
#include "Convert.h"

#include "mach.h"

#define WM_TEMPLATE "FROM/A,NEWADDR,RUN/S,RESET/S,DEBUG/S"

struct wm_args {
	UBYTE *as_from;
	UBYTE *as_newaddr;
	ULONG	as_run;
	ULONG	as_reset;
	ULONG	as_debug;
};

#define RM_TEMPLATE "START/A,END/A,TO/A,RESET/S,DEBUG/S"

struct rm_args {
	UBYTE	*as_start;
	UBYTE	*as_end;
	UBYTE *as_to;
	ULONG	as_reset;
	ULONG	as_debug;
};

#define SY_TEMPLATE "PC/A,MEMORY,SR,AC,XR,YR,SP,RESET/S,DEBUG/S"

struct sy_args {
	UBYTE	*as_pc;
	UBYTE	*as_memory;
	UBYTE	*as_sr;
	UBYTE	*as_ac;
	UBYTE	*as_xr;
	UBYTE	*as_yr;
	UBYTE	*as_sp;
	ULONG	as_reset;
	ULONG	as_debug;
};

#define RU_TEMPLATE "DEBUG/S"

struct ru_args {
	ULONG	as_debug;
};


#define RST_TEMPLATE "DEBUG/S"

struct rst_args {
	ULONG	as_debug;
};

struct rm_args rm_argarray;
struct wm_args wm_argarray;
struct sy_args sy_argarray;
struct ru_args ru_argarray;
struct rst_args rst_argarray;

/*************************************************************************
**
** WRITEMEM
**
******/
void o5_WriteMem(char *myparams)
{
	UBYTE *filename=NULL;
	UBYTE *inbuffer=NULL;
	ULONG len=NULL;
	LONG	newaddr,addr,endaddr,blocks;

	if (!(mach_rdargs(WM_TEMPLATE,(LONG *)&wm_argarray,myparams)))
		panic("error in args");

	if (wm_argarray.as_debug)
		debug=DBG_FULL;

	filename=wm_argarray.as_from;

	inbuffer=LoadFile(filename);
	len=jsize(inbuffer);
	addr=(*inbuffer)+(*(inbuffer+1)<<8);
	if (wm_argarray.as_newaddr) {
		newaddr=makenum(wm_argarray.as_newaddr,0x0000,0xffff,16);
		if (newaddr==-1)
			panic("illegal NEWADDR");
		addr=newaddr;
	}
	endaddr=addr+len-2;

	blocks=((len+253)/254);
	printf("Writing $%04x-$%04x (%d bytes, %d blocks)\n",addr,endaddr,len-2,blocks);

	if (wm_argarray.as_reset)
		doreset();
	bl_sendmem(inbuffer+2,addr,len-2);

	if (wm_argarray.as_run) {
		bl_run(addr,endaddr);
		puts("RUN");
	}
}





/*************************************************************************
**
** READMEM
**
******/
void o5_ReadMem(char *myparams)
{
	UBYTE *filename=NULL;
	UBYTE *inbuffer=NULL;
	ULONG len=NULL;
	LONG	start,end,blocks;

	if (!(mach_rdargs(RM_TEMPLATE,(LONG *)&rm_argarray,myparams)))
		panic("error in args");

	if (rm_argarray.as_debug)
		debug=DBG_FULL;

	start=makenum(rm_argarray.as_start,0x0000,0xffff,16);
	if (start==-1)
		panic("illegal START");
	end=makenum(rm_argarray.as_end,0x0000,0xffff,16);
	if (end==-1)
		panic("illegal END");
	filename=rm_argarray.as_to;

	len=end-start;
	if (end==0)
		len=0x10000-start;

	if (!(inbuffer=jalloc(len+2)))
		panic("no mem");


	blocks=(((len+2)+253)/254);
	printf("Reading $%04x-$%04x (%d bytes, %d blocks)\n",start,end,len,blocks);


	*inbuffer=start&0xff;
	*(inbuffer+1)=start>>8;
	if (rm_argarray.as_reset)
		doreset();
	bl_recvmem(inbuffer+2,start,len);
	SaveFile(filename,inbuffer,len+2);
}



/*************************************************************************
**
** SYS
**
******/
void o5_Sys(char *myparams)
{
	LONG	pc;
	LONG memory=0x37,sr=0x00,ac=0x00,xr=0x00,yr=0x00,sp=0xff;

	if (!(mach_rdargs(SY_TEMPLATE,(LONG *)&sy_argarray,myparams)))
		panic("error in args");

	if (sy_argarray.as_debug)
		debug=DBG_FULL;

	pc=makenum(sy_argarray.as_pc,0x0000,0xffff,16);
	if (pc==-1)
		panic("illegal PC");

	if (sy_argarray.as_memory) {
		memory=makenum(sy_argarray.as_memory,0x00,0xff,16);
		if (memory==-1)
			panic("illegal MEMORY");
	}
	if (sy_argarray.as_sr) {
		sr=makenum(sy_argarray.as_sr,0x00,0xff,16);
		if (sr==-1)
			panic("illegal SR");
	}
	if (sy_argarray.as_ac) {
		ac=makenum(sy_argarray.as_ac,0x00,0xff,16);
		if (ac==-1)
			panic("illegal AC");
	}
	if (sy_argarray.as_xr) {
		xr=makenum(sy_argarray.as_xr,0x00,0xff,16);
		if (xr==-1)
			panic("illegal XR");
	}
	if (sy_argarray.as_yr) {
		yr=makenum(sy_argarray.as_yr,0x00,0xff,16);
		if (yr==-1)
			panic("illegal YR");
	}
	if (sy_argarray.as_sp) {
		sp=makenum(sy_argarray.as_sp,0x00,0xff,16);
		if (sp==-1)
			panic("illegal SP");
	}

	if (sy_argarray.as_reset)
		doreset();
	bl_sys(pc,memory,sr,ac,xr,yr,sp);
	printf(" PC  01 SR AC XR YR SP\n");
	printf("%04x %02x %02x %02x %02x %02x %02x\n",pc,memory,sr,ac,xr,yr,sp);
	printf("AWAY!!!\n");
}


/*************************************************************************
**
** RUN
**
******/
void o5_Run(char *myparams)
{
	if (!(mach_rdargs(RU_TEMPLATE,(LONG *)&ru_argarray,myparams)))
		panic("error in args");

	if (ru_argarray.as_debug)
		debug=DBG_FULL;

	panic("not yet implemented");
}


/*************************************************************************
**
** RESET
**
******/
void o5_Reset(char *myparams)
{
	if (!(mach_rdargs(RST_TEMPLATE,(LONG *)&rst_argarray,myparams)))
		panic("error in args");

	if (rst_argarray.as_debug)
		debug=DBG_FULL;

	doreset();
	printf("reset sent!\n");
}