[picodrive.git] / pico / patch.c

/* Decode a Game Genie code into an M68000 address/data pair.
 * The Game Genie code is made of the characters
 * ABCDEFGHJKLMNPRSTVWXYZ0123456789 (notice the missing I, O, Q and U).
 * Where A = 00000, B = 00001, C = 00010, ... , on to 9 = 11111.
 *
 * These come out to a very scrambled bit pattern like this:
 * (SCRA-MBLE is just an example)
 *
 *   S     C     R     A  -  M     B     L     E
 * 01111 00010 01110 00000 01011 00001 01010 00100
 * ijklm nopIJ KLMNO PABCD EFGHd efgha bcQRS TUVWX
 *
 * Our goal is to rearrange that to this:
 *
 * 0000 0101 1001 1100 0100 0100 : 1011 0000 0111 1000
 * ABCD EFGH IJKL MNOP QRST UVWX : abcd efgh ijkl mnop
 *
 * which in Hexadecimal is 059C44:B078. Simple, huh? ;)
 *
 * So, then, we dutifully change memory location 059C44 to B078!
 * (of course, that's handled by a different source file :)
 */

#include "pico_int.h"
#include "patch.h"

struct patch
{
	unsigned int addr;
	unsigned short data;
	unsigned char comp;
};

struct patch_inst *PicoPatches = NULL;
int PicoPatchCount = 0;

static char genie_chars_md[] = "AaBbCcDdEeFfGgHhJjKkLlMmNnPpRrSsTtVvWwXxYyZz0O1I2233445566778899";

/* genie_decode
 * This function converts a Game Genie code to an address:data pair.
 * The code is given as an 8-character string, like "BJX0SA1C". It need not
 * be null terminated, since only the first 8 characters are taken. It is
 * assumed that the code is already made of valid characters, i.e. there are no
 * Q's, U's, or symbols. If such a character is
 * encountered, the function will return with a warning on stderr.
 *
 * The resulting address:data pair is returned in the struct patch pointed to
 * by result. If an error results, both the address and data will be set to -1.
 */

static void genie_decode_md(const char* code, struct patch* result)
{
  int i = 0, n;
  char* x;

  for(; i < 9; ++i)
  {
    /* Skip i=4; it's going to be the separating hyphen */
    if (i==4) continue;

    /* If strchr returns NULL, we were given a bad character */
    if(!(x = strchr(genie_chars_md, code[i])))
    {
      result->addr = -1; result->data = -1;
      return;
    }
    n = (x - genie_chars_md) >> 1;
    /* Now, based on which character this is, fit it into the result */
    switch(i)
    {
    case 0:
      /* ____ ____ ____ ____ ____ ____ : ____ ____ ABCD E___ */
      result->data |= n << 3;
      break;
    case 1:
      /* ____ ____ DE__ ____ ____ ____ : ____ ____ ____ _ABC */
      result->data |= n >> 2;
      result->addr |= (n & 3) << 14;
      break;
    case 2:
      /* ____ ____ __AB CDE_ ____ ____ : ____ ____ ____ ____ */
      result->addr |= n << 9;
      break;
    case 3:
      /* BCDE ____ ____ ___A ____ ____ : ____ ____ ____ ____ */
      result->addr |= (n & 0xF) << 20 | (n >> 4) << 8;
      break;
    case 5:
      /* ____ ABCD ____ ____ ____ ____ : ___E ____ ____ ____ */
      result->data |= (n & 1) << 12;
      result->addr |= (n >> 1) << 16;
      break;
    case 6:
      /* ____ ____ ____ ____ ____ ____ : E___ ABCD ____ ____ */
      result->data |= (n & 1) << 15 | (n >> 1) << 8;
      break;
    case 7:
      /* ____ ____ ____ ____ CDE_ ____ : _AB_ ____ ____ ____ */
      result->data |= (n >> 3) << 13;
      result->addr |= (n & 7) << 5;
      break;
    case 8:
      /* ____ ____ ____ ____ ___A BCDE : ____ ____ ____ ____ */
      result->addr |= n;
      break;
    }
    /* Go around again */
  }
  return;
}

/* "Decode" an address/data pair into a structure. This is for "012345:ABCD"
 * type codes. You're more likely to find Genie codes circulating around, but
 * there's a chance you could come on to one of these. Which is nice, since
 * they're MUCH easier to implement ;) Once again, the input should be depunc-
 * tuated already. */

static char hex_chars[] = "00112233445566778899AaBbCcDdEeFf";

