memory_sfr_write8(_SP_, 0x07);
}
-static void
-cpu8051_convert_bit_address(uint8_t bit_address, uint8_t *byte_address,
- uint8_t *bit_number)
-{
- if (bit_address > 0x7F) {
- /* SFR 80-FF */
- *byte_address = bit_address & 0xF8;
- *bit_number = bit_address & 0x07;
- } else {
- /* 20-2F */
- *byte_address = (bit_address >> 3) + 0x20;
- *bit_number = bit_address & 0x07;
- }
-}
-
-/* Write with a direct addressing mode at Address the new Value */
-void
-cpu8051_WriteD(unsigned int address, unsigned char value)
-{
- memory_write8(INT_MEM_ID, address, value);
-}
-
-/* Write with an indirect addressing mode at Address the new Value */
-void
-cpu8051_WriteI(unsigned int address, unsigned char value)
-{
- if (address > 0x7F) {
- memory_write8(EXT_MEM_ID, address, value);
- return;
- }
-
- memory_write8(INT_MEM_ID, address, value);
-}
-
-/* Write with a bit addressing mode at BitAddress the new Value */
-void
-cpu8051_WriteB(uint8_t bit_address, uint8_t value)
-{
- uint8_t byte_address;
- uint8_t bit_number;
- unsigned char byte_val, byte_mask;
-
- cpu8051_convert_bit_address(bit_address, &byte_address, &bit_number);
-
- byte_mask = ((1 << bit_number) ^ 0xFF);
- byte_val = cpu8051_ReadD(byte_address) & byte_mask;
- byte_val += value << bit_number;
- cpu8051_WriteD(byte_address, byte_val);
-}
-
-/* Read with a direct addressing mode at Address */
-unsigned char
-cpu8051_ReadD(unsigned int address)
-{
- if (address > 0xFF)
- return memory_read8(EXT_MEM_ID, address);
- else
- return memory_read8(INT_MEM_ID, address);
-}
-
-/* Read with a indirect addressing mode at Address */
-unsigned char
-cpu8051_ReadI(unsigned int address)
-{
- if (address > 0x7F)
- return memory_read8(EXT_MEM_ID, address);
- else
- return memory_read8(INT_MEM_ID, address);
-}
-
-/* Read with a bit addressing mode at BitAddress */
-unsigned char
-cpu8051_ReadB(uint8_t bit_address)
-{
- uint8_t byte_address;
- uint8_t bit_number;
- unsigned char bit_value;
-
- cpu8051_convert_bit_address(bit_address, &byte_address, &bit_number);
-
- bit_value = (cpu8051_ReadD(byte_address) >> bit_number);
- bit_value &= 1;
- return bit_value;
-}
-
static int
cpu8051_interrupt_fire(int interrupt_no, int priority)
{
- if (cpu8051_ReadD(_IP_) & INTERRUPT_MASK(interrupt_no))
+ if (memory_read_direct(_IP_) & INTERRUPT_MASK(interrupt_no))
return priority;
else
return !priority;
static int
cpu8051_interrupt_enabled(int interrupt_no)
{
- return (cpu8051_ReadD(_IE_) & INTERRUPT_MASK(interrupt_no)) ? 1 : 0;
+ return (memory_read_direct(_IE_) & INTERRUPT_MASK(interrupt_no)) ? 1 : 0;
}
static void
{
int i;
- if ((cpu8051_ReadD(_IE_) & 0x80) == 0)
+ if ((memory_read_direct(_IE_) & 0x80) == 0)
return;
for (i = INTERRUPT_PRIORITY_HIGH; i >= INTERRUPT_PRIORITY_LOW; i--) {
/* Interrupt timer 0 */
if (cpu8051_interrupt_enabled(INTERRUPT_1) &&
cpu8051_interrupt_fire(INTERRUPT_1, i) &&
- (cpu8051_ReadD(_TCON_) & 0x20)) {
- cpu8051_WriteD(_TCON_,
- cpu8051_ReadD(_TCON_) & 0xDF);
+ (memory_read_direct(_TCON_) & 0x20)) {
+ memory_write_direct(_TCON_,
+ memory_read_direct(_TCON_) & 0xDF);
cpu8051_process_interrupt(0x0B, i);
return;
}
/* Interrupt timer 1 */
if (cpu8051_interrupt_enabled(INTERRUPT_3) &&
cpu8051_interrupt_fire(INTERRUPT_3, i) &&
- (cpu8051_ReadD(_TCON_) & 0x80)) {
- cpu8051_WriteD(_TCON_,
- cpu8051_ReadD(_TCON_) & 0x7F);
+ (memory_read_direct(_TCON_) & 0x80)) {
+ memory_write_direct(_TCON_,
+ memory_read_direct(_TCON_) & 0x7F);
cpu8051_process_interrupt(0x1B, i);
return;
}
/* Serial Interrupts */
if (cpu8051_interrupt_enabled(INTERRUPT_4) &&
cpu8051_interrupt_fire(INTERRUPT_4, i) &&
- (cpu8051_ReadD(_SCON_) & 0x03)) {
+ (memory_read_direct(_SCON_) & 0x03)) {
cpu8051_process_interrupt(0x23, i);
return;
}
/* Interrupt timer 2 */
if (cpu8051_interrupt_enabled(INTERRUPT_5) &&
cpu8051_interrupt_fire(INTERRUPT_5, i) &&
- (cpu8051_ReadD(_T2CON_) & 0x80)) {
+ (memory_read_direct(_T2CON_) & 0x80)) {
cpu8051_process_interrupt(0x2B, i);
return;
}
uint8_t bit_number;
int len;
- cpu8051_convert_bit_address(bit_address, &byte_address, &bit_number);
+ memory_convert_bit_address(bit_address, &byte_address, &bit_number);
len = cpu8051_sfr_mem_info(byte_address, text);
sprintf(&text[len], ".%X", bit_address);
int
cpu8051_get_instruction_size(unsigned char opcode)
{
- return InstSizesTbl[opcode];
+ return instr_size[opcode];
}
/* Display instruction mnemonic. */
int
cpu8051_disasm_mnemonic(unsigned char opcode, char *buf)
{
- return sprintf(buf, "%s", InstTextTbl[InstTypesTbl[opcode]]);
+ return sprintf(buf, "%s", instr_type_str[instr_type_id[opcode]]);
}
/* Disasm instruction arguments starting at address into a text string */
return;
}
- for (i = 1; i <= InstArgTbl[args_table_offset]; i++) {
- switch (InstArgTbl[args_table_offset + i]) {
+ for (i = 1; i <= instr_arg_type_id[args_table_offset]; i++) {
+ switch (instr_arg_type_id[args_table_offset + i]) {
case ADDR11: {
len += sprintf(&buf[len],
"%.4XH", ((opcode << 3) & 0xF00) +
default: {
len += sprintf(
&buf[len], "%s",
- ArgsTextTbl[InstArgTbl[args_table_offset + i]]);
+ instr_arg_type_str[instr_arg_type_id[
+ args_table_offset + i]]);
}
}
- if (i < InstArgTbl[args_table_offset])
+ if (i < instr_arg_type_id[args_table_offset])
len += sprintf(&buf[len], ",");
}
}
len += sprintf(text, " %.4X ", address);
opcode = memory_read8(PGM_MEM_ID, address);
- inst_size = InstSizesTbl[opcode];
+ inst_size = instr_size[opcode];
/* Display hex bytes. */
for (i = 0; i < inst_size; i++)
# ------------------------------------------------------------------------------
print DISASM_H "/* Size(in bytes) of each instruction (offset in table is instruction opcode) */\n";
-print DISASM_H "static int InstSizesTbl[] = {";
-for ($i = 0; $i < 256; $i++) {
+$nbelement = @nbbytes;
+
+print DISASM_H "static int instr_size[$nbelement] = {";
+
+for ($i = 0; $i < $nbelement; $i++) {
if ($i % 16 == 0) {
print DISASM_H "\n\t";
} else {
print DISASM_H "\n";
print DISASM_H "};\n";
print DISASM_H "\n";
+
# ------------------------------------------------------------------------------
print DISASM_H "/*\n";
print DISASM_H " * For all 256 opcodes, the value in this table gives the instruction type\n";
print DISASM_H " * ex.: MOV, INC, CLR, CPL,...\n";
print DISASM_H " * To know what is the instruction type, use\n";
-print DISASM_H " * the number as an offset in InstTextTbl[]\n";
+print DISASM_H " * the number as an offset in instr_type_str[]\n";
print DISASM_H " */\n";
-print DISASM_H "static int InstTypesTbl[] = {";
-for ($i = 0; $i < 256; $i++) {
+$nbelement = @insttype;
+
+print DISASM_H "static int instr_type_id[$nbelement] = {";
+
+for ($i = 0; $i < $nbelement; $i++) {
if ($i % 16 == 0) {
print DISASM_H "\n\t";
} else {
print DISASM_H "\n";
print DISASM_H "};\n";
print DISASM_H "\n";
+
# ------------------------------------------------------------------------------
-print DISASM_H "/* List of instructions types referenced by InstTypesTbl[] */\n";
-$nbelement=@insttext;
-print DISASM_H "\#define InstTextTblLength $nbelement\n";
-$elementnb=0;
-print DISASM_H "static char *InstTextTbl[] = {\n";
+print DISASM_H "/* List of instructions types referenced by instr_type_id[] */\n";
+$nbelement = @insttext;
+$elementnb = 0;
+print DISASM_H "static char *instr_type_str[$nbelement] = {\n";
+
foreach $instruc (@insttext) {
print DISASM_H "\t\"$instruc\"";
- ($elementnb++ < $nbelement-1) and print DISASM_H ",";
+ if ($elementnb++ < ($nbelement - 1)) {
+ print DISASM_H ",";
+ }
print DISASM_H "\n";
}
+
print DISASM_H "};\n";
print DISASM_H "\n";
+
# ------------------------------------------------------------------------------
print DISASM_H "/*\n";
print DISASM_H " * Table describing all arguments types of an instruction\n";
-print DISASM_H " * The table is indexed InstArgTbl[ opcode * 4]\n";
-print DISASM_H " * InstArgTbl[opcode*4 + 1] gives the number of arguments the instruction has\n";
-print DISASM_H " * InstArgTbl[opcode*4 + i] for i=1,2 and 3 give the type of each argument\n";
+print DISASM_H " * The table is indexed instr_arg_type_id[ opcode * 4]\n";
+print DISASM_H " * instr_arg_type_id[opcode*4 + 1] gives number of instruction arguments\n";
+print DISASM_H " * instr_arg_type_id[opcode*4 + i] for i=1,2 and 3 gives type of each argument\n";
print DISASM_H " * for most instructions, the 3rd argument isn't used\n";
-print DISASM_H " * the argument type is referecing to ArgsTextTbl[]\n";
+print DISASM_H " * the argument type is referecing to instr_arg_type_str[]\n";
print DISASM_H " */\n";
-print DISASM_H "\#define InstArgTblLength 256\n";
-print DISASM_H "static int InstArgTbl[] = {";
-for ($i = 0; $i < 1024; $i++) {
+$nbelement = @instargs;
+
+print DISASM_H "static int instr_arg_type_id[$nbelement] = {";
+
+for ($i = 0; $i < $nbelement; $i++) {
if ($i % 16 == 0) {
print DISASM_H "\n\t";
} else {
# ------------------------------------------------------------------------------
print DISASM_H "/*\n";
print DISASM_H " * List all types of arguments available to instructions\n";
-print DISASM_H " * Referenced by InstArgsTbl[]\n";
+print DISASM_H " * Referenced by instr_arg_type_id[]\n";
print DISASM_H " */\n";
+
$nbelement = @argstypes;
-print DISASM_H "\#define ArgsTextTblLength $nbelement\n";
$elementnb = 0;
-print DISASM_H "static char *ArgsTextTbl[] = {\n";
+
+print DISASM_H "static char *instr_arg_type_str[$nbelement] = {\n";
+
foreach $args (@argstypes) {
print DISASM_H "\t\"$args\"";
- ($elementnb++ < $nbelement-1) and print DISASM_H ",";
+ if ($elementnb++ < $nbelement-1) {
+ print DISASM_H ",";
+ }
print DISASM_H "\n";
}
print DISASM_H "};\n";
print DISASM_H "\n";
# ------------------------------------------------------------------------------
-for ($i=0 ; $i< 256; $i++) {
+for ($i = 0 ; $i < 256; $i++) {
print INST_IMP "/*","*"x76,"\n";
print INST_IMP " * Instruction \"$a_instruction[$i]\" takes $a_cycles[$i] cycle(s) and $a_bytes[$i] byte(s).\n";
print INST_IMP " ","*"x76,"/\n";
if( $i == 0x85 ) {
# Cas particulier pour MOV direct,direct -> src et dest sont inverses dans la memoire
print INST_IMP " unsigned char srcaddr = memory_read8( PGM_MEM_ID, cpu8051.pc++ );\n";
- print INST_IMP " unsigned char source = cpu8051_ReadD( srcaddr );\n";
+ print INST_IMP " unsigned char source = memory_read_direct( srcaddr );\n";
print INST_IMP " unsigned char destaddr = memory_read8( PGM_MEM_ID, cpu8051.pc++ );\n";
- print INST_IMP " unsigned char destination = cpu8051_ReadD( destaddr );\n";
+ print INST_IMP " unsigned char destination = memory_read_direct( destaddr );\n";
print INST_IMP " destination = source;\n";
- print INST_IMP " cpu8051_WriteD( destaddr, destination );\n";
+ print INST_IMP " memory_write_direct( destaddr, destination );\n";
}
else {
if ($instargs[$i*4] > 0) {
cfw("cpu8051.pc += 2;");
}
if ($op_destination == 2) { # A
- cfw("unsigned char destination = cpu8051_ReadD( _ACC_ );");
+ cfw("unsigned char destination = memory_read_direct( _ACC_ );");
}
if ($op_destination == 3) { # direct
cfw("unsigned char destaddr = memory_read8( PGM_MEM_ID, cpu8051.pc++ );");
- cfw("unsigned char destination = cpu8051_ReadD( destaddr );");
+ cfw("unsigned char destination = memory_read_direct( destaddr );");
}
if ($op_destination == 4) { # @R0
- cfw("unsigned char destination = cpu8051_ReadI ( cpu8051_ReadD( BANKPSW + _R0_ ) );");
+ cfw("unsigned char destination = memory_read_indirect ( memory_read_direct( BANKPSW + _R0_ ) );");
}
if ($op_destination == 5) { # @R1
- cfw("unsigned char destination = cpu8051_ReadI ( cpu8051_ReadD( BANKPSW + _R1_ ) );");
+ cfw("unsigned char destination = memory_read_indirect ( memory_read_direct( BANKPSW + _R1_ ) );");
}
if ($op_destination == 6) { # R0
- cfw("unsigned char destination = cpu8051_ReadD( BANKPSW + _R0_ );");
+ cfw("unsigned char destination = memory_read_direct( BANKPSW + _R0_ );");
}
if ($op_destination == 7) { # R1
- cfw("unsigned char destination = cpu8051_ReadD( BANKPSW + _R1_ );");
+ cfw("unsigned char destination = memory_read_direct( BANKPSW + _R1_ );");
}
if ($op_destination == 8) { # R2
- cfw("unsigned char destination = cpu8051_ReadD( BANKPSW + _R2_ );");
+ cfw("unsigned char destination = memory_read_direct( BANKPSW + _R2_ );");
}
if ($op_destination == 9) { # R3
- cfw("unsigned char destination = cpu8051_ReadD( BANKPSW + _R3_ );");
+ cfw("unsigned char destination = memory_read_direct( BANKPSW + _R3_ );");
}
if ($op_destination == 10) { # R4
- cfw("unsigned char destination = cpu8051_ReadD( BANKPSW + _R4_ );");
+ cfw("unsigned char destination = memory_read_direct( BANKPSW + _R4_ );");
}
if ($op_destination == 11) { # R5
- cfw("unsigned char destination = cpu8051_ReadD( BANKPSW + _R5_ );");
+ cfw("unsigned char destination = memory_read_direct( BANKPSW + _R5_ );");
}
if ($op_destination == 12) { # R6
- cfw("unsigned char destination = cpu8051_ReadD( BANKPSW + _R6_ );");
+ cfw("unsigned char destination = memory_read_direct( BANKPSW + _R6_ );");
}
if ($op_destination == 13) { # R7
- cfw("unsigned char destination = cpu8051_ReadD( BANKPSW + _R7_ );");
+ cfw("unsigned char destination = memory_read_direct( BANKPSW + _R7_ );");
}
if ($op_destination == 14) { # bitaddr
cfw("unsigned char destination, dstbitaddr = memory_read8( PGM_MEM_ID, cpu8051.pc++ );");
- cfw("destination = cpu8051_ReadB( dstbitaddr );");
+ cfw("destination = memory_read_bit( dstbitaddr );");
}
if ($op_destination == 15) { # reladdr
cfw("cpu8051.pc++;");
cfw("unsigned char destination = psw_read_cy();");
}
if ($op_destination == 18) { # @A+DPTR
- cfw("unsigned int destination = cpu8051_ReadD( _ACC_ ) + memory_sfr_read_dptr();");
+ cfw("unsigned int destination = memory_read_direct( _ACC_ ) + memory_sfr_read_dptr();");
}
if ($op_destination == 20) { # AB
- cfw("unsigned char destination = cpu8051_ReadD( _ACC_ );");
- cfw("unsigned char source = cpu8051_ReadD( _B_ );");
+ cfw("unsigned char destination = memory_read_direct( _ACC_ );");
+ cfw("unsigned char source = memory_read_direct( _B_ );");
}
if ($op_destination == 21) { # DPTR
cfw("unsigned int destination = memory_sfr_read_dptr();");
}
if ($op_destination == 23) { # /bitaddr
cfw("unsigned char destination, dstbitaddr = memory_read8( PGM_MEM_ID, (cpu8051.pc)++ );");
- cfw("destination = ( cpu8051_ReadB( dstbitaddr ) ^ 1 );");
+ cfw("destination = ( memory_read_bit( dstbitaddr ) ^ 1 );");
}
if ($op_destination == 24) { # @DPTR
- cfw("unsigned char destination = cpu8051_ReadI(memory_sfr_read_dptr());");
+ cfw("unsigned char destination = memory_read_indirect(memory_sfr_read_dptr());");
}
}
cfw("cpu8051.pc += 2;");
}
if ($op_source == 2) { # A
- cfw("unsigned char source = cpu8051_ReadD( _ACC_ );");
+ cfw("unsigned char source = memory_read_direct( _ACC_ );");
}
if ($op_source == 3) { # direct
cfw("unsigned char srcaddr = memory_read8( PGM_MEM_ID, (cpu8051.pc)++ );");
- cfw("unsigned char source = cpu8051_ReadD( srcaddr );");
+ cfw("unsigned char source = memory_read_direct( srcaddr );");
}
if ($op_source == 4) { # @R0
- cfw("unsigned char source = cpu8051_ReadI ( cpu8051_ReadD( BANKPSW + _R0_ ) );");
+ cfw("unsigned char source = memory_read_indirect ( memory_read_direct( BANKPSW + _R0_ ) );");
}
if ($op_source == 5) { # @R1
- cfw("unsigned char source = cpu8051_ReadI ( cpu8051_ReadD( BANKPSW + _R1_ ) );");
+ cfw("unsigned char source = memory_read_indirect ( memory_read_direct( BANKPSW + _R1_ ) );");
}
if ($op_source == 6) { # R0
- cfw("unsigned char source = cpu8051_ReadD( BANKPSW + _R0_ );");
+ cfw("unsigned char source = memory_read_direct( BANKPSW + _R0_ );");
}
if ($op_source == 7) { # R1
- cfw("unsigned char source = cpu8051_ReadD( BANKPSW + _R1_ );");
+ cfw("unsigned char source = memory_read_direct( BANKPSW + _R1_ );");
}
if ($op_source == 8) { # R2
- cfw("unsigned char source = cpu8051_ReadD( BANKPSW + _R2_ );");
+ cfw("unsigned char source = memory_read_direct( BANKPSW + _R2_ );");
}
if ($op_source == 9) { # R3
- cfw("unsigned char source = cpu8051_ReadD( BANKPSW + _R3_ );");
+ cfw("unsigned char source = memory_read_direct( BANKPSW + _R3_ );");
}
if ($op_source == 10) { # R4
- cfw("unsigned char source = cpu8051_ReadD( BANKPSW + _R4_ );");
+ cfw("unsigned char source = memory_read_direct( BANKPSW + _R4_ );");
}
if ($op_source == 11) { # R5
- cfw("unsigned char source = cpu8051_ReadD( BANKPSW + _R5_ );");
+ cfw("unsigned char source = memory_read_direct( BANKPSW + _R5_ );");
}
if ($op_source == 12) { # R6
- cfw("unsigned char source = cpu8051_ReadD( BANKPSW + _R6_ );");
+ cfw("unsigned char source = memory_read_direct( BANKPSW + _R6_ );");
}
if ($op_source == 13) { # R7
- cfw("unsigned char source = cpu8051_ReadD( BANKPSW + _R7_ );");
+ cfw("unsigned char source = memory_read_direct( BANKPSW + _R7_ );");
}
if ($op_source == 14) { # bitaddr
cfw("unsigned char source, srcbitaddr = memory_read8( PGM_MEM_ID, (cpu8051.pc)++ );");
- cfw("source = cpu8051_ReadB( srcbitaddr );");
+ cfw("source = memory_read_bit( srcbitaddr );");
}
if ($op_source == 15) { # reladdr
cfw("(cpu8051.pc)++;");
cfw("unsigned char source = psw_read_cy();");
}
if ($op_source == 18) { # @A+DPTR
- cfw("unsigned char source = memory_read8( PGM_MEM_ID, cpu8051_ReadD( _ACC_ ) + memory_sfr_read_dptr());");
+ cfw("unsigned char source = memory_read8( PGM_MEM_ID, memory_read_direct( _ACC_ ) + memory_sfr_read_dptr());");
}
if ($op_source == 19) { # @A+PC
- cfw("unsigned char source = memory_read8( PGM_MEM_ID, cpu8051_ReadD( _ACC_ ) + ( ++cpu8051.pc ) );");
+ cfw("unsigned char source = memory_read8( PGM_MEM_ID, memory_read_direct( _ACC_ ) + ( ++cpu8051.pc ) );");
}
if ($op_source == 21) { # DPTR
cfw("unsigned int source = memory_sfr_read_dptr();");
}
if ($op_source == 23) { # /bitaddr
cfw("unsigned char source, srcbitaddr = memory_read8( PGM_MEM_ID, (cpu8051.pc)++ );");
- cfw("source = ( cpu8051_ReadB( srcbitaddr ) ^ 1 );");
+ cfw("source = ( memory_read_bit( srcbitaddr ) ^ 1 );");
}
if ($op_source == 24) { # @DPTR
- cfw("unsigned char source = cpu8051_ReadI(memory_sfr_read_dptr());");
+ cfw("unsigned char source = memory_read_indirect(memory_sfr_read_dptr());");
}
}
# JZ
if ($insttype[$i] == 22) {
- cfw("if ( cpu8051_ReadD( _ACC_ ) == 0 ) { cpu8051.pc = destination; }");
+ cfw("if ( memory_read_direct( _ACC_ ) == 0 ) { cpu8051.pc = destination; }");
}
# XRL
# JNZ
if ($insttype[$i] == 24) {
- cfw("if ( cpu8051_ReadD( _ACC_ ) != 0 ) { cpu8051.pc = destination; }");
+ cfw("if ( memory_read_direct( _ACC_ ) != 0 ) { cpu8051.pc = destination; }");
}
# JMP
# If B is zero, the OV flag will be set indicating a
# division-by-zero error
cfw("if (source != 0) {");
- cfw(" cpu8051_WriteD(_ACC_, destination/source);");
- cfw(" cpu8051_WriteD( _B_, destination%source);");
+ cfw(" memory_write_direct(_ACC_, destination/source);");
+ cfw(" memory_write_direct( _B_, destination%source);");
cfw(" psw_clr_ov();");
cfw("} else {");
cfw(" psw_set_ov();");
# A = destination
# B = source
cfw("psw_clr_cy();");
- cfw("cpu8051_WriteD(_ACC_, destination * source);");
- cfw("cpu8051_WriteD(_B_, (destination * source) / 0x100);");
- cfw("if (cpu8051_ReadD(_B_) > 0)");
+ cfw("memory_write_direct(_ACC_, destination * source);");
+ cfw("memory_write_direct(_B_, (destination * source) / 0x100);");
+ cfw("if (memory_read_direct(_B_) > 0)");
cfw(" psw_set_ov();");
cfw("else");
cfw(" psw_clr_ov();");
cfw("cpu8051.pc = addr16;");
}
if ($op_destination == 2) { # A
- cfw("cpu8051_WriteD( _ACC_, destination );");
+ cfw("memory_write_direct( _ACC_, destination );");
}
if ($op_destination == 3) { # direct
- cfw("cpu8051_WriteD( destaddr, destination );");
+ cfw("memory_write_direct( destaddr, destination );");
}
if ($op_destination == 4) { # @R0
- cfw("cpu8051_WriteI( cpu8051_ReadD( BANKPSW + _R0_ ), destination );");
+ cfw("memory_write_indirect( memory_read_direct( BANKPSW + _R0_ ), destination );");
}
if ($op_destination == 5) { # @R1
- cfw("cpu8051_WriteI( cpu8051_ReadD( BANKPSW + _R1_ ), destination );");
+ cfw("memory_write_indirect( memory_read_direct( BANKPSW + _R1_ ), destination );");
}
if ($op_destination == 6) { # R0
- cfw("cpu8051_WriteD( BANKPSW + _R0_, destination );");
+ cfw("memory_write_direct( BANKPSW + _R0_, destination );");
}
if ($op_destination == 7) { # R1
- cfw("cpu8051_WriteD( BANKPSW + _R1_, destination );");
+ cfw("memory_write_direct( BANKPSW + _R1_, destination );");
}
if ($op_destination == 8) { # R2
- cfw("cpu8051_WriteD( BANKPSW + _R2_, destination );");
+ cfw("memory_write_direct( BANKPSW + _R2_, destination );");
}
if ($op_destination == 9) { # R3
- cfw("cpu8051_WriteD( BANKPSW + _R3_, destination );");
+ cfw("memory_write_direct( BANKPSW + _R3_, destination );");
}
if ($op_destination == 10) { # R4
- cfw("cpu8051_WriteD( BANKPSW + _R4_, destination );");
+ cfw("memory_write_direct( BANKPSW + _R4_, destination );");
}
if ($op_destination == 11) { # R5
- cfw("cpu8051_WriteD( BANKPSW + _R5_, destination );");
+ cfw("memory_write_direct( BANKPSW + _R5_, destination );");
}
if ($op_destination == 12) { # R6
- cfw("cpu8051_WriteD( BANKPSW + _R6_, destination );");
+ cfw("memory_write_direct( BANKPSW + _R6_, destination );");
}
if ($op_destination == 13) { # R7
- cfw("cpu8051_WriteD( BANKPSW + _R7_, destination );");
+ cfw("memory_write_direct( BANKPSW + _R7_, destination );");
}
if ($op_destination == 14) { # bitaddr
- cfw("cpu8051_WriteB( dstbitaddr, destination );");
+ cfw("memory_write_bit( dstbitaddr, destination );");
}
if ($op_destination == 17) { # C
cfw("psw_write_cy(destination);");
cfw("memory_sfr_write_dptr(destination);");
}
if ($op_destination == 23) { # /bitaddr
- cfw("cpu8051_WriteB( dstbitaddr, destination );");
+ cfw("memory_write_bit( dstbitaddr, destination );");
}
if ($op_destination == 24) { # @DPTR
- cfw("cpu8051_WriteI(memory_sfr_read_dptr(), destination);");
+ cfw("memory_write_indirect(memory_sfr_read_dptr(), destination);");
}
}
cfw("cpu8051.pc = addr16;");
}
if ($op_source == 2) { # A
- cfw("cpu8051_WriteD( _ACC_, source );");
+ cfw("memory_write_direct( _ACC_, source );");
}
if ($op_source == 3) { # direct
- cfw("cpu8051_WriteD( srcaddr, source );");
+ cfw("memory_write_direct( srcaddr, source );");
}
if ($op_source == 4) { # @R0
- cfw("cpu8051_WriteI( cpu8051_ReadD( BANKPSW + _R0_ ), source );");
+ cfw("memory_write_indirect( memory_read_direct( BANKPSW + _R0_ ), source );");
}
if ($op_source == 5) { # @R1
- cfw("cpu8051_WriteI( cpu8051_ReadD( BANKPSW + _R1_ ), source );");
+ cfw("memory_write_indirect( memory_read_direct( BANKPSW + _R1_ ), source );");
}
if ($op_source == 6) { # R0
- cfw("cpu8051_WriteD( BANKPSW + _R0_, source );");
+ cfw("memory_write_direct( BANKPSW + _R0_, source );");
}
if ($op_source == 7) { # R1
- cfw("cpu8051_WriteD( BANKPSW + _R1_, source );");
+ cfw("memory_write_direct( BANKPSW + _R1_, source );");
}
if ($op_source == 8) { # R2
- cfw("cpu8051_WriteD( BANKPSW + _R2_, source );");
+ cfw("memory_write_direct( BANKPSW + _R2_, source );");
}
if ($op_source == 9) { # R3
- cfw("cpu8051_WriteD( BANKPSW + _R3_, source );");
+ cfw("memory_write_direct( BANKPSW + _R3_, source );");
}
if ($op_source == 10) { # R4
- cfw("cpu8051_WriteD( BANKPSW + _R4_, source );");
+ cfw("memory_write_direct( BANKPSW + _R4_, source );");
}
if ($op_source == 11) { # R5
- cfw("cpu8051_WriteD( BANKPSW + _R5_, source );");
+ cfw("memory_write_direct( BANKPSW + _R5_, source );");
}
if ($op_source == 12) { # R6
- cfw("cpu8051_WriteD( BANKPSW + _R6_, source );");
+ cfw("memory_write_direct( BANKPSW + _R6_, source );");
}
if ($op_source == 13) { # R7
- cfw("cpu8051_WriteD( BANKPSW + _R7_, source );");
+ cfw("memory_write_direct( BANKPSW + _R7_, source );");
}
if ($op_source == 14) { # bitaddr
- cfw("cpu8051_WriteB( srcbitaddr, source );");
+ cfw("memory_write_bit( srcbitaddr, source );");
}
if ($op_source == 17) { # C
cfw("psw_write_cy(source);");
cfw("memory_sfr_write_dptr(source);");
}
if ($op_source == 23) { # /bitaddr
- cfw("cpu8051_WriteB( srcbitaddr, source );");
+ cfw("memory_write_bit( srcbitaddr, source );");
}
if ($op_source == 24) { # @DPTR
- cfw("cpu8051_WriteI(memory_sfr_read_dptr(), source);");
+ cfw("memory_write_indirect(memory_sfr_read_dptr(), source);");
}
}
}
write_header(INST_DEF);
print INST_DEF "#ifndef INSTRUCTIONS_8051_H\n";
print INST_DEF "#define INSTRUCTIONS_8051_H 1\n\n\n";
-print INST_DEF "#define BANKPSW (cpu8051_ReadD(_PSW_) & 0x18)\n\n";
+print INST_DEF "#define BANKPSW (memory_read_direct(_PSW_) & 0x18)\n\n";
print INST_DEF "typedef int (*OPCODE_FP)(void);\n\n\n";
for( $i=0; $i<256; $i++ ) {
print INST_DEF "int\n";
projects / emu8051.git / commitdiff