/*
* Memory modify
*/
static void do_modify(char *s)
{
static char nv[LENCMD];
while (isspace((int)*s))
s++;
if (isxdigit((int)*s))
wrk_ram = ram + exatoi(s);
for (;;) {
printf("%04x = %02x : ", (WORD)(wrk_ram - ram),
*wrk_ram);
fgets(nv, sizeof(nv), stdin);
if (nv[0] == '\n') {
wrk_ram++;
if (wrk_ram > ram + 65535)
wrk_ram = ram;
continue;
}
if (!isxdigit((int)nv[0]))
break;
*wrk_ram++ = exatoi(nv);
if (wrk_ram > ram + 65535)
wrk_ram = ram;
}
}
/*
* Memory dump
*/
static void do_dump(char *s)
{
register int i, j;
BYTE c;
while (isspace((int)*s))
s++;
if (isxdigit((int)*s))
wrk_ram = ram + exatoi(s) - exatoi(s) % 16;
printf("Adr ");
for (i = 0; i < 16; i++)
printf("%02x ", i);
puts(" ASCII");
for (i = 0; i < 16; i++) {
printf("%04x - ", (WORD)(wrk_ram - ram));
for (j = 0; j < 16; j++) {
printf("%02x ", *wrk_ram);
wrk_ram++;
if (wrk_ram > ram + 65535)
wrk_ram = ram;
}
putchar('\t');
for (j = -16; j < 0; j++)
printf("%c", ((c = *(wrk_ram + j)) >= ' ' && c <= 0x7f)
? c : '.');
putchar('\n');
}
}
/*
* Runtime measurement by counting the executed T states
*/
static void do_count(char *s)
{
#ifndef WANT_TIM
puts("Sorry, no t-state count available");
puts("Please recompile with WANT_TIM defined in sim.h");
#else
while (isspace((int)*s))
s++;
if (*s == '\0') {
puts("start stop status T-states");
printf("%04x %04x %s %lu\n",
(WORD)(t_start - ram),
(WORD)(t_end - ram),
t_flag ? "on ": "off", t_states);
} else {
t_start = ram + exatoi(s);
while (*s != ',' && *s != '\0')
s++;
if (*s)
t_end = ram + exatoi(++s);
t_states = 0L;
t_flag = 0;
}
#endif
}
/*
* Memory fill
*/
static void do_fill(char *s)
{
register BYTE *p;
register int i;
register BYTE val;
while (isspace((int)*s))
s++;
p = ram + exatoi(s);
while (*s != ',' && *s != '\0')
s++;
if (*s) {
i = exatoi(++s);
} else {
puts("count missing");
return;
}
while (*s != ',' && *s != '\0')
s++;
if (*s) {
val = exatoi(++s);
} else {
puts("value missing");
return;
}
while (i--) {
*p++ = val;
if (p > ram + 65535)
p = ram;
}
}
/*
* Memory move
*/
static void do_move(char *s)
{
register BYTE *p1, *p2;
register int count;
while (isspace((int)*s))
s++;
p1 = ram + exatoi(s);
while (*s != ',' && *s != '\0')
s++;
if (*s) {
p2 = ram + exatoi(++s);
} else {
puts("to missing");
return;
}
while (*s != ',' && *s != '\0')
s++;
if (*s) {
count = exatoi(++s);
} else {
puts("count missing");
return;
}
while (count--) {
*p2++ = *p1++;
if (p1 > ram + 65535)
p1 = ram;
if (p2 > ram + 65535)
p2 = ram;
}
}
/*
* Software breakpoints
*/
int do_break(char *s)
{
#ifndef SBSIZE
puts("Sorry, no breakpoints available");
puts("Please recompile with SBSIZE defined in sim.h");
return(2);
#else
register int i;
if (*s == '\n') {
puts("No Addr Pass Counter");
for (i = 0; i < SBSIZE; i++)
if (soft[i].sb_pass)
printf("%02d %04x %05d %05d\n", i,
soft[i].sb_adr,soft[i].sb_pass,
soft[i].sb_passcount);
return(0);
}
if (isxdigit((int)*s)) {
i = atoi(s++);
if (i >= SBSIZE) {
printf("breakpoint %d not available\n", i);
return(2);
}
} else {
i = sb_next++;
if (sb_next == SBSIZE)
sb_next = 0;
}
while (isspace((int)*s))
s++;
if (*s == 'c') {
*(ram + soft[i].sb_adr) = soft[i].sb_oldopc;
memset((char *) &soft[i], 0, sizeof(struct softbreak));
return(0);
}
if (soft[i].sb_pass)
*(ram + soft[i].sb_adr) = soft[i].sb_oldopc;
soft[i].sb_adr = exatoi(s);
soft[i].sb_oldopc = *(ram + soft[i].sb_adr);
*(ram + soft[i].sb_adr) = 0x76;
while (!iscntrl((int)*s) && !ispunct((int)*s))
s++;
if (*s != ',')
soft[i].sb_pass = 1;
else
soft[i].sb_pass = exatoi(++s);
soft[i].sb_passcount = 0;
return(0);
#endif
}
/*
* Port modify
*/
static void do_port(char *s)
{
register BYTE port;
static char nv[LENCMD];
extern BYTE io_out(), io_in();
while (isspace((int)*s))
s++;
port = exatoi(s);
printf("%02x = %02x : ", port, io_in(port));
fgets(nv, sizeof(nv), stdin);
if (isxdigit((int)*nv))
io_out(port, (BYTE) exatoi(nv));
}
/*
* Read a file into the memory of the emulated CPU.
* The following file formats are supported:
*
* binary images with Mostek header
* Intel hex
*/
int load_file(char *s) {
char fn[LENCMD];
BYTE fileb[5];
register char *pfn = fn;
// int fd;
FSFILE *fd;
if (!FSInit()) printf("Can't Init FS\n\r");
while (isspace((int) *s))
s++;
while (*s != ',' && *s != '\n' && *s != '\0' && *s != '\r')
*pfn++ = *s++;
*pfn = '\0';
if (strlen(fn) == 0) {
puts("no input file given");
return (1);
}
if ((fd = FSfopen(fn, "R")) == NULL) {
printf("can't open file %s\n", fn);
return (1);
}
if (*s == ',')
wrk_ram = ram +exatoi(++s);
else
wrk_ram = NULL;
FSfread((char *) fileb, 5, 1, fd); /* read first 5 bytes of file */
if (*fileb == (BYTE) 0xff) { /* Mostek header ? */
FSfseek(fd, 0l, 0);
return (load_mos(fd, fn));
} else {
close(fd);
return (load_hex(fn));
}
}
/*
* Run the CPU emulation endless
*/
static void do_go(char *s)
{
while (isspace((int)*s))
s++;
if (isxdigit((int)*s))
PC = exatoi(s);
cont:
cpu_state = CONTIN_RUN;
cpu_error = NONE;
switch(cpu) {
case Z80:
cpu_z80();
break;
case I8080:
cpu_8080();
break;
}
if (cpu_error == OPHALT)
if (handel_break())
if (!cpu_error)
goto cont;
cpu_err_msg();
print_head();
print_reg();
}
/*
* Read a file into the memory of the emulated CPU.
* The following file formats are supported:
*
* binary images with Mostek header
* Intel hex
*/
int load_file(char *s)
{
char fn[LENCMD];
BYTE fileb[5];
register char *pfn = fn;
int fd;
while (isspace((int)*s))
s++;
while (*s != ',' && *s != '\n' && *s != '\0')
*pfn++ = *s++;
*pfn = '\0';
if (strlen(fn) == 0) {
puts("no input file given");
return(1);
}
if ((fd = open(fn, O_RDONLY)) == -1) {
printf("can't open file %s\n", fn);
return(1);
}
if (*s == ',')
wrk_ram = mem_base() + exatoi(++s);
else
wrk_ram = NULL;
read(fd, (char *) fileb, 5); /* read first 5 bytes of file */
if (*fileb == (BYTE) 0xff) { /* Mostek header ? */
lseek(fd, 0l, SEEK_SET);
return (load_mos(fd, fn));
}
else {
close(fd);
return (load_hex(fn));
}
}
/*
* History
*/
static void do_hist(char *s)
{
#ifndef HISIZE
puts("Sorry, no history available");
puts("Please recompile with HISIZE defined in sim.h");
#else
int i, l, b, e, c, sa;
while (isspace((int)*s))
s++;
switch (*s) {
case 'c':
memset((char *) his, 0, sizeof(struct history) * HISIZE);
h_next = 0;
h_flag = 0;
break;
default:
if ((h_next == 0) && (h_flag == 0)) {
puts("History memory is empty");
break;
}
e = h_next;
b = (h_flag) ? h_next + 1 : 0;
l = 0;
while (isspace((int)*s))
s++;
if (*s)
sa = exatoi(s);
else
sa = -1;
for (i = b; i != e; i++) {
if (i == HISIZE)
i = 0;
if (sa != -1) {
if (his[i].h_adr < sa)
continue;
else
sa = -1;
}
printf("%04x AF=%04x BC=%04x DE=%04x HL=%04x IX=%04x IY=%04x SP=%04x\n",
his[i].h_adr, his[i].h_af, his[i].h_bc,
his[i].h_de, his[i].h_hl, his[i].h_ix,
his[i].h_iy, his[i].h_sp);
l++;
if (l == 20) {
l = 0;
printf("q = quit, else continue: ");
c = getkey();
putchar('\n');
if (toupper(c) == 'Q')
break;
}
}
break;
}
#endif
}
/*
* Disassemble
*/
static void do_list(char *s)
{
register int i;
while (isspace((int)*s))
s++;
if (isxdigit((int)*s))
wrk_ram = ram + exatoi(s);
for (i = 0; i < 10; i++) {
printf("%04x - ", (WORD)(wrk_ram - ram));
disass(&wrk_ram, wrk_ram - ram);
if (wrk_ram > ram + 65535)
wrk_ram = ram;
}
}
/*
* Disassemble
*/
static void do_list(char *s)
{
register int i;
while (isspace((int)*s))
s++;
if (isxdigit((int)*s))
wrk_ram = mem_base() + exatoi(s);
for (i = 0; i < 10; i++) {
printf("%04x - ", (unsigned int)(wrk_ram - mem_base()));
disass(&wrk_ram, wrk_ram - mem_base());
if (wrk_ram > mem_base() + 65535)
wrk_ram = mem_base();
}
}
/*
* Run the CPU emulation endless
*/
static void do_go(char *s)
{
while (isspace((int)*s))
s++;
if (isxdigit((int)*s))
PC = ram + exatoi(s);
cont:
cpu_state = CONTIN_RUN;
cpu_error = NONE;
cpu();
if (cpu_error == OPHALT)
if (handel_break())
if (!cpu_error)
goto cont;
cpu_err_msg();
print_head();
print_reg();
}
/*==============================================================================
* ReadHTTPResponse
*
* Reads the HTTP response. This should only be called immediately after
* sending an HTTP POST or GET packet to the server.
*
* POST Response (typical)
* HTTP/1.1 204 No Content\r\n
* Date: Wed, 15 Feb 2012 10:29:37 GMT\r\n
* Server: misultin/0.8.1-exosite\r\n
* Connection: Keep-Alive\r\n
* Content-Length: 0\r\n
* \r\n
*
* GET Response (typical)
* HTTP/1.1 200 OK\r\n
* Date: Wed, 15 Feb 2012 10:29:38 GMT\r\n
* Server: misultin/0.8.1-exosite\r\n
* Connection: Keep-Alive\r\n
* Content-Length: 6\r\n
* \r\n
* temp=2
*=============================================================================*/
unsigned char ReadHTTPResponse(unsigned char isGet)
{
char linebuffer[100];
char * lineptr;
int bodyChars = 0;
unsigned char line_length = 0;
unsigned char fullLine = 0;
//HTTP header
line_length = UARTReadBufferLine(&fullLine, 20, linebuffer, sizeof(linebuffer), "\r\n");
if (!fullLine || !(exstrnloc(linebuffer,"HTTP/1.1 20",line_length))) //we truncate the check so it works for both GET and POST
return AT_REPLY_ERROR;
exstrncpy(http_response.status, linebuffer, line_length);
http_response.status[line_length] = 0;
//Date header
line_length = UARTReadBufferLine(&fullLine, 3, linebuffer, sizeof(linebuffer), "\r\n");
if (!fullLine || !(exstrnloc(linebuffer,"Date:",line_length)))
return AT_REPLY_ERROR;
exstrncpy(http_response.date, linebuffer, line_length);
http_response.date[line_length] = 0;
//Server header
line_length = UARTReadBufferLine(&fullLine, 3, linebuffer, sizeof(linebuffer), "\r\n");
if (!fullLine || !(exstrnloc(linebuffer,"Server:",line_length)))
return AT_REPLY_ERROR;
//Connection header
line_length = UARTReadBufferLine(&fullLine, 3, linebuffer, sizeof(linebuffer), "\r\n");
if (!fullLine || !(exstrnloc(linebuffer,"Connection:",line_length)))
return AT_REPLY_ERROR;
//Content-Length
line_length = UARTReadBufferLine(&fullLine, 3, linebuffer, sizeof(linebuffer), "\r\n");
if (!fullLine || !(exstrnloc(linebuffer,"Content-Length:",line_length))) {
return AT_REPLY_ERROR;
} else { //read content length
lineptr = exstrnloc(linebuffer,":",line_length);
lineptr++; //go past the :
lineptr++; //go past the space
bodyChars = exatoi(lineptr);
}
//Blank Line
line_length = UARTReadBufferLine(&fullLine, 3, linebuffer, sizeof(linebuffer), "\r\n");
if (!fullLine) // \r\n only
return AT_REPLY_ERROR;
//If a GET request, read the body
if (isGet) {
lineptr = http_response.body;
while (bodyChars) {
if (UARTReadBufferChar((unsigned char *)lineptr)) {
lineptr++;
bodyChars--;
}
}
*lineptr = 0; //null terminate
}
return AT_REPLY_OK;
}
int main(int argc, char *argv[])
{
register char *s, *p;
register int i;
char *pn = basename(argv[0]);
struct timeval tv;
#ifdef HAS_CONFIG
struct stat sbuf;
#endif
#ifdef BOOTROM
char *rom = "-r ";
#else
char *rom = "";
#endif
#ifdef CPU_SPEED
f_flag = CPU_SPEED;
tmax = CPU_SPEED * 10000;
#endif
while (--argc > 0 && (*++argv)[0] == '-')
for (s = argv[0] + 1; *s != '\0'; s++)
switch (*s) {
case 's': /* save core and CPU on exit */
s_flag = 1;
break;
case 'l': /* load core and CPU from file */
l_flag = 1;
break;
case 'u': /* trap undocumented ops */
u_flag = 1;
break;
case 'i': /* trap I/O on unused ports */
i_flag = 1;
break;
case 'm': /* initialise Z80 memory */
if (*(s+1) != '\0') {
m_flag = exatoi(s+1);
s += strlen(s+1);
} else {
if (argc <= 1)
goto usage;
argc--;
argv++;
m_flag = exatoi(argv[0]);
}
break;
case 'f': /* set emulation speed */
if (*(s+1) != '\0') {
f_flag = atoi(s+1);
s += strlen(s+1);
} else {
if (argc <= 1)
goto usage;
argc--;
argv++;
f_flag = atoi(argv[0]);
}
tmax = f_flag * 10000;
break;
case 'x': /* get filename with Z80 executable */
x_flag = 1;
s++;
if (*s == '\0') {
if (argc <= 1)
goto usage;
argc--;
argv++;
s = argv[0];
}
p = xfn;
while (*s)
*p++ = *s++;
*p = '\0';
s--;
break;
#ifdef BOOTROM
case 'r': /* load default boot ROM */
x_flag = 1;
strcpy(xfn, BOOTROM);
break;
#endif
#ifdef HAS_DISKS
case 'd': /* get path for disk images */
s++;
if (*s == '\0') {
if (argc <= 1)
goto usage;
argc--;
argv++;
s = argv[0];
}
p = diskdir = diskd;
while (*s)
*p++ = *s++;
*p = '\0';
s--;
break;
#endif
case '8':
cpu = I8080;
break;
case 'z':
cpu = Z80;
break;
case '?':
case 'h':
goto usage;
default:
printf("illegal option %c\n", *s);
usage:
#ifdef HAS_DISKS
printf("usage:\t%s -z -8 -s -l -i -u %s-m val -f freq -x filename -d diskpath\n", pn, rom);
#else
printf("usage:\t%s -z -8 -s -l -i -u %s-m val -f freq -x filename\n", pn, rom);
#endif
puts("\t-z = emulate Zilog Z80");
puts("\t-8 = emulate Intel 8080");
puts("\t-s = save core and CPU");
puts("\t-l = load core and CPU");
puts("\t-i = trap on I/O to unused ports");
puts("\t-u = trap on undocumented instructions");
#ifdef BOOTROM
puts("\t-r = load and execute default ROM");
printf("\t %s\n", BOOTROM);
#endif
puts("\t-m = init memory with val (00-FF)");
puts("\t-f = CPU clock frequency freq in MHz");
puts("\t-x = load and execute filename");
#ifdef HAS_DISKS
puts("\t-d = use disks images at diskpath");
puts("\t default path for disk images:");
puts("\t ./disks");
printf("\t %s\n", DISKSDIR);
#endif
exit(1);
}
putchar('\n');
if (cpu == Z80) {
puts("####### ##### ### ##### ### # #");
puts(" # # # # # # # # ## ##");
puts(" # # # # # # # # # # #");
puts(" # ##### # # ##### ##### # # # #");
puts(" # # # # # # # # #");
puts(" # # # # # # # # # #");
puts("####### ##### ### ##### ### # #");
} else {
puts(" ##### ### ##### ### ##### ### # #");
puts("# # # # # # # # # # # ## ##");
puts("# # # # # # # # # # # # # #");
puts(" ##### # # ##### # # ##### ##### # # # #");
puts("# # # # # # # # # # # #");
puts("# # # # # # # # # # # # #");
puts(" ##### ### ##### ### ##### ### # #");
}
printf("\nRelease %s, %s\n", RELEASE, COPYR);
#ifdef USR_COM
printf("%s Release %s, %s\n\n", USR_COM, USR_REL, USR_CPR);
#else
putchar('\n');
#endif
if (f_flag > 0)
printf("CPU speed is %d MHz\n", f_flag);
else
printf("CPU speed is unlimited\n");
fflush(stdout);
/* if the machine has configuration files try to find them */
#ifdef HAS_CONFIG
/* first try ./conf */
if ((stat("./conf", &sbuf) == 0) && S_ISDIR(sbuf.st_mode)) {
strcpy(&confdir[0], "./conf");
/* then CONFDIR as set in Makefile */
} else {
strcpy(&confdir[0], CONFDIR);
}
//printf("config = %s\n", &confdir[0]);
#endif
/* seed random generator */
gettimeofday(&tv, NULL);
srand(tv.tv_sec);
config(); /* read system configuration */
init_memory(); /* initialise memory configuration */
init_cpu(); /* initialise CPU */
wrk_ram = mem_base(); /* set work pointer for memory */
/* fill memory content with some initial value */
if (m_flag >= 0) {
memset((char *) wrk_ram, m_flag, 65536);
} else {
for (i = 0; i < 65536; i++)
*(wrk_ram + i) = (BYTE) (rand() % 256);
}
init_rom(); /* initialise ROM's */
if (l_flag) /* load core */
if (load_core())
return(1);
int_on(); /* initialize UNIX interrupts */
init_io(); /* initialize I/O devices */
mon(); /* run system */
if (s_flag) /* save core */
save_core();
exit_io(); /* stop I/O devices */
int_off(); /* stop UNIX interrupts */
return(0);
}
int main(int argc, char *argv[]) {
register char *s, *p;
register char *pn = argv[0];
// configure the I/O ports
AD1PCFG = 0xFFFF; // Default all pins to digital
mJTAGPortEnable(0); // turn off jtag
// setup the CPU
SYSTEMConfigPerformance(CLOCKFREQ); // System config performance
mOSCSetPBDIV(OSC_PB_DIV_1); // fix the peripheral bus to half main clock speed
INTEnableSystemMultiVectoredInt();
TRISBbits.TRISB15 = 0;
// TRISDbits.TRISD11 = 0;
// ODCDbits.ODCD11 = 1;
// LATDbits.LATD11=0;
TRISBbits.TRISB13 = 0;
ODCBbits.ODCB13 = 1;
PORTBbits.RB13=0;
#ifdef UARTConsole
UARTInit();
#endif
initKeyboard();
#ifdef UseVideo
initVideo();
#endif
#ifdef CPU_SPEED
f_flag = CPU_SPEED;
tmax = CPU_SPEED * 10000;
#endif
argc = 0;
while (--argc > 0 && (*++argv)[0] == '-')
for (s = argv[0] + 1; *s != '\0'; s++)
switch (*s) {
case 's': /* save core and CPU on exit */
s_flag = 1;
break;
case 'l': /* load core and CPU from file */
l_flag = 1;
break;
#ifdef Z80_UNDOC
case 'z': /* trap undocumented Z80 ops */
z_flag = 1;
break;
#endif
case 'i': /* trap I/O on unused ports */
i_flag = 1;
break;
case 'm': /* initialize Z80 memory */
m_flag = exatoi(s + 1);
s += strlen(s + 1);
break;
case 'f': /* set emulation speed */
f_flag = atoi(s + 1);
s += strlen(s + 1);
tmax = f_flag * 10000;
break;
case 'x': /* get filename with Z80 executable */
x_flag = 1;
s++;
p = xfn;
while (*s)
*p++ = *s++;
*p = '\0';
s--;
break;
case '?':
goto usage;
default:
printf("illegal option %c\n", *s);
#ifndef Z80_UNDOC
usage:
printf("usage:\t%s -s -l -i -mn -fn -xfilename\n", pn);
#else
usage:
printf("usage:\t%s -s -l -i -z -mn -fn -xfilename\n", pn);
#endif
puts("\ts = save core and cpu");
puts("\tl = load core and cpu");
puts("\ti = trap on I/O to unused ports");
#ifdef Z80_UNDOC
puts("\tz = trap on undocumented Z80 ops");
#endif
puts("\tm = init memory with n");
puts("\tf = CPU frequenzy n in MHz");
puts("\tx = load and execute filename");
exit(1);
}
putchar('\n');
puts("####### ##### ### ##### ### # #");
puts(" # # # # # # # # ## ##");
puts(" # # # # # # # # # # #");
puts(" # ##### # # ##### ##### # # # #");
puts(" # # # # # # # # #");
puts(" # # # # # # # # # #");
puts("####### ##### ### ##### ### # #");
printf("\nRelease %s, %s\n", RELEASE, COPYR);
printf("\nPort to PIC32 By kenseglerdesigns.com\n");
if (f_flag > 0)
printf("\nCPU speed is %d MHz\n", f_flag);
else
printf("\nCPU speed is unlimited\n");
#ifdef USR_COM
printf("\n%s Release %s, %s\n", USR_COM, USR_REL, USR_CPR);
#endif
fflush(stdout);
wrk_ram = PC = ram;
STACK = ram +0xffff;
memset((char *) ram, m_flag, 65536);
if (l_flag)
if (load_core())
return (1);
int_on();
init_io();
mon();
if (s_flag)
save_core();
exit_io();
int_off();
return (0);
}
/*
* Register modify
*/
static void do_reg(char *s)
{
static char nv[LENCMD];
while (isspace((int)*s))
s++;
if (*s == '\0') {
print_head();
print_reg();
} else {
if (strncmp(s, "bc'", 3) == 0) {
printf("BC' = %04x : ", B_ * 256 + C_);
fgets(nv, sizeof(nv), stdin);
B_ = (exatoi(nv) & 0xffff) / 256;
C_ = (exatoi(nv) & 0xffff) % 256;
} else if (strncmp(s, "de'", 3) == 0) {
printf("DE' = %04x : ", D_ * 256 + E_);
fgets(nv, sizeof(nv), stdin);
D_ = (exatoi(nv) & 0xffff) / 256;
E_ = (exatoi(nv) & 0xffff) % 256;
} else if (strncmp(s, "hl'", 3) == 0) {
printf("HL' = %04x : ", H_ * 256 + L_);
fgets(nv, sizeof(nv), stdin);
H_ = (exatoi(nv) & 0xffff) / 256;
L_ = (exatoi(nv) & 0xffff) % 256;
} else if (strncmp(s, "pc", 2) == 0) {
printf("PC = %04x : ", (WORD)(PC - ram));
fgets(nv, sizeof(nv), stdin);
PC = ram + (exatoi(nv) & 0xffff);
} else if (strncmp(s, "bc", 2) == 0) {
printf("BC = %04x : ", B * 256 + C);
fgets(nv, sizeof(nv), stdin);
B = (exatoi(nv) & 0xffff) / 256;
C = (exatoi(nv) & 0xffff) % 256;
} else if (strncmp(s, "de", 2) == 0) {
printf("DE = %04x : ", D * 256 + E);
fgets(nv, sizeof(nv), stdin);
D = (exatoi(nv) & 0xffff) / 256;
E = (exatoi(nv) & 0xffff) % 256;
} else if (strncmp(s, "hl", 2) == 0) {
printf("HL = %04x : ", H * 256 + L);
fgets(nv, sizeof(nv), stdin);
H = (exatoi(nv) & 0xffff) / 256;
L = (exatoi(nv) & 0xffff) % 256;
} else if (strncmp(s, "ix", 2) == 0) {
printf("IX = %04x : ", IX);
fgets(nv, sizeof(nv), stdin);
IX = exatoi(nv) & 0xffff;
} else if (strncmp(s, "iy", 2) == 0) {
printf("IY = %04x : ", IY);
fgets(nv, sizeof(nv), stdin);
IY = exatoi(nv) & 0xffff;
} else if (strncmp(s, "sp", 2) == 0) {
printf("SP = %04x : ", (WORD)(STACK - ram));
fgets(nv, sizeof(nv), stdin);
STACK = ram + (exatoi(nv) & 0xffff);
} else if (strncmp(s, "fs", 2) == 0) {
printf("S-FLAG = %c : ", (F & S_FLAG) ? '1' : '0');
fgets(nv, sizeof(nv), stdin);
F = (exatoi(nv)) ? (F | S_FLAG) : (F & ~S_FLAG);
} else if (strncmp(s, "fz", 2) == 0) {
printf("Z-FLAG = %c : ", (F & Z_FLAG) ? '1' : '0');
fgets(nv, sizeof(nv), stdin);
F = (exatoi(nv)) ? (F | Z_FLAG) : (F & ~Z_FLAG);
} else if (strncmp(s, "fh", 2) == 0) {
printf("H-FLAG = %c : ", (F & H_FLAG) ? '1' : '0');
fgets(nv, sizeof(nv), stdin);
F = (exatoi(nv)) ? (F | H_FLAG) : (F & ~H_FLAG);
} else if (strncmp(s, "fp", 2) == 0) {
printf("P-FLAG = %c : ", (F & P_FLAG) ? '1' : '0');
fgets(nv, sizeof(nv), stdin);
F = (exatoi(nv)) ? (F | P_FLAG) : (F & ~P_FLAG);
} else if (strncmp(s, "fn", 2) == 0) {
printf("N-FLAG = %c : ", (F & N_FLAG) ? '1' : '0');
fgets(nv, sizeof(nv), stdin);
F = (exatoi(nv)) ? (F | N_FLAG) : (F & ~N_FLAG);
} else if (strncmp(s, "fc", 2) == 0) {
printf("C-FLAG = %c : ", (F & C_FLAG) ? '1' : '0');
fgets(nv, sizeof(nv), stdin);
F = (exatoi(nv)) ? (F | C_FLAG) : (F & ~C_FLAG);
} else if (strncmp(s, "a'", 2) == 0) {
printf("A' = %02x : ", A_);
fgets(nv, sizeof(nv), stdin);
A_ = exatoi(nv) & 0xff;
} else if (strncmp(s, "f'", 2) == 0) {
printf("F' = %02x : ", F_);
fgets(nv, sizeof(nv), stdin);
F_ = exatoi(nv) & 0xff;
} else if (strncmp(s, "b'", 2) == 0) {
printf("B' = %02x : ", B_);
fgets(nv, sizeof(nv), stdin);
B_ = exatoi(nv) & 0xff;
} else if (strncmp(s, "c'", 2) == 0) {
printf("C' = %02x : ", C_);
fgets(nv, sizeof(nv), stdin);
C_ = exatoi(nv) & 0xff;
} else if (strncmp(s, "d'", 2) == 0) {
printf("D' = %02x : ", D_);
fgets(nv, sizeof(nv), stdin);
D_ = exatoi(nv) & 0xff;
} else if (strncmp(s, "e'", 2) == 0) {
printf("E' = %02x : ", E_);
fgets(nv, sizeof(nv), stdin);
E_ = exatoi(nv) & 0xff;
} else if (strncmp(s, "h'", 2) == 0) {
printf("H' = %02x : ", H_);
fgets(nv, sizeof(nv), stdin);
H_ = exatoi(nv) & 0xff;
} else if (strncmp(s, "l'", 2) == 0) {
printf("L' = %02x : ", L_);
fgets(nv, sizeof(nv), stdin);
L_ = exatoi(nv) & 0xff;
} else if (strncmp(s, "i", 1) == 0) {
printf("I = %02x : ", I);
fgets(nv, sizeof(nv), stdin);
I = exatoi(nv) & 0xff;
} else if (strncmp(s, "a", 1) == 0) {
printf("A = %02x : ", A);
fgets(nv, sizeof(nv), stdin);
A = exatoi(nv) & 0xff;
} else if (strncmp(s, "f", 1) == 0) {
printf("F = %02x : ", F);
fgets(nv, sizeof(nv), stdin);
F = exatoi(nv) & 0xff;
} else if (strncmp(s, "b", 1) == 0) {
printf("B = %02x : ", B);
fgets(nv, sizeof(nv), stdin);
B = exatoi(nv) & 0xff;
} else if (strncmp(s, "c", 1) == 0) {
printf("C = %02x : ", C);
fgets(nv, sizeof(nv), stdin);
C = exatoi(nv) & 0xff;
} else if (strncmp(s, "d", 1) == 0) {
printf("D = %02x : ", D);
fgets(nv, sizeof(nv), stdin);
D = exatoi(nv) & 0xff;
} else if (strncmp(s, "e", 1) == 0) {
printf("E = %02x : ", E);
fgets(nv, sizeof(nv), stdin);
E = exatoi(nv) & 0xff;
} else if (strncmp(s, "h", 1) == 0) {
printf("H = %02x : ", H);
fgets(nv, sizeof(nv), stdin);
H = exatoi(nv) & 0xff;
} else if (strncmp(s, "l", 1) == 0) {
printf("L = %02x : ", L);
fgets(nv, sizeof(nv), stdin);
L = exatoi(nv) & 0xff;
} else
printf("can't change register %s\n", nv);
print_head();
print_reg();
}
}
