static void mon_register_list_set6502(mon_reg_list_t *reg_list, int mem)
{
do {
if (!strcmp(reg_list->name, "PC")) {
mon_register_set_val(mem, e_PC, (WORD)(reg_list->val));
}
if (!strcmp(reg_list->name, "AC")) {
mon_register_set_val(mem, e_A, (WORD)(reg_list->val));
}
if (!strcmp(reg_list->name, "XR")) {
mon_register_set_val(mem, e_X, (WORD)(reg_list->val));
}
if (!strcmp(reg_list->name, "YR")) {
mon_register_set_val(mem, e_Y, (WORD)(reg_list->val));
}
if (!strcmp(reg_list->name, "SP")) {
mon_register_set_val(mem, e_SP, (WORD)(reg_list->val));
}
if (!strcmp(reg_list->name, "00")) {
mon_set_mem_val(mem, 0, (BYTE)(reg_list->val));
}
if (!strcmp(reg_list->name, "01")) {
mon_set_mem_val(mem, 1, (BYTE)(reg_list->val));
}
if (!strcmp(reg_list->name, "NV-BDIZC")) {
mon_register_set_val(mem, e_FLAGS, (WORD)(reg_list->val));
}
reg_list = reg_list->next;
} while (reg_list != NULL);
}
static void mon_register_list_set6502dtv(mon_reg_list_t *reg_list, int mem)
{
do {
if (!strcmp(reg_list->name, "PC"))
mon_register_set_val(mem, e_PC, (WORD)(reg_list->val));
if (!strcmp(reg_list->name, "AC"))
mon_register_set_val(mem, e_A, (WORD)(reg_list->val));
if (!strcmp(reg_list->name, "XR"))
mon_register_set_val(mem, e_X, (WORD)(reg_list->val));
if (!strcmp(reg_list->name, "YR"))
mon_register_set_val(mem, e_Y, (WORD)(reg_list->val));
if (!strcmp(reg_list->name, "SP"))
mon_register_set_val(mem, e_SP, (WORD)(reg_list->val));
if (!strcmp(reg_list->name, "00"))
mon_set_mem_val(mem, 0, (BYTE)(reg_list->val));
if (!strcmp(reg_list->name, "01"))
mon_set_mem_val(mem, 1, (BYTE)(reg_list->val));
if (!strcmp(reg_list->name, "NV-BDIZC"))
mon_register_set_val(mem, e_FLAGS, (WORD)(reg_list->val));
if (!strcmp(reg_list->name, "R3"))
mon_register_set_val(mem, e_R3, (WORD)(reg_list->val));
if (!strcmp(reg_list->name, "R4"))
mon_register_set_val(mem, e_R4, (WORD)(reg_list->val));
if (!strcmp(reg_list->name, "R5"))
mon_register_set_val(mem, e_R5, (WORD)(reg_list->val));
if (!strcmp(reg_list->name, "R6"))
mon_register_set_val(mem, e_R6, (WORD)(reg_list->val));
if (!strcmp(reg_list->name, "R7"))
mon_register_set_val(mem, e_R7, (WORD)(reg_list->val));
if (!strcmp(reg_list->name, "R8"))
mon_register_set_val(mem, e_R8, (WORD)(reg_list->val));
if (!strcmp(reg_list->name, "R9"))
mon_register_set_val(mem, e_R9, (WORD)(reg_list->val));
if (!strcmp(reg_list->name, "R10"))
mon_register_set_val(mem, e_R10, (WORD)(reg_list->val));
if (!strcmp(reg_list->name, "R11"))
mon_register_set_val(mem, e_R11, (WORD)(reg_list->val));
if (!strcmp(reg_list->name, "R12"))
mon_register_set_val(mem, e_R12, (WORD)(reg_list->val));
if (!strcmp(reg_list->name, "R13"))
mon_register_set_val(mem, e_R13, (WORD)(reg_list->val));
if (!strcmp(reg_list->name, "R14"))
mon_register_set_val(mem, e_R15, (WORD)(reg_list->val));
if (!strcmp(reg_list->name, "R15"))
mon_register_set_val(mem, e_R15, (WORD)(reg_list->val));
if (!strcmp(reg_list->name, "ACM"))
mon_register_set_val(mem, e_ACM, (WORD)(reg_list->val));
if (!strcmp(reg_list->name, "YXM"))
mon_register_set_val(mem, e_YXM, (WORD)(reg_list->val));
reg_list = reg_list->next;
} while (reg_list != NULL);
}
void mon_memory_move(MON_ADDR start_addr, MON_ADDR end_addr, MON_ADDR dest)
{
unsigned int i, dst;
int len;
WORD start;
MEMSPACE src_mem, dest_mem;
BYTE *buf;
len = mon_evaluate_address_range(&start_addr, &end_addr, TRUE, -1);
if (len <= 0) {
mon_out("Invalid range.\n");
return;
}
src_mem = addr_memspace(start_addr);
start = addr_location(start_addr);
mon_evaluate_default_addr(&dest);
dst = addr_location(dest);
dest_mem = addr_memspace(dest);
buf = lib_malloc(sizeof(BYTE) * len);
for (i = 0; (int)i < len; i++) {
buf[i] = mon_get_mem_val(src_mem, (WORD)ADDR_LIMIT(start + i));
}
for (i = 0; (int)i < len; i++) {
mon_set_mem_val(dest_mem, (WORD)ADDR_LIMIT(dst + i), buf[i]);
}
lib_free(buf);
}
void mon_memory_fill(MON_ADDR start_addr, MON_ADDR end_addr,
unsigned char *data)
{
WORD start;
MEMSPACE dest_mem;
unsigned int i, mon_index;
int len;
len = mon_evaluate_address_range(&start_addr, &end_addr, FALSE,
(WORD)data_buf_len);
if (len < 0) {
mon_out("Invalid range.\n");
return;
}
start = addr_location(start_addr);
if (!mon_is_valid_addr(start_addr)) {
mon_out("Invalid start address\n");
return;
}
dest_mem = addr_memspace(start_addr);
i = 0;
mon_index = 0;
while ((int)i < len) {
mon_set_mem_val(dest_mem, (WORD)ADDR_LIMIT(start + i),
data_buf[mon_index++]);
if (mon_index >= data_buf_len) {
mon_index = 0;
}
i++;
}
mon_clear_buffer();
}
void mon_drive_block_cmd(int op, int track, int sector, MON_ADDR addr)
{
vdrive_t *vdrive;
mon_evaluate_default_addr(&addr);
vdrive = file_system_get_vdrive(8);
if (!vdrive || vdrive->image == NULL) {
mon_out("No disk attached\n");
return;
}
if (!op) {
BYTE readdata[256];
int i, j, dst;
MEMSPACE dest_mem;
/* We ignore disk error codes here. */
if (vdrive_read_sector(vdrive, readdata, track, sector)
< 0) {
mon_out("Error reading track %d sector %d\n", track, sector);
return;
}
if (mon_is_valid_addr(addr)) {
dst = addr_location(addr);
dest_mem = addr_memspace(addr);
for (i = 0; i < 256; i++) {
mon_set_mem_val(dest_mem, ADDR_LIMIT(dst + i), readdata[i]);
}
mon_out("Read track %d sector %d into address $%04x\n", track, sector, dst);
} else {
for (i = 0; i < 16; i++) {
mon_out(">%04x", i * 16);
for (j = 0; j < 16; j++) {
if ((j & 3) == 0) {
mon_out(" ");
}
mon_out(" %02x", readdata[i * 16 + j]);
}
mon_out("\n");
}
}
} else {
BYTE writedata[256];
int i, src;
MEMSPACE src_mem;
src = addr_location(addr);
src_mem = addr_memspace(addr);
for (i = 0; i < 256; i++) {
writedata[i] = mon_get_mem_val(src_mem, ADDR_LIMIT(src + i));
}
if (vdrive_write_sector(vdrive, writedata, track, sector)) {
mon_out("Error writing track %d sector %d\n", track, sector);
return;
}
mon_out("Write data from address $%04x to track %d sector %d\n",
src, track, sector);
}
}
static int mon_assemble_instr(const char *opcode_name, asm_mode_addr_info_t operand)
{
WORD operand_value = operand.param;
WORD operand_mode = operand.addr_mode;
BYTE operand_extra_value = operand.addr_submode;
BYTE i = 0, opcode = 0;
int len, branch_offset;
bool found = FALSE;
MEMSPACE mem;
WORD loc;
mem = addr_memspace(asm_mode_addr);
loc = addr_location(asm_mode_addr);
do {
const asm_opcode_info_t *opinfo;
opinfo = (monitor_cpu_for_memspace[mem]->asm_opcode_info_get)(i, 0, 0);
if (!strcasecmp(opinfo->mnemonic, opcode_name)) {
/* Special case: ZERO PAGE RELATIVE mode needs special handling. */
if (opinfo->addr_mode == ASM_ADDR_MODE_ZERO_PAGE_RELATIVE
&& operand_mode == ASM_ADDR_MODE_DOUBLE) {
branch_offset = (operand_value - loc - 3) & 0xffff;
if (branch_offset > 0x7f && branch_offset < 0xff80) {
mon_out("Branch offset too large.\n");
return -1;
}
operand_value = (operand_extra_value & 0xff) | ((branch_offset & 0xff) << 8);
opcode = i;
operand_mode = ASM_ADDR_MODE_ZERO_PAGE_RELATIVE;
found = TRUE;
break;
}
if (opinfo->addr_mode == operand_mode && found == FALSE) {
opcode = i;
found = TRUE;
break;
}
/* Special case: Register A not specified for ACCUMULATOR mode. */
if (operand_mode == ASM_ADDR_MODE_IMPLIED
&& opinfo->addr_mode == ASM_ADDR_MODE_ACCUMULATOR) {
opcode = i;
operand_mode = ASM_ADDR_MODE_ACCUMULATOR;
found = TRUE;
break;
}
/* Special case: RELATIVE mode looks like ZERO_PAGE or ABSOLUTE
modes. */
if ((operand_mode == ASM_ADDR_MODE_ZERO_PAGE
|| operand_mode == ASM_ADDR_MODE_ABSOLUTE)
&& opinfo->addr_mode == ASM_ADDR_MODE_RELATIVE) {
branch_offset = (operand_value - loc - 2) & 0xffff;
if (branch_offset > 0x7f && branch_offset < 0xff80) {
mon_out("Branch offset too large.\n");
return -1;
}
operand_value = (branch_offset & 0xff);
operand_mode = ASM_ADDR_MODE_RELATIVE;
opcode = i;
found = TRUE;
break;
}
/* Special case: opcode A - is A a register or $A? */
/* If second case, is it zero page or absolute? */
if (operand_mode == ASM_ADDR_MODE_ACCUMULATOR
&& opinfo->addr_mode == ASM_ADDR_MODE_ZERO_PAGE) {
opcode = i;
operand_mode = ASM_ADDR_MODE_ZERO_PAGE;
operand_value = 0x000a;
found = TRUE;
break;
}
/* It's safe to assume ABSOLUTE if ZERO_PAGE not yet found since
* ZERO_PAGE versions always precede ABSOLUTE versions if they
* exist.
*/
if (operand_mode == ASM_ADDR_MODE_ACCUMULATOR
&& opinfo->addr_mode == ASM_ADDR_MODE_ABSOLUTE) {
opcode = i;
operand_mode = ASM_ADDR_MODE_ABSOLUTE;
operand_value = 0x000a;
found = TRUE;
break;
}
/* It's safe to assume ABSOULTE if ZERO_PAGE not yet found since
* ZERO_PAGE versions always precede ABSOLUTE versions if they
* exist.
*/
if (operand_mode == ASM_ADDR_MODE_ZERO_PAGE
&& opinfo->addr_mode == ASM_ADDR_MODE_ABSOLUTE) {
opcode = i;
operand_mode = ASM_ADDR_MODE_ABSOLUTE;
found = TRUE;
break;
}
}
i++;
} while (i != 0);
if (!found) {
mon_out("Instruction not valid.\n");
return -1;
}
len = (monitor_cpu_for_memspace[mem]->asm_addr_mode_get_size)
((unsigned int)(operand_mode), 0, 0, 0);
/* EP 98.08.23 use correct memspace for assembling. */
mon_set_mem_val(mem, loc, opcode);
if (len >= 2) {
mon_set_mem_val(mem, (WORD)(loc + 1), (BYTE)(operand_value & 0xff));
}
if (len >= 3) {
mon_set_mem_val(mem, (WORD)(loc + 2),
(BYTE)((operand_value >> 8) & 0xff));
}