static void hex_decode_md(const char *code, struct patch *result)
{
  char *x;
  int i;
  /* 6 digits for address */
  for(i = 0; i < 6; ++i)
  {
    if(!(x = strchr(hex_chars, code[i])))
    {
      result->addr = result->data = -1;
      return;
    }
    result->addr = (result->addr << 4) | ((x - hex_chars) >> 1);
  }
  /* 4 digits for data */
  for(i = 7; i < 11; ++i)
  {
    if(!(x = strchr(hex_chars, code[i])))
    {
      if (i==8) break;
      result->addr = result->data = -1;
      return;
    }
    result->data = (result->data << 4) | ((x - hex_chars) >> 1);
  }
}

void genie_decode_ms(const char *code, struct patch *result)
{
  char *x;
  int i;
  /* 2 digits for data */
  for(i=0;i<2;++i)
  {
    if(!(x = strchr(hex_chars, code[i])))
    {
      result->addr = result->data = -1;
      return;
    }
    result->data = (result->data << 4) | ((x - hex_chars) >> 1);
  }
  /* 4 digits for address */
  for(i=2;i<7;++i)
  {
    /* 4th character is hyphen and can be skipped*/
    if (i==3) continue;
    if(!(x = strchr(hex_chars, code[i])))
    {
      result->addr = result->data = -1;
      return;
    }
    result->addr = (result->addr << 4) | ((x - hex_chars) >> 1);
  }
  /* Correct the address */
  result->addr = ((result->addr >> 4) | (result->addr << 12 & 0xF000)) ^ 0xF000;
  /* Optional: 3 digits for comp */
  if (code[8]){
    for(i=8;i<11;++i)
    {
      if (i==9) continue; /* 2nd character is ignored */
      if(!(x = strchr(hex_chars, code[i])))
      {
	result->addr = result->data = -1;
	return;
      }
      result->comp = (result->comp << 4) | ((x - hex_chars) >> 1);
    }
    /* Correct the comp */
    result->comp = ((result->comp >> 2) | ((result->comp << 6) & 0xC0)) ^ 0xBA;
  }
}

void ar_decode_ms(const char *code, struct patch *result){
  char *x;
  int i;
  /* 2 digits of padding*/
  /* 4 digits for address */
  for(i=2;i<7;++i)
  {
    /* 5th character is hyphen and can be skipped*/
    if (i==4) continue;
    if(!(x = strchr(hex_chars, code[i])))
    {
      result->addr = result->data = -1;
      return;
    }
    result->addr = (result->addr << 4) | ((x - hex_chars) >> 1);
  }
  /* 2 digits for data */
  for(i=7;i<9;++i)
  {
    if(!(x = strchr(hex_chars, code[i])))
    {
      result->addr = result->data = -1;
      return;
    }
    result->data = (result->data << 4) | ((x - hex_chars) >> 1);
  }
}

void fusion_ram_decode(const char *code, struct patch *result){
  char *x;
  int i;
  /* 4 digits for address */
  for(i=0;i<4;++i)
  {
    if(!(x = strchr(hex_chars, code[i])))
    {
      result->addr = result->data = -1;
      return;
    }
    result->addr = (result->addr << 4) | ((x - hex_chars) >> 1);
  }
  /* Skip the ':' */
  /* 2 digits for data */
  for(i=5;i<7;++i)
  {
    if(!(x = strchr(hex_chars, code[i])))
    {
      result->addr = result->data = -1;
      return;
    }
    result->data = (result->data << 4) | ((x - hex_chars) >> 1);
  }
}

void fusion_rom_decode(const char *code, struct patch *result){
  char *x;
  int i;
  /* 2 digits for comp */
  for(i=0;i<2;++i)
  {
    if(!(x = strchr(hex_chars, code[i])))
    {
      result->addr = result->data = -1;
      return;
    }
    result->comp = (result->comp << 4) | ((x - hex_chars) >> 1);
  }
  /* 4 digits for address */
  for(i=2;i<6;++i)
  {
    if(!(x = strchr(hex_chars, code[i])))
    {
      result->addr = result->data = -1;
      return;
    }
    result->addr = (result->addr << 4) | ((x - hex_chars) >> 1);
  }
  /* 2 digits for data */
  for(i=7;i<9;++i)
  {
    if(!(x = strchr(hex_chars, code[i])))
    {
      result->addr = result->data = -1;
      return;
    }
    result->data = (result->data << 4) | ((x - hex_chars) >> 1);
  }
}

