gwh/libx48ng
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

add and use .clang-format

Browse source
This commit is contained in:
Gwenhael Le Moine 2023-04-27 12:15:59 +02:00
parent 4c454f9783
commit 4d8afad2c4
No known key found for this signature in database
GPG key ID: FDFE3669426707A7
45 changed files with 17053 additions and 16385 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

18
.clang-format Normal file
View file

@ -0,0 +1,18 @@
---
IndentCaseLabels: 'true'
IndentPPDirectives: None
IndentWidth: '4'
PointerAlignment: Left
SortIncludes: 'false'
SpaceAfterTemplateKeyword: 'false'
SpaceBeforeAssignmentOperators: 'true'
SpaceBeforeParens: ControlStatements
SpaceBeforeRangeBasedForLoopColon: 'true'
SpaceInEmptyParentheses: 'false'
SpacesInAngles: 'true'
SpacesInCStyleCastParentheses: 'true'
SpacesInContainerLiterals: 'true'
SpacesInParentheses: 'true'
SpacesInSquareBrackets: 'true'
...

39
src/X48.ad.h
View file

@ -1,24 +1,15 @@
"*iconic: False", "*iconic: False", "*visual: Default",
"*visual: Default", "*mono: False", "*gray: False",
"*mono: False", "*monoIcon: False", "*useXShm: True",
"*gray: False", "*smallLabelFont: -*-fixed-bold-r-normal-*-14-*-*-*-*-*-iso8859-1",
"*monoIcon: False", "*mediumLabelFont: -*-fixed-bold-r-normal-*-15-*-*-*-*-*-iso8859-1",
"*useXShm: True", "*largeLabelFont: -*-fixed-medium-r-normal-*-20-*-*-*-*-*-iso8859-1",
"*smallLabelFont: -*-fixed-bold-r-normal-*-14-*-*-*-*-*-iso8859-1", "*connectionFont: -*-fixed-medium-r-normal-*-12-*-*-*-*-*-iso8859-1",
"*mediumLabelFont: -*-fixed-bold-r-normal-*-15-*-*-*-*-*-iso8859-1", "*verbose: False", "*quiet: False",
"*largeLabelFont: -*-fixed-medium-r-normal-*-20-*-*-*-*-*-iso8859-1", "*printVersion: False", "*printCopyright: False",
"*connectionFont: -*-fixed-medium-r-normal-*-12-*-*-*-*-*-iso8859-1", "*printWarranty: False", "*useTerminal: True",
"*verbose: False", "*useSerial: False", "*serialLine: /dev/ttyS0",
"*quiet: False", "*completeInitialize: False", "*resetOnStartup: False",
"*printVersion: False", "*romFileName: rom.dump",
"*printCopyright: False", "*homeDirectory: .hp48", "*useDebugger: True",
"*printWarranty: False", "*disassemblerMnemonics: class",
"*useTerminal: True",
"*useSerial: False",
"*serialLine: /dev/ttyS0",
"*completeInitialize: False",
"*resetOnStartup: False",
"*romFileName: rom.dump",
"*homeDirectory: .hp48",
"*useDebugger: True",
"*disassemblerMnemonics: class",

541
src/actions.c
View file

@ -92,336 +92,369 @@
#include "x48_x11.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 ];
int got_alarm; int got_alarm;
int first_press = 1; // PATCH
int conf_bank1 = 0x00000; int conf_bank1 = 0x00000;
int conf_bank2 = 0x00000; int conf_bank2 = 0x00000;
void do_in(void) { void do_in( void ) {
int i, in, out; int i, in, out;
out = 0; out = 0;
for (i = 2; i >= 0; i--) { for ( i = 2; i >= 0; i-- ) {
out <<= 4; out <<= 4;
out |= saturn.OUT[i]; out |= saturn.OUT[ i ];
} }
in = 0; in = 0;
for (i = 0; i < 9; i++) for ( i = 0; i < 9; i++ )
if (out & (1 << i)) if ( out & ( 1 << i ) )
in |= saturn.keybuf.rows[i]; in |= saturn.keybuf.rows[ i ];
#ifdef DEBUG_INOUT #ifdef DEBUG_INOUT
fprintf(stderr, "saturn.OUT=%.3x, saturn.IN=%.4x\n", out, in); fprintf( stderr, "saturn.OUT=%.3x, saturn.IN=%.4x\n", out, in );
#endif #endif
for (i = 0; i < 4; i++) { // PATCH
saturn.IN[i] = in & 0xf; // http://svn.berlios.de/wsvn/x48?op=comp&compare[]=/trunk@12&compare[]=/trunk@13
// PAS TERRIBLE VISIBLEMENT
if ( saturn.PC == 0x00E31 && !first_press &&
( ( out & 0x10 && in & 0x1 ) || // keys are Backspace
( out & 0x40 && in & 0x7 ) || // right, left & down
( out & 0x80 && in & 0x2 ) ) ) // up arrows
{
for ( i = 0; i < 9; i++ )
if ( out & ( 1 << i ) )
saturn.keybuf.rows[ i ] = 0;
first_press = 1;
} else
first_press = 0;
// FIN PATCH
for ( i = 0; i < 4; i++ ) {
saturn.IN[ i ] = in & 0xf;
in >>= 4; in >>= 4;
} }
} }
void clear_program_stat(int n) { saturn.PSTAT[n] = 0; } void clear_program_stat( int n ) { saturn.PSTAT[ n ] = 0; }
void set_program_stat(int n) { saturn.PSTAT[n] = 1; } void set_program_stat( int n ) { saturn.PSTAT[ n ] = 1; }
int get_program_stat(int n) { return saturn.PSTAT[n]; } int get_program_stat( int n ) { return saturn.PSTAT[ n ]; }
void register_to_status(unsigned char *r) { void register_to_status( unsigned char* r ) {
int i; int i;
for (i = 0; i < 12; i++) { for ( i = 0; i < 12; i++ ) {
saturn.PSTAT[i] = (r[i / 4] >> (i % 4)) & 1; saturn.PSTAT[ i ] = ( r[ i / 4 ] >> ( i % 4 ) ) & 1;
} }
} }
void status_to_register(unsigned char *r) { void status_to_register( unsigned char* r ) {
int i; int i;
for (i = 0; i < 12; i++) { for ( i = 0; i < 12; i++ ) {
if (saturn.PSTAT[i]) { if ( saturn.PSTAT[ i ] ) {
r[i / 4] |= 1 << (i % 4); r[ i / 4 ] |= 1 << ( i % 4 );
} else { } else {
r[i / 4] &= ~(1 << (i % 4)) & 0xf; r[ i / 4 ] &= ~( 1 << ( i % 4 ) ) & 0xf;
} }
} }
} }
void swap_register_status(unsigned char *r) { void swap_register_status( unsigned char* r ) {
int i, tmp; int i, tmp;
for (i = 0; i < 12; i++) { for ( i = 0; i < 12; i++ ) {
tmp = saturn.PSTAT[i]; tmp = saturn.PSTAT[ i ];
saturn.PSTAT[i] = (r[i / 4] >> (i % 4)) & 1; saturn.PSTAT[ i ] = ( r[ i / 4 ] >> ( i % 4 ) ) & 1;
if (tmp) { if ( tmp ) {
r[i / 4] |= 1 << (i % 4); r[ i / 4 ] |= 1 << ( i % 4 );
} else { } else {
r[i / 4] &= ~(1 << (i % 4)) & 0xf; r[ i / 4 ] &= ~( 1 << ( i % 4 ) ) & 0xf;
} }
} }
} }
void clear_status(void) { void clear_status( void ) {
int i; int i;
for (i = 0; i < 12; i++) { for ( i = 0; i < 12; i++ ) {
saturn.PSTAT[i] = 0; saturn.PSTAT[ i ] = 0;
} }
} }
void set_register_nibble(unsigned char *reg, int n, unsigned char val) { 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) { return reg[n]; } unsigned char get_register_nibble( unsigned char* reg, int n ) {
return reg[ n ];
void set_register_bit(unsigned char *reg, int n) {
reg[n / 4] |= (1 << (n % 4));
} }
void clear_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 ) );
} }
int get_register_bit(unsigned char *reg, int n) { void clear_register_bit( unsigned char* reg, int n ) {
return ((int)(reg[n / 4] & (1 << (n % 4))) > 0) ? 1 : 0; reg[ n / 4 ] &= ~( 1 << ( n % 4 ) );
} }
short conf_tab_sx[] = {1, 2, 2, 2, 2, 0}; int get_register_bit( unsigned char* reg, int n ) {
short conf_tab_gx[] = {1, 2, 2, 2, 2, 0}; return ( ( int )( reg[ n / 4 ] & ( 1 << ( n % 4 ) ) ) > 0 ) ? 1 : 0;
}
void do_reset(void) { short conf_tab_sx[] = { 1, 2, 2, 2, 2, 0 };
short conf_tab_gx[] = { 1, 2, 2, 2, 2, 0 };
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
saturn.mem_cntl[i].unconfigured = conf_tab_sx[i]; saturn.mem_cntl[ i ].unconfigured = conf_tab_sx[ i ];
saturn.mem_cntl[i].config[0] = 0x0; saturn.mem_cntl[ i ].config[ 0 ] = 0x0;
saturn.mem_cntl[i].config[1] = 0x0; saturn.mem_cntl[ i ].config[ 1 ] = 0x0;
} }
#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", i, fprintf( stderr,
saturn.mem_cntl[i].config[0], saturn.mem_cntl[i].config[1]); "MEMORY CONTROLLER %d is configured to %.5lx, %.5lx\n", i,
saturn.mem_cntl[ i ].config[ 0 ],
saturn.mem_cntl[ i ].config[ 1 ] );
} }
#endif #endif
} }
void do_inton(void) { saturn.kbd_ien = 1; } void do_inton( void ) { saturn.kbd_ien = 1; }
void do_intoff(void) { saturn.kbd_ien = 0; } void do_intoff( void ) { 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", saturn.PC); fprintf( stderr, "PC = %.5lx: RTI SERVICE PENDING INTERRUPT\n",
saturn.PC );
#endif #endif
saturn.int_pending = 0; saturn.int_pending = 0;
saturn.intenable = 0; saturn.intenable = 0;
saturn.PC = 0xf; saturn.PC = 0xf;
} else { } else {
#ifdef DEBUG_INTERRUPT #ifdef DEBUG_INTERRUPT
fprintf(stderr, "PC = %.5lx: RETURN INTERRUPT to ", saturn.PC); fprintf( stderr, "PC = %.5lx: RETURN INTERRUPT to ", saturn.PC );
#endif #endif
saturn.PC = pop_return_addr(); saturn.PC = pop_return_addr();
#ifdef DEBUG_INTERRUPT #ifdef DEBUG_INTERRUPT
fprintf(stderr, "%.5lx\n", saturn.PC); fprintf( stderr, "%.5lx\n", saturn.PC );
#endif #endif
saturn.intenable = 1; saturn.intenable = 1;
if (adj_time_pending) { if ( adj_time_pending ) {
schedule_event = 0; schedule_event = 0;
sched_adjtime = 0; sched_adjtime = 0;
} }
} }
} }
void do_interupt(void) { void do_interupt( void ) {
interrupt_called = 1; interrupt_called = 1;
if (saturn.intenable) { if ( saturn.intenable ) {
#ifdef DEBUG_INTERRUPT #ifdef DEBUG_INTERRUPT
fprintf(stderr, "PC = %.5lx: INTERRUPT\n", saturn.PC); fprintf( stderr, "PC = %.5lx: INTERRUPT\n", saturn.PC );
#endif #endif
push_return_addr(saturn.PC); push_return_addr( saturn.PC );
saturn.PC = 0xf; saturn.PC = 0xf;
saturn.intenable = 0; saturn.intenable = 0;
} }
} }
void do_kbd_int(void) { void do_kbd_int( void ) {
interrupt_called = 1; interrupt_called = 1;
if (saturn.intenable) { if ( saturn.intenable ) {
#ifdef DEBUG_KBD_INT #ifdef DEBUG_KBD_INT
fprintf(stderr, "PC = %.5lx: KBD INT\n", saturn.PC); fprintf( stderr, "PC = %.5lx: KBD INT\n", saturn.PC );
#endif #endif
push_return_addr(saturn.PC); push_return_addr( saturn.PC );
saturn.PC = 0xf; saturn.PC = 0xf;
saturn.intenable = 0; saturn.intenable = 0;
} else { } else {
#ifdef DEBUG_KBD_INT #ifdef DEBUG_KBD_INT
fprintf(stderr, "PC = %.5lx: KBD INT PENDING\n", saturn.PC); fprintf( stderr, "PC = %.5lx: KBD INT PENDING\n", saturn.PC );
#endif #endif
saturn.int_pending = 1; saturn.int_pending = 1;
} }
} }
void do_reset_interrupt_system(void) { void do_reset_interrupt_system( void ) {
int i, gen_intr; int i, gen_intr;
saturn.kbd_ien = 1; saturn.kbd_ien = 1;
gen_intr = 0; gen_intr = 0;
for (i = 0; i < 9; i++) { for ( i = 0; i < 9; i++ ) {
if (saturn.keybuf.rows[i] != 0) { if ( saturn.keybuf.rows[ i ] != 0 ) {
gen_intr = 1; gen_intr = 1;
break; break;
} }
} }
if (gen_intr) { if ( gen_intr ) {
do_kbd_int(); do_kbd_int();
} }
} }
void do_unconfigure(void) { void do_unconfigure( void ) {
int i; int i;
unsigned int conf; unsigned int conf;
conf = 0; conf = 0;
for (i = 4; i >= 0; i--) { for ( i = 4; i >= 0; i-- ) {
conf <<= 4; conf <<= 4;
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
saturn.mem_cntl[i].unconfigured = conf_tab_sx[i]; saturn.mem_cntl[ i ].unconfigured = conf_tab_sx[ i ];
saturn.mem_cntl[i].config[0] = 0x0; saturn.mem_cntl[ i ].config[ 0 ] = 0x0;
saturn.mem_cntl[i].config[1] = 0x0; saturn.mem_cntl[ i ].config[ 1 ] = 0x0;
break; break;
} }
} }
#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", i, fprintf( stderr,
saturn.mem_cntl[i].config[0], saturn.mem_cntl[i].config[1]); "MEMORY CONTROLLER %d is configured to %.5lx, %.5lx\n", i,
saturn.mem_cntl[ i ].config[ 0 ],
saturn.mem_cntl[ i ].config[ 1 ] );
} }
#endif #endif
} }
void do_configure(void) { void do_configure( void ) {
int i; int i;
unsigned long conf; unsigned long conf;
conf = 0; conf = 0;
for (i = 4; i >= 0; i--) { for ( i = 4; i >= 0; i-- ) {
conf <<= 4; conf <<= 4;
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;
} }
} }
#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", i, fprintf( stderr, "MEMORY CONTROLLER %d at %.5lx, %.5lx\n", 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[] = {0, 0, 0, 0, 0x05, 0xf6, 0x07, 0xf8, 0x01, 0xf2, 0, 0}; static int chip_id[] = { 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;
} }
if (i < 6) if ( i < 6 )
id = chip_id[2 * i + (2 - saturn.mem_cntl[i].unconfigured)]; id = chip_id[ 2 * i + ( 2 - saturn.mem_cntl[ i ].unconfigured ) ];
else else
id = 0; id = 0;
#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", i, fprintf( stderr,
saturn.mem_cntl[i].config[1]); "MEMORY CONTROLLER %d configured to ????? %.5lx\n", i,
saturn.mem_cntl[ i ].config[ 1 ] );
} else } else
fprintf(stderr, "MEMORY CONTROLLER %d configured to %.5lx, %.5lx\n", i, fprintf( stderr,
saturn.mem_cntl[i].config[0], saturn.mem_cntl[i].config[1]); "MEMORY CONTROLLER %d configured to %.5lx, %.5lx\n", 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;
} }
return 0; return 0;
} }
void do_shutdown(void) { void do_shutdown( void ) {
int wake, alarms; int wake, alarms;
t1_t2_ticks ticks; t1_t2_ticks ticks;
if (device.display_touched) { if ( device.display_touched ) {
device.display_touched = 0; device.display_touched = 0;
update_display(); update_display();
#ifdef HAVE_XSHM #ifdef HAVE_XSHM
if (disp.display_update) if ( disp.display_update )
refresh_display(); refresh_display();
#endif #endif
} }
stop_timer(RUN_TIMER); stop_timer( RUN_TIMER );
start_timer(IDLE_TIMER); start_timer( IDLE_TIMER );
if (is_zero_register(saturn.OUT, OUT_FIELD)) { if ( is_zero_register( saturn.OUT, OUT_FIELD ) ) {
#ifdef DEBUG_SHUTDOWN #ifdef DEBUG_SHUTDOWN
fprintf(stderr, "%.5lx: SHUTDN: PC = 0\n", saturn.PC); fprintf( stderr, "%.5lx: SHUTDN: PC = 0\n", saturn.PC );
#endif #endif
saturn.intenable = 1; saturn.intenable = 1;
saturn.int_pending = 0; saturn.int_pending = 0;
} }
#ifdef DEBUG_SHUTDOWN #ifdef DEBUG_SHUTDOWN
fprintf(stderr, "%.5lx:\tSHUTDN: Timer 1 Control = %x, Timer 1 = %d\n", fprintf( stderr, "%.5lx:\tSHUTDN: Timer 1 Control = %x, Timer 1 = %d\n",
saturn.PC, saturn.t1_ctrl, saturn.timer1); saturn.PC, saturn.t1_ctrl, saturn.timer1 );
fprintf(stderr, "%.5lx:\tSHUTDN: Timer 2 Control = %x, Timer 2 = %ld\n", fprintf( stderr, "%.5lx:\tSHUTDN: Timer 2 Control = %x, Timer 2 = %ld\n",
saturn.PC, saturn.t2_ctrl, saturn.timer2); saturn.PC, saturn.t2_ctrl, saturn.timer2 );
#endif #endif
if (in_debugger) if ( in_debugger )
wake = 1; wake = 1;
else else
wake = 0; wake = 0;
@ -432,248 +465,248 @@ void do_shutdown(void) {
pause(); pause();
if (got_alarm) { if ( got_alarm ) {
got_alarm = 0; got_alarm = 0;
#ifdef HAVE_XSHM #ifdef HAVE_XSHM
if (disp.display_update) if ( disp.display_update )
refresh_display(); refresh_display();
#endif #endif
ticks = get_t1_t2(); ticks = get_t1_t2();
if (saturn.t2_ctrl & 0x01) { if ( saturn.t2_ctrl & 0x01 ) {
saturn.timer2 = ticks.t2_ticks; saturn.timer2 = ticks.t2_ticks;
} }
saturn.timer1 = set_t1 - ticks.t1_ticks; saturn.timer1 = set_t1 - ticks.t1_ticks;
set_t1 = ticks.t1_ticks; set_t1 = ticks.t1_ticks;
interrupt_called = 0; interrupt_called = 0;
if (GetEvent()) { if ( GetEvent() ) {
if (interrupt_called) if ( interrupt_called )
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();
} }
} }
if (wake == 0) { if ( wake == 0 ) {
interrupt_called = 0; interrupt_called = 0;
receive_char(); receive_char();
if (interrupt_called) if ( interrupt_called )
wake = 1; wake = 1;
} }
alarms++; alarms++;
} }
if (enter_debugger) { if ( enter_debugger ) {
wake = 1; wake = 1;
} }
} while (wake == 0); } while ( wake == 0 );
stop_timer(IDLE_TIMER); stop_timer( IDLE_TIMER );
start_timer(RUN_TIMER); start_timer( RUN_TIMER );
} }
void set_hardware_stat(int op) { void set_hardware_stat( int op ) {
if (op & 1) if ( op & 1 )
saturn.XM = 1; saturn.XM = 1;
if (op & 2) if ( op & 2 )
saturn.SB = 1; saturn.SB = 1;
if (op & 4) if ( op & 4 )
saturn.SR = 1; saturn.SR = 1;
if (op & 8) if ( op & 8 )
saturn.MP = 1; saturn.MP = 1;
} }
void clear_hardware_stat(int op) { void clear_hardware_stat( int op ) {
if (op & 1) if ( op & 1 )
saturn.XM = 0; saturn.XM = 0;
if (op & 2) if ( op & 2 )
saturn.SB = 0; saturn.SB = 0;
if (op & 4) if ( op & 4 )
saturn.SR = 0; saturn.SR = 0;
if (op & 8) if ( op & 8 )
saturn.MP = 0; saturn.MP = 0;
} }
int is_zero_hardware_stat(int op) { int is_zero_hardware_stat( int op ) {
if (op & 1) if ( op & 1 )
if (saturn.XM != 0) if ( saturn.XM != 0 )
return 0; return 0;
if (op & 2) if ( op & 2 )
if (saturn.SB != 0) if ( saturn.SB != 0 )
return 0; return 0;
if (op & 4) if ( op & 4 )
if (saturn.SR != 0) if ( saturn.SR != 0 )
return 0; return 0;
if (op & 8) if ( op & 8 )
if (saturn.MP != 0) if ( saturn.MP != 0 )
return 0; return 0;
return 1; return 1;
} }
void push_return_addr(long addr) { void push_return_addr( long addr ) {
int i; int i;
if (++saturn.rstkp >= NR_RSTK) { if ( ++saturn.rstkp >= NR_RSTK ) {
#if 0 #if 0
fprintf(stderr, "%.5lx: RSTK overflow !!!\n", saturn.PC); fprintf(stderr, "%.5lx: RSTK overflow !!!\n", saturn.PC);
for (i = saturn.rstkp - 1; i >= 0; i--) { for (i = saturn.rstkp - 1; i >= 0; i--) {
fprintf(stderr, "\tRSTK[%d] %.5lx\n", i, saturn.rstk[i]); fprintf(stderr, "\tRSTK[%d] %.5lx\n", i, saturn.rstk[i]);
} }
#endif #endif
for (i = 1; i < NR_RSTK; i++) for ( i = 1; i < NR_RSTK; i++ )
saturn.rstk[i - 1] = saturn.rstk[i]; saturn.rstk[ i - 1 ] = saturn.rstk[ i ];
saturn.rstkp--; saturn.rstkp--;
} }
saturn.rstk[saturn.rstkp] = addr; saturn.rstk[ saturn.rstkp ] = addr;
#ifdef DEBUG_RSTK #ifdef DEBUG_RSTK
fprintf(stderr, "PUSH %.5x:\n", addr); fprintf( stderr, "PUSH %.5x:\n", addr );
for (i = saturn.rstkp; i >= 0; i--) { for ( i = saturn.rstkp; i >= 0; i-- ) {
fprintf(stderr, "RSTK[%d] %.5x\n", i, saturn.rstk[i]); fprintf( stderr, "RSTK[%d] %.5x\n", i, saturn.rstk[ i ] );
} }
#endif #endif
} }
long pop_return_addr(void) { long pop_return_addr( void ) {
#ifdef DEBUG_RSTK #ifdef DEBUG_RSTK
int i; int i;
for (i = saturn.rstkp; i >= 0; i--) { for ( i = saturn.rstkp; i >= 0; i-- ) {
fprintf(stderr, "RSTK[%d] %.5x\n", i, saturn.rstk[i]); fprintf( stderr, "RSTK[%d] %.5x\n", i, saturn.rstk[ i ] );
} }
fprintf(stderr, "POP %.5x:\n", fprintf( stderr, "POP %.5x:\n",
(saturn.rstkp >= 0) ? saturn.rstk[saturn.rstkp] : 0); ( saturn.rstkp >= 0 ) ? saturn.rstk[ saturn.rstkp ] : 0 );
#endif #endif
if (saturn.rstkp < 0) if ( saturn.rstkp < 0 )
return 0; return 0;
return saturn.rstk[saturn.rstkp--]; return saturn.rstk[ saturn.rstkp-- ];
} }
char *make_hexstr(long addr, int n) { char* make_hexstr( long addr, int n ) {
static char str[44]; static char str[ 44 ];
int i, t, trunc; int i, t, trunc;
trunc = 0; trunc = 0;
if (n > 40) { if ( n > 40 ) {
n = 40; n = 40;
trunc = 1; trunc = 1;
} }
for (i = 0; i < n; i++) { for ( i = 0; i < n; i++ ) {
t = read_nibble(addr + i); t = read_nibble( addr + i );
if (t <= 9) if ( t <= 9 )
str[i] = '0' + t; str[ i ] = '0' + t;
else else
str[i] = 'a' + (t - 10); str[ i ] = 'a' + ( t - 10 );
} }
str[n] = '\0'; str[ n ] = '\0';
if (trunc) { if ( trunc ) {
str[n] = '.'; str[ n ] = '.';
str[n + 1] = '.'; str[ n + 1 ] = '.';
str[n + 2] = '.'; str[ n + 2 ] = '.';
str[n + 3] = '\0'; str[ n + 3 ] = '\0';
} }
return str; return str;
} }
void load_constant(unsigned char *reg, int n, long addr) { void load_constant( unsigned char* reg, int n, long addr ) {
int i, p; int i, p;
p = saturn.P; p = saturn.P;
for (i = 0; i < n; i++) { for ( i = 0; i < n; i++ ) {
reg[p] = read_nibble(addr + i); reg[ p ] = read_nibble( addr + i );
p = (p + 1) & 0xf; p = ( p + 1 ) & 0xf;
} }
} }
void load_addr(word_20 *dat, long addr, int n) { void load_addr( word_20* dat, long addr, int n ) {
int i; int i;
for (i = 0; i < n; i++) { for ( i = 0; i < n; i++ ) {
*dat &= ~nibble_masks[i]; *dat &= ~nibble_masks[ i ];
*dat |= read_nibble(addr + i) << (i * 4); *dat |= read_nibble( addr + i ) << ( i * 4 );
} }
} }
void load_address(unsigned char *reg, long addr, int n) { void load_address( unsigned char* reg, long addr, int n ) {
int i; int i;
for (i = 0; i < n; i++) { for ( i = 0; i < n; i++ ) {
reg[i] = read_nibble(addr + i); reg[ i ] = read_nibble( addr + i );
} }
} }
void register_to_address(unsigned char *reg, word_20 *dat, int s) { void register_to_address( unsigned char* reg, word_20* dat, int s ) {
int i, n; int i, n;
if (s) if ( s )
n = 4; n = 4;
else else
n = 5; n = 5;
for (i = 0; i < n; i++) { for ( i = 0; i < n; i++ ) {
*dat &= ~nibble_masks[i]; *dat &= ~nibble_masks[ i ];
*dat |= (reg[i] & 0x0f) << (i * 4); *dat |= ( reg[ i ] & 0x0f ) << ( i * 4 );
} }
} }
void address_to_register(word_20 dat, unsigned char *reg, int s) { void address_to_register( word_20 dat, unsigned char* reg, int s ) {
int i, n; int i, n;
if (s) if ( s )
n = 4; n = 4;
else else
n = 5; n = 5;
for (i = 0; i < n; i++) { for ( i = 0; i < n; i++ ) {
reg[i] = dat & 0x0f; reg[ i ] = dat & 0x0f;
dat >>= 4; dat >>= 4;
} }
} }
long dat_to_addr(unsigned char *dat) { long dat_to_addr( unsigned char* dat ) {
int i; int i;
long addr; long addr;
addr = 0; addr = 0;
for (i = 4; i >= 0; i--) { for ( i = 4; i >= 0; i-- ) {
addr <<= 4; addr <<= 4;
addr |= (dat[i] & 0xf); addr |= ( dat[ i ] & 0xf );
} }
return addr; return addr;
} }
void addr_to_dat(long addr, unsigned char *dat) { void addr_to_dat( long addr, unsigned char* dat ) {
int i; int i;
for (i = 0; i < 5; i++) { for ( i = 0; i < 5; i++ ) {
dat[i] = (addr & 0xf); dat[ i ] = ( addr & 0xf );
addr >>= 4; addr >>= 4;
} }
} }
void add_address(word_20 *dat, int add) { void add_address( word_20* dat, int add ) {
*dat += add; *dat += add;
if (*dat & (word_20)0xfff00000) { if ( *dat & ( word_20 )0xfff00000 ) {
saturn.CARRY = 1; saturn.CARRY = 1;
} else { } else {
saturn.CARRY = 0; saturn.CARRY = 0;
@ -681,62 +714,62 @@ void add_address(word_20 *dat, int add) {
*dat &= 0xfffff; *dat &= 0xfffff;
} }
static int start_fields[] = {-1, 0, 2, 0, 15, 3, 0, 0, -1, 0, static int start_fields[] = { -1, 0, 2, 0, 15, 3, 0, 0, -1, 0,
2, 0, 15, 3, 0, 0, 0, 0, 0}; 2, 0, 15, 3, 0, 0, 0, 0, 0 };
static int end_fields[] = {-1, -1, 2, 2, 15, 14, 1, 15, -1, -1, static int end_fields[] = { -1, -1, 2, 2, 15, 14, 1, 15, -1, -1,
2, 2, 15, 14, 1, 4, 3, 2, 0}; 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;
if ((s = start_fields[code]) == -1) { if ( ( s = start_fields[ code ] ) == -1 ) {
s = saturn.P; s = saturn.P;
} }
return s; return s;
} }
static inline int get_end(int code) { static inline int get_end( int code ) {
int e; int e;
if ((e = end_fields[code]) == -1) { if ( ( e = end_fields[ code ] ) == -1 ) {
e = saturn.P; e = saturn.P;
} }
return e; return e;
} }
void store(word_20 dat, unsigned char *reg, int code) { void store( word_20 dat, unsigned char* reg, int code ) {
int i, s, e; int i, s, e;
s = get_start(code); s = get_start( code );
e = get_end(code); e = get_end( code );
for (i = s; i <= e; i++) { for ( i = s; i <= e; i++ ) {
write_nibble(dat++, reg[i]); write_nibble( dat++, reg[ i ] );
} }
} }
void store_n(word_20 dat, unsigned char *reg, int n) { void store_n( word_20 dat, unsigned char* reg, int n ) {
int i; int i;
for (i = 0; i < n; i++) { for ( i = 0; i < n; i++ ) {
write_nibble(dat++, reg[i]); write_nibble( dat++, reg[ i ] );
} }
} }
void recall(unsigned char *reg, word_20 dat, int code) { void recall( unsigned char* reg, word_20 dat, int code ) {
int i, s, e; int i, s, e;
s = get_start(code); s = get_start( code );
e = get_end(code); e = get_end( code );
for (i = s; i <= e; i++) { for ( i = s; i <= e; i++ ) {
reg[i] = read_nibble_crc(dat++); reg[ i ] = read_nibble_crc( dat++ );
} }
} }
void recall_n(unsigned char *reg, word_20 dat, int n) { void recall_n( unsigned char* reg, word_20 dat, int n ) {
int i; int i;
for (i = 0; i < n; i++) { for ( i = 0; i < n; i++ ) {
reg[i] = read_nibble_crc(dat++); reg[ i ] = read_nibble_crc( dat++ );
} }
} }

12
src/annunc.h
View file

@ -44,36 +44,36 @@
#define ann_alpha_height 12 #define ann_alpha_height 12
static unsigned char ann_alpha_bits[] = { static unsigned char ann_alpha_bits[] = {
0xe0, 0x03, 0x18, 0x44, 0x0c, 0x4c, 0x06, 0x2c, 0x07, 0x2c, 0x07, 0x1c, 0xe0, 0x03, 0x18, 0x44, 0x0c, 0x4c, 0x06, 0x2c, 0x07, 0x2c, 0x07, 0x1c,
0x07, 0x0c, 0x07, 0x0c, 0x07, 0x0e, 0x0e, 0x4d, 0xf8, 0x38, 0x00, 0x00}; 0x07, 0x0c, 0x07, 0x0c, 0x07, 0x0e, 0x0e, 0x4d, 0xf8, 0x38, 0x00, 0x00 };
#define ann_battery_width 15 #define ann_battery_width 15
#define ann_battery_height 12 #define ann_battery_height 12
static unsigned char ann_battery_bits[] = { static unsigned char ann_battery_bits[] = {
0x04, 0x10, 0x02, 0x20, 0x12, 0x24, 0x09, 0x48, 0xc9, 0x49, 0xc9, 0x49, 0x04, 0x10, 0x02, 0x20, 0x12, 0x24, 0x09, 0x48, 0xc9, 0x49, 0xc9, 0x49,
0xc9, 0x49, 0x09, 0x48, 0x12, 0x24, 0x02, 0x20, 0x04, 0x10, 0x00, 0x00}; 0xc9, 0x49, 0x09, 0x48, 0x12, 0x24, 0x02, 0x20, 0x04, 0x10, 0x00, 0x00 };
#define ann_busy_width 15 #define ann_busy_width 15
#define ann_busy_height 12 #define ann_busy_height 12
static unsigned char ann_busy_bits[] = { static unsigned char ann_busy_bits[] = {
0xfc, 0x1f, 0x08, 0x08, 0x08, 0x08, 0xf0, 0x07, 0xe0, 0x03, 0xc0, 0x01, 0xfc, 0x1f, 0x08, 0x08, 0x08, 0x08, 0xf0, 0x07, 0xe0, 0x03, 0xc0, 0x01,
0x40, 0x01, 0x20, 0x02, 0x10, 0x04, 0xc8, 0x09, 0xe8, 0x0b, 0xfc, 0x1f}; 0x40, 0x01, 0x20, 0x02, 0x10, 0x04, 0xc8, 0x09, 0xe8, 0x0b, 0xfc, 0x1f };
#define ann_io_width 15 #define ann_io_width 15
#define ann_io_height 12 #define ann_io_height 12
static unsigned char ann_io_bits[] = { static unsigned char ann_io_bits[] = {
0x0c, 0x00, 0x1e, 0x00, 0x33, 0x0c, 0x61, 0x18, 0xcc, 0x30, 0xfe, 0x7f, 0x0c, 0x00, 0x1e, 0x00, 0x33, 0x0c, 0x61, 0x18, 0xcc, 0x30, 0xfe, 0x7f,
0xfe, 0x7f, 0xcc, 0x30, 0x61, 0x18, 0x33, 0x0c, 0x1e, 0x00, 0x0c, 0x00}; 0xfe, 0x7f, 0xcc, 0x30, 0x61, 0x18, 0x33, 0x0c, 0x1e, 0x00, 0x0c, 0x00 };
#define ann_left_width 15 #define ann_left_width 15
#define ann_left_height 12 #define ann_left_height 12
static unsigned char ann_left_bits[] = { static unsigned char ann_left_bits[] = {
0xfe, 0x3f, 0xff, 0x7f, 0x9f, 0x7f, 0xcf, 0x7f, 0xe7, 0x7f, 0x03, 0x78, 0xfe, 0x3f, 0xff, 0x7f, 0x9f, 0x7f, 0xcf, 0x7f, 0xe7, 0x7f, 0x03, 0x78,
0x03, 0x70, 0xe7, 0x73, 0xcf, 0x73, 0x9f, 0x73, 0xff, 0x73, 0xfe, 0x33}; 0x03, 0x70, 0xe7, 0x73, 0xcf, 0x73, 0x9f, 0x73, 0xff, 0x73, 0xfe, 0x33 };
#define ann_right_width 15 #define ann_right_width 15
#define ann_right_height 12 #define ann_right_height 12
static unsigned char ann_right_bits[] = { static unsigned char ann_right_bits[] = {
0xfe, 0x3f, 0xff, 0x7f, 0xff, 0x7c, 0xff, 0x79, 0xff, 0x73, 0x0f, 0x60, 0xfe, 0x3f, 0xff, 0x7f, 0xff, 0x7c, 0xff, 0x79, 0xff, 0x73, 0x0f, 0x60,
0x07, 0x60, 0xe7, 0x73, 0xe7, 0x79, 0xe7, 0x7c, 0xe7, 0x7f, 0xe6, 0x3f}; 0x07, 0x60, 0xe7, 0x73, 0xe7, 0x79, 0xe7, 0x7c, 0xe7, 0x7f, 0xe6, 0x3f };
#endif /* !_ANNUNC_H */ #endif /* !_ANNUNC_H */

6
src/append.h
View file

@ -38,8 +38,8 @@
#include "global.h" #include "global.h"
extern char *append_str __ProtoType__((char *buf, char *string)); extern char* append_str __ProtoType__( ( char* buf, char* string ) );
extern char *append_tab __ProtoType__((char *buf)); extern char* append_tab __ProtoType__( ( char* buf ) );
extern char *append_tab_16 __ProtoType__((char *buf)); extern char* append_tab_16 __ProtoType__( ( char* buf ) );
#endif /* !_APPEND_H */ #endif /* !_APPEND_H */

106
src/buttons.h
View file

@ -46,115 +46,115 @@
#define menu_label_width 24 #define menu_label_width 24
#define menu_label_height 11 #define menu_label_height 11
static unsigned char menu_label_bits[] = { static unsigned char menu_label_bits[] = {
0xfe, 0xff, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0x7f}; 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0x7f };
#define up_width 11 #define up_width 11
#define up_height 11 #define up_height 11
static unsigned char up_bits[] = { static unsigned char up_bits[] = {
0x20, 0x00, 0x20, 0x00, 0x70, 0x00, 0x70, 0x00, 0xf8, 0x00, 0xf8, 0x00, 0x20, 0x00, 0x20, 0x00, 0x70, 0x00, 0x70, 0x00, 0xf8, 0x00, 0xf8,
0xfc, 0x01, 0xfc, 0x01, 0xfe, 0x03, 0xfe, 0x03, 0xff, 0x07}; 0x00, 0xfc, 0x01, 0xfc, 0x01, 0xfe, 0x03, 0xfe, 0x03, 0xff, 0x07 };
#define down_width 11 #define down_width 11
#define down_height 11 #define down_height 11
static unsigned char down_bits[] = { static unsigned char down_bits[] = {
0xff, 0x07, 0xfe, 0x03, 0xfe, 0x03, 0xfc, 0x01, 0xfc, 0x01, 0xf8, 0x00, 0xff, 0x07, 0xfe, 0x03, 0xfe, 0x03, 0xfc, 0x01, 0xfc, 0x01, 0xf8,
0xf8, 0x00, 0x70, 0x00, 0x70, 0x00, 0x20, 0x00, 0x20, 0x00}; 0x00, 0xf8, 0x00, 0x70, 0x00, 0x70, 0x00, 0x20, 0x00, 0x20, 0x00 };
#define left_width 11 #define left_width 11
#define left_height 11 #define left_height 11
static unsigned char left_bits[] = { static unsigned char left_bits[] = {
0x00, 0x04, 0x00, 0x07, 0xc0, 0x07, 0xf0, 0x07, 0xfc, 0x07, 0xff, 0x07, 0x00, 0x04, 0x00, 0x07, 0xc0, 0x07, 0xf0, 0x07, 0xfc, 0x07, 0xff,
0xfc, 0x07, 0xf0, 0x07, 0xc0, 0x07, 0x00, 0x07, 0x00, 0x04}; 0x07, 0xfc, 0x07, 0xf0, 0x07, 0xc0, 0x07, 0x00, 0x07, 0x00, 0x04 };
#define right_width 11 #define right_width 11
#define right_height 11 #define right_height 11
static unsigned char right_bits[] = { static unsigned char right_bits[] = {
0x01, 0x00, 0x07, 0x00, 0x1f, 0x00, 0x7f, 0x00, 0xff, 0x01, 0xff, 0x07, 0x01, 0x00, 0x07, 0x00, 0x1f, 0x00, 0x7f, 0x00, 0xff, 0x01, 0xff,
0xff, 0x01, 0x7f, 0x00, 0x1f, 0x00, 0x07, 0x00, 0x01, 0x00}; 0x07, 0xff, 0x01, 0x7f, 0x00, 0x1f, 0x00, 0x07, 0x00, 0x01, 0x00 };
#define sqrt_width 20 #define sqrt_width 20
#define sqrt_height 11 #define sqrt_height 11
static unsigned char sqrt_bits[] = { static unsigned char sqrt_bits[] = {
0x00, 0xff, 0x0f, 0x00, 0x01, 0x08, 0x00, 0x01, 0x08, 0x80, 0x8c, 0x01, 0x00, 0xff, 0x0f, 0x00, 0x01, 0x08, 0x00, 0x01, 0x08, 0x80, 0x8c,
0x80, 0x58, 0x01, 0x80, 0x38, 0x00, 0x47, 0x30, 0x00, 0x4c, 0x30, 0x00, 0x01, 0x80, 0x58, 0x01, 0x80, 0x38, 0x00, 0x47, 0x30, 0x00, 0x4c,
0x58, 0x78, 0x00, 0x30, 0x6a, 0x01, 0x20, 0xc6, 0x00}; 0x30, 0x00, 0x58, 0x78, 0x00, 0x30, 0x6a, 0x01, 0x20, 0xc6, 0x00 };
#define power_width 17 #define power_width 17
#define power_height 14 #define power_height 14
static unsigned char power_bits[] = { static unsigned char power_bits[] = {
0x00, 0x8c, 0x01, 0x00, 0x58, 0x01, 0x00, 0x38, 0x00, 0xc8, 0x30, 0x00, 0x00, 0x8c, 0x01, 0x00, 0x58, 0x01, 0x00, 0x38, 0x00, 0xc8, 0x30,
0x9c, 0x30, 0x00, 0x98, 0x78, 0x00, 0x58, 0x6a, 0x01, 0x58, 0xc6, 0x00, 0x00, 0x9c, 0x30, 0x00, 0x98, 0x78, 0x00, 0x58, 0x6a, 0x01, 0x58,
0x38, 0x00, 0x00, 0x30, 0x00, 0x00, 0x10, 0x00, 0x00, 0x08, 0x00, 0x00, 0xc6, 0x00, 0x38, 0x00, 0x00, 0x30, 0x00, 0x00, 0x10, 0x00, 0x00,
0x05, 0x00, 0x00, 0x03, 0x00, 0x00}; 0x08, 0x00, 0x00, 0x05, 0x00, 0x00, 0x03, 0x00, 0x00 };
#define inv_width 18 #define inv_width 18
#define inv_height 13 #define inv_height 13
static unsigned char inv_bits[] = { static unsigned char inv_bits[] = {
0x0c, 0x04, 0x00, 0x0f, 0x06, 0x00, 0x0c, 0x02, 0x00, 0x0c, 0x03, 0x00, 0x0c, 0x04, 0x00, 0x0f, 0x06, 0x00, 0x0c, 0x02, 0x00, 0x0c,
0x0c, 0x01, 0x00, 0x8c, 0x19, 0x03, 0x8c, 0xb0, 0x02, 0xcc, 0x70, 0x00, 0x03, 0x00, 0x0c, 0x01, 0x00, 0x8c, 0x19, 0x03, 0x8c, 0xb0,
0x40, 0x60, 0x00, 0x60, 0x60, 0x00, 0x20, 0xf0, 0x00, 0x30, 0xd4, 0x02, 0x02, 0xcc, 0x70, 0x00, 0x40, 0x60, 0x00, 0x60, 0x60, 0x00,
0x10, 0x8c, 0x01}; 0x20, 0xf0, 0x00, 0x30, 0xd4, 0x02, 0x10, 0x8c, 0x01 };
#define neg_width 21 #define neg_width 21
#define neg_height 11 #define neg_height 11
static unsigned char neg_bits[] = { static unsigned char neg_bits[] = {
0x18, 0x00, 0x00, 0x18, 0x30, 0x00, 0x18, 0x30, 0x00, 0xff, 0x18, 0x00, 0x18, 0x00, 0x00, 0x18, 0x30, 0x00, 0x18, 0x30, 0x00, 0xff, 0x18,
0xff, 0x18, 0x00, 0x18, 0x0c, 0x00, 0x18, 0x0c, 0x00, 0x18, 0xc6, 0x1f, 0x00, 0xff, 0x18, 0x00, 0x18, 0x0c, 0x00, 0x18, 0x0c, 0x00, 0x18,
0x00, 0xc6, 0x1f, 0x00, 0x03, 0x00, 0x00, 0x03, 0x00}; 0xc6, 0x1f, 0x00, 0xc6, 0x1f, 0x00, 0x03, 0x00, 0x00, 0x03, 0x00 };
#define bs_width 11 #define bs_width 11
#define bs_height 11 #define bs_height 11
static unsigned char bs_bits[] = { static unsigned char bs_bits[] = {
0x20, 0x00, 0x30, 0x00, 0x38, 0x00, 0xfc, 0x07, 0xfe, 0x07, 0xff, 0x07, 0x20, 0x00, 0x30, 0x00, 0x38, 0x00, 0xfc, 0x07, 0xfe, 0x07, 0xff,
0xfe, 0x07, 0xfc, 0x07, 0x38, 0x00, 0x30, 0x00, 0x20, 0x00}; 0x07, 0xfe, 0x07, 0xfc, 0x07, 0x38, 0x00, 0x30, 0x00, 0x20, 0x00 };
#define alpha_width 12 #define alpha_width 12
#define alpha_height 10 #define alpha_height 10
static unsigned char alpha_bits[] = { static unsigned char alpha_bits[] = { 0x78, 0x00, 0x84, 0x08, 0x82, 0x09, 0x83,
0x78, 0x00, 0x84, 0x08, 0x82, 0x09, 0x83, 0x05, 0x83, 0x05, 0x83, 0x03, 0x05, 0x83, 0x05, 0x83, 0x03, 0x83, 0x01,
0x83, 0x01, 0x83, 0x01, 0x46, 0x09, 0x3c, 0x06}; 0x83, 0x01, 0x46, 0x09, 0x3c, 0x06 };
#define div_width 10 #define div_width 10
#define div_height 10 #define div_height 10
static unsigned char div_bits[] = { static unsigned char div_bits[] = { 0x30, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00,
0x30, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x03, 0xff, 0x03, 0x00, 0xff, 0x03, 0xff, 0x03, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x30, 0x00}; 0x00, 0x00, 0x30, 0x00, 0x30, 0x00 };
#define shl_width 24 #define shl_width 24
#define shl_height 14 #define shl_height 14
static unsigned char shl_bits[] = { static unsigned char shl_bits[] = {
0xfe, 0xff, 0x7f, 0xff, 0xfc, 0xff, 0x7f, 0xfc, 0xff, 0x3f, 0xfe, 0xff, 0xfe, 0xff, 0x7f, 0xff, 0xfc, 0xff, 0x7f, 0xfc, 0xff, 0x3f, 0xfe,
0x1f, 0xff, 0xff, 0x0f, 0x00, 0xfc, 0x07, 0x00, 0xf8, 0x0f, 0x00, 0xf0, 0xff, 0x1f, 0xff, 0xff, 0x0f, 0x00, 0xfc, 0x07, 0x00, 0xf8, 0x0f,
0x1f, 0xff, 0xf1, 0x3f, 0xfe, 0xf1, 0x7f, 0xfc, 0xf1, 0xff, 0xfc, 0xf1, 0x00, 0xf0, 0x1f, 0xff, 0xf1, 0x3f, 0xfe, 0xf1, 0x7f, 0xfc, 0xf1,
0xff, 0xff, 0xf1, 0xfe, 0xff, 0x71}; 0xff, 0xfc, 0xf1, 0xff, 0xff, 0xf1, 0xfe, 0xff, 0x71 };
#define mul_width 10 #define mul_width 10
#define mul_height 10 #define mul_height 10
static unsigned char mul_bits[] = { static unsigned char mul_bits[] = { 0x03, 0x03, 0x87, 0x03, 0xce, 0x01, 0xfc,
0x03, 0x03, 0x87, 0x03, 0xce, 0x01, 0xfc, 0x00, 0x78, 0x00, 0x78, 0x00, 0x00, 0x78, 0x00, 0x78, 0x00, 0xfc, 0x00,
0xfc, 0x00, 0xce, 0x01, 0x87, 0x03, 0x03, 0x03}; 0xce, 0x01, 0x87, 0x03, 0x03, 0x03 };
#define shr_width 24 #define shr_width 24
#define shr_height 14 #define shr_height 14
static unsigned char shr_bits[] = { static unsigned char shr_bits[] = {
0xfe, 0xff, 0x7f, 0xff, 0x3f, 0xff, 0xff, 0x3f, 0xfe, 0xff, 0x7f, 0xfc, 0xfe, 0xff, 0x7f, 0xff, 0x3f, 0xff, 0xff, 0x3f, 0xfe, 0xff, 0x7f,
0xff, 0xff, 0xf8, 0x3f, 0x00, 0xf0, 0x1f, 0x00, 0xe0, 0x0f, 0x00, 0xf0, 0xfc, 0xff, 0xff, 0xf8, 0x3f, 0x00, 0xf0, 0x1f, 0x00, 0xe0, 0x0f,
0x8f, 0xff, 0xf8, 0x8f, 0x7f, 0xfc, 0x8f, 0x3f, 0xfe, 0x8f, 0x3f, 0xff, 0x00, 0xf0, 0x8f, 0xff, 0xf8, 0x8f, 0x7f, 0xfc, 0x8f, 0x3f, 0xfe,
0x8f, 0xff, 0xff, 0x8e, 0xff, 0x7f}; 0x8f, 0x3f, 0xff, 0x8f, 0xff, 0xff, 0x8e, 0xff, 0x7f };
#define minus_width 10 #define minus_width 10
#define minus_height 10 #define minus_height 10
static unsigned char minus_bits[] = { static unsigned char minus_bits[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x03, 0xff, 0x03, 0x00, 0xff, 0x03, 0xff, 0x03, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
#define plus_width 10 #define plus_width 10
#define plus_height 10 #define plus_height 10
static unsigned char plus_bits[] = { static unsigned char plus_bits[] = { 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30,
0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0xff, 0x03, 0xff, 0x03, 0x00, 0xff, 0x03, 0xff, 0x03, 0x30, 0x00,
0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00}; 0x30, 0x00, 0x30, 0x00, 0x30, 0x00 };
#define last_width 120 #define last_width 120
#define last_height 6 #define last_height 6
@ -166,11 +166,11 @@ static unsigned char last_bits[] = {
0x00, 0x00, 0x00, 0x10, 0x8f, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x10, 0x8f, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x29, 0x09, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x29, 0x09, 0x00, 0x00, 0x00,
0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0xc9, 0x08, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0xc9, 0x08,
0x00, 0x00, 0x00, 0x00, 0x00, 0x80}; 0x00, 0x00, 0x00, 0x00, 0x00, 0x80 };
#define colon_width 2 #define colon_width 2
#define colon_height 10 #define colon_height 10
static unsigned char colon_bits[] = { static unsigned char colon_bits[] = { 0x03, 0x03, 0x03, 0x03, 0x00,
0x03, 0x03, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; 0x00, 0x00, 0x00, 0x00, 0x00 };
#endif /* !_BUTTONS_H */ #endif /* !_BUTTONS_H */

72
src/checkrom.c
View file

@ -45,89 +45,91 @@
#include "global.h" #include "global.h"
#include "romio.h" #include "romio.h"
unsigned char *rom; unsigned char* rom;
unsigned short rom_crc, crc; unsigned short rom_crc, crc;
int verbose = 0; int verbose = 0;
char *progname; char* progname;
#define calc_crc(n) (crc = ((crc >> 4) ^ (((crc ^ n) & 0xf) * 0x1081))) #define calc_crc( n ) \
( crc = ( ( crc >> 4 ) ^ ( ( ( crc ^ n ) & 0xf ) * 0x1081 ) ) )
int main(int argc, char **argv) { int main( int argc, char** argv ) {
unsigned char version[7]; unsigned char version[ 7 ];
long ver_addr; long ver_addr;
int i, a, c, d, d0, d1, D0, D1; int i, a, c, d, d0, d1, D0, D1;
int fail; int fail;
if (argc < 2) { if ( argc < 2 ) {
fprintf(stderr, "usage: %s rom-file\n", argv[0]); fprintf( stderr, "usage: %s rom-file\n", argv[ 0 ] );
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 ],
exit(1); argv[ 1 ] );
exit( 1 );
} }
if (opt_gx != 0) if ( opt_gx != 0 )
ver_addr = 0x7ffbf; ver_addr = 0x7ffbf;
else else
ver_addr = 0x7fff0; ver_addr = 0x7fff0;
for (i = 0; i < 6; i++) { for ( i = 0; i < 6; i++ ) {
version[i] = rom[ver_addr + 2 * i + 1] << 4; version[ i ] = rom[ ver_addr + 2 * i + 1 ] << 4;
version[i] |= rom[ver_addr + 2 * i]; version[ i ] |= rom[ ver_addr + 2 * i ];
} }
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;
} }
fail = a = 0; fail = a = 0;
D0 = 0x00000; D0 = 0x00000;
D1 = 0x40000; D1 = 0x40000;
for (d = 1; d <= rom_size / 0x80000; d++) { for ( d = 1; d <= rom_size / 0x80000; d++ ) {
crc = 0x0000; crc = 0x0000;
rom_crc = 0; rom_crc = 0;
for (i = 0; i < 4; i++) { for ( i = 0; i < 4; i++ ) {
rom_crc <<= 4; rom_crc <<= 4;
rom_crc |= (rom[0x80000 * d - i - 1] & 0x0f); rom_crc |= ( rom[ 0x80000 * d - i - 1 ] & 0x0f );
} }
if (opt_gx) if ( opt_gx )
printf("ROM CRC %d reads 0x%.4x\n", d, rom_crc); printf( "ROM CRC %d reads 0x%.4x\n", d, rom_crc );
else else
printf("ROM CRC reads 0x%.4x\n", rom_crc); printf( "ROM CRC reads 0x%.4x\n", rom_crc );
d0 = D0; d0 = D0;
d1 = D1; d1 = D1;
for (c = 0x3fff; c >= 0x0000; c--) { for ( c = 0x3fff; c >= 0x0000; c-- ) {
for (i = 0; i < 16; i++) { for ( i = 0; i < 16; i++ ) {
calc_crc(rom[d0 + i]); calc_crc( rom[ d0 + i ] );
} }
d0 += 16; d0 += 16;
for (i = 0; i < 16; i++) { for ( i = 0; i < 16; i++ ) {
calc_crc(rom[d1 + i]); calc_crc( rom[ d1 + i ] );
} }
d1 += 16; d1 += 16;
} }
D0 += 0x80000; D0 += 0x80000;
D1 += 0x80000; D1 += 0x80000;
a = crc; a = crc;
a = ((a | 0xf0000) + 1) & 0xfffff; a = ( ( a | 0xf0000 ) + 1 ) & 0xfffff;
if (a != 0x00000) { if ( a != 0x00000 ) {
fail++; fail++;
} }
} }
if (fail != 0) if ( fail != 0 )
printf("IROM %.4x: ROM CRC test FAILED !!!\n", a & 0xffff); printf( "IROM %.4x: ROM CRC test FAILED !!!\n", a & 0xffff );
else else
printf("IROM OK: ROM CRC test passed.\n"); printf( "IROM OK: ROM CRC test passed.\n" );
return 0; return 0;
} }

