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]; char buffer[6];
/* Load the cart into memory */ /* 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)) if ((cart->File == NULL) || (cart->File == MAP_FAILED))

186
src/corecpu/corecpu.c
View File

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

20
src/include/corecpu.h
View File

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

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

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

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

@ -18,45 +18,45 @@
#define ATTR_PAGE_GHOST 0x02 #define ATTR_PAGE_GHOST 0x02
#define ATTR_PAGE_MAPPED 0x01 #define ATTR_PAGE_MAPPED 0x01
typedef byte (*func_rdhook)(byte /* addr */); typedef uint8_t (*func_rdhook)(uint8_t /* addr */);
typedef void (*func_wrhook)(byte addr, byte data); typedef void (*func_wrhook)(uint8_t addr, uint8_t data);
/* Functions to manage pages data */ /* Functions to manage pages data */
void set_page_ptr(byte page, byte *ptr); void set_page_ptr(uint8_t page, uint8_t *ptr);
void set_page_ptr_1k(byte page, byte *ptr); void set_page_ptr_1k(uint8_t page, uint8_t *ptr);
void set_page_ptr_2k(byte page, byte *ptr); void set_page_ptr_2k(uint8_t page, uint8_t *ptr);
void set_page_ptr_4k(byte page, byte *ptr); void set_page_ptr_4k(uint8_t page, uint8_t *ptr);
void set_page_ptr_8k(byte page, byte *ptr); void set_page_ptr_8k(uint8_t page, uint8_t *ptr);
void set_page_ptr_16k(byte page, byte *ptr); void set_page_ptr_16k(uint8_t page, uint8_t *ptr);
void set_page_ptr_32k(byte page, byte *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 */ /* 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 */ /* Generalist functions */
void InitMemory(); void InitMemory();
byte ReadMemory(byte page, byte addr); uint8_t ReadMemory(uint8_t page, uint8_t addr);
void WriteMemory(byte page, byte addr, byte value); void WriteMemory(uint8_t page, uint8_t addr, uint8_t value);
void DumpMemoryState(FILE *fp); void DumpMemoryState(FILE *fp);

8
src/include/paddle.h
View File

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

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

@ -20,13 +20,13 @@ typedef void (*PluginKeypress) (void);
#ifdef __TINES_PLUGINS__ #ifdef __TINES_PLUGINS__
/* Available functions for plugins */ /* Available functions for plugins */
int plugin_install_keypressHandler(byte key, PluginKeypress); int plugin_install_keypressHandler(uint8_t key, PluginKeypress);
int plugin_remove_keypressHandler(byte key, PluginKeypress); int plugin_remove_keypressHandler(uint8_t key, PluginKeypress);
#else /* __TINES_PLUGINS__ */ #else /* __TINES_PLUGINS__ */
/* Available functions outside of plugins */ /* Available functions outside of plugins */
int plugin_keypress(byte key); int plugin_keypress(uint8_t key);
/* Real Prototype: TBD */ /* Real Prototype: TBD */
void plugin_list(); 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); 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_memoryWrite(uint8_t page, uint8_t addr, uint8_t value);
void ppu_debugSprites(); void ppu_debugSprites();

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

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

7
src/include/types.h
View File

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

78
src/main.c
View File

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

2
src/mappersmanager/manager.c
View File

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

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

@ -9,11 +9,11 @@
#include "aorom.h" #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) 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; int BankNb;

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

@ -9,9 +9,9 @@
#include "cnrom.h" #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) 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); set_prom_bank_16k(0x8000,Value);
cnrom_load_bank = 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 */ if (Addr > 0x7FFF) /* Try to write to the rom */

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