/* THIS is the function you call from the MegaDrive or whatever. This figures
 * out whether it's a genie or hex code, depunctuates it, and calls the proper
 * decoder. */
void decode(const char* code, struct patch* result)
{
  int len = strlen(code);

  /* Initialize the result */
  result->addr = result->data = result->comp = 0;

  if(!(PicoAHW & PAHW_SMS))
  {
    //If Genesis

    //Game Genie
    if(len == 9 && code[4] == '-')
    {
      genie_decode_md(code, result);
      return;
    }

    //Master
    else if(len >=9 && code[6] == ':')
    {
      hex_decode_md(code, result);
    }

    else
    {
      goto bad_code;
    }
  } else {
    //If Master System

    //Genie
    if(len == 11 && code[3] == '-' && code[7] == '-')
    {
      genie_decode_ms(code, result);
    }

    //AR
    else if(len == 9 && code[4] == '-')
    {
      ar_decode_ms(code, result);
    }

    //Fusion RAM
    else if(len == 7 && code[4] == ':')
    {
      fusion_ram_decode(code, result);
    }

    //Fusion ROM
    else if(len == 9 && code[6] == ':')
    {
      fusion_rom_decode(code, result);
    }

    else
    {
      goto bad_code;
    }

    //Convert RAM address space to Genesis location.
    if (result->addr>=0xC000)
      result->addr= 0xFF0000 | (0x1FFF & result->addr);
  }

  return;

  bad_code:
  result->data = result->addr = -1;
  return;
}


unsigned int PicoRead16(unsigned int a);
void PicoWrite16(unsigned int a, unsigned short d);
extern unsigned short m68k_read16(unsigned int a);
extern void m68k_write16(unsigned int a, unsigned short d);
extern char PicoRead8_z80(unsigned short a);
extern void PicoWrite8_z80(unsigned short a, char d);

void PicoPatchUnload(void)
{
	if (PicoPatches != NULL)
	{
		free(PicoPatches);
		PicoPatches = NULL;
	}
	PicoPatchCount = 0;
}

int PicoPatchLoad(const char *fname)
{
	FILE *f;
	char buff[256];
	struct patch pt;
	int array_len = 0;

	PicoPatchUnload();

	f = fopen(fname, "r");
	if (f == NULL)
	{
		return -1;
	}

	while (fgets(buff, sizeof(buff), f))
	{
		int llen, clen;

		llen = strlen(buff);
		for (clen = 0; clen < llen; clen++)
			if (isspace_(buff[clen]))
				break;
		buff[clen] = 0;

		if (clen > 11 || clen < 8)
			continue;

		decode(buff, &pt);
		if (pt.addr == (unsigned int)-1 || pt.data == (unsigned short)-1)
			continue;

		/* code was good, add it */
		if (array_len < PicoPatchCount + 1)
		{
			void *ptr;
			array_len *= 2;
			array_len++;
			ptr = realloc(PicoPatches, array_len * sizeof(PicoPatches[0]));
			if (ptr == NULL) break;
			PicoPatches = ptr;
		}
		strcpy(PicoPatches[PicoPatchCount].code, buff);
		/* strip */
		for (clen++; clen < llen; clen++)
			if (!isspace_(buff[clen]))
				break;
		for (llen--; llen > 0; llen--)
			if (!isspace_(buff[llen]))
				break;
		buff[llen+1] = 0;
		strncpy(PicoPatches[PicoPatchCount].name, buff + clen, 51);
		PicoPatches[PicoPatchCount].name[51] = 0;
		PicoPatches[PicoPatchCount].active = 0;
		PicoPatches[PicoPatchCount].addr = pt.addr;
		PicoPatches[PicoPatchCount].data = pt.data;
		PicoPatches[PicoPatchCount].data_old = 0;
		PicoPatchCount++;
		// fprintf(stderr, "loaded patch #%i: %06x:%04x \"%s\"\n", PicoPatchCount-1, pt.addr, pt.data,
		//	PicoPatches[PicoPatchCount-1].name);
	}
	fclose(f);

	return 0;
}

/* to be called when the Rom is loaded and byteswapped */
void PicoPatchPrepare(void)
{
  int i;
  int addr;

  for (i = 0; i < PicoPatchCount; i++)
  {
    addr=PicoPatches[i].addr;
    addr &= ~1;
    if (addr < Pico.romsize)
      PicoPatches[i].data_old = *(unsigned short *)(Pico.rom + addr);
    else
    {
      if(!(PicoAHW & PAHW_SMS))
	PicoPatches[i].data_old = (unsigned short) m68k_read16(addr);
      else
	PicoPatches[i].data_old = (unsigned char) PicoRead8_z80(addr);
    }
    if (strstr(PicoPatches[i].name, "AUTO"))
      PicoPatches[i].active = 1;
  }
}