4
src/config.h
View file

@ -140,10 +140,10 @@
#define SELECT_TYPE_ARG1 int #define SELECT_TYPE_ARG1 int
/* Define to the type of args 2, 3 and 4 for `select'. */ /* Define to the type of args 2, 3 and 4 for `select'. */
#define SELECT_TYPE_ARG234 (fd_set *) #define SELECT_TYPE_ARG234 ( fd_set* )
/* Define to the type of arg 5 for `select'. */ /* Define to the type of arg 5 for `select'. */
#define SELECT_TYPE_ARG5 (struct timeval *) #define SELECT_TYPE_ARG5 ( struct timeval* )
/* Define to 1 if all of the C90 standard headers exist (not just the ones /* Define to 1 if all of the C90 standard headers exist (not just the ones
required in a freestanding environment). This macro is provided for required in a freestanding environment). This macro is provided for

1301
src/debugger.c
View file

File diff suppressed because it is too large Load diff

8
src/debugger.h
View file

@ -57,10 +57,10 @@ extern int enter_debugger;
extern int in_debugger; extern int in_debugger;
extern int exec_flags; extern int exec_flags;
extern void init_debugger __ProtoType__((void)); extern void init_debugger __ProtoType__( ( void ));
extern int debug __ProtoType__((void)); extern int debug __ProtoType__( ( void ));
extern int emulate_debug __ProtoType__((void)); extern int emulate_debug __ProtoType__( ( void ));
extern char *str_nibbles __ProtoType__((word_20 addr, int n)); extern char* str_nibbles __ProtoType__( ( word_20 addr, int n ) );
#endif /* !_DEBUGGER_H */ #endif /* !_DEBUGGER_H */

30
src/device.c
View file

@ -63,48 +63,48 @@ extern int device_check;
device_t device; device_t device;
void check_devices(void) { void check_devices( void ) {
if (device.display_touched > 0 && device.display_touched-- == 1) { if ( device.display_touched > 0 && device.display_touched-- == 1 ) {
device.display_touched = 0; device.display_touched = 0;
update_display(); update_display();
} }
if (device.display_touched > 0) { if ( device.display_touched > 0 ) {
device_check = 1; device_check = 1;
} }
if (device.contrast_touched) { if ( device.contrast_touched ) {
device.contrast_touched = 0; device.contrast_touched = 0;
adjust_contrast(display.contrast); adjust_contrast( display.contrast );
} }
if (device.ann_touched) { if ( device.ann_touched ) {
device.ann_touched = 0; device.ann_touched = 0;
draw_annunc(); draw_annunc();
} }
if (device.baud_touched) { if ( device.baud_touched ) {
device.baud_touched = 0; device.baud_touched = 0;
serial_baud(saturn.baud); serial_baud( saturn.baud );
} }
if (device.ioc_touched) { if ( device.ioc_touched ) {
device.ioc_touched = 0; device.ioc_touched = 0;
if ((saturn.io_ctrl & 0x02) && (saturn.rcs & 0x01)) { if ( ( saturn.io_ctrl & 0x02 ) && ( saturn.rcs & 0x01 ) ) {
do_interupt(); do_interupt();
} }
} }
if (device.rbr_touched) { if ( device.rbr_touched ) {
device.rbr_touched = 0; device.rbr_touched = 0;
receive_char(); receive_char();
} }
if (device.tbr_touched) { if ( device.tbr_touched ) {
device.tbr_touched = 0; device.tbr_touched = 0;
transmit_char(); transmit_char();
} }
if (device.t1_touched) { if ( device.t1_touched ) {
saturn.t1_instr = 0; saturn.t1_instr = 0;
sched_timer1 = saturn.t1_tick; sched_timer1 = saturn.t1_tick;
restart_timer(T1_TIMER); restart_timer( T1_TIMER );
set_t1 = saturn.timer1; set_t1 = saturn.timer1;
device.t1_touched = 0; device.t1_touched = 0;
} }
if (device.t2_touched) { if ( device.t2_touched ) {
saturn.t2_instr = 0; saturn.t2_instr = 0;
sched_timer2 = saturn.t2_tick; sched_timer2 = saturn.t2_tick;
device.t2_touched = 0; device.t2_touched = 0;

14
src/device.h
View file

@ -117,16 +117,16 @@ typedef struct device_t {
} device_t; } device_t;
extern device_t device; extern device_t device;
extern void check_devices __ProtoType__((void)); extern void check_devices __ProtoType__( ( void ));
#if 0 #if 0
extern void check_out_register __ProtoType__((void)); extern void check_out_register __ProtoType__((void));
#endif #endif
extern void update_display __ProtoType__((void)); extern void update_display __ProtoType__( ( void ));
extern void redraw_display __ProtoType__((void)); extern void redraw_display __ProtoType__( ( void ));
extern void disp_draw_nibble __ProtoType__((word_20 addr, word_4 val)); extern void disp_draw_nibble __ProtoType__( ( word_20 addr, word_4 val ) );
extern void menu_draw_nibble __ProtoType__((word_20 addr, word_4 val)); extern void menu_draw_nibble __ProtoType__( ( word_20 addr, word_4 val ) );
extern void draw_annunc __ProtoType__((void)); extern void draw_annunc __ProtoType__( ( void ));
extern void redraw_annunc __ProtoType__((void)); extern void redraw_annunc __ProtoType__( ( void ));
#endif /* !_DEVICE_H */ #endif /* !_DEVICE_H */

1393
src/disasm.c
View file

File diff suppressed because it is too large Load diff

4
src/disasm.h
View file

@ -44,8 +44,8 @@
#define CLASS_MNEMONICS 1 #define CLASS_MNEMONICS 1
extern int disassembler_mode; extern int disassembler_mode;
extern char *mode_name[]; extern char* mode_name[];
extern word_20 disassemble __ProtoType__((word_20 addr, char *out)); extern word_20 disassemble __ProtoType__( ( word_20 addr, char* out ) );
#endif /* !_DISASM_H */ #endif /* !_DISASM_H */

139
src/dump2rom.c
View file

@ -53,143 +53,148 @@
#include <unistd.h> #include <unistd.h>
#include <fcntl.h> #include <fcntl.h>
unsigned char *core; unsigned char* core;
#define DEFAULT_ROM_FILE "rom.dump" #define DEFAULT_ROM_FILE "rom.dump"
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;
unsigned char *tmp_mem; unsigned char* tmp_mem;
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 ==
for (i = 0, j = 0; i < size / 2; i++) { ( tmp_mem = ( unsigned char* )malloc( ( size_t )size / 2 ) ) ) {
byte = (mem[j++] & 0x0f); for ( i = 0, j = 0; i < size / 2; i++ ) {
byte |= (mem[j++] << 4) & 0xf0; byte = ( mem[ j++ ] & 0x0f );
if (1 != fwrite(&byte, 1, 1, fp)) { byte |= ( mem[ j++ ] << 4 ) & 0xf0;
fprintf(stderr, "can\'t write %s\n", name); if ( 1 != fwrite( &byte, 1, 1, fp ) ) {
fclose(fp); fprintf( stderr, "can\'t write %s\n", name );
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 );
return 0; return 0;
} }
free(tmp_mem); free( tmp_mem );
} }
fclose(fp); fclose( fp );
return 1; return 1;
} }
int main(int argc, char **argv) { int main( int argc, char** argv ) {
FILE *dump; FILE* dump;
long addr, size; long addr, size;
int ch, i, gx, error; int ch, i, gx, error;
if (argc < 2) { if ( argc < 2 ) {
fprintf(stderr, "usage: %s hp48-dump-file\n", argv[0]); fprintf( stderr, "usage: %s hp48-dump-file\n", argv[ 0 ] );
exit(1); exit( 1 );
} }
if ((dump = fopen(argv[1], "r")) == NULL) { if ( ( dump = fopen( argv[ 1 ], "r" ) ) == NULL ) {
fprintf(stderr, "%s: can\'t open %s\n", argv[0], argv[1]); fprintf( stderr, "%s: can\'t open %s\n", argv[ 0 ], argv[ 1 ] );
exit(1); exit( 1 );
} }
if ((core = (unsigned char *)malloc(0x100000)) == NULL) { if ( ( core = ( unsigned char* )malloc( 0x100000 ) ) == NULL ) {
fprintf(stderr, "%s: can\'t malloc %d bytes\n", argv[0], 0x100000); fprintf( stderr, "%s: can\'t malloc %d bytes\n", argv[ 0 ], 0x100000 );
exit(1); exit( 1 );
} }
memset(core, 0, 0x100000); memset( core, 0, 0x100000 );
gx = 0; gx = 0;
error = 0; error = 0;
while (1) { while ( 1 ) {
addr = 0; addr = 0;
for (i = 0; i < 5; i++) { for ( i = 0; i < 5; i++ ) {
addr <<= 4; addr <<= 4;
if ((ch = fgetc(dump)) < 0) { if ( ( ch = fgetc( dump ) ) < 0 ) {
error = 1; error = 1;
break; break;
} }
if (ch >= '0' && ch <= '9') { if ( ch >= '0' && ch <= '9' ) {
addr |= ch - '0'; addr |= ch - '0';
} else if (ch >= 'A' && ch <= 'F') { } else if ( ch >= 'A' && ch <= 'F' ) {
addr |= ch - 'A' + 10; addr |= ch - 'A' + 10;
} else { } else {
fprintf(stderr, "%s: Illegal char %c at %lx\n", argv[0], ch, addr); fprintf( stderr, "%s: Illegal char %c at %lx\n", argv[ 0 ], ch,
addr );
error = 1; error = 1;
break; break;
} }
} }
if (error) if ( error )
break; break;
if (addr >= 0x80000) if ( addr >= 0x80000 )
gx = 1; gx = 1;
if ((ch = fgetc(dump)) < 0) { if ( ( ch = fgetc( dump ) ) < 0 ) {
fprintf(stderr, "%s: Unexpected EOF at %lx\n", argv[0], addr); fprintf( stderr, "%s: Unexpected EOF at %lx\n", argv[ 0 ], addr );
break; break;
} }
if (ch != ':') { if ( ch != ':' ) {
fprintf(stderr, "%s: Illegal char %c, expected \':\' at %lx\n", argv[0], fprintf( stderr, "%s: Illegal char %c, expected \':\' at %lx\n",
ch, addr); argv[ 0 ], ch, addr );
break; break;
} }
for (i = 0; i < 16; i++) { for ( i = 0; i < 16; i++ ) {
if ((ch = fgetc(dump)) < 0) { if ( ( ch = fgetc( dump ) ) < 0 ) {
fprintf(stderr, "%s: Unexpected EOF at %lx\n", argv[0], addr); fprintf( stderr, "%s: Unexpected EOF at %lx\n", argv[ 0 ],
addr );
error = 1; error = 1;
break; break;
} }
if (ch >= '0' && ch <= '9') { if ( ch >= '0' && ch <= '9' ) {
core[addr++] = ch - '0'; core[ addr++ ] = ch - '0';
} else if (ch >= 'A' && ch <= 'F') { } else if ( ch >= 'A' && ch <= 'F' ) {
core[addr++] = ch - 'A' + 10; core[ addr++ ] = ch - 'A' + 10;
} else { } else {
fprintf(stderr, "%s: Illegal char %c at %lx\n", argv[0], ch, addr); fprintf( stderr, "%s: Illegal char %c at %lx\n", argv[ 0 ], ch,
addr );
error = 1; error = 1;
break; break;
} }
} }
if (error) if ( error )
break; break;
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", argv[0], fprintf( stderr, "%s: Illegal char %c, expected \'\\n\' at %lx\n",
ch, addr); argv[ 0 ], ch, addr );
break; break;
} }
} }
if (!gx) if ( !gx )
if (core[0x29] == 0x0) if ( core[ 0x29 ] == 0x0 )
gx = 1; gx = 1;
if (gx) if ( gx )
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 ],
exit(1); DEFAULT_ROM_FILE );
exit( 1 );
} }
exit(0); exit( 0 );
} }