@ -9,9 +9,9 @@
#include "iremh3001.h" #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) 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 #if 0
switch(Addr) 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_REG2_DEFAULT 0
#define MMC1_REG3_DEFAULT 0 #define MMC1_REG3_DEFAULT 0
void mmc1_MapperWriteReg0(register byte Addr, register byte Value); void mmc1_MapperWriteReg0(register uint8_t Addr, register uint8_t Value);
void mmc1_MapperWriteReg1(register byte Addr, register byte Value); void mmc1_MapperWriteReg1(register uint8_t Addr, register uint8_t Value);
void mmc1_MapperWriteReg2(register byte Addr, register byte Value); void mmc1_MapperWriteReg2(register uint8_t Addr, register uint8_t Value);
void mmc1_MapperWriteReg3(register byte Addr, register byte Value); void mmc1_MapperWriteReg3(register uint8_t Addr, register uint8_t Value);
void mmc1_MapperDump(FILE *fp) void mmc1_MapperDump(FILE *fp)
{ {
@ -181,7 +181,7 @@ uint32_t VROMBankNb;
uint8_t Bit = 0; uint8_t Bit = 0;
uint8_t BitBuf = 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) 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) 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) 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) if (Value & 0x80)
{ {

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

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

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

@ -9,12 +9,12 @@
#include "mmc4.h" #include "mmc4.h"
byte mmc4_RegA; uint8_t mmc4_RegA;
byte mmc4_RegB; uint8_t mmc4_RegB;
byte mmc4_RegC; uint8_t mmc4_RegC;
byte mmc4_RegD; uint8_t mmc4_RegD;
byte mmc4_RegE; uint8_t mmc4_RegE;
byte mmc4_RegF; uint8_t mmc4_RegF;
#ifdef DEBUG #ifdef DEBUG
#define LOG(s) printf s #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.. */ /* 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)); LOG(("%s(%02X, %02X)\n", __func__, Addr, Value));
mmc4_RegA = 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)); LOG(("%s(%02X, %02X)\n", __func__, Addr, Value));
mmc4_RegB = Value; mmc4_RegB = Value;
@ -41,28 +41,28 @@ void mmc4_MapperWriteRegB(register byte Addr, register byte Value)
set_vrom_bank_4k(0x0000, Value & 0x1F); 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)); LOG(("%s(%02X, %02X)\n", __func__, Addr, Value));
mmc4_RegC = Value; mmc4_RegC = Value;
set_vrom_bank_4k(0x0000, Value & 0x1F); 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)); LOG(("%s(%02X, %02X)\n", __func__, Addr, Value));
mmc4_RegD = Value; mmc4_RegD = Value;
set_vrom_bank_4k(0x1000, Value & 0x1F); 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)); LOG(("%s(%02X, %02X)\n", __func__, Addr, Value));
mmc4_RegE = Value; mmc4_RegE = Value;
set_vrom_bank_4k(0x1000, Value & 0x1F); 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)); LOG(("%s(%02X, %02X)\n", __func__, Addr, Value));
mmc4_RegF = Value; mmc4_RegF = Value;

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

@ -34,7 +34,7 @@ int norom_MapperIRQ(int cycledone)
return 0; 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 */ /* Nothing to do */
return; return;

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

@ -9,9 +9,9 @@
#include "unrom.h" #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) 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); set_vrom_bank_8k(0x0000,Value);
unrom_load_vbank = Value; unrom_load_vbank = Value;

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