void PicoPatchApply(void)
{
  int i, u;
  unsigned int addr;

  for (i = 0; i < PicoPatchCount; i++)
  {
    addr = PicoPatches[i].addr;

    if (addr < Pico.romsize)
    {
      if (PicoPatches[i].active)
      {
	if (!(PicoAHW & PAHW_SMS))
	  *(unsigned short *)(Pico.rom + addr) = PicoPatches[i].data;
	else if (!PicoPatches[i].comp || PicoPatches[i].comp == *(char *)(Pico.rom + addr))
	  *(char *)(Pico.rom + addr) = (char) PicoPatches[i].data;
      }
      else
      {
	// if current addr is not patched by older patch, write back original val
	for (u = 0; u < i; u++)
	  if (PicoPatches[u].addr == addr) break;
	if (u == i)
	{
	  if (!(PicoAHW & PAHW_SMS))
	    *(unsigned short *)(Pico.rom + addr) = PicoPatches[i].data_old;
	  else
	    *(char *)(Pico.rom + addr) = (char) PicoPatches[i].data_old;
	}
      }
      // fprintf(stderr, "patched %i: %06x:%04x\n", PicoPatches[i].active, addr,
      //	*(unsigned short *)(Pico.rom + addr));
    }
    else
    {
      if (PicoPatches[i].active)
      {
	if (!(PicoAHW & PAHW_SMS))
	  m68k_write16(addr,PicoPatches[i].data);
	else
	  PicoWrite8_z80(addr,PicoPatches[i].data);
      }
      else
      {
	// if current addr is not patched by older patch, write back original val
	for (u = 0; u < i; u++)
	  if (PicoPatches[u].addr == addr) break;
	if (u == i)
	{
	  if (!(PicoAHW & PAHW_SMS))
	    m68k_write16(PicoPatches[i].addr,PicoPatches[i].data_old);
	  else
	    PicoWrite8_z80(PicoPatches[i].addr,PicoPatches[i].data_old);
	}
      }
    }
  }
}
Commit	Line	Data
b67ef287	1	/* Decode a Game Genie code into an M68000 address/data pair.
	2	* The Game Genie code is made of the characters
	3	* ABCDEFGHJKLMNPRSTVWXYZ0123456789 (notice the missing I, O, Q and U).
	4	* Where A = 00000, B = 00001, C = 00010, ... , on to 9 = 11111.
	5	*
	6	* These come out to a very scrambled bit pattern like this:
	7	* (SCRA-MBLE is just an example)
	8	*
	9	* S C R A - M B L E
	10	* 01111 00010 01110 00000 01011 00001 01010 00100
	11	* ijklm nopIJ KLMNO PABCD EFGHd efgha bcQRS TUVWX
	12	*
	13	* Our goal is to rearrange that to this:
	14	*
	15	* 0000 0101 1001 1100 0100 0100 : 1011 0000 0111 1000
	16	* ABCD EFGH IJKL MNOP QRST UVWX : abcd efgh ijkl mnop
	17	*
	18	* which in Hexadecimal is 059C44:B078. Simple, huh? ;)
	19	*
	20	* So, then, we dutifully change memory location 059C44 to B078!
	21	* (of course, that's handled by a different source file :)
	22	*/
	23
efcba75f	24	#include "pico_int.h"
efcba75f	25	#include "patch.h"
b67ef287	26
	27	struct patch
	28	{
	29	unsigned int addr;
	30	unsigned short data;
fa55ee51	31	unsigned char comp;
b67ef287	32	};
	33
	34	struct patch_inst *PicoPatches = NULL;
	35	int PicoPatchCount = 0;
	36
fa55ee51	37	static char genie_chars_md[] = "AaBbCcDdEeFfGgHhJjKkLlMmNnPpRrSsTtVvWwXxYyZz0O1I2233445566778899";
b67ef287	38
	39	/* genie_decode
	40	* This function converts a Game Genie code to an address:data pair.
	41	* The code is given as an 8-character string, like "BJX0SA1C". It need not
	42	* be null terminated, since only the first 8 characters are taken. It is
	43	* assumed that the code is already made of valid characters, i.e. there are no
	44	* Q's, U's, or symbols. If such a character is
	45	* encountered, the function will return with a warning on stderr.
	46	*
	47	* The resulting address:data pair is returned in the struct patch pointed to
	48	* by result. If an error results, both the address and data will be set to -1.
	49	*/
	50
