godzil/ti-nesulator
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Use more modern types for fixed size variables.

Browse Source
This commit is contained in:
Godzil 2018-02-01 19:04:46 +00:00
parent a3d67a4de3
commit ad195d6c20
37 changed files with 418 additions and 454 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/NESCarts.c
View File

@ -50,7 +50,7 @@ int LoadCart(const char *filename, NesCart * cart)
{
char buffer[6];
/* Load the cart into memory */
cart->File = (byte *)LoadFilePtr((char *)filename);
cart->File = (uint8_t *)LoadFilePtr((char *)filename);
if ((cart->File == NULL) || (cart->File == MAP_FAILED))

186
src/corecpu/corecpu.c
View File

@ -142,7 +142,7 @@
#ifdef Q6502_NO_DECIMAL
#define ADC_OPERATION(read) do {\
unsigned short tmp = 0; unsigned char v = read; \
uint16_t tmp = 0; uint8_t v = read; \
tmp = cpu->reg_A + v + (cpu->reg_P & Q6502_C_FLAG); \
cpu->reg_P = (cpu->reg_P & ~(Q6502_C_FLAG | Q6502_N_FLAG | Q6502_Z_FLAG | Q6502_V_FLAG)) | \
(tmp & Q6502_N_FLAG) | ((tmp&0xFF)?0:Q6502_Z_FLAG) | \
@ -152,7 +152,7 @@
} while(0)
#define SBC_OPERATION(read) do {\
unsigned short tmp = 0; unsigned char v = read; \
uint16_t tmp = 0; uint8_t v = read; \
tmp = cpu->reg_A - v - (~cpu->reg_P & Q6502_C_FLAG); \
cpu->reg_P = (cpu->reg_P & ~(Q6502_C_FLAG | Q6502_N_FLAG | Q6502_Z_FLAG | Q6502_V_FLAG)) | \
(tmp & Q6502_N_FLAG) | ((tmp&0xFF)?0:Q6502_Z_FLAG) | \
@ -170,7 +170,7 @@
/* CMP is like SBC but without storing the result value */
#define CMP_OPERATION(register, read) do { \
unsigned short tmp = 0; \
uint16_t tmp = 0; \
tmp = register - read; \
cpu->reg_P = (cpu->reg_P & ~(Q6502_C_FLAG | Q6502_N_FLAG | Q6502_Z_FLAG)) | \
(tmp & Q6502_N_FLAG) | ((tmp&0xFF)?0:Q6502_Z_FLAG) | \
@ -181,7 +181,7 @@
#define ORA_OPERATION(read) cpu->reg_A |= read; NZ_FLAG_UPDATE(cpu->reg_A)
#define BIT_OPERATION(read) do { \
byte tmp = read; \
uint8_t tmp = read; \
cpu->reg_P = (cpu->reg_P & ~(Q6502_V_FLAG | Q6502_N_FLAG | Q6502_Z_FLAG)) | \
(tmp & Q6502_N_FLAG) | (tmp & Q6502_V_FLAG) | \
((tmp & cpu->reg_A)?0:Q6502_Z_FLAG); \
@ -199,7 +199,7 @@
val = val >> 1
#define ROR_OPERATION(val) do {\
unsigned short tmp = val | (cpu->reg_P & Q6502_C_FLAG) << 8; \
uint16_t tmp = val | (cpu->reg_P & Q6502_C_FLAG) << 8; \
cpu->reg_P = (cpu->reg_P & ~(Q6502_C_FLAG | Q6502_N_FLAG | Q6502_Z_FLAG)) | \
( tmp&Q6502_C_FLAG) | /* Set the C flag */ \
((tmp&0x100) >> 1) | /* Set the N flag */ \
@ -208,7 +208,7 @@
} while(0)
#define ROL_OPERATION(val) do {\
unsigned short tmp = (val << 1) | (cpu->reg_P & Q6502_C_FLAG); \
uint16_t tmp = (val << 1) | (cpu->reg_P & Q6502_C_FLAG); \
cpu->reg_P = (cpu->reg_P & ~(Q6502_C_FLAG | Q6502_N_FLAG | Q6502_Z_FLAG)) | \
((tmp&0x100)?Q6502_C_FLAG:0) | /* Set the C flag */ \
((tmp&0x80)) | /* Set the N flag */ \
@ -494,7 +494,7 @@ int quick6502_free(quick6502_cpu *cpu)
/*******************************************************************************
*** Here start real CPU logic ***
*******************************************************************************/
static byte CycleTable[256] =
static uint8_t CycleTable[256] =
{
/* 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F */
/* 00 */ 7, 6, 0, 8, 3, 3, 5, 5, 3, 2, 2, 2, 4, 4, 6, 6,
@ -650,8 +650,8 @@ INSTRUCTION(LDAaB)
/** DD: LDA $xxxx,X - LoaD to A **/
INSTRUCTION(LDAaX)
{
register byte op1 = cpu->memory_opcode_read(cpu->reg_PC++);
register byte op2 = cpu->memory_opcode_read(cpu->reg_PC++);
register uint8_t op1 = cpu->memory_opcode_read(cpu->reg_PC++);
register uint8_t op2 = cpu->memory_opcode_read(cpu->reg_PC++);
TRACEi(("LDA $%02X%02X,X", cpu->memory_opcode_read(cpu->reg_PC+1), cpu->memory_opcode_read(cpu->reg_PC)));
cpu->reg_A = MEMORY_READ_AX();
@ -662,8 +662,8 @@ INSTRUCTION(LDAaX)
/** D9: LDA $xxxx,Y - LoaD to A **/
INSTRUCTION(LDAaY)
{
register byte op1 = cpu->memory_opcode_read(cpu->reg_PC++);
register byte op2 = cpu->memory_opcode_read(cpu->reg_PC++);
register uint8_t op1 = cpu->memory_opcode_read(cpu->reg_PC++);
register uint8_t op2 = cpu->memory_opcode_read(cpu->reg_PC++);
cpu->reg_A = MEMORY_READ_AY();
NZ_FLAG_UPDATE(cpu->reg_A);
CROSS_CYCLE_UPDATE(op1 + cpu->reg_Y);
@ -745,8 +745,8 @@ INSTRUCTION(LDXaB)
/** BE: LDX $xxxx,Y - LoaD to X **/
INSTRUCTION(LDXaY)
{
register byte op1 = cpu->memory_opcode_read(cpu->reg_PC++);
register byte op2 = cpu->memory_opcode_read(cpu->reg_PC++);
register uint8_t op1 = cpu->memory_opcode_read(cpu->reg_PC++);
register uint8_t op2 = cpu->memory_opcode_read(cpu->reg_PC++);
TRACEi(("LDX $%02X%02X,Y", op2, op1));
cpu->reg_X = MEMORY_READ_AY();
NZ_FLAG_UPDATE(cpu->reg_X);
@ -801,8 +801,8 @@ INSTRUCTION(LDYaB)
/** BC: LDY $xxxx,X - LoaD to Y **/
INSTRUCTION(LDYaX)
{
register byte op1 = cpu->memory_opcode_read(cpu->reg_PC++);
register byte op2 = cpu->memory_opcode_read(cpu->reg_PC++);
register uint8_t op1 = cpu->memory_opcode_read(cpu->reg_PC++);
register uint8_t op2 = cpu->memory_opcode_read(cpu->reg_PC++);
TRACEi(("LDY $%02X%02X,X", cpu->memory_opcode_read(cpu->reg_PC+1), cpu->memory_opcode_read(cpu->reg_PC)));
cpu->reg_Y = MEMORY_READ_AX();
@ -1198,8 +1198,8 @@ INSTRUCTION(ADCaB)
/** 7D : ADC - ADd with Carry **/
INSTRUCTION(ADCaX)
{
register byte op1 = cpu->memory_opcode_read(cpu->reg_PC++);
register byte op2 = cpu->memory_opcode_read(cpu->reg_PC++);
register uint8_t op1 = cpu->memory_opcode_read(cpu->reg_PC++);
register uint8_t op2 = cpu->memory_opcode_read(cpu->reg_PC++);
TRACEi(("ADC $%02X%02X,X", cpu->memory_opcode_read(cpu->reg_PC+1), cpu->memory_opcode_read(cpu->reg_PC)));
ADC_OPERATION(MEMORY_READ_AX());
@ -1209,8 +1209,8 @@ INSTRUCTION(ADCaX)
/** 79 : ADC - ADd with Carry **/
INSTRUCTION(ADCaY)
{
register byte op1 = cpu->memory_opcode_read(cpu->reg_PC++);
register byte op2 = cpu->memory_opcode_read(cpu->reg_PC++);
register uint8_t op1 = cpu->memory_opcode_read(cpu->reg_PC++);
register uint8_t op2 = cpu->memory_opcode_read(cpu->reg_PC++);
TRACEi(("ADC $%02X%02X,Y", op2, op1));
ADC_OPERATION(MEMORY_READ_AY());
CROSS_CYCLE_UPDATE(op1 + cpu->reg_Y);
@ -1262,8 +1262,8 @@ INSTRUCTION(SBCaB)
/** FD : SBC - SuBstract with Carry **/
INSTRUCTION(SBCaX)
{
register byte op1 = cpu->memory_opcode_read(cpu->reg_PC++);
register byte op2 = cpu->memory_opcode_read(cpu->reg_PC++);
register uint8_t op1 = cpu->memory_opcode_read(cpu->reg_PC++);
register uint8_t op2 = cpu->memory_opcode_read(cpu->reg_PC++);
TRACEi(("SBC $%02X%02X,X", cpu->memory_opcode_read(cpu->reg_PC+1), cpu->memory_opcode_read(cpu->reg_PC)));
SBC_OPERATION(MEMORY_READ_AX());
@ -1274,8 +1274,8 @@ INSTRUCTION(SBCaX)
/** F9 : SBC - SuBstract with Carry **/
INSTRUCTION(SBCaY)
{
register byte op1 = cpu->memory_opcode_read(cpu->reg_PC++);
register byte op2 = cpu->memory_opcode_read(cpu->reg_PC++);
register uint8_t op1 = cpu->memory_opcode_read(cpu->reg_PC++);
register uint8_t op2 = cpu->memory_opcode_read(cpu->reg_PC++);
TRACEi(("SBC $%02X%02X,Y", op2, op1));
SBC_OPERATION(MEMORY_READ_AY());
CROSS_CYCLE_UPDATE(op1 + cpu->reg_Y);
@ -1327,8 +1327,8 @@ INSTRUCTION(CMPaB)
/** DD : CMP - CoMPare **/
INSTRUCTION(CMPaX)
{
register byte op1 = cpu->memory_opcode_read(cpu->reg_PC++);
register byte op2 = cpu->memory_opcode_read(cpu->reg_PC++);
register uint8_t op1 = cpu->memory_opcode_read(cpu->reg_PC++);
register uint8_t op2 = cpu->memory_opcode_read(cpu->reg_PC++);
TRACEi(("CMP $%02X%02X,X", cpu->memory_opcode_read(cpu->reg_PC+1), cpu->memory_opcode_read(cpu->reg_PC)));
CMP_OPERATION(cpu->reg_A, MEMORY_READ_AX());
@ -1338,8 +1338,8 @@ INSTRUCTION(CMPaX)
/** D9 : CMP - CoMPare **/
INSTRUCTION(CMPaY)
{
register byte op1 = cpu->memory_opcode_read(cpu->reg_PC++);
register byte op2 = cpu->memory_opcode_read(cpu->reg_PC++);
register uint8_t op1 = cpu->memory_opcode_read(cpu->reg_PC++);
register uint8_t op2 = cpu->memory_opcode_read(cpu->reg_PC++);
TRACEi(("CMP $%02X%02X,Y", op2, op1));
CMP_OPERATION(cpu->reg_A, MEMORY_READ_AY());
CROSS_CYCLE_UPDATE(op1 + cpu->reg_Y);
@ -1433,8 +1433,8 @@ INSTRUCTION(ORAaB)
/** 1D : ORA - OR with A **/
INSTRUCTION(ORAaX)
{
register byte op1 = cpu->memory_opcode_read(cpu->reg_PC++);
register byte op2 = cpu->memory_opcode_read(cpu->reg_PC++);
register uint8_t op1 = cpu->memory_opcode_read(cpu->reg_PC++);
register uint8_t op2 = cpu->memory_opcode_read(cpu->reg_PC++);
TRACEi(("ORA $%02X%02X,X", cpu->memory_opcode_read(cpu->reg_PC+1), cpu->memory_opcode_read(cpu->reg_PC)));
ORA_OPERATION(MEMORY_READ_AX());
@ -1444,8 +1444,8 @@ INSTRUCTION(ORAaX)
/** 19 : ORA - OR with A **/
INSTRUCTION(ORAaY)
{
register byte op1 = cpu->memory_opcode_read(cpu->reg_PC++);
register byte op2 = cpu->memory_opcode_read(cpu->reg_PC++);
register uint8_t op1 = cpu->memory_opcode_read(cpu->reg_PC++);
register uint8_t op2 = cpu->memory_opcode_read(cpu->reg_PC++);
TRACEi(("ORA $%02X%02X,Y", op2, op1));
ORA_OPERATION(MEMORY_READ_AY());
@ -1499,8 +1499,8 @@ INSTRUCTION(EORaB)
/** 5D : EOR - Exclusive OR **/
INSTRUCTION(EORaX)
{
register byte op1 = cpu->memory_opcode_read(cpu->reg_PC++);
register byte op2 = cpu->memory_opcode_read(cpu->reg_PC++);
register uint8_t op1 = cpu->memory_opcode_read(cpu->reg_PC++);
register uint8_t op2 = cpu->memory_opcode_read(cpu->reg_PC++);
TRACEi(("EOR $%02X%02X,X", cpu->memory_opcode_read(cpu->reg_PC+1), cpu->memory_opcode_read(cpu->reg_PC)));
EOR_OPERATION(MEMORY_READ_AX());
@ -1510,8 +1510,8 @@ INSTRUCTION(EORaX)
/** 59 : EOR - Exclusive OR **/
INSTRUCTION(EORaY)
{
register byte op1 = cpu->memory_opcode_read(cpu->reg_PC++);
register byte op2 = cpu->memory_opcode_read(cpu->reg_PC++);
register uint8_t op1 = cpu->memory_opcode_read(cpu->reg_PC++);
register uint8_t op2 = cpu->memory_opcode_read(cpu->reg_PC++);
TRACEi(("EOR $%02X%02X,Y", op2, op1));
EOR_OPERATION(MEMORY_READ_AY());
CROSS_CYCLE_UPDATE(op1 + cpu->reg_Y);
@ -1564,8 +1564,8 @@ INSTRUCTION(ANDaB)
/** 3D : AND - Logical AND **/
INSTRUCTION(ANDaX)
{
register byte op1 = cpu->memory_opcode_read(cpu->reg_PC++);
register byte op2 = cpu->memory_opcode_read(cpu->reg_PC++);
register uint8_t op1 = cpu->memory_opcode_read(cpu->reg_PC++);
register uint8_t op2 = cpu->memory_opcode_read(cpu->reg_PC++);
TRACEi(("AND $%02X%02X,X", cpu->memory_opcode_read(cpu->reg_PC+1), cpu->memory_opcode_read(cpu->reg_PC)));
AND_OPERATION(MEMORY_READ_AX());
@ -1576,8 +1576,8 @@ INSTRUCTION(ANDaX)
/** 39 : AND - Logical AND **/
INSTRUCTION(ANDaY)
{
register byte op1 = cpu->memory_opcode_read(cpu->reg_PC++);
register byte op2 = cpu->memory_opcode_read(cpu->reg_PC++);
register uint8_t op1 = cpu->memory_opcode_read(cpu->reg_PC++);
register uint8_t op2 = cpu->memory_opcode_read(cpu->reg_PC++);
TRACEi(("AND $%02X%02X,Y", op2, op1));
AND_OPERATION(MEMORY_READ_AY());
CROSS_CYCLE_UPDATE(op1 + cpu->reg_Y);
@ -1631,7 +1631,7 @@ INSTRUCTION(LSRnP)
INSTRUCTION(ROLaB)
{
TRACEi(("ROL $%02X%02X", cpu->memory_opcode_read(cpu->reg_PC+1), cpu->memory_opcode_read(cpu->reg_PC)));
byte val = MEMORY_READ_AB();
uint8_t val = MEMORY_READ_AB();
cpu->reg_PC -= 2;
ROL_OPERATION(val);
MEMORY_WRITE_AB(val);
@ -1641,7 +1641,7 @@ INSTRUCTION(ROLaB)
INSTRUCTION(ROLzP)
{
TRACEi(("ROL $%02X", cpu->memory_opcode_read(cpu->reg_PC)));
byte val = MEMORY_READ_ZP();
uint8_t val = MEMORY_READ_ZP();
cpu->reg_PC -= 1;
ROL_OPERATION(val);
MEMORY_WRITE_ZP(val);
@ -1650,11 +1650,11 @@ INSTRUCTION(ROLzP)
/** 3E : ROL **/
INSTRUCTION(ROLaX)
{
register byte op1 = cpu->memory_opcode_read(cpu->reg_PC++);
register byte op2 = cpu->memory_opcode_read(cpu->reg_PC++);
register uint8_t op1 = cpu->memory_opcode_read(cpu->reg_PC++);
register uint8_t op2 = cpu->memory_opcode_read(cpu->reg_PC++);
TRACEi(("ROL $%02X%02X,X", cpu->memory_opcode_read(cpu->reg_PC+1), cpu->memory_opcode_read(cpu->reg_PC)));
byte val = MEMORY_READ_AX();
uint8_t val = MEMORY_READ_AX();
cpu->reg_PC -= 2;
ROL_OPERATION(val);
MEMORY_WRITE_AX(val);
@ -1664,7 +1664,7 @@ INSTRUCTION(ROLaX)
INSTRUCTION(ROLzX)
{
TRACEi(("ROL $%02X,X", cpu->memory_opcode_read(cpu->reg_PC)));
byte val = MEMORY_READ_ZX();
uint8_t val = MEMORY_READ_ZX();
cpu->reg_PC -= 1;
ROL_OPERATION(val);
MEMORY_WRITE_ZX(val);
@ -1674,7 +1674,7 @@ INSTRUCTION(ROLzX)
INSTRUCTION(RORaB)
{
TRACEi(("ROR $%02X%02X", cpu->memory_opcode_read(cpu->reg_PC+1), cpu->memory_opcode_read(cpu->reg_PC)));
byte val = MEMORY_READ_AB();
uint8_t val = MEMORY_READ_AB();
cpu->reg_PC -= 2;
ROR_OPERATION(val);
MEMORY_WRITE_AB(val);
@ -1684,7 +1684,7 @@ INSTRUCTION(RORaB)
INSTRUCTION(RORzP)
{
TRACEi(("ROR $%02X", cpu->memory_opcode_read(cpu->reg_PC)));
byte val = MEMORY_READ_ZP();
uint8_t val = MEMORY_READ_ZP();
cpu->reg_PC -= 1;
ROR_OPERATION(val);
MEMORY_WRITE_ZP(val);
@ -1693,11 +1693,11 @@ INSTRUCTION(RORzP)
/** 7E : ROR **/
INSTRUCTION(RORaX)
{
register byte op1 = cpu->memory_opcode_read(cpu->reg_PC++);
register byte op2 = cpu->memory_opcode_read(cpu->reg_PC++);
register uint8_t op1 = cpu->memory_opcode_read(cpu->reg_PC++);
register uint8_t op2 = cpu->memory_opcode_read(cpu->reg_PC++);
TRACEi(("ROR $%02X%02X,X", cpu->memory_opcode_read(cpu->reg_PC+1), cpu->memory_opcode_read(cpu->reg_PC)));
byte val = MEMORY_READ_AX();
uint8_t val = MEMORY_READ_AX();
cpu->reg_PC -= 2;
ROR_OPERATION(val);
MEMORY_WRITE_AX(val);
@ -1707,7 +1707,7 @@ INSTRUCTION(RORaX)
INSTRUCTION(RORzX)
{
TRACEi(("ROR $%02X,X", cpu->memory_opcode_read(cpu->reg_PC)));
byte val = MEMORY_READ_ZX();
uint8_t val = MEMORY_READ_ZX();
cpu->reg_PC -= 1;
ROR_OPERATION(val);
MEMORY_WRITE_ZX(val);
@ -1717,7 +1717,7 @@ INSTRUCTION(RORzX)
INSTRUCTION(ASLaB)
{
TRACEi(("ASL $%02X%02X", cpu->memory_opcode_read(cpu->reg_PC+1), cpu->memory_opcode_read(cpu->reg_PC)));
byte val = MEMORY_READ_AB();
uint8_t val = MEMORY_READ_AB();
cpu->reg_PC -= 2;
ASL_OPERATION(val);
MEMORY_WRITE_AB(val);
@ -1727,7 +1727,7 @@ INSTRUCTION(ASLaB)
INSTRUCTION(ASLzP)
{
TRACEi(("ASL $%02X", cpu->memory_opcode_read(cpu->reg_PC)));
byte val = MEMORY_READ_ZP();
uint8_t val = MEMORY_READ_ZP();
cpu->reg_PC -= 1;
ASL_OPERATION(val);
MEMORY_WRITE_ZP(val);
@ -1736,11 +1736,11 @@ INSTRUCTION(ASLzP)
/** 1E : ASL **/
INSTRUCTION(ASLaX)
{
register byte op1 = cpu->memory_opcode_read(cpu->reg_PC++);
register byte op2 = cpu->memory_opcode_read(cpu->reg_PC++);
register uint8_t op1 = cpu->memory_opcode_read(cpu->reg_PC++);
register uint8_t op2 = cpu->memory_opcode_read(cpu->reg_PC++);
TRACEi(("ASL $%02X%02X,X", cpu->memory_opcode_read(cpu->reg_PC+1), cpu->memory_opcode_read(cpu->reg_PC)));
byte val = MEMORY_READ_AX();
uint8_t val = MEMORY_READ_AX();
cpu->reg_PC -= 2;
ASL_OPERATION(val);
MEMORY_WRITE_AX(val);
@ -1750,7 +1750,7 @@ INSTRUCTION(ASLaX)
INSTRUCTION(ASLzX)
{
TRACEi(("ASL $%02X,X", cpu->memory_opcode_read(cpu->reg_PC)));
byte val = MEMORY_READ_ZX();
uint8_t val = MEMORY_READ_ZX();
cpu->reg_PC -= 1;
ASL_OPERATION(val);
MEMORY_WRITE_ZX(val);
@ -1760,7 +1760,7 @@ INSTRUCTION(ASLzX)
INSTRUCTION(LSRaB)
{
TRACEi(("LSR $%02X%02X", cpu->memory_opcode_read(cpu->reg_PC+1), cpu->memory_opcode_read(cpu->reg_PC)));
byte val = MEMORY_READ_AB();
uint8_t val = MEMORY_READ_AB();
cpu->reg_PC -= 2;
LSR_OPERATION(val);
MEMORY_WRITE_AB(val);
@ -1770,7 +1770,7 @@ INSTRUCTION(LSRaB)
INSTRUCTION(LSRzP)
{
TRACEi(("LSR $%02X", cpu->memory_opcode_read(cpu->reg_PC)));
byte val = MEMORY_READ_ZP();
uint8_t val = MEMORY_READ_ZP();
cpu->reg_PC -= 1;
LSR_OPERATION(val);
MEMORY_WRITE_ZP(val);
@ -1779,11 +1779,11 @@ INSTRUCTION(LSRzP)
/** 5E : LSR **/
INSTRUCTION(LSRaX)
{
register byte op1 = cpu->memory_opcode_read(cpu->reg_PC++);
register byte op2 = cpu->memory_opcode_read(cpu->reg_PC++);
register uint8_t op1 = cpu->memory_opcode_read(cpu->reg_PC++);
register uint8_t op2 = cpu->memory_opcode_read(cpu->reg_PC++);
TRACEi(("LSR $%02X%02X,X", cpu->memory_opcode_read(cpu->reg_PC+1), cpu->memory_opcode_read(cpu->reg_PC)));
byte val = MEMORY_READ_AX();
uint8_t val = MEMORY_READ_AX();
cpu->reg_PC -= 2;
LSR_OPERATION(val);
MEMORY_WRITE_AX(val);
@ -1793,7 +1793,7 @@ INSTRUCTION(LSRaX)
INSTRUCTION(LSRzX)
{
TRACEi(("LSR $%02X,X", cpu->memory_opcode_read(cpu->reg_PC)));
byte val = MEMORY_READ_ZX();
uint8_t val = MEMORY_READ_ZX();
cpu->reg_PC -= 1;
LSR_OPERATION(val);
MEMORY_WRITE_ZX(val);
@ -1803,7 +1803,7 @@ INSTRUCTION(LSRzX)
INSTRUCTION(DECaB)
{
TRACEi(("DEC $%02X%02X", cpu->memory_opcode_read(cpu->reg_PC+1), cpu->memory_opcode_read(cpu->reg_PC)));
byte val = MEMORY_READ_AB();
uint8_t val = MEMORY_READ_AB();
cpu->reg_PC -= 2;
MEMORY_WRITE_AB(--val);
NZ_FLAG_UPDATE(val);
@ -1813,7 +1813,7 @@ INSTRUCTION(DECaB)
INSTRUCTION(DECzP)
{
TRACEi(("DEC $%02X", cpu->memory_opcode_read(cpu->reg_PC)));
byte val = MEMORY_READ_ZP();
uint8_t val = MEMORY_READ_ZP();
cpu->reg_PC -= 1;
MEMORY_WRITE_ZP(--val);
NZ_FLAG_UPDATE(val);
@ -1822,11 +1822,11 @@ INSTRUCTION(DECzP)
/** DE : DEC **/
INSTRUCTION(DECaX)
{
register byte op1 = cpu->memory_opcode_read(cpu->reg_PC++);
register byte op2 = cpu->memory_opcode_read(cpu->reg_PC++);
register uint8_t op1 = cpu->memory_opcode_read(cpu->reg_PC++);
register uint8_t op2 = cpu->memory_opcode_read(cpu->reg_PC++);
TRACEi(("DEC $%02X%02X,X", cpu->memory_opcode_read(cpu->reg_PC+1), cpu->memory_opcode_read(cpu->reg_PC)));
byte val = MEMORY_READ_AX();
uint8_t val = MEMORY_READ_AX();
cpu->reg_PC -= 2;
MEMORY_WRITE_AX(--val);
NZ_FLAG_UPDATE(val);
@ -1836,7 +1836,7 @@ INSTRUCTION(DECaX)
INSTRUCTION(DECzX)
{
TRACEi(("DEC $%02X,X", cpu->memory_opcode_read(cpu->reg_PC)));
byte val = MEMORY_READ_ZX();
uint8_t val = MEMORY_READ_ZX();
cpu->reg_PC -= 1;
MEMORY_WRITE_ZX(--val);
NZ_FLAG_UPDATE(val);
@ -1846,7 +1846,7 @@ INSTRUCTION(DECzX)
INSTRUCTION(INCaB)
{
TRACEi(("INC $%02X%02X", cpu->memory_opcode_read(cpu->reg_PC+1), cpu->memory_opcode_read(cpu->reg_PC)));
byte val = MEMORY_READ_AB();
uint8_t val = MEMORY_READ_AB();
cpu->reg_PC -= 2;
MEMORY_WRITE_AB(++val);
NZ_FLAG_UPDATE(val);
@ -1856,7 +1856,7 @@ INSTRUCTION(INCaB)
INSTRUCTION(INCzP)
{
TRACEi(("INC $%02X", cpu->memory_opcode_read(cpu->reg_PC)));
byte val = MEMORY_READ_ZP();
uint8_t val = MEMORY_READ_ZP();
cpu->reg_PC -= 1;
MEMORY_WRITE_ZP(++val);
NZ_FLAG_UPDATE(val);
@ -1865,11 +1865,11 @@ INSTRUCTION(INCzP)
/** FE : INC **/
INSTRUCTION(INCaX)
{
register byte op1 = cpu->memory_opcode_read(cpu->reg_PC++);
register byte op2 = cpu->memory_opcode_read(cpu->reg_PC++);
register uint8_t op1 = cpu->memory_opcode_read(cpu->reg_PC++);
register uint8_t op2 = cpu->memory_opcode_read(cpu->reg_PC++);
TRACEi(("INC $%02X%02X,X", cpu->memory_opcode_read(cpu->reg_PC+1), cpu->memory_opcode_read(cpu->reg_PC)));
byte val = MEMORY_READ_AX();
uint8_t val = MEMORY_READ_AX();
cpu->reg_PC -= 2;
MEMORY_WRITE_AX(++val);
NZ_FLAG_UPDATE(val);
@ -1879,7 +1879,7 @@ INSTRUCTION(INCaX)
INSTRUCTION(INCzX)
{
TRACEi(("INC $%02X,X", cpu->memory_opcode_read(cpu->reg_PC)));
byte val = MEMORY_READ_ZX();
uint8_t val = MEMORY_READ_ZX();
cpu->reg_PC -= 1;
MEMORY_WRITE_ZX(++val);
NZ_FLAG_UPDATE(val);
@ -1973,10 +1973,10 @@ static InstructionNameTag InstructionNameTable[256] =
/** Get current instruction name at specified address and put it into buffer */
int quick6502_getinstruction(quick6502_cpu *cpu, char interpret,
unsigned short addr, char *buffer, int *strlength)
uint16_t addr, char *buffer, int *strlength)
{
int len = 0, curlen;
int readbyte = 1;
int readuint8_t = 1;
char *str = buffer;
uint8_t opcode = cpu->memory_opcode_read(addr);
@ -1999,7 +1999,7 @@ int quick6502_getinstruction(quick6502_cpu *cpu, char interpret,
/* Nothing to interpret.. Really */
readbyte += 2;
readuint8_t += 2;
break;
@ -2020,7 +2020,7 @@ int quick6502_getinstruction(quick6502_cpu *cpu, char interpret,
str += curlen; len += curlen;
}
readbyte += 1;
readuint8_t += 1;
break;
case t_IDY:
@ -2041,7 +2041,7 @@ int quick6502_getinstruction(quick6502_cpu *cpu, char interpret,
str += curlen; len += curlen;
}
readbyte += 1;
readuint8_t += 1;
break;
case t_ABS:
@ -2051,7 +2051,7 @@ int quick6502_getinstruction(quick6502_cpu *cpu, char interpret,
/* Nothing to interpret.. Really */
readbyte += 2;
readuint8_t += 2;
break;
case t_REL:
@ -2061,7 +2061,7 @@ int quick6502_getinstruction(quick6502_cpu *cpu, char interpret,
/* Nothing to interpret.. Really */
readbyte += 1;
readuint8_t += 1;
break;
case t_ZEP:
@ -2070,7 +2070,7 @@ int quick6502_getinstruction(quick6502_cpu *cpu, char interpret,
/* Nothing to interpret.. Really */
readbyte += 1;
readuint8_t += 1;
break;
case t_ZPX:
@ -2085,7 +2085,7 @@ int quick6502_getinstruction(quick6502_cpu *cpu, char interpret,
str += curlen; len += curlen;
}
readbyte += 1;
readuint8_t += 1;
break;
case t_ZPY:
@ -2100,7 +2100,7 @@ int quick6502_getinstruction(quick6502_cpu *cpu, char interpret,
str += curlen; len += curlen;
}
readbyte += 1;
readuint8_t += 1;
break;
case t_ABX:
@ -2117,7 +2117,7 @@ int quick6502_getinstruction(quick6502_cpu *cpu, char interpret,
str += curlen; len += curlen;
}
readbyte += 2;
readuint8_t += 2;
break;
case t_ABY:
@ -2134,7 +2134,7 @@ int quick6502_getinstruction(quick6502_cpu *cpu, char interpret,
str += curlen; len += curlen;
}
readbyte += 2;
readuint8_t += 2;
break;
case t_IND:
@ -2156,14 +2156,14 @@ int quick6502_getinstruction(quick6502_cpu *cpu, char interpret,
str += curlen; len += curlen;
}
readbyte += 2;
readuint8_t += 2;
break;
}
if (strlength != NULL)
*strlength = len;
return readbyte;
return readuint8_t;
}
#else
@ -2191,10 +2191,10 @@ static char InstructionParameters[256][10] =
/** Get current instruction name at specified address and put it into buffer */
int quick6502_getinstruction(quick6502_cpu *cpu, char interpret,
unsigned short addr, char *buffer, int *strlength)
uint16_t addr, char *buffer, int *strlength)
{
unsigned char instr = cpu->memory_opcode_read(cpu->reg_PC);
unsigned char *instrText = InstructionParameters[instr];
uint8_t instr = cpu->memory_opcode_read(cpu->reg_PC);
uint8_t *instrText = InstructionParameters[instr];
buffer += strlen(strcpy(buffer, instrText[1]));
switch(instrText[0])
@ -2220,7 +2220,7 @@ int quick6502_getinstruction(quick6502_cpu *cpu, char interpret,
static inline int quick6502_exec_one(quick6502_cpu *cpu)
{
register byte opcode = cpu->memory_opcode_read(cpu->reg_PC);
register uint8_t opcode = cpu->memory_opcode_read(cpu->reg_PC);
//char instr[100];
//quick6502_dump(cpu, stdout);

8
src/include/Sound.h
View File

@ -162,7 +162,7 @@ void ResumeSound(void);
/** Initialize sound. Returns Rate on success, 0 otherwise. **/
/** Rate=0 to skip initialization (will be silent). **/
/*************************************************************/
int InitSound(unsigned int Rate,unsigned int Latency);
int InitSound(uint32_t Rate,uint32_t Latency);
#endif /* MSDOS */
#ifdef WINDOWS
@ -181,7 +181,7 @@ int InitSound(unsigned int Rate,unsigned int Latency);
/** synthesis (waveOut). Number of wave synthesis buffers **/
/** must be in 2..SND_BUFFERS range. **/
/*************************************************************/
unsigned int InitSound(unsigned int Rate,unsigned int Delay);
uint32_t InitSound(uint32_t Rate,uint32_t Delay);
#endif /* WINDOWS */
@ -200,14 +200,14 @@ unsigned int InitSound(unsigned int Rate,unsigned int Delay);
/** rate. Returns Rate on success, 0 otherwise. Pass Rate=0 **/
/** to skip initialization and be silent. **/
/*************************************************************/
unsigned int InitSound(unsigned int Rate,unsigned int Delay);
uint32_t InitSound(uint32_t Rate,uint32_t Delay);
#endif
/** RenderAudio() ********************************************/
/** Render given number of melodic sound samples. Returns **/
/** number of samples actually rendered. **/
/*************************************************************/
unsigned int RenderAudio(unsigned int Samples);
uint32_t RenderAudio(uint32_t Samples);
/** SndDriver ************************************************/
/** Each sound driver should fill this structure with **/

20
src/include/corecpu.h
View File

@ -32,15 +32,15 @@
#include "types.h"
typedef byte (*quick6502_MemoryReadFunction)(unsigned short addr);
typedef void (*quick6502_MemoryWriteFunction)(unsigned short addr, byte value);
typedef uint8_t (*quick6502_MemoryReadFunction)(uint16_t addr);
typedef void (*quick6502_MemoryWriteFunction)(uint16_t addr, uint8_t value);
typedef struct quick6502_cpu_
{
/* 6502 registers */
byte reg_A, reg_X, reg_Y;
byte reg_P, reg_S;
unsigned short reg_PC;
uint8_t reg_A, reg_X, reg_Y;
uint8_t reg_P, reg_S;
uint16_t reg_PC;
/* Read/Write memory functions */
quick6502_MemoryReadFunction memory_read;
@ -53,12 +53,12 @@ typedef struct quick6502_cpu_
/* Timing related */
long cycle_done;
byte exit_loop;
byte int_pending;
uint8_t exit_loop;
uint8_t int_pending;
/* Other config options */
byte running; /* This field is used to prevent cpu free if this cpu is running */
byte page_crossed;
uint8_t running; /* This field is used to prevent cpu free if this cpu is running */
uint8_t page_crossed;
/* TODO add support for Inst/MemAccess breakpoints */
@ -152,7 +152,7 @@ void quick6502_dump(quick6502_cpu *cpu, FILE * fp);
#define MINE
int quick6502_getinstruction(quick6502_cpu *cpu, char interpret,
unsigned short addr, char *buffer, int *strlength);
uint16_t addr, char *buffer, int *strlength);
/**
* Free the CPU
*

18
src/include/mappers/manager.h
View File

@ -15,8 +15,8 @@
#include <NESCarts.h>
typedef int (*MapperInit) (NesCart * cart);
typedef int (*MapperWriteHook) (register unsigned short Addr,
register unsigned char Value);
typedef int (*MapperWriteHook) (register uint16_t Addr,
register uint8_t Value);
typedef int (*MapperIRQ) (int cycledone);
typedef void (*MapperDump) (FILE *fp);
@ -33,14 +33,14 @@ extern NesCart *Cart;
#define GETLAST16KBANK(c) ((c->PROMSize>>14)-1)
#define GETLAST32KBANK(c) ((c->PROMSize>>15)-1)
void set_vrom_bank_1k(unsigned short addr,int slot);
void set_vrom_bank_2k(unsigned short addr,int slot);
void set_vrom_bank_4k(unsigned short addr,int slot);
void set_vrom_bank_8k(unsigned short addr, int slot);
void set_vrom_bank_1k(uint16_t addr,int slot);
void set_vrom_bank_2k(uint16_t addr,int slot);
void set_vrom_bank_4k(uint16_t addr,int slot);
void set_vrom_bank_8k(uint16_t addr, int slot);
void set_prom_bank_8k(unsigned short addr,int slot);
void set_prom_bank_16k(unsigned short addr,int slot);
void set_prom_bank_32k(unsigned short addr,int slot);
void set_prom_bank_8k(uint16_t addr,int slot);
void set_prom_bank_16k(uint16_t addr,int slot);
void set_prom_bank_32k(uint16_t addr,int slot);
#else /* __TINES_MAPPERS__ */

40
src/include/memory/manager.h
View File

@ -18,45 +18,45 @@
#define ATTR_PAGE_GHOST 0x02
#define ATTR_PAGE_MAPPED 0x01
typedef byte (*func_rdhook)(byte /* addr */);
typedef void (*func_wrhook)(byte addr, byte data);
typedef uint8_t (*func_rdhook)(uint8_t /* addr */);
typedef void (*func_wrhook)(uint8_t addr, uint8_t data);
/* Functions to manage pages data */
void set_page_ptr(byte page, byte *ptr);
void set_page_ptr_1k(byte page, byte *ptr);
void set_page_ptr_2k(byte page, byte *ptr);
void set_page_ptr_4k(byte page, byte *ptr);
void set_page_ptr_8k(byte page, byte *ptr);
void set_page_ptr_16k(byte page, byte *ptr);
void set_page_ptr_32k(byte page, byte *ptr);
void set_page_ptr(uint8_t page, uint8_t *ptr);
void set_page_ptr_1k(uint8_t page, uint8_t *ptr);
void set_page_ptr_2k(uint8_t page, uint8_t *ptr);
void set_page_ptr_4k(uint8_t page, uint8_t *ptr);
void set_page_ptr_8k(uint8_t page, uint8_t *ptr);
void set_page_ptr_16k(uint8_t page, uint8_t *ptr);
void set_page_ptr_32k(uint8_t page, uint8_t *ptr);
byte *get_page_ptr(byte page);
uint8_t *get_page_ptr(uint8_t page);
/* Functions to set pages attributes */
void set_page_rd_hook(byte page, func_rdhook func);
void set_page_rd_hook(uint8_t page, func_rdhook func);
void set_page_wr_hook(byte page, func_wrhook func);
void set_page_wr_hook(uint8_t page, func_wrhook func);
void set_page_readable(byte page, bool value);
void set_page_readable(uint8_t page, uint8_t value);
void set_page_writeable(byte page, bool value);
void set_page_writeable(uint8_t page, uint8_t value);
void set_page_ghost(byte page, bool value, byte ghost);
void set_page_ghost(uint8_t page, uint8_t value, uint8_t ghost);
byte get_page_attributes(byte page);
uint8_t get_page_attributes(uint8_t page);
func_rdhook get_page_rdhook(byte page);
func_rdhook get_page_rdhook(uint8_t page);
func_wrhook get_page_wrhook(byte page);
func_wrhook get_page_wrhook(uint8_t page);
/* Generalist functions */
void InitMemory();
byte ReadMemory(byte page, byte addr);
void WriteMemory(byte page, byte addr, byte value);
uint8_t ReadMemory(uint8_t page, uint8_t addr);
void WriteMemory(uint8_t page, uint8_t addr, uint8_t value);
void DumpMemoryState(FILE *fp);

8
src/include/paddle.h
View File

@ -13,19 +13,19 @@
typedef struct Paddle_
{
unsigned char Bit;
uint8_t Bit;
unsigned char LastWrite;
uint8_t LastWrite;
} Paddle;
unsigned char ReadPaddle(Paddle * pdl);
uint8_t ReadPaddle(Paddle * pdl);
void InitPaddle(Paddle * pdl);
void WritePaddle(Paddle * pdl, unsigned char val);
void WritePaddle(Paddle * pdl, uint8_t val);
#endif

6
src/include/plugins/manager.h
View File

@ -20,13 +20,13 @@ typedef void (*PluginKeypress) (void);
#ifdef __TINES_PLUGINS__
/* Available functions for plugins */
int plugin_install_keypressHandler(byte key, PluginKeypress);
int plugin_remove_keypressHandler(byte key, PluginKeypress);
int plugin_install_keypressHandler(uint8_t key, PluginKeypress);
int plugin_remove_keypressHandler(uint8_t key, PluginKeypress);
#else /* __TINES_PLUGINS__ */
/* Available functions outside of plugins */
int plugin_keypress(byte key);
int plugin_keypress(uint8_t key);
/* Real Prototype: TBD */
void plugin_list();

2
src/include/ppu/ppu.h
View File

@ -54,7 +54,7 @@ void ppu_setScreenMode(uint8_t mode);
PPU_Sprite ppu_getSprite(uint16_t i);
unsigned char ppu_memoryRead(uint8_t page, uint8_t addr);
uint8_t ppu_memoryRead(uint8_t page, uint8_t addr);
void ppu_memoryWrite(uint8_t page, uint8_t addr, uint8_t value);
void ppu_debugSprites();

16
src/include/ppu/ppu.memory.h
View File

@ -11,18 +11,18 @@
int ppu_initMemory();
void ppu_setPagePtr (byte page, byte *ptr);
void ppu_setPagePtr1k(byte page, byte *ptr);
void ppu_setPagePtr2k(byte page, byte *ptr);
void ppu_setPagePtr4k(byte page, byte *ptr);
void ppu_setPagePtr8k(byte page, byte *ptr);
void ppu_setPagePtr (uint8_t page, uint8_t *ptr);
void ppu_setPagePtr1k(uint8_t page, uint8_t *ptr);
void ppu_setPagePtr2k(uint8_t page, uint8_t *ptr);
void ppu_setPagePtr4k(uint8_t page, uint8_t *ptr);
void ppu_setPagePtr8k(uint8_t page, uint8_t *ptr);
void ppu_memoryDumpState(FILE *fp);
byte ppu_readMemory(byte page, byte addr);
void ppu_writeMemory(byte page, byte addr, byte value);
uint8_t ppu_readMemory(uint8_t page, uint8_t addr);
void ppu_writeMemory(uint8_t page, uint8_t addr, uint8_t value);
void ppu_setPageGhost(byte page, bool value, byte ghost);
void ppu_setPageGhost(uint8_t page, uint8_t value, uint8_t ghost);
#else
#error Must only be included inside the PPU code

7
src/include/types.h
View File

@ -12,13 +12,6 @@
#include <stdint.h>
#ifndef BYTE_TYPE_DEFINED
#define BYTE_TYPE_DEFINED
typedef uint8_t byte;
#endif
typedef uint8_t bool;
#define true (0)
#define false (!true)

78
src/main.c
View File

@ -95,18 +95,18 @@ word latestop[MAXLASTOP];
quick6502_cpu *MainCPU;
NesCart *Cart;
byte *FDSRom;
byte *FDSRam;
uint8_t *FDSRom;
uint8_t *FDSRam;
/* Command line options */
byte START_DEBUG = 0;
byte START_WITH_FDS = 0;
uint8_t START_DEBUG = 0;
uint8_t START_WITH_FDS = 0;
char *CART_FILENAME = NULL;
char *PALETTE_FILENAME = NULL;
Paddle P1, P2;
unsigned short ScanLine;
uint16_t ScanLine;
volatile int frame = 0;
volatile uint64_t ccount;
@ -117,25 +117,25 @@ char WantClosing = 0;
struct timeval timeStart;
struct timeval timeEnd;
volatile unsigned long FPS, IPS;
volatile uint32_t FPS, IPS;
short IRQScanHit = -1;
short SZHit = -1;
/* palette */
unsigned long ColorPalette[ 8 * 63 ];
uint32_t ColorPalette[ 8 * 63 ];
#define SET_RGB(r,g,b) ((((r<<8)|g)<<8)|b)|0xFF000000
/* Memory functions */
byte MemoryRead (unsigned short Addr);
byte MemoryOpCodeRead (unsigned short Addr);
byte MemoryStackRead (unsigned short Addr);
byte MemoryPageZeroRead (unsigned short Addr);
uint8_t MemoryRead (uint16_t Addr);
uint8_t MemoryOpCodeRead (uint16_t Addr);
uint8_t MemoryStackRead (uint16_t Addr);
uint8_t MemoryPageZeroRead (uint16_t Addr);
void MemoryWrite (unsigned short Addr, byte Value);
void MemoryStackWrite (unsigned short Addr, byte Value);
void MemoryPageZeroWrite (unsigned short Addr, byte Value);
void MemoryWrite (uint16_t Addr, uint8_t Value);
void MemoryStackWrite (uint16_t Addr, uint8_t Value);
void MemoryPageZeroWrite (uint16_t Addr, uint8_t Value);
void Loop6502(quick6502_cpu *R);
@ -188,7 +188,7 @@ void LoadSaveRam(char *name)
void LoadPalette(char *filename, Palette *pal)
{
FILE *fp;
unsigned char r, v, b, i;
uint8_t r, v, b, i;
console_printf(Console_Default, "%s: try to load pallette file '%s'", __func__, filename);
if ((fp = fopen(filename, "rb")) != NULL)
{
@ -342,9 +342,9 @@ void signalhandler(int sig)
exit(-42);
}
byte Page40[256];
uint8_t Page40[256];
void WrHook4000Multiplexer(byte addr, byte value)
void WrHook4000Multiplexer(uint8_t addr, uint8_t value)
{
switch(addr)
{
@ -372,9 +372,9 @@ void WrHook4000Multiplexer(byte addr, byte value)
}
byte RdHook4000Multiplexer(byte addr)
uint8_t RdHook4000Multiplexer(uint8_t addr)
{
byte ret;
uint8_t ret;
switch(addr)
{
case 0x16:
@ -411,7 +411,7 @@ void printUsage(int argc, char *argv[])
int main(int argc, char *argv[])
{
int i;
unsigned char *MemoryPage;
uint8_t *MemoryPage;
quick6502_cpuconfig CpuConfig;
#ifdef RUN_COVERAGE
@ -514,7 +514,7 @@ int main(int argc, char *argv[])
console_printf(Console_Default, "Allocating 6502 memory\t\t");
/* Allocating first 0x7FF memory */
MemoryPage = (unsigned char *)malloc (0x800);
MemoryPage = (uint8_t *)malloc (0x800);
set_page_ptr_2k(0,MemoryPage);
for (i = 0; i < 0x08; i++)
{
@ -605,8 +605,8 @@ int main(int argc, char *argv[])
console_printf(Console_Error, "Error opcode @ 0x%X [w:%d,r:%d]\n", i, j, k);
}
#endif
/* SRAM (0x6000 : 0x2000 bytes ) */
MemoryPage = (unsigned char *)malloc (0x2000);
/* SRAM (0x6000 : 0x2000 uint8_ts ) */
MemoryPage = (uint8_t *)malloc (0x2000);
set_page_ptr_8k(0x60, MemoryPage);
@ -668,7 +668,7 @@ int main(int argc, char *argv[])
console_printf(Console_Default, "Allocating FDS RAM...\n");
FDSRam = (byte*) malloc( (8+16) * 1024);
FDSRam = (uint8_t*) malloc( (8+16) * 1024);
if (FDSRam == NULL)
{
@ -781,55 +781,55 @@ int main(int argc, char *argv[])
}
/* Access directly to Memory pages *HACKISH* */
extern byte *memory_pages[0xFF];
extern uint8_t *memory_pages[0xFF];
/* Memory functions */
/* Read memory, general function */
byte MemoryRead (unsigned short Addr)
uint8_t MemoryRead (uint16_t Addr)
{
return ReadMemory((Addr&0xFF00)>>8,Addr&0x00FF);
}
/* Read memory for opcode (need fast access) */
byte MemoryOpCodeRead (unsigned short Addr)
uint8_t MemoryOpCodeRead (uint16_t Addr)
{
byte *ptr;
return ((ptr = memory_pages[(Addr&0xFF00)>>8])>(byte*)1)?ptr[Addr&0x00FF]:0xEA;
uint8_t *ptr;
return ((ptr = memory_pages[(Addr&0xFF00)>>8])>(uint8_t*)1)?ptr[Addr&0x00FF]:0xEA;
}
byte MemoryStackRead (unsigned short Addr)
uint8_t MemoryStackRead (uint16_t Addr)
{
byte *ptr = memory_pages[1];
uint8_t *ptr = memory_pages[1];
return ptr[Addr&0x00FF];
}
byte MemoryPageZeroRead (unsigned short Addr)
uint8_t MemoryPageZeroRead (uint16_t Addr)
{
byte *ptr = memory_pages[0];
uint8_t *ptr = memory_pages[0];
return ptr[Addr&0x00FF];
}
/* Write to memory, general function */
void MemoryWrite (unsigned short Addr, byte Value)
void MemoryWrite (uint16_t Addr, uint8_t Value)
{
WriteMemory((Addr&0xFF00)>>8,Addr&0x00FF, Value);
}
void MemoryStackWrite (unsigned short Addr, byte Value)
void MemoryStackWrite (uint16_t Addr, uint8_t Value)
{
byte *ptr = memory_pages[1];
uint8_t *ptr = memory_pages[1];
ptr[Addr&0x00FF] = Value;
}
void MemoryPageZeroWrite (unsigned short Addr, byte Value)
void MemoryPageZeroWrite (uint16_t Addr, uint8_t Value)
{
byte *ptr = memory_pages[0];
uint8_t *ptr = memory_pages[0];
ptr[Addr&0x00FF] = Value;
}
void Loop6502(quick6502_cpu *R)
{
byte ret;
uint8_t ret;
// short skey;
long WaitTime;
static long delta=0;

2
src/mappersmanager/manager.c
View File

@ -20,7 +20,7 @@ MapperWriteHook mapper_hook;
typedef struct Mapper_
{
byte id;
uint8_t id;
char *name;
MapperInit init;

8
src/mappersmanager/mappers/aorom.c
View File

@ -9,11 +9,11 @@
#include "aorom.h"
unsigned char aorom_load_bank;
uint8_t aorom_load_bank;
void aorom_MapperWriteHook(register byte Addr, register byte Value);
void aorom_MapperWriteHook(register uint8_t Addr, register uint8_t Value);
extern byte *ppu_mem_nameTables;
extern uint8_t *ppu_mem_nameTables;
int aorom_InitMapper(NesCart * cart)
{
@ -37,7 +37,7 @@ int aorom_InitMapper(NesCart * cart)
}
void aorom_MapperWriteHook(register byte Addr, register byte Value)
void aorom_MapperWriteHook(register uint8_t Addr, register uint8_t Value)
{
int BankNb;

6
src/mappersmanager/mappers/cnrom.c
View File

@ -9,9 +9,9 @@
#include "cnrom.h"
unsigned char cnrom_load_bank;
uint8_t cnrom_load_bank;
void cnrom_MapperWriteHook(register byte Addr, register byte Value);
void cnrom_MapperWriteHook(register uint8_t Addr, register uint8_t Value);
int cnrom_InitMapper(NesCart * cart)
{
@ -32,7 +32,7 @@ int cnrom_InitMapper(NesCart * cart)
}
void cnrom_MapperWriteHook(register byte Addr, register byte Value)
void cnrom_MapperWriteHook(register uint8_t Addr, register uint8_t Value)
{
set_prom_bank_16k(0x8000,Value);
cnrom_load_bank = Value;

2
src/mappersmanager/mappers/genericmapper.c.template
View File

@ -17,7 +17,7 @@ int _InitMapper(NesCart * cart)
}
int _MapperWriteHook(register word Addr, register byte Value)
int _MapperWriteHook(register word Addr, register uint8_t Value)
{
if (Addr > 0x7FFF) /* Try to write to the rom */

6
src/mappersmanager/mappers/iremh3001.c
View File

@ -9,9 +9,9 @@
#include "iremh3001.h"
unsigned short iremh3001_prom_slot[3];
uint16_t iremh3001_prom_slot[3];
unsigned short iremh3001_vrom_slot[8];
uint16_t iremh3001_vrom_slot[8];
int iremh3001_InitMapper(NesCart * cart)
{
@ -38,7 +38,7 @@ int iremh3001_InitMapper(NesCart * cart)
}
int iremh3001_MapperWriteHook(register byte Addr, register byte Value)
int iremh3001_MapperWriteHook(register uint8_t Addr, register uint8_t Value)
{
#if 0
switch(Addr)

16
src/mappersmanager/mappers/mmc1.c
View File

@ -44,10 +44,10 @@ uint8_t mmc1_CurrentBank;
#define MMC1_REG2_DEFAULT 0
#define MMC1_REG3_DEFAULT 0
void mmc1_MapperWriteReg0(register byte Addr, register byte Value);
void mmc1_MapperWriteReg1(register byte Addr, register byte Value);
void mmc1_MapperWriteReg2(register byte Addr, register byte Value);
void mmc1_MapperWriteReg3(register byte Addr, register byte Value);
void mmc1_MapperWriteReg0(register uint8_t Addr, register uint8_t Value);
void mmc1_MapperWriteReg1(register uint8_t Addr, register uint8_t Value);
void mmc1_MapperWriteReg2(register uint8_t Addr, register uint8_t Value);
void mmc1_MapperWriteReg3(register uint8_t Addr, register uint8_t Value);
void mmc1_MapperDump(FILE *fp)
{
@ -181,7 +181,7 @@ uint32_t VROMBankNb;
uint8_t Bit = 0;
uint8_t BitBuf = 0;
void mmc1_MapperWriteReg0(register byte Addr, register byte Value)
void mmc1_MapperWriteReg0(register uint8_t Addr, register uint8_t Value)
{
if (Value & 0x80)
{
@ -208,7 +208,7 @@ void mmc1_MapperWriteReg0(register byte Addr, register byte Value)
}
}
void mmc1_MapperWriteReg1(register byte Addr, register byte Value)
void mmc1_MapperWriteReg1(register uint8_t Addr, register uint8_t Value)
{
if (Value & 0x80)
{
@ -251,7 +251,7 @@ void mmc1_MapperWriteReg1(register byte Addr, register byte Value)
}
}
void mmc1_MapperWriteReg2(register byte Addr, register byte Value)
void mmc1_MapperWriteReg2(register uint8_t Addr, register uint8_t Value)
{
if (Value & 0x80)
{
@ -295,7 +295,7 @@ void mmc1_MapperWriteReg2(register byte Addr, register byte Value)
}
}
void mmc1_MapperWriteReg3(register byte Addr, register byte Value)
void mmc1_MapperWriteReg3(register uint8_t Addr, register uint8_t Value)
{
if (Value & 0x80)
{

40
src/mappersmanager/mappers/mmc3.c
View File

@ -8,29 +8,29 @@
*/
#include "mmc3.h"
extern unsigned short ScanLine;
extern uint16_t ScanLine;
unsigned short mmc3_command;
uint16_t mmc3_command;
unsigned char mmc3_irq_counter;
unsigned char mmc3_irq_counter_reload;
unsigned char mmc3_irq_enable;
uint8_t mmc3_irq_counter;
uint8_t mmc3_irq_counter_reload;
uint8_t mmc3_irq_enable;
unsigned short mmc3_first_prom_page;
unsigned short mmc3_second_prom_page;
uint16_t mmc3_first_prom_page;
uint16_t mmc3_second_prom_page;
unsigned char mmc3_use_xor;
unsigned char mmc3_last_vrom[6];
uint8_t mmc3_use_xor;
uint8_t mmc3_last_vrom[6];
unsigned char mmc3_last_prom[2];
unsigned char mmc3_last_prom_switch;
uint8_t mmc3_last_prom[2];
uint8_t mmc3_last_prom_switch;
unsigned short dummy;
uint16_t dummy;
void mmc3_MapperWrite80Hook(byte addr, byte value);
void mmc3_MapperWriteA0Hook(byte addr, byte value);
void mmc3_MapperWriteC0Hook(byte addr, byte value);
void mmc3_MapperWriteE0Hook(byte addr, byte value);
void mmc3_MapperWrite80Hook(uint8_t addr, uint8_t value);
void mmc3_MapperWriteA0Hook(uint8_t addr, uint8_t value);
void mmc3_MapperWriteC0Hook(uint8_t addr, uint8_t value);
void mmc3_MapperWriteE0Hook(uint8_t addr, uint8_t value);
void mmc3_MapperDump(FILE *fp)
{
@ -88,7 +88,7 @@ int mmc3_InitMapper(NesCart * cart)
return 0;
}
void mmc3_MapperWrite80Hook(byte addr, byte Value)
void mmc3_MapperWrite80Hook(uint8_t addr, uint8_t Value)
{
//console_printf(Console_Default, "%s(0x%02X, 0x%02X)\n", __func__, addr, Value);
if (addr > 0x01)
@ -216,7 +216,7 @@ void mmc3_MapperWrite80Hook(byte addr, byte Value)
}
void mmc3_MapperWriteA0Hook(byte addr, byte Value)
void mmc3_MapperWriteA0Hook(uint8_t addr, uint8_t Value)
{
//console_printf(Console_Default, "%s(0x%02X, 0x%02X)\n", __func__, addr, Value);
if (addr > 0x01)
@ -243,7 +243,7 @@ void mmc3_MapperWriteA0Hook(byte addr, byte Value)
}
void mmc3_MapperWriteC0Hook(byte addr, byte Value)
void mmc3_MapperWriteC0Hook(uint8_t addr, uint8_t Value)
{
//console_printf(Console_Default, "%s(0x%02X, 0x%02X)\n", __func__, addr, Value);
if (addr > 0x01)
@ -262,7 +262,7 @@ void mmc3_MapperWriteC0Hook(byte addr, byte Value)
}
}
void mmc3_MapperWriteE0Hook(byte addr, byte Value)
void mmc3_MapperWriteE0Hook(uint8_t addr, uint8_t Value)
{
//console_printf(Console_Default, "%s(0x%02X, 0x%02X)\n", __func__, addr, Value);
if (addr > 0x01)

24
src/mappersmanager/mappers/mmc4.c
View File

@ -9,12 +9,12 @@
#include "mmc4.h"
byte mmc4_RegA;
byte mmc4_RegB;
byte mmc4_RegC;
byte mmc4_RegD;
byte mmc4_RegE;
byte mmc4_RegF;
uint8_t mmc4_RegA;
uint8_t mmc4_RegB;
uint8_t mmc4_RegC;
uint8_t mmc4_RegD;
uint8_t mmc4_RegE;
uint8_t mmc4_RegF;
#ifdef DEBUG
#define LOG(s) printf s
@ -24,7 +24,7 @@ byte mmc4_RegF;
/* MAPPER WARNING: This mapper need to attach to the PPU memory... Need more work on this parts.. */
void mmc4_MapperWriteRegA(register byte Addr, register byte Value)
void mmc4_MapperWriteRegA(register uint8_t Addr, register uint8_t Value)
{
LOG(("%s(%02X, %02X)\n", __func__, Addr, Value));
mmc4_RegA = Value;
@ -33,7 +33,7 @@ void mmc4_MapperWriteRegA(register byte Addr, register byte Value)
}
void mmc4_MapperWriteRegB(register byte Addr, register byte Value)
void mmc4_MapperWriteRegB(register uint8_t Addr, register uint8_t Value)
{
LOG(("%s(%02X, %02X)\n", __func__, Addr, Value));
mmc4_RegB = Value;
@ -41,28 +41,28 @@ void mmc4_MapperWriteRegB(register byte Addr, register byte Value)
set_vrom_bank_4k(0x0000, Value & 0x1F);
}
void mmc4_MapperWriteRegC(register byte Addr, register byte Value)
void mmc4_MapperWriteRegC(register uint8_t Addr, register uint8_t Value)
{
LOG(("%s(%02X, %02X)\n", __func__, Addr, Value));
mmc4_RegC = Value;
set_vrom_bank_4k(0x0000, Value & 0x1F);
}
void mmc4_MapperWriteRegD(register byte Addr, register byte Value)
void mmc4_MapperWriteRegD(register uint8_t Addr, register uint8_t Value)
{
LOG(("%s(%02X, %02X)\n", __func__, Addr, Value));
mmc4_RegD = Value;
set_vrom_bank_4k(0x1000, Value & 0x1F);
}
void mmc4_MapperWriteRegE(register byte Addr, register byte Value)
void mmc4_MapperWriteRegE(register uint8_t Addr, register uint8_t Value)
{
LOG(("%s(%02X, %02X)\n", __func__, Addr, Value));
mmc4_RegE = Value;
set_vrom_bank_4k(0x1000, Value & 0x1F);
}
void mmc4_MapperWriteRegF(register byte Addr, register byte Value)
void mmc4_MapperWriteRegF(register uint8_t Addr, register uint8_t Value)
{
LOG(("%s(%02X, %02X)\n", __func__, Addr, Value));
mmc4_RegF = Value;

2
src/mappersmanager/mappers/norom.c
View File

@ -34,7 +34,7 @@ int norom_MapperIRQ(int cycledone)
return 0;
}
void norom_MapperWriteHook(register byte Addr, register byte Value)
void norom_MapperWriteHook(register uint8_t Addr, register uint8_t Value)
{
/* Nothing to do */
return;

6
src/mappersmanager/mappers/unrom.c
View File

@ -9,9 +9,9 @@
#include "unrom.h"
unsigned char unrom_load_vbank;
uint8_t unrom_load_vbank;
void unrom_MapperWriteHook(byte Addr, byte Value);
void unrom_MapperWriteHook(uint8_t Addr, uint8_t Value);
int unrom_InitMapper(NesCart * cart)
{
@ -36,7 +36,7 @@ int unrom_InitMapper(NesCart * cart)
}
void unrom_MapperWriteHook(byte Addr, byte Value)
void unrom_MapperWriteHook(uint8_t Addr, uint8_t Value)
{
set_vrom_bank_8k(0x0000,Value);
unrom_load_vbank = Value;

10
src/mappersmanager/mappers/unrom512.c
View File

@ -10,16 +10,16 @@
#include <ppu/ppu.h>
#include "unrom512.h"
static byte mirroring_set;
static byte loaded_vbank;
static byte loaded_pbank;
static uint8_t mirroring_set;
static uint8_t loaded_vbank;
static uint8_t loaded_pbank;
/*
* not great but as we currently don't support higher than 8K VRAM, allocate it here as we can have
* 32K on such a cart
*/
static uint8_t vram[32768];
void ppu_setPagePtr8k(byte page, byte *ptr);
void ppu_setPagePtr8k(uint8_t page, uint8_t *ptr);
static void unrom512_applyValues()
{
@ -36,7 +36,7 @@ static void unrom512_applyValues()
set_prom_bank_16k(0x8000, loaded_pbank);
}
static void unrom512_MapperWriteHook(byte Addr, byte Value)
static void unrom512_MapperWriteHook(uint8_t Addr, uint8_t Value)
{
mirroring_set = (Value >> 7) & 0x01;
loaded_vbank = (Value >> 5) & 0x03;

2
src/mappersmanager/unused/genericmapper.h
View File

@ -17,7 +17,7 @@ int _InitMapper(NesCart * cart)
}
int _MapperWriteHook(register word Addr, register byte Value)
int _MapperWriteHook(register word Addr, register uint8_t Value)
{
if (Addr > 0x7FFF) /* Try to write to the rom */

32
src/mappersmanager/unused/mmc1.h
View File

@ -6,15 +6,15 @@
* Copyright (c) 2003-2008 986Corp. All rights reserved.
*
*/
unsigned char MMC1_reg0;
uint8_t MMC1_reg0;
unsigned char MMC1_reg1;
uint8_t MMC1_reg1;
unsigned char MMC1_reg2;
uint8_t MMC1_reg2;
unsigned char MMC1_reg3;
uint8_t MMC1_reg3;
unsigned char mmc1_CurrentBank;
uint8_t mmc1_CurrentBank;
#define MMC1_R0_MIRROR 0x01
#define MMC1_R0_ONESCREEN 0x02
@ -42,10 +42,10 @@ unsigned char mmc1_CurrentBank;
#define MMC1_REG3_DEFAULT 0
void mmc1_MapperWriteReg0(register byte Addr, register byte Value);
void mmc1_MapperWriteReg1(register byte Addr, register byte Value);
void mmc1_MapperWriteReg2(register byte Addr, register byte Value);
void mmc1_MapperWriteReg3(register byte Addr, register byte Value);
void mmc1_MapperWriteReg0(register uint8_t Addr, register uint8_t Value);
void mmc1_MapperWriteReg1(register uint8_t Addr, register uint8_t Value);
void mmc1_MapperWriteReg2(register uint8_t Addr, register uint8_t Value);
void mmc1_MapperWriteReg3(register uint8_t Addr, register uint8_t Value);
void mmc1_MapperDump(FILE *fp)
{
@ -128,7 +128,7 @@ Reg 0
void mmc1_ApplyReg0Mod()
{
static unsigned char OldSwitchArea = MMC1_R0_PRGAREA;
static uint8_t OldSwitchArea = MMC1_R0_PRGAREA;
@ -176,10 +176,10 @@ void mmc1_ApplyReg0Mod()
}
int VROMBankNb;
unsigned char Bit = 0;
unsigned char BitBuf = 0;
uint8_t Bit = 0;
uint8_t BitBuf = 0;
void mmc1_MapperWriteReg0(register byte Addr, register byte Value)
void mmc1_MapperWriteReg0(register uint8_t Addr, register uint8_t Value)
{
if (Value & 0x80)
{
@ -206,7 +206,7 @@ void mmc1_MapperWriteReg0(register byte Addr, register byte Value)
}
}
void mmc1_MapperWriteReg1(register byte Addr, register byte Value)
void mmc1_MapperWriteReg1(register uint8_t Addr, register uint8_t Value)
{
if (Value & 0x80)
{
@ -249,7 +249,7 @@ void mmc1_MapperWriteReg1(register byte Addr, register byte Value)
}
}
void mmc1_MapperWriteReg2(register byte Addr, register byte Value)
void mmc1_MapperWriteReg2(register uint8_t Addr, register uint8_t Value)
{
if (Value & 0x80)
{
@ -293,7 +293,7 @@ void mmc1_MapperWriteReg2(register byte Addr, register byte Value)
}
}
void mmc1_MapperWriteReg3(register byte Addr, register byte Value)
void mmc1_MapperWriteReg3(register uint8_t Addr, register uint8_t Value)
{
if (Value & 0x80)
{

20
src/mappersmanager/utils.c
View File

@ -30,45 +30,41 @@ extern char MapperWantIRQ;
Here are some fonction useful for mappers
*/
void set_vrom_bank_1k(unsigned short addr,int slot)
void set_vrom_bank_1k(uint16_t addr,int slot)
{
#ifdef DEBUG_VROM_BANK_SWITCH
console_printf(Console_Default, "Change vrom 1k bank 0x%X to slot %d\n",addr,slot);
#endif
ppu_setPagePtr1k((addr>>8)&0xFF, Cart->VROMBanks + (slot * 1024));
// memcpy(ppu.Memory+addr, Cart->VROMBanks + (slot * 1024), 0x0400);
}
void set_vrom_bank_2k(unsigned short addr,int slot)
void set_vrom_bank_2k(uint16_t addr,int slot)
{
#ifdef DEBUG_VROM_BANK_SWITCH
console_printf(Console_Default, "Change vrom 2k bank 0x%X to slot %d\n",addr,slot);
#endif
ppu_setPagePtr2k((addr>>8)&0xFF, Cart->VROMBanks + (slot * 2 * 1024));
// memcpy(ppu.Memory+addr, Cart->VROMBanks + (slot * 2 * 1024), 0x0800);
}
void set_vrom_bank_4k(unsigned short addr,int slot)
void set_vrom_bank_4k(uint16_t addr,int slot)
{
#ifdef DEBUG_VROM_BANK_SWITCH
console_printf(Console_Default, "Change vrom 4k bank 0x%X to slot %d\n",addr,slot);
#endif
ppu_setPagePtr4k((addr>>8)&0xFF, Cart->VROMBanks + (slot * 4 * 1024));
// memcpy(ppu.Memory+addr, Cart->VROMBanks + (slot * 4 * 1024), 0x1000);
}
void set_vrom_bank_8k(unsigned short addr, int slot)
void set_vrom_bank_8k(uint16_t addr, int slot)
{
#ifdef DEBUG_VROM_BANK_SWITCH
console_printf(Console_Default, "Change vrom 8k bank 0x%X to slot %d\n",addr,slot);
#endif
ppu_setPagePtr8k(0x00, Cart->VROMBanks + (slot * 8 * 1024));
// memcpy(ppu.Memory, Cart->VROMBanks + (slot * 8 * 1024) , 0x2000);
}
/*-----------*/
void set_prom_bank_8k(unsigned short addr,int slot)
void set_prom_bank_8k(uint16_t addr,int slot)
{
#ifdef DEBUG_PROM_BANK_SWITCH
console_printf(Console_Default, "Change prom 8k bank 0x%X to slot %d\n",addr,slot);
@ -76,7 +72,7 @@ void set_prom_bank_8k(unsigned short addr,int slot)
set_page_ptr_8k(addr >> 8, Cart->PROMBanks + (slot * 8 * 1024));
}
void set_prom_bank_16k(unsigned short addr,int slot)
void set_prom_bank_16k(uint16_t addr,int slot)
{
#ifdef DEBUG_PROM_BANK_SWITCH
console_printf(Console_Default, "Change prom 16k bank @ 0x%X [0x%X] to slot 0x%X\n",addr, addr>>8,slot);
@ -84,15 +80,13 @@ void set_prom_bank_16k(unsigned short addr,int slot)
set_page_ptr_16k(addr >> 8, Cart->PROMBanks + (slot * 16 * 1024));
}
void set_prom_bank_32k(unsigned short addr,int slot)
void set_prom_bank_32k(uint16_t addr,int slot)
{ /* addr may not be different from 0x8000 !*/
/* Anyway I don't use it */
#ifdef DEBUG_PROM_BANK_SWITCH
console_printf(Console_Default, "Change prom 32k bank 0x%X to slot %d\n",addr,slot);
#endif
set_page_ptr_32k(addr >> 8, Cart->PROMBanks + (slot * 32 * 1024));
/* set_page_ptr_16k(0x80, Cart->PROMBanks[(slot<<1)]);
set_page_ptr_16k(0xC0, Cart->PROMBanks[(slot<<1)+1]);*/
}

74
src/memorymanager/memory.c
View File

@ -16,7 +16,7 @@
/* Private structures */
#define KBYTE * (1024)
#define Kuint8_t * (1024)
/*
* What inside memory manager:
@ -29,8 +29,8 @@
/* Private data */
byte *memory_pages[0x100];
byte memory_pages_attr[0x100];
uint8_t *memory_pages[0x100];
uint8_t memory_pages_attr[0x100];
func_rdhook rdh_table[0x100];
func_wrhook wrh_table[0x100];
@ -45,13 +45,13 @@ func_wrhook wrh_table[0x100];
#endif
/* Public functions */
void set_page_ptr(byte page, byte *ptr)
void set_page_ptr(uint8_t page, uint8_t *ptr)
{
LOG(console_printf(Console_Default, "Set page 0x%X to ptr %p\n", page, ptr));
memory_pages[page] = ptr;
}
void set_page_ptr_1k(byte page, byte *ptr)
void set_page_ptr_1k(uint8_t page, uint8_t *ptr)
{ /* 1k = 4 * 256 */
LOG(console_printf(Console_Default, "Set page(1k) 0x%X to ptr %p\n", page, ptr));
memory_pages[page + 0] = ptr;
@ -60,7 +60,7 @@ void set_page_ptr_1k(byte page, byte *ptr)
memory_pages[page + 3] = ptr + (0x100 * 3);
}
void set_page_ptr_2k(byte page, byte *ptr)
void set_page_ptr_2k(uint8_t page, uint8_t *ptr)
{
LOG(console_printf(Console_Default, "Set page(2k) 0x%X to ptr %p\n", page, ptr));
memory_pages[page + 0] = ptr;
@ -73,33 +73,33 @@ void set_page_ptr_2k(byte page, byte *ptr)
memory_pages[page + 7] = ptr + (0x100 * 7);
}
void set_page_ptr_4k(byte page, byte *ptr)
void set_page_ptr_4k(uint8_t page, uint8_t *ptr)
{
LOG(console_printf(Console_Default, "Set page(4k) 0x%X to ptr %p\n", page, ptr));
set_page_ptr_2k(page, ptr);
set_page_ptr_2k(page+((4 KBYTE / 256) / 2), ptr + 2 KBYTE);
set_page_ptr_2k(page+((4 Kuint8_t / 256) / 2), ptr + 2 Kuint8_t);
}
void set_page_ptr_8k(byte page, byte *ptr)
void set_page_ptr_8k(uint8_t page, uint8_t *ptr)
{
LOG(console_printf(Console_Default, "Set page(8k) 0x%X to ptr %p\n", page, ptr));
set_page_ptr_4k(page, ptr);
set_page_ptr_4k(page+((8 KBYTE / 256) / 2), ptr + 4 KBYTE);
set_page_ptr_4k(page+((8 Kuint8_t / 256) / 2), ptr + 4 Kuint8_t);
}
void set_page_ptr_16k(byte page, byte *ptr)
void set_page_ptr_16k(uint8_t page, uint8_t *ptr)
{
set_page_ptr_8k(page, ptr);
set_page_ptr_8k(page+((16 KBYTE / 256) / 2), ptr + 8 KBYTE);
set_page_ptr_8k(page+((16 Kuint8_t / 256) / 2), ptr + 8 Kuint8_t);
}
void set_page_ptr_32k(byte page, byte *ptr)
void set_page_ptr_32k(uint8_t page, uint8_t *ptr)
{
set_page_ptr_16k(page, ptr);
set_page_ptr_16k(page+((32 KBYTE / 256) / 2), ptr + 16 KBYTE);
set_page_ptr_16k(page+((32 Kuint8_t / 256) / 2), ptr + 16 Kuint8_t);
}
byte *get_page_ptr(byte page)
uint8_t *get_page_ptr(uint8_t page)
{
return memory_pages[page];
}
@ -107,30 +107,30 @@ byte *get_page_ptr(byte page)
/* Functions to set pages attributes */
void set_page_rd_hook(byte page, func_rdhook func)
void set_page_rd_hook(uint8_t page, func_rdhook func)
{
if (func == NULL)
{
memory_pages_attr[page] &= (~ATTR_PAGE_HAVE_RDHOOK);
if (memory_pages[page] == (byte *)0x01)
if (memory_pages[page] == (uint8_t *)0x01)
memory_pages[page] = NULL;
}
else
{
memory_pages_attr[page] |= ATTR_PAGE_HAVE_RDHOOK;
if (memory_pages[page] == NULL)
memory_pages[page] = (byte *)0x01;
memory_pages[page] = (uint8_t *)0x01;
}
rdh_table[page] = func;
}
void set_page_wr_hook(byte page, func_wrhook func)
void set_page_wr_hook(uint8_t page, func_wrhook func)
{
if (func == NULL)
{
memory_pages_attr[page] &= (~ATTR_PAGE_HAVE_WRHOOK);
if (memory_pages[page] == (byte*)0x01)
if (memory_pages[page] == (uint8_t*)0x01)
memory_pages[page] = NULL;
}
@ -138,13 +138,13 @@ void set_page_wr_hook(byte page, func_wrhook func)
{
memory_pages_attr[page] |= ATTR_PAGE_HAVE_WRHOOK;
if (memory_pages[page] == NULL)
memory_pages[page] = (byte *)0x01;
memory_pages[page] = (uint8_t *)0x01;
}
wrh_table[page] = func;
}
void set_page_readable(byte page, bool value)
void set_page_readable(uint8_t page, uint8_t value)
{
if (value == true)
memory_pages_attr[page] |= ATTR_PAGE_READABLE;
@ -152,7 +152,7 @@ void set_page_readable(byte page, bool value)
memory_pages_attr[page] &= (~ATTR_PAGE_READABLE);
}
void set_page_writeable(byte page, bool value)
void set_page_writeable(uint8_t page, uint8_t value)
{
if (value == true)
memory_pages_attr[page] |= ATTR_PAGE_WRITEABLE;
@ -160,7 +160,7 @@ void set_page_writeable(byte page, bool value)
memory_pages_attr[page] &= (~ATTR_PAGE_WRITEABLE);
}
void set_page_ghost(byte page, bool value, byte ghost)
void set_page_ghost(uint8_t page, uint8_t value, uint8_t ghost)
{
if (value == true)
{
@ -171,12 +171,12 @@ void set_page_ghost(byte page, bool value, byte ghost)
}
}
byte get_page_attributes(byte page)
uint8_t get_page_attributes(uint8_t page)
{
return memory_pages_attr[page];
}
func_rdhook get_page_rdhook(byte page)
func_rdhook get_page_rdhook(uint8_t page)
{
if (memory_pages_attr[page] & ATTR_PAGE_HAVE_RDHOOK)
return rdh_table[page];
@ -184,7 +184,7 @@ func_rdhook get_page_rdhook(byte page)
return NULL;
}
func_wrhook get_page_wrhook(byte page)
func_wrhook get_page_wrhook(uint8_t page)
{
if (memory_pages_attr[page] & ATTR_PAGE_HAVE_WRHOOK)
return wrh_table[page];
@ -192,11 +192,11 @@ func_wrhook get_page_wrhook(byte page)
return NULL;
}
byte ReadMemory(byte page, byte addr)
uint8_t ReadMemory(uint8_t page, uint8_t addr)
{
static byte LastRetByte = 0xA5;
byte *page_ptr;
byte attributes;
static uint8_t LastRetuint8_t = 0xA5;
uint8_t *page_ptr;
uint8_t attributes;
LOG(console_printf(Console_Default, "Read @ 0x%X-%X\n", page, addr));
/* Est-ce que la page est mappé ? && Est-ce que la page est "readable" ? */
if ((page_ptr = memory_pages[page]) &&
@ -204,18 +204,18 @@ byte ReadMemory(byte page, byte addr)
{
LOG(console_printf(Console_Default, "Page is non null & readable\n"));
if ( attributes & ATTR_PAGE_HAVE_RDHOOK )
return ( LastRetByte = rdh_table[page](addr) );
return ( LastRetuint8_t = rdh_table[page](addr) );
else
return ( LastRetByte = page_ptr[addr] );
return ( LastRetuint8_t = page_ptr[addr] );
}
//console_printf(Console_Default, "Trying to read @ 0x%X-%X\n", page, addr);
return LastRetByte;
return LastRetuint8_t;
}
void WriteMemory(byte page, byte addr, byte value)
void WriteMemory(uint8_t page, uint8_t addr, uint8_t value)
{
byte *page_ptr;
byte attributes;
uint8_t *page_ptr;
uint8_t attributes;
LOG(console_printf(Console_Default, "Write 0x%x @ 0x%X-%X\n", value, page, addr));
/* Est-ce que la page est mappé ? && Est-ce que la page est "writable" ? */
if ( (page_ptr = memory_pages[page]) &&

14
src/os/unix/graphics.c
View File

@ -27,9 +27,9 @@ typedef struct GLWindow_t GLWindow;
struct KeyArray
{
unsigned char lastState;
unsigned char curState;
unsigned char debounced;
uint8_t lastState;
uint8_t curState;
uint8_t debounced;
GLFWwindow* window;
};
@ -37,7 +37,7 @@ struct GLWindow_t
{
struct KeyArray keyArray[512];
GLFWwindow* windows;
unsigned char *videoMemory;
uint8_t *videoMemory;
GLint videoTexture;
int WIDTH;
int HEIGHT;
@ -83,8 +83,8 @@ void ShowScreen(GLWindow *g, int w, int h)
void setupGL(GLWindow *g, int w, int h)
{
g->videoMemory = (unsigned char*)malloc(w*h*sizeof(unsigned int));
memset(g->videoMemory, 0,w*h*sizeof(unsigned int));
g->videoMemory = (uint8_t*)malloc(w*h*sizeof(uint32_t));
memset(g->videoMemory, 0,w*h*sizeof(uint32_t));
//Tell OpenGL how to convert from coordinates to pixel values
glViewport(0, 0, w, h);
@ -405,7 +405,7 @@ int graphics_init()
return 0;
}
static unsigned long getColour(long color)
static uint32_t getColour(long color)
{
Palette *pal = &basicPalette[color];
uint8_t r, g, b, a;

8
src/os/unix/graphics_dummy.c
View File

@ -22,16 +22,16 @@ typedef struct GLWindow_t GLWindow;
struct KeyArray
{
unsigned char lastState;
unsigned char curState;
unsigned char debounced;
uint8_t lastState;
uint8_t curState;
uint8_t debounced;
};
struct GLWindow_t
{
struct KeyArray keyArray[512];
GLFWwindow* windows;
unsigned char *videoMemory;
uint8_t *videoMemory;
GLint videoTexture;
int WIDTH;
int HEIGHT;

14
src/os/win32/graphics.c
View File

@ -22,9 +22,9 @@ typedef struct GLWindow_t GLWindow;
struct KeyArray
{
unsigned char lastState;
unsigned char curState;
unsigned char debounced;
uint8_t lastState;
uint8_t curState;
uint8_t debounced;
GLFWwindow* window;
};
@ -32,7 +32,7 @@ struct GLWindow_t
{
struct KeyArray keyArray[512];
GLFWwindow* windows;
unsigned char *videoMemory;
uint8_t *videoMemory;
GLint videoTexture;
int WIDTH;
int HEIGHT;
@ -82,8 +82,8 @@ void ShowScreen(GLWindow *g, int w, int h)
void setupGL(GLWindow *g, int w, int h)
{
g->videoMemory = (unsigned char*)malloc(w*h*sizeof(unsigned int));
memset(g->videoMemory, 0,w*h*sizeof(unsigned int));
g->videoMemory = (uint8_t*)malloc(w*h*sizeof(uint32_t));
memset(g->videoMemory, 0,w*h*sizeof(uint32_t));
//Tell OpenGL how to convert from coordinates to pixel values
glViewport(0, 0, w, h);
@ -396,7 +396,7 @@ int graphics_init()
return 0;
}
static unsigned long getColour(long color)
static uint32_t getColour(long color)
{
Palette *pal = &basicPalette[color];
uint8_t r, g, b, a;

4
src/paddle.c
View File

@ -18,7 +18,7 @@ void InitPaddle(Paddle *pdl)
}
void WritePaddle(Paddle *pdl, unsigned char val)
void WritePaddle(Paddle *pdl, uint8_t val)
{
if ( ( pdl->LastWrite == 1 ) && ( val == 0 ) )
InitPaddle(pdl);
@ -26,7 +26,7 @@ void WritePaddle(Paddle *pdl, unsigned char val)
pdl->LastWrite = val;
}
unsigned char ReadPaddle(Paddle *pdl)
uint8_t ReadPaddle(Paddle *pdl)
{
switch(pdl->Bit++)
{

8
src/pluginsmanager/manager.c
View File

@ -25,7 +25,7 @@ typedef struct Plugin_
typedef struct KeyHandler_
{
byte key;
uint8_t key;
PluginKeypress func;
@ -83,7 +83,7 @@ int plugin_unload(int id)
/* Available functions for plugins */
int plugin_install_keypressHandler(byte key, PluginKeypress func)
int plugin_install_keypressHandler(uint8_t key, PluginKeypress func)
{
KeyHandler *ptr;
@ -115,14 +115,14 @@ int plugin_install_keypressHandler(byte key, PluginKeypress func)
return 0;
}
int plugin_remove_keypressHandler(byte key, PluginKeypress func)
int plugin_remove_keypressHandler(uint8_t key, PluginKeypress func)
{ /* actually do nothing, we cant remove plugin online */
return 0;
}
/* Available functions outside of plugins */
int plugin_keypress(byte key)
int plugin_keypress(uint8_t key)
{
KeyHandler *ptr = keyHandlersList;

68
src/pluginsmanager/plugins/gamegenie.c
View File

@ -41,24 +41,24 @@ typedef enum gg_States_
gg_States gg_state = GG_S00_MAIN_STATE;
/* Own representation of memory */
byte gg_MainRAM[0x800];
byte gg_OldMainRAM[0x800];
byte gg_SRAM[0x2000];
uint8_t gg_MainRAM[0x800];
uint8_t gg_OldMainRAM[0x800];
uint8_t gg_SRAM[0x2000];
/* Field used to now which byte are currently marked as pertinent or not */
byte gg_use_MainRAM[0x800];
byte gg_use_SRAM[0x2000];
/* Field used to now which uint8_t are currently marked as pertinent or not */
uint8_t gg_use_MainRAM[0x800];
uint8_t gg_use_SRAM[0x2000];
int gg_ResultNumber;
byte gg_PatchUsed[10];
byte gg_PatchedPage[10];
byte gg_PatchedAddr[10];
byte gg_PatchedValue[10];
uint8_t gg_PatchUsed[10];
uint8_t gg_PatchedPage[10];
uint8_t gg_PatchedAddr[10];
uint8_t gg_PatchedValue[10];
func_rdhook gg_rdhookPtr[10];
#define GG_RDHOOKPATCH(d) \
byte gg_RdHookPatch##d(byte addr) \
uint8_t gg_RdHookPatch##d(uint8_t addr) \
{ \
if (addr == gg_PatchedAddr[d]) \
{ \
@ -86,7 +86,7 @@ GG_RDHOOKPATCH(7)
GG_RDHOOKPATCH(8)
GG_RDHOOKPATCH(9)
void gg_SetPatch(int id, byte page, byte addr, byte value)
void gg_SetPatch(int id, uint8_t page, uint8_t addr, uint8_t value)
{
func_rdhook fptr;
@ -200,7 +200,7 @@ void MessageBox(char *title, char *msg)
}
unsigned short SelectNumber(char *title, char *msg, byte size)
uint16_t SelectNumber(char *title, char *msg, uint8_t size)
{
int sc_w, sc_h;
@ -208,8 +208,8 @@ unsigned short SelectNumber(char *title, char *msg, byte size)
char valueText[10];
unsigned short value;
byte digit = 0;
uint16_t value;
uint8_t digit = 0;
sc_w = screen->w;
sc_h = screen->h;
@ -393,14 +393,14 @@ int DispMenu(int itemc, char *itemv[], char *title)
return selection;
}
byte AskYesNo(char *title)
uint8_t AskYesNo(char *title)
{
char *YesNo[] = { "No", "Yes" };
return DispMenu(2, YesNo, title);
}
byte gg_CalcChk(unsigned short addr, byte value)
uint8_t gg_CalcChk(uint16_t addr, uint8_t value)
{
int chk = 0x42;
chk += (addr & 0xFF00) >> 8;
@ -415,21 +415,21 @@ byte gg_CalcChk(unsigned short addr, byte value)
VV = value,
CC = cheksum
*/
unsigned long gg_MakeCode(unsigned addr, byte value)
uint32_t gg_MakeCode(uint16_t addr, uint8_t value)
{
unsigned long code = addr << 16;
uint32_t code = addr << 16;
code |= (value << 8);
code |= (gg_CalcChk(addr, value) & 0x00FF);
return code ^ 0x246FF53A;
}
byte gg_SelectPatch()
uint8_t gg_SelectPatch()
{
char *Items[GG_MAX_PATCH + 1];
char *tmp;
int i;
byte ret;
uint8_t ret;
for (i = 0; i < GG_MAX_PATCH; i++)
{
@ -467,7 +467,7 @@ void gg_PatchManager()
void gg_InitSearch()
{
unsigned short addr;
uint16_t addr;
for(addr = 0x000; addr < 0x800; addr ++)
{
@ -487,11 +487,11 @@ typedef enum gg_SearchForMode_
} gg_SearchForMode;
void gg_SearchForValue(byte value)
void gg_SearchForValue(uint8_t value)
{
unsigned short addr;
//byte oldValue;
byte currentValue;
uint16_t addr;
//uint8_t oldValue;
uint8_t currentValue;
gg_ResultNumber = 0x00;
for(addr = 0x000; addr < 0x800; addr ++)
{
@ -518,9 +518,9 @@ void gg_SearchForValue(byte value)
void gg_SearchFor(gg_SearchForMode mode)
{
unsigned short addr;
byte oldValue;
byte currentValue;
uint16_t addr;
uint8_t oldValue;
uint8_t currentValue;
gg_ResultNumber = 0x00;
for(addr = 0x000; addr < 0x800; addr ++)
{
@ -585,14 +585,14 @@ void gg_SearchFor(gg_SearchForMode mode)
}
}
byte gg_DisplayResults()
uint8_t gg_DisplayResults()
{
char *Items[100];
char *tmp;
int i, addr = 0x0000;
byte ret = 0;
uint8_t ret = 0;
unsigned short AddrList[21];
uint16_t AddrList[21];
if (gg_ResultNumber > 20)
{
MessageBox("Code Breaker", "Too many results for displaying them!");
@ -651,8 +651,8 @@ void gg_Start()
char Buffer[100];
int ret;
byte value;
unsigned short addr;
uint8_t value;
uint16_t addr;
switch(gg_state)
{
default:

63
src/ppu/debug/ppu.debug.c
View File

@ -9,40 +9,16 @@
#include <stdio.h>
#include <stdlib.h>
#if 0
/* Allegro includes */
#ifdef __APPLE__
#define USE_CONSOLE
#include <Allegro/allegro.h>
#else
#define USE_CONSOLE
#include <allegro.h>
#endif
#define __TINES_PPU_INTERNAL__
#include <ppu/ppu.h>
#include <ppu/ppu.memory.h>
#include <ppu/ppu.debug.h>
#include <types.h>
extern BITMAP *Buffer;
extern unsigned short ppu_spritePatternTable;
extern short PPU_Reg_S;
void DebugColor()
{
#ifdef TO_MAKE
static unsigned short x = 128;
static unsigned short y = 128;
unsigned char OldDisplayPalette = ppu.DisplayPalette;
byte keyb;
unsigned int i;
unsigned long Color;
static uint16_t x = 128;
static uint16_t y = 128;
uint8_t OldDisplayPalette = ppu.DisplayPalette;
uint8_t keyb;
uint32_t i;
uint32_t Color;
NOBLIT = 1;
@ -120,7 +96,7 @@ void DebugColor()
void DebugSprites()
{
#ifdef TO_MAKE
byte keyb;
uint8_t keyb;
static int SelSprite = 0;
PPUSprite sprite;
NOBLIT = 1;
@ -208,10 +184,10 @@ void DebugSprites()
#define PPU_Rd(addr) ppu_readMemory((addr>>8)&0xFF, addr&0xFF)
void ppu_dumpOneNameTable(unsigned short nametable, int xd, int yd)
void ppu_dumpOneNameTable(uint16_t nametable, int xd, int yd)
{
byte x,y, x1, y1, Color;
unsigned short TileID;
uint8_t x,y, x1, y1, Color;
uint16_t TileID;
for (x = 0; x < 32; x++)
for (y = 0; y < 30; y++)
@ -233,35 +209,35 @@ void ppu_dumpOneNameTable(unsigned short nametable, int xd, int yd)
}
}
void ppu_dumpOneAttributeTable(unsigned short nametable, int xd, int yd)
void ppu_dumpOneAttributeTable(uint16_t nametable, int xd, int yd)
{
int x, x1, y1, Color, AttrByte;
int x, x1, y1, Color, Attruint8_t;
for (x = 0; x < 0x40; x++)
{
AttrByte = PPU_Rd(nametable + 0x23C0 + x);
Attruint8_t = PPU_Rd(nametable + 0x23C0 + x);
x1 = x % 8;
y1 = x / 8;
Color = AttrByte & 0x3; // Pattern 1;
Color = Attruint8_t & 0x3; // Pattern 1;
// Color = PPU_Rd(0x3F00 + (Color * 4) + 1);
rectfill(Buffer,xd+(x1*32),yd+(y1*32),xd+15+(x1*32),yd+15+(y1*32),Color);
textprintf_ex(Buffer, font, 4+xd+(x1*32), 4+yd+(y1*32), ~Color, Color, "%X", Color);
Color = (AttrByte>>2) & 0x3; // Pattern 2;
Color = (Attruint8_t>>2) & 0x3; // Pattern 2;
// Color = PPU_Rd(0x3F00 + (Color * 4) + 1);
rectfill(Buffer,16+xd+(x1*32),yd+(y1*32),16+xd+15+(x1*32),yd+15+(y1*32),Color);
textprintf_ex(Buffer, font, 4+xd+(x1*32)+16, 4+yd+(y1*32), ~Color, Color, "%X", Color);
Color = (AttrByte>>4) & 0x3; // Pattern 3;
Color = (Attruint8_t>>4) & 0x3; // Pattern 3;
// Color = PPU_Rd(0x3F00 + (Color * 4) + 1);
rectfill(Buffer,xd+(x1*32),16+yd+(y1*32),xd+15+(x1*32),16+yd+15+(y1*32),Color);
textprintf_ex(Buffer, font, 4+xd+(x1*32), 4+yd+(y1*32)+16, ~Color, Color, "%X", Color);
Color = (AttrByte>>6) & 0x3; // Pattern 4;
Color = (Attruint8_t>>6) & 0x3; // Pattern 4;
// Color = PPU_Rd(0x3F00 + (Color * 4) + 1);
rectfill(Buffer,16+xd+(x1*32),16+yd+(y1*32),16+xd+15+(x1*32),16+yd+15+(y1*32),Color);
@ -273,7 +249,7 @@ void ppu_dumpOneAttributeTable(unsigned short nametable, int xd, int yd)
}
}
extern byte *ppu_mem_nameTables;
extern uint8_t *ppu_mem_nameTables;
extern int ppu_screenMode;
void ppu_dumpNameTable(int xd, int yd)
{
@ -363,4 +339,5 @@ void ppu_dumpPalette(int x, int y)
rectfill(Buffer, x + 91 + (i % 4) * 20, y + 21 +(i / 4) * 20, x + 91 + (i % 4) * 20 + 20, y + 21 +(i / 4) * 20 + 20, ppu_readMemory(0x3F, i+0x10));
}
}
#endif
#endif

8
src/ppu/ppu.c
View File

@ -32,9 +32,9 @@
extern int VBLANK_TIME;
extern volatile int frame;
extern volatile unsigned long IPS, FPS;
extern volatile uint32_t IPS, FPS;
extern unsigned long ColorPalette[9 * 63];
extern uint32_t ColorPalette[9 * 63];
extern short IRQScanHit;
extern short SZHit;
@ -80,7 +80,7 @@ uint8_t PPU_Reg_V;
uint8_t PPU_Reg_H;
/* S: Playfield pattern table selection latch */
unsigned short PPU_Reg_S;
uint16_t PPU_Reg_S;
/* PAR: Picture Address Register */
uint8_t PPU_Reg_PAR;
@ -88,7 +88,7 @@ uint8_t PPU_Reg_PAR;
/* AR: Tile Attribute (palette select) value latch */
uint8_t PPU_Reg_AR;
unsigned short PPU_Reg_Counter;
uint16_t PPU_Reg_Counter;
/* PPU Memory Areas */

36
src/ppu/ppu.memory.c
View File

@ -20,15 +20,15 @@
#include <types.h>
/* Simple definition only for readability */
#define KBYTE * (1024)
#define Kuint8_t * (1024)
/* Internal representation of the PPU memory */
byte *ppu_memoryPages[0x40];
uint8_t *ppu_memoryPages[0x40];
byte ppu_memoryGhostLink[0x40];
uint8_t ppu_memoryGhostLink[0x40];
/* Internal PPU Sprite Ram */
byte ppu_SpriteRam[0x100];
uint8_t ppu_SpriteRam[0x100];
/*
* Memory management functions
@ -50,22 +50,22 @@ int ppu_initMemory()
return 0;
}
void ppu_updateGhost(byte page)
void ppu_updateGhost(uint8_t page)
{
byte cur_ghost;
uint8_t cur_ghost;
cur_ghost = ppu_memoryGhostLink[page];
if (cur_ghost < 0x40)
ppu_memoryPages[cur_ghost] = ppu_memoryPages[page];
}
void ppu_setPagePtr (byte page, byte *ptr)
void ppu_setPagePtr (uint8_t page, uint8_t *ptr)
{
ppu_memoryPages[page] = ptr;
ppu_updateGhost(page);
}
void ppu_setPagePtr1k(byte page, byte *ptr)
void ppu_setPagePtr1k(uint8_t page, uint8_t *ptr)
{ /* 1k = 4 * 256 */
ppu_memoryPages[page + 0] = ptr;
ppu_memoryPages[page + 1] = ptr + 0x100;
@ -78,7 +78,7 @@ void ppu_setPagePtr1k(byte page, byte *ptr)
ppu_updateGhost(page + 3);
}
void ppu_setPagePtr2k(byte page, byte *ptr)
void ppu_setPagePtr2k(uint8_t page, uint8_t *ptr)
{
ppu_memoryPages[page + 0] = ptr;
ppu_memoryPages[page + 1] = ptr + 0x100;
@ -99,19 +99,19 @@ void ppu_setPagePtr2k(byte page, byte *ptr)
ppu_updateGhost(page + 7);
}
void ppu_setPagePtr4k(byte page, byte *ptr)
void ppu_setPagePtr4k(uint8_t page, uint8_t *ptr)
{
ppu_setPagePtr2k(page, ptr);
ppu_setPagePtr2k(page+((4 KBYTE / 256) / 2), ptr + 2 KBYTE);
ppu_setPagePtr2k(page+((4 Kuint8_t / 256) / 2), ptr + 2 Kuint8_t);
}
void ppu_setPagePtr8k(byte page, byte *ptr)
void ppu_setPagePtr8k(uint8_t page, uint8_t *ptr)
{
ppu_setPagePtr4k(page, ptr);
ppu_setPagePtr4k(page+((8 KBYTE / 256) / 2), ptr + 4 KBYTE);
ppu_setPagePtr4k(page+((8 Kuint8_t / 256) / 2), ptr + 4 Kuint8_t);
}
void ppu_setPageGhost(byte page, bool value, byte ghost)
void ppu_setPageGhost(uint8_t page, uint8_t value, uint8_t ghost)
{
if (value == true)
{
@ -135,9 +135,9 @@ void ppu_memoryDumpState(FILE *fp)
}
}
byte ppu_readMemory(byte page, byte addr)
uint8_t ppu_readMemory(uint8_t page, uint8_t addr)
{
byte *ptr;
uint8_t *ptr;
if (page == 0x3F)
return ( ppu_memoryPages[0x3F][addr&0x1F] & 0x3F );
@ -145,7 +145,7 @@ byte ppu_readMemory(byte page, byte addr)
return ptr[addr];
}
void ppu_writeMemory(byte page, byte addr, byte value)
void ppu_writeMemory(uint8_t page, uint8_t addr, uint8_t value)
{
if (page == 0x3F)
{
@ -162,7 +162,7 @@ void ppu_writeMemory(byte page, byte addr, byte value)
}
else
{
byte *ptr;
uint8_t *ptr;
ptr = ppu_memoryPages[page & 0x3F];
ptr[addr] = value;

8
src/utils/bin2h/bin2h.c
View File

@ -1,6 +1,6 @@
/*
* bin to header - Part of The peTI-NESulator Project
* bin2h.c: Convert a binary file to a table of byte in a C header file.
* bin2h.c: Convert a binary file to a table of uint8_t in a C header file.
*
* Created by Manoel Trapier.
* Copyright 2003-2008 986 Corp. All rights reserved.
@ -60,14 +60,14 @@ int main(int argc, char *argv[])
fprintf(fpout, "/* Generated data file from file '%s' */\n\n\n", infile);
fprintf(fpout, "unsigned char data[] = {\n");
fprintf(fpout, "uint8_t data[] = {\n");
i = 0;
while((c = fgetc(fpin)) >= 0)
{
if (i == 0)
fprintf(fpout, "\t\t0x%02X", (unsigned char)c);
fprintf(fpout, "\t\t0x%02X", (uint8_t)c);
else
fprintf(fpout, ", 0x%02X", (unsigned char)c);
fprintf(fpout, ", 0x%02X", (uint8_t)c);
i++;
if (i > 10)