Add the cpm emulator from Cowgol, modified to work with an 8080 emulator rather
than libz80ex; enable tests for cpm.
This commit is contained in:
David Given
parent
a6b8ae66d7
commit
7473601172
116
plat/cpm/emu/bdos.s
Normal file
116
plat/cpm/emu/bdos.s
Normal file
|
|
@ -0,0 +1,116 @@
|
||||||
|
#
|
||||||
|
.sect .text
|
||||||
|
.sect .rom
|
||||||
|
.sect .data
|
||||||
|
.sect .bss
|
||||||
|
|
||||||
|
.sect .text
|
||||||
|
|
||||||
|
bdos: ! BDOS entry point
|
||||||
|
out 0xff
|
||||||
|
ora a
|
||||||
|
ret
|
||||||
|
|
||||||
|
COLDSTART: ! system startup entry point --- this needs to be four bytes after FBASE.
|
||||||
|
jmp boot ! 0: Cold start routine
|
||||||
|
bios:
|
||||||
|
jmp wboot ! 1: Warm boot - reload command processor
|
||||||
|
jmp const ! 2: Console status
|
||||||
|
jmp conin ! 3: Console input
|
||||||
|
jmp conout ! 4: Console output
|
||||||
|
jmp list ! 5: Printer output
|
||||||
|
jmp punch ! 6: Paper tape punch output
|
||||||
|
jmp reader ! 7: Paper tape reader input
|
||||||
|
jmp home ! 8: Move disc head to track 0
|
||||||
|
jmp seldsk ! 9: Select disc drive
|
||||||
|
jmp settrk !10: Set track number
|
||||||
|
jmp setsec !11: Set sector number
|
||||||
|
jmp setdma !12: Set DMA address
|
||||||
|
jmp read !13: Read a sector
|
||||||
|
jmp write !14: Write a sector
|
||||||
|
|
||||||
|
boot:
|
||||||
|
xra a
|
||||||
|
sta 3 ! iobyte
|
||||||
|
sta 4 ! drive
|
||||||
|
! falls through
|
||||||
|
wboot:
|
||||||
|
mvi a, 0xc3 ! jmp
|
||||||
|
sta 0
|
||||||
|
sta 5
|
||||||
|
|
||||||
|
lxi h, bios
|
||||||
|
shld 1
|
||||||
|
|
||||||
|
lxi h, bdos
|
||||||
|
shld 6
|
||||||
|
|
||||||
|
lda 4 ! get the current drive/user
|
||||||
|
mov c, a
|
||||||
|
out 1
|
||||||
|
|
||||||
|
const:
|
||||||
|
out 2
|
||||||
|
ora a
|
||||||
|
ret
|
||||||
|
|
||||||
|
conin:
|
||||||
|
out 3
|
||||||
|
ora a
|
||||||
|
ret
|
||||||
|
|
||||||
|
conout:
|
||||||
|
out 4
|
||||||
|
ora a
|
||||||
|
ret
|
||||||
|
|
||||||
|
list:
|
||||||
|
out 5
|
||||||
|
ora a
|
||||||
|
ret
|
||||||
|
|
||||||
|
punch:
|
||||||
|
out 6
|
||||||
|
ora a
|
||||||
|
ret
|
||||||
|
|
||||||
|
reader:
|
||||||
|
out 7
|
||||||
|
ora a
|
||||||
|
ret
|
||||||
|
|
||||||
|
home:
|
||||||
|
out 8
|
||||||
|
ora a
|
||||||
|
ret
|
||||||
|
|
||||||
|
seldsk:
|
||||||
|
out 9
|
||||||
|
ora a
|
||||||
|
ret
|
||||||
|
|
||||||
|
settrk:
|
||||||
|
out 10
|
||||||
|
ora a
|
||||||
|
ret
|
||||||
|
|
||||||
|
setsec:
|
||||||
|
out 11
|
||||||
|
ora a
|
||||||
|
ret
|
||||||
|
|
||||||
|
setdma:
|
||||||
|
out 12
|
||||||
|
ora a
|
||||||
|
ret
|
||||||
|
|
||||||
|
read:
|
||||||
|
out 13
|
||||||
|
ora a
|
||||||
|
ret
|
||||||
|
|
||||||
|
write:
|
||||||
|
out 14
|
||||||
|
ora a
|
||||||
|
ret
|
||||||
|
|
||||||
451
plat/cpm/emu/biosbdos.c
Normal file
451
plat/cpm/emu/biosbdos.c
Normal file
|
|
@ -0,0 +1,451 @@
|
||||||
|
#include <stdio.h>
|
||||||
|
#include <stdlib.h>
|
||||||
|
#include <stdint.h>
|
||||||
|
#include <string.h>
|
||||||
|
#include <ctype.h>
|
||||||
|
#include <glob.h>
|
||||||
|
#include <sys/types.h>
|
||||||
|
#include <sys/stat.h>
|
||||||
|
#include <fcntl.h>
|
||||||
|
#include <unistd.h>
|
||||||
|
#include <poll.h>
|
||||||
|
#include <errno.h>
|
||||||
|
#include "intel_8080_emulator.h"
|
||||||
|
#include "globals.h"
|
||||||
|
|
||||||
|
#define FBASE 0xff00
|
||||||
|
#define COLDSTART (FBASE + 4) /* see bdos.asm */
|
||||||
|
#define CBASE (FBASE - (7*1024))
|
||||||
|
|
||||||
|
static uint16_t dma;
|
||||||
|
static int exitcode = 0;
|
||||||
|
|
||||||
|
struct fcb
|
||||||
|
{
|
||||||
|
cpm_filename_t filename; /* includes drive */
|
||||||
|
uint8_t extent;
|
||||||
|
uint8_t s1;
|
||||||
|
uint8_t s2;
|
||||||
|
uint8_t recordcount;
|
||||||
|
uint8_t d[16];
|
||||||
|
uint8_t currentrecord;
|
||||||
|
uint8_t r[3];
|
||||||
|
};
|
||||||
|
|
||||||
|
static void bios_getchar(void);
|
||||||
|
|
||||||
|
static uint16_t get_de(void)
|
||||||
|
{
|
||||||
|
return i8080_read_reg16(DE);
|
||||||
|
}
|
||||||
|
|
||||||
|
static uint8_t get_c(void)
|
||||||
|
{
|
||||||
|
return i8080_read_reg8(C);
|
||||||
|
}
|
||||||
|
|
||||||
|
static uint8_t get_d(void)
|
||||||
|
{
|
||||||
|
return i8080_read_reg8(D);
|
||||||
|
}
|
||||||
|
|
||||||
|
static uint8_t get_e(void)
|
||||||
|
{
|
||||||
|
return i8080_read_reg8(E);
|
||||||
|
}
|
||||||
|
|
||||||
|
static uint8_t get_a(void)
|
||||||
|
{
|
||||||
|
return i8080_read_reg8(A);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void set_a(uint8_t a)
|
||||||
|
{
|
||||||
|
i8080_write_reg8(A, a);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void set_result(uint16_t result)
|
||||||
|
{
|
||||||
|
i8080_write_reg16(HL, result);
|
||||||
|
|
||||||
|
i8080_write_reg8(A, result);
|
||||||
|
uint8_t f = i8080_read_reg8(FLAGS);
|
||||||
|
f &= ~(1<<6) & ~(1<<7);
|
||||||
|
if (!result)
|
||||||
|
f |= 1<<6;
|
||||||
|
if (result & 0x80)
|
||||||
|
f |= 1<<7;
|
||||||
|
i8080_write_reg8(FLAGS, f);
|
||||||
|
|
||||||
|
i8080_write_reg8(B, result);
|
||||||
|
}
|
||||||
|
|
||||||
|
void bios_coldboot(void)
|
||||||
|
{
|
||||||
|
memcpy(&ram[FBASE], bdos_data, bdos_len);
|
||||||
|
i8080_write_reg16(PC, COLDSTART);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void bios_warmboot(void)
|
||||||
|
{
|
||||||
|
dma = 0x0080;
|
||||||
|
|
||||||
|
if (!user_command_line[0])
|
||||||
|
fatal("running the CCP isn't supported");
|
||||||
|
|
||||||
|
static bool terminate_next_time = false;
|
||||||
|
if (terminate_next_time)
|
||||||
|
exit(exitcode);
|
||||||
|
terminate_next_time = true;
|
||||||
|
|
||||||
|
i8080_write_reg16(PC, 0x0100);
|
||||||
|
|
||||||
|
/* Push the magic exit code onto the stack. */
|
||||||
|
i8080_write_reg16(SP, FBASE-4);
|
||||||
|
ram[FBASE-4] = (FBASE-2) & 0xFF;
|
||||||
|
ram[FBASE-3] = (FBASE-2) >> 8;
|
||||||
|
ram[FBASE-2] = 0xD3; // out (??), a
|
||||||
|
ram[FBASE-1] = 0xFE; // exit emulator
|
||||||
|
|
||||||
|
int fd = open(user_command_line[0], O_RDONLY);
|
||||||
|
if (fd == -1)
|
||||||
|
fatal("couldn't open program: %s", strerror(errno));
|
||||||
|
read(fd, &ram[0x0100], 0xFE00);
|
||||||
|
close(fd);
|
||||||
|
|
||||||
|
int offset = 1;
|
||||||
|
for (int word = 1; user_command_line[word]; word++)
|
||||||
|
{
|
||||||
|
if (word > 1)
|
||||||
|
{
|
||||||
|
ram[0x0080 + offset] = ' ';
|
||||||
|
offset++;
|
||||||
|
}
|
||||||
|
|
||||||
|
const char* pin = user_command_line[word];
|
||||||
|
while (*pin)
|
||||||
|
{
|
||||||
|
if (offset > 125)
|
||||||
|
fatal("user command line too long");
|
||||||
|
ram[0x0080 + offset] = toupper(*pin++);
|
||||||
|
offset++;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
ram[0x0080] = offset;
|
||||||
|
ram[0x0080+offset] = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void bios_const(void)
|
||||||
|
{
|
||||||
|
struct pollfd pollfd = { 0, POLLIN, 0 };
|
||||||
|
poll(&pollfd, 1, 0);
|
||||||
|
set_a((pollfd.revents & POLLIN) ? 0xff : 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void bios_getchar(void)
|
||||||
|
{
|
||||||
|
char c = 0;
|
||||||
|
(void) read(0, &c, 1);
|
||||||
|
if (c == '\n')
|
||||||
|
c = '\r';
|
||||||
|
set_a(c);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void bios_putchar(void)
|
||||||
|
{
|
||||||
|
char c = get_c();
|
||||||
|
(void) write(1, &c, 1);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void bios_entry(uint8_t bios_call)
|
||||||
|
{
|
||||||
|
switch (bios_call)
|
||||||
|
{
|
||||||
|
case 0: bios_coldboot(); return;
|
||||||
|
case 1: bios_warmboot(); return;
|
||||||
|
case 2: bios_const(); return; // const
|
||||||
|
case 3: bios_getchar(); return; // conin
|
||||||
|
case 4: bios_putchar(); return; // conout
|
||||||
|
|
||||||
|
case 0xFE: exit(0); // magic emulator exit
|
||||||
|
}
|
||||||
|
|
||||||
|
showregs();
|
||||||
|
fatal("unimplemented bios entry %d", bios_call);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void bdos_getchar(void)
|
||||||
|
{
|
||||||
|
bios_getchar();
|
||||||
|
set_result(get_a());
|
||||||
|
}
|
||||||
|
|
||||||
|
static void bdos_putchar(void)
|
||||||
|
{
|
||||||
|
uint8_t c = get_e();
|
||||||
|
(void) write(1, &c, 1);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void bdos_consoleio(void)
|
||||||
|
{
|
||||||
|
uint8_t c = get_e();
|
||||||
|
if (c == 0xff)
|
||||||
|
{
|
||||||
|
bios_const();
|
||||||
|
if (get_a() == 0xff)
|
||||||
|
bios_getchar();
|
||||||
|
}
|
||||||
|
else
|
||||||
|
bdos_putchar();
|
||||||
|
}
|
||||||
|
|
||||||
|
static void bdos_printstring(void)
|
||||||
|
{
|
||||||
|
uint16_t de = get_de();
|
||||||
|
for (;;)
|
||||||
|
{
|
||||||
|
uint8_t c = ram[de++];
|
||||||
|
if (c == '$')
|
||||||
|
break;
|
||||||
|
(void) write(1, &c, 1);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
static void bdos_consolestatus(void)
|
||||||
|
{
|
||||||
|
bios_const();
|
||||||
|
set_result(get_a());
|
||||||
|
}
|
||||||
|
|
||||||
|
void bdos_readline(void)
|
||||||
|
{
|
||||||
|
fflush(stdout);
|
||||||
|
|
||||||
|
uint16_t de = i8080_read_reg16(DE);
|
||||||
|
uint8_t maxcount = ram[de+0];
|
||||||
|
int count = read(0, &ram[de+2], maxcount);
|
||||||
|
if ((count > 0) && (ram[de+2+count-1] == '\n'))
|
||||||
|
count--;
|
||||||
|
ram[de+1] = count;
|
||||||
|
set_result(count);
|
||||||
|
}
|
||||||
|
|
||||||
|
static struct fcb* fcb_at(uint16_t address)
|
||||||
|
{
|
||||||
|
struct fcb* fcb = (struct fcb*) &ram[address];
|
||||||
|
|
||||||
|
/* Autoselect the current drive. */
|
||||||
|
if (fcb->filename.drive == 0)
|
||||||
|
fcb->filename.drive = ram[4] + 1;
|
||||||
|
|
||||||
|
return fcb;
|
||||||
|
}
|
||||||
|
|
||||||
|
static struct fcb* find_fcb(void)
|
||||||
|
{
|
||||||
|
return fcb_at(i8080_read_reg16(DE));
|
||||||
|
}
|
||||||
|
|
||||||
|
static int get_current_record(struct fcb* fcb)
|
||||||
|
{
|
||||||
|
return (fcb->extent * 128) + fcb->currentrecord;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void set_current_record(struct fcb* fcb, int record, int total)
|
||||||
|
{
|
||||||
|
int extents = total / 128;
|
||||||
|
fcb->extent = record / 128;
|
||||||
|
if (fcb->extent < extents)
|
||||||
|
fcb->recordcount = 128;
|
||||||
|
else
|
||||||
|
fcb->recordcount = total % 128;
|
||||||
|
fcb->currentrecord = record % 128;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void bdos_resetdisk(void)
|
||||||
|
{
|
||||||
|
dma = 0x0080;
|
||||||
|
ram[4] = 0; /* select drive A */
|
||||||
|
set_result(0xff);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void bdos_selectdisk(void)
|
||||||
|
{
|
||||||
|
uint8_t e = get_e();
|
||||||
|
ram[4] = e;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void bdos_getdisk(void)
|
||||||
|
{
|
||||||
|
set_result(ram[4]);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void bdos_openfile(void)
|
||||||
|
{
|
||||||
|
struct fcb* fcb = find_fcb();
|
||||||
|
struct file* f = file_open(&fcb->filename);
|
||||||
|
if (f)
|
||||||
|
{
|
||||||
|
set_current_record(fcb, 0, file_getrecordcount(f));
|
||||||
|
set_result(0);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
set_result(0xff);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void bdos_makefile(void)
|
||||||
|
{
|
||||||
|
struct fcb* fcb = find_fcb();
|
||||||
|
struct file* f = file_create(&fcb->filename);
|
||||||
|
if (f)
|
||||||
|
{
|
||||||
|
set_current_record(fcb, 0, 0);
|
||||||
|
set_result(0);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
set_result(0xff);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void bdos_closefile(void)
|
||||||
|
{
|
||||||
|
struct fcb* fcb = find_fcb();
|
||||||
|
struct file* f = file_open(&fcb->filename);
|
||||||
|
if (file_getrecordcount(f) < 128)
|
||||||
|
file_setrecordcount(f, fcb->recordcount);
|
||||||
|
int result = file_close(&fcb->filename);
|
||||||
|
set_result(result ? 0xff : 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void bdos_renamefile(void)
|
||||||
|
{
|
||||||
|
struct fcb* srcfcb = fcb_at(i8080_read_reg16(DE));
|
||||||
|
struct fcb* destfcb = fcb_at(i8080_read_reg16(DE)+16);
|
||||||
|
int result = file_rename(&srcfcb->filename, &destfcb->filename);
|
||||||
|
set_result(result ? 0xff : 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void bdos_findnext(void)
|
||||||
|
{
|
||||||
|
struct fcb* fcb = (struct fcb*) &ram[dma];
|
||||||
|
memset(fcb, 0, sizeof(struct fcb));
|
||||||
|
int i = file_findnext(&fcb->filename);
|
||||||
|
set_result(i ? 0xff : 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void bdos_findfirst(void)
|
||||||
|
{
|
||||||
|
struct fcb* fcb = find_fcb();
|
||||||
|
int i = file_findfirst(&fcb->filename);
|
||||||
|
if (i == 0)
|
||||||
|
bdos_findnext();
|
||||||
|
else
|
||||||
|
set_result(i ? 0xff : 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void bdos_deletefile(void)
|
||||||
|
{
|
||||||
|
struct fcb* fcb = find_fcb();
|
||||||
|
int i = file_delete(&fcb->filename);
|
||||||
|
set_result(i ? 0xff : 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
typedef int readwrite_cb(struct file* f, uint8_t* ptr, uint16_t record);
|
||||||
|
|
||||||
|
static void bdos_readwritesequential(readwrite_cb* readwrite)
|
||||||
|
{
|
||||||
|
struct fcb* fcb = find_fcb();
|
||||||
|
|
||||||
|
struct file* f = file_open(&fcb->filename);
|
||||||
|
int here = get_current_record(fcb);
|
||||||
|
int i = readwrite(f, &ram[dma], here);
|
||||||
|
set_current_record(fcb, here+1, file_getrecordcount(f));
|
||||||
|
if (i == -1)
|
||||||
|
set_result(0xff);
|
||||||
|
else if (i == 0)
|
||||||
|
set_result(1);
|
||||||
|
else
|
||||||
|
set_result(0);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void bdos_readwriterandom(readwrite_cb* readwrite)
|
||||||
|
{
|
||||||
|
struct fcb* fcb = find_fcb();
|
||||||
|
|
||||||
|
uint16_t record = fcb->r[0] + (fcb->r[1]<<8);
|
||||||
|
struct file* f = file_open(&fcb->filename);
|
||||||
|
int i = readwrite(f, &ram[dma], record);
|
||||||
|
set_current_record(fcb, record, file_getrecordcount(f));
|
||||||
|
if (i == -1)
|
||||||
|
set_result(0xff);
|
||||||
|
else if (i == 0)
|
||||||
|
set_result(1);
|
||||||
|
else
|
||||||
|
set_result(0);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void bdos_filelength(void)
|
||||||
|
{
|
||||||
|
struct fcb* fcb = find_fcb();
|
||||||
|
struct file* f = file_open(&fcb->filename);
|
||||||
|
|
||||||
|
int length = file_getrecordcount(f);
|
||||||
|
fcb->r[0] = length;
|
||||||
|
fcb->r[1] = length>>8;
|
||||||
|
fcb->r[2] = length>>16;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void bdos_getsetuser(void)
|
||||||
|
{
|
||||||
|
if (get_e() == 0xff)
|
||||||
|
set_result(0);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void bdos_entry(uint8_t bdos_call)
|
||||||
|
{
|
||||||
|
switch (bdos_call)
|
||||||
|
{
|
||||||
|
case 1: bdos_getchar(); return;
|
||||||
|
case 2: bdos_putchar(); return;
|
||||||
|
case 6: bdos_consoleio(); return;
|
||||||
|
case 9: bdos_printstring(); return;
|
||||||
|
case 10: bdos_readline(); return;
|
||||||
|
case 11: bdos_consolestatus(); return;
|
||||||
|
case 12: set_result(0x0022); return; // get CP/M version
|
||||||
|
case 13: bdos_resetdisk(); return; // reset disk system
|
||||||
|
case 14: bdos_selectdisk(); return; // select disk
|
||||||
|
case 15: bdos_openfile(); return;
|
||||||
|
case 16: bdos_closefile(); return;
|
||||||
|
case 17: bdos_findfirst(); return;
|
||||||
|
case 18: bdos_findnext(); return;
|
||||||
|
case 19: bdos_deletefile(); return;
|
||||||
|
case 20: bdos_readwritesequential(file_read); return;
|
||||||
|
case 21: bdos_readwritesequential(file_write); return;
|
||||||
|
case 22: bdos_makefile(); return;
|
||||||
|
case 23: bdos_renamefile(); return;
|
||||||
|
case 24: set_result(0xffff); return; // get login vector
|
||||||
|
case 25: bdos_getdisk(); return; // get current disk
|
||||||
|
case 26: dma = get_de(); return; // set DMA
|
||||||
|
case 27: set_result(0); return; // get allocation vector
|
||||||
|
case 29: set_result(0x0000); return; // get read-only vector
|
||||||
|
case 31: set_result(0); return; // get disk parameter block
|
||||||
|
case 32: bdos_getsetuser(); return;
|
||||||
|
case 33: bdos_readwriterandom(file_read); return;
|
||||||
|
case 34: bdos_readwriterandom(file_write); return;
|
||||||
|
case 35: bdos_filelength(); return;
|
||||||
|
case 40: bdos_readwriterandom(file_write); return;
|
||||||
|
case 45: return; // set hardware error action
|
||||||
|
case 108: exitcode = get_d(); return; // set exit code
|
||||||
|
}
|
||||||
|
|
||||||
|
showregs();
|
||||||
|
fatal("unimplemented bdos entry %d", bdos_call);
|
||||||
|
}
|
||||||
|
|
||||||
|
void biosbdos_entry(int syscall)
|
||||||
|
{
|
||||||
|
if (syscall == 0xff)
|
||||||
|
bdos_entry(i8080_read_reg16(BC));
|
||||||
|
else
|
||||||
|
bios_entry(syscall);
|
||||||
|
}
|
||||||
|
|
||||||
44
plat/cpm/emu/build.lua
Normal file
44
plat/cpm/emu/build.lua
Normal file
|
|
@ -0,0 +1,44 @@
|
||||||
|
ackfile {
|
||||||
|
name = "bdos_o",
|
||||||
|
srcs = { "./*.s" },
|
||||||
|
vars = { plat = "cpm" },
|
||||||
|
}
|
||||||
|
|
||||||
|
normalrule {
|
||||||
|
name = "bdos_out",
|
||||||
|
ins = {
|
||||||
|
"util/led+led",
|
||||||
|
"+bdos_o",
|
||||||
|
},
|
||||||
|
outleaves = { "bdos.out" },
|
||||||
|
commands = { "%{ins[1]} -b0:0xff00 %{ins[2]} -o %{outs[1]}" }
|
||||||
|
}
|
||||||
|
|
||||||
|
normalrule {
|
||||||
|
name = "bdos_img",
|
||||||
|
ins = {
|
||||||
|
"util/amisc+aslod",
|
||||||
|
"+bdos_out",
|
||||||
|
},
|
||||||
|
outleaves = { "bdos.img" },
|
||||||
|
commands = { "%{ins[1]} %{ins[2]} %{outs[1]}" }
|
||||||
|
}
|
||||||
|
|
||||||
|
normalrule {
|
||||||
|
name = "bdos_c",
|
||||||
|
ins = {
|
||||||
|
"util/cmisc+objectify",
|
||||||
|
"+bdos_img",
|
||||||
|
},
|
||||||
|
outleaves = { "bdos.c" },
|
||||||
|
commands = { "%{ins[1]} bdos < %{ins[2]} > %{outs[1]}" }
|
||||||
|
}
|
||||||
|
|
||||||
|
cprogram {
|
||||||
|
name = "emu",
|
||||||
|
srcs = {
|
||||||
|
"+bdos_c",
|
||||||
|
"./*.c"
|
||||||
|
},
|
||||||
|
}
|
||||||
|
|
||||||
378
plat/cpm/emu/emulator.c
Normal file
378
plat/cpm/emu/emulator.c
Normal file
|
|
@ -0,0 +1,378 @@
|
||||||
|
#define _POSIX_C_SOURCE 199309
|
||||||
|
#include <stdlib.h>
|
||||||
|
#include <stdio.h>
|
||||||
|
#include <stdint.h>
|
||||||
|
#include <signal.h>
|
||||||
|
#include <string.h>
|
||||||
|
#include "intel_8080_emulator.h"
|
||||||
|
#include "globals.h"
|
||||||
|
|
||||||
|
uint8_t ram[0x10000];
|
||||||
|
|
||||||
|
struct watchpoint
|
||||||
|
{
|
||||||
|
uint16_t address;
|
||||||
|
uint8_t value;
|
||||||
|
bool enabled;
|
||||||
|
};
|
||||||
|
|
||||||
|
static uint16_t breakpoints[16];
|
||||||
|
static struct watchpoint watchpoints[16];
|
||||||
|
static bool tracing = false;
|
||||||
|
static bool singlestepping = true;
|
||||||
|
static bool bdosbreak = false;
|
||||||
|
|
||||||
|
uint8_t i8080_read(uint16_t addr)
|
||||||
|
{
|
||||||
|
return ram[addr];
|
||||||
|
}
|
||||||
|
|
||||||
|
void i8080_write(uint16_t addr, uint8_t value)
|
||||||
|
{
|
||||||
|
ram[addr] = value;
|
||||||
|
}
|
||||||
|
|
||||||
|
uint8_t i8080_inport(uint8_t addr)
|
||||||
|
{
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
void i8080_outport(uint8_t addr, uint8_t value)
|
||||||
|
{
|
||||||
|
biosbdos_entry(addr & 0xff);
|
||||||
|
if (bdosbreak)
|
||||||
|
singlestepping = true;
|
||||||
|
}
|
||||||
|
|
||||||
|
void showregs(void)
|
||||||
|
{
|
||||||
|
uint16_t af = i8080_read_reg16(AF);
|
||||||
|
printf("%c%c.%c.%c%c%c sp=%04x af=%04x bc=%04x de=%04x hl=%04x\n",
|
||||||
|
(af & 0x80) ? 'S' : 's',
|
||||||
|
(af & 0x40) ? 'Z' : 'z',
|
||||||
|
(af & 0x10) ? 'H' : 'h',
|
||||||
|
(af & 0x04) ? 'P' : 'p',
|
||||||
|
(af & 0x02) ? 'N' : 'n',
|
||||||
|
(af & 0x01) ? 'C' : 'c',
|
||||||
|
i8080_read_reg16(SP),
|
||||||
|
af,
|
||||||
|
i8080_read_reg16(BC),
|
||||||
|
i8080_read_reg16(DE),
|
||||||
|
i8080_read_reg16(HL));
|
||||||
|
|
||||||
|
char buffer[80];
|
||||||
|
int tstates;
|
||||||
|
uint16_t pc = i8080_read_reg16(PC);
|
||||||
|
//z80ex_dasm(buffer, sizeof(buffer), 0, &tstates, &tstates, dasm_read_cb, pc, NULL);
|
||||||
|
strcpy(buffer, "<not implemented>");
|
||||||
|
printf("%04x : %s\n", pc, buffer);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void cmd_register(void)
|
||||||
|
{
|
||||||
|
char* w1 = strtok(NULL, " ");
|
||||||
|
char* w2 = strtok(NULL, " ");
|
||||||
|
|
||||||
|
if (w1 && w2)
|
||||||
|
{
|
||||||
|
Z80_REG_T reg = -1;
|
||||||
|
if (strcmp(w1, "sp") == 0)
|
||||||
|
reg = SP;
|
||||||
|
else if (strcmp(w1, "pc") == 0)
|
||||||
|
reg = PC;
|
||||||
|
else if (strcmp(w1, "af") == 0)
|
||||||
|
reg = AF;
|
||||||
|
else if (strcmp(w1, "bc") == 0)
|
||||||
|
reg = BC;
|
||||||
|
else if (strcmp(w1, "de") == 0)
|
||||||
|
reg = DE;
|
||||||
|
else if (strcmp(w1, "hl") == 0)
|
||||||
|
reg = HL;
|
||||||
|
else
|
||||||
|
{
|
||||||
|
printf("Bad register\n");
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
i8080_write_reg16(reg, strtoul(w2, NULL, 16));
|
||||||
|
}
|
||||||
|
|
||||||
|
showregs();
|
||||||
|
}
|
||||||
|
|
||||||
|
static void cmd_break(void)
|
||||||
|
{
|
||||||
|
char* w1 = strtok(NULL, " ");
|
||||||
|
if (w1)
|
||||||
|
{
|
||||||
|
uint16_t breakpc = strtoul(w1, NULL, 16);
|
||||||
|
for (int i=0; i<sizeof(breakpoints)/sizeof(*breakpoints); i++)
|
||||||
|
{
|
||||||
|
if (breakpoints[i] == 0xffff)
|
||||||
|
{
|
||||||
|
breakpoints[i] = breakpc;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
printf("Too many breakpoints\n");
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
for (int i=0; i<sizeof(breakpoints)/sizeof(*breakpoints); i++)
|
||||||
|
{
|
||||||
|
if (breakpoints[i] != 0xffff)
|
||||||
|
printf("%04x\n", breakpoints[i]);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
static void cmd_watch(void)
|
||||||
|
{
|
||||||
|
char* w1 = strtok(NULL, " ");
|
||||||
|
if (w1)
|
||||||
|
{
|
||||||
|
uint16_t watchaddr = strtoul(w1, NULL, 16);
|
||||||
|
for (int i=0; i<sizeof(watchpoints)/sizeof(*watchpoints); i++)
|
||||||
|
{
|
||||||
|
struct watchpoint* w = &watchpoints[i];
|
||||||
|
if (!w->enabled)
|
||||||
|
{
|
||||||
|
w->address = watchaddr;
|
||||||
|
w->enabled = true;
|
||||||
|
w->value = ram[watchaddr];
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
printf("Too many breakpoints\n");
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
for (int i=0; i<sizeof(watchpoints)/sizeof(*watchpoints); i++)
|
||||||
|
{
|
||||||
|
struct watchpoint* w = &watchpoints[i];
|
||||||
|
if (w->enabled)
|
||||||
|
printf("%04x (current value: %02x)\n", w->address, w->value);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
static void cmd_delete_breakpoint(void)
|
||||||
|
{
|
||||||
|
char* w1 = strtok(NULL, " ");
|
||||||
|
if (w1)
|
||||||
|
{
|
||||||
|
uint16_t breakpc = strtoul(w1, NULL, 16);
|
||||||
|
for (int i=0; i<sizeof(breakpoints)/sizeof(*breakpoints); i++)
|
||||||
|
{
|
||||||
|
if (breakpoints[i] == breakpc)
|
||||||
|
{
|
||||||
|
breakpoints[i] = 0xffff;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
printf("No such breakpoint\n");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
static void cmd_delete_watchpoint(void)
|
||||||
|
{
|
||||||
|
char* w1 = strtok(NULL, " ");
|
||||||
|
if (w1)
|
||||||
|
{
|
||||||
|
uint16_t address = strtoul(w1, NULL, 16);
|
||||||
|
for (int i=0; i<sizeof(breakpoints)/sizeof(*breakpoints); i++)
|
||||||
|
{
|
||||||
|
struct watchpoint* w = &watchpoints[i];
|
||||||
|
if (w->enabled && (w->address == address))
|
||||||
|
{
|
||||||
|
w->enabled = false;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
printf("No such watchpoint\n");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
static void cmd_memory(void)
|
||||||
|
{
|
||||||
|
char* w1 = strtok(NULL, " ");
|
||||||
|
char* w2 = strtok(NULL, " ");
|
||||||
|
|
||||||
|
if (!w2)
|
||||||
|
w2 = "100";
|
||||||
|
|
||||||
|
if (w1 && w2)
|
||||||
|
{
|
||||||
|
uint16_t startaddr = strtoul(w1, NULL, 16);
|
||||||
|
uint16_t endaddr = startaddr + strtoul(w2, NULL, 16);
|
||||||
|
uint16_t startrounded = startaddr & ~0xf;
|
||||||
|
uint16_t endrounded = (endaddr + 0xf) & ~0xf;
|
||||||
|
|
||||||
|
uint16_t p = startrounded;
|
||||||
|
|
||||||
|
while (p < endrounded)
|
||||||
|
{
|
||||||
|
printf("%04x : ", p);
|
||||||
|
for (int i = 0; i < 16; i++)
|
||||||
|
{
|
||||||
|
uint16_t pp = p + i;
|
||||||
|
if ((pp >= startaddr) && (pp < endaddr))
|
||||||
|
printf("%02x ", ram[pp]);
|
||||||
|
else
|
||||||
|
printf(" ");
|
||||||
|
}
|
||||||
|
printf(": ");
|
||||||
|
for (int i = 0; i < 16; i++)
|
||||||
|
{
|
||||||
|
uint16_t pp = p + i;
|
||||||
|
if ((pp >= startaddr) && (pp < endaddr))
|
||||||
|
{
|
||||||
|
uint8_t c = ram[pp];
|
||||||
|
if ((c < 32) || (c > 127))
|
||||||
|
c = '.';
|
||||||
|
putchar(c);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
putchar(' ');
|
||||||
|
}
|
||||||
|
p += 16;
|
||||||
|
putchar('\n');
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
static void cmd_bdos(void)
|
||||||
|
{
|
||||||
|
char* w1 = strtok(NULL, " ");
|
||||||
|
if (w1)
|
||||||
|
bdosbreak = !!strtoul(w1, NULL, 16);
|
||||||
|
else
|
||||||
|
printf("break on bdos entry: %s\n", bdosbreak ? "on" : "off");
|
||||||
|
}
|
||||||
|
|
||||||
|
static void cmd_tracing(void)
|
||||||
|
{
|
||||||
|
char* w1 = strtok(NULL, " ");
|
||||||
|
if (w1)
|
||||||
|
tracing = !!strtoul(w1, NULL, 16);
|
||||||
|
else
|
||||||
|
printf("tracing: %s\n", tracing ? "on" : "off");
|
||||||
|
}
|
||||||
|
|
||||||
|
static void cmd_help(void)
|
||||||
|
{
|
||||||
|
printf("Sleazy debugger\n"
|
||||||
|
" r show registers\n"
|
||||||
|
" r <reg> <value> set register\n"
|
||||||
|
" b show breakpoints\n"
|
||||||
|
" b <addr> set breakpoint\n"
|
||||||
|
" db <addr> delete breakpoint\n"
|
||||||
|
" w <addr> set watchpoint\n"
|
||||||
|
" dw <addr> delete watchpoint\n"
|
||||||
|
" m <addr> <len> show memory\n"
|
||||||
|
" s single step\n"
|
||||||
|
" g continue\n"
|
||||||
|
" bdos 0|1 enable break on bdos entry\n"
|
||||||
|
" trace 0|1 enable tracing\n"
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void debug(void)
|
||||||
|
{
|
||||||
|
bool go = false;
|
||||||
|
showregs();
|
||||||
|
while (!go)
|
||||||
|
{
|
||||||
|
char cmdline[80];
|
||||||
|
printf("debug> ");
|
||||||
|
fflush(stdout);
|
||||||
|
if (!fgets(cmdline, sizeof(cmdline), stdin))
|
||||||
|
exit(0);
|
||||||
|
|
||||||
|
char* token = strtok(cmdline, " ");
|
||||||
|
if (token != NULL)
|
||||||
|
{
|
||||||
|
if (strcmp(token, "?") == 0)
|
||||||
|
cmd_help();
|
||||||
|
else if (strcmp(token, "r") == 0)
|
||||||
|
cmd_register();
|
||||||
|
else if (strcmp(token, "b") == 0)
|
||||||
|
cmd_break();
|
||||||
|
else if (strcmp(token, "w") == 0)
|
||||||
|
cmd_watch();
|
||||||
|
else if (strcmp(token, "db") == 0)
|
||||||
|
cmd_delete_breakpoint();
|
||||||
|
else if (strcmp(token, "dw") == 0)
|
||||||
|
cmd_delete_watchpoint();
|
||||||
|
else if (strcmp(token, "m") == 0)
|
||||||
|
cmd_memory();
|
||||||
|
else if (strcmp(token, "s") == 0)
|
||||||
|
{
|
||||||
|
singlestepping = true;
|
||||||
|
go = true;
|
||||||
|
}
|
||||||
|
else if (strcmp(token, "g") == 0)
|
||||||
|
{
|
||||||
|
singlestepping = false;
|
||||||
|
go = true;
|
||||||
|
}
|
||||||
|
else if (strcmp(token, "bdos") == 0)
|
||||||
|
cmd_bdos();
|
||||||
|
else if (strcmp(token, "tracing") == 0)
|
||||||
|
cmd_tracing();
|
||||||
|
else
|
||||||
|
printf("Bad command\n");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
static void sigusr1_cb(int number)
|
||||||
|
{
|
||||||
|
singlestepping = true;
|
||||||
|
}
|
||||||
|
|
||||||
|
void emulator_init(void)
|
||||||
|
{
|
||||||
|
for (int i=0; i<sizeof(breakpoints)/sizeof(*breakpoints); i++)
|
||||||
|
breakpoints[i] = 0xffff;
|
||||||
|
|
||||||
|
singlestepping = flag_enter_debugger;
|
||||||
|
|
||||||
|
struct sigaction action = {
|
||||||
|
.sa_handler = sigusr1_cb
|
||||||
|
};
|
||||||
|
sigaction(SIGUSR1, &action, NULL);
|
||||||
|
}
|
||||||
|
|
||||||
|
void emulator_run(void)
|
||||||
|
{
|
||||||
|
for (;;)
|
||||||
|
{
|
||||||
|
uint16_t pc = i8080_read_reg16(PC);
|
||||||
|
if (!singlestepping)
|
||||||
|
{
|
||||||
|
for (int i=0; i<sizeof(breakpoints)/sizeof(*breakpoints); i++)
|
||||||
|
if (pc == breakpoints[i])
|
||||||
|
singlestepping = true;
|
||||||
|
}
|
||||||
|
for (int i=0; i<sizeof(watchpoints)/sizeof(*watchpoints); i++)
|
||||||
|
{
|
||||||
|
struct watchpoint* w = &watchpoints[i];
|
||||||
|
if (w->enabled && (ram[w->address] != w->value))
|
||||||
|
{
|
||||||
|
printf("\nWatchpoint hit: %04x has changed from %02x to %02x\n",
|
||||||
|
w->address, w->value, ram[w->address]);
|
||||||
|
w->value = ram[w->address];
|
||||||
|
singlestepping = true;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if (singlestepping)
|
||||||
|
debug();
|
||||||
|
else if (tracing)
|
||||||
|
showregs();
|
||||||
|
|
||||||
|
i8080_exec(1);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
440
plat/cpm/emu/fileio.c
Normal file
440
plat/cpm/emu/fileio.c
Normal file
|
|
@ -0,0 +1,440 @@
|
||||||
|
#define _XOPEN_SOURCE 500
|
||||||
|
#define _POSIX_C_SOURCE 200809
|
||||||
|
#include <stdio.h>
|
||||||
|
#include <stdlib.h>
|
||||||
|
#include <string.h>
|
||||||
|
#include <unistd.h>
|
||||||
|
#include <sys/types.h>
|
||||||
|
#include <sys/stat.h>
|
||||||
|
#include <fcntl.h>
|
||||||
|
#include <ctype.h>
|
||||||
|
#include <errno.h>
|
||||||
|
#include <dirent.h>
|
||||||
|
#include "globals.h"
|
||||||
|
|
||||||
|
#define logf(args...) while (0)
|
||||||
|
//#define logf(args...) printf(args)
|
||||||
|
|
||||||
|
struct file
|
||||||
|
{
|
||||||
|
struct file* prev;
|
||||||
|
struct file* next;
|
||||||
|
cpm_filename_t filename;
|
||||||
|
int fd;
|
||||||
|
int flags;
|
||||||
|
};
|
||||||
|
|
||||||
|
#define NUM_FILES 16
|
||||||
|
static struct file files[NUM_FILES];
|
||||||
|
static struct file* firstfile;
|
||||||
|
|
||||||
|
#define NUM_DRIVES 16
|
||||||
|
static int drives[NUM_DRIVES];
|
||||||
|
|
||||||
|
static cpm_filename_t currentpattern;
|
||||||
|
static int currentsearchdrivefd;
|
||||||
|
static DIR* currentdir;
|
||||||
|
|
||||||
|
void files_init(void)
|
||||||
|
{
|
||||||
|
for (int i=0; i<NUM_DRIVES; i++)
|
||||||
|
drives[i] = -1;
|
||||||
|
file_set_drive(0, ".");
|
||||||
|
|
||||||
|
for (int i=0; i<NUM_FILES; i++)
|
||||||
|
{
|
||||||
|
struct file* f = &files[i];
|
||||||
|
if (i == 0)
|
||||||
|
f->prev = NULL;
|
||||||
|
else
|
||||||
|
f->prev = &files[i-1];
|
||||||
|
|
||||||
|
if (i == (NUM_FILES-1))
|
||||||
|
f->next = NULL;
|
||||||
|
else
|
||||||
|
f->next = &files[i+1];
|
||||||
|
|
||||||
|
memset(&f->filename.bytes, ' ', 11);
|
||||||
|
f->filename.drive = 0;
|
||||||
|
f->fd = -1;
|
||||||
|
f->flags = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
firstfile = &files[0];
|
||||||
|
}
|
||||||
|
|
||||||
|
void file_set_drive(int drive, const char* path)
|
||||||
|
{
|
||||||
|
if ((drive < 0) || (drive >= NUM_DRIVES))
|
||||||
|
fatal("bad drive letter");
|
||||||
|
|
||||||
|
if (drives[drive] != -1)
|
||||||
|
close(drives[drive]);
|
||||||
|
drives[drive] = open(path, O_RDONLY);
|
||||||
|
if (drives[drive] == -1)
|
||||||
|
fatal("could not open '%s': %s", path, strerror(errno));
|
||||||
|
|
||||||
|
struct stat st;
|
||||||
|
fstat(drives[drive], &st);
|
||||||
|
if (!S_ISDIR(st.st_mode))
|
||||||
|
fatal("could not open '%s': not a directory", path);
|
||||||
|
logf("[drive %c now pointing at %s (fd %d)]\n", drive+'A', path, drives[drive]);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void bump(struct file* f)
|
||||||
|
{
|
||||||
|
// logf("[bumping file %d to front]\n", f-files);
|
||||||
|
|
||||||
|
if (f != firstfile)
|
||||||
|
{
|
||||||
|
/* Remove from list. */
|
||||||
|
if (f->prev)
|
||||||
|
f->prev->next = f->next;
|
||||||
|
if (f->next)
|
||||||
|
f->next->prev = f->prev;
|
||||||
|
|
||||||
|
/* Reinsert at head of list. */
|
||||||
|
firstfile->prev = f;
|
||||||
|
f->prev = NULL;
|
||||||
|
f->next = firstfile;
|
||||||
|
firstfile = f;
|
||||||
|
}
|
||||||
|
|
||||||
|
// logf("[first file is %d]\n", firstfile-files);
|
||||||
|
// for (int i=0; i<NUM_FILES; i++)
|
||||||
|
// {
|
||||||
|
// f = &files[i];
|
||||||
|
// logf("[file %02d: %c:%.11s, fd=%d, prev=%d next=%d]\n",
|
||||||
|
// i, 'A'-1+f->filename.drive, f->filename.bytes, f->fd,
|
||||||
|
// f->prev ? (f->prev - files) : -1,
|
||||||
|
// f->next ? (f->next - files) : -1);
|
||||||
|
// }
|
||||||
|
}
|
||||||
|
|
||||||
|
static void cpm_filename_to_unix(cpm_filename_t* cpmfilename, char* unixfilename)
|
||||||
|
{
|
||||||
|
char* pin = cpmfilename->bytes;
|
||||||
|
char* pout = unixfilename;
|
||||||
|
|
||||||
|
for (int i=0; i<8; i++)
|
||||||
|
{
|
||||||
|
char c = *pin++;
|
||||||
|
if (c != ' ')
|
||||||
|
*pout++ = tolower(c);
|
||||||
|
}
|
||||||
|
*pout++ = '.';
|
||||||
|
for (int i=0; i<3; i++)
|
||||||
|
{
|
||||||
|
char c = *pin++;
|
||||||
|
if (c != ' ')
|
||||||
|
*pout++ = tolower(c);
|
||||||
|
}
|
||||||
|
if (pout[-1] == '.')
|
||||||
|
pout--;
|
||||||
|
*pout = '\0';
|
||||||
|
}
|
||||||
|
|
||||||
|
static bool unix_filename_to_cpm(const char* unixfilename, cpm_filename_t* cpmfilename)
|
||||||
|
{
|
||||||
|
const char* pin = unixfilename;
|
||||||
|
|
||||||
|
memset(cpmfilename, ' ', sizeof(cpm_filename_t));
|
||||||
|
char* pout = &cpmfilename->bytes[0];
|
||||||
|
int count = 0;
|
||||||
|
int maxcount = 8;
|
||||||
|
for (;;)
|
||||||
|
{
|
||||||
|
char c = *pin++;
|
||||||
|
if ((c == '.') && (maxcount == 8))
|
||||||
|
{
|
||||||
|
maxcount = 3;
|
||||||
|
count = 0;
|
||||||
|
pout = &cpmfilename->bytes[8];
|
||||||
|
}
|
||||||
|
else if (c == '\0')
|
||||||
|
break;
|
||||||
|
else if (count == maxcount)
|
||||||
|
return false;
|
||||||
|
else if (isupper(c))
|
||||||
|
return false;
|
||||||
|
else
|
||||||
|
{
|
||||||
|
*pout++ = toupper(c);
|
||||||
|
count++;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
static bool match_filenames(cpm_filename_t* pattern, cpm_filename_t* filename)
|
||||||
|
{
|
||||||
|
if (pattern->drive != filename->drive)
|
||||||
|
return false;
|
||||||
|
|
||||||
|
for (int i=0; i<sizeof(pattern->bytes); i++)
|
||||||
|
{
|
||||||
|
char p = pattern->bytes[i];
|
||||||
|
if (p == '?')
|
||||||
|
continue;
|
||||||
|
if (p != filename->bytes[i])
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
static int get_drive_fd(cpm_filename_t* filename)
|
||||||
|
{
|
||||||
|
int drive = filename->drive - 1;
|
||||||
|
if ((drive < 0) || (drive >= NUM_DRIVES))
|
||||||
|
{
|
||||||
|
logf("[reference to bad drive %c]\n", drive + 'A');
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
int drivefd = drives[drive];
|
||||||
|
if (drivefd == -1)
|
||||||
|
{
|
||||||
|
logf("[reference to undefined drive %c]\n", drive + 'A');
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
logf("[selecting drive %c on fd %d]\n", drive + 'A', drivefd);
|
||||||
|
return drivefd;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void reopen(struct file* f, int flags)
|
||||||
|
{
|
||||||
|
if ((f->fd == -1) || ((f->flags == O_RDONLY) && (flags == O_RDWR)))
|
||||||
|
{
|
||||||
|
char unixfilename[13];
|
||||||
|
cpm_filename_to_unix(&f->filename, unixfilename);
|
||||||
|
|
||||||
|
if (f->fd != -1)
|
||||||
|
{
|
||||||
|
logf("[reopening actual file '%s' on %d with different flags]\n", unixfilename, f->fd);
|
||||||
|
close(f->fd);
|
||||||
|
}
|
||||||
|
|
||||||
|
int drivefd = get_drive_fd(&f->filename);
|
||||||
|
if (drivefd == -1)
|
||||||
|
return;
|
||||||
|
|
||||||
|
f->flags = flags & O_ACCMODE;
|
||||||
|
errno = 0;
|
||||||
|
f->fd = openat(drivefd, unixfilename, flags, 0666);
|
||||||
|
logf("[opened actual file '%s' to fd %d: %s]\n", unixfilename, f->fd, strerror(errno));
|
||||||
|
}
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
static struct file* find_file(cpm_filename_t* filename)
|
||||||
|
{
|
||||||
|
struct file* f = firstfile;
|
||||||
|
for (;;)
|
||||||
|
{
|
||||||
|
if (memcmp(filename, &f->filename, sizeof(cpm_filename_t)) == 0)
|
||||||
|
break;
|
||||||
|
|
||||||
|
if (f->next)
|
||||||
|
f = f->next;
|
||||||
|
else
|
||||||
|
{
|
||||||
|
logf("[allocating file %d for '%.11s']\n", f-files, filename->bytes);
|
||||||
|
bump(f);
|
||||||
|
if (f->fd != -1)
|
||||||
|
{
|
||||||
|
logf("[closing old file %d for '%.11s']\n", f-files, f->filename.bytes);
|
||||||
|
close(f->fd);
|
||||||
|
}
|
||||||
|
f->fd = -1;
|
||||||
|
f->filename = *filename;
|
||||||
|
f->flags = 0;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return f;
|
||||||
|
}
|
||||||
|
|
||||||
|
struct file* file_open(cpm_filename_t* filename)
|
||||||
|
{
|
||||||
|
struct file* f = find_file(filename);
|
||||||
|
reopen(f, O_RDONLY);
|
||||||
|
if (f->fd == -1)
|
||||||
|
return NULL;
|
||||||
|
return f;
|
||||||
|
}
|
||||||
|
|
||||||
|
struct file* file_create(cpm_filename_t* filename)
|
||||||
|
{
|
||||||
|
struct file* f = find_file(filename);
|
||||||
|
logf("[creating file %d for '%.11s']\n", f-files, f->filename.bytes);
|
||||||
|
reopen(f, O_RDWR | O_CREAT);
|
||||||
|
if (f->fd == -1)
|
||||||
|
return NULL;
|
||||||
|
return f;
|
||||||
|
}
|
||||||
|
|
||||||
|
int file_close(cpm_filename_t* filename)
|
||||||
|
{
|
||||||
|
struct file* f = find_file(filename);
|
||||||
|
|
||||||
|
logf("[explicitly closing file %d for '%.11s']\n", f-files, f->filename.bytes);
|
||||||
|
if (f->fd != -1)
|
||||||
|
{
|
||||||
|
logf("[closing file descriptor %d]\n", f->fd);
|
||||||
|
close(f->fd);
|
||||||
|
}
|
||||||
|
|
||||||
|
memset(&f->filename.bytes, ' ', 11);
|
||||||
|
f->fd = -1;
|
||||||
|
f->flags = 0;
|
||||||
|
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
int file_read(struct file* f, uint8_t* data, uint16_t record)
|
||||||
|
{
|
||||||
|
reopen(f, O_RDONLY);
|
||||||
|
|
||||||
|
logf("[read record %04x from file %d for '%.11s']\n", record, f-files, f->filename.bytes);
|
||||||
|
bump(f);
|
||||||
|
memset(data, '\0', 128);
|
||||||
|
return pread(f->fd, data, 128, record*128);
|
||||||
|
}
|
||||||
|
|
||||||
|
int file_write(struct file* f, uint8_t* data, uint16_t record)
|
||||||
|
{
|
||||||
|
reopen(f, O_RDWR);
|
||||||
|
|
||||||
|
logf("[write record %04x from file %d for '%.11s']\n", record, f-files, f->filename.bytes);
|
||||||
|
bump(f);
|
||||||
|
return pwrite(f->fd, data, 128, record*128);
|
||||||
|
}
|
||||||
|
|
||||||
|
int file_getrecordcount(struct file* f)
|
||||||
|
{
|
||||||
|
reopen(f, O_RDONLY);
|
||||||
|
|
||||||
|
struct stat st;
|
||||||
|
fstat(f->fd, &st);
|
||||||
|
return (st.st_size + 127) >> 7;
|
||||||
|
}
|
||||||
|
|
||||||
|
void file_setrecordcount(struct file* f, int count)
|
||||||
|
{
|
||||||
|
reopen(f, O_RDONLY);
|
||||||
|
|
||||||
|
if (count != file_getrecordcount(f))
|
||||||
|
{
|
||||||
|
logf("[truncating file %d to %d records]\n", f-files, count);
|
||||||
|
reopen(f, O_RDWR);
|
||||||
|
ftruncate(f->fd, count*128);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
int file_findfirst(cpm_filename_t* pattern)
|
||||||
|
{
|
||||||
|
if (currentdir)
|
||||||
|
{
|
||||||
|
closedir(currentdir);
|
||||||
|
currentdir = NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
currentpattern = *pattern;
|
||||||
|
logf("[reset search; current find pattern is '%.11s']\n", currentpattern.bytes);
|
||||||
|
currentsearchdrivefd = get_drive_fd(pattern);
|
||||||
|
if (currentsearchdrivefd == -1)
|
||||||
|
return 0;
|
||||||
|
|
||||||
|
currentdir = fdopendir(dup(currentsearchdrivefd));
|
||||||
|
if (currentdir)
|
||||||
|
{
|
||||||
|
rewinddir(currentdir);
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
int file_findnext(cpm_filename_t* result)
|
||||||
|
{
|
||||||
|
for (;;)
|
||||||
|
{
|
||||||
|
if (!currentdir)
|
||||||
|
return -1;
|
||||||
|
|
||||||
|
struct dirent* de = readdir(currentdir);
|
||||||
|
if (!de)
|
||||||
|
{
|
||||||
|
closedir(currentdir);
|
||||||
|
currentdir = NULL;
|
||||||
|
logf("[finished search]\n");
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
struct stat st;
|
||||||
|
if ((fstatat(currentsearchdrivefd, de->d_name, &st, 0) == 0)
|
||||||
|
&& S_ISREG(st.st_mode)
|
||||||
|
&& unix_filename_to_cpm(de->d_name, result))
|
||||||
|
{
|
||||||
|
result->drive = currentpattern.drive;
|
||||||
|
logf("[compare '%.11s' with pattern '%.11s']\n", result->bytes, currentpattern.bytes);
|
||||||
|
if (match_filenames(¤tpattern, result))
|
||||||
|
{
|
||||||
|
logf("[positive match]\n");
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
int file_delete(cpm_filename_t* pattern)
|
||||||
|
{
|
||||||
|
logf("[attempting to delete pattern '%.11s' on drive %c]\n", pattern->bytes, '@'+pattern->drive);
|
||||||
|
int drivefd = get_drive_fd(pattern);
|
||||||
|
DIR* dir = fdopendir(dup(drivefd));
|
||||||
|
if (!dir)
|
||||||
|
return -1;
|
||||||
|
rewinddir(dir);
|
||||||
|
|
||||||
|
int result = -1;
|
||||||
|
for (;;)
|
||||||
|
{
|
||||||
|
struct dirent* de = readdir(dir);
|
||||||
|
if (!de)
|
||||||
|
break;
|
||||||
|
|
||||||
|
struct stat st;
|
||||||
|
cpm_filename_t candidate;
|
||||||
|
|
||||||
|
if ((fstatat(drivefd, de->d_name, &st, 0) == 0)
|
||||||
|
&& S_ISREG(st.st_mode)
|
||||||
|
&& unix_filename_to_cpm(de->d_name, &candidate))
|
||||||
|
{
|
||||||
|
candidate.drive = pattern->drive;
|
||||||
|
logf("[compare '%.11s' with pattern '%.11s']\n", candidate.bytes, pattern->bytes);
|
||||||
|
if (match_filenames(pattern, &candidate))
|
||||||
|
{
|
||||||
|
logf("[positive match, deleting]\n");
|
||||||
|
unlinkat(drivefd, de->d_name, 0);
|
||||||
|
result = 0;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
closedir(dir);
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
int file_rename(cpm_filename_t* src, cpm_filename_t* dest)
|
||||||
|
{
|
||||||
|
logf("[renaming %.11s to %.11s on drive %c]\n",
|
||||||
|
src->bytes, dest->bytes, '@'+src->drive);
|
||||||
|
|
||||||
|
char srcunixfilename[13];
|
||||||
|
cpm_filename_to_unix(src, srcunixfilename);
|
||||||
|
|
||||||
|
char destunixfilename[13];
|
||||||
|
cpm_filename_to_unix(dest, destunixfilename);
|
||||||
|
|
||||||
|
int drivefd = get_drive_fd(src);
|
||||||
|
return renameat(drivefd, srcunixfilename, drivefd, destunixfilename);
|
||||||
|
}
|
||||||
51
plat/cpm/emu/globals.h
Normal file
51
plat/cpm/emu/globals.h
Normal file
|
|
@ -0,0 +1,51 @@
|
||||||
|
#ifndef GLOBALS_H
|
||||||
|
#define GLOBALS_H
|
||||||
|
|
||||||
|
#include <stdbool.h>
|
||||||
|
#include <z80ex/z80ex.h>
|
||||||
|
|
||||||
|
extern Z80EX_CONTEXT* z80;
|
||||||
|
extern uint8_t ram[0x10000];
|
||||||
|
|
||||||
|
extern void emulator_init(void);
|
||||||
|
extern void emulator_run(void);
|
||||||
|
extern void showregs(void);
|
||||||
|
|
||||||
|
extern const uint8_t ccp_data[];
|
||||||
|
extern const int ccp_len;
|
||||||
|
|
||||||
|
extern const uint8_t bdos_data[];
|
||||||
|
extern const int bdos_len;
|
||||||
|
|
||||||
|
extern void bios_coldboot(void);
|
||||||
|
|
||||||
|
extern void biosbdos_entry(int syscall);
|
||||||
|
|
||||||
|
typedef struct
|
||||||
|
{
|
||||||
|
uint8_t drive;
|
||||||
|
char bytes[11];
|
||||||
|
}
|
||||||
|
cpm_filename_t;
|
||||||
|
|
||||||
|
extern void files_init(void);
|
||||||
|
extern void file_set_drive(int drive, const char* path);
|
||||||
|
extern struct file* file_open(cpm_filename_t* filename);
|
||||||
|
extern struct file* file_create(cpm_filename_t* filename);
|
||||||
|
extern int file_close(cpm_filename_t* filename);
|
||||||
|
extern int file_read(struct file* file, uint8_t* data, uint16_t record);
|
||||||
|
extern int file_write(struct file* file, uint8_t* data, uint16_t record);
|
||||||
|
extern int file_getrecordcount(struct file* f);
|
||||||
|
extern void file_setrecordcount(struct file* f, int count);
|
||||||
|
extern int file_findfirst(cpm_filename_t* pattern);
|
||||||
|
extern int file_findnext(cpm_filename_t* result);
|
||||||
|
extern int file_delete(cpm_filename_t* pattern);
|
||||||
|
extern int file_rename(cpm_filename_t* src, cpm_filename_t* dest);
|
||||||
|
|
||||||
|
extern void fatal(const char* message, ...);
|
||||||
|
|
||||||
|
extern bool flag_enter_debugger;
|
||||||
|
extern char* const* user_command_line;
|
||||||
|
|
||||||
|
#endif
|
||||||
|
|
||||||
874
plat/cpm/emu/intel_8080_emulator.c
Normal file
874
plat/cpm/emu/intel_8080_emulator.c
Normal file
|
|
@ -0,0 +1,874 @@
|
||||||
|
/*
|
||||||
|
Intel 8080 emulator in C
|
||||||
|
Written by Mike Chambers, April 2018
|
||||||
|
|
||||||
|
Use this code for whatever you want. I don't care. It's officially public domain.
|
||||||
|
Credit would be appreciated.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#include <stdio.h>
|
||||||
|
#include <stdint.h>
|
||||||
|
#include <stdlib.h>
|
||||||
|
#include "intel_8080_emulator.h"
|
||||||
|
|
||||||
|
#define ALLOW_UNDEFINED
|
||||||
|
|
||||||
|
#define reg16_PSW (((uint16_t)reg8[A] << 8) | (uint16_t)reg8[FLAGS])
|
||||||
|
#define reg16_BC (((uint16_t)reg8[B] << 8) | (uint16_t)reg8[C])
|
||||||
|
#define reg16_DE (((uint16_t)reg8[D] << 8) | (uint16_t)reg8[E])
|
||||||
|
#define reg16_HL (((uint16_t)reg8[H] << 8) | (uint16_t)reg8[L])
|
||||||
|
|
||||||
|
uint8_t reg8[9], INTE = 0;
|
||||||
|
uint16_t reg_SP, reg_PC;
|
||||||
|
|
||||||
|
#define set_S() reg8[FLAGS] |= 0x80
|
||||||
|
#define set_Z() reg8[FLAGS] |= 0x40
|
||||||
|
#define set_AC() reg8[FLAGS] |= 0x10
|
||||||
|
#define set_P() reg8[FLAGS] |= 0x04
|
||||||
|
#define set_C() reg8[FLAGS] |= 0x01
|
||||||
|
#define clear_S() reg8[FLAGS] &= 0x7F
|
||||||
|
#define clear_Z() reg8[FLAGS] &= 0xBF
|
||||||
|
#define clear_AC() reg8[FLAGS] &= 0xEF
|
||||||
|
#define clear_P() reg8[FLAGS] &= 0xFB
|
||||||
|
#define clear_C() reg8[FLAGS] &= 0xFE
|
||||||
|
#define test_S() (reg8[FLAGS] & 0x80)
|
||||||
|
#define test_Z() (reg8[FLAGS] & 0x40)
|
||||||
|
#define test_AC() (reg8[FLAGS] & 0x10)
|
||||||
|
#define test_P() (reg8[FLAGS] & 0x04)
|
||||||
|
#define test_C() (reg8[FLAGS] & 0x01)
|
||||||
|
|
||||||
|
static const uint8_t parity[0x100] = {
|
||||||
|
1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
|
||||||
|
0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
|
||||||
|
0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
|
||||||
|
1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
|
||||||
|
0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
|
||||||
|
1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
|
||||||
|
1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
|
||||||
|
0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1
|
||||||
|
};
|
||||||
|
|
||||||
|
uint16_t read_RP(uint8_t rp) {
|
||||||
|
switch (rp) {
|
||||||
|
case 0x00:
|
||||||
|
return reg16_BC;
|
||||||
|
case 0x01:
|
||||||
|
return reg16_DE;
|
||||||
|
case 0x02:
|
||||||
|
return reg16_HL;
|
||||||
|
case 0x03:
|
||||||
|
return reg_SP;
|
||||||
|
}
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
uint16_t read_RP_PUSHPOP(uint8_t rp) {
|
||||||
|
switch (rp) {
|
||||||
|
case 0x00:
|
||||||
|
return reg16_BC;
|
||||||
|
case 0x01:
|
||||||
|
return reg16_DE;
|
||||||
|
case 0x02:
|
||||||
|
return reg16_HL;
|
||||||
|
case 0x03:
|
||||||
|
return (reg16_PSW | 0x02) & 0xFFD7;
|
||||||
|
}
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
void write_RP(uint8_t rp, uint8_t lb, uint8_t hb) {
|
||||||
|
switch (rp) {
|
||||||
|
case 0x00:
|
||||||
|
reg8[C] = lb;
|
||||||
|
reg8[B] = hb;
|
||||||
|
break;
|
||||||
|
case 0x01:
|
||||||
|
reg8[E] = lb;
|
||||||
|
reg8[D] = hb;
|
||||||
|
break;
|
||||||
|
case 0x02:
|
||||||
|
reg8[L] = lb;
|
||||||
|
reg8[H] = hb;
|
||||||
|
break;
|
||||||
|
case 0x03:
|
||||||
|
reg_SP = (uint16_t)lb | ((uint16_t)hb << 8);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void write16_RP(uint8_t rp, uint16_t value) {
|
||||||
|
switch (rp) {
|
||||||
|
case 0x00:
|
||||||
|
reg8[C] = value & 0x00FF;
|
||||||
|
reg8[B] = value >> 8;
|
||||||
|
break;
|
||||||
|
case 0x01:
|
||||||
|
reg8[E] = value & 0x00FF;
|
||||||
|
reg8[D] = value >> 8;
|
||||||
|
break;
|
||||||
|
case 0x02:
|
||||||
|
reg8[L] = value & 0x00FF;
|
||||||
|
reg8[H] = value >> 8;
|
||||||
|
break;
|
||||||
|
case 0x03:
|
||||||
|
reg_SP = value;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void write16_RP_PUSHPOP(uint8_t rp, uint16_t value) {
|
||||||
|
switch (rp) {
|
||||||
|
case 0x00:
|
||||||
|
reg8[C] = value & 0x00FF;
|
||||||
|
reg8[B] = value >> 8;
|
||||||
|
break;
|
||||||
|
case 0x01:
|
||||||
|
reg8[E] = value & 0x00FF;
|
||||||
|
reg8[D] = value >> 8;
|
||||||
|
break;
|
||||||
|
case 0x02:
|
||||||
|
reg8[L] = value & 0x00FF;
|
||||||
|
reg8[H] = value >> 8;
|
||||||
|
break;
|
||||||
|
case 0x03:
|
||||||
|
reg8[FLAGS] = ((value & 0x00FF) | 0x02) & 0xD7;
|
||||||
|
reg8[A] = value >> 8;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void calc_SZP(uint8_t value) {
|
||||||
|
if (value == 0) set_Z(); else clear_Z();
|
||||||
|
if (value & 0x80) set_S(); else clear_S();
|
||||||
|
if (parity[value]) set_P(); else clear_P();
|
||||||
|
}
|
||||||
|
|
||||||
|
void calc_AC(uint8_t val1, uint8_t val2) {
|
||||||
|
if (((val1 & 0x0F) + (val2 & 0x0F)) > 0x0F) {
|
||||||
|
set_AC();
|
||||||
|
} else {
|
||||||
|
clear_AC();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void calc_AC_carry(uint8_t val1, uint8_t val2) {
|
||||||
|
if (((val1 & 0x0F) + (val2 & 0x0F)) >= 0x0F) {
|
||||||
|
set_AC();
|
||||||
|
} else {
|
||||||
|
clear_AC();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void calc_subAC(int8_t val1, uint8_t val2) {
|
||||||
|
if ((val2 & 0x0F) <= (val1 & 0x0F)) {
|
||||||
|
set_AC();
|
||||||
|
} else {
|
||||||
|
clear_AC();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void calc_subAC_borrow(int8_t val1, uint8_t val2) {
|
||||||
|
if ((val2 & 0x0F) < (val1 & 0x0F)) {
|
||||||
|
set_AC();
|
||||||
|
} else {
|
||||||
|
clear_AC();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
uint8_t test_cond(uint8_t code) {
|
||||||
|
switch (code) {
|
||||||
|
case 0: //Z not set
|
||||||
|
if (!test_Z()) return 1; else return 0;
|
||||||
|
case 1: //Z set
|
||||||
|
if (test_Z()) return 1; else return 0;
|
||||||
|
case 2: //C not set
|
||||||
|
if (!test_C()) return 1; else return 0;
|
||||||
|
case 3: //C set
|
||||||
|
if (test_C()) return 1; else return 0;
|
||||||
|
case 4: //P not set
|
||||||
|
if (!test_P()) return 1; else return 0;
|
||||||
|
case 5: //P set
|
||||||
|
if (test_P()) return 1; else return 0;
|
||||||
|
case 6: //S not set
|
||||||
|
if (!test_S()) return 1; else return 0;
|
||||||
|
case 7: //S set
|
||||||
|
if (test_S()) return 1; else return 0;
|
||||||
|
}
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
void i8080_push(uint16_t value) {
|
||||||
|
i8080_write(--reg_SP, value >> 8);
|
||||||
|
i8080_write(--reg_SP, (uint8_t)value);
|
||||||
|
}
|
||||||
|
|
||||||
|
uint16_t i8080_pop() {
|
||||||
|
uint16_t temp;
|
||||||
|
temp = i8080_read(reg_SP++);
|
||||||
|
temp |= (uint16_t)i8080_read(reg_SP++) << 8;
|
||||||
|
return temp;
|
||||||
|
}
|
||||||
|
|
||||||
|
void i8080_interrupt(uint8_t n) {
|
||||||
|
if (!INTE) return;
|
||||||
|
i8080_push(reg_PC);
|
||||||
|
reg_PC = (uint16_t)n << 3;
|
||||||
|
INTE = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
void i8080_jump(uint16_t addr) {
|
||||||
|
reg_PC = addr;
|
||||||
|
}
|
||||||
|
|
||||||
|
void i8080_reset() {
|
||||||
|
reg_PC = reg_SP = 0x0000;
|
||||||
|
//reg8[FLAGS] = 0x02;
|
||||||
|
}
|
||||||
|
|
||||||
|
void i8080_write_reg8(reg_t reg, uint8_t value) {
|
||||||
|
if (reg == M) {
|
||||||
|
i8080_write(reg16_HL, value);
|
||||||
|
} else {
|
||||||
|
reg8[reg] = value;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
uint8_t i8080_read_reg8(reg_t reg) {
|
||||||
|
if (reg == M) {
|
||||||
|
return i8080_read(reg16_HL);
|
||||||
|
} else {
|
||||||
|
return reg8[reg];
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
uint16_t i8080_read_reg16(reg_t reg) {
|
||||||
|
switch (reg) {
|
||||||
|
case AF: return reg16_PSW;
|
||||||
|
case BC: return reg16_BC;
|
||||||
|
case DE: return reg16_DE;
|
||||||
|
case HL: return reg16_HL;
|
||||||
|
case SP: return reg_SP;
|
||||||
|
case PC: return reg_PC;
|
||||||
|
}
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
void i8080_write_reg16(reg_t reg, uint16_t value) {
|
||||||
|
switch (reg) {
|
||||||
|
case AF: reg8[A] = value>>8; reg8[FLAGS] = value; break;
|
||||||
|
case BC: reg8[B] = value>>8; reg8[C] = value; break;
|
||||||
|
case DE: reg8[D] = value>>8; reg8[E] = value; break;
|
||||||
|
case HL: reg8[H] = value>>8; reg8[L] = value; break;
|
||||||
|
case SP: reg_SP = value; break;
|
||||||
|
case PC: reg_PC = value; break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
int i8080_exec(int cycles) {
|
||||||
|
uint8_t opcode, temp8, reg, reg2;
|
||||||
|
uint16_t temp16;
|
||||||
|
uint32_t temp32;
|
||||||
|
|
||||||
|
while (cycles > 0) {
|
||||||
|
opcode = i8080_read(reg_PC++);
|
||||||
|
|
||||||
|
switch (opcode) {
|
||||||
|
case 0x3A: //LDA a - load A from memory
|
||||||
|
temp16 = (uint16_t)i8080_read(reg_PC) | ((uint16_t)i8080_read(reg_PC+1)<<8);
|
||||||
|
reg8[A] = i8080_read(temp16);
|
||||||
|
reg_PC += 2;
|
||||||
|
cycles -= 13;
|
||||||
|
break;
|
||||||
|
case 0x32: //STA a - store A to memory
|
||||||
|
temp16 = (uint16_t)i8080_read(reg_PC) | ((uint16_t)i8080_read(reg_PC+1)<<8);
|
||||||
|
i8080_write(temp16, reg8[A]);
|
||||||
|
reg_PC += 2;
|
||||||
|
cycles -= 13;
|
||||||
|
break;
|
||||||
|
case 0x2A: //LHLD a - load H:L from memory
|
||||||
|
temp16 = (uint16_t)i8080_read(reg_PC) | ((uint16_t)i8080_read(reg_PC+1)<<8);
|
||||||
|
reg8[L] = i8080_read(temp16++);
|
||||||
|
reg8[H] = i8080_read(temp16);
|
||||||
|
reg_PC += 2;
|
||||||
|
cycles -= 16;
|
||||||
|
break;
|
||||||
|
case 0x22: //SHLD a - store H:L to memory
|
||||||
|
temp16 = (uint16_t)i8080_read(reg_PC) | ((uint16_t)i8080_read(reg_PC+1)<<8);
|
||||||
|
i8080_write(temp16++, reg8[L]);
|
||||||
|
i8080_write(temp16, reg8[H]);
|
||||||
|
reg_PC += 2;
|
||||||
|
cycles -= 16;
|
||||||
|
break;
|
||||||
|
case 0xEB: //XCHG - exchange DE and HL content
|
||||||
|
temp8 = reg8[D];
|
||||||
|
reg8[D] = reg8[H];
|
||||||
|
reg8[H] = temp8;
|
||||||
|
temp8 = reg8[E];
|
||||||
|
reg8[E] = reg8[L];
|
||||||
|
reg8[L] = temp8;
|
||||||
|
cycles -= 5;
|
||||||
|
break;
|
||||||
|
case 0xC6: //ADI # - add immediate to A
|
||||||
|
temp8 = i8080_read(reg_PC++);
|
||||||
|
temp16 = (uint16_t)reg8[A] + (uint16_t)temp8;
|
||||||
|
if (temp16 & 0xFF00) set_C(); else clear_C();
|
||||||
|
calc_AC(reg8[A], temp8);
|
||||||
|
calc_SZP((uint8_t)temp16);
|
||||||
|
reg8[A] = (uint8_t)temp16;
|
||||||
|
cycles -= 7;
|
||||||
|
break;
|
||||||
|
case 0xCE: //ACI # - add immediate to A with carry
|
||||||
|
temp8 = i8080_read(reg_PC++);
|
||||||
|
temp16 = (uint16_t)reg8[A] + (uint16_t)temp8 + (uint16_t)test_C();
|
||||||
|
if (test_C()) calc_AC_carry(reg8[A], temp8); else calc_AC(reg8[A], temp8);
|
||||||
|
if (temp16 & 0xFF00) set_C(); else clear_C();
|
||||||
|
calc_SZP((uint8_t)temp16);
|
||||||
|
reg8[A] = (uint8_t)temp16;
|
||||||
|
cycles -= 7;
|
||||||
|
break;
|
||||||
|
case 0xD6: //SUI # - subtract immediate from A
|
||||||
|
temp8 = i8080_read(reg_PC++);
|
||||||
|
temp16 = (uint16_t)reg8[A] - (uint16_t)temp8;
|
||||||
|
if (((temp16 & 0x00FF) >= reg8[A]) && temp8) set_C(); else clear_C();
|
||||||
|
calc_subAC(reg8[A], temp8);
|
||||||
|
calc_SZP((uint8_t)temp16);
|
||||||
|
reg8[A] = (uint8_t)temp16;
|
||||||
|
cycles -= 7;
|
||||||
|
break;
|
||||||
|
case 0x27: //DAA - decimal adjust accumulator
|
||||||
|
temp16 = reg8[A];
|
||||||
|
if (((temp16 & 0x0F) > 0x09) || test_AC()) {
|
||||||
|
if (((temp16 & 0x0F) + 0x06) & 0xF0) set_AC(); else clear_AC();
|
||||||
|
temp16 += 0x06;
|
||||||
|
if (temp16 & 0xFF00) set_C(); //can also cause carry to be set during addition to the low nibble
|
||||||
|
}
|
||||||
|
if (((temp16 & 0xF0) > 0x90) || test_C()) {
|
||||||
|
temp16 += 0x60;
|
||||||
|
if (temp16 & 0xFF00) set_C(); //doesn't clear it if this clause is false
|
||||||
|
}
|
||||||
|
calc_SZP((uint8_t)temp16);
|
||||||
|
reg8[A] = (uint8_t)temp16;
|
||||||
|
cycles -= 4;
|
||||||
|
break;
|
||||||
|
case 0xE6: //ANI # - AND immediate with A
|
||||||
|
temp8 = i8080_read(reg_PC++);
|
||||||
|
if ((reg8[A] | temp8) & 0x08) set_AC(); else clear_AC();
|
||||||
|
reg8[A] &= temp8;
|
||||||
|
clear_C();
|
||||||
|
calc_SZP(reg8[A]);
|
||||||
|
cycles -= 7;
|
||||||
|
break;
|
||||||
|
case 0xF6: //ORI # - OR immediate with A
|
||||||
|
reg8[A] |= i8080_read(reg_PC++);
|
||||||
|
clear_AC();
|
||||||
|
clear_C();
|
||||||
|
calc_SZP(reg8[A]);
|
||||||
|
cycles -= 7;
|
||||||
|
break;
|
||||||
|
case 0xEE: //XRI # - XOR immediate with A
|
||||||
|
reg8[A] ^= i8080_read(reg_PC++);
|
||||||
|
clear_AC();
|
||||||
|
clear_C();
|
||||||
|
calc_SZP(reg8[A]);
|
||||||
|
cycles -= 7;
|
||||||
|
break;
|
||||||
|
case 0xDE: //SBI # - subtract immediate from A with borrow
|
||||||
|
temp8 = i8080_read(reg_PC++);
|
||||||
|
temp16 = (uint16_t)reg8[A] - (uint16_t)temp8 - (uint16_t)test_C();
|
||||||
|
if (test_C()) calc_subAC_borrow(reg8[A], temp8); else calc_subAC(reg8[A], temp8);
|
||||||
|
if (((temp16 & 0x00FF) >= reg8[A]) && (temp8 | test_C())) set_C(); else clear_C();
|
||||||
|
calc_SZP((uint8_t)temp16);
|
||||||
|
reg8[A] = (uint8_t)temp16;
|
||||||
|
cycles -= 7;
|
||||||
|
break;
|
||||||
|
case 0xFE: //CPI # - compare immediate with A
|
||||||
|
temp8 = i8080_read(reg_PC++);
|
||||||
|
temp16 = (uint16_t)reg8[A] - (uint16_t)temp8;
|
||||||
|
if (((temp16 & 0x00FF) >= reg8[A]) && temp8) set_C(); else clear_C();
|
||||||
|
calc_subAC(reg8[A], temp8);
|
||||||
|
calc_SZP((uint8_t)temp16);
|
||||||
|
cycles -= 7;
|
||||||
|
break;
|
||||||
|
case 0x07: //RLC - rotate A left
|
||||||
|
if (reg8[A] & 0x80) set_C(); else clear_C();
|
||||||
|
reg8[A] = (reg8[A] >> 7) | (reg8[A] << 1);
|
||||||
|
cycles -= 4;
|
||||||
|
break;
|
||||||
|
case 0x0F: //RRC - rotate A right
|
||||||
|
if (reg8[A] & 0x01) set_C(); else clear_C();
|
||||||
|
reg8[A] = (reg8[A] << 7) | (reg8[A] >> 1);
|
||||||
|
cycles -= 4;
|
||||||
|
break;
|
||||||
|
case 0x17: //RAL - rotate A left through carry
|
||||||
|
temp8 = test_C();
|
||||||
|
if (reg8[A] & 0x80) set_C(); else clear_C();
|
||||||
|
reg8[A] = (reg8[A] << 1) | temp8;
|
||||||
|
cycles -= 4;
|
||||||
|
break;
|
||||||
|
case 0x1F: //RAR - rotate A right through carry
|
||||||
|
temp8 = test_C();
|
||||||
|
if (reg8[A] & 0x01) set_C(); else clear_C();
|
||||||
|
reg8[A] = (reg8[A] >> 1) | (temp8 << 7);
|
||||||
|
cycles -= 4;
|
||||||
|
break;
|
||||||
|
case 0x2F: //CMA - compliment A
|
||||||
|
reg8[A] = ~reg8[A];
|
||||||
|
cycles -= 4;
|
||||||
|
break;
|
||||||
|
case 0x3F: //CMC - compliment carry flag
|
||||||
|
reg8[FLAGS] ^= 1;
|
||||||
|
cycles -= 4;
|
||||||
|
break;
|
||||||
|
case 0x37: //STC - set carry flag
|
||||||
|
set_C();
|
||||||
|
cycles -= 4;
|
||||||
|
break;
|
||||||
|
case 0xC7: //RST n - restart (call n*8)
|
||||||
|
case 0xD7:
|
||||||
|
case 0xE7:
|
||||||
|
case 0xF7:
|
||||||
|
case 0xCF:
|
||||||
|
case 0xDF:
|
||||||
|
case 0xEF:
|
||||||
|
case 0xFF:
|
||||||
|
i8080_push(reg_PC);
|
||||||
|
reg_PC = (uint16_t)((opcode >> 3) & 7) << 3;
|
||||||
|
cycles -= 11;
|
||||||
|
break;
|
||||||
|
case 0xE9: //PCHL - jump to address in H:L
|
||||||
|
reg_PC = reg16_HL;
|
||||||
|
cycles -= 5;
|
||||||
|
break;
|
||||||
|
case 0xE3: //XTHL - swap H:L with top word on stack
|
||||||
|
temp16 = i8080_pop();
|
||||||
|
i8080_push(reg16_HL);
|
||||||
|
write16_RP(2, temp16);
|
||||||
|
cycles -= 18;
|
||||||
|
break;
|
||||||
|
case 0xF9: //SPHL - set SP to content of HL
|
||||||
|
reg_SP = reg16_HL;
|
||||||
|
cycles -= 5;
|
||||||
|
break;
|
||||||
|
case 0xDB: //IN p - read input port into A
|
||||||
|
reg8[A] = i8080_inport(i8080_read(reg_PC++));
|
||||||
|
cycles -= 10;
|
||||||
|
break;
|
||||||
|
case 0xD3: //OUT p - write A to output port
|
||||||
|
i8080_outport(i8080_read(reg_PC++), reg8[A]);
|
||||||
|
cycles -= 10;
|
||||||
|
break;
|
||||||
|
case 0xFB: //EI - enable interrupts
|
||||||
|
INTE = 1;
|
||||||
|
cycles -= 4;
|
||||||
|
break;
|
||||||
|
case 0xF3: //DI - disbale interrupts
|
||||||
|
INTE = 0;
|
||||||
|
cycles -= 4;
|
||||||
|
break;
|
||||||
|
case 0x76: //HLT - halt processor
|
||||||
|
reg_PC--;
|
||||||
|
cycles -= 7;
|
||||||
|
break;
|
||||||
|
case 0x00: //NOP - no operation
|
||||||
|
#ifdef ALLOW_UNDEFINED
|
||||||
|
case 0x10:
|
||||||
|
case 0x20:
|
||||||
|
case 0x30:
|
||||||
|
case 0x08:
|
||||||
|
case 0x18:
|
||||||
|
case 0x28:
|
||||||
|
case 0x38:
|
||||||
|
#endif
|
||||||
|
cycles -= 4;
|
||||||
|
break;
|
||||||
|
case 0x40: case 0x50: case 0x60: case 0x70: //MOV D,S - move register to register
|
||||||
|
case 0x41: case 0x51: case 0x61: case 0x71:
|
||||||
|
case 0x42: case 0x52: case 0x62: case 0x72:
|
||||||
|
case 0x43: case 0x53: case 0x63: case 0x73:
|
||||||
|
case 0x44: case 0x54: case 0x64: case 0x74:
|
||||||
|
case 0x45: case 0x55: case 0x65: case 0x75:
|
||||||
|
case 0x46: case 0x56: case 0x66:
|
||||||
|
case 0x47: case 0x57: case 0x67: case 0x77:
|
||||||
|
case 0x48: case 0x58: case 0x68: case 0x78:
|
||||||
|
case 0x49: case 0x59: case 0x69: case 0x79:
|
||||||
|
case 0x4A: case 0x5A: case 0x6A: case 0x7A:
|
||||||
|
case 0x4B: case 0x5B: case 0x6B: case 0x7B:
|
||||||
|
case 0x4C: case 0x5C: case 0x6C: case 0x7C:
|
||||||
|
case 0x4D: case 0x5D: case 0x6D: case 0x7D:
|
||||||
|
case 0x4E: case 0x5E: case 0x6E: case 0x7E:
|
||||||
|
case 0x4F: case 0x5F: case 0x6F: case 0x7F:
|
||||||
|
reg = (opcode >> 3) & 7;
|
||||||
|
reg2 = opcode & 7;
|
||||||
|
i8080_write_reg8(reg, i8080_read_reg8(reg2));
|
||||||
|
if ((reg == M) || (reg2 == M)) {
|
||||||
|
cycles -= 7;
|
||||||
|
} else {
|
||||||
|
cycles -= 5;
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
case 0x06: //MVI D,# - move immediate to register
|
||||||
|
case 0x16:
|
||||||
|
case 0x26:
|
||||||
|
case 0x36:
|
||||||
|
case 0x0E:
|
||||||
|
case 0x1E:
|
||||||
|
case 0x2E:
|
||||||
|
case 0x3E:
|
||||||
|
reg = (opcode >> 3) & 7;
|
||||||
|
i8080_write_reg8(reg, i8080_read(reg_PC++));
|
||||||
|
if (reg == M) {
|
||||||
|
cycles -= 10;
|
||||||
|
} else {
|
||||||
|
cycles -= 7;
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
case 0x01: //LXI RP,# - load register pair immediate
|
||||||
|
case 0x11:
|
||||||
|
case 0x21:
|
||||||
|
case 0x31:
|
||||||
|
reg = (opcode >> 4) & 3;
|
||||||
|
write_RP(reg, i8080_read(reg_PC), i8080_read(reg_PC + 1));
|
||||||
|
reg_PC += 2;
|
||||||
|
cycles -= 10;
|
||||||
|
break;
|
||||||
|
case 0x0A: //LDAX BC - load A indirect through BC
|
||||||
|
reg8[A] = i8080_read(reg16_BC);
|
||||||
|
cycles -= 7;
|
||||||
|
break;
|
||||||
|
case 0x1A: //LDAX DE - load A indirect through DE
|
||||||
|
reg8[A] = i8080_read(reg16_DE);
|
||||||
|
cycles -= 7;
|
||||||
|
break;
|
||||||
|
case 0x02: //STAX BC - store A indirect through BC
|
||||||
|
i8080_write(reg16_BC, reg8[A]);
|
||||||
|
cycles -= 7;
|
||||||
|
break;
|
||||||
|
case 0x12: //STAX DE - store A indirect through DE
|
||||||
|
i8080_write(reg16_DE, reg8[A]);
|
||||||
|
cycles -= 7;
|
||||||
|
break;
|
||||||
|
case 0x04: //INR D - increment register
|
||||||
|
case 0x14:
|
||||||
|
case 0x24:
|
||||||
|
case 0x34:
|
||||||
|
case 0x0C:
|
||||||
|
case 0x1C:
|
||||||
|
case 0x2C:
|
||||||
|
case 0x3C:
|
||||||
|
reg = (opcode >> 3) & 7;
|
||||||
|
temp8 = i8080_read_reg8(reg); //reg8[reg];
|
||||||
|
calc_AC(temp8, 1);
|
||||||
|
calc_SZP(temp8 + 1);
|
||||||
|
i8080_write_reg8(reg, temp8 + 1); //reg8[reg]++;
|
||||||
|
if (reg == M) {
|
||||||
|
cycles -= 10;
|
||||||
|
} else {
|
||||||
|
cycles -= 5;
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
case 0x05: //DCR D - decrement register
|
||||||
|
case 0x15:
|
||||||
|
case 0x25:
|
||||||
|
case 0x35:
|
||||||
|
case 0x0D:
|
||||||
|
case 0x1D:
|
||||||
|
case 0x2D:
|
||||||
|
case 0x3D:
|
||||||
|
reg = (opcode >> 3) & 7;
|
||||||
|
temp8 = i8080_read_reg8(reg); //reg8[reg];
|
||||||
|
calc_subAC(temp8, 1);
|
||||||
|
calc_SZP(temp8 - 1);
|
||||||
|
i8080_write_reg8(reg, temp8 - 1); //reg8[reg]--;
|
||||||
|
if (reg == M) {
|
||||||
|
cycles -= 10;
|
||||||
|
} else {
|
||||||
|
cycles -= 5;
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
case 0x03: //INX RP - increment register pair
|
||||||
|
case 0x13:
|
||||||
|
case 0x23:
|
||||||
|
case 0x33:
|
||||||
|
reg = (opcode >> 4) & 3;
|
||||||
|
write16_RP(reg, read_RP(reg) + 1);
|
||||||
|
cycles -= 5;
|
||||||
|
break;
|
||||||
|
case 0x0B: //DCX RP - decrement register pair
|
||||||
|
case 0x1B:
|
||||||
|
case 0x2B:
|
||||||
|
case 0x3B:
|
||||||
|
reg = (opcode >> 4) & 3;
|
||||||
|
write16_RP(reg, read_RP(reg) - 1);
|
||||||
|
cycles -= 5;
|
||||||
|
break;
|
||||||
|
case 0x09: //DAD RP - add register pair to HL
|
||||||
|
case 0x19:
|
||||||
|
case 0x29:
|
||||||
|
case 0x39:
|
||||||
|
reg = (opcode >> 4) & 3;
|
||||||
|
temp32 = (uint32_t)reg16_HL + (uint32_t)read_RP(reg);
|
||||||
|
write16_RP(2, (uint16_t)temp32);
|
||||||
|
if (temp32 & 0xFFFF0000) set_C(); else clear_C();
|
||||||
|
cycles -= 10;
|
||||||
|
break;
|
||||||
|
case 0x80: //ADD S - add register or memory to A
|
||||||
|
case 0x81:
|
||||||
|
case 0x82:
|
||||||
|
case 0x83:
|
||||||
|
case 0x84:
|
||||||
|
case 0x85:
|
||||||
|
case 0x86:
|
||||||
|
case 0x87:
|
||||||
|
reg = opcode & 7;
|
||||||
|
temp8 = i8080_read_reg8(reg);
|
||||||
|
temp16 = (uint16_t)reg8[A] + (uint16_t)temp8;
|
||||||
|
if (temp16 & 0xFF00) set_C(); else clear_C();
|
||||||
|
calc_AC(reg8[A], temp8);
|
||||||
|
calc_SZP((uint8_t)temp16);
|
||||||
|
reg8[A] = (uint8_t)temp16;
|
||||||
|
if (reg == M) {
|
||||||
|
cycles -= 7;
|
||||||
|
} else {
|
||||||
|
cycles -= 4;
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
case 0x88: //ADC S - add register or memory to A with carry
|
||||||
|
case 0x89:
|
||||||
|
case 0x8A:
|
||||||
|
case 0x8B:
|
||||||
|
case 0x8C:
|
||||||
|
case 0x8D:
|
||||||
|
case 0x8E:
|
||||||
|
case 0x8F:
|
||||||
|
reg = opcode & 7;
|
||||||
|
temp8 = i8080_read_reg8(reg);
|
||||||
|
temp16 = (uint16_t)reg8[A] + (uint16_t)temp8 + (uint16_t)test_C();
|
||||||
|
if (test_C()) calc_AC_carry(reg8[A], temp8); else calc_AC(reg8[A], temp8);
|
||||||
|
if (temp16 & 0xFF00) set_C(); else clear_C();
|
||||||
|
calc_SZP((uint8_t)temp16);
|
||||||
|
reg8[A] = (uint8_t)temp16;
|
||||||
|
if (reg == M) {
|
||||||
|
cycles -= 7;
|
||||||
|
} else {
|
||||||
|
cycles -= 4;
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
case 0x90: //SUB S - subtract register or memory from A
|
||||||
|
case 0x91:
|
||||||
|
case 0x92:
|
||||||
|
case 0x93:
|
||||||
|
case 0x94:
|
||||||
|
case 0x95:
|
||||||
|
case 0x96:
|
||||||
|
case 0x97:
|
||||||
|
reg = opcode & 7;
|
||||||
|
temp8 = i8080_read_reg8(reg);
|
||||||
|
temp16 = (uint16_t)reg8[A] - (uint16_t)temp8;
|
||||||
|
if (((temp16 & 0x00FF) >= reg8[A]) && temp8) set_C(); else clear_C();
|
||||||
|
calc_subAC(reg8[A], temp8);
|
||||||
|
calc_SZP((uint8_t)temp16);
|
||||||
|
reg8[A] = (uint8_t)temp16;
|
||||||
|
if (reg == M) {
|
||||||
|
cycles -= 7;
|
||||||
|
} else {
|
||||||
|
cycles -= 4;
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
case 0x98: //SBB S - subtract register or memory from A with borrow
|
||||||
|
case 0x99:
|
||||||
|
case 0x9A:
|
||||||
|
case 0x9B:
|
||||||
|
case 0x9C:
|
||||||
|
case 0x9D:
|
||||||
|
case 0x9E:
|
||||||
|
case 0x9F:
|
||||||
|
reg = opcode & 7;
|
||||||
|
temp8 = i8080_read_reg8(reg);
|
||||||
|
temp16 = (uint16_t)reg8[A] - (uint16_t)temp8 - (uint16_t)test_C();
|
||||||
|
if (test_C()) calc_subAC_borrow(reg8[A], temp8); else calc_subAC(reg8[A], temp8);
|
||||||
|
if (((temp16 & 0x00FF) >= reg8[A]) && (temp8 | test_C())) set_C(); else clear_C();
|
||||||
|
calc_SZP((uint8_t)temp16);
|
||||||
|
reg8[A] = (uint8_t)temp16;
|
||||||
|
if (reg == M) {
|
||||||
|
cycles -= 7;
|
||||||
|
} else {
|
||||||
|
cycles -= 4;
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
case 0xA0: //ANA S - AND register with A
|
||||||
|
case 0xA1:
|
||||||
|
case 0xA2:
|
||||||
|
case 0xA3:
|
||||||
|
case 0xA4:
|
||||||
|
case 0xA5:
|
||||||
|
case 0xA6:
|
||||||
|
case 0xA7:
|
||||||
|
reg = opcode & 7;
|
||||||
|
temp8 = i8080_read_reg8(reg);
|
||||||
|
if ((reg8[A] | temp8) & 0x08) set_AC(); else clear_AC();
|
||||||
|
reg8[A] &= temp8;
|
||||||
|
clear_C();
|
||||||
|
calc_SZP(reg8[A]);
|
||||||
|
if (reg == M) {
|
||||||
|
cycles -= 7;
|
||||||
|
} else {
|
||||||
|
cycles -= 4;
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
case 0xB0: //ORA S - OR register with A
|
||||||
|
case 0xB1:
|
||||||
|
case 0xB2:
|
||||||
|
case 0xB3:
|
||||||
|
case 0xB4:
|
||||||
|
case 0xB5:
|
||||||
|
case 0xB6:
|
||||||
|
case 0xB7:
|
||||||
|
reg = opcode & 7;
|
||||||
|
reg8[A] |= i8080_read_reg8(reg);
|
||||||
|
clear_AC();
|
||||||
|
clear_C();
|
||||||
|
calc_SZP(reg8[A]);
|
||||||
|
if (reg == M) {
|
||||||
|
cycles -= 7;
|
||||||
|
} else {
|
||||||
|
cycles -= 4;
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
case 0xA8: //XRA S - XOR register with A
|
||||||
|
case 0xA9:
|
||||||
|
case 0xAA:
|
||||||
|
case 0xAB:
|
||||||
|
case 0xAC:
|
||||||
|
case 0xAD:
|
||||||
|
case 0xAE:
|
||||||
|
case 0xAF:
|
||||||
|
reg = opcode & 7;
|
||||||
|
reg8[A] ^= i8080_read_reg8(reg);
|
||||||
|
clear_AC();
|
||||||
|
clear_C();
|
||||||
|
calc_SZP(reg8[A]);
|
||||||
|
if (reg == M) {
|
||||||
|
cycles -= 7;
|
||||||
|
} else {
|
||||||
|
cycles -= 4;
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
case 0xB8: //CMP S - compare register with A
|
||||||
|
case 0xB9:
|
||||||
|
case 0xBA:
|
||||||
|
case 0xBB:
|
||||||
|
case 0xBC:
|
||||||
|
case 0xBD:
|
||||||
|
case 0xBE:
|
||||||
|
case 0xBF:
|
||||||
|
reg = opcode & 7;
|
||||||
|
temp8 = i8080_read_reg8(reg);
|
||||||
|
temp16 = (uint16_t)reg8[A] - (uint16_t)temp8;
|
||||||
|
if (((temp16 & 0x00FF) >= reg8[A]) && temp8) set_C(); else clear_C();
|
||||||
|
calc_subAC(reg8[A], temp8);
|
||||||
|
calc_SZP((uint8_t)temp16);
|
||||||
|
if (reg == M) {
|
||||||
|
cycles -= 7;
|
||||||
|
} else {
|
||||||
|
cycles -= 4;
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
case 0xC3: //JMP a - unconditional jump
|
||||||
|
#ifdef ALLOW_UNDEFINED
|
||||||
|
case 0xCB:
|
||||||
|
#endif
|
||||||
|
temp16 = (uint16_t)i8080_read(reg_PC) | (((uint16_t)i8080_read(reg_PC + 1)) << 8);
|
||||||
|
reg_PC = temp16;
|
||||||
|
cycles -= 10;
|
||||||
|
break;
|
||||||
|
case 0xC2: //Jccc - conditional jumps
|
||||||
|
case 0xCA:
|
||||||
|
case 0xD2:
|
||||||
|
case 0xDA:
|
||||||
|
case 0xE2:
|
||||||
|
case 0xEA:
|
||||||
|
case 0xF2:
|
||||||
|
case 0xFA:
|
||||||
|
temp16 = (uint16_t)i8080_read(reg_PC) | (((uint16_t)i8080_read(reg_PC + 1)) << 8);
|
||||||
|
if (test_cond((opcode >> 3) & 7)) reg_PC = temp16; else reg_PC += 2;
|
||||||
|
cycles -= 10;
|
||||||
|
break;
|
||||||
|
case 0xCD: //CALL a - unconditional call
|
||||||
|
#ifdef ALLOW_UNDEFINED
|
||||||
|
case 0xDD:
|
||||||
|
case 0xED:
|
||||||
|
case 0xFD:
|
||||||
|
#endif
|
||||||
|
temp16 = (uint16_t)i8080_read(reg_PC) | (((uint16_t)i8080_read(reg_PC + 1)) << 8);
|
||||||
|
i8080_push(reg_PC + 2);
|
||||||
|
reg_PC = temp16;
|
||||||
|
cycles -= 17;
|
||||||
|
break;
|
||||||
|
case 0xC4: //Cccc - conditional calls
|
||||||
|
case 0xCC:
|
||||||
|
case 0xD4:
|
||||||
|
case 0xDC:
|
||||||
|
case 0xE4:
|
||||||
|
case 0xEC:
|
||||||
|
case 0xF4:
|
||||||
|
case 0xFC:
|
||||||
|
temp16 = (uint16_t)i8080_read(reg_PC) | (((uint16_t)i8080_read(reg_PC + 1)) << 8);
|
||||||
|
if (test_cond((opcode >> 3) & 7)) {
|
||||||
|
i8080_push(reg_PC + 2);
|
||||||
|
reg_PC = temp16;
|
||||||
|
cycles -= 17;
|
||||||
|
} else {
|
||||||
|
reg_PC += 2;
|
||||||
|
cycles -= 11;
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
case 0xC9: //RET - unconditional return
|
||||||
|
#ifdef ALLOW_UNDEFINED
|
||||||
|
case 0xD9:
|
||||||
|
#endif
|
||||||
|
reg_PC = i8080_pop();
|
||||||
|
cycles -= 10;
|
||||||
|
break;
|
||||||
|
case 0xC0: //Rccc - conditional returns
|
||||||
|
case 0xC8:
|
||||||
|
case 0xD0:
|
||||||
|
case 0xD8:
|
||||||
|
case 0xE0:
|
||||||
|
case 0xE8:
|
||||||
|
case 0xF0:
|
||||||
|
case 0xF8:
|
||||||
|
if (test_cond((opcode >> 3) & 7)) {
|
||||||
|
reg_PC = i8080_pop();
|
||||||
|
cycles -= 11;
|
||||||
|
} else {
|
||||||
|
cycles -= 5;
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
case 0xC5: //PUSH RP - push register pair on the stack
|
||||||
|
case 0xD5:
|
||||||
|
case 0xE5:
|
||||||
|
case 0xF5:
|
||||||
|
reg = (opcode >> 4) & 3;
|
||||||
|
i8080_push(read_RP_PUSHPOP(reg));
|
||||||
|
cycles -= 11;
|
||||||
|
break;
|
||||||
|
case 0xC1: //POP RP - pop register pair from the stack
|
||||||
|
case 0xD1:
|
||||||
|
case 0xE1:
|
||||||
|
case 0xF1:
|
||||||
|
reg = (opcode >> 4) & 3;
|
||||||
|
write16_RP_PUSHPOP(reg, i8080_pop());
|
||||||
|
cycles -= 10;
|
||||||
|
break;
|
||||||
|
|
||||||
|
#ifndef ALLOW_UNDEFINED
|
||||||
|
default:
|
||||||
|
printf("UNRECOGNIZED INSTRUCTION @ %04Xh: %02X\n", reg_PC - 1, opcode);
|
||||||
|
exit(0);
|
||||||
|
#endif
|
||||||
|
}
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
return cycles;
|
||||||
|
}
|
||||||
25
plat/cpm/emu/intel_8080_emulator.h
Normal file
25
plat/cpm/emu/intel_8080_emulator.h
Normal file
|
|
@ -0,0 +1,25 @@
|
||||||
|
#ifndef INTEL_I8080_EMULATOR_H
|
||||||
|
#define INTEL_I8080_EMULATOR_H
|
||||||
|
|
||||||
|
typedef enum
|
||||||
|
{
|
||||||
|
B=0, C, D, E, H, L, M, A, FLAGS,
|
||||||
|
AF, BC, DE, HL, SP, PC
|
||||||
|
}
|
||||||
|
reg_t;
|
||||||
|
|
||||||
|
extern uint8_t i8080_read(uint16_t addr);
|
||||||
|
extern void i8080_write(uint16_t addr, uint8_t value);
|
||||||
|
extern uint8_t i8080_inport(uint8_t port);
|
||||||
|
extern void i8080_outport(uint8_t port, uint8_t value);
|
||||||
|
|
||||||
|
extern uint8_t i8080_read_reg8(reg_t reg);
|
||||||
|
extern void i8080_write_reg8(reg_t reg, uint8_t value);
|
||||||
|
|
||||||
|
extern uint16_t i8080_read_reg16(reg_t reg);
|
||||||
|
extern void i8080_write_reg16(reg_t reg, uint16_t value);
|
||||||
|
|
||||||
|
extern int i8080_exec(int cycles);
|
||||||
|
|
||||||
|
#endif
|
||||||
|
|
||||||
83
plat/cpm/emu/main.c
Normal file
83
plat/cpm/emu/main.c
Normal file
|
|
@ -0,0 +1,83 @@
|
||||||
|
#include <stdio.h>
|
||||||
|
#include <stdlib.h>
|
||||||
|
#include <stdint.h>
|
||||||
|
#include <stdarg.h>
|
||||||
|
#include <getopt.h>
|
||||||
|
#include <ctype.h>
|
||||||
|
#include "globals.h"
|
||||||
|
|
||||||
|
bool flag_enter_debugger = false;
|
||||||
|
char* const* user_command_line = NULL;
|
||||||
|
|
||||||
|
void fatal(const char* message, ...)
|
||||||
|
{
|
||||||
|
va_list ap;
|
||||||
|
va_start(ap, message);
|
||||||
|
fprintf(stderr, "fatal: ");
|
||||||
|
vfprintf(stderr, message, ap);
|
||||||
|
fprintf(stderr, "\n");
|
||||||
|
exit(1);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void syntax(void)
|
||||||
|
{
|
||||||
|
printf("cpm [<flags>] [command] [args]:\n");
|
||||||
|
printf(" -h this help\n");
|
||||||
|
printf(" -d enter debugger on startup\n");
|
||||||
|
printf(" -p DRIVE=PATH map a drive to a path (by default, A=.)\n");
|
||||||
|
printf("If command is specified, a Unix file of that name will be loaded and\n");
|
||||||
|
printf("injected directly into memory (it's not loaded through the CCP).\n");
|
||||||
|
printf("Arguments may also be provided, but note that any FCBs aren't set up,\n");
|
||||||
|
printf("so traditional Unix utilities probably won't work.\n");
|
||||||
|
exit(1);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void parse_options(int argc, char* const* argv)
|
||||||
|
{
|
||||||
|
for (;;)
|
||||||
|
{
|
||||||
|
switch (getopt(argc, argv, "hdp:"))
|
||||||
|
{
|
||||||
|
case -1:
|
||||||
|
goto end_of_flags;
|
||||||
|
|
||||||
|
case 'd':
|
||||||
|
flag_enter_debugger = true;
|
||||||
|
break;
|
||||||
|
|
||||||
|
case 'p':
|
||||||
|
{
|
||||||
|
if (!optarg[0] || (optarg[1] != '='))
|
||||||
|
fatal("invalid syntax in drive assignment");
|
||||||
|
|
||||||
|
uint8_t drive = toupper(optarg[0]) - 'A';
|
||||||
|
const char* path = &optarg[2];
|
||||||
|
file_set_drive(drive, path);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
default:
|
||||||
|
syntax();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
end_of_flags:
|
||||||
|
user_command_line = &argv[optind];
|
||||||
|
}
|
||||||
|
|
||||||
|
int main(int argc, char* const* argv)
|
||||||
|
{
|
||||||
|
files_init();
|
||||||
|
parse_options(argc, argv);
|
||||||
|
|
||||||
|
emulator_init();
|
||||||
|
bios_coldboot();
|
||||||
|
|
||||||
|
for (;;)
|
||||||
|
{
|
||||||
|
emulator_run();
|
||||||
|
}
|
||||||
|
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
7
plat/cpm/tests/build.lua
Normal file
7
plat/cpm/tests/build.lua
Normal file
|
|
@ -0,0 +1,7 @@
|
||||||
|
include("tests/plat/build.lua")
|
||||||
|
|
||||||
|
plat_testsuite {
|
||||||
|
name = "tests",
|
||||||
|
plat = "cpm",
|
||||||
|
method = "plat/cpm/emu+emu"
|
||||||
|
}
|
||||||
|
|
@ -29,3 +29,8 @@ cprogram {
|
||||||
srcs = { "./ed.c" }
|
srcs = { "./ed.c" }
|
||||||
}
|
}
|
||||||
|
|
||||||
|
cprogram {
|
||||||
|
name = "objectify",
|
||||||
|
srcs = { "./objectify.c" }
|
||||||
|
}
|
||||||
|
|
||||||
|
|
|
||||||
Loading…
Reference in a new issue