1406
src/emulate.c
View file

File diff suppressed because it is too large Load diff

24
src/errors.c
View file

@ -31,26 +31,26 @@
#include "global.h" #include "global.h"
#include "resources.h" #include "resources.h"
char errbuf[1024] = { char errbuf[ 1024 ] = {
0, 0,
}; };
char fixbuf[1024] = { char fixbuf[ 1024 ] = {
0, 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 );
} }
fprintf(stderr, "%s: FATAL ERROR, exit.\n - %s\n", progname, errbuf); fprintf( stderr, "%s: FATAL ERROR, exit.\n - %s\n", progname, errbuf );
if (fixbuf[0] != '\0') if ( fixbuf[ 0 ] != '\0' )
fprintf(stderr, " - %s\n", fixbuf); fprintf( stderr, " - %s\n", fixbuf );
exit(1); exit( 1 );
} }

6
src/errors.h
View file

@ -29,9 +29,9 @@
#include "global.h" #include "global.h"
extern char errbuf[1024]; extern char errbuf[ 1024 ];
extern char fixbuf[1024]; extern char fixbuf[ 1024 ];
extern void fatal_exit __ProtoType__((void)); extern void fatal_exit __ProtoType__( ( void ));
#endif /* !_ERRORS_H */ #endif /* !_ERRORS_H */

52
src/global.h
View file

@ -45,11 +45,11 @@
#include "config.h" #include "config.h"
#define __ProtoType__(x) x #define __ProtoType__( x ) x
#if !defined(__GNUC__) || defined(__STRICT_ANSI__) #if !defined( __GNUC__ ) || defined( __STRICT_ANSI__ )
#define inline #define inline
#if !defined(__STDC__) #if !defined( __STDC__ )
#define const #define const
#endif #endif
#endif #endif
@ -57,7 +57,7 @@
/* /*
* If we are running Linux, `linux' will be defined by gcc. * If we are running Linux, `linux' will be defined by gcc.
*/ */
#if defined(linux) #if defined( linux )
#ifndef LINUX #ifndef LINUX
#define LINUX 1 #define LINUX 1
@ -67,9 +67,9 @@
#else /* Not Linux */ #else /* Not Linux */
#if defined(sun) && defined(unix) #if defined( sun ) && defined( unix )
#if defined(__svr4__) || defined(SVR4) || defined(SYSV) #if defined( __svr4__ ) || defined( SVR4 ) || defined( SYSV )
#ifndef SOLARIS #ifndef SOLARIS
#define SOLARIS 1 #define SOLARIS 1
@ -79,7 +79,7 @@
#else /* Not Solaris */ #else /* Not Solaris */
#if defined(hpux) #if defined( hpux )
#ifndef HPUX #ifndef HPUX
#define HPUX 1 #define HPUX 1
@ -108,28 +108,28 @@
#include <stdio.h> #include <stdio.h>
#include <sys/time.h> #include <sys/time.h>
#include <sys/types.h> #include <sys/types.h>
extern int printf __ProtoType__((char *, ...)); extern int printf __ProtoType__( ( char*, ... ) );
extern int fprintf __ProtoType__((FILE *, char *, ...)); extern int fprintf __ProtoType__( ( FILE*, char*, ... ) );
extern int sscanf __ProtoType__((char *, char *, ...)); extern int sscanf __ProtoType__( ( char*, char*, ... ) );
extern void fflush __ProtoType__((FILE *)); extern void fflush __ProtoType__( ( FILE* ));
extern int fseek __ProtoType__((FILE *, long, int)); extern int fseek __ProtoType__( ( FILE*, long, int ));
extern int fread __ProtoType__((void *, int, int, FILE *)); extern int fread __ProtoType__( ( void*, int, int, FILE* ));
extern int fwrite __ProtoType__((void *, int, int, FILE *)); extern int fwrite __ProtoType__( ( void*, int, int, FILE* ));
extern void fclose __ProtoType__((FILE *)); 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 *, fd_set *, extern int select __ProtoType__( ( int, 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 ));
#ifdef HAVE_XSHM #ifdef HAVE_XSHM
#include <sys/ipc.h> #include <sys/ipc.h>
#include <sys/shm.h> #include <sys/shm.h>
extern int shmget __ProtoType__((key_t, int, int)); extern int shmget __ProtoType__( ( key_t, int, int ));
extern int shmat __ProtoType__((int, void *, int)); extern int shmat __ProtoType__( ( int, void*, int ));
extern int shmctl __ProtoType__((int, int, struct shmid_ds *)); extern int shmctl __ProtoType__( ( int, int, struct shmid_ds* ));
#endif #endif
#endif #endif

32
src/hp.h
View file

@ -66,7 +66,7 @@ static unsigned char hp_bits[] = {
0xfc, 0xcf, 0xf0, 0x7f, 0x60, 0x30, 0xcc, 0x6c, 0x6c, 0xd8, 0xd8, 0x18, 0xfc, 0xcf, 0xf0, 0x7f, 0x60, 0x30, 0xcc, 0x6c, 0x6c, 0xd8, 0xd8, 0x18,
0xf8, 0x6f, 0xfe, 0x3f, 0x60, 0x30, 0x8c, 0x67, 0x78, 0xd8, 0xd8, 0x0f, 0xf8, 0x6f, 0xfe, 0x3f, 0x60, 0x30, 0x8c, 0x67, 0x78, 0xd8, 0xd8, 0x0f,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
#define hp48sx_width 42 #define hp48sx_width 42
#define hp48sx_height 10 #define hp48sx_height 10
@ -75,7 +75,7 @@ static unsigned char hp48sx_bits[] = {
0xf8, 0x39, 0xe7, 0x70, 0xee, 0x00, 0xdc, 0x39, 0xe7, 0x00, 0x7e, 0x00, 0xf8, 0x39, 0xe7, 0x70, 0xee, 0x00, 0xdc, 0x39, 0xe7, 0x00, 0x7e, 0x00,
0xee, 0xf0, 0xe3, 0x0f, 0x3c, 0x00, 0xe7, 0xf8, 0xc1, 0x1f, 0x1c, 0x00, 0xee, 0xf0, 0xe3, 0x0f, 0x3c, 0x00, 0xe7, 0xf8, 0xc1, 0x1f, 0x1c, 0x00,
0xff, 0x9d, 0x03, 0x1c, 0x3e, 0x00, 0xff, 0x9d, 0x3b, 0x1c, 0x3f, 0x00, 0xff, 0x9d, 0x03, 0x1c, 0x3e, 0x00, 0xff, 0x9d, 0x3b, 0x1c, 0x3f, 0x00,
0x70, 0xfc, 0xfb, 0x9f, 0x73, 0x00, 0x70, 0xf8, 0xf1, 0xcf, 0x71, 0x00}; 0x70, 0xfc, 0xfb, 0x9f, 0x73, 0x00, 0x70, 0xf8, 0xf1, 0xcf, 0x71, 0x00 };
#define hp48gx_width 44 #define hp48gx_width 44
#define hp48gx_height 14 #define hp48gx_height 14
@ -86,7 +86,7 @@ static unsigned char hp48gx_bits[] = {
0x8c, 0xe1, 0x61, 0x00, 0xe0, 0x00, 0xc6, 0xb8, 0x31, 0xfc, 0x70, 0x00, 0x8c, 0xe1, 0x61, 0x00, 0xe0, 0x00, 0xc6, 0xb8, 0x31, 0xfc, 0x70, 0x00,
0xc7, 0x18, 0x33, 0xfc, 0xf8, 0x00, 0xff, 0x0d, 0x33, 0x60, 0xd8, 0x00, 0xc7, 0x18, 0x33, 0xfc, 0xf8, 0x00, 0xff, 0x0d, 0x33, 0x60, 0xd8, 0x00,
0xff, 0x0d, 0x73, 0x60, 0x8c, 0x01, 0x60, 0x8c, 0x63, 0x30, 0x86, 0x03, 0xff, 0x0d, 0x73, 0x60, 0x8c, 0x01, 0x60, 0x8c, 0x63, 0x30, 0x86, 0x03,
0x60, 0xfc, 0xe1, 0x3f, 0x07, 0x03, 0x60, 0xf8, 0x80, 0x37, 0x03, 0x03}; 0x60, 0xfc, 0xe1, 0x3f, 0x07, 0x03, 0x60, 0xf8, 0x80, 0x37, 0x03, 0x03 };
#define science_width 131 #define science_width 131
#define science_height 8 #define science_height 8
@ -102,7 +102,7 @@ static unsigned char science_bits[] = {
0xa2, 0x42, 0x7e, 0xa1, 0x10, 0x00, 0x91, 0x90, 0x04, 0x42, 0x44, 0x82, 0xa2, 0x42, 0x7e, 0xa1, 0x10, 0x00, 0x91, 0x90, 0x04, 0x42, 0x44, 0x82,
0x84, 0x20, 0x10, 0x09, 0x84, 0x42, 0x22, 0x42, 0xb1, 0x10, 0x00, 0x0e, 0x84, 0x20, 0x10, 0x09, 0x84, 0x42, 0x22, 0x42, 0xb1, 0x10, 0x00, 0x0e,
0x8f, 0x7c, 0x42, 0x44, 0x82, 0x78, 0xe0, 0x0b, 0x09, 0x82, 0x42, 0x1e, 0x8f, 0x7c, 0x42, 0x44, 0x82, 0x78, 0xe0, 0x0b, 0x09, 0x82, 0x42, 0x1e,
0x41, 0x9f, 0xf7, 0x01}; 0x41, 0x9f, 0xf7, 0x01 };
#define gx_128K_ram_x_hot 1 #define gx_128K_ram_x_hot 1
#define gx_128K_ram_y_hot 8 #define gx_128K_ram_y_hot 8
@ -124,7 +124,7 @@ static unsigned char gx_128K_ram_bits[] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc4, 0x30, 0x12, 0x1c, 0x44, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc4, 0x30, 0x12, 0x1c, 0x44, 0x04,
0x27, 0x49, 0x0a, 0x24, 0x46, 0x04, 0x84, 0x39, 0x06, 0x24, 0xc9, 0x06, 0x27, 0x49, 0x0a, 0x24, 0x46, 0x04, 0x84, 0x39, 0x06, 0x24, 0xc9, 0x06,
0x62, 0x24, 0x07, 0x9e, 0xaf, 0x06, 0x12, 0x24, 0x09, 0x92, 0xa8, 0x05, 0x62, 0x24, 0x07, 0x9e, 0xaf, 0x06, 0x12, 0x24, 0x09, 0x92, 0xa8, 0x05,
0xf2, 0x18, 0x11, 0x52, 0x28, 0x05}; 0xf2, 0x18, 0x11, 0x52, 0x28, 0x05 };
#define gx_silver_x_hot 0 #define gx_silver_x_hot 0
#define gx_silver_y_hot 8 #define gx_silver_y_hot 8
@ -139,22 +139,22 @@ static unsigned char gx_silver_bits[] = {
0x01, 0x48, 0x00, 0x40, 0x00, 0x01, 0x48, 0x00, 0x20, 0x00, 0x00, 0x50, 0x01, 0x48, 0x00, 0x40, 0x00, 0x01, 0x48, 0x00, 0x20, 0x00, 0x00, 0x50,
0x00, 0x10, 0x00, 0x00, 0x60, 0x00, 0x08, 0x00, 0x00, 0x60, 0x00, 0x06, 0x00, 0x10, 0x00, 0x00, 0x60, 0x00, 0x08, 0x00, 0x00, 0x60, 0x00, 0x06,
0x00, 0x00, 0xc0, 0x81, 0x01, 0x00, 0x00, 0x40, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x81, 0x01, 0x00, 0x00, 0x40, 0x7e, 0x00, 0x00, 0x00,
0x40, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00}; 0x40, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00 };
#define gx_green_x_hot 11 #define gx_green_x_hot 11
#define gx_green_y_hot 0 #define gx_green_y_hot 0
#define gx_green_width 34 #define gx_green_width 34
#define gx_green_height 22 #define gx_green_height 22
static unsigned char gx_green_bits[] = { static unsigned char gx_green_bits[] = {
0xff, 0xff, 0xff, 0xff, 0x03, 0xff, 0xff, 0xff, 0xff, 0x03, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0xff, 0xff, 0xff, 0xff, 0x03, 0xff,
0xff, 0xff, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff,
0x03, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x00, 0xfc, 0x03, 0x00, 0xff, 0xff, 0x03, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x00,
0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x00, 0xfc,
0xf0, 0x03, 0x00, 0x00, 0x00, 0xf0, 0x03, 0x00, 0x00, 0x00, 0xf0, 0x03, 0x03, 0x00, 0x00, 0x00, 0xf0, 0x03, 0x00, 0x00, 0x00, 0xf0, 0x03,
0x00, 0x00, 0x00, 0xf0, 0x03, 0x00, 0x00, 0x00, 0xf0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x03, 0x00, 0x00, 0x00, 0xf0, 0x03, 0x00,
0x00, 0xf0, 0x03, 0x00, 0x00, 0x00, 0xf0, 0x03, 0x00, 0x00, 0x00, 0xf0, 0x00, 0x00, 0xf0, 0x03, 0x00, 0x00, 0x00, 0xf0, 0x03, 0x00, 0x00,
0x03, 0x00, 0x00, 0x00, 0xf0, 0x03, 0x00, 0x00, 0x00, 0xf0, 0x03, 0x00, 0x00, 0xf0, 0x03, 0x00, 0x00, 0x00, 0xf0, 0x03, 0x00, 0x00, 0x00,
0x00, 0x00, 0xf0, 0x03, 0x00, 0x00, 0x00, 0xf0, 0x03, 0x00, 0x00, 0x00, 0xf0, 0x03, 0x00, 0x00, 0x00, 0xf0, 0x03, 0x00, 0x00, 0x00, 0xf0,
0xf0, 0x03}; 0x03, 0x00, 0x00, 0x00, 0xf0, 0x03, 0x00, 0x00, 0x00, 0xf0, 0x03 };
#endif /* !_HP_H */ #endif /* !_HP_H */

74
src/hp48.h
View file

@ -112,7 +112,7 @@ typedef struct word_64 {
#endif #endif
typedef struct keystate_t { typedef struct keystate_t {
short rows[9]; short rows[ 9 ];
} keystate_t; } keystate_t;
typedef struct display_t { typedef struct display_t {
@ -137,36 +137,36 @@ typedef struct display_t {
typedef struct mem_cntl_t { typedef struct mem_cntl_t {
unsigned short unconfigured; unsigned short unconfigured;
word_20 config[2]; word_20 config[ 2 ];
} mem_cntl_t; } mem_cntl_t;
typedef struct saturn_t { typedef struct saturn_t {
unsigned long magic; unsigned long magic;
char version[4]; char version[ 4 ];
unsigned char A[16], B[16], C[16], D[16]; unsigned char A[ 16 ], B[ 16 ], C[ 16 ], D[ 16 ];
word_20 d[2]; word_20 d[ 2 ];
#define D0 d[0] #define D0 d[ 0 ]
#define D1 d[1] #define D1 d[ 1 ]
word_4 P; word_4 P;
word_20 PC; word_20 PC;
unsigned char R0[16], R1[16], R2[16], R3[16], R4[16]; unsigned char R0[ 16 ], R1[ 16 ], R2[ 16 ], R3[ 16 ], R4[ 16 ];
unsigned char IN[4]; unsigned char IN[ 4 ];
unsigned char OUT[3]; unsigned char OUT[ 3 ];
word_1 CARRY; word_1 CARRY;
unsigned char PSTAT[NR_PSTAT]; unsigned char PSTAT[ NR_PSTAT ];
unsigned char XM, SB, SR, MP; unsigned char XM, SB, SR, MP;
word_4 hexmode; word_4 hexmode;
word_20 rstk[NR_RSTK]; word_20 rstk[ NR_RSTK ];
short rstkp; short rstkp;
keystate_t keybuf; keystate_t keybuf;
@ -238,12 +238,12 @@ typedef struct saturn_t {
long i_per_s; long i_per_s;
short bank_switch; short bank_switch;
mem_cntl_t mem_cntl[NR_MCTL]; mem_cntl_t mem_cntl[ NR_MCTL ];
unsigned char *rom; unsigned char* rom;
unsigned char *ram; unsigned char* ram;
unsigned char *port1; unsigned char* port1;
unsigned char *port2; unsigned char* port2;
} saturn_t; } saturn_t;
@ -260,33 +260,33 @@ extern long sched_adjtime;
extern long schedule_event; extern long schedule_event;
extern display_t display; extern display_t display;
extern void init_display __ProtoType__((void)); extern void init_display __ProtoType__( ( void ));
extern saturn_t saturn; extern saturn_t saturn;
extern int exit_emulator __ProtoType__((void)); extern int exit_emulator __ProtoType__( ( void ));
extern int init_emulator __ProtoType__((void)); extern int init_emulator __ProtoType__( ( void ));
extern void init_active_stuff __ProtoType__((void)); extern void init_active_stuff __ProtoType__( ( void ));
extern int serial_init __ProtoType__((void)); extern int serial_init __ProtoType__( ( void ));
extern void serial_baud __ProtoType__((int baud)); extern void serial_baud __ProtoType__( ( int baud ) );
extern void transmit_char __ProtoType__((void)); extern void transmit_char __ProtoType__( ( void ));
extern void receive_char __ProtoType__((void)); extern void receive_char __ProtoType__( ( void ));
extern void do_kbd_int __ProtoType__((void)); extern void do_kbd_int __ProtoType__( ( void ));
extern void do_interupt __ProtoType__((void)); extern void do_interupt __ProtoType__( ( void ));
extern void(*write_nibble) __ProtoType__((long addr, int val)); extern void( *write_nibble ) __ProtoType__( ( long addr, int val ) );
extern int(*read_nibble) __ProtoType__((long addr)); extern int( *read_nibble ) __ProtoType__( ( long addr ) );
extern int(*read_nibble_crc) __ProtoType__((long addr)); extern int( *read_nibble_crc ) __ProtoType__( ( long addr ) );
extern int emulate __ProtoType__((void)); extern int emulate __ProtoType__( ( void ));
extern int step_instruction __ProtoType__((void)); extern int step_instruction __ProtoType__( ( void ));
extern void schedule __ProtoType__((void)); extern void schedule __ProtoType__( ( void ));
extern int read_rom __ProtoType__((const char *fname)); 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, int n)); extern void load_addr __ProtoType__( ( word_20 * dat, long addr, int n ) );
#endif /* !_HP48_H */ #endif /* !_HP48_H */

205
src/hp48_emu.h
View file

@ -64,123 +64,132 @@
#include <X11/Xlib.h> #include <X11/Xlib.h>
#include "hp48.h" #include "hp48.h"
extern Display *dpy; extern Display* dpy;
extern Window dispW; extern Window dispW;
extern GC gc; extern GC gc;
extern void push_return_addr __ProtoType__((long addr)); extern void push_return_addr __ProtoType__( ( long addr ) );
extern long pop_return_addr __ProtoType__((void)); extern long pop_return_addr __ProtoType__( ( void ));
extern void init_annunc __ProtoType__((void)); extern void init_annunc __ProtoType__( ( void ));
extern void init_saturn __ProtoType__((void)); extern void init_saturn __ProtoType__( ( void ));
extern void check_timer __ProtoType__((void)); extern void check_timer __ProtoType__( ( void ));
extern void register_to_status __ProtoType__((unsigned char *r)); extern void register_to_status __ProtoType__( ( unsigned char* r ) );
extern void status_to_register __ProtoType__((unsigned char *r)); extern void status_to_register __ProtoType__( ( unsigned char* r ) );
extern void swap_register_status __ProtoType__((unsigned char *r)); extern void swap_register_status __ProtoType__( ( unsigned char* r ) );
extern void clear_status __ProtoType__((void)); extern void clear_status __ProtoType__( ( void ));
extern long read_nibbles __ProtoType__((long addr, int len)); extern long read_nibbles __ProtoType__( ( long addr, int len ) );
extern void write_nibbles __ProtoType__((long addr, long val, int len)); extern void write_nibbles __ProtoType__( ( long addr, long val, int len ) );
extern void dev_memory_init __ProtoType__((void)); extern void dev_memory_init __ProtoType__( ( void ));
extern void set_program_stat __ProtoType__((int n)); extern void set_program_stat __ProtoType__( ( int n ) );
extern void clear_program_stat __ProtoType__((int n)); extern void clear_program_stat __ProtoType__( ( int n ) );
extern int get_program_stat __ProtoType__((int n)); extern int get_program_stat __ProtoType__( ( int n ) );
extern void set_hardware_stat __ProtoType__((int op)); extern void set_hardware_stat __ProtoType__( ( int op ) );
extern void clear_hardware_stat __ProtoType__((int op)); extern void clear_hardware_stat __ProtoType__( ( int op ) );
extern int is_zero_hardware_stat __ProtoType__((int op)); extern int is_zero_hardware_stat __ProtoType__( ( int op ) );
extern void set_register_bit __ProtoType__((unsigned char *reg, int n)); extern void set_register_bit __ProtoType__( ( unsigned char* reg, int n ) );
extern void clear_register_bit __ProtoType__((unsigned char *reg, int n)); extern void clear_register_bit __ProtoType__( ( unsigned char* reg, int n ) );
extern int get_register_bit __ProtoType__((unsigned char *reg, int n)); 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, extern unsigned char get_register_nibble __ProtoType__( ( unsigned char* reg,
int n)); 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, long addr)); extern void load_constant __ProtoType__( ( unsigned char* reg, int n,
extern void load_address __ProtoType__((unsigned char *reg, long addr, int n)); long addr ) );
extern void load_address __ProtoType__( ( unsigned char* reg, long addr,
int n ) );
extern void store __ProtoType__((word_20 dat, unsigned char *reg, int code)); extern void store __ProtoType__( ( word_20 dat, unsigned char* reg,
extern void store_n __ProtoType__((word_20 dat, unsigned char *reg, int n)); int code ) );
extern void recall __ProtoType__((unsigned char *reg, word_20 dat, int code)); extern void store_n __ProtoType__( ( word_20 dat, unsigned char* reg, 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 ) );
extern void do_in __ProtoType__((void)); extern void do_in __ProtoType__( ( void ));
extern void do_reset __ProtoType__((void)); extern void do_reset __ProtoType__( ( void ));
extern void do_configure __ProtoType__((void)); extern void do_configure __ProtoType__( ( void ));
extern void do_unconfigure __ProtoType__((void)); extern void do_unconfigure __ProtoType__( ( void ));
extern void do_inton __ProtoType__((void)); extern void do_inton __ProtoType__( ( void ));
extern void do_intoff __ProtoType__((void)); extern void do_intoff __ProtoType__( ( void ));
extern void do_return_interupt __ProtoType__((void)); extern void do_return_interupt __ProtoType__( ( void ));
extern void do_reset_interrupt_system __ProtoType__((void)); extern void do_reset_interrupt_system __ProtoType__( ( void ));
extern void do_shutdown __ProtoType__((void)); 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, int code, extern void add_register_constant __ProtoType__( ( unsigned char* res, int code,
int val)); int val ) );
extern void sub_register_constant __ProtoType__((unsigned char *res, int code, extern void sub_register_constant __ProtoType__( ( unsigned char* res, 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,
unsigned char *r2, int code)); unsigned char* r2, int code ) );
extern void complement_2_register __ProtoType__((unsigned char *r, int code)); extern void complement_2_register __ProtoType__( ( unsigned char* r,
extern void complement_1_register __ProtoType__((unsigned char *r, int code)); int code ) );
extern void inc_register __ProtoType__((unsigned char *r, int code)); extern void complement_1_register __ProtoType__( ( unsigned char* r,
extern void dec_register __ProtoType__((unsigned char *r, int code)); int code ) );
extern void zero_register __ProtoType__((unsigned char *r, int code)); extern void inc_register __ProtoType__( ( unsigned char* r, int code ) );
extern void or_register __ProtoType__((unsigned char *res, unsigned char *r1, extern void dec_register __ProtoType__( ( unsigned char* r, int code ) );
unsigned char *r2, int code)); extern void zero_register __ProtoType__( ( unsigned char* r, int code ) );
extern void and_register __ProtoType__((unsigned char *res, unsigned char *r1, extern void or_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 and_register __ProtoType__( ( unsigned char* res, unsigned char* r1,
int code)); unsigned char* r2, int code ) );
extern void exchange_register __ProtoType__((unsigned char *r1, extern void copy_register __ProtoType__( ( unsigned char* to,
unsigned char *r2, int code)); unsigned char* from, int code ) );
extern void exchange_register __ProtoType__( ( unsigned char* r1,
unsigned char* r2, int code ) );
extern void exchange_reg __ProtoType__((unsigned char *r, word_20 *d, extern void exchange_reg __ProtoType__( ( unsigned char* r, word_20* d,
int code)); 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, extern void shift_left_circ_register __ProtoType__( ( unsigned char* r,
int code)); int code ) );
extern void shift_right_register __ProtoType__((unsigned char *r, int code)); extern void shift_right_register __ProtoType__( ( unsigned char* r,
extern void shift_right_circ_register __ProtoType__((unsigned char *r, int code ) );
int code)); extern void shift_right_circ_register __ProtoType__( ( unsigned char* r,
extern void shift_right_bit_register __ProtoType__((unsigned char *r, int code ) );
int code)); extern void shift_right_bit_register __ProtoType__( ( unsigned char* r,
extern int is_zero_register __ProtoType__((unsigned char *r, int code)); int code ) );
extern int is_not_zero_register __ProtoType__((unsigned char *r, int code)); extern int is_zero_register __ProtoType__( ( unsigned char* r, int code ) );
extern int is_equal_register __ProtoType__((unsigned char *r1, extern int is_not_zero_register __ProtoType__( ( unsigned char* r, int code ) );
unsigned char *r2, int code)); extern int is_equal_register __ProtoType__( ( unsigned char* r1,
extern int is_not_equal_register __ProtoType__((unsigned char *r1, unsigned char* r2, int code ) );
unsigned char *r2, int code)); extern int is_not_equal_register __ProtoType__( ( unsigned char* r1,
extern int is_less_register __ProtoType__((unsigned char *r1, unsigned char *r2, unsigned char* r2,
int code)); int code ) );
extern int is_less_or_equal_register __ProtoType__((unsigned char *r1, extern int is_less_register __ProtoType__( ( unsigned char* r1,
unsigned char *r2, unsigned char* r2, int code ) );
int code)); extern int is_less_or_equal_register __ProtoType__( ( unsigned char* r1,
extern int is_greater_register __ProtoType__((unsigned char *r1, unsigned char* r2,
unsigned char *r2, int code)); int code ) );
extern int is_greater_or_equal_register __ProtoType__((unsigned char *r1, extern int is_greater_register __ProtoType__( ( unsigned char* r1,
unsigned char *r2, unsigned char* r2, int code ) );
int code)); extern int is_greater_or_equal_register __ProtoType__( ( unsigned char* r1,
unsigned char* r2,
int code ) );
#endif /* !_HP48_EMU_H */ #endif /* !_HP48_EMU_H */

134
src/hp48char.h
View file

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

60
src/icon.h
View file