fa55ee51	51	static void genie_decode_md(const char* code, struct patch* result)
b67ef287	52	{
	53	int i = 0, n;
	54	char* x;
	55
fa55ee51	56	for(; i < 9; ++i)
b67ef287	57	{
fa55ee51	58	/* Skip i=4; it's going to be the separating hyphen */
	59	if (i==4) continue;
	60
b67ef287	61	/* If strchr returns NULL, we were given a bad character */
fa55ee51	62	if(!(x = strchr(genie_chars_md, code[i])))
b67ef287	63	{
	64	result->addr = -1; result->data = -1;
	65	return;
	66	}
fa55ee51	67	n = (x - genie_chars_md) >> 1;
b67ef287	68	/* Now, based on which character this is, fit it into the result */
	69	switch(i)
	70	{
	71	case 0:
	72	/* ____ ____ ____ ____ ____ ____ : ____ ____ ABCD E___ */
	73	result->data \|= n << 3;
	74	break;
	75	case 1:
	76	/* ____ ____ DE__ ____ ____ ____ : ____ ____ ____ _ABC */
	77	result->data \|= n >> 2;
	78	result->addr \|= (n & 3) << 14;
	79	break;
	80	case 2:
	81	/* ____ ____ __AB CDE_ ____ ____ : ____ ____ ____ ____ */
	82	result->addr \|= n << 9;
	83	break;
	84	case 3:
	85	/* BCDE ____ ____ ___A ____ ____ : ____ ____ ____ ____ */
	86	result->addr \|= (n & 0xF) << 20 \| (n >> 4) << 8;
	87	break;
fa55ee51	88	case 5:
b67ef287	89	/* ____ ABCD ____ ____ ____ ____ : ___E ____ ____ ____ */
	90	result->data \|= (n & 1) << 12;
	91	result->addr \|= (n >> 1) << 16;
	92	break;
fa55ee51	93	case 6:
b67ef287	94	/* ____ ____ ____ ____ ____ ____ : E___ ABCD ____ ____ */
	95	result->data \|= (n & 1) << 15 \| (n >> 1) << 8;
	96	break;
fa55ee51	97	case 7:
b67ef287	98	/* ____ ____ ____ ____ CDE_ ____ : _AB_ ____ ____ ____ */
	99	result->data \|= (n >> 3) << 13;
	100	result->addr \|= (n & 7) << 5;
	101	break;
fa55ee51	102	case 8:
b67ef287	103	/* ____ ____ ____ ____ ___A BCDE : ____ ____ ____ ____ */
	104	result->addr \|= n;
	105	break;
	106	}
	107	/* Go around again */
	108	}
	109	return;
	110	}
	111
	112	/* "Decode" an address/data pair into a structure. This is for "012345:ABCD"
	113	* type codes. You're more likely to find Genie codes circulating around, but
	114	* there's a chance you could come on to one of these. Which is nice, since
	115	* they're MUCH easier to implement ;) Once again, the input should be depunc-
	116	* tuated already. */
	117
	118	static char hex_chars[] = "00112233445566778899AaBbCcDdEeFf";
	119
