Miroirs/x48
1
0
Fork 0
mirror of https://github.com/gwenhael-le-moine/x48.git synced 2025-01-12 20:01:13 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

format all sources

Browse source
This commit is contained in:
Gwenhael Le Moine 2022-03-24 13:41:22 +01:00
parent b50a915e0a
commit 33c0a11156
No known key found for this signature in database
GPG key ID: FDFE3669426707A7
38 changed files with 10403 additions and 11434 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

179
src/actions.c
View file

@ -83,13 +83,13 @@
#include <stdlib.h> #include <stdlib.h>
#include <unistd.h> #include <unistd.h>
#include "debugger.h"
#include "device.h"
#include "hp48.h" #include "hp48.h"
#include "hp48_emu.h" #include "hp48_emu.h"
#include "device.h"
#include "x48_x11.h"
#include "timer.h"
#include "debugger.h"
#include "romio.h" #include "romio.h"
#include "timer.h"
#include "x48_x11.h"
static int interrupt_called = 0; static int interrupt_called = 0;
extern long nibble_masks[16]; extern long nibble_masks[16];
@ -121,17 +121,11 @@ void do_in(void) {
} }
} }
void clear_program_stat(int n) { void clear_program_stat(int n) { saturn.PSTAT[n] = 0; }
saturn.PSTAT[n] = 0;
}
void set_program_stat(int n) { void set_program_stat(int n) { saturn.PSTAT[n] = 1; }
saturn.PSTAT[n] = 1;
}
int get_program_stat(int n) { int get_program_stat(int n) { return saturn.PSTAT[n]; }
return saturn.PSTAT[n];
}
void register_to_status(unsigned char *r) { void register_to_status(unsigned char *r) {
int i; int i;
@ -179,9 +173,7 @@ void set_register_nibble(unsigned char *reg, int n, unsigned char val) {
reg[n] = val; reg[n] = val;
} }
unsigned char get_register_nibble(unsigned char *reg, int n) { unsigned char get_register_nibble(unsigned char *reg, int n) { return reg[n]; }
return reg[n];
}
void set_register_bit(unsigned char *reg, int n) { void set_register_bit(unsigned char *reg, int n) {
reg[n / 4] |= (1 << (n % 4)); reg[n / 4] |= (1 << (n % 4));
@ -201,8 +193,7 @@ short conf_tab_gx[] = { 1, 2, 2, 2, 2, 0 };
void do_reset(void) { void do_reset(void) {
int i; int i;
for (i = 0; i < 6; i++) for (i = 0; i < 6; i++) {
{
if (opt_gx) if (opt_gx)
saturn.mem_cntl[i].unconfigured = conf_tab_gx[i]; saturn.mem_cntl[i].unconfigured = conf_tab_gx[i];
else else
@ -213,30 +204,24 @@ void do_reset(void) {
#ifdef DEBUG_CONFIG #ifdef DEBUG_CONFIG
fprintf(stderr, "%.5lx: RESET\n", saturn.PC); fprintf(stderr, "%.5lx: RESET\n", saturn.PC);
for (i = 0; i < 6; i++) for (i = 0; i < 6; i++) {
{
if (saturn.mem_cntl[i].unconfigured) if (saturn.mem_cntl[i].unconfigured)
fprintf(stderr, "MEMORY CONTROLLER %d is unconfigured\n", i); fprintf(stderr, "MEMORY CONTROLLER %d is unconfigured\n", i);
else else
fprintf(stderr, "MEMORY CONTROLLER %d is configured to %.5lx, %.5lx\n", fprintf(stderr, "MEMORY CONTROLLER %d is configured to %.5lx, %.5lx\n", i,
i, saturn.mem_cntl[i].config[0], saturn.mem_cntl[i].config[1]); saturn.mem_cntl[i].config[0], saturn.mem_cntl[i].config[1]);
} }
#endif #endif
} }
void do_inton(void) { void do_inton(void) { saturn.kbd_ien = 1; }
saturn.kbd_ien = 1;
}
void do_intoff(void) { void do_intoff(void) { saturn.kbd_ien = 0; }
saturn.kbd_ien = 0;
}
void do_return_interupt(void) { void do_return_interupt(void) {
if (saturn.int_pending) { if (saturn.int_pending) {
#ifdef DEBUG_INTERRUPT #ifdef DEBUG_INTERRUPT
fprintf(stderr, "PC = %.5lx: RTI SERVICE PENDING INTERRUPT\n", fprintf(stderr, "PC = %.5lx: RTI SERVICE PENDING INTERRUPT\n", saturn.PC);
saturn.PC);
#endif #endif
saturn.int_pending = 0; saturn.int_pending = 0;
saturn.intenable = 0; saturn.intenable = 0;
@ -255,7 +240,6 @@ void do_return_interupt(void) {
schedule_event = 0; schedule_event = 0;
sched_adjtime = 0; sched_adjtime = 0;
} }
} }
} }
@ -314,10 +298,8 @@ void do_unconfigure(void) {
conf |= saturn.C[i]; conf |= saturn.C[i];
} }
for (i = 0; i < 6; i++) for (i = 0; i < 6; i++) {
{ if (saturn.mem_cntl[i].config[0] == conf) {
if (saturn.mem_cntl[i].config[0] == conf)
{
if (opt_gx) if (opt_gx)
saturn.mem_cntl[i].unconfigured = conf_tab_gx[i]; saturn.mem_cntl[i].unconfigured = conf_tab_gx[i];
else else
@ -330,13 +312,12 @@ void do_unconfigure(void) {
#ifdef DEBUG_CONFIG #ifdef DEBUG_CONFIG
fprintf(stderr, "%.5lx: UNCNFG %.5x:\n", saturn.PC, conf); fprintf(stderr, "%.5lx: UNCNFG %.5x:\n", saturn.PC, conf);
for (i = 0; i < 6; i++) for (i = 0; i < 6; i++) {
{
if (saturn.mem_cntl[i].unconfigured) if (saturn.mem_cntl[i].unconfigured)
fprintf(stderr, "MEMORY CONTROLLER %d is unconfigured\n", i); fprintf(stderr, "MEMORY CONTROLLER %d is unconfigured\n", i);
else else
fprintf(stderr, "MEMORY CONTROLLER %d is configured to %.5lx, %.5lx\n", fprintf(stderr, "MEMORY CONTROLLER %d is configured to %.5lx, %.5lx\n", i,
i, saturn.mem_cntl[i].config[0], saturn.mem_cntl[i].config[1]); saturn.mem_cntl[i].config[0], saturn.mem_cntl[i].config[1]);
} }
#endif #endif
} }
@ -351,10 +332,8 @@ void do_configure(void) {
conf |= saturn.C[i]; conf |= saturn.C[i];
} }
for (i = 0; i < 6; i++) for (i = 0; i < 6; i++) {
{ if (saturn.mem_cntl[i].unconfigured) {
if (saturn.mem_cntl[i].unconfigured)
{
saturn.mem_cntl[i].unconfigured--; saturn.mem_cntl[i].unconfigured--;
saturn.mem_cntl[i].config[saturn.mem_cntl[i].unconfigured] = conf; saturn.mem_cntl[i].config[saturn.mem_cntl[i].unconfigured] = conf;
break; break;
@ -363,25 +342,22 @@ void do_configure(void) {
#ifdef DEBUG_CONFIG #ifdef DEBUG_CONFIG
fprintf(stderr, "%.5lx: CONFIG %.5lx:\n", saturn.PC, conf); fprintf(stderr, "%.5lx: CONFIG %.5lx:\n", saturn.PC, conf);
for (i = 0; i < 6; i++) for (i = 0; i < 6; i++) {
{
if (saturn.mem_cntl[i].unconfigured) if (saturn.mem_cntl[i].unconfigured)
fprintf(stderr, "MEMORY CONTROLLER %d is unconfigured\n", i); fprintf(stderr, "MEMORY CONTROLLER %d is unconfigured\n", i);
else else
fprintf(stderr, "MEMORY CONTROLLER %d at %.5lx, %.5lx\n", fprintf(stderr, "MEMORY CONTROLLER %d at %.5lx, %.5lx\n", i,
i, saturn.mem_cntl[i].config[0], saturn.mem_cntl[i].config[1]); saturn.mem_cntl[i].config[0], saturn.mem_cntl[i].config[1]);
} }
#endif #endif
} }
int get_identification(void) { int get_identification(void) {
int i; int i;
static int chip_id[] static int chip_id[] = {0, 0, 0, 0, 0x05, 0xf6, 0x07, 0xf8, 0x01, 0xf2, 0, 0};
= { 0, 0, 0, 0, 0x05, 0xf6, 0x07, 0xf8, 0x01, 0xf2, 0, 0 };
int id; int id;
for (i = 0; i < 6; i++) for (i = 0; i < 6; i++) {
{
if (saturn.mem_cntl[i].unconfigured) if (saturn.mem_cntl[i].unconfigured)
break; break;
} }
@ -392,26 +368,22 @@ int get_identification(void) {
#ifdef DEBUG_ID #ifdef DEBUG_ID
fprintf(stderr, "%.5lx: C=ID, returning: %x\n", saturn.PC, id); fprintf(stderr, "%.5lx: C=ID, returning: %x\n", saturn.PC, id);
for (i = 0; i < 6; i++) for (i = 0; i < 6; i++) {
{
if (saturn.mem_cntl[i].unconfigured == 2) if (saturn.mem_cntl[i].unconfigured == 2)
fprintf(stderr, "MEMORY CONTROLLER %d is unconfigured\n", i); fprintf(stderr, "MEMORY CONTROLLER %d is unconfigured\n", i);
else if (saturn.mem_cntl[i].unconfigured == 1) else if (saturn.mem_cntl[i].unconfigured == 1) {
{
if (i == 0) if (i == 0)
fprintf(stderr, "MEMORY CONTROLLER %d unconfigured\n", i); fprintf(stderr, "MEMORY CONTROLLER %d unconfigured\n", i);
else else
fprintf(stderr, "MEMORY CONTROLLER %d configured to ????? %.5lx\n", fprintf(stderr, "MEMORY CONTROLLER %d configured to ????? %.5lx\n", i,
i, saturn.mem_cntl[i].config[1]); saturn.mem_cntl[i].config[1]);
} } else
else fprintf(stderr, "MEMORY CONTROLLER %d configured to %.5lx, %.5lx\n", i,
fprintf(stderr, "MEMORY CONTROLLER %d configured to %.5lx, %.5lx\n", saturn.mem_cntl[i].config[0], saturn.mem_cntl[i].config[1]);
i, saturn.mem_cntl[i].config[0], saturn.mem_cntl[i].config[1]);
} }
#endif #endif
for (i = 0; i < 3; i++) for (i = 0; i < 3; i++) {
{
saturn.C[i] = id & 0x0f; saturn.C[i] = id & 0x0f;
id >>= 4; id >>= 4;
} }
@ -426,7 +398,8 @@ void do_shutdown(void) {
device.display_touched = 0; device.display_touched = 0;
update_display(); update_display();
#ifdef HAVE_XSHM #ifdef HAVE_XSHM
if (disp.display_update) refresh_display(); if (disp.display_update)
refresh_display();
#endif #endif
} }
@ -463,7 +436,8 @@ void do_shutdown(void) {
got_alarm = 0; got_alarm = 0;
#ifdef HAVE_XSHM #ifdef HAVE_XSHM
if (disp.display_update) refresh_display(); if (disp.display_update)
refresh_display();
#endif #endif
ticks = get_t1_t2(); ticks = get_t1_t2();
@ -479,29 +453,23 @@ void do_shutdown(void) {
wake = 1; wake = 1;
} }
if (saturn.timer2 <= 0) if (saturn.timer2 <= 0) {
{ if (saturn.t2_ctrl & 0x04) {
if (saturn.t2_ctrl & 0x04)
{
wake = 1; wake = 1;
} }
if (saturn.t2_ctrl & 0x02) if (saturn.t2_ctrl & 0x02) {
{
wake = 1; wake = 1;
saturn.t2_ctrl |= 0x08; saturn.t2_ctrl |= 0x08;
do_interupt(); do_interupt();
} }
} }
if (saturn.timer1 <= 0) if (saturn.timer1 <= 0) {
{
saturn.timer1 &= 0x0f; saturn.timer1 &= 0x0f;
if (saturn.t1_ctrl & 0x04) if (saturn.t1_ctrl & 0x04) {
{
wake = 1; wake = 1;
} }
if (saturn.t1_ctrl & 0x03) if (saturn.t1_ctrl & 0x03) {
{
wake = 1; wake = 1;
saturn.t1_ctrl |= 0x08; saturn.t1_ctrl |= 0x08;
do_interupt(); do_interupt();
@ -518,8 +486,7 @@ void do_shutdown(void) {
alarms++; alarms++;
} }
if (enter_debugger) if (enter_debugger) {
{
wake = 1; wake = 1;
} }
} while (wake == 0); } while (wake == 0);
@ -529,24 +496,40 @@ void do_shutdown(void) {
} }
void set_hardware_stat(int op) { void set_hardware_stat(int op) {
if (op & 1) saturn.XM = 1; if (op & 1)
if (op & 2) saturn.SB = 1; saturn.XM = 1;
if (op & 4) saturn.SR = 1; if (op & 2)
if (op & 8) saturn.MP = 1; saturn.SB = 1;
if (op & 4)
saturn.SR = 1;
if (op & 8)
saturn.MP = 1;
} }
void clear_hardware_stat(int op) { void clear_hardware_stat(int op) {
if (op & 1) saturn.XM = 0; if (op & 1)
if (op & 2) saturn.SB = 0; saturn.XM = 0;
if (op & 4) saturn.SR = 0; if (op & 2)
if (op & 8) saturn.MP = 0; saturn.SB = 0;
if (op & 4)
saturn.SR = 0;
if (op & 8)
saturn.MP = 0;
} }
int is_zero_hardware_stat(int op) { int is_zero_hardware_stat(int op) {
if (op & 1) if (saturn.XM != 0) return 0; if (op & 1)
if (op & 2) if (saturn.SB != 0) return 0; if (saturn.XM != 0)
if (op & 4) if (saturn.SR != 0) return 0; return 0;
if (op & 8) if (saturn.MP != 0) return 0; if (op & 2)
if (saturn.SB != 0)
return 0;
if (op & 4)
if (saturn.SR != 0)
return 0;
if (op & 8)
if (saturn.MP != 0)
return 0;
return 1; return 1;
} }
@ -698,17 +681,11 @@ void add_address(word_20 *dat, int add) {
*dat &= 0xfffff; *dat &= 0xfffff;
} }
static int start_fields[] = { static int start_fields[] = {-1, 0, 2, 0, 15, 3, 0, 0, -1, 0,
-1, 0, 2, 0, 15, 3, 0, 0, 2, 0, 15, 3, 0, 0, 0, 0, 0};
-1, 0, 2, 0, 15, 3, 0, 0,
0, 0, 0
};
static int end_fields[] = { static int end_fields[] = {-1, -1, 2, 2, 15, 14, 1, 15, -1, -1,
-1, -1, 2, 2, 15, 14, 1, 15, 2, 2, 15, 14, 1, 4, 3, 2, 0};
-1, -1, 2, 2, 15, 14, 1, 4,
3, 2, 0
};
static inline int get_start(int code) { static inline int get_start(int code) {
int s; int s;

6
src/checkrom.c
View file

@ -39,8 +39,8 @@
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <unistd.h>
#include <sys/stat.h> #include <sys/stat.h>
#include <unistd.h>
#include "global.h" #include "global.h"
#include "romio.h" #include "romio.h"
@ -64,8 +64,7 @@ int main(int argc, char **argv) {
exit(1); exit(1);
} }
if (!read_rom_file(argv[1], &rom, &rom_size)) if (!read_rom_file(argv[1], &rom, &rom_size)) {
{
fprintf(stderr, "%s: can\'t read ROM from %s\n", argv[0], argv[1]); fprintf(stderr, "%s: can\'t read ROM from %s\n", argv[0], argv[1]);
exit(1); exit(1);
} }
@ -82,7 +81,6 @@ int main(int argc, char **argv) {
version[6] = '\0'; version[6] = '\0';
printf("ROM Version is %s\n", version); printf("ROM Version is %s\n", version);
for (i = 0x100; i < 0x140; i++) { for (i = 0x100; i < 0x140; i++) {
rom[i] = 0x0; rom[i] = 0x0;
} }

1
src/constants.h
View file

@ -45,4 +45,3 @@
#define COLOR_MODE_COLOR 3 #define COLOR_MODE_COLOR 3
#endif /* !_CONSTANTS_H */ #endif /* !_CONSTANTS_H */

950
src/debugger.c
View file

File diff suppressed because it is too large Load diff

4
src/device.c
View file

@ -53,9 +53,9 @@
#include <stdlib.h> #include <stdlib.h>
#include "device.h"
#include "hp48.h" #include "hp48.h"
#include "hp48_emu.h" #include "hp48_emu.h"
#include "device.h"
#include "timer.h" #include "timer.h"
#include "x48_x11.h" #include "x48_x11.h"
@ -175,10 +175,10 @@ void check_devices(void) {
#if 0 #if 0
#include <fcntl.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <unistd.h> #include <unistd.h>
#include <fcntl.h>
void check_out_register(void) { void check_out_register(void) {
static int au = -2; static int au = -2;

1
src/device.h
View file

@ -51,6 +51,7 @@
#define _DEVICE_H 1 #define _DEVICE_H 1
#include "global.h" #include "global.h"
#include "hp48.h"
#define DISP_INSTR_OFF 0x10 #define DISP_INSTR_OFF 0x10

763
src/disasm.c
View file

File diff suppressed because it is too large Load diff

36
src/dump2rom.c
View file

@ -45,13 +45,12 @@
* $Id: dump2rom.c,v 1.7 1995/01/11 18:20:01 ecd Exp ecd $ * $Id: dump2rom.c,v 1.7 1995/01/11 18:20:01 ecd Exp ecd $
*/ */
#include "global.h" #include "global.h"
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <unistd.h>
#include <string.h> #include <string.h>
#include <unistd.h>
#ifdef SUNOS #ifdef SUNOS
#include <memory.h> #include <memory.h>
#endif #endif
@ -67,36 +66,28 @@ int write_mem_file(char *name, unsigned char *mem, int size) {
unsigned char byte; unsigned char byte;
int i, j; int i, j;
if (NULL == (fp = fopen(name, "w"))) if (NULL == (fp = fopen(name, "w"))) {
{
fprintf(stderr, "can\'t open %s\n", name); fprintf(stderr, "can\'t open %s\n", name);
return 0; return 0;
} }
if (NULL == (tmp_mem = (unsigned char *)malloc((size_t)size / 2))) if (NULL == (tmp_mem = (unsigned char *)malloc((size_t)size / 2))) {
{ for (i = 0, j = 0; i < size / 2; i++) {
for (i = 0, j = 0; i < size / 2; i++)
{
byte = (mem[j++] & 0x0f); byte = (mem[j++] & 0x0f);
byte |= (mem[j++] << 4) & 0xf0; byte |= (mem[j++] << 4) & 0xf0;
if (1 != fwrite(&byte, 1, 1, fp)) if (1 != fwrite(&byte, 1, 1, fp)) {
{
fprintf(stderr, "can\'t write %s\n", name); fprintf(stderr, "can\'t write %s\n", name);
fclose(fp); fclose(fp);
return 0; return 0;
} }
} }
} } else {
else for (i = 0, j = 0; i < size / 2; i++) {
{
for (i = 0, j = 0; i < size / 2; i++)
{
tmp_mem[i] = (mem[j++] & 0x0f); tmp_mem[i] = (mem[j++] & 0x0f);
tmp_mem[i] |= (mem[j++] << 4) & 0xf0; tmp_mem[i] |= (mem[j++] << 4) & 0xf0;
} }
if (fwrite(tmp_mem, 1, (size_t)size / 2, fp) != size / 2) if (fwrite(tmp_mem, 1, (size_t)size / 2, fp) != size / 2) {
{
fprintf(stderr, "can\'t write %s\n", name); fprintf(stderr, "can\'t write %s\n", name);
fclose(fp); fclose(fp);
free(tmp_mem); free(tmp_mem);
@ -160,8 +151,8 @@ int main(int argc, char **argv) {
break; break;
} }
if (ch != ':') { if (ch != ':') {
fprintf(stderr, "%s: Illegal char %c, expected \':\' at %lx\n", fprintf(stderr, "%s: Illegal char %c, expected \':\' at %lx\n", argv[0],
argv[0], ch, addr); ch, addr);
break; break;
} }
for (i = 0; i < 16; i++) { for (i = 0; i < 16; i++) {
@ -185,8 +176,8 @@ int main(int argc, char **argv) {
if ((ch = fgetc(dump)) < 0) if ((ch = fgetc(dump)) < 0)
break; break;
if (ch != '\n') { if (ch != '\n') {
fprintf(stderr, "%s: Illegal char %c, expected \'\\n\' at %lx\n", fprintf(stderr, "%s: Illegal char %c, expected \'\\n\' at %lx\n", argv[0],
argv[0], ch, addr); ch, addr);
break; break;
} }
} }
@ -198,8 +189,7 @@ int main(int argc, char **argv) {
size = 0x100000; size = 0x100000;
else else
size = 0x80000; size = 0x80000;
if (!write_mem_file(DEFAULT_ROM_FILE, core, size)) if (!write_mem_file(DEFAULT_ROM_FILE, core, size)) {
{
fprintf(stderr, "%s: can\'t write to %s\n", argv[0], DEFAULT_ROM_FILE); fprintf(stderr, "%s: can\'t write to %s\n", argv[0], DEFAULT_ROM_FILE);
exit(1); exit(1);
} }

81
src/emulate.c
View file

@ -43,17 +43,16 @@
* $Id: emulate.c,v 1.16 1995/01/11 18:20:01 ecd Exp ecd $ * $Id: emulate.c,v 1.16 1995/01/11 18:20:01 ecd Exp ecd $
*/ */
#include "global.h" #include "global.h"
#include <stdio.h> #include <stdio.h>
#include "debugger.h"
#include "device.h"
#include "hp48.h" #include "hp48.h"
#include "hp48_emu.h" #include "hp48_emu.h"
#include "device.h"
#include "timer.h" #include "timer.h"
#include "x48_x11.h" #include "x48_x11.h"
#include "debugger.h"
extern int throttle; extern int throttle;
@ -109,10 +108,8 @@ unsigned long delta_t_16;
unsigned long delta_i; unsigned long delta_i;
word_64 run; word_64 run;
static word_20 jumpmasks[] = { static word_20 jumpmasks[] = {0xffffffff, 0xfffffff0, 0xffffff00, 0xfffff000,
0xffffffff, 0xfffffff0, 0xffffff00, 0xfffff000, 0xffff0000, 0xfff00000, 0xff000000, 0xf0000000};
0xffff0000, 0xfff00000, 0xff000000, 0xf0000000
};
int decode_group_80(void) { int decode_group_80(void) {
int t, op3, op4, op5, op6; int t, op3, op4, op5, op6;
@ -1186,16 +1183,20 @@ static inline int decode_8_thru_f(int op1) {
saturn.CARRY = is_less_register(saturn.D, saturn.C, A_FIELD); saturn.CARRY = is_less_register(saturn.D, saturn.C, A_FIELD);
break; break;
case 8: /* ?A>=B */ case 8: /* ?A>=B */
saturn.CARRY = is_greater_or_equal_register(saturn.A, saturn.B, A_FIELD); saturn.CARRY =
is_greater_or_equal_register(saturn.A, saturn.B, A_FIELD);
break; break;
case 9: /* ?B>=C */ case 9: /* ?B>=C */
saturn.CARRY = is_greater_or_equal_register(saturn.B, saturn.C, A_FIELD); saturn.CARRY =
is_greater_or_equal_register(saturn.B, saturn.C, A_FIELD);
break; break;
case 0xa: /* ?C>=A */ case 0xa: /* ?C>=A */
saturn.CARRY = is_greater_or_equal_register(saturn.C, saturn.A, A_FIELD); saturn.CARRY =
is_greater_or_equal_register(saturn.C, saturn.A, A_FIELD);
break; break;
case 0xb: /* ?D>=C */ case 0xb: /* ?D>=C */
saturn.CARRY = is_greater_or_equal_register(saturn.D, saturn.C, A_FIELD); saturn.CARRY =
is_greater_or_equal_register(saturn.D, saturn.C, A_FIELD);
break; break;
case 0xc: /* ?A<=B */ case 0xc: /* ?A<=B */
saturn.CARRY = is_less_or_equal_register(saturn.A, saturn.B, A_FIELD); saturn.CARRY = is_less_or_equal_register(saturn.A, saturn.B, A_FIELD);
@ -2220,15 +2221,17 @@ inline void schedule(void) {
schedule_event = sched_timer2; schedule_event = sched_timer2;
#ifdef DEBUG_SCHED #ifdef DEBUG_SCHED
fprintf(stderr, "next timer 2 step: %ld, event: %ld\n", fprintf(stderr, "next timer 2 step: %ld, event: %ld\n", sched_timer2,
sched_timer2, schedule_event); schedule_event);
#endif #endif
if (device_check) { if (device_check) {
device_check = 0; device_check = 0;
if ((sched_display -= steps) <= 0) { if ((sched_display -= steps) <= 0) {
if (device.display_touched) device.display_touched -= steps; if (device.display_touched)
if (device.display_touched < 0) device.display_touched = 1; device.display_touched -= steps;
if (device.display_touched < 0)
device.display_touched = 1;
#ifdef DEBUG_DISP_SCHED #ifdef DEBUG_DISP_SCHED
fprintf(stderr, "check_device: disp_when %d, disp_touched %d\n", fprintf(stderr, "check_device: disp_when %d, disp_touched %d\n",
sched_display, device.display_touched); sched_display, device.display_touched);
@ -2239,7 +2242,8 @@ inline void schedule(void) {
if (device.display_touched) { if (device.display_touched) {
if (device.display_touched < sched_display) if (device.display_touched < sched_display)
sched_display = device.display_touched - 1; sched_display = device.display_touched - 1;
if (sched_display < schedule_event) schedule_event = sched_display; if (sched_display < schedule_event)
schedule_event = sched_display;
} }
} }
@ -2249,11 +2253,12 @@ inline void schedule(void) {
receive_char(); receive_char();
} }
} }
if (sched_receive < schedule_event) schedule_event = sched_receive; if (sched_receive < schedule_event)
schedule_event = sched_receive;
#ifdef DEBUG_SCHED #ifdef DEBUG_SCHED
fprintf(stderr, "next receive: %ld, event: %ld\n", fprintf(stderr, "next receive: %ld, event: %ld\n", sched_receive,
sched_receive, schedule_event); schedule_event);
#endif #endif
if ((sched_adjtime -= steps) <= 0) { if ((sched_adjtime -= steps) <= 0) {
@ -2288,14 +2293,14 @@ inline void schedule(void) {
} else { } else {
adj_time_pending = 1; adj_time_pending = 1;
} }
} }
if (sched_adjtime < schedule_event) schedule_event = sched_adjtime; if (sched_adjtime < schedule_event)
schedule_event = sched_adjtime;
#ifdef DEBUG_SCHED #ifdef DEBUG_SCHED
fprintf(stderr, "next adjtime: %ld, event: %ld\n", fprintf(stderr, "next adjtime: %ld, event: %ld\n", sched_adjtime,
sched_adjtime, schedule_event); schedule_event);
#endif #endif
if ((sched_timer1 -= steps) <= 0) { if ((sched_timer1 -= steps) <= 0) {
@ -2311,11 +2316,12 @@ inline void schedule(void) {
do_interupt(); do_interupt();
} }
} }
if (sched_timer1 < schedule_event) schedule_event = sched_timer1; if (sched_timer1 < schedule_event)
schedule_event = sched_timer1;
#ifdef DEBUG_SCHED #ifdef DEBUG_SCHED
fprintf(stderr, "next timer 1 step: %ld, event: %ld\n", fprintf(stderr, "next timer 1 step: %ld, event: %ld\n", sched_timer1,
sched_timer1, schedule_event); schedule_event);
#endif #endif
if ((sched_statistics -= steps) <= 0) { if ((sched_statistics -= steps) <= 0) {
@ -2332,11 +2338,13 @@ inline void schedule(void) {
delta_i = instructions - old_stat_instr; delta_i = instructions - old_stat_instr;
old_stat_instr = instructions; old_stat_instr = instructions;
if (delta_t_1 > 0) { if (delta_t_1 > 0) {
t1_i_per_tick = ((NR_SAMPLES - 1) * t1_i_per_tick + t1_i_per_tick =
(delta_i / delta_t_16)) / NR_SAMPLES; ((NR_SAMPLES - 1) * t1_i_per_tick + (delta_i / delta_t_16)) /
NR_SAMPLES;
t2_i_per_tick = t1_i_per_tick / 512; t2_i_per_tick = t1_i_per_tick / 512;
saturn.i_per_s = ((NR_SAMPLES - 1) * saturn.i_per_s + saturn.i_per_s =
(delta_i / delta_t_1)) / NR_SAMPLES; ((NR_SAMPLES - 1) * saturn.i_per_s + (delta_i / delta_t_1)) /
NR_SAMPLES;
} else { } else {
t1_i_per_tick = 8192; t1_i_per_tick = 8192;
t2_i_per_tick = 16; t2_i_per_tick = 16;
@ -2361,8 +2369,8 @@ inline void schedule(void) {
schedule_event = sched_statistics; schedule_event = sched_statistics;
#ifdef DEBUG_SCHED #ifdef DEBUG_SCHED
fprintf(stderr, "next statistics: %ld, event: %ld\n", fprintf(stderr, "next statistics: %ld, event: %ld\n", sched_statistics,
sched_statistics, schedule_event); schedule_event);
#endif #endif
if ((sched_instr_rollover -= steps) <= 0) { if ((sched_instr_rollover -= steps) <= 0) {
@ -2386,7 +2394,8 @@ inline void schedule(void) {
if (got_alarm) { if (got_alarm) {
got_alarm = 0; got_alarm = 0;
#ifdef HAVE_XSHM #ifdef HAVE_XSHM
if (disp.display_update) refresh_display(); if (disp.display_update)
refresh_display();
#endif #endif
GetEvent(); GetEvent();
} }
@ -2427,7 +2436,8 @@ int emulate(void) {
#else #else
gettimeofday(&tv, &tz); gettimeofday(&tv, &tz);
#endif #endif
while ((tv.tv_sec == tv2.tv_sec) && ((tv.tv_usec - tv2.tv_usec) < 2)) { while ((tv.tv_sec == tv2.tv_sec) &&
((tv.tv_usec - tv2.tv_usec) < 2)) {
gettimeofday(&tv, &tz); gettimeofday(&tv, &tz);
} }
@ -2444,8 +2454,7 @@ int emulate(void) {
// puts("bug"); // puts("bug");
// schedule_event = 0; // schedule_event = 0;
} }
if (schedule_event-- <= 0) if (schedule_event-- <= 0) {
{
schedule(); schedule();
} }
} while (!enter_debugger); } while (!enter_debugger);

11
src/errors.c
View file

@ -31,15 +31,18 @@
#include "global.h" #include "global.h"
#include "resources.h" #include "resources.h"
char errbuf[1024] = { 0, }; char errbuf[1024] = {
char fixbuf[1024] = { 0, }; 0,
};
char fixbuf[1024] = {
0,
};
void fatal_exit(void) { void fatal_exit(void) {
if (quiet) if (quiet)
exit(1); exit(1);
if (errbuf[0] == '\0') if (errbuf[0] == '\0') {
{
fprintf(stderr, "%s: FATAL ERROR, exit.\n", progname); fprintf(stderr, "%s: FATAL ERROR, exit.\n", progname);
exit(1); exit(1);
} }

4
src/global.h
View file

@ -123,8 +123,8 @@ extern void fclose __ProtoType__((FILE *));
extern int fgetc __ProtoType__((FILE *)); extern int fgetc __ProtoType__((FILE *));
extern void bzero __ProtoType__((void *, int)); extern void bzero __ProtoType__((void *, int));
extern time_t time __ProtoType__((time_t *)); extern time_t time __ProtoType__((time_t *));
extern int select __ProtoType__((int, fd_set *, fd_set *, extern int select __ProtoType__((int, fd_set *, fd_set *, fd_set *,
fd_set *, struct timeval *)); struct timeval *));
extern int setitimer __ProtoType__((int, struct itimerval *, extern int setitimer __ProtoType__((int, struct itimerval *,
struct itimerval *)); struct itimerval *));
extern int gethostname __ProtoType__((char *, int)); extern int gethostname __ProtoType__((char *, int));

3
src/hp48.h
View file

@ -288,6 +288,5 @@ extern int read_rom __ProtoType__((const char *fname));
extern int read_files __ProtoType__((void)); extern int read_files __ProtoType__((void));
extern int write_files __ProtoType__((void)); extern int write_files __ProtoType__((void));
extern void load_addr __ProtoType__((word_20 *dat, long addr, extern void load_addr __ProtoType__((word_20 * dat, long addr, int n));
int n));
#endif /* !_HP48_H */ #endif /* !_HP48_H */

88
src/hp48_emu.h
View file

@ -100,29 +100,23 @@ extern int get_register_bit __ProtoType__((unsigned char *reg, int n));
extern void set_register_nibble __ProtoType__((unsigned char *reg, int n, extern void set_register_nibble __ProtoType__((unsigned char *reg, int n,
unsigned char val)); unsigned char val));
extern unsigned char get_register_nibble __ProtoType__((unsigned char *reg, int n)); extern unsigned char get_register_nibble __ProtoType__((unsigned char *reg,
int n));
extern void register_to_address __ProtoType__((unsigned char *reg, word_20 *dat,
extern void register_to_address __ProtoType__((unsigned char *reg, int s));
word_20 *dat, int s)); extern void address_to_register __ProtoType__((word_20 dat, unsigned char *reg,
extern void address_to_register __ProtoType__((word_20 dat, int s));
unsigned char *reg, int s));
extern void add_address __ProtoType__((word_20 * dat, int add)); extern void add_address __ProtoType__((word_20 * dat, int add));
extern char *make_hexstr __ProtoType__((long addr, int n)); extern char *make_hexstr __ProtoType__((long addr, int n));
extern void load_constant __ProtoType__((unsigned char *reg, int n, extern void load_constant __ProtoType__((unsigned char *reg, int n, long addr));
long addr)); extern void load_address __ProtoType__((unsigned char *reg, long addr, int n));
extern void load_address __ProtoType__((unsigned char *reg, long addr,
int n));
extern void store __ProtoType__((word_20 dat, unsigned char *reg, extern void store __ProtoType__((word_20 dat, unsigned char *reg, int code));
int code)); extern void store_n __ProtoType__((word_20 dat, unsigned char *reg, int n));
extern void store_n __ProtoType__((word_20 dat, unsigned char *reg, extern void recall __ProtoType__((unsigned char *reg, word_20 dat, int code));
int n)); extern void recall_n __ProtoType__((unsigned char *reg, word_20 dat, int n));
extern void recall __ProtoType__((unsigned char *reg, word_20 dat,
int code));
extern void recall_n __ProtoType__((unsigned char *reg, word_20 dat,
int n));
extern long dat_to_addr __ProtoType__((unsigned char *dat)); extern long dat_to_addr __ProtoType__((unsigned char *dat));
extern void addr_to_dat __ProtoType__((long addr, unsigned char *dat)); extern void addr_to_dat __ProtoType__((long addr, unsigned char *dat));
@ -139,10 +133,10 @@ extern void do_shutdown __ProtoType__((void));
extern int get_identification __ProtoType__((void)); extern int get_identification __ProtoType__((void));
extern void add_p_plus_one __ProtoType__((unsigned char *r)); extern void add_p_plus_one __ProtoType__((unsigned char *r));
extern void add_register_constant __ProtoType__((unsigned char *res, extern void add_register_constant __ProtoType__((unsigned char *res, int code,
int code, int val)); int val));
extern void sub_register_constant __ProtoType__((unsigned char *res, extern void sub_register_constant __ProtoType__((unsigned char *res, int code,
int code, int val)); int val));
extern void add_register __ProtoType__((unsigned char *res, unsigned char *r1, extern void add_register __ProtoType__((unsigned char *res, unsigned char *r1,
unsigned char *r2, int code)); unsigned char *r2, int code));
extern void sub_register __ProtoType__((unsigned char *res, unsigned char *r1, extern void sub_register __ProtoType__((unsigned char *res, unsigned char *r1,
@ -158,44 +152,34 @@ extern void and_register __ProtoType__((unsigned char *res, unsigned char *r1,
unsigned char *r2, int code)); unsigned char *r2, int code));
extern void copy_register __ProtoType__((unsigned char *to, unsigned char *from, extern void copy_register __ProtoType__((unsigned char *to, unsigned char *from,
int code)); int code));
extern void exchange_register __ProtoType__((unsigned char *r1, unsigned char *r2, extern void exchange_register __ProtoType__((unsigned char *r1,
int code)); unsigned char *r2, int code));
extern void exchange_reg __ProtoType__((unsigned char *r, word_20 *d, int code)); extern void exchange_reg __ProtoType__((unsigned char *r, word_20 *d,
int code));
extern void shift_left_register __ProtoType__((unsigned char *r, int code)); extern void shift_left_register __ProtoType__((unsigned char *r, int code));
extern void shift_left_circ_register __ProtoType__((unsigned char *r, int code)); extern void shift_left_circ_register __ProtoType__((unsigned char *r,
int code));
extern void shift_right_register __ProtoType__((unsigned char *r, int code)); extern void shift_right_register __ProtoType__((unsigned char *r, int code));
extern void shift_right_circ_register __ProtoType__((unsigned char *r, int code)); extern void shift_right_circ_register __ProtoType__((unsigned char *r,
extern void shift_right_bit_register __ProtoType__((unsigned char *r, int code));
extern int is_zero_register __ProtoType__((
unsigned char *r,
int code)); int code));
extern int is_not_zero_register __ProtoType__(( extern void shift_right_bit_register __ProtoType__((unsigned char *r,
unsigned char *r,
int code)); int code));
extern int is_equal_register __ProtoType__(( extern int is_zero_register __ProtoType__((unsigned char *r, int code));
unsigned char *r1, extern int is_not_zero_register __ProtoType__((unsigned char *r, int code));
extern int is_equal_register __ProtoType__((unsigned char *r1,
unsigned char *r2, int code));
extern int is_not_equal_register __ProtoType__((unsigned char *r1,
unsigned char *r2, int code));
extern int is_less_register __ProtoType__((unsigned char *r1, unsigned char *r2,
int code));
extern int is_less_or_equal_register __ProtoType__((unsigned char *r1,
unsigned char *r2, unsigned char *r2,
int code)); int code));
extern int is_not_equal_register __ProtoType__(( extern int is_greater_register __ProtoType__((unsigned char *r1,
unsigned char *r1, unsigned char *r2, int code));
unsigned char *r2, extern int is_greater_or_equal_register __ProtoType__((unsigned char *r1,
int code));
extern int is_less_register __ProtoType__((
unsigned char *r1,
unsigned char *r2,
int code));
extern int is_less_or_equal_register __ProtoType__((
unsigned char *r1,
unsigned char *r2,
int code));
extern int is_greater_register __ProtoType__((
unsigned char *r1,
unsigned char *r2,
int code));
extern int is_greater_or_equal_register __ProtoType__((
unsigned char *r1,
unsigned char *r2, unsigned char *r2,
int code)); int code));

324
src/hp48char.h
View file

@ -44,265 +44,71 @@ typedef struct trans_tbl_t {
#ifndef DEFINE_TRANS_TABLE #ifndef DEFINE_TRANS_TABLE
extern trans_tbl_t hp48_trans_tbl[256]; extern trans_tbl_t hp48_trans_tbl[256];
#else #else
trans_tbl_t hp48_trans_tbl[256] = trans_tbl_t hp48_trans_tbl[256] = {
{ {0, "\\0"}, {1, "\\001"}, {2, "\\002"}, {3, "\\003"},
{ 0, "\\0" }, {4, "\\004"}, {5, "\\005"}, {6, "\\006"}, {7, "\\007"},
{ 1, "\\001" }, {8, "\\b"}, {9, "\\t"}, {10, "\\n"}, {11, "\\011"},
{ 2, "\\002" }, {12, "\\f"}, {13, "\\r"}, {14, "\\014"}, {15, "\\015"},
{ 3, "\\003" }, {16, "\\016"}, {17, "\\017"}, {18, "\\018"}, {19, "\\019"},
{ 4, "\\004" }, {20, "\\020"}, {21, "\\021"}, {22, "\\022"}, {23, "\\023"},
{ 5, "\\005" }, {24, "\\024"}, {25, "\\025"}, {26, "\\026"}, {27, "\\027"},
{ 6, "\\006" }, {28, "\\028"}, {29, "\\029"}, {30, "\\030"}, {31, "\\031"},
{ 7, "\\007" }, {' ', 0}, {'!', 0}, {'"', 0}, {'#', 0},
{ 8, "\\b" }, {'$', 0}, {'%', 0}, {'&', 0}, {'\'', 0},
{ 9, "\\t" }, {'(', 0}, {')', 0}, {'*', 0}, {'+', 0},
{ 10, "\\n" }, {',', 0}, {'-', 0}, {'.', 0}, {'/', 0},
{ 11, "\\011" }, {'0', 0}, {'1', 0}, {'2', 0}, {'3', 0},
{ 12, "\\f" }, {'4', 0}, {'5', 0}, {'6', 0}, {'7', 0},
{ 13, "\\r" }, {'8', 0}, {'9', 0}, {':', 0}, {';', 0},
{ 14, "\\014" }, {'<', 0}, {'=', 0}, {'>', 0}, {'?', 0},
{ 15, "\\015" }, {'@', 0}, {'A', 0}, {'B', 0}, {'C', 0},
{ 16, "\\016" }, {'D', 0}, {'E', 0}, {'F', 0}, {'G', 0},
{ 17, "\\017" }, {'H', 0}, {'I', 0}, {'J', 0}, {'K', 0},
{ 18, "\\018" }, {'L', 0}, {'M', 0}, {'N', 0}, {'O', 0},
{ 19, "\\019" }, {'P', 0}, {'Q', 0}, {'R', 0}, {'S', 0},
{ 20, "\\020" }, {'T', 0}, {'U', 0}, {'V', 0}, {'W', 0},
{ 21, "\\021" }, {'X', 0}, {'Y', 0}, {'Z', 0}, {'[', 0},
{ 22, "\\022" }, {'\\', 0}, {']', 0}, {'^', 0}, {'_', 0},
{ 23, "\\023" }, {'`', 0}, {'a', 0}, {'b', 0}, {'c', 0},
{ 24, "\\024" }, {'d', 0}, {'e', 0}, {'f', 0}, {'g', 0},
{ 25, "\\025" }, {'h', 0}, {'i', 0}, {'j', 0}, {'k', 0},
{ 26, "\\026" }, {'l', 0}, {'m', 0}, {'n', 0}, {'o', 0},
{ 27, "\\027" }, {'p', 0}, {'q', 0}, {'r', 0}, {'s', 0},
{ 28, "\\028" }, {'t', 0}, {'u', 0}, {'v', 0}, {'w', 0},
{ 29, "\\029" }, {'x', 0}, {'y', 0}, {'z', 0}, {'{', 0},
{ 30, "\\030" }, {'|', 0}, {'}', 0}, {'~', 0}, {127, "\\127"},
{ 31, "\\031" }, {128, "\\<)"}, {129, "\\x-"}, {130, "\\.V"}, {131, "\\v/"},
{ ' ', 0 }, {132, "\\.S"}, {133, "\\GS"}, {134, "\\|>"}, {135, "\\pi"},
{ '!', 0 }, {136, "\\.d"}, {137, "\\<="}, {138, "\\>="}, {139, "\\=/"},
{ '"', 0 }, {140, "\\Ga"}, {141, "\\->"}, {142, "\\<-"}, {143, "\\|v"},
{ '#', 0 }, {144, "\\|^"}, {145, "\\Gg"}, {146, "\\Gd"}, {147, "\\Ge"},
{ '$', 0 }, {148, "\\Gn"}, {149, "\\Gh"}, {150, "\\Gl"}, {151, "\\Gr"},
{ '%', 0 }, {152, "\\Gs"}, {153, "\\Gt"}, {154, "\\Gw"}, {155, "\\GD"},
{ '&', 0 }, {156, "\\PI"}, {157, "\\GW"}, {158, "\\[]"}, {159, "\\oo"},
{ '\'', 0 }, {160, "\\160"}, {161, "\\161"}, {162, "\\162"}, {163, "\\163"},
{ '(', 0 }, {164, "\\164"}, {165, "\\165"}, {166, "\\166"}, {167, "\\167"},
{ ')', 0 }, {168, "\\168"}, {169, "\\169"}, {170, "\\170"}, {171, "\\<<"},
{ '*', 0 }, {172, "\\172"}, {173, "\\173"}, {174, "\\174"}, {175, "\\175"},
{ '+', 0 }, {176, "\\^o"}, {177, "\\177"}, {178, "\\178"}, {179, "\\179"},
{ ',', 0 }, {180, "\\180"}, {181, "\\Gm"}, {182, "\\182"}, {183, "\\183"},
{ '-', 0 }, {184, "\\184"}, {185, "\\185"}, {186, "\\186"}, {187, "\\>>"},
{ '.', 0 }, {188, "\\188"}, {189, "\\189"}, {190, "\\190"}, {191, "\\191"},
{ '/', 0 }, {192, "\\192"}, {193, "\\193"}, {194, "\\194"}, {195, "\\195"},
{ '0', 0 }, {196, "\\196"}, {197, "\\197"}, {198, "\\198"}, {199, "\\199"},
{ '1', 0 }, {200, "\\200"}, {201, "\\201"}, {202, "\\202"}, {203, "\\203"},
{ '2', 0 }, {204, "\\204"}, {205, "\\205"}, {206, "\\206"}, {207, "\\207"},
{ '3', 0 }, {208, "\\208"}, {209, "\\209"}, {210, "\\210"}, {211, "\\211"},
{ '4', 0 }, {212, "\\212"}, {213, "\\213"}, {214, "\\214"}, {215, "\\.x"},
{ '5', 0 }, {216, "\\O/"}, {217, "\\217"}, {218, "\\218"}, {219, "\\219"},
{ '6', 0 }, {220, "\\220"}, {221, "\\221"}, {222, "\\222"}, {223, "\\223"},
{ '7', 0 }, {224, "\\224"}, {225, "\\225"}, {226, "\\226"}, {227, "\\227"},
{ '8', 0 }, {228, "\\228"}, {229, "\\229"}, {230, "\\230"}, {231, "\\231"},
{ '9', 0 }, {232, "\\232"}, {233, "\\233"}, {234, "\\234"}, {235, "\\235"},
{ ':', 0 }, {236, "\\236"}, {237, "\\237"}, {238, "\\238"}, {239, "\\239"},
{ ';', 0 }, {240, "\\240"}, {241, "\\241"}, {242, "\\242"}, {243, "\\243"},
{ '<', 0 }, {244, "\\244"}, {245, "\\245"}, {246, "\\246"}, {247, "\\:-"},
{ '=', 0 }, {248, "\\248"}, {249, "\\249"}, {250, "\\250"}, {251, "\\251"},
{ '>', 0 }, {252, "\\252"}, {253, "\\253"}, {254, "\\254"}, {255, "\\255"}};
{ '?', 0 },
{ '@', 0 },
{ 'A', 0 },
{ 'B', 0 },
{ 'C', 0 },
{ 'D', 0 },
{ 'E', 0 },
{ 'F', 0 },
{ 'G', 0 },
{ 'H', 0 },
{ 'I', 0 },
{ 'J', 0 },
{ 'K', 0 },
{ 'L', 0 },
{ 'M', 0 },
{ 'N', 0 },
{ 'O', 0 },
{ 'P', 0 },
{ 'Q', 0 },
{ 'R', 0 },
{ 'S', 0 },
{ 'T', 0 },
{ 'U', 0 },
{ 'V', 0 },
{ 'W', 0 },
{ 'X', 0 },
{ 'Y', 0 },
{ 'Z', 0 },
{ '[', 0 },
{ '\\', 0 },
{ ']', 0 },
{ '^', 0 },
{ '_', 0 },
{ '`', 0 },
{ 'a', 0 },
{ 'b', 0 },
{ 'c', 0 },
{ 'd', 0 },
{ 'e', 0 },
{ 'f', 0 },
{ 'g', 0 },
{ 'h', 0 },
{ 'i', 0 },
{ 'j', 0 },
{ 'k', 0 },
{ 'l', 0 },
{ 'm', 0 },
{ 'n', 0 },
{ 'o', 0 },
{ 'p', 0 },
{ 'q', 0 },
{ 'r', 0 },
{ 's', 0 },
{ 't', 0 },
{ 'u', 0 },
{ 'v', 0 },
{ 'w', 0 },
{ 'x', 0 },
{ 'y', 0 },
{ 'z', 0 },
{ '{', 0 },
{ '|', 0 },
{ '}', 0 },
{ '~', 0 },
{ 127, "\\127" },
{ 128, "\\<)" },
{ 129, "\\x-" },
{ 130, "\\.V" },
{ 131, "\\v/" },
{ 132, "\\.S" },
{ 133, "\\GS" },
{ 134, "\\|>" },
{ 135, "\\pi" },
{ 136, "\\.d" },
{ 137, "\\<=" },
{ 138, "\\>=" },
{ 139, "\\=/" },
{ 140, "\\Ga" },
{ 141, "\\->" },
{ 142, "\\<-" },
{ 143, "\\|v" },
{ 144, "\\|^" },
{ 145, "\\Gg" },
{ 146, "\\Gd" },
{ 147, "\\Ge" },
{ 148, "\\Gn" },
{ 149, "\\Gh" },
{ 150, "\\Gl" },
{ 151, "\\Gr" },
{ 152, "\\Gs" },
{ 153, "\\Gt" },
{ 154, "\\Gw" },
{ 155, "\\GD" },
{ 156, "\\PI" },
{ 157, "\\GW" },
{ 158, "\\[]" },
{ 159, "\\oo" },
{ 160, "\\160" },
{ 161, "\\161" },
{ 162, "\\162" },
{ 163, "\\163" },
{ 164, "\\164" },
{ 165, "\\165" },
{ 166, "\\166" },
{ 167, "\\167" },
{ 168, "\\168" },
{ 169, "\\169" },
{ 170, "\\170" },
{ 171, "\\<<" },
{ 172, "\\172" },
{ 173, "\\173" },
{ 174, "\\174" },
{ 175, "\\175" },
{ 176, "\\^o" },
{ 177, "\\177" },
{ 178, "\\178" },
{ 179, "\\179" },
{ 180, "\\180" },
{ 181, "\\Gm" },
{ 182, "\\182" },
{ 183, "\\183" },
{ 184, "\\184" },
{ 185, "\\185" },
{ 186, "\\186" },
{ 187, "\\>>" },
{ 188, "\\188" },
{ 189, "\\189" },
{ 190, "\\190" },
{ 191, "\\191" },
{ 192, "\\192" },
{ 193, "\\193" },
{ 194, "\\194" },
{ 195, "\\195" },
{ 196, "\\196" },
{ 197, "\\197" },
{ 198, "\\198" },
{ 199, "\\199" },
{ 200, "\\200" },
{ 201, "\\201" },
{ 202, "\\202" },
{ 203, "\\203" },
{ 204, "\\204" },
{ 205, "\\205" },
{ 206, "\\206" },
{ 207, "\\207" },
{ 208, "\\208" },
{ 209, "\\209" },
{ 210, "\\210" },
{ 211, "\\211" },
{ 212, "\\212" },
{ 213, "\\213" },
{ 214, "\\214" },
{ 215, "\\.x" },
{ 216, "\\O/" },
{ 217, "\\217" },
{ 218, "\\218" },
{ 219, "\\219" },
{ 220, "\\220" },
{ 221, "\\221" },
{ 222, "\\222" },
{ 223, "\\223" },
{ 224, "\\224" },
{ 225, "\\225" },
{ 226, "\\226" },
{ 227, "\\227" },
{ 228, "\\228" },
{ 229, "\\229" },
{ 230, "\\230" },
{ 231, "\\231" },
{ 232, "\\232" },
{ 233, "\\233" },
{ 234, "\\234" },
{ 235, "\\235" },
{ 236, "\\236" },
{ 237, "\\237" },
{ 238, "\\238" },
{ 239, "\\239" },
{ 240, "\\240" },
{ 241, "\\241" },
{ 242, "\\242" },
{ 243, "\\243" },
{ 244, "\\244" },
{ 245, "\\245" },
{ 246, "\\246" },
{ 247, "\\:-" },
{ 248, "\\248" },
{ 249, "\\249" },
{ 250, "\\250" },
{ 251, "\\251" },
{ 252, "\\252" },
{ 253, "\\253" },
{ 254, "\\254" },
{ 255, "\\255" }
};
#endif /* DEFINE_TRANS_TABLE */ #endif /* DEFINE_TRANS_TABLE */
#endif /* !_HP48CHAR_H */ #endif /* !_HP48CHAR_H */

702
src/init.c
View file

File diff suppressed because it is too large Load diff

64
src/lcd.c
View file

@ -60,23 +60,22 @@
* $Id: lcd.c,v 1.13 1995/01/11 18:20:01 ecd Exp ecd $ * $Id: lcd.c,v 1.13 1995/01/11 18:20:01 ecd Exp ecd $
*/ */
#include "global.h" #include "global.h"
#include <stdio.h> #include <stdio.h>
#include <unistd.h>
#include <string.h> #include <string.h>
#include <unistd.h>
#ifdef SUNOS #ifdef SUNOS
#include <memory.h> #include <memory.h>
#endif #endif
#include <X11/Xlib.h> #include <X11/Xlib.h>
#include <X11/Xutil.h> #include <X11/Xutil.h>
#include "annunc.h"
#include "device.h"
#include "hp48.h" #include "hp48.h"
#include "hp48_emu.h" #include "hp48_emu.h"
#include "x48_x11.h" #include "x48_x11.h"
#include "annunc.h"
#include "device.h"
static int last_annunc_state = -1; static int last_annunc_state = -1;
@ -91,8 +90,7 @@ unsigned char lcd_buffer[DISP_ROWS][NIBS_PER_BUFFER_ROW];
Pixmap nibble_maps[16]; Pixmap nibble_maps[16];
unsigned char nibbles[16][2] = unsigned char nibbles[16][2] = {
{
{0x00, 0x00}, /* ---- */ {0x00, 0x00}, /* ---- */
{0x03, 0x03}, /* *--- */ {0x03, 0x03}, /* *--- */
{0x0c, 0x0c}, /* -*-- */ {0x0c, 0x0c}, /* -*-- */
@ -117,8 +115,8 @@ void init_nibble_maps(void) {
int i; int i;
for (i = 0; i < 16; i++) { for (i = 0; i < 16; i++) {
nibble_maps[i] = XCreateBitmapFromData(dpy, disp.win, nibble_maps[i] =
(char *)nibbles[i], 8, 2); XCreateBitmapFromData(dpy, disp.win, (char *)nibbles[i], 8, 2);
} }
#ifdef HAVE_XSHM #ifdef HAVE_XSHM
if (shm_flag) { if (shm_flag) {
@ -180,8 +178,8 @@ void init_display(void) {
else else
display.nibs_per_line = (NIBBLES_PER_ROW + saturn.line_offset) & 0xfff; display.nibs_per_line = (NIBBLES_PER_ROW + saturn.line_offset) & 0xfff;
display.disp_end = display.disp_start + display.disp_end =
(display.nibs_per_line * (display.lines + 1)); display.disp_start + (display.nibs_per_line * (display.lines + 1));
display.menu_start = saturn.menu_addr; display.menu_start = saturn.menu_addr;
display.menu_end = saturn.menu_addr + 0x110; display.menu_end = saturn.menu_addr + 0x110;
@ -238,8 +236,7 @@ void update_display(void) {
word_20 data_addr, data_addr_2; word_20 data_addr, data_addr_2;
#endif #endif
if (!disp.mapped) if (!disp.mapped) {
{
refresh_icon(); refresh_icon();
return; return;
} }
@ -316,9 +313,11 @@ void update_display(void) {
} else { } else {
#ifdef HAVE_XSHM #ifdef HAVE_XSHM
if (shm_flag) { if (shm_flag) {
memset(disp.disp_image->data, 0, memset(
disp.disp_image->data, 0,
(size_t)(disp.disp_image->bytes_per_line * disp.disp_image->height)); (size_t)(disp.disp_image->bytes_per_line * disp.disp_image->height));
memset(disp.menu_image->data, 0, memset(
disp.menu_image->data, 0,
(size_t)(disp.menu_image->bytes_per_line * disp.menu_image->height)); (size_t)(disp.menu_image->bytes_per_line * disp.menu_image->height));
disp.display_update = UPDATE_DISP | UPDATE_MENU; disp.display_update = UPDATE_DISP | UPDATE_MENU;
} else { } else {
@ -380,8 +379,7 @@ void disp_draw_nibble(word_20 addr, word_4 val) {
for (y = 0; y < display.lines; y++) { for (y = 0; y < display.lines; y++) {
disp.disp_image->data[shm_addr] = nibble_bits[val]; disp.disp_image->data[shm_addr] = nibble_bits[val];
shm_addr += disp.disp_image->bytes_per_line; shm_addr += disp.disp_image->bytes_per_line;
disp.disp_image->data[shm_addr] disp.disp_image->data[shm_addr] = nibble_bits[val];
= nibble_bits[val];
shm_addr += disp.disp_image->bytes_per_line; shm_addr += disp.disp_image->bytes_per_line;
} }
disp.display_update |= UPDATE_DISP; disp.display_update |= UPDATE_DISP;
@ -409,8 +407,9 @@ void menu_draw_nibble(word_20 addr, word_4 val) {
offset = (addr - display.menu_start); offset = (addr - display.menu_start);
#ifdef HAVE_XSHM #ifdef HAVE_XSHM
if (shm_flag) { if (shm_flag) {
shm_addr = 2 * (offset / NIBBLES_PER_ROW) * disp.menu_image->bytes_per_line shm_addr =
+ (offset % NIBBLES_PER_ROW); 2 * (offset / NIBBLES_PER_ROW) * disp.menu_image->bytes_per_line +
(offset % NIBBLES_PER_ROW);
disp.menu_image->data[shm_addr] = nibble_bits[val]; disp.menu_image->data[shm_addr] = nibble_bits[val];
disp.menu_image->data[shm_addr + disp.menu_image->bytes_per_line] = disp.menu_image->data[shm_addr + disp.menu_image->bytes_per_line] =
nibble_bits[val]; nibble_bits[val];
@ -428,7 +427,6 @@ void menu_draw_nibble(word_20 addr, word_4 val) {
#endif #endif
} }
struct ann_struct { struct ann_struct {
int bit; int bit;
int x; int x;
@ -445,8 +443,7 @@ struct ann_struct {
ann_battery_bits}, ann_battery_bits},
{ANN_BUSY, 196, 4, ann_busy_width, ann_busy_height, ann_busy_bits}, {ANN_BUSY, 196, 4, ann_busy_width, ann_busy_height, ann_busy_bits},
{ANN_IO, 241, 4, ann_io_width, ann_io_height, ann_io_bits}, {ANN_IO, 241, 4, ann_io_width, ann_io_height, ann_io_bits},
{ 0 } {0}};
};
void draw_annunc(void) { void draw_annunc(void) {
int val; int val;
@ -457,18 +454,14 @@ void draw_annunc(void) {
if (val == last_annunc_state) if (val == last_annunc_state)
return; return;
last_annunc_state = val; last_annunc_state = val;
for (i = 0; ann_tbl[i].bit; i++) for (i = 0; ann_tbl[i].bit; i++) {
{ if ((ann_tbl[i].bit & val) == ann_tbl[i].bit) {
if ((ann_tbl[i].bit & val) == ann_tbl[i].bit)
{
XCopyPlane(dpy, ann_tbl[i].pixmap, disp.win, disp.gc, 0, 0, XCopyPlane(dpy, ann_tbl[i].pixmap, disp.win, disp.gc, 0, 0,
ann_tbl[i].width, ann_tbl[i].height, ann_tbl[i].width, ann_tbl[i].height, ann_tbl[i].x,
ann_tbl[i].x, ann_tbl[i].y, 1); ann_tbl[i].y, 1);
} } else {
else XClearArea(dpy, disp.win, ann_tbl[i].x, ann_tbl[i].y, ann_tbl[i].width,
{ ann_tbl[i].height, False);
XClearArea(dpy, disp.win, ann_tbl[i].x, ann_tbl[i].y,
ann_tbl[i].width, ann_tbl[i].height, False);
} }
} }
refresh_icon(); refresh_icon();
@ -483,9 +476,8 @@ void init_annunc(void) {
int i; int i;
for (i = 0; ann_tbl[i].bit; i++) { for (i = 0; ann_tbl[i].bit; i++) {
ann_tbl[i].pixmap = XCreateBitmapFromData(dpy, disp.win, ann_tbl[i].pixmap =
(char *)ann_tbl[i].bits, XCreateBitmapFromData(dpy, disp.win, (char *)ann_tbl[i].bits,
ann_tbl[i].width, ann_tbl[i].width, ann_tbl[i].height);
ann_tbl[i].height);
} }
} }

25
src/main.c
View file

@ -57,19 +57,18 @@
* $Id: main.c,v 1.11 1995/01/11 18:20:01 ecd Exp ecd $ * $Id: main.c,v 1.11 1995/01/11 18:20:01 ecd Exp ecd $
*/ */
#include <errno.h>
#include <fcntl.h>
#include <signal.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <signal.h>
#include <unistd.h>
#include <string.h> #include <string.h>
#include <errno.h>
#include <sys/time.h> #include <sys/time.h>
#include <fcntl.h> #include <unistd.h>
#include "x48_x11.h"
#include "hp48.h"
#include "debugger.h" #include "debugger.h"
#include "hp48.h"
#include "x48_x11.h"
#include <langinfo.h> #include <langinfo.h>
#include <locale.h> #include <locale.h>
@ -104,20 +103,16 @@ void save_options(int argc, char **argv) {
saved_argc = argc; saved_argc = argc;
saved_argv = (char **)malloc((argc + 2) * sizeof(char *)); saved_argv = (char **)malloc((argc + 2) * sizeof(char *));
if (saved_argv == (char **)0) if (saved_argv == (char **)0) {
{
fprintf(stderr, "%s: malloc failed in save_options(), exit\n", progname); fprintf(stderr, "%s: malloc failed in save_options(), exit\n", progname);
exit(1); exit(1);
} }
saved_argv[argc] = (char *)0; saved_argv[argc] = (char *)0;
while (argc--) while (argc--) {
{
l = strlen(argv[argc]) + 1; l = strlen(argv[argc]) + 1;
saved_argv[argc] = (char *)malloc(l); saved_argv[argc] = (char *)malloc(l);
if (saved_argv[argc] == (char *)0) if (saved_argv[argc] == (char *)0) {
{ fprintf(stderr, "%s: malloc failed in save_options(), exit\n", progname);
fprintf(stderr, "%s: malloc failed in save_options(), exit\n",
progname);
exit(1); exit(1);
} }
memcpy(saved_argv[argc], argv[argc], l); memcpy(saved_argv[argc], argv[argc], l);

754
src/memory.c
View file

File diff suppressed because it is too large Load diff

18
src/mkcard.c
View file

@ -25,13 +25,12 @@
* $Id: mkcard.c,v 1.1 1995/01/11 18:11:25 ecd Exp ecd $ * $Id: mkcard.c,v 1.1 1995/01/11 18:11:25 ecd Exp ecd $
*/ */
#include "global.h" #include "global.h"
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <unistd.h>
#include <string.h> #include <string.h>
#include <unistd.h>
#ifdef SUNOS #ifdef SUNOS
#include <memory.h> #include <memory.h>
#endif #endif
@ -42,14 +41,12 @@ unsigned char *mem;
int write_mem_file(char *name, unsigned char *mem, int size) { int write_mem_file(char *name, unsigned char *mem, int size) {
FILE *fp; FILE *fp;
if (NULL == (fp = fopen(name, "w"))) if (NULL == (fp = fopen(name, "w"))) {
{
fprintf(stderr, "can\'t open %s\n", name); fprintf(stderr, "can\'t open %s\n", name);
return 0; return 0;
} }
if (fwrite(mem, 1, (size_t)size, fp) != size) if (fwrite(mem, 1, (size_t)size, fp) != size) {
{
fprintf(stderr, "can\'t write %s\n", name); fprintf(stderr, "can\'t write %s\n", name);
fclose(fp); fclose(fp);
return 0; return 0;
@ -65,8 +62,7 @@ int main(int argc, char **argv) {
char *asize; char *asize;
unsigned char *core; unsigned char *core;
if (argc < 2) if (argc < 2) {
{
fprintf(stderr, "usage: %s [32K | 128K | 1M | 2M | 4M] file-name\n", fprintf(stderr, "usage: %s [32K | 128K | 1M | 2M | 4M] file-name\n",
argv[0]); argv[0]);
exit(1); exit(1);
@ -88,8 +84,7 @@ int main(int argc, char **argv) {
size = 0x200000; size = 0x200000;
else if (!strcmp(asize, "4M")) else if (!strcmp(asize, "4M"))
size = 0x400000; size = 0x400000;
else else {
{
fprintf(stderr, fprintf(stderr,
"%s: size must be one of 32K, 128K, 256K, 512K, 1M, 2M, or 4M\n", "%s: size must be one of 32K, 128K, 256K, 512K, 1M, 2M, or 4M\n",
argv[0]); argv[0]);
@ -102,8 +97,7 @@ int main(int argc, char **argv) {
} }
memset(core, 0, size); memset(core, 0, size);
if (!write_mem_file(name, core, size)) if (!write_mem_file(name, core, size)) {
{
fprintf(stderr, "%s: can\'t write to %s\n", argv[0], name); fprintf(stderr, "%s: can\'t write to %s\n", argv[0], name);
exit(1); exit(1);
} }

2
src/mmu.h
View file

@ -27,7 +27,6 @@
#ifndef _MMU_H #ifndef _MMU_H
#define _MMU_H 1 #define _MMU_H 1
#define NR_MCTL 6 #define NR_MCTL 6
#define MCTL_MMIO_SX 0 #define MCTL_MMIO_SX 0
@ -44,7 +43,6 @@
#define MCTL_PORT2_GX 4 #define MCTL_PORT2_GX 4
#define MCTL_SysROM_GX 5 #define MCTL_SysROM_GX 5
#if 0 #if 0
extern void init_mmu __ProtoType__((void)); extern void init_mmu __ProtoType__((void));
extern void reset_mmu __ProtoType__((void)); extern void reset_mmu __ProtoType__((void));

9
src/options.c
View file

@ -44,8 +44,8 @@
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <unistd.h>
#include <string.h> #include <string.h>
#include <unistd.h>
#include "constants.h" #include "constants.h"
#include "resources.h" #include "resources.h"
@ -90,7 +90,8 @@ where options include:\n\
-xrm <resource> set Xresource <resource>\n\ -xrm <resource> set Xresource <resource>\n\
-/+throttle turn off/on speed emulation\n\ -/+throttle turn off/on speed emulation\n\
-/+netbook turn off/on netbook layout\n\ -/+netbook turn off/on netbook layout\n\
\n", VERSION_MAJOR, VERSION_MINOR, PATCHLEVEL, progname); \n",
VERSION_MAJOR, VERSION_MINOR, PATCHLEVEL, progname);
fflush(stdout); fflush(stdout);
exit(1); exit(1);
@ -100,8 +101,8 @@ void show_version(void) {
fprintf(stdout, "\n\ fprintf(stdout, "\n\
%s Version %d.%d.%d, x48 is Copyright (c) 1994-2005 by Eddie C. Dost <ecd@dressler.de>.\n\ %s Version %d.%d.%d, x48 is Copyright (c) 1994-2005 by Eddie C. Dost <ecd@dressler.de>.\n\
Compiled on %s by <%s> #%d\n\n", Compiled on %s by <%s> #%d\n\n",
progname, VERSION_MAJOR, VERSION_MINOR, PATCHLEVEL, progname, VERSION_MAJOR, VERSION_MINOR, PATCHLEVEL, COMPILE_TIME,
COMPILE_TIME, COMPILE_BY, COMPILE_VERSION); COMPILE_BY, COMPILE_VERSION);
} }
void show_copyright(void) { void show_copyright(void) {

36
src/register.c
View file

@ -42,28 +42,21 @@
* $Id: register.c,v 1.6 1995/01/11 18:20:01 ecd Exp ecd $ * $Id: register.c,v 1.6 1995/01/11 18:20:01 ecd Exp ecd $
*/ */
#include "global.h" #include "global.h"
#include <stdlib.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h>
#include "hp48.h" #include "hp48.h"
#include "hp48_emu.h" #include "hp48_emu.h"
extern long nibble_masks[16]; extern long nibble_masks[16];
static int start_fields[] = { static int start_fields[] = {-1, 0, 2, 0, 15, 3, 0, 0, -1, 0,
-1, 0, 2, 0, 15, 3, 0, 0, 2, 0, 15, 3, 0, 0, 0, 0, 0};
-1, 0, 2, 0, 15, 3, 0, 0,
0, 0, 0
};
static int end_fields[] = { static int end_fields[] = {-1, -1, 2, 2, 15, 14, 1, 15, -1, -1,
-1, -1, 2, 2, 15, 14, 1, 15, 2, 2, 15, 14, 1, 4, 3, 2, 0};
-1, -1, 2, 2, 15, 14, 1, 4,
3, 2, 0
};
static inline int get_start(int code) { static inline int get_start(int code) {
int s; int s;
@ -83,8 +76,8 @@ static inline int get_end(int code) {
return e; return e;
} }
void add_register(unsigned char *res, unsigned char *r1, void add_register(unsigned char *res, unsigned char *r1, unsigned char *r2,
unsigned char *r2, int code) { int code) {
int t, c, i, s, e; int t, c, i, s, e;
s = get_start(code); s = get_start(code);
@ -128,8 +121,8 @@ void add_p_plus_one(unsigned char *r) {
saturn.CARRY = 0; saturn.CARRY = 0;
} }
void sub_register(unsigned char *res, unsigned char *r1, void sub_register(unsigned char *res, unsigned char *r1, unsigned char *r2,
unsigned char *r2, int code) { int code) {
int t, c, i, s, e; int t, c, i, s, e;
s = get_start(code); s = get_start(code);
@ -288,8 +281,8 @@ void zero_register(unsigned char *r, int code) {
r[i] = 0; r[i] = 0;
} }
void or_register(unsigned char *res, unsigned char *r1, void or_register(unsigned char *res, unsigned char *r1, unsigned char *r2,
unsigned char *r2, int code) { int code) {
int i, s, e; int i, s, e;
s = get_start(code); s = get_start(code);
@ -299,8 +292,8 @@ void or_register(unsigned char *res, unsigned char *r1,
} }
} }
void and_register(unsigned char *res, unsigned char *r1, void and_register(unsigned char *res, unsigned char *r1, unsigned char *r2,
unsigned char *r2, int code) { int code) {
int i, s, e; int i, s, e;
s = get_start(code); s = get_start(code);
@ -522,7 +515,8 @@ int is_greater_register(unsigned char *r1, unsigned char *r2, int code) {
return z; return z;
} }
int is_greater_or_equal_register(unsigned char *r1, unsigned char *r2, int code) { int is_greater_or_equal_register(unsigned char *r1, unsigned char *r2,
int code) {
int z, i, s, e; int z, i, s, e;
s = get_start(code); s = get_start(code);

131
src/resources.c
View file

@ -50,14 +50,14 @@
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <stdio.h>
#include <X11/Xlib.h> #include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <X11/Xresource.h> #include <X11/Xresource.h>
#include <X11/Xutil.h>
#include <stdio.h>
#include "resources.h"
#include "disasm.h" #include "disasm.h"
#include "errors.h" #include "errors.h"
#include "resources.h"
XrmDatabase rdb = (XrmDatabase)0; XrmDatabase rdb = (XrmDatabase)0;
@ -92,16 +92,14 @@ void get_resources(void) {
useSerial = get_boolean_resource("useSerial", "UseSerial"); useSerial = get_boolean_resource("useSerial", "UseSerial");
serialLine = get_string_resource("serialLine", "SerialLine"); serialLine = get_string_resource("serialLine", "SerialLine");
initialize = get_boolean_resource("completeInitialize", initialize = get_boolean_resource("completeInitialize", "CompleteInitialize");
"CompleteInitialize"); resetOnStartup = get_boolean_resource("resetOnStartup", "ResetOnStartup");
resetOnStartup = get_boolean_resource("resetOnStartup",
"ResetOnStartup");
romFileName = get_string_resource("romFileName", "RomFileName"); romFileName = get_string_resource("romFileName", "RomFileName");
homeDirectory = get_string_resource("homeDirectory", "HomeDirectory"); homeDirectory = get_string_resource("homeDirectory", "HomeDirectory");
useDebugger = get_boolean_resource("useDebugger", "UseDebugger"); useDebugger = get_boolean_resource("useDebugger", "UseDebugger");
disassembler_mode = get_mnemonic_resource("disassemblerMnemonics", disassembler_mode =
"DisassemblerMnemonics"); get_mnemonic_resource("disassemblerMnemonics", "DisassemblerMnemonics");
netbook = get_boolean_resource("netbook", "Netbook"); netbook = get_boolean_resource("netbook", "Netbook");
@ -119,8 +117,7 @@ char * get_string_resource_from_db (XrmDatabase db, char *name, char *class) {
strcpy(full_class, res_class); strcpy(full_class, res_class);
strcat(full_class, "."); strcat(full_class, ".");
strcat(full_class, class); strcat(full_class, class);
if (XrmGetResource (db, full_name, full_class, &type, &value)) if (XrmGetResource(db, full_name, full_class, &type, &value)) {
{
char *str = (char *)malloc(value.size + 1); char *str = (char *)malloc(value.size + 1);
strncpy(str, (char *)value.addr, value.size); strncpy(str, (char *)value.addr, value.size);
str[value.size] = 0; str[value.size] = 0;
@ -138,7 +135,8 @@ int get_mnemonic_resource (char *name, char *class) {
char *s = get_string_resource(name, class); char *s = get_string_resource(name, class);
char *os = s; char *os = s;
if (! s) return CLASS_MNEMONICS; if (!s)
return CLASS_MNEMONICS;
for (tmp = buf; *s; s++) for (tmp = buf; *s; s++)
*tmp++ = isupper(*s) ? _tolower(*s) : *s; *tmp++ = isupper(*s) ? _tolower(*s) : *s;
*tmp = 0; *tmp = 0;
@ -157,7 +155,8 @@ int get_boolean_resource (char *name, char *class) {
char *tmp, buf[100]; char *tmp, buf[100];
char *s = get_string_resource(name, class); char *s = get_string_resource(name, class);
char *os = s; char *os = s;
if (! s) return 0; if (!s)
return 0;
for (tmp = buf; *s; s++) for (tmp = buf; *s; s++)
*tmp++ = isupper(*s) ? _tolower(*s) : *s; *tmp++ = isupper(*s) ? _tolower(*s) : *s;
*tmp = 0; *tmp = 0;
@ -167,22 +166,20 @@ int get_boolean_resource (char *name, char *class) {
return 1; return 1;
if (!strcmp(buf, "off") || !strcmp(buf, "false") || !strcmp(buf, "no")) if (!strcmp(buf, "off") || !strcmp(buf, "false") || !strcmp(buf, "no"))
return 0; return 0;
fprintf (stderr, "%s: %s must be boolean, not %s.\n", fprintf(stderr, "%s: %s must be boolean, not %s.\n", progname, name, buf);
progname, name, buf);
return 0; return 0;
} }
int get_integer_resource(char *name, char *class) { int get_integer_resource(char *name, char *class) {
int val; int val;
char c, *s = get_string_resource(name, class); char c, *s = get_string_resource(name, class);
if (!s) return 0; if (!s)
if (1 == sscanf (s, " %d %c", &val, &c)) return 0;
{ if (1 == sscanf(s, " %d %c", &val, &c)) {
free(s); free(s);
return val; return val;
} }
fprintf (stderr, "%s: %s must be an integer, not %s.\n", fprintf(stderr, "%s: %s must be an integer, not %s.\n", progname, name, s);
progname, name, s);
free(s); free(s);
return 0; return 0;
} }
@ -191,37 +188,36 @@ unsigned int get_pixel_resource (char *name, char *class, Display *dpy,
Colormap cmap) { Colormap cmap) {
XColor color; XColor color;
char *s = get_string_resource(name, class); char *s = get_string_resource(name, class);
if (!s) goto DEFAULT; if (!s)
goto DEFAULT;
if (! XParseColor (dpy, cmap, s, &color)) if (!XParseColor(dpy, cmap, s, &color)) {
{
fprintf(stderr, "%s: can't parse color %s\n", progname, s); fprintf(stderr, "%s: can't parse color %s\n", progname, s);
goto DEFAULT; goto DEFAULT;
} }
if (! XAllocColor (dpy, cmap, &color)) if (!XAllocColor(dpy, cmap, &color)) {
{
fprintf(stderr, "%s: couldn't allocate color %s\n", progname, s); fprintf(stderr, "%s: couldn't allocate color %s\n", progname, s);
goto DEFAULT; goto DEFAULT;
} }
free(s); free(s);
return color.pixel; return color.pixel;
DEFAULT: DEFAULT:
if (s) free (s); if (s)
return (strcmp (class, "Background") free(s);
? WhitePixel (dpy, DefaultScreen (dpy)) return (strcmp(class, "Background") ? WhitePixel(dpy, DefaultScreen(dpy))
: BlackPixel(dpy, DefaultScreen(dpy))); : BlackPixel(dpy, DefaultScreen(dpy)));
} }
static Visual * pick_visual_of_class (Display *dpy, int visual_class, unsigned int *depth) { static Visual *pick_visual_of_class(Display *dpy, int visual_class,
unsigned int *depth) {
XVisualInfo vi_in, *vi_out; XVisualInfo vi_in, *vi_out;
int out_count; int out_count;
vi_in.class = visual_class; vi_in.class = visual_class;
vi_in.screen = DefaultScreen(dpy); vi_in.screen = DefaultScreen(dpy);
vi_out = XGetVisualInfo(dpy, VisualClassMask|VisualScreenMask, vi_out = XGetVisualInfo(dpy, VisualClassMask | VisualScreenMask, &vi_in,
&vi_in, &out_count); &out_count);
if (vi_out) if (vi_out) { /* choose the 'best' one, if multiple */
{ /* choose the 'best' one, if multiple */
int i, best; int i, best;
Visual *visual; Visual *visual;
for (i = 0, best = 0; i < out_count; i++) for (i = 0, best = 0; i < out_count; i++)
@ -231,9 +227,7 @@ static Visual * pick_visual_of_class (Display *dpy, int visual_class, unsigned i
*depth = vi_out[best].depth; *depth = vi_out[best].depth;
XFree((char *)vi_out); XFree((char *)vi_out);
return visual; return visual;
} } else {
else
{
*depth = DefaultDepth(dpy, DefaultScreen(dpy)); *depth = DefaultDepth(dpy, DefaultScreen(dpy));
return DefaultVisual(dpy, DefaultScreen(dpy)); return DefaultVisual(dpy, DefaultScreen(dpy));
} }
@ -245,10 +239,9 @@ static Visual * id_to_visual (Display *dpy, int id, unsigned int *depth) {
vi_in.screen = DefaultScreen(dpy); vi_in.screen = DefaultScreen(dpy);
vi_in.visualid = id; vi_in.visualid = id;
vi_out = XGetVisualInfo(dpy, VisualScreenMask|VisualIDMask, vi_out =
&vi_in, &out_count); XGetVisualInfo(dpy, VisualScreenMask | VisualIDMask, &vi_in, &out_count);
if (vi_out) if (vi_out) {
{
Visual *v = vi_out[0].visual; Visual *v = vi_out[0].visual;
*depth = vi_out[0].depth; *depth = vi_out[0].depth;
XFree((char *)vi_out); XFree((char *)vi_out);
@ -257,7 +250,8 @@ static Visual * id_to_visual (Display *dpy, int id, unsigned int *depth) {
return 0; return 0;
} }
Visual * get_visual_resource(Display *dpy, char *name, char *class, unsigned int *depth) { Visual *get_visual_resource(Display *dpy, char *name, char *class,
unsigned int *depth) {
char c; char c;
char *tmp, *s; char *tmp, *s;
int vclass; int vclass;
@ -266,38 +260,45 @@ Visual * get_visual_resource(Display *dpy, char *name, char *class, unsigned int
s = get_string_resource(name, class); s = get_string_resource(name, class);
if (s) if (s)
for (tmp = s; *tmp; tmp++) for (tmp = s; *tmp; tmp++)
if (isupper(*tmp)) *tmp = _tolower(*tmp); if (isupper(*tmp))
*tmp = _tolower(*tmp);
if (!s || !strcmp(s, "default")) vclass = -1; if (!s || !strcmp(s, "default"))
else if (!strcmp (s, "staticgray")) vclass = StaticGray; vclass = -1;
else if (!strcmp (s, "staticcolor")) vclass = StaticColor; else if (!strcmp(s, "staticgray"))
else if (!strcmp (s, "truecolor")) vclass = TrueColor; vclass = StaticGray;
else if (!strcmp (s, "grayscale")) vclass = GrayScale; else if (!strcmp(s, "staticcolor"))
else if (!strcmp (s, "pseudocolor")) vclass = PseudoColor; vclass = StaticColor;
else if (!strcmp (s, "directcolor")) vclass = DirectColor; else if (!strcmp(s, "truecolor"))
else if (1 == sscanf (s, " %d %c", &id, &c)) vclass = -2; vclass = TrueColor;
else if (1 == sscanf (s, " 0x%x %c", &id, &c)) vclass = -2; else if (!strcmp(s, "grayscale"))
else vclass = GrayScale;
{ else if (!strcmp(s, "pseudocolor"))
vclass = PseudoColor;
else if (!strcmp(s, "directcolor"))
vclass = DirectColor;
else if (1 == sscanf(s, " %d %c", &id, &c))
vclass = -2;
else if (1 == sscanf(s, " 0x%x %c", &id, &c))
vclass = -2;
else {
fprintf(stderr, "%s: unrecognized visual \"%s\".\n", progname, s); fprintf(stderr, "%s: unrecognized visual \"%s\".\n", progname, s);
vclass = -1; vclass = -1;
} }
if (s) free (s); if (s)
free(s);
if (vclass == -1) if (vclass == -1) {
{
*depth = DefaultDepth(dpy, DefaultScreen(dpy)); *depth = DefaultDepth(dpy, DefaultScreen(dpy));
return DefaultVisual(dpy, DefaultScreen(dpy)); return DefaultVisual(dpy, DefaultScreen(dpy));
} } else if (vclass == -2) {
else if (vclass == -2)
{
Visual *v = id_to_visual(dpy, id, depth); Visual *v = id_to_visual(dpy, id, depth);
if (v) return v; if (v)
return v;
fprintf(stderr, "%s: no visual with id 0x%x.\n", progname, id); fprintf(stderr, "%s: no visual with id 0x%x.\n", progname, id);
*depth = DefaultDepth(dpy, DefaultScreen(dpy)); *depth = DefaultDepth(dpy, DefaultScreen(dpy));
return DefaultVisual(dpy, DefaultScreen(dpy)); return DefaultVisual(dpy, DefaultScreen(dpy));
} } else
else
return pick_visual_of_class(dpy, vclass, depth); return pick_visual_of_class(dpy, vclass, depth);
} }
@ -309,13 +310,11 @@ XFontStruct * get_font_resource(Display *dpy, char *name, char *class) {
if (s) if (s)
f = XLoadQueryFont(dpy, s); f = XLoadQueryFont(dpy, s);
else else {
{
sprintf(errbuf, "can\'t get resource \'%s\'", name); sprintf(errbuf, "can\'t get resource \'%s\'", name);
fatal_exit(); fatal_exit();
} }
if (f == (XFontStruct *)0) if (f == (XFontStruct *)0) {
{
sprintf(errbuf, "can\'t load font \'%s\'", s); sprintf(errbuf, "can\'t load font \'%s\'", s);
sprintf(fixbuf, "Please change resource \'%s\'", name); sprintf(fixbuf, "Please change resource \'%s\'", name);
fatal_exit(); fatal_exit();

12
src/resources.h
View file

@ -69,14 +69,10 @@ extern void get_resources __ProtoType__ ((void));
extern char *get_string_resource_from_db __ProtoType__((XrmDatabase db, extern char *get_string_resource_from_db __ProtoType__((XrmDatabase db,
char *name, char *name,
char *class)); char *class));
extern char * get_string_resource __ProtoType__ ((char *name, extern char *get_string_resource __ProtoType__((char *name, char *class));
char *class)); extern int get_boolean_resource __ProtoType__((char *name, char *class));
extern int get_boolean_resource __ProtoType__ ((char *name, extern int get_mnemonic_resource __ProtoType__((char *name, char *class));
char *class)); extern Visual *get_visual_resource __ProtoType__((Display * dpy, char *name,
extern int get_mnemonic_resource __ProtoType__ ((char *name,
char *class));
extern Visual * get_visual_resource __ProtoType__ ((Display *dpy,
char *name,
char *class, char *class,
unsigned int *depth)); unsigned int *depth));
extern XFontStruct *get_font_resource __ProtoType__((Display * dpy, extern XFontStruct *get_font_resource __ProtoType__((Display * dpy,

120
src/romio.c
View file

@ -27,8 +27,8 @@
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <unistd.h>
#include <sys/stat.h> #include <sys/stat.h>
#include <unistd.h>
#include "global.h" #include "global.h"
#include "resources.h" #include "resources.h"
@ -47,55 +47,42 @@ int read_rom_file(char *name, unsigned char **mem, int *size) {
*mem = NULL; *mem = NULL;
*size = 0; *size = 0;
if (NULL == (fp = fopen(name, "r"))) if (NULL == (fp = fopen(name, "r"))) {
{
fprintf(stderr, "can\'t open %s\n", name); fprintf(stderr, "can\'t open %s\n", name);
return 0; return 0;
} }
if (stat(name, &st) < 0) if (stat(name, &st) < 0) {
{
fprintf(stderr, "can\'t stat %s\n", name); fprintf(stderr, "can\'t stat %s\n", name);
fclose(fp); fclose(fp);
return 0; return 0;
} }
if (fread(four, 1, 4, fp) != 4) if (fread(four, 1, 4, fp) != 4) {
{
fprintf(stderr, "can\'t read first 4 bytes of %s\n", name); fprintf(stderr, "can\'t read first 4 bytes of %s\n", name);
fclose(fp); fclose(fp);
return 0; return 0;
} }
if (four[0] == 0x02 && four[1] == 0x03 && if (four[0] == 0x02 && four[1] == 0x03 && four[2] == 0x06 &&
four[2] == 0x06 && four[3] == 0x09) four[3] == 0x09) {
{
*size = st.st_size; *size = st.st_size;
} } else if (four[0] == 0x32 && four[1] == 0x96 && four[2] == 0x1b &&
else if (four[0] == 0x32 && four[1] == 0x96 && four[3] == 0x80) {
four[2] == 0x1b && four[3] == 0x80)
{
*size = 2 * st.st_size; *size = 2 * st.st_size;
} } else if (four[1] = 0x49) {
else if (four[1] = 0x49)
{
fprintf(stderr, "%s is an HP49 ROM\n", name); fprintf(stderr, "%s is an HP49 ROM\n", name);
*size = 2 * st.st_size; *size = 2 * st.st_size;
} } else if (four[0]) {
else if (four[0])
{
printf("%d\n", st.st_size); printf("%d\n", st.st_size);
*size = st.st_size; *size = st.st_size;
} } else {
else
{
fprintf(stderr, "%s is not a HP48 ROM\n", name); fprintf(stderr, "%s is not a HP48 ROM\n", name);
fclose(fp); fclose(fp);
return 0; return 0;
} }
if (fseek(fp, 0, 0) < 0) if (fseek(fp, 0, 0) < 0) {
{
fprintf(stderr, "can\'t fseek to position 0 in %s\n", name); fprintf(stderr, "can\'t fseek to position 0 in %s\n", name);
*size = 0; *size = 0;
fclose(fp); fclose(fp);
@ -104,13 +91,11 @@ int read_rom_file(char *name, unsigned char **mem, int *size) {
*mem = (unsigned char *)malloc(*size); *mem = (unsigned char *)malloc(*size);
if (st.st_size == *size) if (st.st_size == *size) {
{
/* /*
* size is same as memory size, old version file * size is same as memory size, old version file
*/ */
if (fread(*mem, 1, (size_t)*size, fp) != *size) if (fread(*mem, 1, (size_t)*size, fp) != *size) {
{
fprintf(stderr, "can\'t read %s\n", name); fprintf(stderr, "can\'t read %s\n", name);
free(*mem); free(*mem);
*mem = NULL; *mem = NULL;
@ -118,17 +103,14 @@ int read_rom_file(char *name, unsigned char **mem, int *size) {
fclose(fp); fclose(fp);
return 0; return 0;
} }
} } else {
else
{
/* /*
* size is different, check size and decompress memory * size is different, check size and decompress memory
*/ */
if (st.st_size != *size / 2) if (st.st_size != *size / 2) {
{ fprintf(stderr, "strange size %s, expected %d, found %ld\n", name,
fprintf(stderr, "strange size %s, expected %d, found %ld\n", *size / 2, st.st_size);
name, *size / 2, st.st_size);
free(*mem); free(*mem);
*mem = NULL; *mem = NULL;
*size = 0; *size = 0;
@ -136,12 +118,9 @@ int read_rom_file(char *name, unsigned char **mem, int *size) {
return 0; return 0;
} }
if (NULL == (tmp_mem = (unsigned char *)malloc((size_t)st.st_size))) if (NULL == (tmp_mem = (unsigned char *)malloc((size_t)st.st_size))) {
{ for (i = 0, j = 0; i < *size / 2; i++) {
for (i = 0, j = 0; i < *size / 2; i++) if (1 != fread(&byte, 1, 1, fp)) {
{
if (1 != fread(&byte, 1, 1, fp))
{
fprintf(stderr, "can\'t read %s\n", name); fprintf(stderr, "can\'t read %s\n", name);
free(*mem); free(*mem);
*mem = NULL; *mem = NULL;
@ -152,11 +131,8 @@ int read_rom_file(char *name, unsigned char **mem, int *size) {
(*mem)[j++] = byte & 0xf; (*mem)[j++] = byte & 0xf;
(*mem)[j++] = (byte >> 4) & 0xf; (*mem)[j++] = (byte >> 4) & 0xf;
} }
} } else {
else if (fread(tmp_mem, 1, (size_t)*size / 2, fp) != *size / 2) {
{
if (fread(tmp_mem, 1, (size_t)*size / 2, fp) != *size / 2)
{
fprintf(stderr, "can\'t read %s\n", name); fprintf(stderr, "can\'t read %s\n", name);
free(*mem); free(*mem);
*mem = NULL; *mem = NULL;
@ -166,8 +142,7 @@ int read_rom_file(char *name, unsigned char **mem, int *size) {
return 0; return 0;
} }
for (i = 0, j = 0; i < *size / 2; i++) for (i = 0, j = 0; i < *size / 2; i++) {
{
(*mem)[j++] = tmp_mem[i] & 0xf; (*mem)[j++] = tmp_mem[i] & 0xf;
(*mem)[j++] = (tmp_mem[i] >> 4) & 0xf; (*mem)[j++] = (tmp_mem[i] >> 4) & 0xf;
} }
@ -178,46 +153,31 @@ int read_rom_file(char *name, unsigned char **mem, int *size) {
fclose(fp); fclose(fp);
if ((*mem)[0x29] == 0x00) if ((*mem)[0x29] == 0x00) {
{ if (*size == ROM_SIZE_GX) {
if (*size == ROM_SIZE_GX)
{
opt_gx = 1; opt_gx = 1;
} } else if (*size == 4 * ROM_SIZE_GX) {
else fprintf(stderr, "%s seems to be HP49 ROM, but size is 0x%x\n", name,
if (*size == 4 * ROM_SIZE_GX) *size);
{
fprintf(stderr, "%s seems to be HP49 ROM, but size is 0x%x\n",
name, *size);
opt_gx = 2; opt_gx = 2;
} } else if (*size == 8 * ROM_SIZE_GX) {
else fprintf(stderr, "%s seems to be HP49 ROM, but size is 0x%x\n", name,
if (*size == 8 * ROM_SIZE_GX) *size);
{
fprintf(stderr, "%s seems to be HP49 ROM, but size is 0x%x\n",
name, *size);
opt_gx = 2; opt_gx = 2;
} } else {
else fprintf(stderr, "%s seems to be G/GX ROM, but size is 0x%x\n", name,
{ *size);
fprintf(stderr, "%s seems to be G/GX ROM, but size is 0x%x\n",
name, *size);
free(*mem); free(*mem);
*mem = NULL; *mem = NULL;
*size = 0; *size = 0;
return 0; return 0;
} }
} } else {
else if (*size == ROM_SIZE_SX) {
{
if (*size == ROM_SIZE_SX)
{
opt_gx = 0; opt_gx = 0;
} } else {
else fprintf(stderr, "%s seems to be S/SX ROM, but size is 0x%x\n", name,
{ *size);
fprintf(stderr, "%s seems to be S/SX ROM, but size is 0x%x\n",
name, *size);
free(*mem); free(*mem);
*mem = NULL; *mem = NULL;
*size = 0; *size = 0;

347
src/rpl.c
View file

@ -38,16 +38,16 @@
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <unistd.h>
#include <string.h> #include <string.h>
#include <unistd.h>
#include "append.h"
#include "debugger.h"
#include "disasm.h"
#include "hp48.h" #include "hp48.h"
#include "hp48_emu.h" #include "hp48_emu.h"
#include "rpl.h"
#include "debugger.h"
#include "append.h"
#include "disasm.h"
#include "romio.h" #include "romio.h"
#include "rpl.h"
#define DEFINE_TRANS_TABLE 1 #define DEFINE_TRANS_TABLE 1
#include "hp48char.h" #include "hp48char.h"
#undef DEFINE_TRANS_TABLE #undef DEFINE_TRANS_TABLE
@ -57,8 +57,7 @@ struct objfunc {
short length; short length;
word_20 prolog; word_20 prolog;
char *(*func)__ProtoType__((word_20 * addr, char *string)); char *(*func)__ProtoType__((word_20 * addr, char *string));
} objects[] = { } objects[] = {{"System Binary", 0, DOBINT, dec_bin_int},
{ "System Binary", 0, DOBINT, dec_bin_int },
{"Real", 0, DOREAL, dec_real}, {"Real", 0, DOREAL, dec_real},
{"Long Real", 0, DOEREL, dec_long_real}, {"Long Real", 0, DOEREL, dec_long_real},
{"Complex", 0, DOCMP, dec_complex}, {"Complex", 0, DOCMP, dec_complex},
@ -91,8 +90,7 @@ struct objfunc {
{"^", 0, UM_POW, dec_unit_op}, {"^", 0, UM_POW, dec_unit_op},
{" ", 0, UM_PRE, dec_unit_op}, {" ", 0, UM_PRE, dec_unit_op},
{"_", 0, UM_END, dec_unit_op}, {"_", 0, UM_END, dec_unit_op},
{ 0, 0, 0 } {0, 0, 0}};
};
char *skip_ob(word_20 *addr, char *string) { char *skip_ob(word_20 *addr, char *string) {
word_20 size, type; word_20 size, type;
@ -100,14 +98,12 @@ char * skip_ob(word_20 *addr, char *string) {
struct objfunc *op; struct objfunc *op;
type = read_nibbles(*addr - 5, 5); type = read_nibbles(*addr - 5, 5);
for (op = objects; op->prolog != 0; op++) for (op = objects; op->prolog != 0; op++) {
{
if (op->prolog == type) if (op->prolog == type)
break; break;
} }
if (op->prolog) if (op->prolog) {
{
sprintf(p, "%s", op->name); sprintf(p, "%s", op->name);
p += strlen(p); p += strlen(p);
} }
@ -122,8 +118,7 @@ char * skip_ob(word_20 *addr, char *string) {
long hxs2real(long hxs) { long hxs2real(long hxs) {
int n = 0, c = 1; int n = 0, c = 1;
while (hxs) while (hxs) {
{
n += (hxs & 0xf) * c; n += (hxs & 0xf) * c;
c *= 10; c *= 10;
hxs >>= 4; hxs >>= 4;
@ -168,14 +163,13 @@ char * real_number(word_20 *addr, char *string, int ml, int xl) {
* Figure out the exponent * Figure out the exponent
*/ */
xs = 5; xs = 5;
while (--xl) xs *= 10; while (--xl)
xs *= 10;
re = hxs2real(r.x); re = hxs2real(r.x);
if (re >= xs) if (re >= xs)
re = re - 2 * xs; re = re - 2 * xs;
if ((re >= 0) && (re < ml + 1)) {
if ((re >= 0) && (re < ml + 1))
{
if (r.s >= 5) if (r.s >= 5)
*p++ = '-'; *p++ = '-';
@ -188,22 +182,23 @@ char * real_number(word_20 *addr, char *string, int ml, int xl) {
for (; i < ml + 1; i++) for (; i < ml + 1; i++)
*p++ = m[i]; *p++ = m[i];
p--; p--;
while(*p == '0') p--; while (*p == '0')
if (*p == '.') p--; p--;
if (*p == '.')
p--;
*++p = '\0'; *++p = '\0';
return p; return p;
} }
if ((re < 0) && (re >= -ml - 1)) if ((re < 0) && (re >= -ml - 1)) {
{
sprintf(fmt, "%%.1X%%.8lX%%.%dlX", ml - 8); sprintf(fmt, "%%.1X%%.8lX%%.%dlX", ml - 8);
sprintf(m, fmt, r.m, r.mh, r.ml); sprintf(m, fmt, r.m, r.mh, r.ml);
for (i = ml; m[i] == '0'; i--) ; for (i = ml; m[i] == '0'; i--)
;
if (-re <= ml - i + 1) if (-re <= ml - i + 1) {
{
if (r.s >= 5) if (r.s >= 5)
*p++ = '-'; *p++ = '-';
@ -215,7 +210,8 @@ char * real_number(word_20 *addr, char *string, int ml, int xl) {
for (i = 0; i < ml + 1; i++) for (i = 0; i < ml + 1; i++)
*p++ = m[i]; *p++ = m[i];
p--; p--;
while(*p == '0') p--; while (*p == '0')
p--;
*++p = '\0'; *++p = '\0';
return p; return p;
@ -227,11 +223,11 @@ char * real_number(word_20 *addr, char *string, int ml, int xl) {
p += strlen(p) - 1; p += strlen(p) - 1;
while(*p == '0') p--; while (*p == '0')
p--;
*++p = '\0'; *++p = '\0';
if (re) if (re) {
{
sprintf(p, "E%ld", re); sprintf(p, "E%ld", re);
p += strlen(p); p += strlen(p);
*p = '\0'; *p = '\0';
@ -288,21 +284,17 @@ char * dec_string(word_20 *addr, char *string) {
n = 1000; n = 1000;
*p++ = '\"'; *p++ = '\"';
for (i = 0; i < n; i++) for (i = 0; i < n; i++) {
{
c = read_nibbles(*addr, 2); c = read_nibbles(*addr, 2);
*addr += 2; *addr += 2;
if (hp48_trans_tbl[c].trans) if (hp48_trans_tbl[c].trans) {
{
sprintf(p, hp48_trans_tbl[c].trans); sprintf(p, hp48_trans_tbl[c].trans);
p += strlen(p); p += strlen(p);
} } else
else
*p++ = c; *p++ = c;
} }
if (n != len) if (n != len) {
{
*p++ = '.'; *p++ = '.';
*p++ = '.'; *p++ = '.';
*p++ = '.'; *p++ = '.';
@ -322,13 +314,11 @@ char * dec_hex_string(word_20 *addr, char *string) {
*addr += 5; *addr += 5;
len -= 5; len -= 5;
if (len <= 16) if (len <= 16) {
{
*p++ = '#'; *p++ = '#';
*p++ = ' '; *p++ = ' ';
lead = 1; lead = 1;
for (i = len - 1; i >= 0; i--) for (i = len - 1; i >= 0; i--) {
{
*p = hex[read_nibble(*addr + i)]; *p = hex[read_nibble(*addr + i)];
if (lead) if (lead)
if ((i != 0) && (*p == '0')) if ((i != 0) && (*p == '0'))
@ -339,9 +329,7 @@ char * dec_hex_string(word_20 *addr, char *string) {
} }
*p++ = 'h'; *p++ = 'h';
} } else {
else
{
*p++ = 'C'; *p++ = 'C';
*p++ = '#'; *p++ = '#';
*p++ = ' '; *p++ = ' ';
@ -358,8 +346,7 @@ char * dec_hex_string(word_20 *addr, char *string) {
for (i = 0; i < n; i++) for (i = 0; i < n; i++)
*p++ = hex[read_nibble(*addr + i)]; *p++ = hex[read_nibble(*addr + i)];
if (n != len) if (n != len) {
{
*p++ = '.'; *p++ = '.';
*p++ = '.'; *p++ = '.';
*p++ = '.'; *p++ = '.';
@ -379,12 +366,10 @@ char * dec_list(word_20 *addr, char *string) {
*p++ = '{'; *p++ = '{';
*p++ = ' '; *p++ = ' ';
semi = read_nibbles(*addr, 5); semi = read_nibbles(*addr, 5);
while (semi != SEMI) while (semi != SEMI) {
{
p = dec_rpl_obj(addr, p); p = dec_rpl_obj(addr, p);
semi = read_nibbles(*addr, 5); semi = read_nibbles(*addr, 5);
if (semi != SEMI) if (semi != SEMI) {
{
*p++ = ' '; *p++ = ' ';
*p = '\0'; *p = '\0';
} }
@ -403,12 +388,10 @@ char * dec_symb(word_20 *addr, char *string) {
semi = read_nibbles(*addr, 5); semi = read_nibbles(*addr, 5);
*p++ = '\''; *p++ = '\'';
while (semi != SEMI) while (semi != SEMI) {
{
p = dec_rpl_obj(addr, p); p = dec_rpl_obj(addr, p);
semi = read_nibbles(*addr, 5); semi = read_nibbles(*addr, 5);
if (semi != SEMI) if (semi != SEMI) {
{
*p++ = ' '; *p++ = ' ';
*p = '\0'; *p = '\0';
} }
@ -425,12 +408,10 @@ char * dec_unit(word_20 *addr, char *string) {
char *p = string; char *p = string;
semi = read_nibbles(*addr, 5); semi = read_nibbles(*addr, 5);
while (semi != SEMI) while (semi != SEMI) {
{
p = dec_rpl_obj(addr, p); p = dec_rpl_obj(addr, p);
semi = read_nibbles(*addr, 5); semi = read_nibbles(*addr, 5);
if (semi != SEMI) if (semi != SEMI) {
{
*p++ = ' '; *p++ = ' ';
*p = '\0'; *p = '\0';
} }
@ -444,8 +425,7 @@ char * dec_unit_op(word_20 *addr, char *string) {
char *p = string; char *p = string;
op = read_nibbles(*addr - 5, 5); op = read_nibbles(*addr - 5, 5);
switch (op) switch (op) {
{
case UM_MUL: case UM_MUL:
*p++ = '*'; *p++ = '*';
break; break;
@ -485,15 +465,12 @@ char * dec_library(word_20 *addr, char *string) {
sprintf(p, "Library %d: ", libnum); sprintf(p, "Library %d: ", libnum);
p += strlen(p); p += strlen(p);
for (i = 0; i < libidsize; i++) for (i = 0; i < libidsize; i++) {
{
c = read_nibbles(*addr + 2 * i + 7, 2); c = read_nibbles(*addr + 2 * i + 7, 2);
if (hp48_trans_tbl[c].trans) if (hp48_trans_tbl[c].trans) {
{
sprintf(p, hp48_trans_tbl[c].trans); sprintf(p, hp48_trans_tbl[c].trans);
p += strlen(p); p += strlen(p);
} } else
else
*p++ = c; *p++ = c;
} }
@ -524,8 +501,7 @@ char * dec_acptr(word_20 *addr, char *string) {
int i; int i;
static char hex[] = "0123456789ABCDEF"; static char hex[] = "0123456789ABCDEF";
if (opt_gx) if (opt_gx) {
{
size = 10; size = 10;
sprintf(p, "ACPTR "); sprintf(p, "ACPTR ");
p += strlen(p); p += strlen(p);
@ -534,9 +510,7 @@ char * dec_acptr(word_20 *addr, char *string) {
*p++ = ' '; *p++ = ' ';
for (i = 5; i < 10; i++) for (i = 5; i < 10; i++)
*p++ = hex[read_nibble(*addr + i)]; *p++ = hex[read_nibble(*addr + i)];
} } else {
else
{
size = read_nibbles(*addr, 5); size = read_nibbles(*addr, 5);
sprintf(p, "Ext 1"); sprintf(p, "Ext 1");
p += strlen(p); p += strlen(p);
@ -553,12 +527,10 @@ char * dec_prog(word_20 *addr, char *string) {
char *p = string; char *p = string;
semi = read_nibbles(*addr, 5); semi = read_nibbles(*addr, 5);
while (semi != SEMI) while (semi != SEMI) {
{
p = dec_rpl_obj(addr, p); p = dec_rpl_obj(addr, p);
semi = read_nibbles(*addr, 5); semi = read_nibbles(*addr, 5);
if (semi != SEMI) if (semi != SEMI) {
{
*p++ = ' '; *p++ = ' ';
*p = '\0'; *p = '\0';
} }
@ -576,8 +548,7 @@ char * dec_code(word_20 *addr, char *string) {
p += strlen(p); p += strlen(p);
n = 0; n = 0;
while (n < len) while (n < len) {
{
/* /*
*addr = disassemble(*addr, p); *addr = disassemble(*addr, p);
*/ */
@ -600,21 +571,17 @@ char * dec_local_ident(word_20 *addr, char *string) {
if (len > 1000) if (len > 1000)
n = 1000; n = 1000;
for (i = 0; i < n; i++) for (i = 0; i < n; i++) {
{
c = read_nibbles(*addr, 2); c = read_nibbles(*addr, 2);
*addr += 2; *addr += 2;
if (hp48_trans_tbl[c].trans) if (hp48_trans_tbl[c].trans) {
{
sprintf(p, hp48_trans_tbl[c].trans); sprintf(p, hp48_trans_tbl[c].trans);
p += strlen(p); p += strlen(p);
} } else
else
*p++ = c; *p++ = c;
} }
if (n != len) if (n != len) {
{
*p++ = '.'; *p++ = '.';
*p++ = '.'; *p++ = '.';
*p++ = '.'; *p++ = '.';
@ -636,21 +603,17 @@ char * dec_global_ident(word_20 *addr, char *string) {
if (len > 1000) if (len > 1000)
n = 1000; n = 1000;
for (i = 0; i < n; i++) for (i = 0; i < n; i++) {
{
c = read_nibbles(*addr, 2); c = read_nibbles(*addr, 2);
*addr += 2; *addr += 2;
if (hp48_trans_tbl[c].trans) if (hp48_trans_tbl[c].trans) {
{
sprintf(p, hp48_trans_tbl[c].trans); sprintf(p, hp48_trans_tbl[c].trans);
p += strlen(p); p += strlen(p);
} } else
else
*p++ = c; *p++ = c;
} }
if (n != len) if (n != len) {
{
*p++ = '.'; *p++ = '.';
*p++ = '.'; *p++ = '.';
*p++ = '.'; *p++ = '.';
@ -676,14 +639,11 @@ char * xlib_name(int lib, int command, char *string) {
*/ */
ram_base = saturn.mem_cntl[1].config[0]; ram_base = saturn.mem_cntl[1].config[0];
ram_mask = saturn.mem_cntl[1].config[1]; ram_mask = saturn.mem_cntl[1].config[1];
if (opt_gx) if (opt_gx) {
{
saturn.mem_cntl[1].config[0] = 0x80000; saturn.mem_cntl[1].config[0] = 0x80000;
saturn.mem_cntl[1].config[1] = 0xc0000; saturn.mem_cntl[1].config[1] = 0xc0000;
romptab = ROMPTAB_GX; romptab = ROMPTAB_GX;
} } else {
else
{
saturn.mem_cntl[1].config[0] = 0x70000; saturn.mem_cntl[1].config[0] = 0x70000;
saturn.mem_cntl[1].config[1] = 0xf0000; saturn.mem_cntl[1].config[1] = 0xf0000;
romptab = ROMPTAB_SX; romptab = ROMPTAB_SX;
@ -695,13 +655,11 @@ char * xlib_name(int lib, int command, char *string) {
n = read_nibbles(romptab, 3); n = read_nibbles(romptab, 3);
romptab += 3; romptab += 3;
if (n > 0) if (n > 0) {
{
/* /*
* look up lib number in romptab * look up lib number in romptab
*/ */
while (n--) while (n--) {
{
lib_n = read_nibbles(romptab, 3); lib_n = read_nibbles(romptab, 3);
romptab += 3; romptab += 3;
if (lib_n == lib) if (lib_n == lib)
@ -710,18 +668,15 @@ char * xlib_name(int lib, int command, char *string) {
if (opt_gx) if (opt_gx)
romptab += 8; romptab += 8;
} }
if (lib_n == lib) if (lib_n == lib) {
{
/* /*
* look at hash table pointer * look at hash table pointer
*/ */
lib_addr = read_nibbles(romptab, 5); lib_addr = read_nibbles(romptab, 5);
if (opt_gx) if (opt_gx) {
{
romptab += 5; romptab += 5;
acptr = read_nibbles(romptab, 5); acptr = read_nibbles(romptab, 5);
if (acptr != 0x00000) if (acptr != 0x00000) {
{
saturn.mem_cntl[1].config[0] = ram_base; saturn.mem_cntl[1].config[0] = ram_base;
saturn.mem_cntl[1].config[1] = ram_mask; saturn.mem_cntl[1].config[1] = ram_mask;
sprintf(p, "XLIB %d %d", lib, command); sprintf(p, "XLIB %d %d", lib, command);
@ -731,8 +686,7 @@ char * xlib_name(int lib, int command, char *string) {
} }
lib_addr += 3; lib_addr += 3;
offset = read_nibbles(lib_addr, 5); offset = read_nibbles(lib_addr, 5);
if (offset > 0) if (offset > 0) {
{
/* /*
* look at the hash table * look at the hash table
*/ */
@ -749,16 +703,13 @@ char * xlib_name(int lib, int command, char *string) {
* check pointer type * check pointer type
*/ */
type = read_nibbles(lib_addr, 5); type = read_nibbles(lib_addr, 5);
if (type == DOBINT) if (type == DOBINT) {
{
/* /*
* follow pointer to real address * follow pointer to real address
*/ */
lib_addr += 5; lib_addr += 5;
lib_addr = read_nibbles(lib_addr, 5); lib_addr = read_nibbles(lib_addr, 5);
} } else if (type == DOACPTR) {
else if (type == DOACPTR)
{
/* /*
* follow pointer to real address * follow pointer to real address
*/ */
@ -766,8 +717,7 @@ char * xlib_name(int lib, int command, char *string) {
acptr = lib_addr + 5; acptr = lib_addr + 5;
lib_addr = read_nibbles(lib_addr, 5); lib_addr = read_nibbles(lib_addr, 5);
acptr = read_nibbles(acptr, 5); acptr = read_nibbles(acptr, 5);
if (acptr != 0x00000) if (acptr != 0x00000) {
{
saturn.mem_cntl[1].config[0] = ram_base; saturn.mem_cntl[1].config[0] = ram_base;
saturn.mem_cntl[1].config[1] = ram_mask; saturn.mem_cntl[1].config[1] = ram_mask;
sprintf(p, "XLIB %d %d", lib, command); sprintf(p, "XLIB %d %d", lib, command);
@ -795,25 +745,20 @@ char * xlib_name(int lib, int command, char *string) {
*/ */
offset = 5 * command; offset = 5 * command;
lib_addr += offset; lib_addr += offset;
if (lib_addr < hash_end) if (lib_addr < hash_end) {
{
offset = read_nibbles(lib_addr, 5); offset = read_nibbles(lib_addr, 5);
if (offset > 0) if (offset > 0) {
{
name_addr = lib_addr - offset; name_addr = lib_addr - offset;
len = read_nibbles(name_addr, 2); len = read_nibbles(name_addr, 2);
name_addr += 2; name_addr += 2;
present = 1; present = 1;
for (i = 0; i < len; i++) for (i = 0; i < len; i++) {
{
c = read_nibbles(name_addr, 2); c = read_nibbles(name_addr, 2);
name_addr += 2; name_addr += 2;
if (hp48_trans_tbl[c].trans) if (hp48_trans_tbl[c].trans) {
{
sprintf(p, hp48_trans_tbl[c].trans); sprintf(p, hp48_trans_tbl[c].trans);
p += strlen(p); p += strlen(p);
} } else
else
*p++ = c; *p++ = c;
} }
*p = '\0'; *p = '\0';
@ -829,8 +774,7 @@ char * xlib_name(int lib, int command, char *string) {
saturn.mem_cntl[1].config[0] = ram_base; saturn.mem_cntl[1].config[0] = ram_base;
saturn.mem_cntl[1].config[1] = ram_mask; saturn.mem_cntl[1].config[1] = ram_mask;
if (!present) if (!present) {
{
sprintf(p, "XLIB %d %d", lib, command); sprintf(p, "XLIB %d %d", lib, command);
p += strlen(p); p += strlen(p);
} }
@ -865,8 +809,7 @@ char * any_array(word_20 *addr, char *string, short lnk_flag) {
dim = read_nibbles(*addr, 5); dim = read_nibbles(*addr, 5);
*addr += 5; *addr += 5;
for (op = objects; op->prolog != 0; op++) for (op = objects; op->prolog != 0; op++) {
{
if (op->prolog == type) if (op->prolog == type)
break; break;
} }
@ -874,24 +817,20 @@ char * any_array(word_20 *addr, char *string, short lnk_flag) {
dim_lens = (word_20 *)malloc(dim * sizeof(word_20)); dim_lens = (word_20 *)malloc(dim * sizeof(word_20));
dims = (word_20 *)malloc(dim * sizeof(word_20)); dims = (word_20 *)malloc(dim * sizeof(word_20));
elems = 1; elems = 1;
for (i = 0; i < dim; i++) for (i = 0; i < dim; i++) {
{
dim_lens[i] = read_nibbles(*addr, 5); dim_lens[i] = read_nibbles(*addr, 5);
dims[i] = dim_lens[i]; dims[i] = dim_lens[i];
elems *= dim_lens[i]; elems *= dim_lens[i];
*addr += 5; *addr += 5;
} }
if (op->prolog == 0) if (op->prolog == 0) {
{
sprintf(p, "of Type %.5lX, Dim %ld, Size ", type, (long)dim); sprintf(p, "of Type %.5lX, Dim %ld, Size ", type, (long)dim);
p += strlen(p); p += strlen(p);
for (i = 0; i < dim; i++) for (i = 0; i < dim; i++) {
{
sprintf(p, "%ld", (long)dim_lens[i]); sprintf(p, "%ld", (long)dim_lens[i]);
p += strlen(p); p += strlen(p);
if (i < dim - 1) if (i < dim - 1) {
{
sprintf(p, " x "); sprintf(p, " x ");
p += strlen(p); p += strlen(p);
} }
@ -904,31 +843,25 @@ char * any_array(word_20 *addr, char *string, short lnk_flag) {
} }
d = -1; d = -1;
while (elems--) while (elems--) {
{ if (d < dim - 1) {
if (d < dim - 1) for (; d < dim - 1; d++) {
{
for ( ; d < dim - 1; d++)
{
*p++ = '['; *p++ = '[';
} }
d = dim - 1; d = dim - 1;
} }
if (lnk_flag) if (lnk_flag) {
{
elem_addr = read_nibbles(*addr, 5); elem_addr = read_nibbles(*addr, 5);
elem_addr += *addr; elem_addr += *addr;
*addr += 5; *addr += 5;
p = (*op->func)(&elem_addr, p); p = (*op->func)(&elem_addr, p);
} } else
else
p = (*op->func)(addr, p); p = (*op->func)(addr, p);
*p = '\0'; *p = '\0';
dims[d]--; dims[d]--;
if (dims[d]) if (dims[d])
*p++ = ' '; *p++ = ' ';
while (dims[d] == 0) while (dims[d] == 0) {
{
dims[d] = dim_lens[d]; dims[d] = dim_lens[d];
d--; d--;
dims[d]--; dims[d]--;
@ -960,12 +893,10 @@ char * dec_char(word_20 *addr, char *string) {
*addr += 2; *addr += 2;
*p++ = '\''; *p++ = '\'';
if (hp48_trans_tbl[c].trans) if (hp48_trans_tbl[c].trans) {
{
sprintf(p, hp48_trans_tbl[c].trans); sprintf(p, hp48_trans_tbl[c].trans);
p += strlen(p); p += strlen(p);
} } else
else
*p++ = c; *p++ = c;
*p++ = '\''; *p++ = '\'';
@ -987,14 +918,11 @@ short check_xlib(word_20 addr, char *string) {
*/ */
ram_base = saturn.mem_cntl[1].config[0]; ram_base = saturn.mem_cntl[1].config[0];
ram_mask = saturn.mem_cntl[1].config[1]; ram_mask = saturn.mem_cntl[1].config[1];
if (opt_gx) if (opt_gx) {
{
saturn.mem_cntl[1].config[0] = 0x80000; saturn.mem_cntl[1].config[0] = 0x80000;
saturn.mem_cntl[1].config[1] = 0xc0000; saturn.mem_cntl[1].config[1] = 0xc0000;
romptab = ROMPTAB_GX; romptab = ROMPTAB_GX;
} } else {
else
{
saturn.mem_cntl[1].config[0] = 0x70000; saturn.mem_cntl[1].config[0] = 0x70000;
saturn.mem_cntl[1].config[1] = 0xf0000; saturn.mem_cntl[1].config[1] = 0xf0000;
romptab = ROMPTAB_SX; romptab = ROMPTAB_SX;
@ -1011,13 +939,11 @@ fprintf(stderr, "Number of Libraries = %d\n", n);
fflush(stderr); fflush(stderr);
*/ */
if (n > 0) if (n > 0) {
{
/* /*
* look up lib number in romptab * look up lib number in romptab
*/ */
while (n--) while (n--) {
{
lib = read_nibbles(romptab, 3); lib = read_nibbles(romptab, 3);
romptab += 3; romptab += 3;
/* /*
@ -1034,8 +960,7 @@ fflush(stderr);
*/ */
romptab += 5; romptab += 5;
if (opt_gx) if (opt_gx) {
{
acptr = read_nibbles(romptab, 5); acptr = read_nibbles(romptab, 5);
romptab += 8; romptab += 8;
if (acptr != 0x00000) if (acptr != 0x00000)
@ -1044,8 +969,7 @@ fflush(stderr);
lib_addr += 13; lib_addr += 13;
offset = read_nibbles(lib_addr, 5); offset = read_nibbles(lib_addr, 5);
if (offset > 0) if (offset > 0) {
{
/* /*
* look at the link table * look at the link table
*/ */
@ -1065,8 +989,7 @@ fflush(stderr);
* check pointer type * check pointer type
*/ */
type = read_nibbles(lib_addr, 5); type = read_nibbles(lib_addr, 5);
if (type == DOBINT) if (type == DOBINT) {
{
/* /*
* follow pointer to real address * follow pointer to real address
*/ */
@ -1092,13 +1015,10 @@ fflush(stderr);
*/ */
lib_addr += 5; lib_addr += 5;
command = 0; command = 0;
while (lib_addr < link_end) while (lib_addr < link_end) {
{
offset = read_nibbles(lib_addr, 5); offset = read_nibbles(lib_addr, 5);
if (offset > 0) if (offset > 0) {
{ if (addr == ((lib_addr + offset) & 0xfffff)) {
if (addr == ((lib_addr + offset) & 0xfffff))
{
p = xlib_name(lib, command, p); p = xlib_name(lib, command, p);
saturn.mem_cntl[1].config[0] = ram_base; saturn.mem_cntl[1].config[0] = ram_base;
saturn.mem_cntl[1].config[1] = ram_mask; saturn.mem_cntl[1].config[1] = ram_mask;
@ -1125,7 +1045,6 @@ fflush(stderr);
return 0; return 0;
} }
char *dec_rpl_obj(word_20 *addr, char *string) { char *dec_rpl_obj(word_20 *addr, char *string) {
word_20 prolog = 0; word_20 prolog = 0;
word_20 prolog_2; word_20 prolog_2;
@ -1135,23 +1054,17 @@ char * dec_rpl_obj(word_20 *addr, char *string) {
prolog = read_nibbles(*addr, 5); prolog = read_nibbles(*addr, 5);
for (op = objects; op->prolog != 0; op++) for (op = objects; op->prolog != 0; op++) {
{
if (op->prolog == prolog) if (op->prolog == prolog)
break; break;
} }
if (op->prolog == 0) if (op->prolog == 0) {
{ if (check_xlib(prolog, tmp_str)) {
if (check_xlib(prolog, tmp_str))
{
p = append_str(p, tmp_str); p = append_str(p, tmp_str);
} } else {
else
{
prolog_2 = read_nibbles(prolog, 5); prolog_2 = read_nibbles(prolog, 5);
for (op = objects; op->prolog != 0; op++) for (op = objects; op->prolog != 0; op++) {
{
if (op->prolog == prolog_2) if (op->prolog == prolog_2)
break; break;
} }
@ -1181,49 +1094,37 @@ void decode_rpl_obj_2(word_20 addr, char *typ, char *dat) {
prolog = read_nibbles(addr, 5); prolog = read_nibbles(addr, 5);
for (op = objects; op->prolog != 0; op++) for (op = objects; op->prolog != 0; op++) {
{
if (op->prolog == prolog) if (op->prolog == prolog)
break; break;
} }
if (op->prolog == 0) if (op->prolog == 0) {
{ if (addr == SEMI) {
if (addr == SEMI)
{
append_str(typ, "Primitive Code"); append_str(typ, "Primitive Code");
append_str(dat, "SEMI"); append_str(dat, "SEMI");
} } else if (addr + 5 == prolog) {
else if (addr + 5 == prolog)
{
append_str(typ, "Primitive Code"); append_str(typ, "Primitive Code");
sprintf(dat, "at %.5lX", prolog); sprintf(dat, "at %.5lX", prolog);
} } else {
else
{
append_str(typ, "PTR"); append_str(typ, "PTR");
sprintf(dat, "%.5lX", prolog); sprintf(dat, "%.5lX", prolog);
} }
return; return;
} }
if (op->prolog == DOCOL) if (op->prolog == DOCOL) {
{ if (check_xlib(addr, tmp_str)) {
if (check_xlib(addr, tmp_str))
{
append_str(typ, "XLib Call"); append_str(typ, "XLib Call");
append_str(dat, tmp_str); append_str(dat, tmp_str);
return; return;
} }
} }
if (op->length) if (op->length) {
{
len = (read_nibbles(addr + 5, 5) - 5) / op->length; len = (read_nibbles(addr + 5, 5) - 5) / op->length;
sprintf(typ, "%s %d", op->name, len); sprintf(typ, "%s %d", op->name, len);
} } else {
else
{
append_str(typ, op->name); append_str(typ, op->name);
} }
@ -1242,30 +1143,23 @@ char * decode_rpl_obj(word_20 addr, char *buf) {
prolog = read_nibbles(addr, 5); prolog = read_nibbles(addr, 5);
for (op = objects; op->prolog != 0; op++) for (op = objects; op->prolog != 0; op++) {
{
if (op->prolog == prolog) if (op->prolog == prolog)
break; break;
} }
if (op->prolog == 0) if (op->prolog == 0) {
{ if (addr == SEMI) {
if (addr == SEMI)
{
p = append_str(buf, "Primitive Code"); p = append_str(buf, "Primitive Code");
p = append_tab_16(buf); p = append_tab_16(buf);
p = append_str(p, "SEMI"); p = append_str(p, "SEMI");
} } else if (addr + 5 == prolog) {
else if (addr + 5 == prolog)
{
p = append_str(buf, "Primitive Code"); p = append_str(buf, "Primitive Code");
p = append_tab_16(buf); p = append_tab_16(buf);
sprintf(p, "at %.5lX", prolog); sprintf(p, "at %.5lX", prolog);
p += strlen(p); p += strlen(p);
*p = '\0'; *p = '\0';
} } else {
else
{
p = append_str(buf, "PTR"); p = append_str(buf, "PTR");
p = append_tab_16(buf); p = append_tab_16(buf);
sprintf(p, "%.5lX", prolog); sprintf(p, "%.5lX", prolog);
@ -1275,10 +1169,8 @@ char * decode_rpl_obj(word_20 addr, char *buf) {
return p; return p;
} }
if (op->prolog == DOCOL) if (op->prolog == DOCOL) {
{ if (check_xlib(addr, tmp_str)) {
if (check_xlib(addr, tmp_str))
{
p = append_str(buf, "XLib Call"); p = append_str(buf, "XLib Call");
p = append_tab_16(buf); p = append_tab_16(buf);
p = append_str(p, tmp_str); p = append_str(p, tmp_str);
@ -1288,8 +1180,7 @@ char * decode_rpl_obj(word_20 addr, char *buf) {
p = append_str(buf, op->name); p = append_str(buf, op->name);
if (op->length) if (op->length) {
{
len = (read_nibbles(addr + 5, 5) - 5) / op->length; len = (read_nibbles(addr + 5, 5) - 5) / op->length;
sprintf(p, " %d", len); sprintf(p, " %d", len);
p += strlen(p); p += strlen(p);

4
src/rpl.h
View file

@ -46,7 +46,6 @@
#define ROMPTAB_SX 0x707d9 #define ROMPTAB_SX 0x707d9
#define ROMPTAB_GX 0x809a3 #define ROMPTAB_GX 0x809a3
/* /*
* Object Prologs * Object Prologs
*/ */
@ -102,7 +101,8 @@ typedef struct hp_real {
} hp_real; } hp_real;
extern char *decode_rpl_obj __ProtoType__((word_20 addr, char *buf)); extern char *decode_rpl_obj __ProtoType__((word_20 addr, char *buf));
extern void decode_rpl_obj_2 __ProtoType__((word_20 addr, char *typ, char *dat)); extern void decode_rpl_obj_2 __ProtoType__((word_20 addr, char *typ,
char *dat));
extern char *skip_ob __ProtoType__((word_20 * addr, char *string)); extern char *skip_ob __ProtoType__((word_20 * addr, char *string));
extern char *dec_rpl_obj __ProtoType__((word_20 * addr, char *string)); extern char *dec_rpl_obj __ProtoType__((word_20 * addr, char *string));

165
src/serial.c
View file

@ -60,28 +60,27 @@
* $Id: serial.c,v 1.11 1995/01/11 18:20:01 ecd Exp ecd $ * $Id: serial.c,v 1.11 1995/01/11 18:20:01 ecd Exp ecd $
*/ */
#include "global.h" #include "global.h"
#include <errno.h>
#include <fcntl.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/time.h> #include <sys/time.h>
#if defined(HPUX) || defined(CSRG_BASED) #if defined(HPUX) || defined(CSRG_BASED)
#include <sys/ioctl.h> #include <sys/ioctl.h>
#endif #endif
#include <unistd.h>
#include <termios.h> #include <termios.h>
#include <unistd.h>
#ifdef SOLARIS #ifdef SOLARIS
#include <sys/stream.h> #include <sys/stream.h>
#include <sys/stropts.h> #include <sys/stropts.h>
#include <sys/termios.h> #include <sys/termios.h>
#endif #endif
#include "hp48.h"
#include "device.h" #include "device.h"
#include "hp48.h"
#include "hp48_emu.h" #include "hp48_emu.h"
#include "resources.h" #include "resources.h"
#include "x48_x11.h" #include "x48_x11.h"
@ -98,14 +97,14 @@ static char *ir_name = (char *)0;
/* #define DEBUG_SERIAL */ /* #define DEBUG_SERIAL */
void update_connection_display(void) { void update_connection_display(void) {
if (wire_fd == -1) if (wire_fd == -1) {
{ if (wire_name)
if (wire_name) free(wire_name); free(wire_name);
wire_name = (char *)0; wire_name = (char *)0;
} }
if (ir_fd == -1) if (ir_fd == -1) {
{ if (ir_name)
if (ir_name) free(ir_name); free(ir_name);
ir_name = (char *)0; ir_name = (char *)0;
} }
ShowConnections(wire_name, ir_name); ShowConnections(wire_name, ir_name);
@ -120,126 +119,98 @@ int serial_init(void) {
wire_fd = -1; wire_fd = -1;
ttyp = -1; ttyp = -1;
if (useTerminal) if (useTerminal) {
{
#if defined(IRIX) #if defined(IRIX)
if ((p = _getpty(&wire_fd, O_RDWR | O_EXCL | O_NDELAY, 0666, 0)) == NULL) if ((p = _getpty(&wire_fd, O_RDWR | O_EXCL | O_NDELAY, 0666, 0)) == NULL) {
{
wire_fd = -1; wire_fd = -1;
ttyp = -1; ttyp = -1;
} } else {
else if ((ttyp = open(p, O_RDWR | O_NDELAY, 0666)) < 0) {
{
if ((ttyp = open(p, O_RDWR | O_NDELAY, 0666)) < 0)
{
close(wire_fd); close(wire_fd);
wire_fd = -1; wire_fd = -1;
ttyp = -1; ttyp = -1;
} } else {
else
{
if (verbose) if (verbose)
printf("%s: wire connection on %s\n", progname, p); printf("%s: wire connection on %s\n", progname, p);
wire_name = strdup(p); wire_name = strdup(p);
} }
} }
#elif defined(SOLARIS) #elif defined(SOLARIS)
if ((wire_fd = open("/dev/ptmx", O_RDWR | O_NONBLOCK, 0666)) >= 0) if ((wire_fd = open("/dev/ptmx", O_RDWR | O_NONBLOCK, 0666)) >= 0) {
{
grantpt(wire_fd); grantpt(wire_fd);
unlockpt(wire_fd); unlockpt(wire_fd);
p = ptsname(wire_fd); p = ptsname(wire_fd);
strcpy(tty_dev_name, p); strcpy(tty_dev_name, p);
if ((ttyp = open(tty_dev_name, O_RDWR | O_NDELAY, 0666)) >= 0) if ((ttyp = open(tty_dev_name, O_RDWR | O_NDELAY, 0666)) >= 0) {
{
ioctl(ttyp, I_PUSH, "ptem"); ioctl(ttyp, I_PUSH, "ptem");
ioctl(ttyp, I_PUSH, "ldterm"); ioctl(ttyp, I_PUSH, "ldterm");
if (verbose) if (verbose)
printf("%s: wire connection on %s\n", progname, printf("%s: wire connection on %s\n", progname, tty_dev_name);
tty_dev_name);
wire_name = strdup(tty_dev_name); wire_name = strdup(tty_dev_name);
} }
} }
#elif defined(LINUX) #elif defined(LINUX)
/* Unix98 PTY (Preferred) */ /* Unix98 PTY (Preferred) */
if ((wire_fd = open("/dev/ptmx", O_RDWR | O_NONBLOCK, 0666)) >= 0) if ((wire_fd = open("/dev/ptmx", O_RDWR | O_NONBLOCK, 0666)) >= 0) {
{
grantpt(wire_fd); grantpt(wire_fd);
unlockpt(wire_fd); unlockpt(wire_fd);
if (ptsname_r(wire_fd, tty_dev_name, 128)) { if (ptsname_r(wire_fd, tty_dev_name, 128)) {
perror("Could not get the name of the wire device."); perror("Could not get the name of the wire device.");
exit(-1); exit(-1);
} }
if ((ttyp = open(tty_dev_name, O_RDWR | O_NDELAY, 0666)) >= 0) if ((ttyp = open(tty_dev_name, O_RDWR | O_NDELAY, 0666)) >= 0) {
{
if (verbose) if (verbose)
printf("%s: wire connection on %s\n", progname, printf("%s: wire connection on %s\n", progname, tty_dev_name);
tty_dev_name);
wire_name = strdup(tty_dev_name); wire_name = strdup(tty_dev_name);
} }
} }
/* BSD PTY (Legacy) */ /* BSD PTY (Legacy) */
else else {
{
c = 'p'; c = 'p';
do do {
{ for (n = 0; n < 16; n++) {
for (n = 0; n < 16; n++)
{
sprintf(tty_dev_name, "/dev/pty%c%x", c, n); sprintf(tty_dev_name, "/dev/pty%c%x", c, n);
if ((wire_fd = open(tty_dev_name, if ((wire_fd =
O_RDWR | O_EXCL | O_NDELAY, 0666)) >= 0) open(tty_dev_name, O_RDWR | O_EXCL | O_NDELAY, 0666)) >= 0) {
{
ttyp = wire_fd; ttyp = wire_fd;
sprintf(tty_dev_name, "/dev/tty%c%x", c, n); sprintf(tty_dev_name, "/dev/tty%c%x", c, n);
if (verbose) if (verbose)
printf("%s: wire connection on %s\n", progname, printf("%s: wire connection on %s\n", progname, tty_dev_name);
tty_dev_name);
wire_name = strdup(tty_dev_name); wire_name = strdup(tty_dev_name);
break; break;
} }
} }
c++; c++;
} } while ((wire_fd < 0) && (errno != ENOENT));
while ((wire_fd < 0) && (errno != ENOENT));
} }
#else #else
/* /*
* Here we go for SUNOS, HPUX * Here we go for SUNOS, HPUX
*/ */
c = 'p'; c = 'p';
do do {
{ for (n = 0; n < 16; n++) {
for (n = 0; n < 16; n++)
{
sprintf(tty_dev_name, "/dev/ptyp%x", n); sprintf(tty_dev_name, "/dev/ptyp%x", n);
if ((wire_fd = open(tty_dev_name, if ((wire_fd = open(tty_dev_name, O_RDWR | O_EXCL | O_NDELAY, 0666)) >=
O_RDWR | O_EXCL | O_NDELAY, 0666)) >= 0) 0) {
{
sprintf(tty_dev_name, "/dev/tty%c%x", c, n); sprintf(tty_dev_name, "/dev/tty%c%x", c, n);
if ((ttyp = open(tty_dev_name, O_RDWR | O_NDELAY, 0666)) < 0) if ((ttyp = open(tty_dev_name, O_RDWR | O_NDELAY, 0666)) < 0) {
{
wire_fd = -1; wire_fd = -1;
ttyp = -1; ttyp = -1;
} } else {
else
{
if (verbose) if (verbose)
printf("%s: wire connection on %s\n", progname, printf("%s: wire connection on %s\n", progname, tty_dev_name);
tty_dev_name);
wire_name = strdup(tty_dev_name); wire_name = strdup(tty_dev_name);
break; break;
} }
} }
} }
c++; c++;
} } while ((wire_fd < 0) && (errno != ENOENT));
while ((wire_fd < 0) && (errno != ENOENT));
#endif #endif
} }
if (ttyp >= 0) if (ttyp >= 0) {
{
#if defined(TCSANOW) #if defined(TCSANOW)
if (tcgetattr(ttyp, &ttybuf) < 0) if (tcgetattr(ttyp, &ttybuf) < 0)
#else #else
@ -263,8 +234,7 @@ int serial_init(void) {
ttybuf.c_cc[VTIME] = 0; ttybuf.c_cc[VTIME] = 0;
ttybuf.c_cc[VMIN] = 1; ttybuf.c_cc[VMIN] = 1;
if (ttyp >= 0) if (ttyp >= 0) {
{
#if defined(TCSANOW) #if defined(TCSANOW)
if (tcsetattr(ttyp, TCSANOW, &ttybuf) < 0) if (tcsetattr(ttyp, TCSANOW, &ttybuf) < 0)
#else #else
@ -280,19 +250,16 @@ int serial_init(void) {
} }
ir_fd = -1; ir_fd = -1;
if (useSerial) if (useSerial) {
{
sprintf(tty_dev_name, serialLine); sprintf(tty_dev_name, serialLine);
if ((ir_fd = open(tty_dev_name, O_RDWR | O_NDELAY)) >= 0) if ((ir_fd = open(tty_dev_name, O_RDWR | O_NDELAY)) >= 0) {
{
if (verbose) if (verbose)
printf("%s: IR connection on %s\n", progname, tty_dev_name); printf("%s: IR connection on %s\n", progname, tty_dev_name);
ir_name = strdup(tty_dev_name); ir_name = strdup(tty_dev_name);
} }
} }
if (ir_fd >= 0) if (ir_fd >= 0) {
{
#if defined(TCSANOW) #if defined(TCSANOW)
if (tcgetattr(ir_fd, &ttybuf) < 0) if (tcgetattr(ir_fd, &ttybuf) < 0)
#else #else
@ -300,8 +267,8 @@ int serial_init(void) {
#endif #endif
{ {
if (!quiet) if (!quiet)
fprintf(stderr, "%s: ioctl(IR, TCGETS) failed, errno = %d\n", fprintf(stderr, "%s: ioctl(IR, TCGETS) failed, errno = %d\n", progname,
progname, errno); errno);
ir_fd = -1; ir_fd = -1;
} }
} }
@ -315,8 +282,7 @@ int serial_init(void) {
ttybuf.c_cc[VTIME] = 0; ttybuf.c_cc[VTIME] = 0;
ttybuf.c_cc[VMIN] = 1; ttybuf.c_cc[VMIN] = 1;
if (ir_fd >= 0) if (ir_fd >= 0) {
{
#if defined(TCSANOW) #if defined(TCSANOW)
if (tcsetattr(ir_fd, TCSANOW, &ttybuf) < 0) if (tcsetattr(ir_fd, TCSANOW, &ttybuf) < 0)
#else #else
@ -324,8 +290,8 @@ int serial_init(void) {
#endif #endif
{ {
if (!quiet) if (!quiet)
fprintf(stderr, "%s: ioctl(IR, TCSETS) failed, errno = %d\n", fprintf(stderr, "%s: ioctl(IR, TCSETS) failed, errno = %d\n", progname,
progname, errno); errno);
ir_fd = -1; ir_fd = -1;
} }
} }
@ -337,8 +303,7 @@ void serial_baud(int baud) {
int error = 0; int error = 0;
struct termios ttybuf; struct termios ttybuf;
if (ir_fd >= 0) if (ir_fd >= 0) {
{
#if defined(TCSANOW) #if defined(TCSANOW)
if (tcgetattr(ir_fd, &ttybuf) < 0) if (tcgetattr(ir_fd, &ttybuf) < 0)
#else #else
@ -346,8 +311,8 @@ void serial_baud(int baud) {
#endif #endif
{ {
if (!quiet) if (!quiet)
fprintf(stderr, "%s: ioctl(IR, TCGETS) failed, errno = %d\n", fprintf(stderr, "%s: ioctl(IR, TCGETS) failed, errno = %d\n", progname,
progname, errno); errno);
ir_fd = -1; ir_fd = -1;
error = 1; error = 1;
} }
@ -355,8 +320,7 @@ void serial_baud(int baud) {
#if defined(__APPLE__) #if defined(__APPLE__)
baud &= 0x7; baud &= 0x7;
switch (baud) switch (baud) {
{
case 0: /* 1200 */ case 0: /* 1200 */
ttybuf.c_cflag |= B1200; ttybuf.c_cflag |= B1200;
break; break;
@ -391,8 +355,7 @@ void serial_baud(int baud) {
break; break;
} }
if ((ir_fd >= 0) && ((ttybuf.c_ospeed) == 0)) if ((ir_fd >= 0) && ((ttybuf.c_ospeed) == 0)) {
{
if (!quiet) if (!quiet)
fprintf(stderr, "%s: can\'t set baud rate, using 9600\n", progname); fprintf(stderr, "%s: can\'t set baud rate, using 9600\n", progname);
ttybuf.c_cflag |= B9600; ttybuf.c_cflag |= B9600;
@ -401,8 +364,7 @@ void serial_baud(int baud) {
ttybuf.c_cflag &= ~CBAUD; ttybuf.c_cflag &= ~CBAUD;
baud &= 0x7; baud &= 0x7;
switch (baud) switch (baud) {
{
case 0: /* 1200 */ case 0: /* 1200 */
ttybuf.c_cflag |= B1200; ttybuf.c_cflag |= B1200;
break; break;
@ -437,15 +399,13 @@ void serial_baud(int baud) {
break; break;
} }
if ((ir_fd >= 0) && ((ttybuf.c_cflag & CBAUD) == 0)) if ((ir_fd >= 0) && ((ttybuf.c_cflag & CBAUD) == 0)) {
{
if (!quiet) if (!quiet)
fprintf(stderr, "%s: can\'t set baud rate, using 9600\n", progname); fprintf(stderr, "%s: can\'t set baud rate, using 9600\n", progname);
ttybuf.c_cflag |= B9600; ttybuf.c_cflag |= B9600;
} }
#endif #endif
if (ir_fd >= 0) if (ir_fd >= 0) {
{
#if defined(TCSANOW) #if defined(TCSANOW)
if (tcsetattr(ir_fd, TCSANOW, &ttybuf) < 0) if (tcsetattr(ir_fd, TCSANOW, &ttybuf) < 0)
#else #else
@ -453,15 +413,14 @@ void serial_baud(int baud) {
#endif #endif
{ {
if (!quiet) if (!quiet)
fprintf(stderr, "%s: ioctl(IR, TCSETS) failed, errno = %d\n", fprintf(stderr, "%s: ioctl(IR, TCSETS) failed, errno = %d\n", progname,
progname, errno); errno);
ir_fd = -1; ir_fd = -1;
error = 1; error = 1;
} }
} }
if (ttyp >= 0) if (ttyp >= 0) {
{
#if defined(TCSANOW) #if defined(TCSANOW)
if (tcgetattr(ttyp, &ttybuf) < 0) if (tcgetattr(ttyp, &ttybuf) < 0)
#else #else
@ -482,8 +441,7 @@ void serial_baud(int baud) {
ttybuf.c_cflag &= ~CBAUD; ttybuf.c_cflag &= ~CBAUD;
baud &= 0x7; baud &= 0x7;
switch (baud) switch (baud) {
{
case 0: /* 1200 */ case 0: /* 1200 */
ttybuf.c_cflag |= B1200; ttybuf.c_cflag |= B1200;
break; break;
@ -518,15 +476,13 @@ void serial_baud(int baud) {
break; break;
} }
if ((ttyp >= 0) && ((ttybuf.c_cflag & CBAUD) == 0)) if ((ttyp >= 0) && ((ttybuf.c_cflag & CBAUD) == 0)) {
{
if (!quiet) if (!quiet)
fprintf(stderr, "%s: can\'t set baud rate, using 9600\n", progname); fprintf(stderr, "%s: can\'t set baud rate, using 9600\n", progname);
ttybuf.c_cflag |= B9600; ttybuf.c_cflag |= B9600;
} }
#endif #endif
if (ttyp >= 0) if (ttyp >= 0) {
{
#if defined(TCSANOW) #if defined(TCSANOW)
if (tcsetattr(ttyp, TCSANOW, &ttybuf) < 0) if (tcsetattr(ttyp, TCSANOW, &ttybuf) < 0)
#else #else
@ -545,7 +501,6 @@ void serial_baud(int baud) {
update_connection_display(); update_connection_display();
} }
void transmit_char(void) { void transmit_char(void) {
#ifdef DEBUG_SERIALx #ifdef DEBUG_SERIALx
fprintf(stderr, "XMT %s\n", (saturn.ir_ctrl & 0x04) ? "IR" : "wire"); fprintf(stderr, "XMT %s\n", (saturn.ir_ctrl & 0x04) ? "IR" : "wire");

3
src/small.h
View file

@ -323,7 +323,6 @@ letter_t small_font[] = {
{0, 0, 0}, {0, 0, 0},
{rcurly_width, rcurly_height, rcurly_bits}, {rcurly_width, rcurly_height, rcurly_bits},
{0, 0, 0}, {0, 0, 0},
{ 0, 0, 0 } {0, 0, 0}};
};
#endif /* !_SMALL_H */ #endif /* !_SMALL_H */

68
src/timer.c
View file

@ -40,14 +40,14 @@
#include "global.h" #include "global.h"
#include <stdlib.h>
#include <stdio.h> #include <stdio.h>
#include <unistd.h> #include <stdlib.h>
#include <time.h> #include <time.h>
#include <unistd.h>
#include "timer.h"
#include "debugger.h" #include "debugger.h"
#include "romio.h" #include "romio.h"
#include "timer.h"
#include <assert.h> #include <assert.h>
@ -157,8 +157,7 @@ void set_accesstime(void) {
ticks += time_offset; ticks += time_offset;
timer2 = saturn.timer2; timer2 = saturn.timer2;
if (saturn.timer2 & 0x80000000) if (saturn.timer2 & 0x80000000) {
{
assert(timer2 < 0); assert(timer2 < 0);
} }
@ -168,39 +167,33 @@ void set_accesstime(void) {
crc = 0x0; crc = 0x0;
if (opt_gx) if (opt_gx) {
{
accesstime_loc = ACCESSTIME_GX; accesstime_loc = ACCESSTIME_GX;
accesscrc_loc = ACCESSCRC_GX; accesscrc_loc = ACCESSCRC_GX;
timeout_loc = TIMEOUT_GX; timeout_loc = TIMEOUT_GX;
timeoutclk_loc = TIMEOUTCLK_GX; timeoutclk_loc = TIMEOUTCLK_GX;
} } else {
else
{
accesstime_loc = ACCESSTIME_SX; accesstime_loc = ACCESSTIME_SX;
accesscrc_loc = ACCESSCRC_SX; accesscrc_loc = ACCESSCRC_SX;
timeout_loc = TIMEOUT_SX; timeout_loc = TIMEOUT_SX;
timeoutclk_loc = TIMEOUTCLK_SX; timeoutclk_loc = TIMEOUTCLK_SX;
} }
for (i = 0; i < 13; i++) for (i = 0; i < 13; i++) {
{
val = ticks & 0xf; val = ticks & 0xf;
calc_crc(val); calc_crc(val);
saturn.ram[accesstime_loc + i] = val; saturn.ram[accesstime_loc + i] = val;
ticks >>= 4; ticks >>= 4;
} }
for (i = 0; i < 4; i++) for (i = 0; i < 4; i++) {
{
saturn.ram[accesscrc_loc + i] = crc & 0xf; saturn.ram[accesscrc_loc + i] = crc & 0xf;
crc >>= 4; crc >>= 4;
} }
timeout += ticks_10_min; timeout += ticks_10_min;
for (i = 0; i < 13; i++) for (i = 0; i < 13; i++) {
{
val = timeout & 0xf; val = timeout & 0xf;
calc_crc(val); calc_crc(val);
saturn.ram[timeout_loc + i] = val; saturn.ram[timeout_loc + i] = val;
@ -237,7 +230,8 @@ void start_timer(int timer) {
timers[timer].start += (tv.tv_usec << 7) / 15625; timers[timer].start += (tv.tv_usec << 7) / 15625;
} }
#ifdef DEBUG_TIMER #ifdef DEBUG_TIMER
fprintf(stderr, "Timer%c[%d] start at 0x%lx\n", timer == T1_TIMER?'*':' ', timer, timers[timer].start); fprintf(stderr, "Timer%c[%d] start at 0x%lx\n", timer == T1_TIMER ? '*' : ' ',
timer, timers[timer].start);
#endif #endif
} }
@ -271,8 +265,7 @@ void restart_timer(int timer) {
timers[timer].start += (tv.tv_usec << 7) / 15625; timers[timer].start += (tv.tv_usec << 7) / 15625;
} }
#ifdef DEBUG_TIMER #ifdef DEBUG_TIMER
fprintf(stderr, "Timer[%d] restart at 0x%lx\n", timer, fprintf(stderr, "Timer[%d] restart at 0x%lx\n", timer, timers[timer].start);
timers[timer].start);
#endif #endif
} }
@ -306,11 +299,12 @@ void stop_timer(int timer) {
} }
timers[timer].value += timers[timer].stop - timers[timer].start; timers[timer].value += timers[timer].stop - timers[timer].start;
// add_sub_64(&timers[timer].stop, &timers[timer].start, &timers[timer].value); // add_sub_64(&timers[timer].stop, &timers[timer].start,
// &timers[timer].value);
#ifdef DEBUG_TIMER #ifdef DEBUG_TIMER
fprintf(stderr, "Timer[%d] stop at 0x%llx, value 0x%llx\n", fprintf(stderr, "Timer[%d] stop at 0x%llx, value 0x%llx\n", timer,
timer, timers[timer].stop, timers[timer].value); timers[timer].stop, timers[timer].value);
#endif #endif
} }
@ -393,12 +387,10 @@ t1_t2_ticks get_t1_t2(void) {
#endif #endif
tv.tv_sec -= systime_offset; tv.tv_sec -= systime_offset;
if (timers[T1_TIMER].run) if (timers[T1_TIMER].run) {
{
stop = (tv.tv_sec << 9); stop = (tv.tv_sec << 9);
stop += (tv.tv_usec / 15625) >> 3; stop += (tv.tv_usec / 15625) >> 3;
if (timers[T1_TIMER].start <= stop) if (timers[T1_TIMER].start <= stop) {
{
timers[T1_TIMER].value += stop - timers[T1_TIMER].start; timers[T1_TIMER].value += stop - timers[T1_TIMER].start;
} else { } else {
fprintf(stderr, "clock running backwards\n"); fprintf(stderr, "clock running backwards\n");
@ -416,32 +408,27 @@ t1_t2_ticks get_t1_t2(void) {
access_time = 0x0; access_time = 0x0;
for (i = 13 - 1; i >= 0; i--) for (i = 13 - 1; i >= 0; i--) {
{
access_time <<= 4; access_time <<= 4;
access_time |= ((int)saturn.ram[accesstime_loc + i] & 0xf); access_time |= ((int)saturn.ram[accesstime_loc + i] & 0xf);
} }
access_time -= stop; access_time -= stop;
if (adj_time_pending || in_debugger) if (adj_time_pending || in_debugger) {
{
/* /*
* We have been inside an interrupt for very long, maybe * We have been inside an interrupt for very long, maybe
* or we are sleeping in the debugger. * or we are sleeping in the debugger.
* Don't adjust the time, can't come from user, anyhow. * Don't adjust the time, can't come from user, anyhow.
*/ */
if ((saturn.timer2 >= 0 && access_time < 0) if ((saturn.timer2 >= 0 && access_time < 0) ||
|| ((unsigned long)saturn.timer2 > access_time)) ((unsigned long)saturn.timer2 > access_time)) {
{
/* /*
* check OK, return calculated time * check OK, return calculated time
*/ */
ticks.t2_ticks = access_time; ticks.t2_ticks = access_time;
} } else {
else
{
/* /*
* Don't increment timer2, return old value and * Don't increment timer2, return old value and
* slow down timer2. * slow down timer2.
@ -473,16 +460,13 @@ t1_t2_ticks get_t1_t2(void) {
#endif #endif
} }
if ((saturn.timer2 >= 0 && (access_time < 0)) if ((saturn.timer2 >= 0 && (access_time < 0)) ||
|| ((unsigned long)saturn.timer2 > access_time)) ((unsigned long)saturn.timer2 > access_time)) {
{
/* /*
* check OK, return calculated time * check OK, return calculated time
*/ */
ticks.t2_ticks = access_time; ticks.t2_ticks = access_time;
} } else {
else
{
/* /*
* Don't increment timer2, return old value and * Don't increment timer2, return old value and
* slow down timer2. * slow down timer2.

1834
src/x48_x11.c
View file

File diff suppressed because it is too large Load diff

2
src/x48_x11.h
View file

@ -65,9 +65,9 @@
#include <X11/Xlib.h> #include <X11/Xlib.h>
#ifdef HAVE_XSHM #ifdef HAVE_XSHM
#include <X11/extensions/XShm.h>
#include <sys/ipc.h> #include <sys/ipc.h>
#include <sys/shm.h> #include <sys/shm.h>
#include <X11/extensions/XShm.h>
#endif #endif
#define WHITE 0 #define WHITE 0