[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 "memory.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 >= 7 && code[3] == '-')
    {
      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;
}

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