fa55ee51	120	static void hex_decode_md(const char code, struct patch result)
b67ef287	121	{
	122	char *x;
	123	int i;
	124	/* 6 digits for address */
	125	for(i = 0; i < 6; ++i)
fa55ee51	126	{
fa55ee51	127	if(!(x = strchr(hex_chars, code[i])))
b67ef287	128	{
fa55ee51	129	result->addr = result->data = -1;
fa55ee51	130	return;
b67ef287	131	}
fa55ee51	132	result->addr = (result->addr << 4) \| ((x - hex_chars) >> 1);
fa55ee51	133	}
b67ef287	134	/* 4 digits for data */
fa55ee51	135	for(i = 7; i < 11; ++i)
	136	{
	137	if(!(x = strchr(hex_chars, code[i])))
	138	{
	139	if (i==8) break;
	140	result->addr = result->data = -1;
	141	return;
	142	}
	143	result->data = (result->data << 4) \| ((x - hex_chars) >> 1);
	144	}
	145	}
	146
	147	void genie_decode_ms(const char code, struct patch result)
	148	{
	149	char *x;
	150	int i;
	151	/* 2 digits for data */
	152	for(i=0;i<2;++i)
	153	{
	154	if(!(x = strchr(hex_chars, code[i])))
	155	{
	156	result->addr = result->data = -1;
	157	return;
	158	}
	159	result->data = (result->data << 4) \| ((x - hex_chars) >> 1);
	160	}
	161	/* 4 digits for address */
	162	for(i=2;i<7;++i)
	163	{
	164	/* 4th character is hyphen and can be skipped*/
	165	if (i==3) continue;
	166	if(!(x = strchr(hex_chars, code[i])))
	167	{
	168	result->addr = result->data = -1;
	169	return;
	170	}
	171	result->addr = (result->addr << 4) \| ((x - hex_chars) >> 1);
	172	}
	173	/* Correct the address */
	174	result->addr = ((result->addr >> 4) \| (result->addr << 12 & 0xF000)) ^ 0xF000;
	175	/* Optional: 3 digits for comp */
	176	if (code[8]){
	177	for(i=8;i<11;++i)
b67ef287	178	{
fa55ee51	179	if (i==9) continue; /* 2nd character is ignored */
b67ef287	180	if(!(x = strchr(hex_chars, code[i])))
	181	{
	182	result->addr = result->data = -1;
	183	return;
	184	}
fa55ee51	185	result->comp = (result->comp << 4) \| ((x - hex_chars) >> 1);
	186	}
	187	/* Correct the comp */
	188	result->comp = ((result->comp >> 2) \| ((result->comp << 6) & 0xC0)) ^ 0xBA;
	189	}
	190	}
	191
	192	void ar_decode_ms(const char code, struct patch result){
	193	char *x;
	194	int i;
	195	/* 2 digits of padding*/
	196	/* 4 digits for address */
	197	for(i=2;i<7;++i)
	198	{
	199	/* 5th character is hyphen and can be skipped*/
	200	if (i==4) continue;
	201	if(!(x = strchr(hex_chars, code[i])))
	202	{
	203	result->addr = result->data = -1;
	204	return;
	205	}
	206	result->addr = (result->addr << 4) \| ((x - hex_chars) >> 1);
	207	}
	208	/* 2 digits for data */
	209	for(i=7;i<9;++i)
	210	{
	211	if(!(x = strchr(hex_chars, code[i])))
	212	{
	213	result->addr = result->data = -1;
	214	return;
	215	}
	216	result->data = (result->data << 4) \| ((x - hex_chars) >> 1);
	217	}
	218	}
	219
	220	void fusion_ram_decode(const char code, struct patch result){
	221	char *x;
	222	int i;
	223	/* 4 digits for address */
	224	for(i=0;i<4;++i)
	225	{
	226	if(!(x = strchr(hex_chars, code[i])))
	227	{
	228	result->addr = result->data = -1;
	229	return;
	230	}
	231	result->addr = (result->addr << 4) \| ((x - hex_chars) >> 1);
	232	}
	233	/* Skip the ':' */
	234	/* 2 digits for data */
	235	for(i=5;i<7;++i)
	236	{
	237	if(!(x = strchr(hex_chars, code[i])))
	238	{
	239	result->addr = result->data = -1;
	240	return;
	241	}
	242	result->data = (result->data << 4) \| ((x - hex_chars) >> 1);
	243	}
	244	}
	245
	246	void fusion_rom_decode(const char code, struct patch result){
	247	char *x;
	248	int i;
249	/* 2 digits for comp */
250	for(i=0;i<2;++i)
251	{
252	if(!(x = strchr(hex_chars, code[i])))
253	{
254	result->addr = result->data = -1;
255	return;
b67ef287	256	}
fa55ee51	257	result->comp = (result->comp << 4) \| ((x - hex_chars) >> 1);
	258	}
	259	/* 4 digits for address */
	260	for(i=2;i<6;++i)
	261	{
	262	if(!(x = strchr(hex_chars, code[i])))
	263	{
	264	result->addr = result->data = -1;
	265	return;
	266	}
	267	result->addr = (result->addr << 4) \| ((x - hex_chars) >> 1);
	268	}
	269	/* 2 digits for data */
	270	for(i=7;i<9;++i)
	271	{
	272	if(!(x = strchr(hex_chars, code[i])))
	273	{
	274	result->addr = result->data = -1;
	275	return;
	276	}
	277	result->data = (result->data << 4) \| ((x - hex_chars) >> 1);
	278	}
b67ef287	279	}
	280
	281	/* THIS is the function you call from the MegaDrive or whatever. This figures
	282	* out whether it's a genie or hex code, depunctuates it, and calls the proper
	283	* decoder. */