@ -67,7 +67,7 @@ static unsigned char hp48_icon_bits[] = {
0xff, 0xff, 0xff, 0xff, 0xe3, 0x30, 0x0c, 0xc3, 0xe3, 0x30, 0x0c, 0xc3, 0xff, 0xff, 0xff, 0xff, 0xe3, 0x30, 0x0c, 0xc3, 0xe3, 0x30, 0x0c, 0xc3,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe3, 0x30, 0x0c, 0xc3, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe3, 0x30, 0x0c, 0xc3,
0xe3, 0x30, 0x0c, 0xc3, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe3, 0x30, 0x0c, 0xc3, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff}; 0xff, 0xff, 0xff, 0xff };
#define hp48_top_width 32 #define hp48_top_width 32
#define hp48_top_height 30 #define hp48_top_height 30
@ -81,7 +81,7 @@ static unsigned char hp48_top_bits[] = {
0x07, 0x00, 0x00, 0xe0, 0x07, 0x00, 0x00, 0xe0, 0x07, 0x00, 0x00, 0xe0, 0x07, 0x00, 0x00, 0xe0, 0x07, 0x00, 0x00, 0xe0, 0x07, 0x00, 0x00, 0xe0,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0x63, 0x8c, 0x31, 0xc6, 0x63, 0x8c, 0x31, 0xc6, 0xff, 0xff, 0xff, 0xff}; 0x63, 0x8c, 0x31, 0xc6, 0x63, 0x8c, 0x31, 0xc6, 0xff, 0xff, 0xff, 0xff };
#define hp48_bottom_width 32 #define hp48_bottom_width 32
#define hp48_bottom_height 64 #define hp48_bottom_height 64
@ -107,19 +107,19 @@ static unsigned char hp48_bottom_bits[] = {
0xff, 0xff, 0xff, 0xff, 0xe3, 0x30, 0x0c, 0xc3, 0xe3, 0x30, 0x0c, 0xc3, 0xff, 0xff, 0xff, 0xff, 0xe3, 0x30, 0x0c, 0xc3, 0xe3, 0x30, 0x0c, 0xc3,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe3, 0x30, 0x0c, 0xc3, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe3, 0x30, 0x0c, 0xc3,
0xe3, 0x30, 0x0c, 0xc3, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe3, 0x30, 0x0c, 0xc3, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff}; 0xff, 0xff, 0xff, 0xff };
#define hp48_logo_width 13 #define hp48_logo_width 13
#define hp48_logo_height 4 #define hp48_logo_height 4
static unsigned char hp48_logo_bits[] = { static unsigned char hp48_logo_bits[] = { 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0xf8, 0x1f, 0xf8, 0x1f}; 0xf8, 0x1f, 0xf8, 0x1f };
#define hp48_text_width 29 #define hp48_text_width 29
#define hp48_text_height 7 #define hp48_text_height 7
static unsigned char hp48_text_bits[] = { static unsigned char hp48_text_bits[] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xf8, 0x00, 0xfe, 0x1f}; 0x00, 0x00, 0x00, 0x00, 0xf8, 0x00, 0xfe, 0x1f };
#define hp48_disp_width 29 #define hp48_disp_width 29
#define hp48_disp_height 21 #define hp48_disp_height 21
@ -130,7 +130,7 @@ static unsigned char hp48_disp_bits[] = {
0xf8, 0xff, 0xff, 0x1f, 0xf8, 0xff, 0xff, 0x1f, 0xf8, 0xff, 0xff, 0x1f, 0xf8, 0xff, 0xff, 0x1f, 0xf8, 0xff, 0xff, 0x1f, 0xf8, 0xff, 0xff, 0x1f,
0xf8, 0xff, 0xff, 0x1f, 0xf8, 0xff, 0xff, 0x1f, 0xf8, 0xff, 0xff, 0x1f, 0xf8, 0xff, 0xff, 0x1f, 0xf8, 0xff, 0xff, 0x1f, 0xf8, 0xff, 0xff, 0x1f,
0xf8, 0xff, 0xff, 0x1f, 0xf8, 0xff, 0xff, 0x1f, 0xf8, 0xff, 0xff, 0x1f, 0xf8, 0xff, 0xff, 0x1f, 0xf8, 0xff, 0xff, 0x1f, 0xf8, 0xff, 0xff, 0x1f,
0xf8, 0xff, 0xff, 0x1f, 0xf8, 0xff, 0xff, 0x1f, 0xf8, 0xff, 0xff, 0x1f}; 0xf8, 0xff, 0xff, 0x1f, 0xf8, 0xff, 0xff, 0x1f, 0xf8, 0xff, 0xff, 0x1f };
#define hp48_keys_width 30 #define hp48_keys_width 30
#define hp48_keys_height 61 #define hp48_keys_height 61
@ -155,16 +155,16 @@ static unsigned char hp48_keys_bits[] = {
0x00, 0xcf, 0xf3, 0x3c, 0x00, 0xcf, 0xf3, 0x3c, 0x00, 0x00, 0x00, 0x00, 0x00, 0xcf, 0xf3, 0x3c, 0x00, 0xcf, 0xf3, 0x3c, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0xcf, 0xf3, 0x3c, 0x00, 0xcf, 0xf3, 0x3c, 0x00, 0x00, 0x00, 0x00, 0x00, 0xcf, 0xf3, 0x3c, 0x00, 0xcf, 0xf3, 0x3c,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1c, 0xcf, 0xf3, 0x3c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1c, 0xcf, 0xf3, 0x3c,
0x1c, 0xcf, 0xf3, 0x3c}; 0x1c, 0xcf, 0xf3, 0x3c };
#define hp48_orange_width 5 #define hp48_orange_width 5
#define hp48_orange_height 53 #define hp48_orange_height 53
static unsigned char hp48_orange_bits[] = { static unsigned char hp48_orange_bits[] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x1c, 0x1c}; 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1c, 0x1c };
#define hp48_blue_width 5 #define hp48_blue_width 5
#define hp48_blue_height 57 #define hp48_blue_height 57
@ -173,18 +173,18 @@ static unsigned char hp48_blue_bits[] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1c, 0x1c}; 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1c, 0x1c };
#define hp48_on_width 25 #define hp48_on_width 25
#define hp48_on_height 19 #define hp48_on_height 19
static unsigned char hp48_on_bits[] = { static unsigned char hp48_on_bits[] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe2, 0x00, 0x00, 0x00, 0x13, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe2, 0x00,
0x00, 0x80, 0x12, 0x01, 0x80, 0x48, 0x12, 0x01, 0x80, 0xc8, 0xe7, 0x00, 0x00, 0x00, 0x13, 0x01, 0x00, 0x80, 0x12, 0x01, 0x80, 0x48, 0x12,
0x00, 0x05, 0x12, 0x01, 0x00, 0x02, 0x12, 0x01, 0x00, 0x05, 0x12, 0x01, 0x01, 0x80, 0xc8, 0xe7, 0x00, 0x00, 0x05, 0x12, 0x01, 0x00, 0x02,
0x80, 0x08, 0xe2, 0x00}; 0x12, 0x01, 0x00, 0x05, 0x12, 0x01, 0x80, 0x08, 0xe2, 0x00 };
#define hp48_top_gx_width 32 #define hp48_top_gx_width 32
#define hp48_top_gx_height 30 #define hp48_top_gx_height 30
@ -198,19 +198,19 @@ static unsigned char hp48_top_gx_bits[] = {
0x07, 0x00, 0x00, 0xe0, 0x07, 0x00, 0x00, 0xe0, 0x07, 0x00, 0x00, 0xe0, 0x07, 0x00, 0x00, 0xe0, 0x07, 0x00, 0x00, 0xe0, 0x07, 0x00, 0x00, 0xe0,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0x63, 0x8c, 0x31, 0xc6, 0x63, 0x8c, 0x31, 0xc6, 0xff, 0xff, 0xff, 0xff}; 0x63, 0x8c, 0x31, 0xc6, 0x63, 0x8c, 0x31, 0xc6, 0xff, 0xff, 0xff, 0xff };
#define hp48_logo_gx_width 16 #define hp48_logo_gx_width 16
#define hp48_logo_gx_height 4 #define hp48_logo_gx_height 4
static unsigned char hp48_logo_gx_bits[] = { static unsigned char hp48_logo_gx_bits[] = { 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0xf8, 0xf7, 0xf8, 0xf7}; 0xf8, 0xf7, 0xf8, 0xf7 };
#define hp48_text_gx_width 29 #define hp48_text_gx_width 29
#define hp48_text_gx_height 7 #define hp48_text_gx_height 7
static unsigned char hp48_text_gx_bits[] = { static unsigned char hp48_text_gx_bits[] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f,
0x00, 0x00, 0x00, 0x1f}; 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f };
#define hp48_green_gx_width 29 #define hp48_green_gx_width 29
#define hp48_green_gx_height 57 #define hp48_green_gx_height 57
@ -233,6 +233,6 @@ static unsigned char hp48_green_gx_bits[] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00}; 0x00, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00 };
#endif /* !_ICON_H */ #endif /* !_ICON_H */

1566
src/init.c
View file

File diff suppressed because it is too large Load diff

391
src/lcd.c
View file

@ -80,149 +80,152 @@ display_t display;
#define DISP_ROWS 64 #define DISP_ROWS 64
#define NIBS_PER_BUFFER_ROW (NIBBLES_PER_ROW + 2) #define NIBS_PER_BUFFER_ROW ( NIBBLES_PER_ROW + 2 )
unsigned char disp_buf[DISP_ROWS][NIBS_PER_BUFFER_ROW]; unsigned char disp_buf[ DISP_ROWS ][ NIBS_PER_BUFFER_ROW ];
unsigned char lcd_buffer[DISP_ROWS][NIBS_PER_BUFFER_ROW]; 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 }, /* -*-- */
{0x0f, 0x0f}, /* **-- */ { 0x0f, 0x0f }, /* **-- */
{0x30, 0x30}, /* --*- */ { 0x30, 0x30 }, /* --*- */
{0x33, 0x33}, /* *-*- */ { 0x33, 0x33 }, /* *-*- */
{0x3c, 0x3c}, /* -**- */ { 0x3c, 0x3c }, /* -**- */
{0x3f, 0x3f}, /* ***- */ { 0x3f, 0x3f }, /* ***- */
{0xc0, 0xc0}, /* ---* */ { 0xc0, 0xc0 }, /* ---* */
{0xc3, 0xc3}, /* *--* */ { 0xc3, 0xc3 }, /* *--* */
{0xcc, 0xcc}, /* -*-* */ { 0xcc, 0xcc }, /* -*-* */
{0xcf, 0xcf}, /* **-* */ { 0xcf, 0xcf }, /* **-* */
{0xf0, 0xf0}, /* --** */ { 0xf0, 0xf0 }, /* --** */
{0xf3, 0xf3}, /* *-** */ { 0xf3, 0xf3 }, /* *-** */
{0xfc, 0xfc}, /* -*** */ { 0xfc, 0xfc }, /* -*** */
{0xff, 0xff} /* **** */ { 0xff, 0xff } /* **** */
}; };
static unsigned char nibble_bits[16]; static unsigned char nibble_bits[ 16 ];
void init_nibble_maps(void) { void init_nibble_maps( void ) {
int i; int i;
for (i = 0; i < 16; i++) { for ( i = 0; i < 16; i++ ) {
nibble_maps[i] = nibble_maps[ i ] =
XCreateBitmapFromData(dpy, disp.win, (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 ) {
if (disp.disp_image->bitmap_bit_order == MSBFirst) { if ( disp.disp_image->bitmap_bit_order == MSBFirst ) {
nibble_bits[0x0] = 0x00; /* ---- */ nibble_bits[ 0x0 ] = 0x00; /* ---- */
nibble_bits[0x1] = 0xc0; /* *--- */ nibble_bits[ 0x1 ] = 0xc0; /* *--- */
nibble_bits[0x2] = 0x30; /* -*-- */ nibble_bits[ 0x2 ] = 0x30; /* -*-- */
nibble_bits[0x3] = 0xf0; /* **-- */ nibble_bits[ 0x3 ] = 0xf0; /* **-- */
nibble_bits[0x4] = 0x0c; /* --*- */ nibble_bits[ 0x4 ] = 0x0c; /* --*- */
nibble_bits[0x5] = 0xcc; /* *-*- */ nibble_bits[ 0x5 ] = 0xcc; /* *-*- */
nibble_bits[0x6] = 0x3c; /* -**- */ nibble_bits[ 0x6 ] = 0x3c; /* -**- */
nibble_bits[0x7] = 0xfc; /* ***- */ nibble_bits[ 0x7 ] = 0xfc; /* ***- */
nibble_bits[0x8] = 0x03; /* ---* */ nibble_bits[ 0x8 ] = 0x03; /* ---* */
nibble_bits[0x9] = 0xc3; /* *--* */ nibble_bits[ 0x9 ] = 0xc3; /* *--* */
nibble_bits[0xa] = 0x33; /* -*-* */ nibble_bits[ 0xa ] = 0x33; /* -*-* */
nibble_bits[0xb] = 0xf3; /* **-* */ nibble_bits[ 0xb ] = 0xf3; /* **-* */
nibble_bits[0xc] = 0x0f; /* --** */ nibble_bits[ 0xc ] = 0x0f; /* --** */
nibble_bits[0xd] = 0xcf; /* *-** */ nibble_bits[ 0xd ] = 0xcf; /* *-** */
nibble_bits[0xe] = 0x3f; /* -*** */ nibble_bits[ 0xe ] = 0x3f; /* -*** */
nibble_bits[0xf] = 0xff; /* **** */ nibble_bits[ 0xf ] = 0xff; /* **** */
} else { } else {
nibble_bits[0x0] = 0x00; /* ---- */ nibble_bits[ 0x0 ] = 0x00; /* ---- */
nibble_bits[0x1] = 0x03; /* *--- */ nibble_bits[ 0x1 ] = 0x03; /* *--- */
nibble_bits[0x2] = 0x0c; /* -*-- */ nibble_bits[ 0x2 ] = 0x0c; /* -*-- */
nibble_bits[0x3] = 0x0f; /* **-- */ nibble_bits[ 0x3 ] = 0x0f; /* **-- */
nibble_bits[0x4] = 0x30; /* --*- */ nibble_bits[ 0x4 ] = 0x30; /* --*- */
nibble_bits[0x5] = 0x33; /* *-*- */ nibble_bits[ 0x5 ] = 0x33; /* *-*- */
nibble_bits[0x6] = 0x3c; /* -**- */ nibble_bits[ 0x6 ] = 0x3c; /* -**- */
nibble_bits[0x7] = 0x3f; /* ***- */ nibble_bits[ 0x7 ] = 0x3f; /* ***- */
nibble_bits[0x8] = 0xc0; /* ---* */ nibble_bits[ 0x8 ] = 0xc0; /* ---* */
nibble_bits[0x9] = 0xc3; /* *--* */ nibble_bits[ 0x9 ] = 0xc3; /* *--* */
nibble_bits[0xa] = 0xcc; /* -*-* */ nibble_bits[ 0xa ] = 0xcc; /* -*-* */
nibble_bits[0xb] = 0xcf; /* **-* */ nibble_bits[ 0xb ] = 0xcf; /* **-* */
nibble_bits[0xc] = 0xf0; /* --** */ nibble_bits[ 0xc ] = 0xf0; /* --** */
nibble_bits[0xd] = 0xf3; /* *-** */ nibble_bits[ 0xd ] = 0xf3; /* *-** */
nibble_bits[0xe] = 0xfc; /* -*** */ nibble_bits[ 0xe ] = 0xfc; /* -*** */
nibble_bits[0xf] = 0xff; /* **** */ nibble_bits[ 0xf ] = 0xff; /* **** */
} }
} }
#endif #endif
} }
void init_display(void) { void init_display( void ) {
display.on = (int)(saturn.disp_io & 0x8) >> 3; display.on = ( int )( saturn.disp_io & 0x8 ) >> 3;
display.disp_start = (saturn.disp_addr & 0xffffe); display.disp_start = ( saturn.disp_addr & 0xffffe );
display.offset = (saturn.disp_io & 0x7); display.offset = ( saturn.disp_io & 0x7 );
disp.offset = 2 * display.offset; disp.offset = 2 * display.offset;
display.lines = (saturn.line_count & 0x3f); display.lines = ( saturn.line_count & 0x3f );
if (display.lines == 0) if ( display.lines == 0 )
display.lines = 63; display.lines = 63;
disp.lines = 2 * display.lines; disp.lines = 2 * display.lines;
if (disp.lines < 110) if ( disp.lines < 110 )
disp.lines = 110; disp.lines = 110;
if (display.offset > 3) if ( display.offset > 3 )
display.nibs_per_line = (NIBBLES_PER_ROW + saturn.line_offset + 2) & 0xfff; display.nibs_per_line =
( NIBBLES_PER_ROW + saturn.line_offset + 2 ) & 0xfff;
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_end =
display.disp_start + (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;
display.contrast = saturn.contrast_ctrl; display.contrast = saturn.contrast_ctrl;
display.contrast |= ((saturn.disp_test & 0x1) << 4); display.contrast |= ( ( saturn.disp_test & 0x1 ) << 4 );
display.annunc = saturn.annunc; display.annunc = saturn.annunc;
memset(disp_buf, 0xf0, sizeof(disp_buf)); memset( disp_buf, 0xf0, sizeof( disp_buf ) );
memset(lcd_buffer, 0xf0, sizeof(lcd_buffer)); memset( lcd_buffer, 0xf0, sizeof( lcd_buffer ) );
init_nibble_maps(); init_nibble_maps();
} }
static inline void draw_nibble(int c, int r, int val) { static inline void draw_nibble( int c, int r, int val ) {
int x, y; int x, y;
x = (c * 8) + 5; x = ( c * 8 ) + 5;
if (r <= display.lines) if ( r <= display.lines )
x -= disp.offset; x -= disp.offset;
y = (r * 2) + 20; y = ( r * 2 ) + 20;
val &= 0x0f; val &= 0x0f;
if (val != lcd_buffer[r][c]) { if ( val != lcd_buffer[ r ][ c ] ) {
XCopyPlane(dpy, nibble_maps[val], disp.win, disp.gc, 0, 0, 8, 2, x, y, 1); XCopyPlane( dpy, nibble_maps[ val ], disp.win, disp.gc, 0, 0, 8, 2, x,
lcd_buffer[r][c] = val; y, 1 );
lcd_buffer[ r ][ c ] = val;
} }
} }
static inline void draw_row(long addr, int row) { static inline void draw_row( long addr, int row ) {
int i, v; int i, v;
int line_length; int line_length;
line_length = NIBBLES_PER_ROW; line_length = NIBBLES_PER_ROW;
if ((display.offset > 3) && (row <= display.lines)) if ( ( display.offset > 3 ) && ( row <= display.lines ) )
line_length += 2; line_length += 2;
for (i = 0; i < line_length; i++) { for ( i = 0; i < line_length; i++ ) {
v = read_nibble(addr + i); v = read_nibble( addr + i );
if (v != disp_buf[row][i]) { if ( v != disp_buf[ row ][ i ] ) {
disp_buf[row][i] = v; disp_buf[ row ][ i ] = v;
draw_nibble(i, row, v); draw_nibble( i, row, v );
} }
} }
} }
void update_display(void) { void update_display( void ) {
int i, j; int i, j;
long addr; long addr;
static int old_offset = -1; static int old_offset = -1;
@ -233,26 +236,26 @@ 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;
} }
if (display.on) { if ( display.on ) {
addr = display.disp_start; addr = display.disp_start;
#ifdef HAVE_XSHM #ifdef HAVE_XSHM
if (shm_flag) { if ( shm_flag ) {
data_addr = 0; data_addr = 0;
data_addr_2 = disp.disp_image->bytes_per_line; data_addr_2 = disp.disp_image->bytes_per_line;
line_length = NIBBLES_PER_ROW; line_length = NIBBLES_PER_ROW;
if (display.offset > 3) if ( display.offset > 3 )
line_length += 2; line_length += 2;
line_pad = 2 * disp.disp_image->bytes_per_line - line_length; line_pad = 2 * disp.disp_image->bytes_per_line - line_length;
addr_pad = display.nibs_per_line - line_length; addr_pad = display.nibs_per_line - line_length;
for (i = 0; i <= display.lines; i++) { for ( i = 0; i <= display.lines; i++ ) {
for (j = 0; j < line_length; j++) { for ( j = 0; j < line_length; j++ ) {
val = read_nibble(addr++); val = read_nibble( addr++ );
disp.disp_image->data[data_addr++] = nibble_bits[val]; disp.disp_image->data[ data_addr++ ] = nibble_bits[ val ];
disp.disp_image->data[data_addr_2++] = nibble_bits[val]; disp.disp_image->data[ data_addr_2++ ] = nibble_bits[ val ];
} }
addr += addr_pad; addr += addr_pad;
data_addr += line_pad; data_addr += line_pad;
@ -261,37 +264,44 @@ void update_display(void) {
disp.display_update |= UPDATE_DISP; disp.display_update |= UPDATE_DISP;
} else { } else {
#endif #endif
if (display.offset != old_offset) { if ( display.offset != old_offset ) {
memset(disp_buf, 0xf0, memset(
(size_t)((display.lines + 1) * NIBS_PER_BUFFER_ROW)); disp_buf, 0xf0,
memset(lcd_buffer, 0xf0, ( size_t )( ( display.lines + 1 ) * NIBS_PER_BUFFER_ROW ) );
(size_t)((display.lines + 1) * NIBS_PER_BUFFER_ROW)); memset(
lcd_buffer, 0xf0,
( size_t )( ( display.lines + 1 ) * NIBS_PER_BUFFER_ROW ) );
old_offset = display.offset; old_offset = display.offset;
} }
if (display.lines != old_lines) { if ( display.lines != old_lines ) {
memset(&disp_buf[56][0], 0xf0, (size_t)(8 * NIBS_PER_BUFFER_ROW)); memset( &disp_buf[ 56 ][ 0 ], 0xf0,
memset(&lcd_buffer[56][0], 0xf0, (size_t)(8 * NIBS_PER_BUFFER_ROW)); ( size_t )( 8 * NIBS_PER_BUFFER_ROW ) );
memset( &lcd_buffer[ 56 ][ 0 ], 0xf0,
( size_t )( 8 * NIBS_PER_BUFFER_ROW ) );
old_lines = display.lines; old_lines = display.lines;
} }
for (i = 0; i <= display.lines; i++) { for ( i = 0; i <= display.lines; i++ ) {
draw_row(addr, i); draw_row( addr, i );
addr += display.nibs_per_line; addr += display.nibs_per_line;
} }
#ifdef HAVE_XSHM #ifdef HAVE_XSHM
} }
#endif #endif
if (i < DISP_ROWS) { if ( i < DISP_ROWS ) {
addr = display.menu_start; addr = display.menu_start;
#ifdef HAVE_XSHM #ifdef HAVE_XSHM
if (shm_flag) { if ( shm_flag ) {
data_addr = 0; data_addr = 0;
data_addr_2 = disp.menu_image->bytes_per_line; data_addr_2 = disp.menu_image->bytes_per_line;
line_pad = 2 * disp.menu_image->bytes_per_line - NIBBLES_PER_ROW; line_pad =
for (; i < DISP_ROWS; i++) { 2 * disp.menu_image->bytes_per_line - NIBBLES_PER_ROW;
for (j = 0; j < NIBBLES_PER_ROW; j++) { for ( ; i < DISP_ROWS; i++ ) {
val = read_nibble(addr++); for ( j = 0; j < NIBBLES_PER_ROW; j++ ) {
disp.menu_image->data[data_addr++] = nibble_bits[val]; val = read_nibble( addr++ );
disp.menu_image->data[data_addr_2++] = nibble_bits[val]; disp.menu_image->data[ data_addr++ ] =
nibble_bits[ val ];
disp.menu_image->data[ data_addr_2++ ] =
nibble_bits[ val ];
} }
data_addr += line_pad; data_addr += line_pad;
data_addr_2 += line_pad; data_addr_2 += line_pad;
@ -299,8 +309,8 @@ void update_display(void) {
disp.display_update |= UPDATE_MENU; disp.display_update |= UPDATE_MENU;
} else { } else {
#endif #endif
for (; i < DISP_ROWS; i++) { for ( ; i < DISP_ROWS; i++ ) {
draw_row(addr, i); draw_row( addr, i );
addr += NIBBLES_PER_ROW; addr += NIBBLES_PER_ROW;
} }
#ifdef HAVE_XSHM #ifdef HAVE_XSHM
@ -309,20 +319,20 @@ void update_display(void) {
} }
} else { } else {
#ifdef HAVE_XSHM #ifdef HAVE_XSHM
if (shm_flag) { if ( shm_flag ) {
memset( memset( disp.disp_image->data, 0,
disp.disp_image->data, 0, ( size_t )( disp.disp_image->bytes_per_line *
(size_t)(disp.disp_image->bytes_per_line * disp.disp_image->height)); disp.disp_image->height ) );
memset( memset( disp.menu_image->data, 0,
disp.menu_image->data, 0, ( size_t )( disp.menu_image->bytes_per_line *
(size_t)(disp.menu_image->bytes_per_line * disp.menu_image->height)); disp.menu_image->height ) );
disp.display_update = UPDATE_DISP | UPDATE_MENU; disp.display_update = UPDATE_DISP | UPDATE_MENU;
} else { } else {
#endif #endif
memset(disp_buf, 0xf0, sizeof(disp_buf)); memset( disp_buf, 0xf0, sizeof( disp_buf ) );
for (i = 0; i < 64; i++) { for ( i = 0; i < 64; i++ ) {
for (j = 0; j < NIBBLES_PER_ROW; j++) { for ( j = 0; j < NIBBLES_PER_ROW; j++ ) {
draw_nibble(j, i, 0x00); draw_nibble( j, i, 0x00 );
} }
} }
#ifdef HAVE_XSHM #ifdef HAVE_XSHM
@ -331,61 +341,62 @@ void update_display(void) {
} }
} }
void redraw_display(void) { void redraw_display( void ) {
XClearWindow(dpy, disp.win); XClearWindow( dpy, disp.win );
memset(disp_buf, 0, sizeof(disp_buf)); memset( disp_buf, 0, sizeof( disp_buf ) );
memset(lcd_buffer, 0, sizeof(lcd_buffer)); memset( lcd_buffer, 0, sizeof( lcd_buffer ) );
update_display(); update_display();
} }
void disp_draw_nibble(word_20 addr, word_4 val) { void disp_draw_nibble( word_20 addr, word_4 val ) {
long offset; long offset;
#ifdef HAVE_XSHM #ifdef HAVE_XSHM
int shm_addr; int shm_addr;
#endif #endif
int x, y; int x, y;
offset = (addr - display.disp_start); offset = ( addr - display.disp_start );
x = offset % display.nibs_per_line; x = offset % display.nibs_per_line;
if (x < 0 || x > 35) if ( x < 0 || x > 35 )
return; return;
if (display.nibs_per_line != 0) { if ( display.nibs_per_line != 0 ) {
y = offset / display.nibs_per_line; y = offset / display.nibs_per_line;
if (y < 0 || y > 63) if ( y < 0 || y > 63 )
return; return;
#ifdef HAVE_XSHM #ifdef HAVE_XSHM
if (shm_flag) { if ( shm_flag ) {
shm_addr = (2 * y * disp.disp_image->bytes_per_line) + x; shm_addr = ( 2 * y * disp.disp_image->bytes_per_line ) + x;
disp.disp_image->data[shm_addr] = nibble_bits[val]; disp.disp_image->data[ shm_addr ] = nibble_bits[ val ];
disp.disp_image->data[shm_addr + disp.disp_image->bytes_per_line] = disp.disp_image
nibble_bits[val]; ->data[ shm_addr + disp.disp_image->bytes_per_line ] =
nibble_bits[ val ];
disp.display_update |= UPDATE_DISP; disp.display_update |= UPDATE_DISP;
} else { } else {
#endif #endif
if (val != disp_buf[y][x]) { if ( val != disp_buf[ y ][ x ] ) {
disp_buf[y][x] = val; disp_buf[ y ][ x ] = val;
draw_nibble(x, y, val); draw_nibble( x, y, val );
} }
#ifdef HAVE_XSHM #ifdef HAVE_XSHM
} }
#endif #endif
} else { } else {
#ifdef HAVE_XSHM #ifdef HAVE_XSHM
if (shm_flag) { if ( shm_flag ) {
shm_addr = x; shm_addr = x;
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] = 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.display_update |= UPDATE_DISP; disp.display_update |= UPDATE_DISP;
} else { } else {
#endif #endif
for (y = 0; y < display.lines; y++) { for ( y = 0; y < display.lines; y++ ) {
if (val != disp_buf[y][x]) { if ( val != disp_buf[ y ][ x ] ) {
disp_buf[y][x] = val; disp_buf[ y ][ x ] = val;
draw_nibble(x, y, val); draw_nibble( x, y, val );
} }
} }
#ifdef HAVE_XSHM #ifdef HAVE_XSHM
@ -394,30 +405,30 @@ void disp_draw_nibble(word_20 addr, word_4 val) {
} }
} }
void menu_draw_nibble(word_20 addr, word_4 val) { void menu_draw_nibble( word_20 addr, word_4 val ) {
long offset; long offset;
#ifdef HAVE_XSHM #ifdef HAVE_XSHM
int shm_addr; int shm_addr;
#endif #endif
int x, y; int x, y;
offset = (addr - display.menu_start); offset = ( addr - display.menu_start );
#ifdef HAVE_XSHM #ifdef HAVE_XSHM
if (shm_flag) { if ( shm_flag ) {
shm_addr = shm_addr =
2 * (offset / NIBBLES_PER_ROW) * disp.menu_image->bytes_per_line + 2 * ( offset / NIBBLES_PER_ROW ) * disp.menu_image->bytes_per_line +
(offset % NIBBLES_PER_ROW); ( 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 ];
disp.display_update |= UPDATE_MENU; disp.display_update |= UPDATE_MENU;
} else { } else {
#endif #endif
x = offset % NIBBLES_PER_ROW; x = offset % NIBBLES_PER_ROW;
y = display.lines + (offset / NIBBLES_PER_ROW) + 1; y = display.lines + ( offset / NIBBLES_PER_ROW ) + 1;
if (val != disp_buf[y][x]) { if ( val != disp_buf[ y ][ x ] ) {
disp_buf[y][x] = val; disp_buf[ y ][ x ] = val;
draw_nibble(x, y, val); draw_nibble( x, y, val );
} }
#ifdef HAVE_XSHM #ifdef HAVE_XSHM
} }
@ -430,51 +441,51 @@ struct ann_struct {
int y; int y;
unsigned int width; unsigned int width;
unsigned int height; unsigned int height;
unsigned char *bits; unsigned char* bits;
Pixmap pixmap; Pixmap pixmap;
} ann_tbl[] = { } ann_tbl[] = {
{ANN_LEFT, 16, 4, ann_left_width, ann_left_height, ann_left_bits}, { ANN_LEFT, 16, 4, ann_left_width, ann_left_height, ann_left_bits },
{ANN_RIGHT, 61, 4, ann_right_width, ann_right_height, ann_right_bits}, { ANN_RIGHT, 61, 4, ann_right_width, ann_right_height, ann_right_bits },
{ANN_ALPHA, 106, 4, ann_alpha_width, ann_alpha_height, ann_alpha_bits}, { ANN_ALPHA, 106, 4, ann_alpha_width, ann_alpha_height, ann_alpha_bits },
{ANN_BATTERY, 151, 4, ann_battery_width, ann_battery_height, { ANN_BATTERY, 151, 4, ann_battery_width, ann_battery_height,
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;
int i; int i;
val = display.annunc; val = display.annunc;
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].x, ann_tbl[ i ].width, ann_tbl[ i ].height, 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, XClearArea( dpy, disp.win, ann_tbl[ i ].x, ann_tbl[ i ].y,
ann_tbl[i].height, False); ann_tbl[ i ].width, ann_tbl[ i ].height, False );
} }
} }
refresh_icon(); refresh_icon();
} }
void redraw_annunc(void) { void redraw_annunc( void ) {
last_annunc_state = -1; last_annunc_state = -1;
draw_annunc(); draw_annunc();
} }
void init_annunc(void) { 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 = ann_tbl[ i ].pixmap =
XCreateBitmapFromData(dpy, disp.win, (char *)ann_tbl[i].bits, XCreateBitmapFromData( dpy, disp.win, ( char* )ann_tbl[ i ].bits,
ann_tbl[i].width, ann_tbl[i].height); ann_tbl[ i ].width, ann_tbl[ i ].height );
} }
} }

98
src/main.c
View file

@ -73,17 +73,17 @@
#include <langinfo.h> #include <langinfo.h>
#include <locale.h> #include <locale.h>
char *progname; char* progname;
char *res_name; char* res_name;
char *res_class; char* res_class;
int saved_argc; int saved_argc;
char **saved_argv; char** saved_argv;
saturn_t saturn; saturn_t saturn;
void signal_handler(int sig) { void signal_handler( int sig ) {
switch (sig) { switch ( sig ) {
case SIGINT: case SIGINT:
enter_debugger |= USER_INTERRUPT; enter_debugger |= USER_INTERRUPT;
break; break;
@ -91,63 +91,65 @@ void signal_handler(int sig) {
got_alarm = 1; got_alarm = 1;
break; break;
case SIGPIPE: case SIGPIPE:
exit_x48(0); exit_x48( 0 );
exit(0); exit( 0 );
default: default:
break; break;
} }
} }
void save_options(int argc, char **argv) { void save_options( int argc, char** argv ) {
int l; int l;
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",
exit(1); progname );
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",
exit(1); progname );
exit( 1 );
} }
memcpy(saved_argv[argc], argv[argc], l); memcpy( saved_argv[ argc ], argv[ argc ], l );
} }
} }
int main(int argc, char **argv) { int main( int argc, char** argv ) {
char *name; char* name;
sigset_t set; sigset_t set;
struct sigaction sa; struct sigaction sa;
long flags; long flags;
struct itimerval it; struct itimerval it;
setlocale(LC_ALL, "C"); setlocale( LC_ALL, "C" );
name = (char *)0; name = ( char* )0;
/* /*
* Get the name we are called. * Get the name we are called.
*/ */
progname = strrchr(argv[0], '/'); progname = strrchr( argv[ 0 ], '/' );
if (progname == NULL) if ( progname == NULL )
progname = argv[0]; progname = argv[ 0 ];
else else
progname++; progname++;
/* /*
* save command line options * save command line options
*/ */
save_options(argc, argv); save_options( argc, argv );
/* /*
* Open up the display * Open up the display
*/ */
if (InitDisplay(argc, argv) < 0) { if ( InitDisplay( argc, argv ) < 0 ) {
exit(1); exit( 1 );
} }
/* /*
@ -158,9 +160,9 @@ int main(int argc, char **argv) {
/* /*
* Create the HP-48 window * Create the HP-48 window
*/ */
if (CreateWindows(saved_argc, saved_argv) < 0) { if ( CreateWindows( saved_argc, saved_argv ) < 0 ) {
fprintf(stderr, "%s: can\'t create window\n", progname); fprintf( stderr, "%s: can\'t create window\n", progname );
exit(1); exit( 1 );
} }
/* /*
@ -171,38 +173,38 @@ int main(int argc, char **argv) {
/* /*
* install a handler for SIGALRM * install a handler for SIGALRM
*/ */
sigemptyset(&set); sigemptyset( &set );
sigaddset(&set, SIGALRM); sigaddset( &set, SIGALRM );
sa.sa_handler = signal_handler; sa.sa_handler = signal_handler;
sa.sa_mask = set; sa.sa_mask = set;
#ifdef SA_RESTART #ifdef SA_RESTART
sa.sa_flags = SA_RESTART; sa.sa_flags = SA_RESTART;
#endif #endif
sigaction(SIGALRM, &sa, (struct sigaction *)0); sigaction( SIGALRM, &sa, ( struct sigaction* )0 );
/* /*
* install a handler for SIGINT * install a handler for SIGINT
*/ */
sigemptyset(&set); sigemptyset( &set );
sigaddset(&set, SIGINT); sigaddset( &set, SIGINT );
sa.sa_handler = signal_handler; sa.sa_handler = signal_handler;
sa.sa_mask = set; sa.sa_mask = set;
#ifdef SA_RESTART #ifdef SA_RESTART
sa.sa_flags = SA_RESTART; sa.sa_flags = SA_RESTART;
#endif #endif
sigaction(SIGINT, &sa, (struct sigaction *)0); sigaction( SIGINT, &sa, ( struct sigaction* )0 );
/* /*
* install a handler for SIGPIPE * install a handler for SIGPIPE
*/ */
sigemptyset(&set); sigemptyset( &set );
sigaddset(&set, SIGPIPE); sigaddset( &set, SIGPIPE );
sa.sa_handler = signal_handler; sa.sa_handler = signal_handler;
sa.sa_mask = set; sa.sa_mask = set;
#ifdef SA_RESTART #ifdef SA_RESTART
sa.sa_flags = SA_RESTART; sa.sa_flags = SA_RESTART;
#endif #endif
sigaction(SIGPIPE, &sa, (struct sigaction *)0); sigaction( SIGPIPE, &sa, ( struct sigaction* )0 );
/* /*
* set the real time interval timer * set the real time interval timer
@ -211,26 +213,26 @@ int main(int argc, char **argv) {
it.it_interval.tv_usec = 20000; it.it_interval.tv_usec = 20000;
it.it_value.tv_sec = 0; it.it_value.tv_sec = 0;
it.it_value.tv_usec = 20000; it.it_value.tv_usec = 20000;
setitimer(ITIMER_REAL, &it, (struct itimerval *)0); setitimer( ITIMER_REAL, &it, ( struct itimerval* )0 );
/* /*
* Set stdin flags to not include O_NDELAY and O_NONBLOCK * Set stdin flags to not include O_NDELAY and O_NONBLOCK
*/ */
flags = fcntl(STDIN_FILENO, F_GETFL, 0); flags = fcntl( STDIN_FILENO, F_GETFL, 0 );
flags &= ~O_NDELAY; flags &= ~O_NDELAY;
flags &= ~O_NONBLOCK; flags &= ~O_NONBLOCK;
fcntl(STDIN_FILENO, F_SETFL, flags); fcntl( STDIN_FILENO, F_SETFL, flags );
do { do {
if (!exec_flags) if ( !exec_flags )
emulate(); emulate();
else else
emulate_debug(); emulate_debug();
debug(); debug();
} while (1); } while ( 1 );
return 0; return 0;
} }

1306
src/memory.c
View file

File diff suppressed because it is too large Load diff

75
src/mkcard.c
View file

@ -33,71 +33,72 @@
#include <unistd.h> #include <unistd.h>
#include <fcntl.h> #include <fcntl.h>
unsigned char *mem; 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;
} }
fclose(fp); fclose( fp );
return 1; return 1;
} }
int main(int argc, char **argv) { int main( int argc, char** argv ) {
long size; long size;
char *name; char* name;
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 );
} }
name = argv[2]; name = argv[ 2 ];
asize = argv[1]; asize = argv[ 1 ];
if (!strcmp(asize, "32K")) if ( !strcmp( asize, "32K" ) )
size = 0x8000; size = 0x8000;
else if (!strcmp(asize, "128K")) else if ( !strcmp( asize, "128K" ) )
size = 0x20000; size = 0x20000;
else if (!strcmp(asize, "256K")) else if ( !strcmp( asize, "256K" ) )
size = 0x40000; size = 0x40000;
else if (!strcmp(asize, "512K")) else if ( !strcmp( asize, "512K" ) )
size = 0x80000; size = 0x80000;
else if (!strcmp(asize, "1M")) else if ( !strcmp( asize, "1M" ) )
size = 0x100000; size = 0x100000;
else if (!strcmp(asize, "2M")) else if ( !strcmp( asize, "2M" ) )
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 ] );
exit(1); exit( 1 );
} }
if ((core = (unsigned char *)malloc(size)) == NULL) { if ( ( core = ( unsigned char* )malloc( size ) ) == NULL ) {
fprintf(stderr, "%s: can\'t malloc %ld bytes\n", argv[0], size); fprintf( stderr, "%s: can\'t malloc %ld bytes\n", argv[ 0 ], size );
exit(1); exit( 1 );
} }
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 );
} }
exit(0); exit( 0 );
} }