@ -10,16 +10,16 @@
#include <ppu/ppu.h> #include <ppu/ppu.h>
#include "unrom512.h" #include "unrom512.h"
static byte mirroring_set; static uint8_t mirroring_set;
static byte loaded_vbank; static uint8_t loaded_vbank;
static byte loaded_pbank; 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 * 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 * 32K on such a cart
*/ */
static uint8_t vram[32768]; 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() static void unrom512_applyValues()
{ {
@ -36,7 +36,7 @@ static void unrom512_applyValues()
set_prom_bank_16k(0x8000, loaded_pbank); 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; mirroring_set = (Value >> 7) & 0x01;
loaded_vbank = (Value >> 5) & 0x03; 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 */ 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. * 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_MIRROR 0x01
#define MMC1_R0_ONESCREEN 0x02 #define MMC1_R0_ONESCREEN 0x02
@ -42,10 +42,10 @@ unsigned char mmc1_CurrentBank;
#define MMC1_REG3_DEFAULT 0 #define MMC1_REG3_DEFAULT 0
void mmc1_MapperWriteReg0(register byte Addr, register byte Value); void mmc1_MapperWriteReg0(register uint8_t Addr, register uint8_t Value);
void mmc1_MapperWriteReg1(register byte Addr, register byte Value); void mmc1_MapperWriteReg1(register uint8_t Addr, register uint8_t Value);
void mmc1_MapperWriteReg2(register byte Addr, register byte Value); void mmc1_MapperWriteReg2(register uint8_t Addr, register uint8_t Value);
void mmc1_MapperWriteReg3(register byte Addr, register byte Value); void mmc1_MapperWriteReg3(register uint8_t Addr, register uint8_t Value);
void mmc1_MapperDump(FILE *fp) void mmc1_MapperDump(FILE *fp)
{ {
@ -128,7 +128,7 @@ Reg 0
void mmc1_ApplyReg0Mod() 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; int VROMBankNb;
unsigned char Bit = 0; uint8_t Bit = 0;
unsigned char BitBuf = 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) 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) 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) 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) if (Value & 0x80)
{ {

20
src/mappersmanager/utils.c
View File

@ -30,45 +30,41 @@ extern char MapperWantIRQ;
Here are some fonction useful for mappers 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 #ifdef DEBUG_VROM_BANK_SWITCH
console_printf(Console_Default, "Change vrom 1k bank 0x%X to slot %d\n",addr,slot); console_printf(Console_Default, "Change vrom 1k bank 0x%X to slot %d\n",addr,slot);
#endif #endif
ppu_setPagePtr1k((addr>>8)&0xFF, Cart->VROMBanks + (slot * 1024)); 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 #ifdef DEBUG_VROM_BANK_SWITCH
console_printf(Console_Default, "Change vrom 2k bank 0x%X to slot %d\n",addr,slot); console_printf(Console_Default, "Change vrom 2k bank 0x%X to slot %d\n",addr,slot);
#endif #endif
ppu_setPagePtr2k((addr>>8)&0xFF, Cart->VROMBanks + (slot * 2 * 1024)); 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 #ifdef DEBUG_VROM_BANK_SWITCH
console_printf(Console_Default, "Change vrom 4k bank 0x%X to slot %d\n",addr,slot); console_printf(Console_Default, "Change vrom 4k bank 0x%X to slot %d\n",addr,slot);
#endif #endif
ppu_setPagePtr4k((addr>>8)&0xFF, Cart->VROMBanks + (slot * 4 * 1024)); 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 #ifdef DEBUG_VROM_BANK_SWITCH
console_printf(Console_Default, "Change vrom 8k bank 0x%X to slot %d\n",addr,slot); console_printf(Console_Default, "Change vrom 8k bank 0x%X to slot %d\n",addr,slot);
#endif #endif
ppu_setPagePtr8k(0x00, Cart->VROMBanks + (slot * 8 * 1024)); 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 #ifdef DEBUG_PROM_BANK_SWITCH
console_printf(Console_Default, "Change prom 8k bank 0x%X to slot %d\n",addr,slot); 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)); 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 #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); 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)); 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 !*/ { /* addr may not be different from 0x8000 !*/
/* Anyway I don't use it */ /* Anyway I don't use it */
#ifdef DEBUG_PROM_BANK_SWITCH #ifdef DEBUG_PROM_BANK_SWITCH
console_printf(Console_Default, "Change prom 32k bank 0x%X to slot %d\n",addr,slot); console_printf(Console_Default, "Change prom 32k bank 0x%X to slot %d\n",addr,slot);
#endif #endif
set_page_ptr_32k(addr >> 8, Cart->PROMBanks + (slot * 32 * 1024)); 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 */ /* Private structures */
#define KBYTE * (1024) #define Kuint8_t * (1024)
/* /*
* What inside memory manager: * What inside memory manager:
@ -29,8 +29,8 @@
/* Private data */ /* Private data */
byte *memory_pages[0x100]; uint8_t *memory_pages[0x100];
byte memory_pages_attr[0x100]; uint8_t memory_pages_attr[0x100];
func_rdhook rdh_table[0x100]; func_rdhook rdh_table[0x100];
func_wrhook wrh_table[0x100]; func_wrhook wrh_table[0x100];
@ -45,13 +45,13 @@ func_wrhook wrh_table[0x100];
#endif #endif
/* Public functions */ /* 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)); LOG(console_printf(Console_Default, "Set page 0x%X to ptr %p\n", page, ptr));
memory_pages[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 */ { /* 1k = 4 * 256 */
LOG(console_printf(Console_Default, "Set page(1k) 0x%X to ptr %p\n", page, ptr)); LOG(console_printf(Console_Default, "Set page(1k) 0x%X to ptr %p\n", page, ptr));
memory_pages[page + 0] = 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); 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)); LOG(console_printf(Console_Default, "Set page(2k) 0x%X to ptr %p\n", page, ptr));
memory_pages[page + 0] = 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); 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)); 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, 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)); 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, 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, 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, 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]; return memory_pages[page];
} }
@ -107,30 +107,30 @@ byte *get_page_ptr(byte page)
/* Functions to set pages attributes */ /* 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) if (func == NULL)
{ {
memory_pages_attr[page] &= (~ATTR_PAGE_HAVE_RDHOOK); 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; memory_pages[page] = NULL;
} }
else else
{ {
memory_pages_attr[page] |= ATTR_PAGE_HAVE_RDHOOK; memory_pages_attr[page] |= ATTR_PAGE_HAVE_RDHOOK;
if (memory_pages[page] == NULL) if (memory_pages[page] == NULL)
memory_pages[page] = (byte *)0x01; memory_pages[page] = (uint8_t *)0x01;
} }
rdh_table[page] = func; 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) if (func == NULL)
{ {
memory_pages_attr[page] &= (~ATTR_PAGE_HAVE_WRHOOK); 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; 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; memory_pages_attr[page] |= ATTR_PAGE_HAVE_WRHOOK;
if (memory_pages[page] == NULL) if (memory_pages[page] == NULL)
memory_pages[page] = (byte *)0x01; memory_pages[page] = (uint8_t *)0x01;
} }
wrh_table[page] = func; 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) if (value == true)
memory_pages_attr[page] |= ATTR_PAGE_READABLE; 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); 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) if (value == true)
memory_pages_attr[page] |= ATTR_PAGE_WRITEABLE; 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); 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) 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]; 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) if (memory_pages_attr[page] & ATTR_PAGE_HAVE_RDHOOK)
return rdh_table[page]; return rdh_table[page];
@ -184,7 +184,7 @@ func_rdhook get_page_rdhook(byte page)
return NULL; 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) if (memory_pages_attr[page] & ATTR_PAGE_HAVE_WRHOOK)
return wrh_table[page]; return wrh_table[page];
@ -192,11 +192,11 @@ func_wrhook get_page_wrhook(byte page)
return NULL; return NULL;
} }
byte ReadMemory(byte page, byte addr) uint8_t ReadMemory(uint8_t page, uint8_t addr)
{ {
static byte LastRetByte = 0xA5; static uint8_t LastRetuint8_t = 0xA5;
byte *page_ptr; uint8_t *page_ptr;
byte attributes; uint8_t attributes;
LOG(console_printf(Console_Default, "Read @ 0x%X-%X\n", page, addr)); 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" ? */ /* Est-ce que la page est mappé ? && Est-ce que la page est "readable" ? */
if ((page_ptr = memory_pages[page]) && 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")); LOG(console_printf(Console_Default, "Page is non null & readable\n"));
if ( attributes & ATTR_PAGE_HAVE_RDHOOK ) if ( attributes & ATTR_PAGE_HAVE_RDHOOK )
return ( LastRetByte = rdh_table[page](addr) ); return ( LastRetuint8_t = rdh_table[page](addr) );
else 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); //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; uint8_t *page_ptr;
byte attributes; uint8_t attributes;
LOG(console_printf(Console_Default, "Write 0x%x @ 0x%X-%X\n", value, page, addr)); 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" ? */ /* Est-ce que la page est mappé ? && Est-ce que la page est "writable" ? */
if ( (page_ptr = memory_pages[page]) && 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 struct KeyArray
{ {
unsigned char lastState; uint8_t lastState;
unsigned char curState; uint8_t curState;
unsigned char debounced; uint8_t debounced;
GLFWwindow* window; GLFWwindow* window;
}; };
@ -37,7 +37,7 @@ struct GLWindow_t
{ {
struct KeyArray keyArray[512]; struct KeyArray keyArray[512];
GLFWwindow* windows; GLFWwindow* windows;
unsigned char *videoMemory; uint8_t *videoMemory;
GLint videoTexture; GLint videoTexture;
int WIDTH; int WIDTH;
int HEIGHT; int HEIGHT;
@ -83,8 +83,8 @@ void ShowScreen(GLWindow *g, int w, int h)
void setupGL(GLWindow *g, int w, int h) void setupGL(GLWindow *g, int w, int h)
{ {
g->videoMemory = (unsigned char*)malloc(w*h*sizeof(unsigned int)); g->videoMemory = (uint8_t*)malloc(w*h*sizeof(uint32_t));
memset(g->videoMemory, 0,w*h*sizeof(unsigned int)); memset(g->videoMemory, 0,w*h*sizeof(uint32_t));
//Tell OpenGL how to convert from coordinates to pixel values //Tell OpenGL how to convert from coordinates to pixel values
glViewport(0, 0, w, h); glViewport(0, 0, w, h);
@ -405,7 +405,7 @@ int graphics_init()
return 0; return 0;
} }
static unsigned long getColour(long color) static uint32_t getColour(long color)
{ {
Palette *pal = &basicPalette[color]; Palette *pal = &basicPalette[color];
uint8_t r, g, b, a; 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 struct KeyArray
{ {
unsigned char lastState; uint8_t lastState;
unsigned char curState; uint8_t curState;
unsigned char debounced; uint8_t debounced;
}; };
struct GLWindow_t struct GLWindow_t
{ {
struct KeyArray keyArray[512]; struct KeyArray keyArray[512];
GLFWwindow* windows; GLFWwindow* windows;
unsigned char *videoMemory; uint8_t *videoMemory;
GLint videoTexture; GLint videoTexture;
int WIDTH; int WIDTH;
int HEIGHT; int HEIGHT;

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

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

8
src/pluginsmanager/manager.c
View File

@ -25,7 +25,7 @@ typedef struct Plugin_
typedef struct KeyHandler_ typedef struct KeyHandler_
{ {
byte key; uint8_t key;
PluginKeypress func; PluginKeypress func;
@ -83,7 +83,7 @@ int plugin_unload(int id)
/* Available functions for plugins */ /* Available functions for plugins */
int plugin_install_keypressHandler(byte key, PluginKeypress func) int plugin_install_keypressHandler(uint8_t key, PluginKeypress func)
{ {
KeyHandler *ptr; KeyHandler *ptr;
@ -115,14 +115,14 @@ int plugin_install_keypressHandler(byte key, PluginKeypress func)
return 0; 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 */ { /* actually do nothing, we cant remove plugin online */
return 0; return 0;
} }
/* Available functions outside of plugins */ /* Available functions outside of plugins */
int plugin_keypress(byte key) int plugin_keypress(uint8_t key)
{ {
KeyHandler *ptr = keyHandlersList; 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; gg_States gg_state = GG_S00_MAIN_STATE;
/* Own representation of memory */ /* Own representation of memory */
byte gg_MainRAM[0x800]; uint8_t gg_MainRAM[0x800];
byte gg_OldMainRAM[0x800]; uint8_t gg_OldMainRAM[0x800];
byte gg_SRAM[0x2000]; uint8_t gg_SRAM[0x2000];
/* Field used to now which byte are currently marked as pertinent or not */ /* Field used to now which uint8_t are currently marked as pertinent or not */
byte gg_use_MainRAM[0x800]; uint8_t gg_use_MainRAM[0x800];
byte gg_use_SRAM[0x2000]; uint8_t gg_use_SRAM[0x2000];
int gg_ResultNumber; int gg_ResultNumber;
byte gg_PatchUsed[10]; uint8_t gg_PatchUsed[10];
byte gg_PatchedPage[10]; uint8_t gg_PatchedPage[10];
byte gg_PatchedAddr[10]; uint8_t gg_PatchedAddr[10];
byte gg_PatchedValue[10]; uint8_t gg_PatchedValue[10];
func_rdhook gg_rdhookPtr[10]; func_rdhook gg_rdhookPtr[10];
#define GG_RDHOOKPATCH(d) \ #define GG_RDHOOKPATCH(d) \
byte gg_RdHookPatch##d(byte addr) \ uint8_t gg_RdHookPatch##d(uint8_t addr) \
{ \ { \
if (addr == gg_PatchedAddr[d]) \ if (addr == gg_PatchedAddr[d]) \
{ \ { \
@ -86,7 +86,7 @@ GG_RDHOOKPATCH(7)
GG_RDHOOKPATCH(8) GG_RDHOOKPATCH(8)
GG_RDHOOKPATCH(9) 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; 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; int sc_w, sc_h;
@ -208,8 +208,8 @@ unsigned short SelectNumber(char *title, char *msg, byte size)
char valueText[10]; char valueText[10];
unsigned short value; uint16_t value;
byte digit = 0; uint8_t digit = 0;
sc_w = screen->w; sc_w = screen->w;
sc_h = screen->h; sc_h = screen->h;
@ -393,14 +393,14 @@ int DispMenu(int itemc, char *itemv[], char *title)
return selection; return selection;
} }
byte AskYesNo(char *title) uint8_t AskYesNo(char *title)
{ {
char *YesNo[] = { "No", "Yes" }; char *YesNo[] = { "No", "Yes" };
return DispMenu(2, YesNo, title); 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; int chk = 0x42;
chk += (addr & 0xFF00) >> 8; chk += (addr & 0xFF00) >> 8;
@ -415,21 +415,21 @@ byte gg_CalcChk(unsigned short addr, byte value)
VV = value, VV = value,
CC = cheksum 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 |= (value << 8);
code |= (gg_CalcChk(addr, value) & 0x00FF); code |= (gg_CalcChk(addr, value) & 0x00FF);
return code ^ 0x246FF53A; return code ^ 0x246FF53A;
} }
byte gg_SelectPatch() uint8_t gg_SelectPatch()
{ {
char *Items[GG_MAX_PATCH + 1]; char *Items[GG_MAX_PATCH + 1];
char *tmp; char *tmp;
int i; int i;
byte ret; uint8_t ret;
for (i = 0; i < GG_MAX_PATCH; i++) for (i = 0; i < GG_MAX_PATCH; i++)
{ {
@ -467,7 +467,7 @@ void gg_PatchManager()
void gg_InitSearch() void gg_InitSearch()
{ {
unsigned short addr; uint16_t addr;
for(addr = 0x000; addr < 0x800; addr ++) for(addr = 0x000; addr < 0x800; addr ++)
{ {
@ -487,11 +487,11 @@ typedef enum gg_SearchForMode_
} gg_SearchForMode; } gg_SearchForMode;
void gg_SearchForValue(byte value) void gg_SearchForValue(uint8_t value)
{ {
unsigned short addr; uint16_t addr;
//byte oldValue; //uint8_t oldValue;
byte currentValue; uint8_t currentValue;
gg_ResultNumber = 0x00; gg_ResultNumber = 0x00;
for(addr = 0x000; addr < 0x800; addr ++) for(addr = 0x000; addr < 0x800; addr ++)
{ {
@ -518,9 +518,9 @@ void gg_SearchForValue(byte value)
void gg_SearchFor(gg_SearchForMode mode) void gg_SearchFor(gg_SearchForMode mode)
{ {
unsigned short addr; uint16_t addr;
byte oldValue; uint8_t oldValue;
byte currentValue; uint8_t currentValue;
gg_ResultNumber = 0x00; gg_ResultNumber = 0x00;
for(addr = 0x000; addr < 0x800; addr ++) 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 *Items[100];
char *tmp; char *tmp;
int i, addr = 0x0000; int i, addr = 0x0000;
byte ret = 0; uint8_t ret = 0;
unsigned short AddrList[21]; uint16_t AddrList[21];
if (gg_ResultNumber > 20) if (gg_ResultNumber > 20)
{ {
MessageBox("Code Breaker", "Too many results for displaying them!"); MessageBox("Code Breaker", "Too many results for displaying them!");
@ -651,8 +651,8 @@ void gg_Start()
char Buffer[100]; char Buffer[100];
int ret; int ret;
byte value; uint8_t value;
unsigned short addr; uint16_t addr;
switch(gg_state) switch(gg_state)
{ {
default: default:

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

@ -9,40 +9,16 @@
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#if 0 #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() void DebugColor()
{ {
#ifdef TO_MAKE #ifdef TO_MAKE
static unsigned short x = 128; static uint16_t x = 128;
static unsigned short y = 128; static uint16_t y = 128;
unsigned char OldDisplayPalette = ppu.DisplayPalette; uint8_t OldDisplayPalette = ppu.DisplayPalette;
byte keyb; uint8_t keyb;
unsigned int i; uint32_t i;
unsigned long Color; uint32_t Color;
NOBLIT = 1; NOBLIT = 1;
@ -120,7 +96,7 @@ void DebugColor()
void DebugSprites() void DebugSprites()
{ {
#ifdef TO_MAKE #ifdef TO_MAKE
byte keyb; uint8_t keyb;
static int SelSprite = 0; static int SelSprite = 0;
PPUSprite sprite; PPUSprite sprite;
NOBLIT = 1; NOBLIT = 1;
@ -208,10 +184,10 @@ void DebugSprites()
#define PPU_Rd(addr) ppu_readMemory((addr>>8)&0xFF, addr&0xFF) #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; uint8_t x,y, x1, y1, Color;
unsigned short TileID; uint16_t TileID;
for (x = 0; x < 32; x++) for (x = 0; x < 32; x++)
for (y = 0; y < 30; y++) 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++) for (x = 0; x < 0x40; x++)
{ {
AttrByte = PPU_Rd(nametable + 0x23C0 + x); Attruint8_t = PPU_Rd(nametable + 0x23C0 + x);
x1 = x % 8; x1 = x % 8;
y1 = x / 8; y1 = x / 8;
Color = AttrByte & 0x3; // Pattern 1; Color = Attruint8_t & 0x3; // Pattern 1;
// Color = PPU_Rd(0x3F00 + (Color * 4) + 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); 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); 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); // 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); 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); 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); // 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); 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); 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); // 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); 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; extern int ppu_screenMode;
void ppu_dumpNameTable(int xd, int yd) 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)); 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 int VBLANK_TIME;
extern volatile int frame; 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 IRQScanHit;
extern short SZHit; extern short SZHit;
@ -80,7 +80,7 @@ uint8_t PPU_Reg_V;
uint8_t PPU_Reg_H; uint8_t PPU_Reg_H;
/* S: Playfield pattern table selection latch */ /* S: Playfield pattern table selection latch */
unsigned short PPU_Reg_S; uint16_t PPU_Reg_S;
/* PAR: Picture Address Register */ /* PAR: Picture Address Register */
uint8_t PPU_Reg_PAR; uint8_t PPU_Reg_PAR;
@ -88,7 +88,7 @@ uint8_t PPU_Reg_PAR;
/* AR: Tile Attribute (palette select) value latch */ /* AR: Tile Attribute (palette select) value latch */
uint8_t PPU_Reg_AR; uint8_t PPU_Reg_AR;
unsigned short PPU_Reg_Counter; uint16_t PPU_Reg_Counter;
/* PPU Memory Areas */ /* PPU Memory Areas */

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

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

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

@ -1,6 +1,6 @@
/* /*
* bin to header - Part of The peTI-NESulator Project * 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. * Created by Manoel Trapier.
* Copyright 2003-2008 986 Corp. All rights reserved. * 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, "/* Generated data file from file '%s' */\n\n\n", infile);
fprintf(fpout, "unsigned char data[] = {\n"); fprintf(fpout, "uint8_t data[] = {\n");
i = 0; i = 0;
while((c = fgetc(fpin)) >= 0) while((c = fgetc(fpin)) >= 0)
{ {
if (i == 0) if (i == 0)
fprintf(fpout, "\t\t0x%02X", (unsigned char)c); fprintf(fpout, "\t\t0x%02X", (uint8_t)c);
else else
fprintf(fpout, ", 0x%02X", (unsigned char)c); fprintf(fpout, ", 0x%02X", (uint8_t)c);
i++; i++;
if (i > 10) if (i > 10)