20563b60	284	void decode(const char* code, struct patch* result)
b67ef287	285	{
fa55ee51	286	int len = strlen(code);
b67ef287	287
b67ef287	288	/* Initialize the result */
fa55ee51	289	result->addr = result->data = result->comp = 0;
b67ef287	290
fa55ee51	291	if(!(PicoAHW & PAHW_SMS))
b67ef287	292	{
fa55ee51	293	//If Genesis
b67ef287	294
fa55ee51	295	//Game Genie
b67ef287	296	if(len == 9 && code[4] == '-')
b67ef287	297	{
fa55ee51	298	genie_decode_md(code, result);
b67ef287	299	return;
	300	}
	301
fa55ee51	302	//Master
	303	else if(len >=9 && code[6] == ':')
	304	{
	305	hex_decode_md(code, result);
	306	}
	307
	308	else
	309	{
	310	goto bad_code;
	311	}
	312	} else {
	313	//If Master System
b67ef287	314
fa55ee51	315	//Genie
	316	if(len == 11 && code[3] == '-' && code[7] == '-')
	317	{
	318	genie_decode_ms(code, result);
	319	}
b67ef287	320
fa55ee51	321	//AR
	322	else if(len == 9 && code[4] == '-')
	323	{
	324	ar_decode_ms(code, result);
	325	}
b67ef287	326
fa55ee51	327	//Fusion RAM
	328	else if(len == 7 && code[4] == ':')
	329	{
	330	fusion_ram_decode(code, result);
	331	}
b67ef287	332
fa55ee51	333	//Fusion ROM
	334	else if(len == 9 && code[6] == ':')
	335	{
	336	fusion_rom_decode(code, result);
	337	}
b67ef287	338
fa55ee51	339	else
	340	{
	341	goto bad_code;
	342	}
b67ef287	343
fa55ee51	344	//Convert RAM address space to Genesis location.
	345	if (result->addr>=0xC000)
	346	result->addr= 0xFF0000 \| (0x1FFF & result->addr);
	347	}
b67ef287	348
fa55ee51	349	return;
	350
	351	bad_code:
b67ef287	352	result->data = result->addr = -1;
	353	return;
	354	}
	355
	356
	357
eff55556	358	unsigned int PicoRead16(unsigned int a);
b67ef287	359	void PicoWrite16(unsigned int a, unsigned short d);
daae6156	360	extern unsigned short m68k_read16(unsigned int a);
fa55ee51	361	extern void m68k_write16(unsigned int a, unsigned short d);
	362	extern char PicoRead8_z80(unsigned short a);
	363	extern void PicoWrite8_z80(unsigned short a, char d);