28
src/options.c
View file

@ -50,8 +50,8 @@
#include "constants.h" #include "constants.h"
#include "resources.h" #include "resources.h"
void usage(void) { void usage( void ) {
fprintf(stdout, "\n\ fprintf( stdout, "\n\
x48 Version %d.%d.%d, Copyright (c) 1994-2005 by Eddie C. Dost <ecd@dressler.de>.\n\ x48 Version %d.%d.%d, Copyright (c) 1994-2005 by Eddie C. Dost <ecd@dressler.de>.\n\
\n\ \n\
usage:\n\t%s [-options ...]\n\ usage:\n\t%s [-options ...]\n\
@ -91,22 +91,22 @@ where options include:\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", \n",
VERSION_MAJOR, VERSION_MINOR, PATCHLEVEL, progname); VERSION_MAJOR, VERSION_MINOR, PATCHLEVEL, progname );
fflush(stdout); fflush( stdout );
exit(1); exit( 1 );
} }
void show_version(void) { 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 #%d\n\n", Compiled on %s #%d\n\n",
progname, VERSION_MAJOR, VERSION_MINOR, PATCHLEVEL, COMPILE_TIME, progname, VERSION_MAJOR, VERSION_MINOR, PATCHLEVEL, COMPILE_TIME,
COMPILE_VERSION); COMPILE_VERSION );
} }
void show_copyright(void) { void show_copyright( void ) {
fprintf(stdout, "\n\ fprintf( stdout, "\n\
COPYRIGHT\n\ COPYRIGHT\n\
\n\ \n\
X48 is an Emulator/Debugger for the HP-48 Handheld Calculator.\n\ X48 is an Emulator/Debugger for the HP-48 Handheld Calculator.\n\
@ -124,11 +124,11 @@ GNU General Public License for more details.\n\
\n\ \n\
You should have received a copy of the GNU General Public License\n\ You should have received a copy of the GNU General Public License\n\
along with this program; if not, write to the Free Software\n\ along with this program; if not, write to the Free Software\n\
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.\n\n"); Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.\n\n" );
} }
void show_warranty(void) { void show_warranty( void ) {
fprintf(stdout, "\n\ fprintf( stdout, "\n\
NO WARRANTY\n\ NO WARRANTY\n\
\n\ \n\
BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY\n\ BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY\n\
@ -149,5 +149,5 @@ OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED\n\
TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY\n\ TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY\n\
YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER\n\ YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER\n\
PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE\n\ PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE\n\
POSSIBILITY OF SUCH DAMAGES.\n\n"); POSSIBILITY OF SUCH DAMAGES.\n\n" );
} }

104
src/options.h
View file

@ -49,72 +49,72 @@
#include <X11/Xresource.h> #include <X11/Xresource.h>
static XrmOptionDescRec options[] = { static XrmOptionDescRec options[] = {
{"-display", ".display", XrmoptionSepArg, (void *)0}, { "-display", ".display", XrmoptionSepArg, ( void* )0 },
{"-geometry", "*geometry", XrmoptionSepArg, (void *)0}, { "-geometry", "*geometry", XrmoptionSepArg, ( void* )0 },
{"-iconGeom", "*iconGeom", XrmoptionSepArg, (void *)0}, { "-iconGeom", "*iconGeom", XrmoptionSepArg, ( void* )0 },
{"-iconName", "*iconName", XrmoptionSepArg, (void *)0}, { "-iconName", "*iconName", XrmoptionSepArg, ( void* )0 },
{"-iconic", "*iconic", XrmoptionNoArg, (void *)"True"}, { "-iconic", "*iconic", XrmoptionNoArg, ( void* )"True" },
{"-name", (char *)0, XrmoptionSepArg, (void *)0}, { "-name", ( char* )0, XrmoptionSepArg, ( void* )0 },
{"-title", "*title", XrmoptionSepArg, (void *)0}, { "-title", "*title", XrmoptionSepArg, ( void* )0 },
{"-xshm", "*useXShm", XrmoptionNoArg, (void *)"True"}, { "-xshm", "*useXShm", XrmoptionNoArg, ( void* )"True" },
{"+xshm", "*useXShm", XrmoptionNoArg, (void *)"False"}, { "+xshm", "*useXShm", XrmoptionNoArg, ( void* )"False" },
{"-visual", "*visual", XrmoptionSepArg, (void *)0}, { "-visual", "*visual", XrmoptionSepArg, ( void* )0 },
{"-mono", "*mono", XrmoptionNoArg, (void *)"True"}, { "-mono", "*mono", XrmoptionNoArg, ( void* )"True" },
{"-gray", "*gray", XrmoptionNoArg, (void *)"True"}, { "-gray", "*gray", XrmoptionNoArg, ( void* )"True" },
{"-monoIcon", "*monoIcon", XrmoptionNoArg, (void *)"True"}, { "-monoIcon", "*monoIcon", XrmoptionNoArg, ( void* )"True" },
{"-version", "*printVersion", XrmoptionNoArg, (void *)"True"}, { "-version", "*printVersion", XrmoptionNoArg, ( void* )"True" },
{"-copyright", "*printCopyright", XrmoptionNoArg, (void *)"True"}, { "-copyright", "*printCopyright", XrmoptionNoArg, ( void* )"True" },
{"-warranty", "*printWarranty", XrmoptionNoArg, (void *)"True"}, { "-warranty", "*printWarranty", XrmoptionNoArg, ( void* )"True" },
{"-smallFont", "*smallLabelFont", XrmoptionSepArg, (void *)0}, { "-smallFont", "*smallLabelFont", XrmoptionSepArg, ( void* )0 },
{"-mediumFont", "*mediumLabelFont", XrmoptionSepArg, (void *)0}, { "-mediumFont", "*mediumLabelFont", XrmoptionSepArg, ( void* )0 },
{"-largeFont", "*largeLabelFont", XrmoptionSepArg, (void *)0}, { "-largeFont", "*largeLabelFont", XrmoptionSepArg, ( void* )0 },
{"-connFont", "*connectionFont", XrmoptionSepArg, (void *)0}, { "-connFont", "*connectionFont", XrmoptionSepArg, ( void* )0 },
{"-verbose", "*verbose", XrmoptionNoArg, (void *)"True"}, { "-verbose", "*verbose", XrmoptionNoArg, ( void* )"True" },
{"-quiet", "*quiet", XrmoptionNoArg, (void *)"True"}, { "-quiet", "*quiet", XrmoptionNoArg, ( void* )"True" },
{"-terminal", "*useTerminal", XrmoptionNoArg, (void *)"True"}, { "-terminal", "*useTerminal", XrmoptionNoArg, ( void* )"True" },
{"+terminal", "*useTerminal", XrmoptionNoArg, (void *)"False"}, { "+terminal", "*useTerminal", XrmoptionNoArg, ( void* )"False" },
{"-serial", "*useSerial", XrmoptionNoArg, (void *)"True"}, { "-serial", "*useSerial", XrmoptionNoArg, ( void* )"True" },
{"+serial", "*useSerial", XrmoptionNoArg, (void *)"False"}, { "+serial", "*useSerial", XrmoptionNoArg, ( void* )"False" },
{"-line", "*serialLine", XrmoptionSepArg, (void *)0}, { "-line", "*serialLine", XrmoptionSepArg, ( void* )0 },
{"-initialize", "*completeInitialize", XrmoptionNoArg, (void *)"True"}, { "-initialize", "*completeInitialize", XrmoptionNoArg, ( void* )"True" },
{"-reset", "*resetOnStartup", XrmoptionNoArg, (void *)"True"}, { "-reset", "*resetOnStartup", XrmoptionNoArg, ( void* )"True" },
{"-rom", "*romFileName", XrmoptionSepArg, (void *)0}, { "-rom", "*romFileName", XrmoptionSepArg, ( void* )0 },
{"-home", "*homeDirectory", XrmoptionSepArg, (void *)0}, { "-home", "*homeDirectory", XrmoptionSepArg, ( void* )0 },
{"-debug", "*useDebugger", XrmoptionNoArg, (void *)"False"}, { "-debug", "*useDebugger", XrmoptionNoArg, ( void* )"False" },
{"+debug", "*useDebugger", XrmoptionNoArg, (void *)"True"}, { "+debug", "*useDebugger", XrmoptionNoArg, ( void* )"True" },
{"-disasm", "*disassemblerMnemonics", XrmoptionSepArg, (void *)0}, { "-disasm", "*disassemblerMnemonics", XrmoptionSepArg, ( void* )0 },
{"-xrm", (char *)0, XrmoptionResArg, (void *)0}, { "-xrm", ( char* )0, XrmoptionResArg, ( void* )0 },
{"-netbook", "*netbook", XrmoptionNoArg, (void *)"False"}, { "-netbook", "*netbook", XrmoptionNoArg, ( void* )"False" },
{"+netbook", "*netbook", XrmoptionNoArg, (void *)"True"}, { "+netbook", "*netbook", XrmoptionNoArg, ( void* )"True" },
{"-throttle", "*throttle", XrmoptionNoArg, (void *)"False"}, { "-throttle", "*throttle", XrmoptionNoArg, ( void* )"False" },
{"+throttle", "*throttle", XrmoptionNoArg, (void *)"True"}, { "+throttle", "*throttle", XrmoptionNoArg, ( void* )"True" },
/* /*
* these are parsed for compatibility, but not used yet. * these are parsed for compatibility, but not used yet.
*/ */
{"-bg", "*background", XrmoptionSepArg, (void *)0}, { "-bg", "*background", XrmoptionSepArg, ( void* )0 },
{"-background", "*background", XrmoptionSepArg, (void *)0}, { "-background", "*background", XrmoptionSepArg, ( void* )0 },
{"-bd", "*borderColor", XrmoptionSepArg, (void *)0}, { "-bd", "*borderColor", XrmoptionSepArg, ( void* )0 },
{"-bordercolor", "*borderColor", XrmoptionSepArg, (void *)0}, { "-bordercolor", "*borderColor", XrmoptionSepArg, ( void* )0 },
{"-bw", "*borderWidth", XrmoptionSepArg, (void *)0}, { "-bw", "*borderWidth", XrmoptionSepArg, ( void* )0 },
{"-borderwidth", "*borderWidth", XrmoptionSepArg, (void *)0}, { "-borderwidth", "*borderWidth", XrmoptionSepArg, ( void* )0 },
{"-fg", "*foreground", XrmoptionSepArg, (void *)0}, { "-fg", "*foreground", XrmoptionSepArg, ( void* )0 },
{"-foreground", "*foreground", XrmoptionSepArg, (void *)0}, { "-foreground", "*foreground", XrmoptionSepArg, ( void* )0 },
{"-fn", "*fontName", XrmoptionSepArg, (void *)0}, { "-fn", "*fontName", XrmoptionSepArg, ( void* )0 },
{"-font", "*fontName", XrmoptionSepArg, (void *)0}, { "-font", "*fontName", XrmoptionSepArg, ( void* )0 },
{"-rv", "*reverseVideo", XrmoptionNoArg, (void *)"True"}, { "-rv", "*reverseVideo", XrmoptionNoArg, ( void* )"True" },
{"+rv", "*reverseVideo", XrmoptionNoArg, (void *)"False"}, { "+rv", "*reverseVideo", XrmoptionNoArg, ( void* )"False" },
{"-reverse", "*reverseVideo", XrmoptionNoArg, (void *)"True"}, { "-reverse", "*reverseVideo", XrmoptionNoArg, ( void* )"True" },
}; };

413
src/register.c
View file

@ -50,426 +50,426 @@
#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[] = {-1, 0, 2, 0, 15, 3, 0, 0, -1, 0, static int start_fields[] = { -1, 0, 2, 0, 15, 3, 0, 0, -1, 0,
2, 0, 15, 3, 0, 0, 0, 0, 0}; 2, 0, 15, 3, 0, 0, 0, 0, 0 };
static int end_fields[] = {-1, -1, 2, 2, 15, 14, 1, 15, -1, -1, static int end_fields[] = { -1, -1, 2, 2, 15, 14, 1, 15, -1, -1,
2, 2, 15, 14, 1, 4, 3, 2, 0}; 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;
if ((s = start_fields[code]) == -1) { if ( ( s = start_fields[ code ] ) == -1 ) {
s = saturn.P; s = saturn.P;
} }
return s; return s;
} }
static inline int get_end(int code) { static inline int get_end( int code ) {
int e; int e;
if ((e = end_fields[code]) == -1) { if ( ( e = end_fields[ code ] ) == -1 ) {
e = saturn.P; e = saturn.P;
} }
return e; return e;
} }
void add_register(unsigned char *res, unsigned char *r1, unsigned char *r2, void add_register( unsigned char* res, unsigned char* r1, 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 );
e = get_end(code); e = get_end( code );
c = 0; c = 0;
for (i = s; i <= e; i++) { for ( i = s; i <= e; i++ ) {
t = r1[i] + r2[i] + c; t = r1[ i ] + r2[ i ] + c;
if (t < (int)saturn.hexmode) { if ( t < ( int )saturn.hexmode ) {
res[i] = t & 0xf; res[ i ] = t & 0xf;
c = 0; c = 0;
} else { } else {
res[i] = (t - saturn.hexmode) & 0xf; res[ i ] = ( t - saturn.hexmode ) & 0xf;
c = 1; c = 1;
} }
} }
if (c) if ( c )
saturn.CARRY = 1; saturn.CARRY = 1;
else else
saturn.CARRY = 0; saturn.CARRY = 0;
} }
void add_p_plus_one(unsigned char *r) { void add_p_plus_one( unsigned char* r ) {
int t, c, i, s, e; int t, c, i, s, e;
s = 0; s = 0;
e = 4; e = 4;
c = saturn.P + 1; c = saturn.P + 1;
for (i = s; i <= e; i++) { for ( i = s; i <= e; i++ ) {
t = r[i] + c; t = r[ i ] + c;
if (t < 16) { if ( t < 16 ) {
r[i] = t & 0xf; r[ i ] = t & 0xf;
c = 0; c = 0;
} else { } else {
r[i] = (t - 16) & 0xf; r[ i ] = ( t - 16 ) & 0xf;
c = 1; c = 1;
} }
} }
if (c) if ( c )
saturn.CARRY = 1; saturn.CARRY = 1;
else else
saturn.CARRY = 0; saturn.CARRY = 0;
} }
void sub_register(unsigned char *res, unsigned char *r1, unsigned char *r2, void sub_register( unsigned char* res, unsigned char* r1, 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 );
e = get_end(code); e = get_end( code );
c = 0; c = 0;
for (i = s; i <= e; i++) { for ( i = s; i <= e; i++ ) {
t = r1[i] - r2[i] - c; t = r1[ i ] - r2[ i ] - c;
if (t >= 0) { if ( t >= 0 ) {
res[i] = t & 0xf; res[ i ] = t & 0xf;
c = 0; c = 0;
} else { } else {
res[i] = (t + saturn.hexmode) & 0xf; res[ i ] = ( t + saturn.hexmode ) & 0xf;
c = 1; c = 1;
} }
} }
if (c) if ( c )
saturn.CARRY = 1; saturn.CARRY = 1;
else else
saturn.CARRY = 0; saturn.CARRY = 0;
} }
void complement_2_register(unsigned char *r, int code) { void complement_2_register( unsigned char* r, int code ) {
int t, c, carry, i, s, e; int t, c, carry, i, s, e;
s = get_start(code); s = get_start( code );
e = get_end(code); e = get_end( code );
c = 1; c = 1;
carry = 0; carry = 0;
for (i = s; i <= e; i++) { for ( i = s; i <= e; i++ ) {
t = (saturn.hexmode - 1) - r[i] + c; t = ( saturn.hexmode - 1 ) - r[ i ] + c;
if (t < (int)saturn.hexmode) { if ( t < ( int )saturn.hexmode ) {
r[i] = t & 0xf; r[ i ] = t & 0xf;
c = 0; c = 0;
} else { } else {
r[i] = (t - saturn.hexmode) & 0xf; r[ i ] = ( t - saturn.hexmode ) & 0xf;
c = 1; c = 1;
} }
carry += r[i]; carry += r[ i ];
} }
if (carry) if ( carry )
saturn.CARRY = 1; saturn.CARRY = 1;
else else
saturn.CARRY = 0; saturn.CARRY = 0;
} }
void complement_1_register(unsigned char *r, int code) { void complement_1_register( unsigned char* r, int code ) {
int t, i, s, e; int t, i, s, e;
s = get_start(code); s = get_start( code );
e = get_end(code); e = get_end( code );
for (i = s; i <= e; i++) { for ( i = s; i <= e; i++ ) {
t = (saturn.hexmode - 1) - r[i]; t = ( saturn.hexmode - 1 ) - r[ i ];
r[i] = t & 0xf; r[ i ] = t & 0xf;
} }
saturn.CARRY = 0; saturn.CARRY = 0;
} }
void inc_register(unsigned char *r, int code) { void inc_register( unsigned char* r, int code ) {
int t, c, i, s, e; int t, c, i, s, e;
s = get_start(code); s = get_start( code );
e = get_end(code); e = get_end( code );
c = 1; c = 1;
for (i = s; i <= e; i++) { for ( i = s; i <= e; i++ ) {
t = r[i] + c; t = r[ i ] + c;
if (t < (int)saturn.hexmode) { if ( t < ( int )saturn.hexmode ) {
r[i] = t & 0xf; r[ i ] = t & 0xf;
c = 0; c = 0;
break; break;
} else { } else {
r[i] = (t - saturn.hexmode) & 0xf; r[ i ] = ( t - saturn.hexmode ) & 0xf;
c = 1; c = 1;
} }
} }
if (c) if ( c )
saturn.CARRY = 1; saturn.CARRY = 1;
else else
saturn.CARRY = 0; saturn.CARRY = 0;
} }
void add_register_constant(unsigned char *r, int code, int val) { void add_register_constant( unsigned char* r, int code, int val ) {
int t, c, i, s, e; int t, c, i, s, e;
s = get_start(code); s = get_start( code );
e = get_end(code); e = get_end( code );
c = val; c = val;
for (i = s; i <= e; i++) { for ( i = s; i <= e; i++ ) {
t = r[i] + c; t = r[ i ] + c;
if (t < 16) { if ( t < 16 ) {
r[i] = t & 0xf; r[ i ] = t & 0xf;
c = 0; c = 0;
break; break;
} else { } else {
r[i] = (t - 16) & 0xf; r[ i ] = ( t - 16 ) & 0xf;
c = 1; c = 1;
} }
} }
if (c) if ( c )
saturn.CARRY = 1; saturn.CARRY = 1;
else else
saturn.CARRY = 0; saturn.CARRY = 0;
} }
void dec_register(unsigned char *r, int code) { void dec_register( unsigned char* r, int code ) {
int t, c, i, s, e; int t, c, i, s, e;
s = get_start(code); s = get_start( code );
e = get_end(code); e = get_end( code );
c = 1; c = 1;
for (i = s; i <= e; i++) { for ( i = s; i <= e; i++ ) {
t = r[i] - c; t = r[ i ] - c;
if (t >= 0) { if ( t >= 0 ) {
r[i] = t & 0xf; r[ i ] = t & 0xf;
c = 0; c = 0;
break; break;
} else { } else {
r[i] = (t + saturn.hexmode) & 0xf; r[ i ] = ( t + saturn.hexmode ) & 0xf;
c = 1; c = 1;
} }
} }
if (c) if ( c )
saturn.CARRY = 1; saturn.CARRY = 1;
else else
saturn.CARRY = 0; saturn.CARRY = 0;
} }
void sub_register_constant(unsigned char *r, int code, int val) { void sub_register_constant( unsigned char* r, int code, int val ) {
int t, c, i, s, e; int t, c, i, s, e;
s = get_start(code); s = get_start( code );
e = get_end(code); e = get_end( code );
c = val; c = val;
for (i = s; i <= e; i++) { for ( i = s; i <= e; i++ ) {
t = r[i] - c; t = r[ i ] - c;
if (t >= 0) { if ( t >= 0 ) {
r[i] = t & 0xf; r[ i ] = t & 0xf;
c = 0; c = 0;
break; break;
} else { } else {
r[i] = (t + 16) & 0xf; r[ i ] = ( t + 16 ) & 0xf;
c = 1; c = 1;
} }
} }
if (c) if ( c )
saturn.CARRY = 1; saturn.CARRY = 1;
else else
saturn.CARRY = 0; saturn.CARRY = 0;
} }
void zero_register(unsigned char *r, int code) { void zero_register( unsigned char* r, int code ) {
int i, s, e; int i, s, e;
s = get_start(code); s = get_start( code );
e = get_end(code); e = get_end( code );
for (i = s; i <= e; i++) for ( i = s; i <= e; i++ )
r[i] = 0; r[ i ] = 0;
} }
void or_register(unsigned char *res, unsigned char *r1, unsigned char *r2, void or_register( unsigned char* res, unsigned char* r1, unsigned char* r2,
int code) { int code ) {
int i, s, e; int i, s, e;
s = get_start(code); s = get_start( code );
e = get_end(code); e = get_end( code );
for (i = s; i <= e; i++) { for ( i = s; i <= e; i++ ) {
res[i] = (r1[i] | r2[i]) & 0xf; res[ i ] = ( r1[ i ] | r2[ i ] ) & 0xf;
} }
} }
void and_register(unsigned char *res, unsigned char *r1, unsigned char *r2, void and_register( unsigned char* res, unsigned char* r1, unsigned char* r2,
int code) { int code ) {
int i, s, e; int i, s, e;
s = get_start(code); s = get_start( code );
e = get_end(code); e = get_end( code );
for (i = s; i <= e; i++) { for ( i = s; i <= e; i++ ) {
res[i] = (r1[i] & r2[i]) & 0xf; res[ i ] = ( r1[ i ] & r2[ i ] ) & 0xf;
} }
} }
void copy_register(unsigned char *to, unsigned char *from, int code) { void copy_register( unsigned char* to, unsigned char* from, int code ) {
int i, s, e; int i, s, e;
s = get_start(code); s = get_start( code );
e = get_end(code); e = get_end( code );
for (i = s; i <= e; i++) for ( i = s; i <= e; i++ )
to[i] = from[i]; to[ i ] = from[ i ];
} }
void exchange_register(unsigned char *r1, unsigned char *r2, int code) { void exchange_register( unsigned char* r1, unsigned char* r2, int code ) {
int t, i, s, e; int t, i, s, e;
s = get_start(code); s = get_start( code );
e = get_end(code); e = get_end( code );
for (i = s; i <= e; i++) { for ( i = s; i <= e; i++ ) {
t = r1[i]; t = r1[ i ];
r1[i] = r2[i]; r1[ i ] = r2[ i ];
r2[i] = t; r2[ i ] = t;
} }
} }
void exchange_reg(unsigned char *r, word_20 *d, int code) { void exchange_reg( unsigned char* r, word_20* d, int code ) {
int t, i, s, e; int t, i, s, e;
s = get_start(code); s = get_start( code );
e = get_end(code); e = get_end( code );
for (i = s; i <= e; i++) { for ( i = s; i <= e; i++ ) {
t = r[i]; t = r[ i ];
r[i] = (*d >> (i * 4)) & 0x0f; r[ i ] = ( *d >> ( i * 4 ) ) & 0x0f;
*d &= ~nibble_masks[i]; *d &= ~nibble_masks[ i ];
*d |= t << (i * 4); *d |= t << ( i * 4 );
} }
} }
void shift_left_register(unsigned char *r, int code) { void shift_left_register( unsigned char* r, int code ) {
int i, s, e; int i, s, e;
s = get_start(code); s = get_start( code );
e = get_end(code); e = get_end( code );
for (i = e; i > s; i--) { for ( i = e; i > s; i-- ) {
r[i] = r[i - 1] & 0x0f; r[ i ] = r[ i - 1 ] & 0x0f;
} }
r[s] = 0; r[ s ] = 0;
} }
void shift_left_circ_register(unsigned char *r, int code) { void shift_left_circ_register( unsigned char* r, int code ) {
int t, i, s, e; int t, i, s, e;
s = get_start(code); s = get_start( code );
e = get_end(code); e = get_end( code );
t = r[e] & 0x0f; t = r[ e ] & 0x0f;
for (i = e; i > s; i--) { for ( i = e; i > s; i-- ) {
r[i] = r[i - 1] & 0x0f; r[ i ] = r[ i - 1 ] & 0x0f;
} }
r[s] = t; r[ s ] = t;
} }
void shift_right_register(unsigned char *r, int code) { void shift_right_register( unsigned char* r, int code ) {
int i, s, e; int i, s, e;
s = get_start(code); s = get_start( code );
e = get_end(code); e = get_end( code );
if (r[s] & 0x0f) if ( r[ s ] & 0x0f )
saturn.SB = 1; saturn.SB = 1;
for (i = s; i < e; i++) { for ( i = s; i < e; i++ ) {
r[i] = r[i + 1] & 0x0f; r[ i ] = r[ i + 1 ] & 0x0f;
} }
r[e] = 0; r[ e ] = 0;
} }
void shift_right_circ_register(unsigned char *r, int code) { void shift_right_circ_register( unsigned char* r, int code ) {
int t, i, s, e; int t, i, s, e;
s = get_start(code); s = get_start( code );
e = get_end(code); e = get_end( code );
t = r[s] & 0x0f; t = r[ s ] & 0x0f;
for (i = s; i < e; i++) { for ( i = s; i < e; i++ ) {
r[i] = r[i + 1] & 0x0f; r[ i ] = r[ i + 1 ] & 0x0f;
} }
r[e] = t; r[ e ] = t;
if (t) if ( t )
saturn.SB = 1; saturn.SB = 1;
} }
void shift_right_bit_register(unsigned char *r, int code) { void shift_right_bit_register( unsigned char* r, int code ) {
int t, i, s, e, sb; int t, i, s, e, sb;
s = get_start(code); s = get_start( code );
e = get_end(code); e = get_end( code );
sb = 0; sb = 0;
for (i = e; i >= s; i--) { for ( i = e; i >= s; i-- ) {
t = (((r[i] >> 1) & 7) | (sb << 3)) & 0x0f; t = ( ( ( r[ i ] >> 1 ) & 7 ) | ( sb << 3 ) ) & 0x0f;
sb = r[i] & 1; sb = r[ i ] & 1;
r[i] = t; r[ i ] = t;
} }
if (sb) if ( sb )
saturn.SB = 1; saturn.SB = 1;
} }
int is_zero_register(unsigned char *r, int code) { int is_zero_register( unsigned char* r, int code ) {
int z, i, s, e; int z, i, s, e;
s = get_start(code); s = get_start( code );
e = get_end(code); e = get_end( code );
z = 1; z = 1;
for (i = s; i <= e; i++) for ( i = s; i <= e; i++ )
if ((r[i] & 0xf) != 0) { if ( ( r[ i ] & 0xf ) != 0 ) {
z = 0; z = 0;
break; break;
} }
return z; return z;
} }
int is_not_zero_register(unsigned char *r, int code) { int is_not_zero_register( unsigned char* r, int code ) {
int z, i, s, e; int z, i, s, e;
s = get_start(code); s = get_start( code );
e = get_end(code); e = get_end( code );
z = 0; z = 0;
for (i = s; i <= e; i++) for ( i = s; i <= e; i++ )
if ((r[i] & 0xf) != 0) { if ( ( r[ i ] & 0xf ) != 0 ) {
z = 1; z = 1;
break; break;
} }
return z; return z;
} }
int is_equal_register(unsigned char *r1, unsigned char *r2, int code) { int is_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 );
e = get_end(code); e = get_end( code );
z = 1; z = 1;
for (i = s; i <= e; i++) for ( i = s; i <= e; i++ )
if ((r1[i] & 0xf) != (r2[i] & 0xf)) { if ( ( r1[ i ] & 0xf ) != ( r2[ i ] & 0xf ) ) {
z = 0; z = 0;
break; break;
} }
return z; return z;
} }
int is_not_equal_register(unsigned char *r1, unsigned char *r2, int code) { int is_not_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 );
e = get_end(code); e = get_end( code );
z = 0; z = 0;
for (i = s; i <= e; i++) for ( i = s; i <= e; i++ )
if ((r1[i] & 0xf) != (r2[i] & 0xf)) { if ( ( r1[ i ] & 0xf ) != ( r2[ i ] & 0xf ) ) {
z = 1; z = 1;
break; break;
} }
return z; return z;
} }
int is_less_register(unsigned char *r1, unsigned char *r2, int code) { int is_less_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 );
e = get_end(code); e = get_end( code );
z = 0; z = 0;
for (i = e; i >= s; i--) { for ( i = e; i >= s; i-- ) {
if ((int)(r1[i] & 0xf) < (int)(r2[i] & 0xf)) { if ( ( int )( r1[ i ] & 0xf ) < ( int )( r2[ i ] & 0xf ) ) {
z = 1; z = 1;
break; break;
} }
if ((int)(r1[i] & 0xf) > (int)(r2[i] & 0xf)) { if ( ( int )( r1[ i ] & 0xf ) > ( int )( r2[ i ] & 0xf ) ) {
z = 0; z = 0;
break; break;
} }
@ -477,18 +477,19 @@ int is_less_register(unsigned char *r1, unsigned char *r2, int code) {
return z; return z;
} }
int is_less_or_equal_register(unsigned char *r1, unsigned char *r2, int code) { int is_less_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 );
e = get_end(code); e = get_end( code );
z = 1; z = 1;
for (i = e; i >= s; i--) { for ( i = e; i >= s; i-- ) {
if ((int)(r1[i] & 0xf) < (int)(r2[i] & 0xf)) { if ( ( int )( r1[ i ] & 0xf ) < ( int )( r2[ i ] & 0xf ) ) {
z = 1; z = 1;
break; break;
} }
if ((int)(r1[i] & 0xf) > (int)(r2[i] & 0xf)) { if ( ( int )( r1[ i ] & 0xf ) > ( int )( r2[ i ] & 0xf ) ) {
z = 0; z = 0;
break; break;
} }
@ -496,18 +497,18 @@ int is_less_or_equal_register(unsigned char *r1, unsigned char *r2, int code) {
return z; return z;
} }
int is_greater_register(unsigned char *r1, unsigned char *r2, int code) { int is_greater_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 );
e = get_end(code); e = get_end( code );
z = 0; z = 0;
for (i = e; i >= s; i--) { for ( i = e; i >= s; i-- ) {
if ((int)(r1[i] & 0xf) > (int)(r2[i] & 0xf)) { if ( ( int )( r1[ i ] & 0xf ) > ( int )( r2[ i ] & 0xf ) ) {
z = 1; z = 1;
break; break;
} }
if ((int)(r1[i] & 0xf) < (int)(r2[i] & 0xf)) { if ( ( int )( r1[ i ] & 0xf ) < ( int )( r2[ i ] & 0xf ) ) {
z = 0; z = 0;
break; break;
} }
@ -515,19 +516,19 @@ 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 is_greater_or_equal_register( unsigned char* r1, unsigned char* r2,
int code) { int code ) {
int z, i, s, e; int z, i, s, e;
s = get_start(code); s = get_start( code );
e = get_end(code); e = get_end( code );
z = 1; z = 1;
for (i = e; i >= s; i--) { for ( i = e; i >= s; i-- ) {
if ((int)(r1[i] & 0xf) < (int)(r2[i] & 0xf)) { if ( ( int )( r1[ i ] & 0xf ) < ( int )( r2[ i ] & 0xf ) ) {
z = 0; z = 0;
break; break;
} }
if ((int)(r1[i] & 0xf) > (int)(r2[i] & 0xf)) { if ( ( int )( r1[ i ] & 0xf ) > ( int )( r2[ i ] & 0xf ) ) {
z = 1; z = 1;
break; break;
} }

291
src/resources.c
View file

@ -59,264 +59,269 @@
#include "errors.h" #include "errors.h"
#include "resources.h" #include "resources.h"
XrmDatabase rdb = (XrmDatabase)0; XrmDatabase rdb = ( XrmDatabase )0;
int verbose; int verbose;
int quiet; int quiet;
int useTerminal; int useTerminal;
int useSerial; int useSerial;
char *serialLine; char* serialLine;
int useXShm; int useXShm;
int useDebugger; int useDebugger;
int netbook; int netbook;
int throttle; int throttle;
int initialize; int initialize;
int resetOnStartup; int resetOnStartup;
char *romFileName; char* romFileName;
char *homeDirectory; char* homeDirectory;
void get_resources(void) { void get_resources( void ) {
if (get_boolean_resource("printVersion", "PrintVersion")) if ( get_boolean_resource( "printVersion", "PrintVersion" ) )
show_version(); show_version();
if (get_boolean_resource("printCopyright", "PrintCopyright")) if ( get_boolean_resource( "printCopyright", "PrintCopyright" ) )
show_copyright(); show_copyright();
if (get_boolean_resource("printWarranty", "PrintWarranty")) if ( get_boolean_resource( "printWarranty", "PrintWarranty" ) )
show_warranty(); show_warranty();
verbose = get_boolean_resource("verbose", "Verbose"); verbose = get_boolean_resource( "verbose", "Verbose" );
quiet = get_boolean_resource("quiet", "Quiet"); quiet = get_boolean_resource( "quiet", "Quiet" );
useXShm = get_boolean_resource("useXShm", "UseXShm"); useXShm = get_boolean_resource( "useXShm", "UseXShm" );
useTerminal = get_boolean_resource("useTerminal", "UseTerminal"); useTerminal = get_boolean_resource( "useTerminal", "UseTerminal" );
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", "CompleteInitialize"); initialize =
resetOnStartup = get_boolean_resource("resetOnStartup", "ResetOnStartup"); get_boolean_resource( "completeInitialize", "CompleteInitialize" );
romFileName = get_string_resource("romFileName", "RomFileName"); resetOnStartup = get_boolean_resource( "resetOnStartup", "ResetOnStartup" );
homeDirectory = get_string_resource("homeDirectory", "HomeDirectory"); romFileName = get_string_resource( "romFileName", "RomFileName" );
homeDirectory = get_string_resource( "homeDirectory", "HomeDirectory" );
useDebugger = get_boolean_resource("useDebugger", "UseDebugger"); useDebugger = get_boolean_resource( "useDebugger", "UseDebugger" );
disassembler_mode = disassembler_mode = get_mnemonic_resource( "disassemblerMnemonics",
get_mnemonic_resource("disassemblerMnemonics", "DisassemblerMnemonics"); "DisassemblerMnemonics" );
netbook = get_boolean_resource("netbook", "Netbook"); netbook = get_boolean_resource( "netbook", "Netbook" );
throttle = get_boolean_resource("throttle", "Throttle"); throttle = get_boolean_resource( "throttle", "Throttle" );
} }
char *get_string_resource_from_db(XrmDatabase db, char *name, char *class) { char* get_string_resource_from_db( XrmDatabase db, char* name, char* class ) {
XrmValue value; XrmValue value;
char *type; char* type;
char full_name[1024], full_class[1024]; char full_name[ 1024 ], full_class[ 1024 ];
strcpy(full_name, res_name); strcpy( full_name, res_name );
strcat(full_name, "."); strcat( full_name, "." );
strcat(full_name, name); strcat( full_name, name );
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;
return str; return str;
} }
return (char *)0; return ( char* )0;
} }
char *get_string_resource(char *name, char *class) { char* get_string_resource( char* name, char* class ) {
return get_string_resource_from_db(rdb, name, class); return get_string_resource_from_db( rdb, name, class );
} }
int get_mnemonic_resource(char *name, char *class) { int get_mnemonic_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) if ( !s )
return CLASS_MNEMONICS; 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;
free(os); free( os );
if (!strcmp(buf, "hp")) if ( !strcmp( buf, "hp" ) )
return HP_MNEMONICS; return HP_MNEMONICS;
if (!strcmp(buf, "class")) if ( !strcmp( buf, "class" ) )
return CLASS_MNEMONICS; return CLASS_MNEMONICS;
fprintf(stderr, "%s: %s must be one of \'HP\' or \'class\', not %s.\n", fprintf( stderr, "%s: %s must be one of \'HP\' or \'class\', not %s.\n",
progname, name, buf); progname, name, buf );
return CLASS_MNEMONICS; return CLASS_MNEMONICS;
} }
int get_boolean_resource(char *name, char *class) { 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) if ( !s )
return 0; 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;
free(os); free( os );
if (!strcmp(buf, "on") || !strcmp(buf, "true") || !strcmp(buf, "yes")) if ( !strcmp( buf, "on" ) || !strcmp( buf, "true" ) ||
!strcmp( buf, "yes" ) )
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", progname, name, buf); fprintf( stderr, "%s: %s must be boolean, not %s.\n", 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) if ( !s )
return 0; return 0;
if (1 == sscanf(s, " %d %c", &val, &c)) { 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", progname, name, s); fprintf( stderr, "%s: %s must be an integer, not %s.\n", progname, name,
free(s); s );
free( s );
return 0; return 0;
} }
unsigned int get_pixel_resource(char *name, char *class, Display *dpy, 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) if ( !s )
goto DEFAULT; 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) if ( s )
free(s); free( s );
return (strcmp(class, "Background") ? WhitePixel(dpy, DefaultScreen(dpy)) return ( strcmp( class, "Background" )
: BlackPixel(dpy, DefaultScreen(dpy))); ? WhitePixel( dpy, DefaultScreen( dpy ) )
: BlackPixel( dpy, DefaultScreen( dpy ) ) );
} }
static Visual *pick_visual_of_class(Display *dpy, int visual_class, static Visual* pick_visual_of_class( Display* dpy, int visual_class,
unsigned int *depth) { 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_in, vi_out = XGetVisualInfo( dpy, VisualClassMask | VisualScreenMask, &vi_in,
&out_count); &out_count );
if (vi_out) { /* choose the 'best' one, if multiple */ if ( vi_out ) { /* 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++ )
if (vi_out[i].depth > vi_out[best].depth) if ( vi_out[ i ].depth > vi_out[ best ].depth )
best = i; best = i;
visual = vi_out[best].visual; visual = vi_out[ best ].visual;
*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 ) );
} }
} }
static Visual *id_to_visual(Display *dpy, int id, unsigned int *depth) { static Visual* id_to_visual( Display* dpy, int id, unsigned int* depth ) {
XVisualInfo vi_in, *vi_out; XVisualInfo vi_in, *vi_out;
int out_count; int out_count;
vi_in.screen = DefaultScreen(dpy); vi_in.screen = DefaultScreen( dpy );
vi_in.visualid = id; vi_in.visualid = id;
vi_out = vi_out = XGetVisualInfo( dpy, VisualScreenMask | VisualIDMask, &vi_in,
XGetVisualInfo(dpy, VisualScreenMask | VisualIDMask, &vi_in, &out_count); &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 );
return v; return v;
} }
return 0; return 0;
} }
Visual *get_visual_resource(Display *dpy, char *name, char *class, Visual* get_visual_resource( Display* dpy, char* name, char* class,
unsigned int *depth) { unsigned int* depth ) {
char c; char c;
char *tmp, *s; char *tmp, *s;
int vclass; int vclass;
int id; int id;
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)) if ( isupper( *tmp ) )
*tmp = _tolower(*tmp); *tmp = _tolower( *tmp );
if (!s || !strcmp(s, "default")) if ( !s || !strcmp( s, "default" ) )
vclass = -1; vclass = -1;
else if (!strcmp(s, "staticgray")) else if ( !strcmp( s, "staticgray" ) )
vclass = StaticGray; vclass = StaticGray;
else if (!strcmp(s, "staticcolor")) else if ( !strcmp( s, "staticcolor" ) )
vclass = StaticColor; vclass = StaticColor;
else if (!strcmp(s, "truecolor")) else if ( !strcmp( s, "truecolor" ) )
vclass = TrueColor; vclass = TrueColor;
else if (!strcmp(s, "grayscale")) else if ( !strcmp( s, "grayscale" ) )
vclass = GrayScale; vclass = GrayScale;
else if (!strcmp(s, "pseudocolor")) else if ( !strcmp( s, "pseudocolor" ) )
vclass = PseudoColor; vclass = PseudoColor;
else if (!strcmp(s, "directcolor")) else if ( !strcmp( s, "directcolor" ) )
vclass = DirectColor; vclass = DirectColor;
else if (1 == sscanf(s, " %d %c", &id, &c)) else if ( 1 == sscanf( s, " %d %c", &id, &c ) )
vclass = -2; vclass = -2;
else if (1 == sscanf(s, " 0x%x %c", &id, &c)) else if ( 1 == sscanf( s, " 0x%x %c", &id, &c ) )
vclass = -2; vclass = -2;
else { 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) if ( s )
free(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) if ( v )
return 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 );
} }
XFontStruct *get_font_resource(Display *dpy, char *name, char *class) { XFontStruct* get_font_resource( Display* dpy, char* name, char* class ) {
char *s; char* s;
XFontStruct *f = (XFontStruct *)0; XFontStruct* f = ( XFontStruct* )0;
s = get_string_resource(name, class); s = get_string_resource( name, 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();
} }
return f; return f;

54
src/resources.h
View file

@ -49,47 +49,47 @@ extern int useXShm;
extern int useDebugger; extern int useDebugger;
extern int netbook; extern int netbook;
extern int throttle; extern int throttle;
extern char *serialLine; extern char* serialLine;
extern int initialize; extern int initialize;
extern int resetOnStartup; extern int resetOnStartup;
extern char *romFileName; extern char* romFileName;
extern char *homeDirectory; extern char* homeDirectory;
extern char *progname; extern char* progname;
extern char *res_name; extern char* res_name;
extern char *res_class; extern char* res_class;
extern XrmDatabase rdb; extern XrmDatabase rdb;
extern void usage __ProtoType__((void)); extern void usage __ProtoType__( ( void ));
extern void show_version __ProtoType__((void)); extern void show_version __ProtoType__( ( void ));
extern void show_copyright __ProtoType__((void)); extern void show_copyright __ProtoType__( ( void ));
extern void show_warranty __ProtoType__((void)); extern void show_warranty __ProtoType__( ( void ));
extern void get_resources __ProtoType__((void)); 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, char *class)); extern char* get_string_resource __ProtoType__( ( char* name, char* class ) );
extern int get_boolean_resource __ProtoType__((char *name, char *class)); extern int get_boolean_resource __ProtoType__( ( char* name, char* class ) );
extern int get_mnemonic_resource __ProtoType__((char *name, char *class)); extern int get_mnemonic_resource __ProtoType__( ( char* name, char* class ) );
extern Visual *get_visual_resource __ProtoType__((Display * dpy, char *name, 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,
char *res_name, char* res_name,
char *res_class)); char* res_class ) );
#ifndef isupper #ifndef isupper
#define isupper(c) ((c) >= 'A' && (c) <= 'Z') #define isupper( c ) ( ( c ) >= 'A' && ( c ) <= 'Z' )
#endif #endif
#ifndef islower #ifndef islower
#define islower(c) ((c) >= 'a' && (c) <= 'z') #define islower( c ) ( ( c ) >= 'a' && ( c ) <= 'z' )
#endif #endif
#ifndef _tolower #ifndef _tolower
#define _tolower(c) ((c) - 'A' + 'a') #define _tolower( c ) ( ( c ) - 'A' + 'a' )
#endif #endif
#ifndef _toupper #ifndef _toupper
#define _toupper(c) ((c) - 'a' + 'A') #define _toupper( c ) ( ( c ) - 'a' + 'A' )
#endif #endif
#endif /* !_RESOURCES_H */ #endif /* !_RESOURCES_H */

143
src/romio.c
View file

@ -37,70 +37,70 @@
unsigned int opt_gx = 0; unsigned int opt_gx = 0;
unsigned int rom_size = 0; unsigned int rom_size = 0;
int read_rom_file(char *name, unsigned char **mem, int *size) { int read_rom_file( char* name, unsigned char** mem, int* size ) {
struct stat st; struct stat st;
FILE *fp; FILE* fp;
unsigned char *tmp_mem; unsigned char* tmp_mem;
unsigned char byte; unsigned char byte;
unsigned char four[4]; unsigned char four[ 4 ];
int i, j; int i, j;
*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 && four[2] == 0x06 && if ( four[ 0 ] == 0x02 && four[ 1 ] == 0x03 && 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[ 2 ] == 0x1b &&
four[3] == 0x80) { 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 );
return 0; return 0;
} }
*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;
*size = 0; *size = 0;
fclose(fp); fclose( fp );
return 0; return 0;
} }
} else { } else {
@ -108,85 +108,86 @@ int read_rom_file(char *name, unsigned char **mem, int *size) {
* 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", name,
*size / 2, st.st_size); *size / 2, st.st_size );
free(*mem); free( *mem );
*mem = NULL; *mem = NULL;
*size = 0; *size = 0;
fclose(fp); fclose( fp );
return 0; return 0;
} }
if (NULL == (tmp_mem = (unsigned char *)malloc((size_t)st.st_size))) { if ( NULL ==
for (i = 0, j = 0; i < *size / 2; i++) { ( tmp_mem = ( unsigned char* )malloc( ( size_t )st.st_size ) ) ) {
if (1 != fread(&byte, 1, 1, fp)) { for ( i = 0, j = 0; i < *size / 2; i++ ) {
fprintf(stderr, "can\'t read %s\n", name); if ( 1 != fread( &byte, 1, 1, fp ) ) {
free(*mem); fprintf( stderr, "can\'t read %s\n", name );
free( *mem );
*mem = NULL; *mem = NULL;
*size = 0; *size = 0;
fclose(fp); fclose( fp );
return 0; return 0;
} }
(*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;
*size = 0; *size = 0;
fclose(fp); fclose( fp );
free(tmp_mem); free( tmp_mem );
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;
} }
free(tmp_mem); free( tmp_mem );
} }
} }
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 if ( *size == 4 * ROM_SIZE_GX ) {
fprintf(stderr, "%s seems to be HP49 ROM, but size is 0x%x\n", name, fprintf( stderr, "%s seems to be HP49 ROM, but size is 0x%x\n",
*size); name, *size );
opt_gx = 2; opt_gx = 2;
} else if (*size == 8 * ROM_SIZE_GX) { } else if ( *size == 8 * ROM_SIZE_GX ) {
fprintf(stderr, "%s seems to be HP49 ROM, but size is 0x%x\n", name, fprintf( stderr, "%s seems to be HP49 ROM, but size is 0x%x\n",
*size); 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, fprintf( stderr, "%s seems to be G/GX ROM, but size is 0x%x\n",
*size); 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, fprintf( stderr, "%s seems to be S/SX ROM, but size is 0x%x\n",
*size); name, *size );
free(*mem); free( *mem );
*mem = NULL; *mem = NULL;
*size = 0; *size = 0;
return 0; return 0;
} }
} }
if (verbose) if ( verbose )
printf("%s: read %s\n", progname, name); printf( "%s: read %s\n", progname, name );
return 1; return 1;
} }

5
src/romio.h
View file

@ -36,8 +36,7 @@
extern unsigned int opt_gx; extern unsigned int opt_gx;
extern unsigned int rom_size; extern unsigned int rom_size;
extern int read_rom_file __ProtoType__((char *name, extern int read_rom_file __ProtoType__( ( char* name, unsigned char** mem,
unsigned char **mem, int* size ) );
int *size));
#endif /* !_ROMIO_H */ #endif /* !_ROMIO_H */

882
src/rpl.c
View file

File diff suppressed because it is too large Load diff

54
src/rpl.h
View file

@ -100,33 +100,33 @@ typedef struct hp_real {
word_1 s; word_1 s;
} 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, extern void decode_rpl_obj_2 __ProtoType__( ( word_20 addr, char* typ,
char *dat)); 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 ) );
extern char *dec_bin_int __ProtoType__((word_20 * addr, char *string)); extern char* dec_bin_int __ProtoType__( ( word_20 * addr, char* string ) );
extern char *dec_real __ProtoType__((word_20 * addr, char *string)); extern char* dec_real __ProtoType__( ( word_20 * addr, char* string ) );
extern char *dec_long_real __ProtoType__((word_20 * addr, char *string)); extern char* dec_long_real __ProtoType__( ( word_20 * addr, char* string ) );
extern char *dec_complex __ProtoType__((word_20 * addr, char *string)); extern char* dec_complex __ProtoType__( ( word_20 * addr, char* string ) );
extern char *dec_long_complex __ProtoType__((word_20 * addr, char *string)); extern char* dec_long_complex __ProtoType__( ( word_20 * addr, char* string ) );
extern char *dec_char __ProtoType__((word_20 * addr, char *string)); extern char* dec_char __ProtoType__( ( word_20 * addr, char* string ) );
extern char *dec_array __ProtoType__((word_20 * addr, char *string)); extern char* dec_array __ProtoType__( ( word_20 * addr, char* string ) );
extern char *dec_lnk_array __ProtoType__((word_20 * addr, char *string)); extern char* dec_lnk_array __ProtoType__( ( word_20 * addr, char* string ) );
extern char *dec_string __ProtoType__((word_20 * addr, char *string)); extern char* dec_string __ProtoType__( ( word_20 * addr, char* string ) );
extern char *dec_hex_string __ProtoType__((word_20 * addr, char *string)); extern char* dec_hex_string __ProtoType__( ( word_20 * addr, char* string ) );
extern char *dec_list __ProtoType__((word_20 * addr, char *string)); extern char* dec_list __ProtoType__( ( word_20 * addr, char* string ) );
extern char *dec_symb __ProtoType__((word_20 * addr, char *string)); extern char* dec_symb __ProtoType__( ( word_20 * addr, char* string ) );
extern char *dec_unit __ProtoType__((word_20 * addr, char *string)); extern char* dec_unit __ProtoType__( ( word_20 * addr, char* string ) );
extern char *dec_library __ProtoType__((word_20 * addr, char *string)); extern char* dec_library __ProtoType__( ( word_20 * addr, char* string ) );
extern char *dec_library_data __ProtoType__((word_20 * addr, char *string)); extern char* dec_library_data __ProtoType__( ( word_20 * addr, char* string ) );
extern char *dec_acptr __ProtoType__((word_20 * addr, char *string)); extern char* dec_acptr __ProtoType__( ( word_20 * addr, char* string ) );
extern char *dec_prog __ProtoType__((word_20 * addr, char *string)); extern char* dec_prog __ProtoType__( ( word_20 * addr, char* string ) );
extern char *dec_code __ProtoType__((word_20 * addr, char *string)); extern char* dec_code __ProtoType__( ( word_20 * addr, char* string ) );
extern char *dec_global_ident __ProtoType__((word_20 * addr, char *string)); extern char* dec_global_ident __ProtoType__( ( word_20 * addr, char* string ) );
extern char *dec_local_ident __ProtoType__((word_20 * addr, char *string)); extern char* dec_local_ident __ProtoType__( ( word_20 * addr, char* string ) );
extern char *dec_xlib_name __ProtoType__((word_20 * addr, char *string)); extern char* dec_xlib_name __ProtoType__( ( word_20 * addr, char* string ) );
extern char *dec_unit_op __ProtoType__((word_20 * addr, char *string)); extern char* dec_unit_op __ProtoType__( ( word_20 * addr, char* string ) );
#endif /* !_RPL_H */ #endif /* !_RPL_H */

413
src/serial.c
View file