b67ef287	364
	365	void PicoPatchUnload(void)
	366	{
	367	if (PicoPatches != NULL)
	368	{
	369	free(PicoPatches);
	370	PicoPatches = NULL;
	371	}
	372	PicoPatchCount = 0;
	373	}
	374
	375	int PicoPatchLoad(const char *fname)
	376	{
	377	FILE *f;
	378	char buff[256];
	379	struct patch pt;
	380	int array_len = 0;
	381
	382	PicoPatchUnload();
	383
	384	f = fopen(fname, "r");
	385	if (f == NULL)
	386	{
	387	return -1;
	388	}
	389
	390	while (fgets(buff, sizeof(buff), f))
	391	{
	392	int llen, clen;
	393
	394	llen = strlen(buff);
	395	for (clen = 0; clen < llen; clen++)
ee2a3bdf	396	if (isspace_(buff[clen]))
ee2a3bdf	397	break;
b67ef287	398	buff[clen] = 0;
	399
	400	if (clen > 11 \|\| clen < 8)
	401	continue;
	402
	403	decode(buff, &pt);
	404	if (pt.addr == (unsigned int)-1 \|\| pt.data == (unsigned short)-1)
	405	continue;
	406
	407	/* code was good, add it */
	408	if (array_len < PicoPatchCount + 1)
	409	{
	410	void *ptr;
	411	array_len *= 2;
	412	array_len++;
	413	ptr = realloc(PicoPatches, array_len * sizeof(PicoPatches[0]));
	414	if (ptr == NULL) break;
	415	PicoPatches = ptr;
	416	}
	417	strcpy(PicoPatches[PicoPatchCount].code, buff);
	418	/* strip */
	419	for (clen++; clen < llen; clen++)
ee2a3bdf	420	if (!isspace_(buff[clen]))
ee2a3bdf	421	break;
b67ef287	422	for (llen--; llen > 0; llen--)
ee2a3bdf	423	if (!isspace_(buff[llen]))
ee2a3bdf	424	break;
b67ef287	425	buff[llen+1] = 0;
	426	strncpy(PicoPatches[PicoPatchCount].name, buff + clen, 51);
	427	PicoPatches[PicoPatchCount].name[51] = 0;
	428	PicoPatches[PicoPatchCount].active = 0;
	429	PicoPatches[PicoPatchCount].addr = pt.addr;
	430	PicoPatches[PicoPatchCount].data = pt.data;
	431	PicoPatches[PicoPatchCount].data_old = 0;
	432	PicoPatchCount++;
	433	// fprintf(stderr, "loaded patch #%i: %06x:%04x \"%s\"\n", PicoPatchCount-1, pt.addr, pt.data,
	434	// PicoPatches[PicoPatchCount-1].name);
	435	}
	436	fclose(f);
	437
	438	return 0;
	439	}
	440
	441	/* to be called when the Rom is loaded and byteswapped */
	442	void PicoPatchPrepare(void)
	443	{
fa55ee51	444	int i;
fa55ee51	445	int addr;
b67ef287	446
fa55ee51	447	for (i = 0; i < PicoPatchCount; i++)
	448	{
	449	addr=PicoPatches[i].addr;
	450	addr &= ~1;
	451	if (addr < Pico.romsize)
	452	PicoPatches[i].data_old = (unsigned short )(Pico.rom + addr);
	453	else
	454	{
	455	if(!(PicoAHW & PAHW_SMS))
	456	PicoPatches[i].data_old = (unsigned short) m68k_read16(addr);
	457	else
	458	PicoPatches[i].data_old = (unsigned char) PicoRead8_z80(addr);
	459	}
	460	if (strstr(PicoPatches[i].name, "AUTO"))
	461	PicoPatches[i].active = 1;
	462	}
b67ef287	463	}
	464
	465	void PicoPatchApply(void)
	466	{
fa55ee51	467	int i, u;
	468	unsigned int addr;
	469
	470	for (i = 0; i < PicoPatchCount; i++)
	471	{
	472	addr = PicoPatches[i].addr;
b67ef287	473
fa55ee51	474	if (addr < Pico.romsize)
	475	{
	476	if (PicoPatches[i].active)
	477	{
	478	if (!(PicoAHW & PAHW_SMS))
	479	(unsigned short )(Pico.rom + addr) = PicoPatches[i].data;
	480	else if (!PicoPatches[i].comp \|\| PicoPatches[i].comp == (char )(Pico.rom + addr))
	481	(char )(Pico.rom + addr) = (char) PicoPatches[i].data;
	482	}
	483	else
	484	{
	485	// if current addr is not patched by older patch, write back original val
	486	for (u = 0; u < i; u++)
	487	if (PicoPatches[u].addr == addr) break;
	488	if (u == i)
b67ef287	489	{
fa55ee51	490	if (!(PicoAHW & PAHW_SMS))
	491	(unsigned short )(Pico.rom + addr) = PicoPatches[i].data_old;
	492	else
	493	(char )(Pico.rom + addr) = (char) PicoPatches[i].data_old;
	494	}
	495	}
	496	// fprintf(stderr, "patched %i: %06x:%04x\n", PicoPatches[i].active, addr,
	497	// (unsigned short )(Pico.rom + addr));
	498	}
	499	else
	500	{
	501	if (PicoPatches[i].active)
	502	{
	503	if (!(PicoAHW & PAHW_SMS))
	504	m68k_write16(addr,PicoPatches[i].data);
	505	else
	506	PicoWrite8_z80(addr,PicoPatches[i].data);
	507	}
	508	else
	509	{
	510	// if current addr is not patched by older patch, write back original val
	511	for (u = 0; u < i; u++)
	512	if (PicoPatches[u].addr == addr) break;
	513	if (u == i)
	514	{
	515	if (!(PicoAHW & PAHW_SMS))
	516	m68k_write16(PicoPatches[i].addr,PicoPatches[i].data_old);
	517	else
	518	PicoWrite8_z80(PicoPatches[i].addr,PicoPatches[i].data_old);
b67ef287	519	}
fa55ee51	520	}
	521	}
	522	}
b67ef287	523	}
b67ef287	524