@ -68,7 +68,7 @@
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.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 <termios.h> #include <termios.h>
@ -86,97 +86,106 @@ static int ttyp;
extern int rece_instr; extern int rece_instr;
static char *wire_name = (char *)0; static char* wire_name = ( char* )0;
static char *ir_name = (char *)0; 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 );
} }
int serial_init(void) { int serial_init( void ) {
char *p; char* p;
int c; int c;
int n; int n;
char tty_dev_name[128]; char tty_dev_name[ 128 ];
struct termios ttybuf; struct termios ttybuf;
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 ) ) >=
grantpt(wire_fd); 0 ) {
unlockpt(wire_fd); grantpt( wire_fd );
p = ptsname(wire_fd); unlockpt( wire_fd );
strcpy(tty_dev_name, p); p = ptsname( wire_fd );
if ((ttyp = open(tty_dev_name, O_RDWR | O_NDELAY, 0666)) >= 0) { strcpy( tty_dev_name, p );
ioctl(ttyp, I_PUSH, "ptem"); if ( ( ttyp = open( tty_dev_name, O_RDWR | O_NDELAY, 0666 ) ) >=
ioctl(ttyp, I_PUSH, "ldterm"); 0 ) {
if (verbose) ioctl( ttyp, I_PUSH, "ptem" );
printf("%s: wire connection on %s\n", progname, tty_dev_name); ioctl( ttyp, I_PUSH, "ldterm" );
wire_name = strdup(tty_dev_name); if ( verbose )
printf( "%s: wire connection on %s\n", progname,
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 ) ) >=
grantpt(wire_fd); 0 ) {
unlockpt(wire_fd); grantpt( wire_fd );
if (ptsname_r(wire_fd, tty_dev_name, 128)) { unlockpt( wire_fd );
perror("Could not get the name of the wire device."); if ( ptsname_r( wire_fd, tty_dev_name, 128 ) ) {
exit(-1); perror( "Could not get the name of the wire device." );
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 ) ) >=
if (verbose) 0 ) {
printf("%s: wire connection on %s\n", progname, tty_dev_name); if ( verbose )
wire_name = strdup(tty_dev_name); printf( "%s: wire connection on %s\n", progname,
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 = if ( ( wire_fd =
open(tty_dev_name, 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, tty_dev_name); printf( "%s: wire connection on %s\n", progname,
wire_name = strdup(tty_dev_name); 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
/* /*
@ -184,37 +193,39 @@ int serial_init(void) {
*/ */
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, O_RDWR | O_EXCL | O_NDELAY, 0666)) >= if ( ( wire_fd = open( tty_dev_name, O_RDWR | O_EXCL | O_NDELAY,
0) { 0666 ) ) >= 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, tty_dev_name); printf( "%s: wire connection on %s\n", progname,
wire_name = strdup(tty_dev_name); 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
if (ioctl(ttyp, TCGETS, (char *)&ttybuf) < 0) if ( ioctl( ttyp, TCGETS, ( char* )&ttybuf ) < 0 )
#endif #endif
{ {
if (!quiet) if ( !quiet )
fprintf(stderr, "%s: ioctl(wire, TCGETS) failed, errno = %d\n", fprintf( stderr, "%s: ioctl(wire, TCGETS) failed, errno = %d\n",
progname, errno); progname, errno );
wire_fd = -1; wire_fd = -1;
ttyp = -1; ttyp = -1;
} }
@ -224,46 +235,46 @@ int serial_init(void) {
ttybuf.c_iflag = 0; ttybuf.c_iflag = 0;
ttybuf.c_oflag = 0; ttybuf.c_oflag = 0;
ttybuf.c_cflag = B9600 | CS8 | CLOCAL | CREAD; ttybuf.c_cflag = B9600 | CS8 | CLOCAL | CREAD;
for (n = 0; n < NCCS; n++) for ( n = 0; n < NCCS; n++ )
ttybuf.c_cc[n] = 0; ttybuf.c_cc[ n ] = 0;
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
if (ioctl(ttyp, TCSETS, (char *)&ttybuf) < 0) if ( ioctl( ttyp, TCSETS, ( char* )&ttybuf ) < 0 )
#endif #endif
{ {
if (!quiet) if ( !quiet )
fprintf(stderr, "%s: ioctl(wire, TCSETS) failed, errno = %d\n", fprintf( stderr, "%s: ioctl(wire, TCSETS) failed, errno = %d\n",
progname, errno); progname, errno );
wire_fd = -1; wire_fd = -1;
ttyp = -1; ttyp = -1;
} }
} }
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
if (ioctl(ir_fd, TCGETS, (char *)&ttybuf) < 0) if ( ioctl( ir_fd, TCGETS, ( char* )&ttybuf ) < 0 )
#endif #endif
{ {
if (!quiet) if ( !quiet )
fprintf(stderr, "%s: ioctl(IR, TCGETS) failed, errno = %d\n", progname, fprintf( stderr, "%s: ioctl(IR, TCGETS) failed, errno = %d\n",
errno); progname, errno );
ir_fd = -1; ir_fd = -1;
} }
} }
@ -272,21 +283,21 @@ int serial_init(void) {
ttybuf.c_iflag = 0; ttybuf.c_iflag = 0;
ttybuf.c_oflag = 0; ttybuf.c_oflag = 0;
ttybuf.c_cflag = B9600 | CS8 | CLOCAL | CREAD; ttybuf.c_cflag = B9600 | CS8 | CLOCAL | CREAD;
for (n = 0; n < NCCS; n++) for ( n = 0; n < NCCS; n++ )
ttybuf.c_cc[n] = 0; ttybuf.c_cc[ n ] = 0;
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
if (ioctl(ir_fd, TCSETS, (char *)&ttybuf) < 0) if ( ioctl( ir_fd, TCSETS, ( char* )&ttybuf ) < 0 )
#endif #endif
{ {
if (!quiet) if ( !quiet )
fprintf(stderr, "%s: ioctl(IR, TCSETS) failed, errno = %d\n", progname, fprintf( stderr, "%s: ioctl(IR, TCSETS) failed, errno = %d\n",
errno); progname, errno );
ir_fd = -1; ir_fd = -1;
} }
} }
@ -294,28 +305,28 @@ int serial_init(void) {
return 1; return 1;
} }
void serial_baud(int baud) { 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
if (ioctl(ir_fd, TCGETS, (char *)&ttybuf) < 0) if ( ioctl( ir_fd, TCGETS, ( char* )&ttybuf ) < 0 )
#endif #endif
{ {
if (!quiet) if ( !quiet )
fprintf(stderr, "%s: ioctl(IR, TCGETS) failed, errno = %d\n", progname, fprintf( stderr, "%s: ioctl(IR, TCGETS) failed, errno = %d\n",
errno); progname, errno );
ir_fd = -1; ir_fd = -1;
error = 1; error = 1;
} }
} }
#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;
@ -350,16 +361,17 @@ 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;
} }
#else #else
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;
@ -394,49 +406,50 @@ 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
if (ioctl(ir_fd, TCSETS, (char *)&ttybuf) < 0) if ( ioctl( ir_fd, TCSETS, ( char* )&ttybuf ) < 0 )
#endif #endif
{ {
if (!quiet) if ( !quiet )
fprintf(stderr, "%s: ioctl(IR, TCSETS) failed, errno = %d\n", progname, fprintf( stderr, "%s: ioctl(IR, TCSETS) failed, errno = %d\n",
errno); progname, 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
if (ioctl(ttyp, TCGETS, (char *)&ttybuf) < 0) if ( ioctl( ttyp, TCGETS, ( char* )&ttybuf ) < 0 )
#endif #endif
{ {
if (!quiet) if ( !quiet )
fprintf(stderr, "%s: ioctl(wire, TCGETS) failed, errno = %d\n", fprintf( stderr, "%s: ioctl(wire, TCGETS) failed, errno = %d\n",
progname, errno); progname, errno );
wire_fd = -1; wire_fd = -1;
ttyp = -1; ttyp = -1;
error = 1; error = 1;
} }
} }
#if defined(__APPLE__) #if defined( __APPLE__ )
#else #else
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;
@ -471,48 +484,49 @@ 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
if (ioctl(ttyp, TCSETS, (char *)&ttybuf) < 0) if ( ioctl( ttyp, TCSETS, ( char* )&ttybuf ) < 0 )
#endif #endif
{ {
if (!quiet) if ( !quiet )
fprintf(stderr, "%s: ioctl(wire, TCSETS) failed, errno = %d\n", fprintf( stderr, "%s: ioctl(wire, TCSETS) failed, errno = %d\n",
progname, errno); progname, errno );
wire_fd = -1; wire_fd = -1;
ttyp = -1; ttyp = -1;
error = 1; error = 1;
} }
} }
if (error) if ( error )
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" );
#endif #endif
if (saturn.ir_ctrl & 0x04) { if ( saturn.ir_ctrl & 0x04 ) {
if (ir_fd == -1) { if ( ir_fd == -1 ) {
saturn.tcs &= 0x0e; saturn.tcs &= 0x0e;
if (saturn.io_ctrl & 0x04) { if ( saturn.io_ctrl & 0x04 ) {
do_interupt(); do_interupt();
} }
return; return;
} }
} else { } else {
if (wire_fd == -1) { if ( wire_fd == -1 ) {
saturn.tcs &= 0x0e; saturn.tcs &= 0x0e;
if (saturn.io_ctrl & 0x04) { if ( saturn.io_ctrl & 0x04 ) {
do_interupt(); do_interupt();
} }
return; return;
@ -520,40 +534,42 @@ void transmit_char(void) {
} }
#ifdef DEBUG_SERIAL #ifdef DEBUG_SERIAL
if (isprint(saturn.tbr)) { if ( isprint( saturn.tbr ) ) {
fprintf(stderr, "-> \'%c\'\n", saturn.tbr); fprintf( stderr, "-> \'%c\'\n", saturn.tbr );
} else { } else {
fprintf(stderr, "-> %x\n", saturn.tbr); fprintf( stderr, "-> %x\n", saturn.tbr );
} }
#endif #endif
if (saturn.ir_ctrl & 0x04) { if ( saturn.ir_ctrl & 0x04 ) {
if (write(ir_fd, &saturn.tbr, 1) == 1) { if ( write( ir_fd, &saturn.tbr, 1 ) == 1 ) {
saturn.tcs &= 0x0e; saturn.tcs &= 0x0e;
if (saturn.io_ctrl & 0x04) { if ( saturn.io_ctrl & 0x04 ) {
do_interupt(); do_interupt();
} }
} else { } else {
if (errno != EAGAIN) { if ( errno != EAGAIN ) {
fprintf(stderr, "%s: serial write error: %d\n", progname, errno); fprintf( stderr, "%s: serial write error: %d\n", progname,
errno );
} }
saturn.tcs &= 0x0e; saturn.tcs &= 0x0e;
if (saturn.io_ctrl & 0x04) { if ( saturn.io_ctrl & 0x04 ) {
do_interupt(); do_interupt();
} }
} }
} else { } else {
if (write(wire_fd, &saturn.tbr, 1) == 1) { if ( write( wire_fd, &saturn.tbr, 1 ) == 1 ) {
saturn.tcs &= 0x0e; saturn.tcs &= 0x0e;
if (saturn.io_ctrl & 0x04) { if ( saturn.io_ctrl & 0x04 ) {
do_interupt(); do_interupt();
} }
} else { } else {
if (errno != EAGAIN) { if ( errno != EAGAIN ) {
if (!quiet) if ( !quiet )
fprintf(stderr, "%s: serial write error: %d\n", progname, errno); fprintf( stderr, "%s: serial write error: %d\n", progname,
errno );
} }
saturn.tcs &= 0x0e; saturn.tcs &= 0x0e;
if (saturn.io_ctrl & 0x04) { if ( saturn.io_ctrl & 0x04 ) {
do_interupt(); do_interupt();
} }
} }
@ -566,46 +582,47 @@ void receive_char() {
struct timeval tout; struct timeval tout;
fd_set rfds; fd_set rfds;
int nfd; int nfd;
static unsigned char buf[NR_BUFFER + 1]; static unsigned char buf[ NR_BUFFER + 1 ];
static int nrd = 0, bp = 0; static int nrd = 0, bp = 0;
#ifdef DEBUG_SERIALx #ifdef DEBUG_SERIALx
fprintf(stderr, "RCV %s\n", (saturn.ir_ctrl & 0x04) ? "IR" : "wire"); fprintf( stderr, "RCV %s\n", ( saturn.ir_ctrl & 0x04 ) ? "IR" : "wire" );
#endif #endif
rece_instr = 0; rece_instr = 0;
if (saturn.ir_ctrl & 0x04) { if ( saturn.ir_ctrl & 0x04 ) {
if (ir_fd == -1) if ( ir_fd == -1 )
return; return;
} else { } else {
if (wire_fd == -1) if ( wire_fd == -1 )
return; return;
} }
if (saturn.rcs & 0x01) { if ( saturn.rcs & 0x01 ) {
return; return;
} }
if (nrd == 0) { if ( nrd == 0 ) {
tout.tv_sec = 0; tout.tv_sec = 0;
tout.tv_usec = 0; tout.tv_usec = 0;
FD_ZERO(&rfds); FD_ZERO( &rfds );
if (saturn.ir_ctrl & 0x04) { if ( saturn.ir_ctrl & 0x04 ) {
FD_SET(ir_fd, &rfds); FD_SET( ir_fd, &rfds );
nfd = ir_fd + 1; nfd = ir_fd + 1;
} else { } else {
FD_SET(wire_fd, &rfds); FD_SET( wire_fd, &rfds );
nfd = wire_fd + 1; nfd = wire_fd + 1;
} }
if ((nfd = select(nfd, &rfds, (fd_set *)0, (fd_set *)0, &tout)) > 0) { if ( ( nfd = select( nfd, &rfds, ( fd_set* )0, ( fd_set* )0, &tout ) ) >
0 ) {
#ifdef DEBUG_SERIAL #ifdef DEBUG_SERIAL
fprintf(stderr, "select = %d\n", nfd); fprintf( stderr, "select = %d\n", nfd );
#endif #endif
if (saturn.ir_ctrl & 0x04) { if ( saturn.ir_ctrl & 0x04 ) {
if (FD_ISSET(ir_fd, &rfds)) { if ( FD_ISSET( ir_fd, &rfds ) ) {
nrd = read(ir_fd, buf, NR_BUFFER); nrd = read( ir_fd, buf, NR_BUFFER );
if (nrd < 0) { if ( nrd < 0 ) {
nrd = 0; nrd = 0;
return; return;
} }
@ -614,9 +631,9 @@ void receive_char() {
return; return;
} }
} else { } else {
if (FD_ISSET(wire_fd, &rfds)) { if ( FD_ISSET( wire_fd, &rfds ) ) {
nrd = read(wire_fd, buf, NR_BUFFER); nrd = read( wire_fd, buf, NR_BUFFER );
if (nrd < 0) { if ( nrd < 0 ) {
nrd = 0; nrd = 0;
return; return;
} }
@ -629,17 +646,17 @@ void receive_char() {
return; return;
} }
} }
if (nrd == 0) { if ( nrd == 0 ) {
return; return;
} }
if (!(saturn.io_ctrl & 0x08)) { if ( !( saturn.io_ctrl & 0x08 ) ) {
nrd = 0; nrd = 0;
return; return;
} }
saturn.rbr = buf[bp++]; saturn.rbr = buf[ bp++ ];
nrd--; nrd--;
saturn.rcs |= 0x01; saturn.rcs |= 0x01;
if (saturn.io_ctrl & 0x02) { if ( saturn.io_ctrl & 0x02 ) {
do_interupt(); do_interupt();
} }
} }

506
src/small.h
View file

@ -48,288 +48,256 @@
#define blank_width 4 #define blank_width 4
#define blank_height 7 #define blank_height 7
static unsigned char blank_bits[] = { static unsigned char blank_bits[] = { 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; 0x00, 0x00, 0x00 };
#define hash_width 5 #define hash_width 5
#define hash_height 7 #define hash_height 7
static unsigned char hash_bits[] = { static unsigned char hash_bits[] = { 0x00, 0x0a, 0x1f, 0x0a, 0x0a, 0x1f, 0x0a };
0x00, 0x0a, 0x1f, 0x0a, 0x0a, 0x1f, 0x0a};
#define lbrace_width 3 #define lbrace_width 3
#define lbrace_height 7 #define lbrace_height 7
static unsigned char lbrace_bits[] = { static unsigned char lbrace_bits[] = { 0x04, 0x02, 0x01, 0x01,
0x04, 0x02, 0x01, 0x01, 0x01, 0x02, 0x04}; 0x01, 0x02, 0x04 };
#define rbrace_width 3 #define rbrace_width 3
#define rbrace_height 7 #define rbrace_height 7
static unsigned char rbrace_bits[] = { static unsigned char rbrace_bits[] = { 0x01, 0x02, 0x04, 0x04,
0x01, 0x02, 0x04, 0x04, 0x04, 0x02, 0x01}; 0x04, 0x02, 0x01 };
#define comma_width 3 #define comma_width 3
#define comma_height 7 #define comma_height 7
static unsigned char comma_bits[] = { static unsigned char comma_bits[] = { 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x06, 0x06, 0x03}; 0x06, 0x06, 0x03 };
#define slash_width 3 #define slash_width 3
#define slash_height 7 #define slash_height 7
static unsigned char slash_bits[] = { static unsigned char slash_bits[] = { 0x04, 0x04, 0x02, 0x02,
0x04, 0x04, 0x02, 0x02, 0x02, 0x01, 0x01}; 0x02, 0x01, 0x01 };
#define two_width 5 #define two_width 5
#define two_height 7 #define two_height 7
static unsigned char two_bits[] = { static unsigned char two_bits[] = { 0x0e, 0x11, 0x10, 0x08, 0x04, 0x02, 0x1f };
0x0e, 0x11, 0x10, 0x08, 0x04, 0x02, 0x1f};
#define three_width 5 #define three_width 5
#define three_height 7 #define three_height 7
static unsigned char three_bits[] = { static unsigned char three_bits[] = { 0x0e, 0x11, 0x10, 0x0c,
0x0e, 0x11, 0x10, 0x0c, 0x10, 0x11, 0x0e}; 0x10, 0x11, 0x0e };
#define small_colon_width 2 #define small_colon_width 2
#define small_colon_height 7 #define small_colon_height 7
static unsigned char small_colon_bits[] = { static unsigned char small_colon_bits[] = { 0x00, 0x03, 0x03, 0x00,
0x00, 0x03, 0x03, 0x00, 0x03, 0x03, 0x00}; 0x03, 0x03, 0x00 };
#define A_width 5 #define A_width 5
#define A_height 7 #define A_height 7
static unsigned char A_bits[] = { static unsigned char A_bits[] = { 0x0e, 0x11, 0x11, 0x1f, 0x11, 0x11, 0x11 };
0x0e, 0x11, 0x11, 0x1f, 0x11, 0x11, 0x11};
#define B_width 5 #define B_width 5
#define B_height 7 #define B_height 7
static unsigned char B_bits[] = { static unsigned char B_bits[] = { 0x0f, 0x11, 0x11, 0x0f, 0x11, 0x11, 0x0f };
0x0f, 0x11, 0x11, 0x0f, 0x11, 0x11, 0x0f};
#define C_width 5 #define C_width 5
#define C_height 7 #define C_height 7
static unsigned char C_bits[] = { static unsigned char C_bits[] = { 0x0e, 0x11, 0x01, 0x01, 0x01, 0x11, 0x0e };
0x0e, 0x11, 0x01, 0x01, 0x01, 0x11, 0x0e};
#define D_width 5 #define D_width 5
#define D_height 7 #define D_height 7
static unsigned char D_bits[] = { static unsigned char D_bits[] = { 0x0f, 0x11, 0x11, 0x11, 0x11, 0x11, 0x0f };
0x0f, 0x11, 0x11, 0x11, 0x11, 0x11, 0x0f};
#define E_width 5 #define E_width 5
#define E_height 7 #define E_height 7
static unsigned char E_bits[] = { static unsigned char E_bits[] = { 0x1f, 0x01, 0x01, 0x0f, 0x01, 0x01, 0x1f };
0x1f, 0x01, 0x01, 0x0f, 0x01, 0x01, 0x1f};
#define F_width 5 #define F_width 5
#define F_height 7 #define F_height 7
static unsigned char F_bits[] = { static unsigned char F_bits[] = { 0x1f, 0x01, 0x01, 0x0f, 0x01, 0x01, 0x01 };
0x1f, 0x01, 0x01, 0x0f, 0x01, 0x01, 0x01};
#define G_width 5 #define G_width 5
#define G_height 7 #define G_height 7
static unsigned char G_bits[] = { static unsigned char G_bits[] = { 0x0e, 0x11, 0x01, 0x01, 0x19, 0x11, 0x0e };
0x0e, 0x11, 0x01, 0x01, 0x19, 0x11, 0x0e};
#define H_width 5 #define H_width 5
#define H_height 7 #define H_height 7
static unsigned char H_bits[] = { static unsigned char H_bits[] = { 0x11, 0x11, 0x11, 0x1f, 0x11, 0x11, 0x11 };
0x11, 0x11, 0x11, 0x1f, 0x11, 0x11, 0x11};
#define I_width 1 #define I_width 1
#define I_height 7 #define I_height 7
static unsigned char I_bits[] = { static unsigned char I_bits[] = { 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01 };
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01};
#define J_width 4 #define J_width 4
#define J_height 7 #define J_height 7
static unsigned char J_bits[] = { static unsigned char J_bits[] = { 0x08, 0x08, 0x08, 0x08, 0x08, 0x09, 0x06 };
0x08, 0x08, 0x08, 0x08, 0x08, 0x09, 0x06};
#define K_width 5 #define K_width 5
#define K_height 7 #define K_height 7
static unsigned char K_bits[] = { static unsigned char K_bits[] = { 0x11, 0x09, 0x05, 0x03, 0x05, 0x09, 0x11 };
0x11, 0x09, 0x05, 0x03, 0x05, 0x09, 0x11};
#define L_width 4 #define L_width 4
#define L_height 7 #define L_height 7
static unsigned char L_bits[] = { static unsigned char L_bits[] = { 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x0f };
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x0f};
#define M_width 5 #define M_width 5
#define M_height 7 #define M_height 7
static unsigned char M_bits[] = { static unsigned char M_bits[] = { 0x11, 0x1b, 0x15, 0x11, 0x11, 0x11, 0x11 };
0x11, 0x1b, 0x15, 0x11, 0x11, 0x11, 0x11};
#define N_width 5 #define N_width 5
#define N_height 7 #define N_height 7
static unsigned char N_bits[] = { static unsigned char N_bits[] = { 0x11, 0x11, 0x13, 0x15, 0x19, 0x11, 0x11 };
0x11, 0x11, 0x13, 0x15, 0x19, 0x11, 0x11};
#define O_width 5 #define O_width 5
#define O_height 7 #define O_height 7
static unsigned char O_bits[] = { static unsigned char O_bits[] = { 0x0e, 0x11, 0x11, 0x11, 0x11, 0x11, 0x0e };
0x0e, 0x11, 0x11, 0x11, 0x11, 0x11, 0x0e};
#define P_width 5 #define P_width 5
#define P_height 7 #define P_height 7
static unsigned char P_bits[] = { static unsigned char P_bits[] = { 0x0f, 0x11, 0x11, 0x0f, 0x01, 0x01, 0x01 };
0x0f, 0x11, 0x11, 0x0f, 0x01, 0x01, 0x01};
#define Q_width 5 #define Q_width 5
#define Q_height 7 #define Q_height 7
static unsigned char Q_bits[] = { static unsigned char Q_bits[] = { 0x0e, 0x11, 0x11, 0x11, 0x15, 0x09, 0x16 };
0x0e, 0x11, 0x11, 0x11, 0x15, 0x09, 0x16};
#define R_width 5 #define R_width 5
#define R_height 7 #define R_height 7
static unsigned char R_bits[] = { static unsigned char R_bits[] = { 0x0f, 0x11, 0x11, 0x0f, 0x05, 0x09, 0x11 };
0x0f, 0x11, 0x11, 0x0f, 0x05, 0x09, 0x11};
#define S_width 5 #define S_width 5
#define S_height 7 #define S_height 7
static unsigned char S_bits[] = { static unsigned char S_bits[] = { 0x0e, 0x11, 0x01, 0x0e, 0x10, 0x11, 0x0e };
0x0e, 0x11, 0x01, 0x0e, 0x10, 0x11, 0x0e};
#define T_width 5 #define T_width 5
#define T_height 7 #define T_height 7
static unsigned char T_bits[] = { static unsigned char T_bits[] = { 0x1f, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04 };
0x1f, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04};
#define U_width 5 #define U_width 5
#define U_height 7 #define U_height 7
static unsigned char U_bits[] = { static unsigned char U_bits[] = { 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x0e };
0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x0e};
#define V_width 5 #define V_width 5
#define V_height 7 #define V_height 7
static unsigned char V_bits[] = { static unsigned char V_bits[] = { 0x11, 0x11, 0x11, 0x11, 0x0a, 0x0a, 0x04 };
0x11, 0x11, 0x11, 0x11, 0x0a, 0x0a, 0x04};
#define W_width 5 #define W_width 5
#define W_height 7 #define W_height 7
static unsigned char W_bits[] = { static unsigned char W_bits[] = { 0x11, 0x11, 0x11, 0x11, 0x15, 0x1b, 0x11 };
0x11, 0x11, 0x11, 0x11, 0x15, 0x1b, 0x11};
#define X_width 5 #define X_width 5
#define X_height 7 #define X_height 7
static unsigned char X_bits[] = { static unsigned char X_bits[] = { 0x11, 0x11, 0x0a, 0x04, 0x0a, 0x11, 0x11 };
0x11, 0x11, 0x0a, 0x04, 0x0a, 0x11, 0x11};
#define Y_width 5 #define Y_width 5
#define Y_height 7 #define Y_height 7
static unsigned char Y_bits[] = { static unsigned char Y_bits[] = { 0x11, 0x11, 0x0a, 0x04, 0x04, 0x04, 0x04 };
0x11, 0x11, 0x0a, 0x04, 0x04, 0x04, 0x04};
#define Z_width 5 #define Z_width 5
#define Z_height 7 #define Z_height 7
static unsigned char Z_bits[] = { static unsigned char Z_bits[] = { 0x1f, 0x10, 0x08, 0x04, 0x02, 0x01, 0x1f };
0x1f, 0x10, 0x08, 0x04, 0x02, 0x01, 0x1f};
#define lbracket_width 3 #define lbracket_width 3
#define lbracket_height 7 #define lbracket_height 7
static unsigned char lbracket_bits[] = { static unsigned char lbracket_bits[] = { 0x07, 0x01, 0x01, 0x01,
0x07, 0x01, 0x01, 0x01, 0x01, 0x01, 0x07}; 0x01, 0x01, 0x07 };
#define rbracket_width 3 #define rbracket_width 3
#define rbracket_height 7 #define rbracket_height 7
static unsigned char rbracket_bits[] = { static unsigned char rbracket_bits[] = { 0x07, 0x04, 0x04, 0x04,
0x07, 0x04, 0x04, 0x04, 0x04, 0x04, 0x07}; 0x04, 0x04, 0x07 };
#define arrow_width 7 #define arrow_width 7
#define arrow_height 7 #define arrow_height 7
static unsigned char arrow_bits[] = { static unsigned char arrow_bits[] = { 0x00, 0x08, 0x18, 0x3f,
0x00, 0x08, 0x18, 0x3f, 0x18, 0x08, 0x00}; 0x18, 0x08, 0x00 };
#define diff_width 5 #define diff_width 5
#define diff_height 7 #define diff_height 7
static unsigned char diff_bits[] = { static unsigned char diff_bits[] = { 0x0e, 0x10, 0x10, 0x1e, 0x11, 0x11, 0x0e };
0x0e, 0x10, 0x10, 0x1e, 0x11, 0x11, 0x0e};
#define integral_width 5 #define integral_width 5
#define integral_height 8 #define integral_height 8
static unsigned char integral_bits[] = { static unsigned char integral_bits[] = { 0x0c, 0x12, 0x02, 0x04,
0x0c, 0x12, 0x02, 0x04, 0x04, 0x08, 0x09, 0x06}; 0x04, 0x08, 0x09, 0x06 };
#define sigma_width 6 #define sigma_width 6
#define sigma_height 9 #define sigma_height 9
static unsigned char sigma_bits[] = { static unsigned char sigma_bits[] = { 0x3f, 0x21, 0x02, 0x04, 0x08,
0x3f, 0x21, 0x02, 0x04, 0x08, 0x04, 0x02, 0x21, 0x3f}; 0x04, 0x02, 0x21, 0x3f };
#define sqr_width 11 #define sqr_width 11
#define sqr_height 10 #define sqr_height 10
static unsigned char sqr_bits[] = { static unsigned char sqr_bits[] = { 0x00, 0x03, 0x80, 0x04, 0x00, 0x04, 0x00,
0x00, 0x03, 0x80, 0x04, 0x00, 0x04, 0x00, 0x02, 0x26, 0x01, 0x94, 0x07, 0x02, 0x26, 0x01, 0x94, 0x07, 0x08, 0x00,
0x08, 0x00, 0x14, 0x00, 0x53, 0x00, 0x21, 0x00}; 0x14, 0x00, 0x53, 0x00, 0x21, 0x00 };
#define root_width 18 #define root_width 18
#define root_height 13 #define root_height 13
static unsigned char root_bits[] = { static unsigned char root_bits[] = {
0x26, 0x00, 0x00, 0x14, 0x00, 0x00, 0x08, 0xfe, 0x03, 0x14, 0x02, 0x02, 0x26, 0x00, 0x00, 0x14, 0x00, 0x00, 0x08, 0xfe, 0x03, 0x14,
0x53, 0x02, 0x00, 0x21, 0x99, 0x00, 0x00, 0x91, 0x00, 0x10, 0x91, 0x00, 0x02, 0x02, 0x53, 0x02, 0x00, 0x21, 0x99, 0x00, 0x00, 0x91,
0xa0, 0x50, 0x00, 0xc0, 0x60, 0x00, 0x80, 0x20, 0x00, 0x00, 0x14, 0x00, 0x00, 0x10, 0x91, 0x00, 0xa0, 0x50, 0x00, 0xc0, 0x60, 0x00,
0x00, 0x0c, 0x00}; 0x80, 0x20, 0x00, 0x00, 0x14, 0x00, 0x00, 0x0c, 0x00 };
#define pow10_width 13 #define pow10_width 13
#define pow10_height 9 #define pow10_height 9
static unsigned char pow10_bits[] = { static unsigned char pow10_bits[] = { 0x00, 0x12, 0x00, 0x0c, 0x32, 0x04,
0x00, 0x12, 0x00, 0x0c, 0x32, 0x04, 0x4b, 0x0a, 0x4a, 0x09, 0x4a, 0x00, 0x4b, 0x0a, 0x4a, 0x09, 0x4a, 0x00,
0x4a, 0x00, 0x4a, 0x00, 0x32, 0x00}; 0x4a, 0x00, 0x4a, 0x00, 0x32, 0x00 };
#define exp_width 11 #define exp_width 11
#define exp_height 9 #define exp_height 9
static unsigned char exp_bits[] = { static unsigned char exp_bits[] = { 0x80, 0x04, 0x00, 0x03, 0x00, 0x01,
0x80, 0x04, 0x00, 0x03, 0x00, 0x01, 0x8c, 0x02, 0x52, 0x02, 0x09, 0x00, 0x8c, 0x02, 0x52, 0x02, 0x09, 0x00,
0x07, 0x00, 0x21, 0x00, 0x1e, 0x00}; 0x07, 0x00, 0x21, 0x00, 0x1e, 0x00 };
#define under_width 6 #define under_width 6
#define under_height 7 #define under_height 7
static unsigned char under_bits[] = { static unsigned char under_bits[] = { 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f}; 0x00, 0x00, 0x3f };
#define prog_width 16 #define prog_width 16
#define prog_height 7 #define prog_height 7
static unsigned char prog_bits[] = { static unsigned char prog_bits[] = { 0x48, 0x12, 0x24, 0x24, 0x12, 0x48, 0x09,
0x48, 0x12, 0x24, 0x24, 0x12, 0x48, 0x09, 0x90, 0x12, 0x48, 0x24, 0x24, 0x90, 0x12, 0x48, 0x24, 0x24, 0x48, 0x12 };
0x48, 0x12};
#define string_width 10 #define string_width 10
#define string_height 7 #define string_height 7
static unsigned char string_bits[] = { static unsigned char string_bits[] = { 0x85, 0x02, 0x85, 0x02, 0x85,
0x85, 0x02, 0x85, 0x02, 0x85, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00}; 0x00, 0x00, 0x00, 0x00 };
#define equal_width 5 #define equal_width 5
#define equal_height 7 #define equal_height 7
static unsigned char equal_bits[] = { static unsigned char equal_bits[] = { 0x00, 0x1f, 0x00, 0x00,
0x00, 0x1f, 0x00, 0x00, 0x1f, 0x00, 0x00}; 0x1f, 0x00, 0x00 };
#define nl_width 8 #define nl_width 8
#define nl_height 7 #define nl_height 7
static unsigned char nl_bits[] = { static unsigned char nl_bits[] = { 0x00, 0x84, 0x86, 0xff, 0x06, 0x04, 0x00 };
0x00, 0x84, 0x86, 0xff, 0x06, 0x04, 0x00};
#define pi_width 6 #define pi_width 6
#define pi_height 7 #define pi_height 7
static unsigned char pi_bits[] = { static unsigned char pi_bits[] = { 0x20, 0x1f, 0x12, 0x12, 0x12, 0x12, 0x12 };
0x20, 0x1f, 0x12, 0x12, 0x12, 0x12, 0x12};
#define angle_width 8 #define angle_width 8
#define angle_height 7 #define angle_height 7
static unsigned char angle_bits[] = { static unsigned char angle_bits[] = { 0x40, 0x20, 0x10, 0x28,
0x40, 0x20, 0x10, 0x28, 0x44, 0x42, 0xff}; 0x44, 0x42, 0xff };
#define lcurly_width 5 #define lcurly_width 5
#define lcurly_height 7 #define lcurly_height 7
static unsigned char lcurly_bits[] = { static unsigned char lcurly_bits[] = { 0x18, 0x04, 0x04, 0x02,
0x18, 0x04, 0x04, 0x02, 0x04, 0x04, 0x18}; 0x04, 0x04, 0x18 };
#define rcurly_width 5 #define rcurly_width 5
#define rcurly_height 7 #define rcurly_height 7
static unsigned char rcurly_bits[] = { static unsigned char rcurly_bits[] = { 0x03, 0x04, 0x04, 0x08,
0x03, 0x04, 0x04, 0x08, 0x04, 0x04, 0x03}; 0x04, 0x04, 0x03 };
#define sqr_gx_width 11 #define sqr_gx_width 11
#define sqr_gx_height 13 #define sqr_gx_height 13
static unsigned char sqr_gx_bits[] = { static unsigned char sqr_gx_bits[] = { 0x00, 0x03, 0x80, 0x04, 0x00, 0x04, 0x00,
0x00, 0x03, 0x80, 0x04, 0x00, 0x04, 0x00, 0x02, 0x00, 0x01, 0x80, 0x07, 0x02, 0x00, 0x01, 0x80, 0x07, 0x00, 0x00,
0x00, 0x00, 0x66, 0x00, 0x14, 0x00, 0x08, 0x00, 0x14, 0x00, 0x53, 0x00, 0x66, 0x00, 0x14, 0x00, 0x08, 0x00, 0x14,
0x21, 0x00}; 0x00, 0x53, 0x00, 0x21, 0x00 };
#define root_gx_width 18 #define root_gx_width 18
#define root_gx_height 15 #define root_gx_height 15
@ -337,236 +305,236 @@ static unsigned char root_gx_bits[] = {
0x66, 0x00, 0x00, 0x14, 0x00, 0x00, 0x08, 0x00, 0x00, 0x14, 0x00, 0x00, 0x66, 0x00, 0x00, 0x14, 0x00, 0x00, 0x08, 0x00, 0x00, 0x14, 0x00, 0x00,
0x53, 0xfe, 0x03, 0x21, 0x02, 0x02, 0x00, 0x02, 0x00, 0x00, 0x99, 0x00, 0x53, 0xfe, 0x03, 0x21, 0x02, 0x02, 0x00, 0x02, 0x00, 0x00, 0x99, 0x00,
0x00, 0x91, 0x00, 0x10, 0x91, 0x00, 0xa0, 0x50, 0x00, 0xc0, 0x60, 0x00, 0x00, 0x91, 0x00, 0x10, 0x91, 0x00, 0xa0, 0x50, 0x00, 0xc0, 0x60, 0x00,
0x80, 0x20, 0x00, 0x00, 0x14, 0x00, 0x00, 0x0c, 0x00}; 0x80, 0x20, 0x00, 0x00, 0x14, 0x00, 0x00, 0x0c, 0x00 };
#define pow10_gx_width 13 #define pow10_gx_width 13
#define pow10_gx_height 12 #define pow10_gx_height 12
static unsigned char pow10_gx_bits[] = { static unsigned char pow10_gx_bits[] = {
0x00, 0x12, 0x00, 0x0c, 0x00, 0x04, 0x00, 0x0a, 0x00, 0x09, 0x32, 0x00, 0x00, 0x12, 0x00, 0x0c, 0x00, 0x04, 0x00, 0x0a, 0x00, 0x09, 0x32, 0x00,
0x4b, 0x00, 0x4a, 0x00, 0x4a, 0x00, 0x4a, 0x00, 0x4a, 0x00, 0x32, 0x00}; 0x4b, 0x00, 0x4a, 0x00, 0x4a, 0x00, 0x4a, 0x00, 0x4a, 0x00, 0x32, 0x00 };
#define exp_gx_width 13 #define exp_gx_width 13
#define exp_gx_height 12 #define exp_gx_height 12
static unsigned char exp_gx_bits[] = { static unsigned char exp_gx_bits[] = {
0x00, 0xfb, 0x00, 0xf6, 0x00, 0xe6, 0x00, 0xf6, 0x80, 0xed, 0x18, 0xe0, 0x00, 0xfb, 0x00, 0xf6, 0x00, 0xe6, 0x00, 0xf6, 0x80, 0xed, 0x18, 0xe0,
0x36, 0xe0, 0x36, 0xe0, 0x1f, 0xe0, 0x03, 0xe0, 0x13, 0xe0, 0x0e, 0xe0}; 0x36, 0xe0, 0x36, 0xe0, 0x1f, 0xe0, 0x03, 0xe0, 0x13, 0xe0, 0x0e, 0xe0 };
#define parens_gx_width 20 #define parens_gx_width 20
#define parens_gx_height 12 #define parens_gx_height 12
static unsigned char parens_gx_bits[] = { static unsigned char parens_gx_bits[] = {
0x0c, 0x00, 0x03, 0x06, 0x00, 0x06, 0x06, 0x00, 0x06, 0x03, 0x00, 0x0c, 0x0c, 0x00, 0x03, 0x06, 0x00, 0x06, 0x06, 0x00, 0x06, 0x03, 0x00, 0x0c,
0x03, 0x00, 0x0c, 0x03, 0x00, 0x0c, 0x03, 0x00, 0x0c, 0x03, 0x00, 0x0c, 0x03, 0x00, 0x0c, 0x03, 0x00, 0x0c, 0x03, 0x00, 0x0c, 0x03, 0x00, 0x0c,
0x03, 0x00, 0x0c, 0x06, 0x00, 0x06, 0x06, 0x00, 0x06, 0x0c, 0x00, 0x03}; 0x03, 0x00, 0x0c, 0x06, 0x00, 0x06, 0x06, 0x00, 0x06, 0x0c, 0x00, 0x03 };
#define hash_gx_width 8 #define hash_gx_width 8
#define hash_gx_height 12 #define hash_gx_height 12
static unsigned char hash_gx_bits[] = { static unsigned char hash_gx_bits[] = { 0x00, 0x00, 0x48, 0x48, 0xfe, 0x24,
0x00, 0x00, 0x48, 0x48, 0xfe, 0x24, 0x24, 0x7f, 0x12, 0x12, 0x00, 0x00}; 0x24, 0x7f, 0x12, 0x12, 0x00, 0x00 };
#define bracket_gx_width 12 #define bracket_gx_width 12
#define bracket_gx_height 12 #define bracket_gx_height 12
static unsigned char bracket_gx_bits[] = { static unsigned char bracket_gx_bits[] = {
0x0f, 0x0f, 0x03, 0x0c, 0x03, 0x0c, 0x03, 0x0c, 0x03, 0x0c, 0x03, 0x0c, 0x0f, 0x0f, 0x03, 0x0c, 0x03, 0x0c, 0x03, 0x0c, 0x03, 0x0c, 0x03, 0x0c,
0x03, 0x0c, 0x03, 0x0c, 0x03, 0x0c, 0x03, 0x0c, 0x03, 0x0c, 0x0f, 0x0f}; 0x03, 0x0c, 0x03, 0x0c, 0x03, 0x0c, 0x03, 0x0c, 0x03, 0x0c, 0x0f, 0x0f };
#define under_gx_width 10 #define under_gx_width 10
#define under_gx_height 12 #define under_gx_height 12
static unsigned char under_gx_bits[] = { static unsigned char under_gx_bits[] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x03, 0xff, 0x03}; 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x03, 0xff, 0x03 };
#define prog_gx_width 24 #define prog_gx_width 24
#define prog_gx_height 12 #define prog_gx_height 12
static unsigned char prog_gx_bits[] = { static unsigned char prog_gx_bits[] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0xc3, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0xc3, 0x18,
0x8c, 0x81, 0x31, 0xc6, 0x00, 0x63, 0x63, 0x00, 0xc6, 0xc6, 0x00, 0x63, 0x8c, 0x81, 0x31, 0xc6, 0x00, 0x63, 0x63, 0x00, 0xc6, 0xc6, 0x00, 0x63,
0x8c, 0x81, 0x31, 0x18, 0xc3, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; 0x8c, 0x81, 0x31, 0x18, 0xc3, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
#define quote_gx_width 12 #define quote_gx_width 12
#define quote_gx_height 12 #define quote_gx_height 12
static unsigned char quote_gx_bits[] = { static unsigned char quote_gx_bits[] = {
0x05, 0x0a, 0x05, 0x0a, 0x05, 0x0a, 0x05, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x05, 0x0a, 0x05, 0x0a, 0x05, 0x0a, 0x05, 0x0a, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
#define curly_gx_width 14 #define curly_gx_width 14
#define curly_gx_height 12 #define curly_gx_height 12
static unsigned char curly_gx_bits[] = { static unsigned char curly_gx_bits[] = {
0x0c, 0x0c, 0x06, 0x18, 0x06, 0x18, 0x06, 0x18, 0x06, 0x18, 0x03, 0x30, 0x0c, 0x0c, 0x06, 0x18, 0x06, 0x18, 0x06, 0x18, 0x06, 0x18, 0x03, 0x30,
0x06, 0x18, 0x06, 0x18, 0x06, 0x18, 0x06, 0x18, 0x06, 0x18, 0x0c, 0x0c}; 0x06, 0x18, 0x06, 0x18, 0x06, 0x18, 0x06, 0x18, 0x06, 0x18, 0x0c, 0x0c };
#define colon_gx_width 8 #define colon_gx_width 8
#define colon_gx_height 12 #define colon_gx_height 12
static unsigned char colon_gx_bits[] = { static unsigned char colon_gx_bits[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0xc3,
0x00, 0x00, 0x00, 0x00, 0x00, 0xc3, 0xc3, 0x00, 0x00, 0xc3, 0xc3, 0x00}; 0xc3, 0x00, 0x00, 0xc3, 0xc3, 0x00 };
#define angle_gx_width 12 #define angle_gx_width 12
#define angle_gx_height 12 #define angle_gx_height 12
static unsigned char angle_gx_bits[] = { static unsigned char angle_gx_bits[] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x80, 0x01, 0xc0, 0x00, 0xe0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x80, 0x01, 0xc0, 0x00, 0xe0, 0x01,
0xb0, 0x03, 0x18, 0x03, 0x0c, 0x03, 0x06, 0x03, 0xff, 0x0f, 0xff, 0x0f}; 0xb0, 0x03, 0x18, 0x03, 0x0c, 0x03, 0x06, 0x03, 0xff, 0x0f, 0xff, 0x0f };
#define pi_gx_width 10 #define pi_gx_width 10
#define pi_gx_height 12 #define pi_gx_height 12
static unsigned char pi_gx_bits[] = { static unsigned char pi_gx_bits[] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xfe, 0x03, 0xff, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xfe, 0x03, 0xff, 0x01,
0xcc, 0x00, 0xcc, 0x00, 0xcc, 0x00, 0xcc, 0x00, 0xcc, 0x00, 0xcc, 0x00}; 0xcc, 0x00, 0xcc, 0x00, 0xcc, 0x00, 0xcc, 0x00, 0xcc, 0x00, 0xcc, 0x00 };
#define nl_gx_width 18 #define nl_gx_width 18
#define nl_gx_height 12 #define nl_gx_height 12
static unsigned char nl_gx_bits[] = { static unsigned char nl_gx_bits[] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xc0, 0x00, 0x03, 0xf0, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xc0, 0x00, 0x03, 0xf0, 0x00, 0x03,
0xfc, 0x00, 0x03, 0xff, 0xff, 0x03, 0xff, 0xff, 0x03, 0xfc, 0x00, 0x00, 0xfc, 0x00, 0x03, 0xff, 0xff, 0x03, 0xff, 0xff, 0x03, 0xfc, 0x00, 0x00,
0xf0, 0x00, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; 0xf0, 0x00, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
#define comma_gx_width 3 #define comma_gx_width 3
#define comma_gx_height 12 #define comma_gx_height 12
static unsigned char comma_gx_bits[] = { static unsigned char comma_gx_bits[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x07, 0x04, 0x04, 0x02}; 0x07, 0x07, 0x07, 0x04, 0x04, 0x02 };
#define arrow_gx_width 18 #define arrow_gx_width 18
#define arrow_gx_height 12 #define arrow_gx_height 12
static unsigned char arrow_gx_bits[] = { static unsigned char arrow_gx_bits[] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x3c, 0x00,
0x00, 0xfc, 0x00, 0xff, 0xff, 0x03, 0xff, 0xff, 0x03, 0x00, 0xfc, 0x00, 0x00, 0xfc, 0x00, 0xff, 0xff, 0x03, 0xff, 0xff, 0x03, 0x00, 0xfc, 0x00,
0x00, 0x3c, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; 0x00, 0x3c, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
#define equal_gx_width 8 #define equal_gx_width 8
#define equal_gx_height 12 #define equal_gx_height 12
static unsigned char equal_gx_bits[] = { static unsigned char equal_gx_bits[] = { 0x00, 0x00, 0x00, 0xff, 0xff, 0x00,
0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00}; 0x00, 0xff, 0xff, 0x00, 0x00, 0x00 };
typedef struct letter_t { typedef struct letter_t {
unsigned int w, h; unsigned int w, h;
unsigned char *bits; unsigned char* bits;
} letter_t; } letter_t;
letter_t small_font[] = { letter_t small_font[] = {
{0, 0, 0}, { 0, 0, 0 },
{nl_gx_width, nl_gx_height, nl_gx_bits}, /* \001 == \n gx */ { nl_gx_width, nl_gx_height, nl_gx_bits }, /* \001 == \n gx */
{comma_gx_width, comma_gx_height, comma_gx_bits}, /* \002 == comma gx */ { comma_gx_width, comma_gx_height, comma_gx_bits }, /* \002 == comma gx */
{arrow_gx_width, arrow_gx_height, arrow_gx_bits}, /* \003 == \-> gx */ { arrow_gx_width, arrow_gx_height, arrow_gx_bits }, /* \003 == \-> gx */
{equal_gx_width, equal_gx_height, equal_gx_bits}, /* \004 == equal gx */ { equal_gx_width, equal_gx_height, equal_gx_bits }, /* \004 == equal gx */
{pi_gx_width, pi_gx_height, pi_gx_bits}, /* \005 == pi gx */ { pi_gx_width, pi_gx_height, pi_gx_bits }, /* \005 == pi gx */
{0, 0, 0}, { 0, 0, 0 },
{0, 0, 0}, { 0, 0, 0 },
{0, 0, 0}, { 0, 0, 0 },
{0, 0, 0}, { 0, 0, 0 },
{0, 0, 0}, { 0, 0, 0 },
{0, 0, 0}, { 0, 0, 0 },
{0, 0, 0}, { 0, 0, 0 },
{0, 0, 0}, { 0, 0, 0 },
{0, 0, 0}, { 0, 0, 0 },
{0, 0, 0}, { 0, 0, 0 },
{0, 0, 0}, /* # 16 */ { 0, 0, 0 }, /* # 16 */
{0, 0, 0}, { 0, 0, 0 },
{0, 0, 0}, { 0, 0, 0 },
{0, 0, 0}, { 0, 0, 0 },
{0, 0, 0}, { 0, 0, 0 },
{0, 0, 0}, { 0, 0, 0 },
{0, 0, 0}, { 0, 0, 0 },
{0, 0, 0}, { 0, 0, 0 },
{0, 0, 0}, { 0, 0, 0 },
{0, 0, 0}, { 0, 0, 0 },
{0, 0, 0}, { 0, 0, 0 },
{0, 0, 0}, { 0, 0, 0 },
{0, 0, 0}, { 0, 0, 0 },
{0, 0, 0}, { 0, 0, 0 },
{0, 0, 0}, { 0, 0, 0 },
{0, 0, 0}, { 0, 0, 0 },
{blank_width, blank_height, blank_bits}, /* # 32 */ { blank_width, blank_height, blank_bits }, /* # 32 */
{0, 0, 0}, { 0, 0, 0 },
{0, 0, 0}, { 0, 0, 0 },
{hash_width, hash_height, hash_bits}, { hash_width, hash_height, hash_bits },
{0, 0, 0}, { 0, 0, 0 },
{0, 0, 0}, { 0, 0, 0 },
{0, 0, 0}, { 0, 0, 0 },
{0, 0, 0}, { 0, 0, 0 },
{lbrace_width, lbrace_height, lbrace_bits}, { lbrace_width, lbrace_height, lbrace_bits },
{rbrace_width, rbrace_height, rbrace_bits}, { rbrace_width, rbrace_height, rbrace_bits },
{0, 0, 0}, { 0, 0, 0 },
{0, 0, 0}, { 0, 0, 0 },
{comma_width, comma_height, comma_bits}, { comma_width, comma_height, comma_bits },
{0, 0, 0}, { 0, 0, 0 },
{0, 0, 0}, { 0, 0, 0 },
{slash_width, slash_height, slash_bits}, { slash_width, slash_height, slash_bits },
{0, 0, 0}, /* # 48 */ { 0, 0, 0 }, /* # 48 */
{0, 0, 0}, { 0, 0, 0 },
{two_width, two_height, two_bits}, { two_width, two_height, two_bits },
{three_width, three_height, three_bits}, { three_width, three_height, three_bits },
{0, 0, 0}, { 0, 0, 0 },
{0, 0, 0}, { 0, 0, 0 },
{0, 0, 0}, { 0, 0, 0 },
{0, 0, 0}, { 0, 0, 0 },
{0, 0, 0}, { 0, 0, 0 },
{0, 0, 0}, { 0, 0, 0 },
{small_colon_width, small_colon_height, small_colon_bits}, { small_colon_width, small_colon_height, small_colon_bits },
{0, 0, 0}, { 0, 0, 0 },
{0, 0, 0}, { 0, 0, 0 },
{equal_width, equal_height, equal_bits}, { equal_width, equal_height, equal_bits },
{0, 0, 0}, { 0, 0, 0 },
{0, 0, 0}, { 0, 0, 0 },
{0, 0, 0}, /* # 64 */ { 0, 0, 0 }, /* # 64 */
{A_width, A_height, A_bits}, { A_width, A_height, A_bits },
{B_width, B_height, B_bits}, { B_width, B_height, B_bits },
{C_width, C_height, C_bits}, { C_width, C_height, C_bits },
{D_width, D_height, D_bits}, { D_width, D_height, D_bits },
{E_width, E_height, E_bits}, { E_width, E_height, E_bits },
{F_width, F_height, F_bits}, { F_width, F_height, F_bits },
{G_width, G_height, G_bits}, { G_width, G_height, G_bits },
{H_width, H_height, H_bits}, { H_width, H_height, H_bits },
{I_width, I_height, I_bits}, { I_width, I_height, I_bits },
{J_width, J_height, J_bits}, { J_width, J_height, J_bits },
{K_width, K_height, K_bits}, { K_width, K_height, K_bits },
{L_width, L_height, L_bits}, { L_width, L_height, L_bits },
{M_width, M_height, M_bits}, { M_width, M_height, M_bits },
{N_width, N_height, N_bits}, { N_width, N_height, N_bits },
{O_width, O_height, O_bits}, { O_width, O_height, O_bits },
{P_width, P_height, P_bits}, /* # 80 */ { P_width, P_height, P_bits }, /* # 80 */
{Q_width, Q_height, Q_bits}, { Q_width, Q_height, Q_bits },
{R_width, R_height, R_bits}, { R_width, R_height, R_bits },
{S_width, S_height, S_bits}, { S_width, S_height, S_bits },
{T_width, T_height, T_bits}, { T_width, T_height, T_bits },
{U_width, U_height, U_bits}, { U_width, U_height, U_bits },
{V_width, V_height, V_bits}, { V_width, V_height, V_bits },
{W_width, W_height, W_bits}, { W_width, W_height, W_bits },
{X_width, X_height, X_bits}, { X_width, X_height, X_bits },
{Y_width, Y_height, Y_bits}, { Y_width, Y_height, Y_bits },
{Z_width, Z_height, Z_bits}, { Z_width, Z_height, Z_bits },
{lbracket_width, lbracket_height, lbracket_bits}, { lbracket_width, lbracket_height, lbracket_bits },
{0, 0, 0}, { 0, 0, 0 },
{rbracket_width, rbracket_height, rbracket_bits}, { rbracket_width, rbracket_height, rbracket_bits },
{0, 0, 0}, { 0, 0, 0 },
{under_width, under_height, under_bits}, { under_width, under_height, under_bits },
{0, 0, 0}, /* # 96 */ { 0, 0, 0 }, /* # 96 */
{arrow_width, arrow_height, arrow_bits}, /* a == left arrow */ { arrow_width, arrow_height, arrow_bits }, /* a == left arrow */
{diff_width, diff_height, diff_bits}, /* b == differential */ { diff_width, diff_height, diff_bits }, /* b == differential */
{integral_width, integral_height, integral_bits}, /* c == integral */ { integral_width, integral_height, integral_bits }, /* c == integral */
{sigma_width, sigma_height, sigma_bits}, /* d == sigma */ { sigma_width, sigma_height, sigma_bits }, /* d == sigma */
{sqr_width, sqr_height, sqr_bits}, /* e == sqr */ { sqr_width, sqr_height, sqr_bits }, /* e == sqr */
{root_width, root_height, root_bits}, /* f == root */ { root_width, root_height, root_bits }, /* f == root */
{pow10_width, pow10_height, pow10_bits}, /* g == pow10 */ { pow10_width, pow10_height, pow10_bits }, /* g == pow10 */
{exp_width, exp_height, exp_bits}, /* h == exp */ { exp_width, exp_height, exp_bits }, /* h == exp */
{prog_width, prog_height, prog_bits}, /* i == << >> */ { prog_width, prog_height, prog_bits }, /* i == << >> */
{string_width, string_height, string_bits}, /* j == " " */ { string_width, string_height, string_bits }, /* j == " " */
{nl_width, nl_height, nl_bits}, /* k == New Line */ { nl_width, nl_height, nl_bits }, /* k == New Line */
{pi_width, pi_height, pi_bits}, /* l == pi */ { pi_width, pi_height, pi_bits }, /* l == pi */
{angle_width, angle_height, angle_bits}, /* m == angle */ { angle_width, angle_height, angle_bits }, /* m == angle */
{sqr_gx_width, sqr_gx_height, sqr_gx_bits}, /* n == sqr gx */ { sqr_gx_width, sqr_gx_height, sqr_gx_bits }, /* n == sqr gx */
{root_gx_width, root_gx_height, root_gx_bits}, /* o == root gx */ { root_gx_width, root_gx_height, root_gx_bits }, /* o == root gx */
{pow10_gx_width, pow10_gx_height, pow10_gx_bits}, /* p == pow10 gx */ { pow10_gx_width, pow10_gx_height, pow10_gx_bits }, /* p == pow10 gx */
{exp_gx_width, exp_gx_height, exp_gx_bits}, /* q == exp gx */ { exp_gx_width, exp_gx_height, exp_gx_bits }, /* q == exp gx */
{parens_gx_width, parens_gx_height, parens_gx_bits}, /* r == ( ) gx */ { parens_gx_width, parens_gx_height, parens_gx_bits }, /* r == ( ) gx */
{hash_gx_width, hash_gx_height, hash_gx_bits}, /* s == # gx */ { hash_gx_width, hash_gx_height, hash_gx_bits }, /* s == # gx */
{bracket_gx_width, bracket_gx_height, bracket_gx_bits}, /* t == [] gx */ { bracket_gx_width, bracket_gx_height, bracket_gx_bits }, /* t == [] gx */
{under_gx_width, under_gx_height, under_gx_bits}, /* u == _ gx */ { under_gx_width, under_gx_height, under_gx_bits }, /* u == _ gx */
{prog_gx_width, prog_gx_height, prog_gx_bits}, /* v == << >> gx */ { prog_gx_width, prog_gx_height, prog_gx_bits }, /* v == << >> gx */
{quote_gx_width, quote_gx_height, quote_gx_bits}, /* w == " " gx */ { quote_gx_width, quote_gx_height, quote_gx_bits }, /* w == " " gx */
{curly_gx_width, curly_gx_height, curly_gx_bits}, /* x == {} gx */ { curly_gx_width, curly_gx_height, curly_gx_bits }, /* x == {} gx */
{colon_gx_width, colon_gx_height, colon_gx_bits}, /* y == :: gx */ { colon_gx_width, colon_gx_height, colon_gx_bits }, /* y == :: gx */
{angle_gx_width, angle_gx_height, angle_gx_bits}, /* z == angle gx */ { angle_gx_width, angle_gx_height, angle_gx_bits }, /* z == angle gx */
{lcurly_width, lcurly_height, lcurly_bits}, { lcurly_width, lcurly_height, lcurly_bits },
{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 */

226
src/timer.c
View file

@ -61,7 +61,7 @@ typedef struct x48_timer_t {
word_64 value; word_64 value;
} x48_timer_t; } x48_timer_t;
static x48_timer_t timers[NR_TIMERS]; static x48_timer_t timers[ NR_TIMERS ];
static long systime_offset = 0; static long systime_offset = 0;
@ -82,18 +82,19 @@ word_64 set_0_time = 0x0;
word_64 time_offset = 0x0; word_64 time_offset = 0x0;
#define RAM_BASE_SX 0x70000 #define RAM_BASE_SX 0x70000
#define ACCESSTIME_SX (0x70052 - RAM_BASE_SX) #define ACCESSTIME_SX ( 0x70052 - RAM_BASE_SX )
#define ACCESSCRC_SX (0x7005F - RAM_BASE_SX) #define ACCESSCRC_SX ( 0x7005F - RAM_BASE_SX )
#define TIMEOUT_SX (0x70063 - RAM_BASE_SX) #define TIMEOUT_SX ( 0x70063 - RAM_BASE_SX )
#define TIMEOUTCLK_SX (0x70070 - RAM_BASE_SX) #define TIMEOUTCLK_SX ( 0x70070 - RAM_BASE_SX )
#define RAM_BASE_GX 0x80000 #define RAM_BASE_GX 0x80000
#define ACCESSTIME_GX (0x80058 - RAM_BASE_GX) #define ACCESSTIME_GX ( 0x80058 - RAM_BASE_GX )
#define ACCESSCRC_GX (0x80065 - RAM_BASE_GX) #define ACCESSCRC_GX ( 0x80065 - RAM_BASE_GX )
#define TIMEOUT_GX (0x80069 - RAM_BASE_GX) #define TIMEOUT_GX ( 0x80069 - RAM_BASE_GX )
#define TIMEOUTCLK_GX (0x80076 - RAM_BASE_GX) #define TIMEOUTCLK_GX ( 0x80076 - RAM_BASE_GX )
#define calc_crc(nib) (crc = (crc >> 4) ^ (((crc ^ (nib)) & 0xf) * 0x1081)) #define calc_crc( nib ) \
( crc = ( crc >> 4 ) ^ ( ( ( crc ^ ( nib ) ) & 0xf ) * 0x1081 ) )
/* /*
* Set ACCESSTIME: (on startup) * Set ACCESSTIME: (on startup)
@ -108,7 +109,7 @@ word_64 time_offset = 0x0;
* 8. Prevent AutoOff by setting TIMEOUT * 8. Prevent AutoOff by setting TIMEOUT
* *
*/ */
void set_accesstime(void) { void set_accesstime( void ) {
struct timeval tv; struct timeval tv;
struct timezone tz; struct timezone tz;
word_64 ticks, timeout, timer2; word_64 ticks, timeout, timer2;
@ -118,34 +119,34 @@ void set_accesstime(void) {
word_4 val; word_4 val;
int i; int i;
time_t gmt; time_t gmt;
struct tm *ltm; struct tm* ltm;
/* /*
* This is done to set the variable 'timezone' on SYSV systems * This is done to set the variable 'timezone' on SYSV systems
*/ */
(void)time(&gmt); ( void )time( &gmt );
ltm = localtime(&gmt); ltm = localtime( &gmt );
#if defined(SYSV_TIME) || defined(__sgi) #if defined( SYSV_TIME ) || defined( __sgi )
systime_offset = timezone; systime_offset = timezone;
if (ltm->tm_isdst) if ( ltm->tm_isdst )
systime_offset -= 3600; systime_offset -= 3600;
#else #else
systime_offset = -ltm->tm_gmtoff; systime_offset = -ltm->tm_gmtoff;
#endif #endif
gettimeofday(&tv, &tz); gettimeofday( &tv, &tz );
tv.tv_sec -= systime_offset; tv.tv_sec -= systime_offset;
ticks = tv.tv_sec; ticks = tv.tv_sec;
ticks <<= 13; ticks <<= 13;
ticks += (tv.tv_usec << 7) / 15625; ticks += ( tv.tv_usec << 7 ) / 15625;
time_offset = unix_0_time + set_0_time; time_offset = unix_0_time + set_0_time;
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 );
} }
ticks += timer2; ticks += timer2;
@ -154,7 +155,7 @@ 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;
@ -166,156 +167,157 @@ void set_accesstime(void) {
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;
timeout >>= 4; timeout >>= 4;
} }
saturn.ram[timeoutclk_loc] = 0xf; saturn.ram[ timeoutclk_loc ] = 0xf;
} }
void start_timer(int timer) { void start_timer( int timer ) {
struct timeval tv; struct timeval tv;
struct timezone tz; struct timezone tz;
assert(timer <= NR_TIMERS); assert( timer <= NR_TIMERS );
if (timers[timer].run == 1) if ( timers[ timer ].run == 1 )
return; return;
gettimeofday(&tv, &tz); gettimeofday( &tv, &tz );
tv.tv_sec -= systime_offset; tv.tv_sec -= systime_offset;
timers[timer].run = 1; timers[ timer ].run = 1;
if (timer == T1_TIMER) { if ( timer == T1_TIMER ) {
timers[timer].start = (tv.tv_sec << 9); timers[ timer ].start = ( tv.tv_sec << 9 );
timers[timer].start += (tv.tv_usec / 15625) >> 3; timers[ timer ].start += ( tv.tv_usec / 15625 ) >> 3;
} else { } else {
timers[timer].start = tv.tv_sec; timers[ timer ].start = tv.tv_sec;
timers[timer].start <<= 13; timers[ timer ].start <<= 13;
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 ? '*' : ' ', fprintf( stderr, "Timer%c[%d] start at 0x%lx\n",
timer, timers[timer].start); timer == T1_TIMER ? '*' : ' ', timer, timers[ timer ].start );
#endif #endif
} }
void restart_timer(int timer) { void restart_timer( int timer ) {
struct timeval tv; struct timeval tv;
struct timezone tz; struct timezone tz;
if (timer > NR_TIMERS) if ( timer > NR_TIMERS )
return; return;
timers[timer].start = 0; timers[ timer ].start = 0;
timers[timer].stop = 0; timers[ timer ].stop = 0;
timers[timer].value = 0; timers[ timer ].value = 0;
gettimeofday(&tv, &tz); gettimeofday( &tv, &tz );
tv.tv_sec -= systime_offset; tv.tv_sec -= systime_offset;
timers[timer].run = 1; timers[ timer ].run = 1;
if (timer == T1_TIMER) { if ( timer == T1_TIMER ) {
timers[timer].start = (tv.tv_sec << 9); timers[ timer ].start = ( tv.tv_sec << 9 );
timers[timer].start += (tv.tv_usec / 15625) >> 3; timers[ timer ].start += ( tv.tv_usec / 15625 ) >> 3;
} else { } else {
timers[timer].start = tv.tv_sec; timers[ timer ].start = tv.tv_sec;
timers[timer].start <<= 13; timers[ timer ].start <<= 13;
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, timers[timer].start); fprintf( stderr, "Timer[%d] restart at 0x%lx\n", timer,
timers[ timer ].start );
#endif #endif
} }
void stop_timer(int timer) { void stop_timer( int timer ) {
struct timeval tv; struct timeval tv;
struct timezone tz; struct timezone tz;
if (timer > NR_TIMERS) if ( timer > NR_TIMERS )
return; return;
if (timers[timer].run == 0) if ( timers[ timer ].run == 0 )
return; return;
gettimeofday(&tv, &tz); gettimeofday( &tv, &tz );
tv.tv_sec -= systime_offset; tv.tv_sec -= systime_offset;
timers[timer].run = 0; timers[ timer ].run = 0;
if (timer == T1_TIMER) { if ( timer == T1_TIMER ) {
timers[timer].stop = (tv.tv_sec << 9); timers[ timer ].stop = ( tv.tv_sec << 9 );
timers[timer].stop += (tv.tv_usec / 15625) >> 3; timers[ timer ].stop += ( tv.tv_usec / 15625 ) >> 3;
} else { } else {
timers[timer].stop = tv.tv_sec; timers[ timer ].stop = tv.tv_sec;
timers[timer].stop <<= 13; timers[ timer ].stop <<= 13;
timers[timer].stop += (tv.tv_usec << 7) / 15625; timers[ timer ].stop += ( tv.tv_usec << 7 ) / 15625;
} }
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, // add_sub_64(&timers[timer].stop, &timers[timer].start,
// &timers[timer].value); // &timers[timer].value);
#ifdef DEBUG_TIMER #ifdef DEBUG_TIMER
fprintf(stderr, "Timer[%d] stop at 0x%llx, value 0x%llx\n", timer, fprintf( stderr, "Timer[%d] stop at 0x%llx, value 0x%llx\n", timer,
timers[timer].stop, timers[timer].value); timers[ timer ].stop, timers[ timer ].value );
#endif #endif
} }
void reset_timer(int timer) { void reset_timer( int timer ) {
if (timer > NR_TIMERS) if ( timer > NR_TIMERS )
return; return;
timers[timer].run = 0; timers[ timer ].run = 0;
timers[timer].start = 0; timers[ timer ].start = 0;
timers[timer].stop = 0; timers[ timer ].stop = 0;
timers[timer].value = 0; timers[ timer ].value = 0;
#ifdef DEBUG_TIMER #ifdef DEBUG_TIMER
fprintf(stderr, "Timer[%d] reset\n", timer); fprintf( stderr, "Timer[%d] reset\n", timer );
#endif #endif
} }
static word_64 zero = 0; static word_64 zero = 0;
word_64 get_timer(int timer) { word_64 get_timer( int timer ) {
struct timeval tv; struct timeval tv;
struct timezone tz; struct timezone tz;
word_64 stop; word_64 stop;
if (timer > NR_TIMERS) if ( timer > NR_TIMERS )
return zero; return zero;
if (timers[timer].run) { if ( timers[ timer ].run ) {
gettimeofday(&tv, &tz); gettimeofday( &tv, &tz );
tv.tv_sec -= systime_offset; tv.tv_sec -= systime_offset;
if (timer == T1_TIMER) { if ( timer == T1_TIMER ) {
stop = (tv.tv_sec << 9); stop = ( tv.tv_sec << 9 );
stop += (tv.tv_usec / 15625) >> 3; stop += ( tv.tv_usec / 15625 ) >> 3;
} else { } else {
stop = tv.tv_sec; stop = tv.tv_sec;
stop <<= 13; stop <<= 13;
stop += (tv.tv_usec << 7) / 15625; stop += ( tv.tv_usec << 7 ) / 15625;
} }
timers[timer].value += stop - timers[timer].start; timers[ timer ].value += stop - timers[ timer ].start;
} }
return timers[timer].value; return timers[ timer ].value;
} }
/* /*
@ -329,7 +331,7 @@ word_64 get_timer(int timer) {
* *
*/ */
t1_t2_ticks get_t1_t2(void) { t1_t2_ticks get_t1_t2( void ) {
struct timeval tv; struct timeval tv;
struct timezone tz; struct timezone tz;
word_64 stop; word_64 stop;
@ -341,23 +343,23 @@ t1_t2_ticks get_t1_t2(void) {
word_20 accesstime_loc; word_20 accesstime_loc;
int i; int i;
gettimeofday(&tv, &tz); gettimeofday( &tv, &tz );
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" );
} }
} }
ticks.t1_ticks = timers[T1_TIMER].value; ticks.t1_ticks = timers[ T1_TIMER ].value;
stop = tv.tv_sec; stop = tv.tv_sec;
stop <<= 13; stop <<= 13;
stop += (tv.tv_usec << 7) / 15625; stop += ( tv.tv_usec << 7 ) / 15625;
stop += time_offset; stop += time_offset;
@ -365,22 +367,22 @@ 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
*/ */
@ -400,25 +402,25 @@ t1_t2_ticks get_t1_t2(void) {
diff_time = saturn.timer2; diff_time = saturn.timer2;
adj_time = access_time - diff_time; adj_time = access_time - diff_time;
delta = abs(adj_time); delta = abs( adj_time );
if (delta > 0x3c000) /* Half a minute */ if ( delta > 0x3c000 ) /* Half a minute */
{ {
set_0_time += adj_time; set_0_time += adj_time;
time_offset += adj_time; time_offset += adj_time;
access_time -= adj_time; access_time -= adj_time;
#ifdef DEBUG_TIMER_ADJUST #ifdef DEBUG_TIMER_ADJUST
fprintf(stderr, "Time adjusted by "); fprintf( stderr, "Time adjusted by " );
fprintf(stderr, "%lX", adj_time); fprintf( stderr, "%lX", adj_time );
fprintf(stderr, " TICKS, Total offset "); fprintf( stderr, " TICKS, Total offset " );
fprintf(stderr, "%lX", set_0_time); fprintf( stderr, "%lX", set_0_time );
fprintf(stderr, " TICKS\n"); fprintf( stderr, " TICKS\n" );
#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
*/ */

16
src/timer.h
View file

@ -49,14 +49,14 @@ typedef struct t1_t2_ticks {
unsigned long t2_ticks; unsigned long t2_ticks;
} t1_t2_ticks; } t1_t2_ticks;
extern void reset_timer __ProtoType__((int timer)); extern void reset_timer __ProtoType__( ( int timer ) );
extern void start_timer __ProtoType__((int timer)); extern void start_timer __ProtoType__( ( int timer ) );
extern void restart_timer __ProtoType__((int timer)); extern void restart_timer __ProtoType__( ( int timer ) );
extern void stop_timer __ProtoType__((int timer)); extern void stop_timer __ProtoType__( ( int timer ) );
extern word_64 get_timer __ProtoType__((int timer)); extern word_64 get_timer __ProtoType__( ( int timer ) );
extern long diff_timer __ProtoType__((word_64 * t1, word_64 *t2)); extern long diff_timer __ProtoType__( ( word_64 * t1, word_64* t2 ) );
extern t1_t2_ticks get_t1_t2 __ProtoType__((void)); extern t1_t2_ticks get_t1_t2 __ProtoType__( ( void ));
extern void set_accesstime __ProtoType__((void)); extern void set_accesstime __ProtoType__( ( void ));
#endif /* !_TIMER_H */ #endif /* !_TIMER_H */

4
src/version.h
View file

@ -38,7 +38,7 @@ extern int VERSION_MAJOR;
extern int VERSION_MINOR; extern int VERSION_MINOR;
extern int PATCHLEVEL; extern int PATCHLEVEL;
extern int COMPILE_VERSION; extern int COMPILE_VERSION;
extern char *COMPILE_TIME; extern char* COMPILE_TIME;
extern char *COMPILE_BY; extern char* COMPILE_BY;
#endif /* !_VERSION_H */ #endif /* !_VERSION_H */

3827
src/x48_x11.c
View file

File diff suppressed because it is too large Load diff

28
src/x48_x11.h
View file

@ -92,16 +92,16 @@
#define BLACK 19 #define BLACK 19
typedef struct color_t { typedef struct color_t {
char *name; char* name;
int r, g, b; int r, g, b;
int mono_rgb; int mono_rgb;
int gray_rgb; int gray_rgb;
XColor xcolor; XColor xcolor;
} color_t; } color_t;
extern color_t *colors; extern color_t* colors;
#define COLOR(c) (colors[(c)].xcolor.pixel) #define COLOR( c ) ( colors[ ( c ) ].xcolor.pixel )
#define UPDATE_MENU 1 #define UPDATE_MENU 1
#define UPDATE_DISP 2 #define UPDATE_DISP 2
@ -116,9 +116,9 @@ typedef struct disp_t {
#ifdef HAVE_XSHM #ifdef HAVE_XSHM
int display_update; int display_update;
XShmSegmentInfo disp_info; XShmSegmentInfo disp_info;
XImage *disp_image; XImage* disp_image;
XShmSegmentInfo menu_info; XShmSegmentInfo menu_info;
XImage *menu_image; XImage* menu_image;
#endif #endif
} disp_t; } disp_t;
@ -128,22 +128,22 @@ extern disp_t disp;
extern int shm_flag; extern int shm_flag;
#endif #endif
extern Display *dpy; extern Display* dpy;
extern int screen; extern int screen;
extern int InitDisplay __ProtoType__((int argc, char **argv)); extern int InitDisplay __ProtoType__( ( int argc, char** argv ) );
extern int CreateWindows __ProtoType__((int argc, char **argv)); extern int CreateWindows __ProtoType__( ( int argc, char** argv ) );
extern int GetEvent __ProtoType__((void)); extern int GetEvent __ProtoType__( ( void ));
extern void adjust_contrast __ProtoType__((int contrast)); extern void adjust_contrast __ProtoType__( ( int contrast ) );
extern void refresh_icon __ProtoType__((void)); extern void refresh_icon __ProtoType__( ( void ));
extern void ShowConnections __ProtoType__((char *w, char *i)); extern void ShowConnections __ProtoType__( ( char* w, char* i ) );
extern void exit_x48 __ProtoType__((int tell_x11)); extern void exit_x48 __ProtoType__( ( int tell_x11 ) );
#ifdef HAVE_XSHM #ifdef HAVE_XSHM
extern void refresh_display __ProtoType__((void)); extern void refresh_display __ProtoType__( ( void ));
#endif #endif
#endif /* !_X48_X11_H */ #endif /* !_X48_X11_H */