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

update .clang-format and format all the code

Browse source
This commit is contained in:
Gwenhael Le Moine 2023-09-22 09:44:23 +02:00
parent 7979ebe5c4
commit 28d46cbfb3
No known key found for this signature in database
GPG key ID: FDFE3669426707A7
22 changed files with 2956 additions and 5234 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

71
.clang-format
View file

@ -1,18 +1,59 @@
--- ---
IndentCaseLabels: 'true' Language: Cpp
IndentPPDirectives: None ColumnLimit: 140
IndentWidth: '4' IndentWidth: 4
PointerAlignment: Left PPIndentWidth: 2
SortIncludes: 'false' UseTab: Never
SpaceAfterTemplateKeyword: 'false'
SpaceBeforeAssignmentOperators: 'true'
SpaceBeforeParens: ControlStatements
SpaceBeforeRangeBasedForLoopColon: 'true'
SpaceInEmptyParentheses: 'false'
SpacesInAngles: 'true'
SpacesInCStyleCastParentheses: 'true'
SpacesInContainerLiterals: 'true'
SpacesInParentheses: 'true'
SpacesInSquareBrackets: 'true'
AlignArrayOfStructures: Left
IndentCaseBlocks: true
IndentCaseLabels: true
IndentGotoLabels: false
IndentPPDirectives: AfterHash
IndentWrappedFunctionNames: true
InsertBraces: false
InsertNewlineAtEOF: true
MaxEmptyLinesToKeep: 1
PointerAlignment: Left
ReferenceAlignment: Left
QualifierAlignment: Left
SortIncludes: false
SpaceBeforeAssignmentOperators: true
SpaceBeforeParens: ControlStatements
SpaceBeforeRangeBasedForLoopColon: true
SpaceInEmptyParentheses: false
SpacesInAngles: true
SpacesInCStyleCastParentheses: true
SpacesInContainerLiterals: true
SpacesInParentheses: true
SpacesInSquareBrackets: true
SpaceAfterCStyleCast: false
SpaceAfterLogicalNot: false
BreakBeforeBraces: Custom
BraceWrapping:
AfterCaseLabel: false
AfterClass: false
AfterControlStatement: Never
AfterEnum: false
AfterExternBlock: false
AfterFunction: true
AfterNamespace: false
AfterObjCDeclaration: false
AfterStruct: false
AfterUnion: false
BeforeCatch: false
BeforeElse: false
BeforeLambdaBody: false
BeforeWhile: false
IndentBraces: false
SplitEmptyFunction: true
SplitEmptyRecord: true
SplitEmptyNamespace: true
... ...

702
src/debugger.c
View file

File diff suppressed because it is too large Load diff

126
src/emu_actions.c
View file

@ -22,7 +22,8 @@ int conf_bank2 = 0x00000;
short conf_tab_sx[] = { 1, 2, 2, 2, 2, 0 }; short conf_tab_sx[] = { 1, 2, 2, 2, 2, 0 };
short conf_tab_gx[] = { 1, 2, 2, 2, 2, 0 }; short conf_tab_gx[] = { 1, 2, 2, 2, 2, 0 };
void do_in( void ) { void do_in( void )
{
int i, in, out; int i, in, out;
out = 0; out = 0;
@ -65,7 +66,8 @@ 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++ ) {
@ -73,7 +75,8 @@ void register_to_status( unsigned char* r ) {
} }
} }
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++ ) {
@ -85,7 +88,8 @@ void status_to_register( unsigned char* r ) {
} }
} }
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++ ) {
@ -98,32 +102,24 @@ void swap_register_status( unsigned char* r ) {
} }
} }
void clear_status( void ) { void clear_status( void )
{
for ( int i = 0; i < 12; i++ ) for ( int 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 ) { unsigned char get_register_nibble( unsigned char* reg, int n ) { return reg[ n ]; }
return reg[ n ];
}
void set_register_bit( unsigned char* reg, int n ) { void set_register_bit( unsigned char* reg, int n ) { reg[ n / 4 ] |= ( 1 << ( n % 4 ) ); }
reg[ n / 4 ] |= ( 1 << ( n % 4 ) );
}
void clear_register_bit( unsigned char* reg, int n ) { void clear_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 ) { int get_register_bit( unsigned char* reg, int n ) { return ( ( int )( reg[ n / 4 ] & ( 1 << ( n % 4 ) ) ) > 0 ) ? 1 : 0; }
return ( ( int )( reg[ n / 4 ] & ( 1 << ( n % 4 ) ) ) > 0 ) ? 1 : 0;
}
void do_reset( void ) { void do_reset( void )
{
for ( int i = 0; i < 6; i++ ) { for ( int 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 ];
@ -139,7 +135,8 @@ 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 ) {
saturn.int_pending = 0; saturn.int_pending = 0;
saturn.intenable = 0; saturn.intenable = 0;
@ -155,7 +152,8 @@ void do_return_interupt( void ) {
} }
} }
void do_interupt( void ) { void do_interupt( void )
{
interrupt_called = 1; interrupt_called = 1;
if ( saturn.intenable ) { if ( saturn.intenable ) {
push_return_addr( saturn.PC ); push_return_addr( saturn.PC );
@ -164,7 +162,8 @@ void do_interupt( void ) {
} }
} }
void do_kbd_int( void ) { void do_kbd_int( void )
{
interrupt_called = 1; interrupt_called = 1;
if ( saturn.intenable ) { if ( saturn.intenable ) {
push_return_addr( saturn.PC ); push_return_addr( saturn.PC );
@ -174,7 +173,8 @@ void do_kbd_int( void ) {
saturn.int_pending = 1; saturn.int_pending = 1;
} }
void do_reset_interrupt_system( void ) { void do_reset_interrupt_system( void )
{
saturn.kbd_ien = 1; saturn.kbd_ien = 1;
int gen_intr = 0; int gen_intr = 0;
for ( int i = 0; i < 9; i++ ) { for ( int i = 0; i < 9; i++ ) {
@ -187,7 +187,8 @@ void do_reset_interrupt_system( void ) {
do_kbd_int(); do_kbd_int();
} }
void do_unconfigure( void ) { void do_unconfigure( void )
{
int i; int i;
unsigned int conf = 0; unsigned int conf = 0;
@ -210,7 +211,8 @@ void do_unconfigure( void ) {
} }
} }
void do_configure( void ) { void do_configure( void )
{
int i; int i;
unsigned long conf = 0; unsigned long conf = 0;
@ -222,25 +224,22 @@ void do_configure( void ) {
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 ] = saturn.mem_cntl[ i ].config[ saturn.mem_cntl[ i ].unconfigured ] = conf;
conf;
break; break;
} }
} }
} }
int get_identification( void ) { int get_identification( void )
{
int i; int i;
static int chip_id[] = { 0, 0, 0, 0, 0x05, 0xf6, static int chip_id[] = { 0, 0, 0, 0, 0x05, 0xf6, 0x07, 0xf8, 0x01, 0xf2, 0, 0 };
0x07, 0xf8, 0x01, 0xf2, 0, 0 };
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;
int id = ( i < 6 ) int id = ( i < 6 ) ? chip_id[ 2 * i + ( 2 - saturn.mem_cntl[ i ].unconfigured ) ] : 0;
? chip_id[ 2 * i + ( 2 - saturn.mem_cntl[ i ].unconfigured ) ]
: 0;
for ( i = 0; i < 3; i++ ) { for ( i = 0; i < 3; i++ ) {
saturn.C[ i ] = id & 0x0f; saturn.C[ i ] = id & 0x0f;
@ -250,7 +249,8 @@ int get_identification( void ) {
return 0; return 0;
} }
void do_shutdown( void ) { void do_shutdown( void )
{
if ( device.display_touched ) { if ( device.display_touched ) {
device.display_touched = 0; device.display_touched = 0;
ui_refresh_LCD(); ui_refresh_LCD();
@ -325,7 +325,8 @@ void do_shutdown( void ) {
start_timer( RUN_TIMER ); start_timer( RUN_TIMER );
} }
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 )
@ -336,7 +337,8 @@ void clear_hardware_stat( int op ) {
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;
@ -353,7 +355,8 @@ int is_zero_hardware_stat( int op ) {
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 ) {
@ -364,13 +367,15 @@ void push_return_addr( long addr ) {
saturn.rstk[ saturn.rstkp ] = addr; saturn.rstk[ saturn.rstkp ] = addr;
} }
long pop_return_addr( void ) { long pop_return_addr( void )
{
if ( saturn.rstkp < 0 ) if ( saturn.rstkp < 0 )
return 0; return 0;
return saturn.rstk[ saturn.rstkp-- ]; return saturn.rstk[ saturn.rstkp-- ];
} }
void load_constant( unsigned char* reg, int n, long addr ) { void load_constant( unsigned char* reg, int n, long addr )
{
int p = saturn.P; int p = saturn.P;
for ( int i = 0; i < n; i++ ) { for ( int i = 0; i < n; i++ ) {
@ -379,14 +384,16 @@ void load_constant( unsigned char* reg, int n, long addr ) {
} }
} }
void load_addr( word_20* dat, long addr, int n ) { void load_addr( word_20* dat, long addr, int n )
{
for ( int i = 0; i < n; i++ ) { for ( int 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 register_to_address( unsigned char* reg, word_20* dat, int s ) { void register_to_address( unsigned char* reg, word_20* dat, int s )
{
int n; int n;
if ( s ) if ( s )
@ -399,7 +406,8 @@ void register_to_address( unsigned char* reg, word_20* dat, int s ) {
} }
} }
long dat_to_addr( unsigned char* dat ) { long dat_to_addr( unsigned char* dat )
{
long addr = 0; long addr = 0;
for ( int i = 4; i >= 0; i-- ) { for ( int i = 4; i >= 0; i-- ) {
@ -409,14 +417,16 @@ long dat_to_addr( unsigned char* dat ) {
return addr; return addr;
} }
void addr_to_dat( long addr, unsigned char* dat ) { void addr_to_dat( long addr, unsigned char* dat )
{
for ( int i = 0; i < 5; i++ ) { for ( int 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;
@ -426,13 +436,12 @@ 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 )
@ -441,7 +450,8 @@ static inline int get_start( int code ) {
return s; /* FIXME: potentially return uninitialized s ? */ return s; /* FIXME: potentially return uninitialized 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 )
@ -450,7 +460,8 @@ static inline int get_end( int code ) {
return e; /* FIXME: potentially return uninitialized e ? */ return e; /* FIXME: potentially return uninitialized e ? */
} }
void store( word_20 dat, unsigned char* reg, int code ) { void store( word_20 dat, unsigned char* reg, int code )
{
int s = get_start( code ); int s = get_start( code );
int e = get_end( code ); int e = get_end( code );
@ -458,12 +469,14 @@ void store( word_20 dat, unsigned char* reg, int code ) {
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 )
{
for ( int i = 0; i < n; i++ ) for ( int 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 s = get_start( code ); int s = get_start( code );
int e = get_end( code ); int e = get_end( code );
@ -471,7 +484,8 @@ void recall( unsigned char* reg, word_20 dat, int code ) {
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 )
{
for ( int i = 0; i < n; i++ ) for ( int i = 0; i < n; i++ )
reg[ i ] = read_nibble_crc( dat++ ); reg[ i ] = read_nibble_crc( dat++ );
} }

325
src/emu_emulate.c
View file

@ -3,11 +3,11 @@
#include <sys/time.h> #include <sys/time.h>
#include "runtime_options.h" /* throttle */
#include "ui.h" /* ui_get_event(); ui_adjust_contrast(); ui_update_LCD(); ui_draw_annunc(); */
#include "debugger.h" /* enter_debugger, TRAP_INSTRUCTION, ILLEGAL_INSTRUCTION */ #include "debugger.h" /* enter_debugger, TRAP_INSTRUCTION, ILLEGAL_INSTRUCTION */
#include "emulator.h" #include "emulator.h"
#include "emulator_inner.h" #include "emulator_inner.h"
#include "runtime_options.h" /* throttle */
#include "ui.h" /* ui_get_event(); ui_adjust_contrast(); ui_update_LCD(); ui_draw_annunc(); */
#define P_FIELD 0 /* unused? */ #define P_FIELD 0 /* unused? */
#define WP_FIELD 1 /* unused? */ #define WP_FIELD 1 /* unused? */
@ -70,8 +70,7 @@ unsigned long delta_t_16;
unsigned long delta_i; unsigned long delta_i;
word_64 run; word_64 run;
static word_20 jumpmasks[] = { 0xffffffff, 0xfffffff0, 0xffffff00, 0xfffff000, static word_20 jumpmasks[] = { 0xffffffff, 0xfffffff0, 0xffffff00, 0xfffff000, 0xffff0000, 0xfff00000, 0xff000000, 0xf0000000 };
0xffff0000, 0xfff00000, 0xff000000, 0xf0000000 };
saturn_t saturn; saturn_t saturn;
@ -79,7 +78,8 @@ extern int device_check;
device_t device; device_t device;
int decode_group_80( void ) { int decode_group_80( void )
{
int t, op3, op4, op5, op6; int t, op3, op4, op5, op6;
unsigned char* REG; unsigned char* REG;
long addr; long addr;
@ -173,8 +173,7 @@ int decode_group_80( void ) {
t = 0; t = 0;
else else
t = 1; t = 1;
saturn.CARRY = saturn.CARRY = ( get_register_bit( REG, op5 ) == t ) ? 1 : 0;
( get_register_bit( REG, op5 ) == t ) ? 1 : 0;
if ( saturn.CARRY ) { if ( saturn.CARRY ) {
saturn.PC += 5; saturn.PC += 5;
op6 = read_nibbles( saturn.PC, 2 ); op6 = read_nibbles( saturn.PC, 2 );
@ -248,7 +247,8 @@ int decode_group_80( void ) {
} }
} }
int decode_group_1( void ) { int decode_group_1( void )
{
int op, op2, op3, op4; int op, op2, op3, op4;
op2 = read_nibble( saturn.PC + 1 ); op2 = read_nibble( saturn.PC + 1 );
@ -645,7 +645,8 @@ int decode_group_1( void ) {
} }
} }
static inline int decode_8_thru_f( int op1 ) { static inline int decode_8_thru_f( int op1 )
{
int op2, op3, op4, op5, op6; int op2, op3, op4, op5, op6;
op2 = read_nibble( saturn.PC + 1 ); op2 = read_nibble( saturn.PC + 1 );
@ -697,23 +698,19 @@ static inline int decode_8_thru_f( int op1 ) {
switch ( op5 & 3 ) { switch ( op5 & 3 ) {
case 0: /* A=A+CON */ case 0: /* A=A+CON */
saturn.PC += 6; saturn.PC += 6;
add_register_constant( saturn.A, op4, add_register_constant( saturn.A, op4, op6 + 1 );
op6 + 1 );
return 0; return 0;
case 1: /* B=B+CON */ case 1: /* B=B+CON */
saturn.PC += 6; saturn.PC += 6;
add_register_constant( saturn.B, op4, add_register_constant( saturn.B, op4, op6 + 1 );
op6 + 1 );
return 0; return 0;
case 2: /* C=C+CON */ case 2: /* C=C+CON */
saturn.PC += 6; saturn.PC += 6;
add_register_constant( saturn.C, op4, add_register_constant( saturn.C, op4, op6 + 1 );
op6 + 1 );
return 0; return 0;
case 3: /* D=D+CON */ case 3: /* D=D+CON */
saturn.PC += 6; saturn.PC += 6;
add_register_constant( saturn.D, op4, add_register_constant( saturn.D, op4, op6 + 1 );
op6 + 1 );
return 0; return 0;
default: default:
return 1; return 1;
@ -722,23 +719,19 @@ static inline int decode_8_thru_f( int op1 ) {
switch ( op5 & 3 ) { switch ( op5 & 3 ) {
case 0: /* A=A-CON */ case 0: /* A=A-CON */
saturn.PC += 6; saturn.PC += 6;
sub_register_constant( saturn.A, op4, sub_register_constant( saturn.A, op4, op6 + 1 );
op6 + 1 );
return 0; return 0;
case 1: /* B=B-CON */ case 1: /* B=B-CON */
saturn.PC += 6; saturn.PC += 6;
sub_register_constant( saturn.B, op4, sub_register_constant( saturn.B, op4, op6 + 1 );
op6 + 1 );
return 0; return 0;
case 2: /* C=C-CON */ case 2: /* C=C-CON */
saturn.PC += 6; saturn.PC += 6;
sub_register_constant( saturn.C, op4, sub_register_constant( saturn.C, op4, op6 + 1 );
op6 + 1 );
return 0; return 0;
case 3: /* D=D-CON */ case 3: /* D=D-CON */
saturn.PC += 6; saturn.PC += 6;
sub_register_constant( saturn.D, op4, sub_register_constant( saturn.D, op4, op6 + 1 );
op6 + 1 );
return 0; return 0;
default: default:
return 1; return 1;
@ -776,59 +769,49 @@ static inline int decode_8_thru_f( int op1 ) {
switch ( op6 ) { switch ( op6 ) {
case 0: /* saturn.R0=A */ case 0: /* saturn.R0=A */
saturn.PC += 6; saturn.PC += 6;
copy_register( saturn.R0, saturn.A, copy_register( saturn.R0, saturn.A, op4 );
op4 );
return 0; return 0;
case 1: /* saturn.R1=A */ case 1: /* saturn.R1=A */
case 5: case 5:
saturn.PC += 6; saturn.PC += 6;
copy_register( saturn.R1, saturn.A, copy_register( saturn.R1, saturn.A, op4 );
op4 );
return 0; return 0;
case 2: /* saturn.R2=A */ case 2: /* saturn.R2=A */
case 6: case 6:
saturn.PC += 6; saturn.PC += 6;
copy_register( saturn.R2, saturn.A, copy_register( saturn.R2, saturn.A, op4 );
op4 );
return 0; return 0;
case 3: /* saturn.R3=A */ case 3: /* saturn.R3=A */
case 7: case 7:
saturn.PC += 6; saturn.PC += 6;
copy_register( saturn.R3, saturn.A, copy_register( saturn.R3, saturn.A, op4 );
op4 );
return 0; return 0;
case 4: /* saturn.R4=A */ case 4: /* saturn.R4=A */
saturn.PC += 6; saturn.PC += 6;
copy_register( saturn.R4, saturn.A, copy_register( saturn.R4, saturn.A, op4 );
op4 );
return 0; return 0;
case 8: /* saturn.R0=C */ case 8: /* saturn.R0=C */
saturn.PC += 6; saturn.PC += 6;
copy_register( saturn.R0, saturn.C, copy_register( saturn.R0, saturn.C, op4 );
op4 );
return 0; return 0;
case 9: /* saturn.R1=C */ case 9: /* saturn.R1=C */
case 0xd: case 0xd:
saturn.PC += 6; saturn.PC += 6;
copy_register( saturn.R1, saturn.C, copy_register( saturn.R1, saturn.C, op4 );
op4 );
return 0; return 0;
case 0xa: /* saturn.R2=C */ case 0xa: /* saturn.R2=C */
case 0xe: case 0xe:
saturn.PC += 6; saturn.PC += 6;
copy_register( saturn.R2, saturn.C, copy_register( saturn.R2, saturn.C, op4 );
op4 );
return 0; return 0;
case 0xb: /* saturn.R3=C */ case 0xb: /* saturn.R3=C */
case 0xf: case 0xf:
saturn.PC += 6; saturn.PC += 6;
copy_register( saturn.R3, saturn.C, copy_register( saturn.R3, saturn.C, op4 );
op4 );
return 0; return 0;
case 0xc: /* saturn.R4=C */ case 0xc: /* saturn.R4=C */
saturn.PC += 6; saturn.PC += 6;
copy_register( saturn.R4, saturn.C, copy_register( saturn.R4, saturn.C, op4 );
op4 );
return 0; return 0;
default: default:
return 1; return 1;
@ -837,59 +820,49 @@ static inline int decode_8_thru_f( int op1 ) {
switch ( op6 ) { switch ( op6 ) {
case 0: /* A=R0 */ case 0: /* A=R0 */
saturn.PC += 6; saturn.PC += 6;
copy_register( saturn.A, saturn.R0, copy_register( saturn.A, saturn.R0, op4 );
op4 );
return 0; return 0;
case 1: /* A=R1 */ case 1: /* A=R1 */
case 5: case 5:
saturn.PC += 6; saturn.PC += 6;
copy_register( saturn.A, saturn.R1, copy_register( saturn.A, saturn.R1, op4 );
op4 );
return 0; return 0;
case 2: /* A=R2 */ case 2: /* A=R2 */
case 6: case 6:
saturn.PC += 6; saturn.PC += 6;
copy_register( saturn.A, saturn.R2, copy_register( saturn.A, saturn.R2, op4 );
op4 );
return 0; return 0;
case 3: /* A=R3 */ case 3: /* A=R3 */
case 7: case 7:
saturn.PC += 6; saturn.PC += 6;
copy_register( saturn.A, saturn.R3, copy_register( saturn.A, saturn.R3, op4 );
op4 );
return 0; return 0;
case 4: /* A=R4 */ case 4: /* A=R4 */
saturn.PC += 6; saturn.PC += 6;
copy_register( saturn.A, saturn.R4, copy_register( saturn.A, saturn.R4, op4 );
op4 );
return 0; return 0;
case 8: /* C=R0 */ case 8: /* C=R0 */
saturn.PC += 6; saturn.PC += 6;
copy_register( saturn.C, saturn.R0, copy_register( saturn.C, saturn.R0, op4 );
op4 );
return 0; return 0;
case 9: /* C=R1 */ case 9: /* C=R1 */
case 0xd: case 0xd:
saturn.PC += 6; saturn.PC += 6;
copy_register( saturn.C, saturn.R1, copy_register( saturn.C, saturn.R1, op4 );
op4 );
return 0; return 0;
case 0xa: /* C=R2 */ case 0xa: /* C=R2 */
case 0xe: case 0xe:
saturn.PC += 6; saturn.PC += 6;
copy_register( saturn.C, saturn.R2, copy_register( saturn.C, saturn.R2, op4 );
op4 );
return 0; return 0;
case 0xb: /* C=R3 */ case 0xb: /* C=R3 */
case 0xf: case 0xf:
saturn.PC += 6; saturn.PC += 6;
copy_register( saturn.C, saturn.R3, copy_register( saturn.C, saturn.R3, op4 );
op4 );
return 0; return 0;
case 0xc: /* C=R4 */ case 0xc: /* C=R4 */
saturn.PC += 6; saturn.PC += 6;
copy_register( saturn.C, saturn.R4, copy_register( saturn.C, saturn.R4, op4 );
op4 );
return 0; return 0;
default: default:
return 1; return 1;
@ -898,59 +871,49 @@ static inline int decode_8_thru_f( int op1 ) {
switch ( op6 ) { switch ( op6 ) {
case 0: /* AR0EX */ case 0: /* AR0EX */
saturn.PC += 6; saturn.PC += 6;
exchange_register( saturn.A, exchange_register( saturn.A, saturn.R0, op4 );
saturn.R0, op4 );
return 0; return 0;
case 1: /* AR1EX */ case 1: /* AR1EX */
case 5: case 5:
saturn.PC += 6; saturn.PC += 6;
exchange_register( saturn.A, exchange_register( saturn.A, saturn.R1, op4 );
saturn.R1, op4 );
return 0; return 0;
case 2: /* AR2EX */ case 2: /* AR2EX */
case 6: case 6:
saturn.PC += 6; saturn.PC += 6;
exchange_register( saturn.A, exchange_register( saturn.A, saturn.R2, op4 );
saturn.R2, op4 );
return 0; return 0;
case 3: /* AR3EX */ case 3: /* AR3EX */
case 7: case 7:
saturn.PC += 6; saturn.PC += 6;
exchange_register( saturn.A, exchange_register( saturn.A, saturn.R3, op4 );
saturn.R3, op4 );
return 0; return 0;
case 4: /* AR4EX */ case 4: /* AR4EX */
saturn.PC += 6; saturn.PC += 6;
exchange_register( saturn.A, exchange_register( saturn.A, saturn.R4, op4 );
saturn.R4, op4 );
return 0; return 0;
case 8: /* CR0EX */ case 8: /* CR0EX */
saturn.PC += 6; saturn.PC += 6;
exchange_register( saturn.C, exchange_register( saturn.C, saturn.R0, op4 );
saturn.R0, op4 );
return 0; return 0;
case 9: /* CR1EX */ case 9: /* CR1EX */
case 0xd: case 0xd:
saturn.PC += 6; saturn.PC += 6;
exchange_register( saturn.C, exchange_register( saturn.C, saturn.R1, op4 );
saturn.R1, op4 );
return 0; return 0;
case 0xa: /* CR2EX */ case 0xa: /* CR2EX */
case 0xe: case 0xe:
saturn.PC += 6; saturn.PC += 6;
exchange_register( saturn.C, exchange_register( saturn.C, saturn.R2, op4 );
saturn.R2, op4 );
return 0; return 0;
case 0xb: /* CR3EX */ case 0xb: /* CR3EX */
case 0xf: case 0xf:
saturn.PC += 6; saturn.PC += 6;
exchange_register( saturn.C, exchange_register( saturn.C, saturn.R3, op4 );
saturn.R3, op4 );
return 0; return 0;
case 0xc: /* CR4EX */ case 0xc: /* CR4EX */
saturn.PC += 6; saturn.PC += 6;
exchange_register( saturn.C, exchange_register( saturn.C, saturn.R4, op4 );
saturn.R4, op4 );
return 0; return 0;
default: default:
return 1; return 1;
@ -1093,68 +1056,52 @@ static inline int decode_8_thru_f( int op1 ) {
op3 = read_nibble( saturn.PC + 2 ); op3 = read_nibble( saturn.PC + 2 );
switch ( op3 ) { switch ( op3 ) {
case 0: /* ?A=B */ case 0: /* ?A=B */
saturn.CARRY = is_equal_register( saturn.CARRY = is_equal_register( saturn.A, saturn.B, A_FIELD );
saturn.A, saturn.B, A_FIELD );
break; break;
case 1: /* ?B=C */ case 1: /* ?B=C */
saturn.CARRY = is_equal_register( saturn.CARRY = is_equal_register( saturn.B, saturn.C, A_FIELD );
saturn.B, saturn.C, A_FIELD );
break; break;
case 2: /* ?A=C */ case 2: /* ?A=C */
saturn.CARRY = is_equal_register( saturn.CARRY = is_equal_register( saturn.A, saturn.C, A_FIELD );
saturn.A, saturn.C, A_FIELD );
break; break;
case 3: /* ?C=D */ case 3: /* ?C=D */
saturn.CARRY = is_equal_register( saturn.CARRY = is_equal_register( saturn.C, saturn.D, A_FIELD );
saturn.C, saturn.D, A_FIELD );
break; break;
case 4: /* ?A#B */ case 4: /* ?A#B */
saturn.CARRY = is_not_equal_register( saturn.CARRY = is_not_equal_register( saturn.A, saturn.B, A_FIELD );
saturn.A, saturn.B, A_FIELD );
break; break;
case 5: /* ?B#C */ case 5: /* ?B#C */
saturn.CARRY = is_not_equal_register( saturn.CARRY = is_not_equal_register( saturn.B, saturn.C, A_FIELD );
saturn.B, saturn.C, A_FIELD );
break; break;
case 6: /* ?A#C */ case 6: /* ?A#C */
saturn.CARRY = is_not_equal_register( saturn.CARRY = is_not_equal_register( saturn.A, saturn.C, A_FIELD );
saturn.A, saturn.C, A_FIELD );
break; break;
case 7: /* ?C#D */ case 7: /* ?C#D */
saturn.CARRY = is_not_equal_register( saturn.CARRY = is_not_equal_register( saturn.C, saturn.D, A_FIELD );
saturn.C, saturn.D, A_FIELD );
break; break;
case 8: /* ?A=0 */ case 8: /* ?A=0 */
saturn.CARRY = saturn.CARRY = is_zero_register( saturn.A, A_FIELD );
is_zero_register( saturn.A, A_FIELD );
break; break;
case 9: /* ?B=0 */ case 9: /* ?B=0 */
saturn.CARRY = saturn.CARRY = is_zero_register( saturn.B, A_FIELD );
is_zero_register( saturn.B, A_FIELD );
break; break;
case 0xa: /* ?C=0 */ case 0xa: /* ?C=0 */
saturn.CARRY = saturn.CARRY = is_zero_register( saturn.C, A_FIELD );
is_zero_register( saturn.C, A_FIELD );
break; break;
case 0xb: /* ?D=0 */ case 0xb: /* ?D=0 */
saturn.CARRY = saturn.CARRY = is_zero_register( saturn.D, A_FIELD );
is_zero_register( saturn.D, A_FIELD );
break; break;
case 0xc: /* ?A#0 */ case 0xc: /* ?A#0 */
saturn.CARRY = saturn.CARRY = is_not_zero_register( saturn.A, A_FIELD );
is_not_zero_register( saturn.A, A_FIELD );
break; break;
case 0xd: /* ?B#0 */ case 0xd: /* ?B#0 */
saturn.CARRY = saturn.CARRY = is_not_zero_register( saturn.B, A_FIELD );
is_not_zero_register( saturn.B, A_FIELD );
break; break;
case 0xe: /* ?C#0 */ case 0xe: /* ?C#0 */
saturn.CARRY = saturn.CARRY = is_not_zero_register( saturn.C, A_FIELD );
is_not_zero_register( saturn.C, A_FIELD );
break; break;
case 0xf: /* ?D#0 */ case 0xf: /* ?D#0 */
saturn.CARRY = saturn.CARRY = is_not_zero_register( saturn.D, A_FIELD );
is_not_zero_register( saturn.D, A_FIELD );
break; break;
default: default:
return 1; return 1;
@ -1178,68 +1125,52 @@ static inline int decode_8_thru_f( int op1 ) {
op3 = read_nibble( saturn.PC + 2 ); op3 = read_nibble( saturn.PC + 2 );
switch ( op3 ) { switch ( op3 ) {
case 0: /* ?A>B */ case 0: /* ?A>B */
saturn.CARRY = is_greater_register( saturn.CARRY = is_greater_register( saturn.A, saturn.B, A_FIELD );
saturn.A, saturn.B, A_FIELD );
break; break;
case 1: /* ?B>C */ case 1: /* ?B>C */
saturn.CARRY = is_greater_register( saturn.CARRY = is_greater_register( saturn.B, saturn.C, A_FIELD );
saturn.B, saturn.C, A_FIELD );
break; break;
case 2: /* ?C>A */ case 2: /* ?C>A */
saturn.CARRY = is_greater_register( saturn.CARRY = is_greater_register( saturn.C, saturn.A, A_FIELD );
saturn.C, saturn.A, A_FIELD );
break; break;
case 3: /* ?D>C */ case 3: /* ?D>C */
saturn.CARRY = is_greater_register( saturn.CARRY = is_greater_register( saturn.D, saturn.C, A_FIELD );
saturn.D, saturn.C, A_FIELD );
break; break;
case 4: /* ?A<B */ case 4: /* ?A<B */
saturn.CARRY = saturn.CARRY = is_less_register( saturn.A, saturn.B, A_FIELD );
is_less_register( saturn.A, saturn.B, A_FIELD );
break; break;
case 5: /* ?B<C */ case 5: /* ?B<C */
saturn.CARRY = saturn.CARRY = is_less_register( saturn.B, saturn.C, A_FIELD );
is_less_register( saturn.B, saturn.C, A_FIELD );
break; break;
case 6: /* ?C<A */ case 6: /* ?C<A */
saturn.CARRY = saturn.CARRY = is_less_register( saturn.C, saturn.A, A_FIELD );
is_less_register( saturn.C, saturn.A, A_FIELD );
break; break;
case 7: /* ?D<C */ case 7: /* ?D<C */
saturn.CARRY = saturn.CARRY = is_less_register( saturn.D, saturn.C, A_FIELD );
is_less_register( saturn.D, saturn.C, A_FIELD );
break; break;
case 8: /* ?A>=B */ case 8: /* ?A>=B */
saturn.CARRY = is_greater_or_equal_register( saturn.CARRY = is_greater_or_equal_register( saturn.A, saturn.B, A_FIELD );
saturn.A, saturn.B, A_FIELD );
break; break;
case 9: /* ?B>=C */ case 9: /* ?B>=C */
saturn.CARRY = is_greater_or_equal_register( saturn.CARRY = is_greater_or_equal_register( saturn.B, saturn.C, A_FIELD );
saturn.B, saturn.C, A_FIELD );
break; break;
case 0xa: /* ?C>=A */ case 0xa: /* ?C>=A */
saturn.CARRY = is_greater_or_equal_register( saturn.CARRY = is_greater_or_equal_register( saturn.C, saturn.A, A_FIELD );
saturn.C, saturn.A, A_FIELD );
break; break;
case 0xb: /* ?D>=C */ case 0xb: /* ?D>=C */
saturn.CARRY = is_greater_or_equal_register( saturn.CARRY = is_greater_or_equal_register( saturn.D, saturn.C, A_FIELD );
saturn.D, saturn.C, A_FIELD );
break; break;
case 0xc: /* ?A<=B */ case 0xc: /* ?A<=B */
saturn.CARRY = is_less_or_equal_register( saturn.CARRY = is_less_or_equal_register( saturn.A, saturn.B, A_FIELD );
saturn.A, saturn.B, A_FIELD );
break; break;
case 0xd: /* ?B<=C */ case 0xd: /* ?B<=C */
saturn.CARRY = is_less_or_equal_register( saturn.CARRY = is_less_or_equal_register( saturn.B, saturn.C, A_FIELD );
saturn.B, saturn.C, A_FIELD );
break; break;
case 0xe: /* ?C<=A */ case 0xe: /* ?C<=A */
saturn.CARRY = is_less_or_equal_register( saturn.CARRY = is_less_or_equal_register( saturn.C, saturn.A, A_FIELD );
saturn.C, saturn.A, A_FIELD );
break; break;
case 0xf: /* ?D<=C */ case 0xf: /* ?D<=C */
saturn.CARRY = is_less_or_equal_register( saturn.CARRY = is_less_or_equal_register( saturn.D, saturn.C, A_FIELD );
saturn.D, saturn.C, A_FIELD );
break; break;
default: default:
return 1; return 1;
@ -1293,36 +1224,28 @@ static inline int decode_8_thru_f( int op1 ) {
if ( op2 < 8 ) { if ( op2 < 8 ) {
switch ( op3 ) { switch ( op3 ) {
case 0: /* ?A=B */ case 0: /* ?A=B */
saturn.CARRY = saturn.CARRY = is_equal_register( saturn.A, saturn.B, op2 );
is_equal_register( saturn.A, saturn.B, op2 );
break; break;
case 1: /* ?B=C */ case 1: /* ?B=C */
saturn.CARRY = saturn.CARRY = is_equal_register( saturn.B, saturn.C, op2 );
is_equal_register( saturn.B, saturn.C, op2 );
break; break;
case 2: /* ?A=C */ case 2: /* ?A=C */
saturn.CARRY = saturn.CARRY = is_equal_register( saturn.A, saturn.C, op2 );
is_equal_register( saturn.A, saturn.C, op2 );
break; break;
case 3: /* ?C=D */ case 3: /* ?C=D */
saturn.CARRY = saturn.CARRY = is_equal_register( saturn.C, saturn.D, op2 );
is_equal_register( saturn.C, saturn.D, op2 );
break; break;
case 4: /* ?A#B */ case 4: /* ?A#B */
saturn.CARRY = saturn.CARRY = is_not_equal_register( saturn.A, saturn.B, op2 );
is_not_equal_register( saturn.A, saturn.B, op2 );
break; break;
case 5: /* ?B#C */ case 5: /* ?B#C */
saturn.CARRY = saturn.CARRY = is_not_equal_register( saturn.B, saturn.C, op2 );
is_not_equal_register( saturn.B, saturn.C, op2 );
break; break;
case 6: /* ?A#C */ case 6: /* ?A#C */
saturn.CARRY = saturn.CARRY = is_not_equal_register( saturn.A, saturn.C, op2 );
is_not_equal_register( saturn.A, saturn.C, op2 );
break; break;
case 7: /* ?C#D */ case 7: /* ?C#D */
saturn.CARRY = saturn.CARRY = is_not_equal_register( saturn.C, saturn.D, op2 );
is_not_equal_register( saturn.C, saturn.D, op2 );
break; break;
case 8: /* ?A=0 */ case 8: /* ?A=0 */
saturn.CARRY = is_zero_register( saturn.A, op2 ); saturn.CARRY = is_zero_register( saturn.A, op2 );
@ -1355,68 +1278,52 @@ static inline int decode_8_thru_f( int op1 ) {
op2 &= 7; op2 &= 7;
switch ( op3 ) { switch ( op3 ) {
case 0: /* ?A>B */ case 0: /* ?A>B */
saturn.CARRY = saturn.CARRY = is_greater_register( saturn.A, saturn.B, op2 );
is_greater_register( saturn.A, saturn.B, op2 );
break; break;
case 1: /* ?B>C */ case 1: /* ?B>C */
saturn.CARRY = saturn.CARRY = is_greater_register( saturn.B, saturn.C, op2 );
is_greater_register( saturn.B, saturn.C, op2 );
break; break;
case 2: /* ?C>A */ case 2: /* ?C>A */
saturn.CARRY = saturn.CARRY = is_greater_register( saturn.C, saturn.A, op2 );
is_greater_register( saturn.C, saturn.A, op2 );
break; break;
case 3: /* ?D>C */ case 3: /* ?D>C */
saturn.CARRY = saturn.CARRY = is_greater_register( saturn.D, saturn.C, op2 );
is_greater_register( saturn.D, saturn.C, op2 );
break; break;
case 4: /* ?A<B */ case 4: /* ?A<B */
saturn.CARRY = saturn.CARRY = is_less_register( saturn.A, saturn.B, op2 );
is_less_register( saturn.A, saturn.B, op2 );
break; break;
case 5: /* ?B<C */ case 5: /* ?B<C */
saturn.CARRY = saturn.CARRY = is_less_register( saturn.B, saturn.C, op2 );
is_less_register( saturn.B, saturn.C, op2 );
break; break;
case 6: /* ?C<A */ case 6: /* ?C<A */
saturn.CARRY = saturn.CARRY = is_less_register( saturn.C, saturn.A, op2 );
is_less_register( saturn.C, saturn.A, op2 );
break; break;
case 7: /* ?D<C */ case 7: /* ?D<C */
saturn.CARRY = saturn.CARRY = is_less_register( saturn.D, saturn.C, op2 );
is_less_register( saturn.D, saturn.C, op2 );
break; break;
case 8: /* ?A>=B */ case 8: /* ?A>=B */
saturn.CARRY = is_greater_or_equal_register( saturn.CARRY = is_greater_or_equal_register( saturn.A, saturn.B, op2 );
saturn.A, saturn.B, op2 );
break; break;
case 9: /* ?B>=C */ case 9: /* ?B>=C */
saturn.CARRY = is_greater_or_equal_register( saturn.CARRY = is_greater_or_equal_register( saturn.B, saturn.C, op2 );
saturn.B, saturn.C, op2 );
break; break;
case 0xa: /* ?C>=A */ case 0xa: /* ?C>=A */
saturn.CARRY = is_greater_or_equal_register( saturn.CARRY = is_greater_or_equal_register( saturn.C, saturn.A, op2 );
saturn.C, saturn.A, op2 );
break; break;
case 0xb: /* ?D>=C */ case 0xb: /* ?D>=C */
saturn.CARRY = is_greater_or_equal_register( saturn.CARRY = is_greater_or_equal_register( saturn.D, saturn.C, op2 );
saturn.D, saturn.C, op2 );
break; break;
case 0xc: /* ?A<=B */ case 0xc: /* ?A<=B */
saturn.CARRY = is_less_or_equal_register( saturn.CARRY = is_less_or_equal_register( saturn.A, saturn.B, op2 );
saturn.A, saturn.B, op2 );
break; break;
case 0xd: /* ?B<=C */ case 0xd: /* ?B<=C */
saturn.CARRY = is_less_or_equal_register( saturn.CARRY = is_less_or_equal_register( saturn.B, saturn.C, op2 );
saturn.B, saturn.C, op2 );
break; break;
case 0xe: /* ?C<=A */ case 0xe: /* ?C<=A */
saturn.CARRY = is_less_or_equal_register( saturn.CARRY = is_less_or_equal_register( saturn.C, saturn.A, op2 );
saturn.C, saturn.A, op2 );
break; break;
case 0xf: /* ?D<=C */ case 0xf: /* ?D<=C */
saturn.CARRY = is_less_or_equal_register( saturn.CARRY = is_less_or_equal_register( saturn.D, saturn.C, op2 );
saturn.D, saturn.C, op2 );
break; break;
default: default:
return 1; return 1;
@ -2002,7 +1909,8 @@ static inline int decode_8_thru_f( int op1 ) {
} }
} }
inline int step_instruction( void ) { inline int step_instruction( void )
{
int op0, op1, op2, op3; int op0, op1, op2, op3;
int stop = 0; int stop = 0;
@ -2246,7 +2154,8 @@ inline int step_instruction( void ) {
return stop; return stop;
} }
inline void schedule( void ) { inline void schedule( void )
{
t1_t2_ticks ticks; t1_t2_ticks ticks;
unsigned long steps; unsigned long steps;
static unsigned long old_stat_instr; static unsigned long old_stat_instr;
@ -2413,13 +2322,9 @@ inline void schedule( void ) {
delta_i = instructions - old_stat_instr; delta_i = instructions - old_stat_instr;
old_stat_instr = instructions; old_stat_instr = instructions;
if ( delta_t_1 > 0 ) { if ( delta_t_1 > 0 ) {
t1_i_per_tick = ( ( NR_SAMPLES - 1 ) * t1_i_per_tick + t1_i_per_tick = ( ( NR_SAMPLES - 1 ) * t1_i_per_tick + ( delta_i / delta_t_16 ) ) / NR_SAMPLES;
( delta_i / delta_t_16 ) ) /
NR_SAMPLES;
t2_i_per_tick = t1_i_per_tick / 512; t2_i_per_tick = t1_i_per_tick / 512;
saturn.i_per_s = ( ( NR_SAMPLES - 1 ) * saturn.i_per_s + saturn.i_per_s = ( ( NR_SAMPLES - 1 ) * saturn.i_per_s + ( delta_i / delta_t_1 ) ) / NR_SAMPLES;
( delta_i / delta_t_1 ) ) /
NR_SAMPLES;
} else { } else {
t1_i_per_tick = 8192; t1_i_per_tick = 8192;
t2_i_per_tick = 16; t2_i_per_tick = 16;
@ -2452,7 +2357,8 @@ inline void schedule( void ) {
} }
} }
void emulate( void ) { void emulate( void )
{
struct timeval tv; struct timeval tv;
struct timeval tv2; struct timeval tv2;
struct timezone tz; struct timezone tz;
@ -2474,14 +2380,11 @@ void emulate( void ) {
do { do {
step_instruction(); step_instruction();
for ( int i = 0; i < ( int )( sizeof( saturn.keybuf.rows ) / for ( int i = 0; i < ( int )( sizeof( saturn.keybuf.rows ) / sizeof( saturn.keybuf.rows[ 0 ] ) ); i++ ) {
sizeof( saturn.keybuf.rows[ 0 ] ) );
i++ ) {
if ( saturn.keybuf.rows[ i ] || throttle ) { if ( saturn.keybuf.rows[ i ] || throttle ) {
/* Throttling speed if needed */ /* Throttling speed if needed */
gettimeofday( &tv, &tz ); gettimeofday( &tv, &tz );
while ( ( tv.tv_sec == tv2.tv_sec ) && while ( ( tv.tv_sec == tv2.tv_sec ) && ( ( tv.tv_usec - tv2.tv_usec ) < 2 ) )
( ( tv.tv_usec - tv2.tv_usec ) < 2 ) )
gettimeofday( &tv, &tz ); gettimeofday( &tv, &tz );
tv2.tv_usec = tv.tv_usec; tv2.tv_usec = tv.tv_usec;

105
src/emu_init.c
View file

@ -1,15 +1,15 @@
#include <errno.h> #include <errno.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <unistd.h>
#include <sys/stat.h>
#include <string.h> #include <string.h>
#include <sys/stat.h>
#include <sys/types.h> #include <sys/types.h>
#include <unistd.h>
#include "runtime_options.h"
#include "emulator.h" #include "emulator.h"
#include "emulator_inner.h" #include "emulator_inner.h"
#include "romio.h" #include "romio.h"
#include "runtime_options.h"
#define X48_MAGIC 0x48503438 #define X48_MAGIC 0x48503438
#define NR_CONFIG 8 #define NR_CONFIG 8
@ -26,7 +26,8 @@ long port2_size;
long port2_mask; long port2_mask;
short port2_is_ram; short port2_is_ram;
int read_rom( const char* fname ) { int read_rom( const char* fname )
{
int ram_size; int ram_size;
if ( !read_rom_file( fname, &saturn.rom, &rom_size ) ) if ( !read_rom_file( fname, &saturn.rom, &rom_size ) )
@ -62,7 +63,8 @@ int read_rom( const char* fname ) {
return 1; return 1;
} }
void saturn_config_init( void ) { void saturn_config_init( void )
{
saturn.version[ 0 ] = VERSION_MAJOR; saturn.version[ 0 ] = VERSION_MAJOR;
saturn.version[ 1 ] = VERSION_MINOR; saturn.version[ 1 ] = VERSION_MINOR;
saturn.version[ 2 ] = PATCHLEVEL; saturn.version[ 2 ] = PATCHLEVEL;
@ -76,7 +78,8 @@ void saturn_config_init( void ) {
saturn.lbr = 0x0; saturn.lbr = 0x0;
} }
void init_saturn( void ) { void init_saturn( void )
{
memset( &saturn, 0, sizeof( saturn ) - 4 * sizeof( unsigned char* ) ); memset( &saturn, 0, sizeof( saturn ) - 4 * sizeof( unsigned char* ) );
saturn.PC = 0x00000; saturn.PC = 0x00000;
saturn.magic = X48_MAGIC; saturn.magic = X48_MAGIC;
@ -107,7 +110,8 @@ void init_saturn( void ) {
dev_memory_init(); dev_memory_init();
} }
int init_emulator( void ) { int init_emulator( void )
{
/* If not forced to initialize and files are readble => let's go */ /* If not forced to initialize and files are readble => let's go */
if ( !initialize && read_files() ) { if ( !initialize && read_files() ) {
if ( resetOnStartup ) if ( resetOnStartup )
@ -126,7 +130,8 @@ int init_emulator( void ) {
return 0; return 0;
} }
int exit_emulator( void ) { int exit_emulator( void )
{
write_files(); write_files();
return 1; return 1;
@ -136,7 +141,8 @@ int exit_emulator( void ) {
/* READING ~/.x48ng/{rom,ram,hp48,port1,port2} */ /* READING ~/.x48ng/{rom,ram,hp48,port1,port2} */
/***********************************************/ /***********************************************/
int read_8( FILE* fp, word_8* var ) { int read_8( FILE* fp, word_8* var )
{
unsigned char tmp; unsigned char tmp;
if ( fread( &tmp, 1, 1, fp ) != 1 ) { if ( fread( &tmp, 1, 1, fp ) != 1 ) {
@ -148,7 +154,8 @@ int read_8( FILE* fp, word_8* var ) {
return 1; return 1;
} }
int read_char( FILE* fp, char* var ) { int read_char( FILE* fp, char* var )
{
char tmp; char tmp;
if ( fread( &tmp, 1, 1, fp ) != 1 ) { if ( fread( &tmp, 1, 1, fp ) != 1 ) {
@ -160,7 +167,8 @@ int read_char( FILE* fp, char* var ) {
return 1; return 1;
} }
int read_16( FILE* fp, word_16* var ) { int read_16( FILE* fp, word_16* var )
{
unsigned char tmp[ 2 ]; unsigned char tmp[ 2 ];
if ( fread( &tmp[ 0 ], 1, 2, fp ) != 2 ) { if ( fread( &tmp[ 0 ], 1, 2, fp ) != 2 ) {
@ -173,7 +181,8 @@ int read_16( FILE* fp, word_16* var ) {
return 1; return 1;
} }
int read_32( FILE* fp, word_32* var ) { int read_32( FILE* fp, word_32* var )
{
unsigned char tmp[ 4 ]; unsigned char tmp[ 4 ];
if ( fread( &tmp[ 0 ], 1, 4, fp ) != 4 ) { if ( fread( &tmp[ 0 ], 1, 4, fp ) != 4 ) {
@ -188,7 +197,8 @@ int read_32( FILE* fp, word_32* var ) {
return 1; return 1;
} }
int read_u_long( FILE* fp, unsigned long* var ) { int read_u_long( FILE* fp, unsigned long* var )
{
unsigned char tmp[ 4 ]; unsigned char tmp[ 4 ];
if ( fread( &tmp[ 0 ], 1, 4, fp ) != 4 ) { if ( fread( &tmp[ 0 ], 1, 4, fp ) != 4 ) {
@ -203,7 +213,8 @@ int read_u_long( FILE* fp, unsigned long* var ) {
return 1; return 1;
} }
int read_state_file( FILE* fp ) { int read_state_file( FILE* fp )
{
int i; int i;
/* /*
@ -368,7 +379,8 @@ int read_state_file( FILE* fp ) {
return 1; return 1;
} }
int read_mem_file( char* name, word_4* mem, int size ) { int read_mem_file( char* name, word_4* mem, int size )
{
struct stat st; struct stat st;
FILE* fp; FILE* fp;
word_8* tmp_mem; word_8* tmp_mem;
@ -404,8 +416,7 @@ int read_mem_file( char* name, word_4* mem, int size ) {
if ( st.st_size != size / 2 ) { if ( st.st_size != size / 2 ) {
if ( verbose ) if ( verbose )
fprintf( stderr, "strange size %s, expected %d, found %ld\n", fprintf( stderr, "strange size %s, expected %d, found %ld\n", name, size / 2, st.st_size );
name, size / 2, st.st_size );
fclose( fp ); fclose( fp );
return 0; return 0;
} }
@ -422,8 +433,7 @@ int read_mem_file( char* name, word_4* mem, int size ) {
mem[ j++ ] = ( word_4 )( ( ( int )byte >> 4 ) & 0xf ); mem[ j++ ] = ( word_4 )( ( ( int )byte >> 4 ) & 0xf );
} }
} else { } else {
if ( fread( tmp_mem, 1, ( size_t )size / 2, fp ) != if ( fread( tmp_mem, 1, ( size_t )size / 2, fp ) != ( unsigned long )( size / 2 ) ) {
( unsigned long )( size / 2 ) ) {
if ( verbose ) if ( verbose )
fprintf( stderr, "can\'t read %s\n", name ); fprintf( stderr, "can\'t read %s\n", name );
fclose( fp ); fclose( fp );
@ -448,7 +458,8 @@ int read_mem_file( char* name, word_4* mem, int size ) {
return 1; return 1;
} }
int read_files( void ) { int read_files( void )
{
unsigned long v1, v2; unsigned long v1, v2;
int i, read_version; int i, read_version;
int ram_size; int ram_size;
@ -515,8 +526,7 @@ int read_files( void ) {
*/ */
if ( !read_state_file( fp ) ) { if ( !read_state_file( fp ) ) {
if ( verbose ) if ( verbose )
fprintf( stderr, "can\'t handle %s\n", fprintf( stderr, "can\'t handle %s\n", normalized_state_path );
normalized_state_path );
init_saturn(); init_saturn();
} else if ( verbose ) } else if ( verbose )
printf( "read %s\n", normalized_state_path ); printf( "read %s\n", normalized_state_path );
@ -567,8 +577,7 @@ int read_files( void ) {
if ( NULL == ( saturn.port1 = ( word_4* )malloc( port1_size ) ) ) { if ( NULL == ( saturn.port1 = ( word_4* )malloc( port1_size ) ) ) {
if ( verbose ) if ( verbose )
fprintf( stderr, "can\'t malloc PORT1[%ld]\n", port1_size ); fprintf( stderr, "can\'t malloc PORT1[%ld]\n", port1_size );
} else if ( !read_mem_file( normalized_port1_path, saturn.port1, } else if ( !read_mem_file( normalized_port1_path, saturn.port1, port1_size ) ) {
port1_size ) ) {
port1_size = 0; port1_size = 0;
port1_is_ram = 0; port1_is_ram = 0;
} else { } else {
@ -597,13 +606,11 @@ int read_files( void ) {
if ( stat( normalized_port2_path, &st ) >= 0 ) { if ( stat( normalized_port2_path, &st ) >= 0 ) {
port2_size = 2 * st.st_size; port2_size = 2 * st.st_size;
if ( ( opt_gx && ( ( port2_size % 0x40000 ) == 0 ) ) || if ( ( opt_gx && ( ( port2_size % 0x40000 ) == 0 ) ) ||
( !opt_gx && ( !opt_gx && ( ( port2_size == 0x10000 ) || ( port2_size == 0x40000 ) ) ) ) {
( ( port2_size == 0x10000 ) || ( port2_size == 0x40000 ) ) ) ) {
if ( NULL == ( saturn.port2 = ( word_4* )malloc( port2_size ) ) ) { if ( NULL == ( saturn.port2 = ( word_4* )malloc( port2_size ) ) ) {
if ( verbose ) if ( verbose )
fprintf( stderr, "can\'t malloc PORT2[%ld]\n", port2_size ); fprintf( stderr, "can\'t malloc PORT2[%ld]\n", port2_size );
} else if ( !read_mem_file( normalized_port2_path, saturn.port2, } else if ( !read_mem_file( normalized_port2_path, saturn.port2, port2_size ) ) {
port2_size ) ) {
port2_size = 0; port2_size = 0;
port2_is_ram = 0; port2_is_ram = 0;
} else { } else {
@ -631,7 +638,8 @@ int read_files( void ) {
/* WRITING ~/.x48ng/{rom,ram,hp48,port1,port2} */ /* WRITING ~/.x48ng/{rom,ram,hp48,port1,port2} */
/***********************************************/ /***********************************************/
int write_8( FILE* fp, word_8* var ) { int write_8( FILE* fp, word_8* var )
{
unsigned char tmp; unsigned char tmp;
tmp = *var; tmp = *var;
@ -643,7 +651,8 @@ int write_8( FILE* fp, word_8* var ) {
return 1; return 1;
} }
int write_char( FILE* fp, char* var ) { int write_char( FILE* fp, char* var )
{
char tmp; char tmp;
tmp = *var; tmp = *var;
@ -655,7 +664,8 @@ int write_char( FILE* fp, char* var ) {
return 1; return 1;
} }
int write_16( FILE* fp, word_16* var ) { int write_16( FILE* fp, word_16* var )
{
unsigned char tmp[ 2 ]; unsigned char tmp[ 2 ];
tmp[ 0 ] = ( *var >> 8 ) & 0xff; tmp[ 0 ] = ( *var >> 8 ) & 0xff;
@ -668,7 +678,8 @@ int write_16( FILE* fp, word_16* var ) {
return 1; return 1;
} }
int write_32( FILE* fp, word_32* var ) { int write_32( FILE* fp, word_32* var )
{
unsigned char tmp[ 4 ]; unsigned char tmp[ 4 ];
tmp[ 0 ] = ( *var >> 24 ) & 0xff; tmp[ 0 ] = ( *var >> 24 ) & 0xff;
@ -683,7 +694,8 @@ int write_32( FILE* fp, word_32* var ) {
return 1; return 1;
} }
int write_u_long( FILE* fp, unsigned long* var ) { int write_u_long( FILE* fp, unsigned long* var )
{
unsigned char tmp[ 4 ]; unsigned char tmp[ 4 ];
tmp[ 0 ] = ( *var >> 24 ) & 0xff; tmp[ 0 ] = ( *var >> 24 ) & 0xff;
@ -698,7 +710,8 @@ int write_u_long( FILE* fp, unsigned long* var ) {
return 1; return 1;
} }
int write_mem_file( char* name, word_4* mem, int size ) { int write_mem_file( char* name, word_4* mem, int size )
{
FILE* fp; FILE* fp;
word_8* tmp_mem; word_8* tmp_mem;
word_8 byte; word_8 byte;
@ -727,8 +740,7 @@ int write_mem_file( char* name, word_4* mem, int size ) {
tmp_mem[ i ] |= ( mem[ j++ ] << 4 ) & 0xf0; tmp_mem[ i ] |= ( mem[ j++ ] << 4 ) & 0xf0;
} }
if ( fwrite( tmp_mem, 1, ( size_t )size / 2, fp ) != if ( fwrite( tmp_mem, 1, ( size_t )size / 2, fp ) != ( unsigned long )size / 2 ) {
( unsigned long )size / 2 ) {
if ( verbose ) if ( verbose )
fprintf( stderr, "can\'t write %s\n", name ); fprintf( stderr, "can\'t write %s\n", name );
fclose( fp ); fclose( fp );
@ -747,7 +759,8 @@ int write_mem_file( char* name, word_4* mem, int size ) {
return 1; return 1;
} }
int write_state_file( char* filename ) { int write_state_file( char* filename )
{
int i; int i;
FILE* fp; FILE* fp;
@ -856,7 +869,8 @@ int write_state_file( char* filename ) {
return 1; return 1;
} }
int write_files( void ) { int write_files( void )
{
struct stat st; struct stat st;
int make_dir = 0; int make_dir = 0;
int ram_size = opt_gx ? RAM_SIZE_GX : RAM_SIZE_SX; int ram_size = opt_gx ? RAM_SIZE_GX : RAM_SIZE_SX;
@ -866,15 +880,13 @@ int write_files( void ) {
make_dir = 1; make_dir = 1;
} else { } else {
if ( verbose ) if ( verbose )
fprintf( stderr, "can\'t stat %s, saving to /tmp\n", fprintf( stderr, "can\'t stat %s, saving to /tmp\n", normalized_config_path );
normalized_config_path );
strcpy( normalized_config_path, "/tmp" ); strcpy( normalized_config_path, "/tmp" );
} }
} else { } else {
if ( !S_ISDIR( st.st_mode ) ) { if ( !S_ISDIR( st.st_mode ) ) {
if ( verbose ) if ( verbose )
fprintf( stderr, "%s is no directory, saving to /tmp\n", fprintf( stderr, "%s is no directory, saving to /tmp\n", normalized_config_path );
normalized_config_path );
strcpy( normalized_config_path, "/tmp" ); strcpy( normalized_config_path, "/tmp" );
} }
} }
@ -882,8 +894,7 @@ int write_files( void ) {
if ( make_dir ) { if ( make_dir ) {
if ( mkdir( normalized_config_path, 0777 ) == -1 ) { if ( mkdir( normalized_config_path, 0777 ) == -1 ) {
if ( verbose ) if ( verbose )
fprintf( stderr, "can\'t mkdir %s, saving to /tmp\n", fprintf( stderr, "can\'t mkdir %s, saving to /tmp\n", normalized_config_path );
normalized_config_path );
strcpy( normalized_config_path, "/tmp" ); strcpy( normalized_config_path, "/tmp" );
} }
} }
@ -909,14 +920,12 @@ int write_files( void ) {
return 0; return 0;
if ( ( port1_size > 0 ) && port1_is_ram ) { if ( ( port1_size > 0 ) && port1_is_ram ) {
if ( !write_mem_file( normalized_port1_path, saturn.port1, if ( !write_mem_file( normalized_port1_path, saturn.port1, port1_size ) )
port1_size ) )
return 0; return 0;
} }
if ( ( port2_size > 0 ) && port2_is_ram ) { if ( ( port2_size > 0 ) && port2_is_ram ) {
if ( !write_mem_file( normalized_port2_path, saturn.port2, if ( !write_mem_file( normalized_port2_path, saturn.port2, port2_size ) )
port2_size ) )
return 0; return 0;
} }

255
src/emu_memory.c
View file

@ -7,8 +7,8 @@
#include "emulator.h" #include "emulator.h"
#include "emulator_inner.h" #include "emulator_inner.h"
#include "romio.h" #include "romio.h"
#include "ui.h" /* ui_disp_draw_nibble(); ui_menu_draw_nibble(); */
#include "runtime_options.h" #include "runtime_options.h"
#include "ui.h" /* ui_disp_draw_nibble(); ui_menu_draw_nibble(); */
#define MCTL_MMIO_SX 0 #define MCTL_MMIO_SX 0
#define MCTL_SysRAM_SX 1 #define MCTL_SysRAM_SX 1
@ -26,10 +26,8 @@
#define DISP_INSTR_OFF 0x10 #define DISP_INSTR_OFF 0x10
long nibble_masks[ 16 ] = { 0x0000000f, 0x000000f0, 0x00000f00, 0x0000f000, long nibble_masks[ 16 ] = { 0x0000000f, 0x000000f0, 0x00000f00, 0x0000f000, 0x000f0000, 0x00f00000, 0x0f000000, 0xf0000000,
0x000f0000, 0x00f00000, 0x0f000000, 0xf0000000, 0x0000000f, 0x000000f0, 0x00000f00, 0x0000f000, 0x000f0000, 0x00f00000, 0x0f000000, 0xf0000000 };
0x0000000f, 0x000000f0, 0x00000f00, 0x0000f000,
0x000f0000, 0x00f00000, 0x0f000000, 0xf0000000 };
display_t display; display_t display;
@ -39,13 +37,14 @@ int ( *read_nibble_crc )( long addr );
static int line_counter = -1; static int line_counter = -1;
static inline int calc_crc( int nib ) { static inline int calc_crc( int nib )
saturn.crc = {
( saturn.crc >> 4 ) ^ ( ( ( saturn.crc ^ nib ) & 0xf ) * 0x1081 ); saturn.crc = ( saturn.crc >> 4 ) ^ ( ( ( saturn.crc ^ nib ) & 0xf ) * 0x1081 );
return nib; return nib;
} }
void write_dev_mem( long addr, int val ) { void write_dev_mem( long addr, int val )
{
static int old_line_offset = -1; static int old_line_offset = -1;
device_check = 1; device_check = 1;
@ -57,14 +56,10 @@ void write_dev_mem( long addr, int val ) {
display.on = ( val & 0x8 ) >> 3; display.on = ( val & 0x8 ) >> 3;
display.offset = val & 0x7; display.offset = val & 0x7;
if ( display.offset > 3 ) if ( display.offset > 3 )
display.nibs_per_line = display.nibs_per_line = ( NIBBLES_PER_ROW + saturn.line_offset + 2 ) & 0xfff;
( NIBBLES_PER_ROW + saturn.line_offset + 2 ) & 0xfff;
else else
display.nibs_per_line = display.nibs_per_line = ( NIBBLES_PER_ROW + saturn.line_offset ) & 0xfff;
( NIBBLES_PER_ROW + saturn.line_offset ) & 0xfff; display.disp_end = display.disp_start + ( display.nibs_per_line * ( display.lines + 1 ) );
display.disp_end =
display.disp_start +
( display.nibs_per_line * ( display.lines + 1 ) );
device.display_touched = DISP_INSTR_OFF; device.display_touched = DISP_INSTR_OFF;
} }
return; return;
@ -186,9 +181,7 @@ void write_dev_mem( long addr, int val ) {
saturn.disp_addr |= val << ( ( addr - 0x120 ) * 4 ); saturn.disp_addr |= val << ( ( addr - 0x120 ) * 4 );
if ( display.disp_start != ( saturn.disp_addr & 0xffffe ) ) { if ( display.disp_start != ( saturn.disp_addr & 0xffffe ) ) {
display.disp_start = saturn.disp_addr & 0xffffe; display.disp_start = saturn.disp_addr & 0xffffe;
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 ) );
device.display_touched = DISP_INSTR_OFF; device.display_touched = DISP_INSTR_OFF;
} }
return; return;
@ -200,14 +193,10 @@ void write_dev_mem( long addr, int val ) {
if ( saturn.line_offset != old_line_offset ) { if ( saturn.line_offset != old_line_offset ) {
old_line_offset = saturn.line_offset; old_line_offset = saturn.line_offset;
if ( display.offset > 3 ) if ( display.offset > 3 )
display.nibs_per_line = display.nibs_per_line = ( NIBBLES_PER_ROW + saturn.line_offset + 2 ) & 0xfff;
( NIBBLES_PER_ROW + saturn.line_offset + 2 ) & 0xfff;
else else
display.nibs_per_line = display.nibs_per_line = ( NIBBLES_PER_ROW + saturn.line_offset ) & 0xfff;
( NIBBLES_PER_ROW + saturn.line_offset ) & 0xfff; display.disp_end = display.disp_start + ( display.nibs_per_line * ( display.lines + 1 ) );
display.disp_end =
display.disp_start +
( display.nibs_per_line * ( display.lines + 1 ) );
device.display_touched = DISP_INSTR_OFF; device.display_touched = DISP_INSTR_OFF;
} }
return; return;
@ -220,9 +209,7 @@ void write_dev_mem( long addr, int val ) {
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;
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 ) );
device.display_touched = DISP_INSTR_OFF; device.display_touched = DISP_INSTR_OFF;
} }
return; return;
@ -279,13 +266,13 @@ void write_dev_mem( long addr, int val ) {
return; return;
default: default:
if ( verbose ) if ( verbose )
fprintf( stderr, "%.5lx: UNKNOWN DEVICE WRITE AT 0x%lx !!!\n", fprintf( stderr, "%.5lx: UNKNOWN DEVICE WRITE AT 0x%lx !!!\n", saturn.PC, addr );
saturn.PC, addr );
return; return;
} }
} }
int read_dev_mem( long addr ) { int read_dev_mem( long addr )
{
switch ( ( int )addr ) { switch ( ( int )addr ) {
case 0x100: /* DISPLAY IO */ case 0x100: /* DISPLAY IO */
return saturn.disp_io & 0x0f; return saturn.disp_io & 0x0f;
@ -362,10 +349,7 @@ int read_dev_mem( long addr ) {
line_counter++; line_counter++;
if ( line_counter > 0x3f ) if ( line_counter > 0x3f )
line_counter = -1; line_counter = -1;
return ( ( ( saturn.line_count & 0xc0 ) | return ( ( ( saturn.line_count & 0xc0 ) | ( line_counter & 0x3f ) ) >> ( ( addr - 0x128 ) * 4 ) ) & 0x0f;
( line_counter & 0x3f ) ) >>
( ( addr - 0x128 ) * 4 ) ) &
0x0f;
case 0x12a: case 0x12a:
case 0x12b: case 0x12b:
case 0x12c: case 0x12c:
@ -397,19 +381,18 @@ int read_dev_mem( long addr ) {
return ( saturn.timer2 >> ( ( addr - 0x138 ) * 4 ) ) & 0xf; return ( saturn.timer2 >> ( ( addr - 0x138 ) * 4 ) ) & 0xf;
default: default:
if ( verbose ) if ( verbose )
fprintf( stderr, "%.5lx: UNKNOWN DEVICE READ AT 0x%lx !!!\n", fprintf( stderr, "%.5lx: UNKNOWN DEVICE READ AT 0x%lx !!!\n", saturn.PC, addr );
saturn.PC, addr );
return 0x00; return 0x00;
} }
} }
void write_nibble_sx( long addr, int val ) { void write_nibble_sx( long addr, int val )
{
addr &= 0xfffff; addr &= 0xfffff;
val &= 0x0f; val &= 0x0f;
switch ( ( int )( addr >> 16 ) & 0x0f ) { switch ( ( int )( addr >> 16 ) & 0x0f ) {
case 0: case 0:
if ( addr < 0x140 && addr >= 0x100 && if ( addr < 0x140 && addr >= 0x100 && saturn.mem_cntl[ MCTL_MMIO_SX ].config[ 0 ] == 0x100 ) {
saturn.mem_cntl[ MCTL_MMIO_SX ].config[ 0 ] == 0x100 ) {
write_dev_mem( addr, val ); write_dev_mem( addr, val );
return; return;
} }
@ -423,18 +406,15 @@ void write_nibble_sx( long addr, int val ) {
return; return;
case 7: case 7:
if ( saturn.mem_cntl[ MCTL_SysRAM_SX ].config[ 0 ] == 0x70000 ) { if ( saturn.mem_cntl[ MCTL_SysRAM_SX ].config[ 0 ] == 0x70000 ) {
if ( saturn.mem_cntl[ MCTL_SysRAM_SX ].config[ 1 ] == 0xfc000 && if ( saturn.mem_cntl[ MCTL_SysRAM_SX ].config[ 1 ] == 0xfc000 && addr < 0x74000 ) {
addr < 0x74000 ) {
saturn.ram[ addr - 0x70000 ] = val; saturn.ram[ addr - 0x70000 ] = val;
break; break;
} }
if ( saturn.mem_cntl[ MCTL_SysRAM_SX ].config[ 1 ] == 0xfe000 && if ( saturn.mem_cntl[ MCTL_SysRAM_SX ].config[ 1 ] == 0xfe000 && addr < 0x72000 ) {
addr < 0x72000 ) {
saturn.ram[ addr - 0x70000 ] = val; saturn.ram[ addr - 0x70000 ] = val;
break; break;
} }
if ( saturn.mem_cntl[ MCTL_SysRAM_SX ].config[ 1 ] == if ( saturn.mem_cntl[ MCTL_SysRAM_SX ].config[ 1 ] == 0xf0000 ) {
0xf0000 ) {
saturn.ram[ addr - 0x70000 ] = val; saturn.ram[ addr - 0x70000 ] = val;
break; break;
} }
@ -500,13 +480,13 @@ void write_nibble_sx( long addr, int val ) {
ui_menu_draw_nibble( addr, val ); ui_menu_draw_nibble( addr, val );
} }
void write_nibble_gx( long addr, int val ) { void write_nibble_gx( long addr, int val )
{
addr &= 0xfffff; addr &= 0xfffff;
val &= 0x0f; val &= 0x0f;
switch ( ( int )( addr >> 16 ) & 0x0f ) { switch ( ( int )( addr >> 16 ) & 0x0f ) {
case 0: case 0:
if ( addr < 0x140 && addr >= 0x100 && if ( addr < 0x140 && addr >= 0x100 && saturn.mem_cntl[ MCTL_MMIO_GX ].config[ 0 ] == 0x100 ) {
saturn.mem_cntl[ MCTL_MMIO_GX ].config[ 0 ] == 0x100 ) {
write_dev_mem( addr, val ); write_dev_mem( addr, val );
return; return;
} }
@ -524,38 +504,31 @@ void write_nibble_gx( long addr, int val ) {
} }
return; return;
case 7: case 7:
if ( addr >= 0x7f000 && if ( addr >= 0x7f000 && saturn.mem_cntl[ MCTL_BANK_GX ].config[ 0 ] == 0x7f000 ) {
saturn.mem_cntl[ MCTL_BANK_GX ].config[ 0 ] == 0x7f000 ) {
return; return;
} }
if ( addr >= 0x7e000 && addr < 0x7f000 && if ( addr >= 0x7e000 && addr < 0x7f000 && saturn.mem_cntl[ MCTL_PORT1_GX ].config[ 0 ] == 0x7e000 ) {
saturn.mem_cntl[ MCTL_PORT1_GX ].config[ 0 ] == 0x7e000 ) {
return; return;
} }
if ( addr >= 0x7e000 && addr < 0x7f000 && if ( addr >= 0x7e000 && addr < 0x7f000 && saturn.mem_cntl[ MCTL_PORT2_GX ].config[ 0 ] == 0x7e000 ) {
saturn.mem_cntl[ MCTL_PORT2_GX ].config[ 0 ] == 0x7e000 ) {
return; return;
} }
return; return;
case 8: case 8:
if ( saturn.mem_cntl[ MCTL_SysRAM_GX ].config[ 0 ] == 0x80000 ) { if ( saturn.mem_cntl[ MCTL_SysRAM_GX ].config[ 0 ] == 0x80000 ) {
if ( saturn.mem_cntl[ MCTL_SysRAM_GX ].config[ 1 ] == 0xfc000 && if ( saturn.mem_cntl[ MCTL_SysRAM_GX ].config[ 1 ] == 0xfc000 && addr < 0x84000 ) {
addr < 0x84000 ) {
saturn.ram[ addr - 0x80000 ] = val; saturn.ram[ addr - 0x80000 ] = val;
break; break;
} }
if ( saturn.mem_cntl[ MCTL_SysRAM_GX ].config[ 1 ] == 0xfe000 && if ( saturn.mem_cntl[ MCTL_SysRAM_GX ].config[ 1 ] == 0xfe000 && addr < 0x82000 ) {
addr < 0x82000 ) {
saturn.ram[ addr - 0x80000 ] = val; saturn.ram[ addr - 0x80000 ] = val;
break; break;
} }
if ( saturn.mem_cntl[ MCTL_SysRAM_GX ].config[ 1 ] == if ( saturn.mem_cntl[ MCTL_SysRAM_GX ].config[ 1 ] == 0xf0000 ) {
0xf0000 ) {
saturn.ram[ addr - 0x80000 ] = val; saturn.ram[ addr - 0x80000 ] = val;
break; break;
} }
if ( saturn.mem_cntl[ MCTL_SysRAM_GX ].config[ 1 ] == if ( saturn.mem_cntl[ MCTL_SysRAM_GX ].config[ 1 ] == 0xc0000 ) {
0xc0000 ) {
saturn.ram[ addr - 0x80000 ] = val; saturn.ram[ addr - 0x80000 ] = val;
break; break;
} }
@ -568,16 +541,14 @@ void write_nibble_gx( long addr, int val ) {
} }
} }
if ( saturn.mem_cntl[ MCTL_SysRAM_GX ].config[ 0 ] == 0x80000 ) if ( saturn.mem_cntl[ MCTL_SysRAM_GX ].config[ 0 ] == 0x80000 )
if ( saturn.mem_cntl[ MCTL_SysRAM_GX ].config[ 1 ] == if ( saturn.mem_cntl[ MCTL_SysRAM_GX ].config[ 1 ] == 0xc0000 ) {
0xc0000 ) {
saturn.ram[ addr - 0x80000 ] = val; saturn.ram[ addr - 0x80000 ] = val;
break; break;
} }
return; return;
case 0xa: case 0xa:
if ( saturn.mem_cntl[ MCTL_SysRAM_GX ].config[ 0 ] == 0x80000 ) if ( saturn.mem_cntl[ MCTL_SysRAM_GX ].config[ 0 ] == 0x80000 )
if ( saturn.mem_cntl[ MCTL_SysRAM_GX ].config[ 1 ] == if ( saturn.mem_cntl[ MCTL_SysRAM_GX ].config[ 1 ] == 0xc0000 ) {
0xc0000 ) {
saturn.ram[ addr - 0x80000 ] = val; saturn.ram[ addr - 0x80000 ] = val;
break; break;
} }
@ -589,28 +560,23 @@ void write_nibble_gx( long addr, int val ) {
return; return;
case 0xb: case 0xb:
if ( saturn.mem_cntl[ MCTL_SysRAM_GX ].config[ 0 ] == 0x80000 ) if ( saturn.mem_cntl[ MCTL_SysRAM_GX ].config[ 0 ] == 0x80000 )
if ( saturn.mem_cntl[ MCTL_SysRAM_GX ].config[ 1 ] == if ( saturn.mem_cntl[ MCTL_SysRAM_GX ].config[ 1 ] == 0xc0000 ) {
0xc0000 ) {
saturn.ram[ addr - 0x80000 ] = val; saturn.ram[ addr - 0x80000 ] = val;
break; break;
} }
if ( saturn.mem_cntl[ MCTL_PORT2_GX ].config[ 0 ] == 0xb0000 ) { if ( saturn.mem_cntl[ MCTL_PORT2_GX ].config[ 0 ] == 0xb0000 ) {
if ( port2_is_ram ) if ( port2_is_ram )
saturn.port2[ ( ( saturn.bank_switch << 18 ) + saturn.port2[ ( ( saturn.bank_switch << 18 ) + ( addr - 0xb0000 ) ) & port2_mask ] = val;
( addr - 0xb0000 ) ) &
port2_mask ] = val;
return; return;
} }
return; return;
case 0xc: case 0xc:
if ( saturn.mem_cntl[ MCTL_SysRAM_GX ].config[ 0 ] == 0xc0000 ) { if ( saturn.mem_cntl[ MCTL_SysRAM_GX ].config[ 0 ] == 0xc0000 ) {
if ( saturn.mem_cntl[ MCTL_SysRAM_GX ].config[ 1 ] == 0xfc000 && if ( saturn.mem_cntl[ MCTL_SysRAM_GX ].config[ 1 ] == 0xfc000 && addr < 0xc4000 ) {
addr < 0xc4000 ) {
saturn.ram[ addr - 0xc0000 ] = val; saturn.ram[ addr - 0xc0000 ] = val;
break; break;
} }
if ( saturn.mem_cntl[ MCTL_SysRAM_GX ].config[ 1 ] == 0xfe000 && if ( saturn.mem_cntl[ MCTL_SysRAM_GX ].config[ 1 ] == 0xfe000 && addr < 0xc2000 ) {
addr < 0xc2000 ) {
saturn.ram[ addr - 0xc0000 ] = val; saturn.ram[ addr - 0xc0000 ] = val;
break; break;
} }
@ -624,9 +590,7 @@ void write_nibble_gx( long addr, int val ) {
} }
if ( saturn.mem_cntl[ MCTL_PORT2_GX ].config[ 0 ] == 0xc0000 ) { if ( saturn.mem_cntl[ MCTL_PORT2_GX ].config[ 0 ] == 0xc0000 ) {
if ( port2_is_ram ) if ( port2_is_ram )
saturn.port2[ ( ( saturn.bank_switch << 18 ) + saturn.port2[ ( ( saturn.bank_switch << 18 ) + ( addr - 0xc0000 ) ) & port2_mask ] = val;
( addr - 0xc0000 ) ) &
port2_mask ] = val;
return; return;
} }
return; return;
@ -634,8 +598,7 @@ void write_nibble_gx( long addr, int val ) {
case 0xe: case 0xe:
case 0xf: case 0xf:
if ( saturn.mem_cntl[ MCTL_SysRAM_GX ].config[ 0 ] == 0xc0000 ) if ( saturn.mem_cntl[ MCTL_SysRAM_GX ].config[ 0 ] == 0xc0000 )
if ( saturn.mem_cntl[ MCTL_SysRAM_GX ].config[ 1 ] == if ( saturn.mem_cntl[ MCTL_SysRAM_GX ].config[ 1 ] == 0xc0000 ) {
0xc0000 ) {
saturn.ram[ addr - 0xc0000 ] = val; saturn.ram[ addr - 0xc0000 ] = val;
break; break;
} }
@ -648,9 +611,7 @@ void write_nibble_gx( long addr, int val ) {
if ( saturn.mem_cntl[ MCTL_PORT2_GX ].config[ 0 ] == 0xc0000 ) if ( saturn.mem_cntl[ MCTL_PORT2_GX ].config[ 0 ] == 0xc0000 )
if ( saturn.mem_cntl[ MCTL_PORT2_GX ].config[ 1 ] == 0xc0000 ) { if ( saturn.mem_cntl[ MCTL_PORT2_GX ].config[ 1 ] == 0xc0000 ) {
if ( port2_is_ram ) if ( port2_is_ram )
saturn.port2[ ( ( saturn.bank_switch << 18 ) + saturn.port2[ ( ( saturn.bank_switch << 18 ) + ( addr - 0xc0000 ) ) & port2_mask ] = val;
( addr - 0xc0000 ) ) &
port2_mask ] = val;
return; return;
} }
return; return;
@ -669,7 +630,8 @@ void write_nibble_gx( long addr, int val ) {
ui_menu_draw_nibble( addr, val ); ui_menu_draw_nibble( addr, val );
} }
int read_nibble_sx( long addr ) { int read_nibble_sx( long addr )
{
addr &= 0xfffff; addr &= 0xfffff;
switch ( ( int )( addr >> 16 ) & 0x0f ) { switch ( ( int )( addr >> 16 ) & 0x0f ) {
case 0: case 0:
@ -689,11 +651,9 @@ int read_nibble_sx( long addr ) {
return saturn.rom[ addr ]; return saturn.rom[ addr ];
case 7: case 7:
if ( saturn.mem_cntl[ MCTL_SysRAM_SX ].config[ 0 ] == 0x70000 ) { if ( saturn.mem_cntl[ MCTL_SysRAM_SX ].config[ 0 ] == 0x70000 ) {
if ( saturn.mem_cntl[ MCTL_SysRAM_SX ].config[ 1 ] == 0xfc000 && if ( saturn.mem_cntl[ MCTL_SysRAM_SX ].config[ 1 ] == 0xfc000 && addr < 0x74000 )
addr < 0x74000 )
return saturn.ram[ addr - 0x70000 ]; return saturn.ram[ addr - 0x70000 ];
if ( saturn.mem_cntl[ MCTL_SysRAM_SX ].config[ 1 ] == 0xfe000 && if ( saturn.mem_cntl[ MCTL_SysRAM_SX ].config[ 1 ] == 0xfe000 && addr < 0x72000 )
addr < 0x72000 )
return saturn.ram[ addr - 0x70000 ]; return saturn.ram[ addr - 0x70000 ];
if ( saturn.mem_cntl[ MCTL_SysRAM_SX ].config[ 1 ] == 0xf0000 ) if ( saturn.mem_cntl[ MCTL_SysRAM_SX ].config[ 1 ] == 0xf0000 )
return saturn.ram[ addr - 0x70000 ]; return saturn.ram[ addr - 0x70000 ];
@ -734,7 +694,8 @@ int read_nibble_sx( long addr ) {
return 0x00; return 0x00;
} }
int read_nibble_gx( long addr ) { int read_nibble_gx( long addr )
{
addr &= 0xfffff; addr &= 0xfffff;
switch ( ( int )( addr >> 16 ) & 0x0f ) { switch ( ( int )( addr >> 16 ) & 0x0f ) {
case 0: case 0:
@ -756,8 +717,7 @@ int read_nibble_gx( long addr ) {
return saturn.ram[ addr - 0x40000 ]; return saturn.ram[ addr - 0x40000 ];
return saturn.rom[ addr ]; return saturn.rom[ addr ];
case 7: case 7:
if ( addr >= 0x7f000 && if ( addr >= 0x7f000 && saturn.mem_cntl[ MCTL_BANK_GX ].config[ 0 ] == 0x7f000 ) {
saturn.mem_cntl[ MCTL_BANK_GX ].config[ 0 ] == 0x7f000 ) {
if ( addr == 0x7f000 ) { if ( addr == 0x7f000 ) {
saturn.bank_switch = 0; saturn.bank_switch = 0;
} }
@ -766,22 +726,18 @@ int read_nibble_gx( long addr ) {
} }
return 0x7; return 0x7;
} }
if ( addr >= 0x7e000 && addr < 0x7f000 && if ( addr >= 0x7e000 && addr < 0x7f000 && saturn.mem_cntl[ MCTL_PORT1_GX ].config[ 0 ] == 0x7e000 ) {
saturn.mem_cntl[ MCTL_PORT1_GX ].config[ 0 ] == 0x7e000 ) {
return 0x7; return 0x7;
} }
if ( addr >= 0x7e000 && addr < 0x7f000 && if ( addr >= 0x7e000 && addr < 0x7f000 && saturn.mem_cntl[ MCTL_PORT2_GX ].config[ 0 ] == 0x7e000 ) {
saturn.mem_cntl[ MCTL_PORT2_GX ].config[ 0 ] == 0x7e000 ) {
return 0x7; return 0x7;
} }
return saturn.rom[ addr ]; return saturn.rom[ addr ];
case 8: case 8:
if ( saturn.mem_cntl[ MCTL_SysRAM_GX ].config[ 0 ] == 0x80000 ) { if ( saturn.mem_cntl[ MCTL_SysRAM_GX ].config[ 0 ] == 0x80000 ) {
if ( saturn.mem_cntl[ MCTL_SysRAM_GX ].config[ 1 ] == 0xfc000 && if ( saturn.mem_cntl[ MCTL_SysRAM_GX ].config[ 1 ] == 0xfc000 && addr < 0x84000 )
addr < 0x84000 )
return saturn.ram[ addr - 0x80000 ]; return saturn.ram[ addr - 0x80000 ];
if ( saturn.mem_cntl[ MCTL_SysRAM_GX ].config[ 1 ] == 0xfe000 && if ( saturn.mem_cntl[ MCTL_SysRAM_GX ].config[ 1 ] == 0xfe000 && addr < 0x82000 )
addr < 0x82000 )
return saturn.ram[ addr - 0x80000 ]; return saturn.ram[ addr - 0x80000 ];
if ( saturn.mem_cntl[ MCTL_SysRAM_GX ].config[ 1 ] == 0xf0000 ) if ( saturn.mem_cntl[ MCTL_SysRAM_GX ].config[ 1 ] == 0xf0000 )
return saturn.ram[ addr - 0x80000 ]; return saturn.ram[ addr - 0x80000 ];
@ -818,9 +774,7 @@ int read_nibble_gx( long addr ) {
if ( saturn.mem_cntl[ MCTL_SysRAM_GX ].config[ 1 ] == 0xc0000 ) if ( saturn.mem_cntl[ MCTL_SysRAM_GX ].config[ 1 ] == 0xc0000 )
return saturn.ram[ addr - 0x80000 ]; return saturn.ram[ addr - 0x80000 ];
if ( saturn.mem_cntl[ MCTL_PORT2_GX ].config[ 0 ] == 0xb0000 ) { if ( saturn.mem_cntl[ MCTL_PORT2_GX ].config[ 0 ] == 0xb0000 ) {
return saturn.port2[ ( ( saturn.bank_switch << 18 ) + return saturn.port2[ ( ( saturn.bank_switch << 18 ) + ( addr - 0xb0000 ) ) & port2_mask ];
( addr - 0xb0000 ) ) &
port2_mask ];
/* /*
if (port2_size > (saturn.bank_switch << 18)) if (port2_size > (saturn.bank_switch << 18))
{ {
@ -833,11 +787,9 @@ int read_nibble_gx( long addr ) {
return saturn.rom[ addr ]; return saturn.rom[ addr ];
case 0xc: case 0xc:
if ( saturn.mem_cntl[ MCTL_SysRAM_GX ].config[ 0 ] == 0xc0000 ) { if ( saturn.mem_cntl[ MCTL_SysRAM_GX ].config[ 0 ] == 0xc0000 ) {
if ( saturn.mem_cntl[ MCTL_SysRAM_GX ].config[ 1 ] == 0xfc000 && if ( saturn.mem_cntl[ MCTL_SysRAM_GX ].config[ 1 ] == 0xfc000 && addr < 0xc4000 )
addr < 0xc4000 )
return saturn.ram[ addr - 0xc0000 ]; return saturn.ram[ addr - 0xc0000 ];
if ( saturn.mem_cntl[ MCTL_SysRAM_GX ].config[ 1 ] == 0xfe000 && if ( saturn.mem_cntl[ MCTL_SysRAM_GX ].config[ 1 ] == 0xfe000 && addr < 0xc2000 )
addr < 0xc2000 )
return saturn.ram[ addr - 0xc0000 ]; return saturn.ram[ addr - 0xc0000 ];
return saturn.ram[ addr - 0xc0000 ]; return saturn.ram[ addr - 0xc0000 ];
} }
@ -845,9 +797,7 @@ int read_nibble_gx( long addr ) {
return saturn.port1[ ( addr - 0xc0000 ) & port1_mask ]; return saturn.port1[ ( addr - 0xc0000 ) & port1_mask ];
} }
if ( saturn.mem_cntl[ MCTL_PORT2_GX ].config[ 0 ] == 0xc0000 ) { if ( saturn.mem_cntl[ MCTL_PORT2_GX ].config[ 0 ] == 0xc0000 ) {
return saturn.port2[ ( ( saturn.bank_switch << 18 ) + return saturn.port2[ ( ( saturn.bank_switch << 18 ) + ( addr - 0xc0000 ) ) & port2_mask ];
( addr - 0xc0000 ) ) &
port2_mask ];
/* /*
if (port2_size > (saturn.bank_switch << 18)) if (port2_size > (saturn.bank_switch << 18))
{ {
@ -870,9 +820,7 @@ int read_nibble_gx( long addr ) {
} }
if ( saturn.mem_cntl[ MCTL_PORT2_GX ].config[ 0 ] == 0xc0000 ) if ( saturn.mem_cntl[ MCTL_PORT2_GX ].config[ 0 ] == 0xc0000 )
if ( saturn.mem_cntl[ MCTL_PORT2_GX ].config[ 1 ] == 0xc0000 ) { if ( saturn.mem_cntl[ MCTL_PORT2_GX ].config[ 1 ] == 0xc0000 ) {
return saturn.port2[ ( ( saturn.bank_switch << 18 ) + return saturn.port2[ ( ( saturn.bank_switch << 18 ) + ( addr - 0xc0000 ) ) & port2_mask ];
( addr - 0xc0000 ) ) &
port2_mask ];
/* /*
if (port2_size > (saturn.bank_switch << 18)) if (port2_size > (saturn.bank_switch << 18))
{ {
@ -888,7 +836,8 @@ int read_nibble_gx( long addr ) {
return 0x00; return 0x00;
} }
int read_nibble_crc_sx( long addr ) { int read_nibble_crc_sx( long addr )
{
addr &= 0xfffff; addr &= 0xfffff;
switch ( ( int )( addr >> 16 ) & 0x0f ) { switch ( ( int )( addr >> 16 ) & 0x0f ) {
case 0: case 0:
@ -908,11 +857,9 @@ int read_nibble_crc_sx( long addr ) {
return calc_crc( saturn.rom[ addr ] ); return calc_crc( saturn.rom[ addr ] );
case 7: case 7:
if ( saturn.mem_cntl[ MCTL_SysRAM_SX ].config[ 0 ] == 0x70000 ) { if ( saturn.mem_cntl[ MCTL_SysRAM_SX ].config[ 0 ] == 0x70000 ) {
if ( saturn.mem_cntl[ MCTL_SysRAM_SX ].config[ 1 ] == 0xfc000 && if ( saturn.mem_cntl[ MCTL_SysRAM_SX ].config[ 1 ] == 0xfc000 && addr < 0x74000 )
addr < 0x74000 )
return calc_crc( saturn.ram[ addr - 0x70000 ] ); return calc_crc( saturn.ram[ addr - 0x70000 ] );
if ( saturn.mem_cntl[ MCTL_SysRAM_SX ].config[ 1 ] == 0xfe000 && if ( saturn.mem_cntl[ MCTL_SysRAM_SX ].config[ 1 ] == 0xfe000 && addr < 0x72000 )
addr < 0x72000 )
return calc_crc( saturn.ram[ addr - 0x70000 ] ); return calc_crc( saturn.ram[ addr - 0x70000 ] );
if ( saturn.mem_cntl[ MCTL_SysRAM_SX ].config[ 1 ] == 0xf0000 ) if ( saturn.mem_cntl[ MCTL_SysRAM_SX ].config[ 1 ] == 0xf0000 )
return calc_crc( saturn.ram[ addr - 0x70000 ] ); return calc_crc( saturn.ram[ addr - 0x70000 ] );
@ -923,43 +870,38 @@ int read_nibble_crc_sx( long addr ) {
case 0xa: case 0xa:
case 0xb: case 0xb:
if ( saturn.mem_cntl[ MCTL_PORT1_SX ].config[ 0 ] == 0x80000 ) { if ( saturn.mem_cntl[ MCTL_PORT1_SX ].config[ 0 ] == 0x80000 ) {
return calc_crc( return calc_crc( saturn.port1[ ( addr - 0x80000 ) & port1_mask ] );
saturn.port1[ ( addr - 0x80000 ) & port1_mask ] );
} }
if ( saturn.mem_cntl[ MCTL_PORT2_SX ].config[ 0 ] == 0x80000 ) { if ( saturn.mem_cntl[ MCTL_PORT2_SX ].config[ 0 ] == 0x80000 ) {
return calc_crc( return calc_crc( saturn.port2[ ( addr - 0x80000 ) & port2_mask ] );
saturn.port2[ ( addr - 0x80000 ) & port2_mask ] );
} }
return 0x00; return 0x00;
case 0xc: case 0xc:
case 0xd: case 0xd:
case 0xe: case 0xe:
if ( saturn.mem_cntl[ MCTL_PORT1_SX ].config[ 0 ] == 0xc0000 ) { if ( saturn.mem_cntl[ MCTL_PORT1_SX ].config[ 0 ] == 0xc0000 ) {
return calc_crc( return calc_crc( saturn.port1[ ( addr - 0xc0000 ) & port1_mask ] );
saturn.port1[ ( addr - 0xc0000 ) & port1_mask ] );
} }
if ( saturn.mem_cntl[ MCTL_PORT2_SX ].config[ 0 ] == 0xc0000 ) { if ( saturn.mem_cntl[ MCTL_PORT2_SX ].config[ 0 ] == 0xc0000 ) {
return calc_crc( return calc_crc( saturn.port2[ ( addr - 0xc0000 ) & port2_mask ] );
saturn.port2[ ( addr - 0xc0000 ) & port2_mask ] );
} }
return 0x00; return 0x00;
case 0xf: case 0xf:
if ( saturn.mem_cntl[ MCTL_SysRAM_SX ].config[ 0 ] == 0xf0000 ) if ( saturn.mem_cntl[ MCTL_SysRAM_SX ].config[ 0 ] == 0xf0000 )
return calc_crc( saturn.ram[ addr - 0xf0000 ] ); return calc_crc( saturn.ram[ addr - 0xf0000 ] );
if ( saturn.mem_cntl[ MCTL_PORT1_SX ].config[ 0 ] == 0xc0000 ) { if ( saturn.mem_cntl[ MCTL_PORT1_SX ].config[ 0 ] == 0xc0000 ) {
return calc_crc( return calc_crc( saturn.port1[ ( addr - 0xc0000 ) & port1_mask ] );
saturn.port1[ ( addr - 0xc0000 ) & port1_mask ] );
} }
if ( saturn.mem_cntl[ MCTL_PORT2_SX ].config[ 0 ] == 0xc0000 ) { if ( saturn.mem_cntl[ MCTL_PORT2_SX ].config[ 0 ] == 0xc0000 ) {
return calc_crc( return calc_crc( saturn.port2[ ( addr - 0xc0000 ) & port2_mask ] );
saturn.port2[ ( addr - 0xc0000 ) & port2_mask ] );
} }
return 0x00; return 0x00;
} }
return 0x00; return 0x00;
} }
int read_nibble_crc_gx( long addr ) { int read_nibble_crc_gx( long addr )
{
addr &= 0xfffff; addr &= 0xfffff;
switch ( ( int )( addr >> 16 ) & 0x0f ) { switch ( ( int )( addr >> 16 ) & 0x0f ) {
case 0: case 0:
@ -981,8 +923,7 @@ int read_nibble_crc_gx( long addr ) {
return calc_crc( saturn.ram[ addr - 0x40000 ] ); return calc_crc( saturn.ram[ addr - 0x40000 ] );
return calc_crc( saturn.rom[ addr ] ); return calc_crc( saturn.rom[ addr ] );
case 7: case 7:
if ( addr >= 0x7f000 && if ( addr >= 0x7f000 && saturn.mem_cntl[ MCTL_BANK_GX ].config[ 0 ] == 0x7f000 ) {
saturn.mem_cntl[ MCTL_BANK_GX ].config[ 0 ] == 0x7f000 ) {
if ( addr == 0x7f000 ) { if ( addr == 0x7f000 ) {
saturn.bank_switch = 0; saturn.bank_switch = 0;
} }
@ -991,22 +932,18 @@ int read_nibble_crc_gx( long addr ) {
} }
return 0x7; return 0x7;
} }
if ( addr >= 0x7e000 && addr < 0x7f000 && if ( addr >= 0x7e000 && addr < 0x7f000 && saturn.mem_cntl[ MCTL_PORT1_GX ].config[ 0 ] == 0x7e000 ) {
saturn.mem_cntl[ MCTL_PORT1_GX ].config[ 0 ] == 0x7e000 ) {
return 0x7; return 0x7;
} }
if ( addr >= 0x7e000 && addr < 0x7f000 && if ( addr >= 0x7e000 && addr < 0x7f000 && saturn.mem_cntl[ MCTL_PORT2_GX ].config[ 0 ] == 0x7e000 ) {
saturn.mem_cntl[ MCTL_PORT2_GX ].config[ 0 ] == 0x7e000 ) {
return 0x7; return 0x7;
} }
return calc_crc( saturn.rom[ addr ] ); return calc_crc( saturn.rom[ addr ] );
case 8: case 8:
if ( saturn.mem_cntl[ MCTL_SysRAM_GX ].config[ 0 ] == 0x80000 ) { if ( saturn.mem_cntl[ MCTL_SysRAM_GX ].config[ 0 ] == 0x80000 ) {
if ( saturn.mem_cntl[ MCTL_SysRAM_GX ].config[ 1 ] == 0xfc000 && if ( saturn.mem_cntl[ MCTL_SysRAM_GX ].config[ 1 ] == 0xfc000 && addr < 0x84000 )
addr < 0x84000 )
return calc_crc( saturn.ram[ addr - 0x80000 ] ); return calc_crc( saturn.ram[ addr - 0x80000 ] );
if ( saturn.mem_cntl[ MCTL_SysRAM_GX ].config[ 1 ] == 0xfe000 && if ( saturn.mem_cntl[ MCTL_SysRAM_GX ].config[ 1 ] == 0xfe000 && addr < 0x82000 )
addr < 0x82000 )
return calc_crc( saturn.ram[ addr - 0x80000 ] ); return calc_crc( saturn.ram[ addr - 0x80000 ] );
if ( saturn.mem_cntl[ MCTL_SysRAM_GX ].config[ 1 ] == 0xf0000 ) if ( saturn.mem_cntl[ MCTL_SysRAM_GX ].config[ 1 ] == 0xf0000 )
return calc_crc( saturn.ram[ addr - 0x80000 ] ); return calc_crc( saturn.ram[ addr - 0x80000 ] );
@ -1035,8 +972,7 @@ int read_nibble_crc_gx( long addr ) {
if ( saturn.mem_cntl[ MCTL_SysRAM_GX ].config[ 1 ] == 0xc0000 ) if ( saturn.mem_cntl[ MCTL_SysRAM_GX ].config[ 1 ] == 0xc0000 )
return calc_crc( saturn.ram[ addr - 0x80000 ] ); return calc_crc( saturn.ram[ addr - 0x80000 ] );
if ( saturn.mem_cntl[ MCTL_PORT1_GX ].config[ 0 ] == 0xa0000 ) { if ( saturn.mem_cntl[ MCTL_PORT1_GX ].config[ 0 ] == 0xa0000 ) {
return calc_crc( return calc_crc( saturn.port1[ ( addr - 0xa0000 ) & port1_mask ] );
saturn.port1[ ( addr - 0xa0000 ) & port1_mask ] );
} }
return calc_crc( saturn.rom[ addr ] ); return calc_crc( saturn.rom[ addr ] );
case 0xb: case 0xb:
@ -1044,9 +980,7 @@ int read_nibble_crc_gx( long addr ) {
if ( saturn.mem_cntl[ MCTL_SysRAM_GX ].config[ 1 ] == 0xc0000 ) if ( saturn.mem_cntl[ MCTL_SysRAM_GX ].config[ 1 ] == 0xc0000 )
return calc_crc( saturn.ram[ addr - 0x80000 ] ); return calc_crc( saturn.ram[ addr - 0x80000 ] );
if ( saturn.mem_cntl[ MCTL_PORT2_GX ].config[ 0 ] == 0xb0000 ) { if ( saturn.mem_cntl[ MCTL_PORT2_GX ].config[ 0 ] == 0xb0000 ) {
return calc_crc( saturn.port2[ ( ( saturn.bank_switch << 18 ) + return calc_crc( saturn.port2[ ( ( saturn.bank_switch << 18 ) + ( addr - 0xb0000 ) ) & port2_mask ] );
( addr - 0xb0000 ) ) &
port2_mask ] );
/* /*
if (port2_size > (saturn.bank_switch << 18)) if (port2_size > (saturn.bank_switch << 18))
{ {
@ -1061,22 +995,17 @@ int read_nibble_crc_gx( long addr ) {
return calc_crc( saturn.rom[ addr ] ); return calc_crc( saturn.rom[ addr ] );
case 0xc: case 0xc:
if ( saturn.mem_cntl[ MCTL_SysRAM_GX ].config[ 0 ] == 0xc0000 ) { if ( saturn.mem_cntl[ MCTL_SysRAM_GX ].config[ 0 ] == 0xc0000 ) {
if ( saturn.mem_cntl[ MCTL_SysRAM_GX ].config[ 1 ] == 0xfc000 && if ( saturn.mem_cntl[ MCTL_SysRAM_GX ].config[ 1 ] == 0xfc000 && addr < 0xc4000 )
addr < 0xc4000 )
return calc_crc( saturn.ram[ addr - 0xc0000 ] ); return calc_crc( saturn.ram[ addr - 0xc0000 ] );
if ( saturn.mem_cntl[ MCTL_SysRAM_GX ].config[ 1 ] == 0xfe000 && if ( saturn.mem_cntl[ MCTL_SysRAM_GX ].config[ 1 ] == 0xfe000 && addr < 0xc2000 )
addr < 0xc2000 )
return calc_crc( saturn.ram[ addr - 0xc0000 ] ); return calc_crc( saturn.ram[ addr - 0xc0000 ] );
return calc_crc( saturn.ram[ addr - 0xc0000 ] ); return calc_crc( saturn.ram[ addr - 0xc0000 ] );
} }
if ( saturn.mem_cntl[ MCTL_PORT1_GX ].config[ 0 ] == 0xc0000 ) { if ( saturn.mem_cntl[ MCTL_PORT1_GX ].config[ 0 ] == 0xc0000 ) {
return calc_crc( return calc_crc( saturn.port1[ ( addr - 0xc0000 ) & port1_mask ] );
saturn.port1[ ( addr - 0xc0000 ) & port1_mask ] );
} }
if ( saturn.mem_cntl[ MCTL_PORT2_GX ].config[ 0 ] == 0xc0000 ) { if ( saturn.mem_cntl[ MCTL_PORT2_GX ].config[ 0 ] == 0xc0000 ) {
return calc_crc( saturn.port2[ ( ( saturn.bank_switch << 18 ) + return calc_crc( saturn.port2[ ( ( saturn.bank_switch << 18 ) + ( addr - 0xc0000 ) ) & port2_mask ] );
( addr - 0xc0000 ) ) &
port2_mask ] );
/* /*
if (port2_size > (saturn.bank_switch << 18)) if (port2_size > (saturn.bank_switch << 18))
{ {
@ -1097,15 +1026,11 @@ int read_nibble_crc_gx( long addr ) {
return calc_crc( saturn.ram[ addr - 0xc0000 ] ); return calc_crc( saturn.ram[ addr - 0xc0000 ] );
if ( saturn.mem_cntl[ MCTL_PORT1_GX ].config[ 0 ] == 0xc0000 ) if ( saturn.mem_cntl[ MCTL_PORT1_GX ].config[ 0 ] == 0xc0000 )
if ( saturn.mem_cntl[ MCTL_PORT1_GX ].config[ 1 ] == 0xc0000 ) { if ( saturn.mem_cntl[ MCTL_PORT1_GX ].config[ 1 ] == 0xc0000 ) {
return calc_crc( return calc_crc( saturn.port1[ ( addr - 0xc0000 ) & port1_mask ] );
saturn.port1[ ( addr - 0xc0000 ) & port1_mask ] );
} }
if ( saturn.mem_cntl[ MCTL_PORT2_GX ].config[ 0 ] == 0xc0000 ) if ( saturn.mem_cntl[ MCTL_PORT2_GX ].config[ 0 ] == 0xc0000 )
if ( saturn.mem_cntl[ MCTL_PORT2_GX ].config[ 1 ] == 0xc0000 ) { if ( saturn.mem_cntl[ MCTL_PORT2_GX ].config[ 1 ] == 0xc0000 ) {
return calc_crc( return calc_crc( saturn.port2[ ( ( saturn.bank_switch << 18 ) + ( addr - 0xc0000 ) ) & port2_mask ] );
saturn.port2[ ( ( saturn.bank_switch << 18 ) +
( addr - 0xc0000 ) ) &
port2_mask ] );
/* /*
if (port2_size > (saturn.bank_switch << 18)) if (port2_size > (saturn.bank_switch << 18))
{ {
@ -1122,7 +1047,8 @@ int read_nibble_crc_gx( long addr ) {
return 0x00; return 0x00;
} }
long read_nibbles( long addr, int len ) { long read_nibbles( long addr, int len )
{
long val = 0; long val = 0;
addr += len; addr += len;
@ -1132,7 +1058,8 @@ long read_nibbles( long addr, int len ) {
return val; return val;
} }
void dev_memory_init( void ) { void dev_memory_init( void )
{
if ( opt_gx ) { if ( opt_gx ) {
read_nibble = read_nibble_gx; read_nibble = read_nibble_gx;
read_nibble_crc = read_nibble_crc_gx; read_nibble_crc = read_nibble_crc_gx;

104
src/emu_register.c
View file

@ -6,14 +6,12 @@
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 static inline int get_start( int code )
get_start( int code ) { /* FIXME: Duplicate from hp48emu_actions.c */ { /* FIXME: Duplicate from hp48emu_actions.c */
int s; int s;
if ( ( s = start_fields[ code ] ) == -1 ) if ( ( s = start_fields[ code ] ) == -1 )
@ -22,8 +20,8 @@ get_start( int code ) { /* FIXME: Duplicate from hp48emu_actions.c */
return s; /* FIXME: potentially return uninitialized s ? */ return s; /* FIXME: potentially return uninitialized s ? */
} }
static inline int static inline int get_end( int code )
get_end( int code ) { /* FIXME: Duplicate from hp48emu_actions.c */ { /* FIXME: Duplicate from hp48emu_actions.c */
int e; int e;
if ( ( e = end_fields[ code ] ) == -1 ) if ( ( e = end_fields[ code ] ) == -1 )
@ -32,8 +30,8 @@ get_end( int code ) { /* FIXME: Duplicate from hp48emu_actions.c */
return e; /* FIXME: potentially return uninitialized e ? */ return e; /* FIXME: potentially return uninitialized 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; int t;
int s = get_start( code ); int s = get_start( code );
int e = get_end( code ); int e = get_end( code );
@ -53,7 +51,8 @@ void add_register( unsigned char* res, unsigned char* r1, unsigned char* r2,
saturn.CARRY = c ? 1 : 0; saturn.CARRY = c ? 1 : 0;
} }
void add_p_plus_one( unsigned char* r ) { void add_p_plus_one( unsigned char* r )
{
int t; int t;
int s = 0; int s = 0;
int e = 4; int e = 4;
@ -73,8 +72,8 @@ void add_p_plus_one( unsigned char* r ) {
saturn.CARRY = c ? 1 : 0; saturn.CARRY = c ? 1 : 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; int t;
int s = get_start( code ); int s = get_start( code );
int e = get_end( code ); int e = get_end( code );
@ -93,7 +92,8 @@ void sub_register( unsigned char* res, unsigned char* r1, unsigned char* r2,
saturn.CARRY = c ? 1 : 0; saturn.CARRY = c ? 1 : 0;
} }
void complement_2_register( unsigned char* r, int code ) { void complement_2_register( unsigned char* r, int code )
{
int t; int t;
int s = get_start( code ); int s = get_start( code );
int e = get_end( code ); int e = get_end( code );
@ -115,7 +115,8 @@ void complement_2_register( unsigned char* r, int code ) {
saturn.CARRY = carry ? 1 : 0; saturn.CARRY = carry ? 1 : 0;
} }
void complement_1_register( unsigned char* r, int code ) { void complement_1_register( unsigned char* r, int code )
{
int t; int t;
int s = get_start( code ); int s = get_start( code );
int e = get_end( code ); int e = get_end( code );
@ -127,7 +128,8 @@ void complement_1_register( unsigned char* r, int code ) {
saturn.CARRY = 0; saturn.CARRY = 0;
} }
void inc_register( unsigned char* r, int code ) { void inc_register( unsigned char* r, int code )
{
int t; int t;
int s = get_start( code ); int s = get_start( code );
int e = get_end( code ); int e = get_end( code );
@ -148,7 +150,8 @@ void inc_register( unsigned char* r, int code ) {
saturn.CARRY = c ? 1 : 0; saturn.CARRY = c ? 1 : 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; int t;
int s = get_start( code ); int s = get_start( code );
int e = get_end( code ); int e = get_end( code );
@ -169,7 +172,8 @@ void add_register_constant( unsigned char* r, int code, int val ) {
saturn.CARRY = c ? 1 : 0; saturn.CARRY = c ? 1 : 0;
} }
void dec_register( unsigned char* r, int code ) { void dec_register( unsigned char* r, int code )
{
int t; int t;
int s = get_start( code ); int s = get_start( code );
int e = get_end( code ); int e = get_end( code );
@ -190,7 +194,8 @@ void dec_register( unsigned char* r, int code ) {
saturn.CARRY = c ? 1 : 0; saturn.CARRY = c ? 1 : 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; int t;
int s = get_start( code ); int s = get_start( code );
int e = get_end( code ); int e = get_end( code );
@ -211,7 +216,8 @@ void sub_register_constant( unsigned char* r, int code, int val ) {
saturn.CARRY = c ? 1 : 0; saturn.CARRY = c ? 1 : 0;
} }
void zero_register( unsigned char* r, int code ) { void zero_register( unsigned char* r, int code )
{
int s = get_start( code ); int s = get_start( code );
int e = get_end( code ); int e = get_end( code );
@ -219,8 +225,8 @@ void zero_register( unsigned char* r, int code ) {
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 s = get_start( code ); int s = get_start( code );
int e = get_end( code ); int e = get_end( code );
@ -228,8 +234,8 @@ void or_register( unsigned char* res, unsigned char* r1, unsigned char* r2,
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 s = get_start( code ); int s = get_start( code );
int e = get_end( code ); int e = get_end( code );
@ -237,7 +243,8 @@ void and_register( unsigned char* res, unsigned char* r1, unsigned char* r2,
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 s = get_start( code ); int s = get_start( code );
int e = get_end( code ); int e = get_end( code );
@ -245,7 +252,8 @@ void copy_register( unsigned char* to, unsigned char* from, int code ) {
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; int t;
int s = get_start( code ); int s = get_start( code );
int e = get_end( code ); int e = get_end( code );
@ -257,7 +265,8 @@ void exchange_register( unsigned char* r1, unsigned char* r2, int code ) {
} }
} }
void exchange_reg( unsigned char* r, word_20* d, int code ) { void exchange_reg( unsigned char* r, word_20* d, int code )
{
int t; int t;
int s = get_start( code ); int s = get_start( code );
int e = get_end( code ); int e = get_end( code );
@ -270,7 +279,8 @@ void exchange_reg( unsigned char* r, word_20* d, int code ) {
} }
} }
void shift_left_register( unsigned char* r, int code ) { void shift_left_register( unsigned char* r, int code )
{
int s = get_start( code ); int s = get_start( code );
int e = get_end( code ); int e = get_end( code );
@ -280,7 +290,8 @@ void shift_left_register( unsigned char* r, int code ) {
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 s = get_start( code ); int s = get_start( code );
int e = get_end( code ); int e = get_end( code );
int t = r[ e ] & 0x0f; int t = r[ e ] & 0x0f;
@ -291,7 +302,8 @@ void shift_left_circ_register( unsigned char* r, int code ) {
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 s = get_start( code ); int s = get_start( code );
int e = get_end( code ); int e = get_end( code );
@ -304,7 +316,8 @@ void shift_right_register( unsigned char* r, int code ) {
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 s = get_start( code ); int s = get_start( code );
int e = get_end( code ); int e = get_end( code );
int t = r[ s ] & 0x0f; int t = r[ s ] & 0x0f;
@ -317,7 +330,8 @@ void shift_right_circ_register( unsigned char* r, int code ) {
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; int t;
int s = get_start( code ); int s = get_start( code );
int e = get_end( code ); int e = get_end( code );
@ -332,7 +346,8 @@ void shift_right_bit_register( unsigned char* r, int code ) {
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 s = get_start( code ); int s = get_start( code );
int e = get_end( code ); int e = get_end( code );
int z = 1; int z = 1;
@ -346,7 +361,8 @@ int is_zero_register( unsigned char* r, int code ) {
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 s = get_start( code ); int s = get_start( code );
int e = get_end( code ); int e = get_end( code );
int z = 0; int z = 0;
@ -360,7 +376,8 @@ int is_not_zero_register( unsigned char* r, int code ) {
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 s = get_start( code ); int s = get_start( code );
int e = get_end( code ); int e = get_end( code );
int z = 1; int z = 1;
@ -374,7 +391,8 @@ int is_equal_register( unsigned char* r1, unsigned char* r2, int code ) {
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 s = get_start( code ); int s = get_start( code );
int e = get_end( code ); int e = get_end( code );
int z = 0; int z = 0;
@ -388,7 +406,8 @@ int is_not_equal_register( unsigned char* r1, unsigned char* r2, int code ) {
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 s = get_start( code ); int s = get_start( code );
int e = get_end( code ); int e = get_end( code );
int z = 0; int z = 0;
@ -407,8 +426,8 @@ 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 is_less_or_equal_register( unsigned char* r1, unsigned char* r2, int code )
int code ) { {
int s = get_start( code ); int s = get_start( code );
int e = get_end( code ); int e = get_end( code );
int z = 1; int z = 1;
@ -427,7 +446,8 @@ int is_less_or_equal_register( unsigned char* r1, unsigned char* r2,
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 s = get_start( code ); int s = get_start( code );
int e = get_end( code ); int e = get_end( code );
int z = 0; int z = 0;
@ -446,8 +466,8 @@ int is_greater_register( unsigned char* r1, unsigned char* r2, int code ) {
return z; return z;
} }
int is_greater_or_equal_register( unsigned char* r1, unsigned char* r2, int is_greater_or_equal_register( unsigned char* r1, unsigned char* r2, int code )
int code ) { {
int s = get_start( code ); int s = get_start( code );
int e = get_end( code ); int e = get_end( code );
int z = 1; int z = 1;

54
src/emu_serial.c
View file

@ -7,9 +7,9 @@
#include <termios.h> #include <termios.h>
#include <unistd.h> #include <unistd.h>
#include "runtime_options.h"
#include "emulator.h" #include "emulator.h"
#include "emulator_inner.h" #include "emulator_inner.h"
#include "runtime_options.h"
static int wire_fd; static int wire_fd;
static int ir_fd; static int ir_fd;
@ -20,7 +20,8 @@ extern int rece_instr;
char* wire_name = ( char* )0; char* wire_name = ( char* )0;
char* ir_name = ( char* )0; char* ir_name = ( char* )0;
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 );
@ -33,7 +34,8 @@ void update_connection_display( void ) {
} }
} }
int init_serial( void ) { int init_serial( void )
{
int c; int c;
int n; int n;
char tty_dev_name[ 128 ]; char tty_dev_name[ 128 ];
@ -43,16 +45,14 @@ int init_serial( void ) {
ttyp = -1; ttyp = -1;
if ( useTerminal ) { if ( useTerminal ) {
/* Unix98 PTY (Preferred) */ /* Unix98 PTY (Preferred) */
if ( ( wire_fd = open( "/dev/ptmx", O_RDWR | O_NONBLOCK, 0666 ) ) >= if ( ( wire_fd = open( "/dev/ptmx", O_RDWR | O_NONBLOCK, 0666 ) ) >= 0 ) {
0 ) {
grantpt( wire_fd ); grantpt( wire_fd );
unlockpt( wire_fd ); unlockpt( wire_fd );
if ( ptsname_r( wire_fd, tty_dev_name, 128 ) ) { if ( ptsname_r( wire_fd, tty_dev_name, 128 ) ) {
perror( "Could not get the name of the wire device." ); perror( "Could not get the name of the wire device." );
exit( -1 ); exit( -1 );
} }
if ( ( ttyp = open( tty_dev_name, O_RDWR | O_NDELAY, 0666 ) ) >= if ( ( ttyp = open( tty_dev_name, O_RDWR | O_NDELAY, 0666 ) ) >= 0 ) {
0 ) {
if ( verbose ) if ( verbose )
printf( "wire connection on %s\n", tty_dev_name ); printf( "wire connection on %s\n", tty_dev_name );
wire_name = strdup( tty_dev_name ); wire_name = strdup( tty_dev_name );
@ -64,9 +64,7 @@ int init_serial( void ) {
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 )
@ -88,8 +86,7 @@ int init_serial( void ) {
#endif #endif
{ {
if ( verbose ) if ( verbose )
fprintf( stderr, "ioctl(wire, TCGETS) failed, errno = %d\n", fprintf( stderr, "ioctl(wire, TCGETS) failed, errno = %d\n", errno );
errno );
wire_fd = -1; wire_fd = -1;
ttyp = -1; ttyp = -1;
} }
@ -112,8 +109,7 @@ int init_serial( void ) {
#endif #endif
{ {
if ( verbose ) if ( verbose )
fprintf( stderr, "ioctl(wire, TCSETS) failed, errno = %d\n", fprintf( stderr, "ioctl(wire, TCSETS) failed, errno = %d\n", errno );
errno );
wire_fd = -1; wire_fd = -1;
ttyp = -1; ttyp = -1;
} }
@ -137,8 +133,7 @@ int init_serial( void ) {
#endif #endif
{ {
if ( verbose ) if ( verbose )
fprintf( stderr, "ioctl(IR, TCGETS) failed, errno = %d\n", fprintf( stderr, "ioctl(IR, TCGETS) failed, errno = %d\n", errno );
errno );
ir_fd = -1; ir_fd = -1;
} }
} }
@ -160,8 +155,7 @@ int init_serial( void ) {
#endif #endif
{ {
if ( verbose ) if ( verbose )
fprintf( stderr, "ioctl(IR, TCSETS) failed, errno = %d\n", fprintf( stderr, "ioctl(IR, TCSETS) failed, errno = %d\n", errno );
errno );
ir_fd = -1; ir_fd = -1;
} }
} }
@ -169,7 +163,8 @@ int init_serial( 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;
@ -181,8 +176,7 @@ void serial_baud( int baud ) {
#endif #endif
{ {
if ( verbose ) if ( verbose )
fprintf( stderr, "ioctl(IR, TCGETS) failed, errno = %d\n", fprintf( stderr, "ioctl(IR, TCGETS) failed, errno = %d\n", errno );
errno );
ir_fd = -1; ir_fd = -1;
error = 1; error = 1;
} }
@ -283,8 +277,7 @@ void serial_baud( int baud ) {
#endif #endif
{ {
if ( verbose ) if ( verbose )
fprintf( stderr, "ioctl(IR, TCSETS) failed, errno = %d\n", fprintf( stderr, "ioctl(IR, TCSETS) failed, errno = %d\n", errno );
errno );
ir_fd = -1; ir_fd = -1;
error = 1; error = 1;
} }
@ -298,8 +291,7 @@ void serial_baud( int baud ) {
#endif #endif
{ {
if ( verbose ) if ( verbose )
fprintf( stderr, "ioctl(wire, TCGETS) failed, errno = %d\n", fprintf( stderr, "ioctl(wire, TCGETS) failed, errno = %d\n", errno );
errno );
wire_fd = -1; wire_fd = -1;
ttyp = -1; ttyp = -1;
error = 1; error = 1;
@ -360,8 +352,7 @@ void serial_baud( int baud ) {
#endif #endif
{ {
if ( verbose ) if ( verbose )
fprintf( stderr, "ioctl(wire, TCSETS) failed, errno = %d\n", fprintf( stderr, "ioctl(wire, TCSETS) failed, errno = %d\n", errno );
errno );
wire_fd = -1; wire_fd = -1;
ttyp = -1; ttyp = -1;
error = 1; error = 1;
@ -371,7 +362,8 @@ void serial_baud( int baud ) {
update_connection_display(); update_connection_display();
} }
void transmit_char( void ) { void transmit_char( void )
{
if ( saturn.ir_ctrl & 0x04 ) { if ( saturn.ir_ctrl & 0x04 ) {
if ( ir_fd == -1 ) { if ( ir_fd == -1 ) {
saturn.tcs &= 0x0e; saturn.tcs &= 0x0e;
@ -426,7 +418,8 @@ void transmit_char( void ) {
#define NR_BUFFER 256 #define NR_BUFFER 256
void receive_char( void ) { void receive_char( void )
{
struct timeval tout; struct timeval tout;
fd_set rfds; fd_set rfds;
int nfd; int nfd;
@ -455,8 +448,7 @@ void receive_char( void ) {
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 ) ) > if ( ( nfd = select( nfd, &rfds, ( fd_set* )0, ( fd_set* )0, &tout ) ) > 0 ) {
0 ) {
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 );

36
src/emu_timer.c
View file

@ -1,15 +1,15 @@
#include <assert.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <time.h> #include <time.h>
#include <unistd.h> #include <unistd.h>
#include <assert.h>
#include <sys/time.h> #include <sys/time.h>
#include "romio.h" #include "debugger.h" /* used for in_debugger */
#include "emulator.h" #include "emulator.h"
#include "emulator_inner.h" #include "emulator_inner.h"
#include "debugger.h" /* used for in_debugger */ #include "romio.h"
#define NR_TIMERS 4 #define NR_TIMERS 4
@ -52,8 +52,7 @@ word_64 time_offset = 0x0;
#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 ) \ #define calc_crc( nib ) ( crc = ( crc >> 4 ) ^ ( ( ( crc ^ ( nib ) ) & 0xf ) * 0x1081 ) )
( crc = ( crc >> 4 ) ^ ( ( ( crc ^ ( nib ) ) & 0xf ) * 0x1081 ) )
/* /*
* Set ACCESSTIME: (on startup) * Set ACCESSTIME: (on startup)
@ -68,7 +67,8 @@ 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;
@ -147,7 +147,8 @@ void set_accesstime( void ) {
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;
@ -171,7 +172,8 @@ void start_timer( int timer ) {
} }
} }
void restart_timer( int timer ) { void restart_timer( int timer )
{
struct timeval tv; struct timeval tv;
struct timezone tz; struct timezone tz;
@ -197,7 +199,8 @@ void restart_timer( int timer ) {
} }
} }
void stop_timer( int timer ) { void stop_timer( int timer )
{
struct timeval tv; struct timeval tv;
struct timezone tz; struct timezone tz;
@ -226,7 +229,8 @@ void stop_timer( int timer ) {
// &timers[timer].value); // &timers[timer].value);
} }
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;
@ -237,7 +241,8 @@ void reset_timer( int timer ) {
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;
@ -277,7 +282,8 @@ 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;
@ -329,8 +335,7 @@ t1_t2_ticks get_t1_t2( void ) {
* 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
*/ */
@ -359,8 +364,7 @@ t1_t2_ticks get_t1_t2( void ) {
access_time -= adj_time; access_time -= adj_time;
} }
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
*/ */

15
src/emulator_inner.h
View file

@ -74,19 +74,15 @@ int get_identification( void );
void add_p_plus_one( unsigned char* r ); void add_p_plus_one( unsigned char* r );
void add_register_constant( unsigned char* res, int code, int val ); void add_register_constant( unsigned char* res, int code, int val );
void sub_register_constant( unsigned char* res, int code, int val ); void sub_register_constant( unsigned char* res, int code, int val );
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 ); void sub_register( unsigned char* res, unsigned char* r1, unsigned char* r2, int code );
void sub_register( unsigned char* res, unsigned char* r1, unsigned char* r2,
int code );
void complement_2_register( unsigned char* r, int code ); void complement_2_register( unsigned char* r, int code );
void complement_1_register( unsigned char* r, int code ); void complement_1_register( unsigned char* r, int code );
void inc_register( unsigned char* r, int code ); void inc_register( unsigned char* r, int code );
void dec_register( unsigned char* r, int code ); void dec_register( unsigned char* r, int code );
void zero_register( unsigned char* r, int code ); void zero_register( unsigned char* r, int code );
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 ); void and_register( unsigned char* res, unsigned char* r1, unsigned char* r2, int code );
void and_register( unsigned char* res, unsigned char* r1, unsigned char* r2,
int code );
void copy_register( unsigned char* to, unsigned char* from, int code ); void copy_register( unsigned char* to, unsigned char* from, int code );
void exchange_register( unsigned char* r1, unsigned char* r2, int code ); void exchange_register( unsigned char* r1, unsigned char* r2, int code );
void exchange_reg( unsigned char* r, word_20* d, int code ); void exchange_reg( unsigned char* r, word_20* d, int code );
@ -102,8 +98,7 @@ int is_not_equal_register( unsigned char* r1, unsigned char* r2, int code );
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 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 is_greater_register( unsigned char* r1, unsigned char* r2, int code ); int is_greater_register( unsigned char* r1, unsigned char* r2, int code );
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 );
/****************/ /****************/
/* emu_serial.c */ /* emu_serial.c */

14
src/main.c
View file

@ -1,20 +1,21 @@
#include <errno.h> #include <errno.h>
#include <fcntl.h> #include <fcntl.h>
#include <langinfo.h>
#include <locale.h>
#include <signal.h> #include <signal.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <sys/time.h> #include <sys/time.h>
#include <unistd.h> #include <unistd.h>
#include <langinfo.h>
#include <locale.h>
#include "runtime_options.h"
#include "emulator.h"
#include "debugger.h" #include "debugger.h"
#include "emulator.h"
#include "runtime_options.h"
#include "ui.h" /* init_ui(); */ #include "ui.h" /* init_ui(); */
void signal_handler( int sig ) { void signal_handler( int sig )
{
switch ( sig ) { switch ( sig ) {
case SIGINT: /* Ctrl-C */ case SIGINT: /* Ctrl-C */
enter_debugger |= USER_INTERRUPT; enter_debugger |= USER_INTERRUPT;
@ -30,7 +31,8 @@ void signal_handler( int sig ) {
} }
} }
int main( int argc, char** argv ) { int main( int argc, char** argv )
{
setlocale( LC_ALL, "C" ); setlocale( LC_ALL, "C" );
/**********/ /**********/

29
src/romio.c
View file

@ -1,7 +1,7 @@
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <unistd.h>
#include <sys/stat.h> #include <sys/stat.h>
#include <unistd.h>
#include "romio.h" #include "romio.h"
@ -11,7 +11,8 @@
unsigned int opt_gx = 0; unsigned int opt_gx = 0;
unsigned int rom_size = 0; unsigned int rom_size = 0;
int read_rom_file( const char* name, unsigned char** mem, unsigned int* size ) { int read_rom_file( const char* name, unsigned char** mem, unsigned int* size )
{
struct stat st; struct stat st;
FILE* fp; FILE* fp;
unsigned char* tmp_mem; unsigned char* tmp_mem;
@ -38,11 +39,9 @@ int read_rom_file( const char* name, unsigned char** mem, unsigned int* size ) {
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 );
@ -83,8 +82,7 @@ int read_rom_file( const char* name, unsigned char** mem, unsigned int* size ) {
*/ */
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;
@ -92,8 +90,7 @@ int read_rom_file( const char* name, unsigned char** mem, unsigned int* size ) {
return 0; return 0;
} }
if ( NULL == if ( NULL == ( tmp_mem = ( unsigned char* )malloc( ( size_t )st.st_size ) ) ) {
( tmp_mem = ( unsigned char* )malloc( ( size_t )st.st_size ) ) ) {
for ( i = 0, j = 0; i < *size / 2; i++ ) { for ( i = 0, j = 0; i < *size / 2; i++ ) {
if ( 1 != fread( &byte, 1, 1, fp ) ) { if ( 1 != fread( &byte, 1, 1, fp ) ) {
fprintf( stderr, "can\'t read %s\n", name ); fprintf( stderr, "can\'t read %s\n", name );
@ -132,16 +129,13 @@ int read_rom_file( const char* name, unsigned char** mem, unsigned int* size ) {
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", fprintf( stderr, "%s seems to be HP49 ROM, but size is 0x%x\n", name, *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", fprintf( stderr, "%s seems to be HP49 ROM, but size is 0x%x\n", name, *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", fprintf( stderr, "%s seems to be G/GX ROM, but size is 0x%x\n", name, *size );
name, *size );
free( *mem ); free( *mem );
*mem = NULL; *mem = NULL;
*size = 0; *size = 0;
@ -151,8 +145,7 @@ int read_rom_file( const char* name, unsigned char** mem, unsigned int* size ) {
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", fprintf( stderr, "%s seems to be S/SX ROM, but size is 0x%x\n", name, *size );
name, *size );
free( *mem ); free( *mem );
*mem = NULL; *mem = NULL;
*size = 0; *size = 0;

3
src/romio.h
View file

@ -4,7 +4,6 @@
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( const char* name, unsigned char** mem, extern int read_rom_file( const char* name, unsigned char** mem, unsigned int* size );
unsigned int* size );
#endif /* !_ROMIO_H */ #endif /* !_ROMIO_H */

40
src/runtime_options.c
View file

@ -1,10 +1,10 @@
#include <errno.h> #include <errno.h>
#include <pwd.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <pwd.h>
#include <unistd.h>
#include <sys/stat.h> #include <sys/stat.h>
#include <unistd.h>
#include <getopt.h> #include <getopt.h>
@ -63,7 +63,8 @@ char normalized_state_path[ MAX_LENGTH_FILENAME ];
char normalized_port1_path[ MAX_LENGTH_FILENAME ]; char normalized_port1_path[ MAX_LENGTH_FILENAME ];
char normalized_port2_path[ MAX_LENGTH_FILENAME ]; char normalized_port2_path[ MAX_LENGTH_FILENAME ];
void get_absolute_config_dir( char* source, char* dest ) { void get_absolute_config_dir( char* source, char* dest )
{
char* home; char* home;
struct passwd* pwd; struct passwd* pwd;
@ -90,14 +91,14 @@ void get_absolute_config_dir( char* source, char* dest ) {
strcat( dest, "/" ); strcat( dest, "/" );
} }
static inline void normalize_filenames( void ) { static inline void normalize_filenames( void )
{
struct stat st; struct stat st;
int normalized_config_path_exist = 1; int normalized_config_path_exist = 1;
get_absolute_config_dir( configDir, normalized_config_path ); get_absolute_config_dir( configDir, normalized_config_path );
if ( verbose ) if ( verbose )
fprintf( stderr, "normalized_config_path: %s\n", fprintf( stderr, "normalized_config_path: %s\n", normalized_config_path );
normalized_config_path );
if ( stat( normalized_config_path, &st ) == -1 ) if ( stat( normalized_config_path, &st ) == -1 )
if ( errno == ENOENT ) if ( errno == ENOENT )
@ -141,7 +142,8 @@ static inline void normalize_filenames( void ) {
strcat( normalized_port2_path, port2FileName ); strcat( normalized_port2_path, port2FileName );
} }
int parse_args( int argc, char* argv[] ) { int parse_args( int argc, char* argv[] )
{
int option_index; int option_index;
int c = '?'; int c = '?';
@ -187,10 +189,10 @@ int parse_args( int argc, char* argv[] ) {
{ "tui", no_argument, &frontend_type, FRONTEND_TEXT}, { "tui", no_argument, &frontend_type, FRONTEND_TEXT},
{ 0, 0, 0, 0 } }; { 0, 0, 0, 0 }
};
char* help_text = char* help_text = "usage: %s [options]\n"
"usage: %s [options]\n"
"options:\n" "options:\n"
"\t-h --help\t\t\twhat you are reading\n" "\t-h --help\t\t\twhat you are reading\n"
"\t-v --version\t\t\tshow version\n" "\t-v --version\t\t\tshow version\n"
@ -250,13 +252,11 @@ int parse_args( int argc, char* argv[] ) {
switch ( c ) { switch ( c ) {
case 'h': case 'h':
fprintf( stdout, help_text, progname, serialLine, smallFont, fprintf( stdout, help_text, progname, serialLine, smallFont, mediumFont, largeFont, connFont );
mediumFont, largeFont, connFont );
exit( 0 ); exit( 0 );
break; break;
case 'v': case 'v':
fprintf( stdout, "%s %d.%d.%d\n", progname, VERSION_MAJOR, fprintf( stdout, "%s %d.%d.%d\n", progname, VERSION_MAJOR, VERSION_MINOR, PATCHLEVEL );
VERSION_MINOR, PATCHLEVEL );
exit( 0 ); exit( 0 );
break; break;
case 1000: case 1000:
@ -390,16 +390,12 @@ int parse_args( int argc, char* argv[] ) {
fprintf( stderr, "largeFont = %s\n", largeFont ); fprintf( stderr, "largeFont = %s\n", largeFont );
fprintf( stderr, "connFont = %s\n", connFont ); fprintf( stderr, "connFont = %s\n", connFont );
fprintf( stderr, "normalized_config_path = %s\n", fprintf( stderr, "normalized_config_path = %s\n", normalized_config_path );
normalized_config_path );
fprintf( stderr, "normalized_rom_path = %s\n", normalized_rom_path ); fprintf( stderr, "normalized_rom_path = %s\n", normalized_rom_path );
fprintf( stderr, "normalized_ram_path = %s\n", normalized_ram_path ); fprintf( stderr, "normalized_ram_path = %s\n", normalized_ram_path );
fprintf( stderr, "normalized_state_path = %s\n", fprintf( stderr, "normalized_state_path = %s\n", normalized_state_path );
normalized_state_path ); fprintf( stderr, "normalized_port1_path = %s\n", normalized_port1_path );
fprintf( stderr, "normalized_port1_path = %s\n", fprintf( stderr, "normalized_port2_path = %s\n", normalized_port2_path );
normalized_port1_path );
fprintf( stderr, "normalized_port2_path = %s\n",
normalized_port2_path );
} }
return ( optind ); return ( optind );

11
src/tools/checkrom.c
View file

@ -1,7 +1,7 @@
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <unistd.h>
#include <sys/stat.h> #include <sys/stat.h>
#include <unistd.h>
#include "romio.h" #include "romio.h"
@ -10,10 +10,10 @@ unsigned short rom_crc, crc;
int verbose = 0; int verbose = 0;
#define calc_crc( n ) \ #define calc_crc( n ) ( crc = ( ( crc >> 4 ) ^ ( ( ( crc ^ n ) & 0xf ) * 0x1081 ) ) )
( 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;
@ -25,8 +25,7 @@ int main( int argc, char** argv ) {
} }
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 ], fprintf( stderr, "%s: can\'t read ROM from %s\n", argv[ 0 ], argv[ 1 ] );
argv[ 1 ] );
exit( 1 ); exit( 1 );
} }

26
src/tools/dump2rom.c
View file

@ -1,14 +1,15 @@
#include <fcntl.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <unistd.h> #include <unistd.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, size_t size ) { int write_mem_file( char* name, unsigned char* mem, size_t size )
{
FILE* fp; FILE* fp;
unsigned char* tmp_mem; unsigned char* tmp_mem;
unsigned char byte; unsigned char byte;
@ -49,7 +50,8 @@ int write_mem_file( char* name, unsigned char* mem, size_t size ) {
return 1; return 1;
} }
int main( int argc, char** argv ) { int main( int argc, char** argv )
{
FILE* dump; FILE* dump;
long addr; long addr;
size_t size; size_t size;
@ -86,8 +88,7 @@ int main( int argc, char** argv ) {
} 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, fprintf( stderr, "%s: Illegal char %c at %lx\n", argv[ 0 ], ch, addr );
addr );
error = 1; error = 1;
break; break;
} }
@ -101,14 +102,12 @@ int main( int argc, char** argv ) {
break; break;
} }
if ( ch != ':' ) { if ( ch != ':' ) {
fprintf( stderr, "%s: Illegal char %c, expected \':\' at %lx\n", fprintf( stderr, "%s: Illegal char %c, expected \':\' at %lx\n", argv[ 0 ], 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 ], fprintf( stderr, "%s: Unexpected EOF at %lx\n", argv[ 0 ], addr );
addr );
error = 1; error = 1;
break; break;
} }
@ -117,8 +116,7 @@ int main( int argc, char** argv ) {
} else if ( ch >= 'A' && ch <= 'F' ) { } else if ( ch >= 'A' && ch <= 'F' ) {
core[ addr++ ] = ( unsigned char )( ch - 'A' + 10 ); core[ addr++ ] = ( unsigned char )( ch - 'A' + 10 );
} else { } else {
fprintf( stderr, "%s: Illegal char %c at %lx\n", argv[ 0 ], ch, fprintf( stderr, "%s: Illegal char %c at %lx\n", argv[ 0 ], ch, addr );
addr );
error = 1; error = 1;
break; break;
} }
@ -128,8 +126,7 @@ int main( int argc, char** argv ) {
if ( ( ch = fgetc( dump ) ) < 0 ) if ( ( ch = fgetc( dump ) ) < 0 )
break; break;
if ( ch != '\n' ) { if ( ch != '\n' ) {
fprintf( stderr, "%s: Illegal char %c, expected \'\\n\' at %lx\n", fprintf( stderr, "%s: Illegal char %c, expected \'\\n\' at %lx\n", argv[ 0 ], ch, addr );
argv[ 0 ], ch, addr );
break; break;
} }
} }
@ -142,8 +139,7 @@ int main( int argc, char** argv ) {
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 ], fprintf( stderr, "%s: can\'t write to %s\n", argv[ 0 ], DEFAULT_ROM_FILE );
DEFAULT_ROM_FILE );
exit( 1 ); exit( 1 );
} }

14
src/tools/mkcard.c
View file

@ -1,12 +1,13 @@
#include <fcntl.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <unistd.h> #include <unistd.h>
#include <fcntl.h>
unsigned char* mem; unsigned char* mem;
int write_mem_file( char* name, unsigned char* mem, size_t size ) { int write_mem_file( char* name, unsigned char* mem, size_t size )
{
FILE* fp; FILE* fp;
if ( NULL == ( fp = fopen( name, "w" ) ) ) { if ( NULL == ( fp = fopen( name, "w" ) ) ) {
@ -24,15 +25,15 @@ int write_mem_file( char* name, unsigned char* mem, size_t size ) {
return 1; return 1;
} }
int main( int argc, char** argv ) { int main( int argc, char** argv )
{
size_t size; size_t 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 );
} }
@ -53,8 +54,7 @@ int main( int argc, char** argv ) {
else if ( !strcmp( asize, "4M" ) ) else if ( !strcmp( asize, "4M" ) )
size = 0x400000; size = 0x400000;
else { else {
fprintf( stderr, fprintf( stderr, "size must be one of 32K, 128K, 256K, 512K, 1M, 2M, or 4M\n" );
"size must be one of 32K, 128K, 256K, 512K, 1M, 2M, or 4M\n" );
exit( 1 ); exit( 1 );
} }

14
src/ui.c
View file

@ -1,7 +1,7 @@
#include <stdio.h> #include <stdio.h>
#include "ui.h"
#include "runtime_options.h" #include "runtime_options.h"
#include "ui.h"
#include "ui_inner.h" #include "ui_inner.h"
int last_annunc_state = -1; int last_annunc_state = -1;
@ -137,7 +137,8 @@ letter_t small_font[ 128 ] = {
{ 0, 0, 0 }, { 0, 0, 0 },
{ rcurly_width, rcurly_height, rcurly_bitmap }, { rcurly_width, rcurly_height, rcurly_bitmap },
{ 0, 0, 0 }, { 0, 0, 0 },
{ 0, 0, 0 } }; { 0, 0, 0 }
};
void ( *ui_disp_draw_nibble )( word_20 addr, word_4 val ); void ( *ui_disp_draw_nibble )( word_20 addr, word_4 val );
void ( *ui_menu_draw_nibble )( word_20 addr, word_4 val ); void ( *ui_menu_draw_nibble )( word_20 addr, word_4 val );
@ -149,7 +150,8 @@ void ( *ui_draw_annunc )( void );
void ( *ui_init_LCD )( void ); void ( *ui_init_LCD )( void );
void ( *init_ui )( int argc, char** argv ); void ( *init_ui )( int argc, char** argv );
void setup_frontend( void ) { void setup_frontend( void )
{
switch ( frontend_type ) { switch ( frontend_type ) {
case FRONTEND_X11: case FRONTEND_X11:
default: default:
@ -190,7 +192,8 @@ void setup_frontend( void ) {
} }
} }
int SmallTextWidth( const char* string, unsigned int length ) { int SmallTextWidth( const char* string, unsigned int length )
{
unsigned int i; unsigned int i;
int w; int w;
@ -200,8 +203,7 @@ int SmallTextWidth( const char* string, unsigned int length ) {
w += small_font[ ( int )string[ i ] ].w + 1; w += small_font[ ( int )string[ i ] ].w + 1;
} else { } else {
if ( verbose ) if ( verbose )
fprintf( stderr, "Unknown small letter 0x00%x\n", fprintf( stderr, "Unknown small letter 0x00%x\n", ( int )string[ i ] );
( int )string[ i ] );
w += 5; w += 5;
} }
} }

404
src/ui_inner.h
View file

@ -103,119 +103,83 @@
#define hp_width 96 #define hp_width 96
#define hp_height 24 #define hp_height 24
static unsigned char hp_bitmap[] = { static unsigned char hp_bitmap[] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 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, 0x9f, 0xfd, 0x3f, 0x60, 0xcc, 0x6f, 0x66, 0x83, 0xdf, 0xff, 0x3f, 0xfc, 0x9f, 0xf1, 0x7f, 0x60, 0xcc,
0xf8, 0x9f, 0xfd, 0x3f, 0x60, 0xcc, 0x6f, 0x66, 0x83, 0xdf, 0xff, 0x3f, 0x60, 0x66, 0x83, 0x01, 0x06, 0x06, 0xfc, 0xc7, 0xc0, 0x7f, 0x60, 0xcc, 0x60, 0x66, 0x83, 0x01, 0x06, 0x06, 0xfc, 0xc3, 0x80,
0xfc, 0x9f, 0xf1, 0x7f, 0x60, 0xcc, 0x60, 0x66, 0x83, 0x01, 0x06, 0x06, 0x7f, 0x60, 0xcc, 0x40, 0x26, 0x83, 0x01, 0x06, 0x06, 0xfc, 0x61, 0x00, 0x7f, 0xe0, 0xcf, 0xcf, 0x36, 0x83, 0x1f, 0x06, 0x06,
0xfc, 0xc7, 0xc0, 0x7f, 0x60, 0xcc, 0x60, 0x66, 0x83, 0x01, 0x06, 0x06, 0xfc, 0x60, 0x00, 0x7e, 0x60, 0xcc, 0xc0, 0x36, 0x83, 0x01, 0x06, 0x06, 0xfc, 0x30, 0x00, 0x7e, 0x60, 0xcc, 0x80, 0x19, 0x83,
0xfc, 0xc3, 0x80, 0x7f, 0x60, 0xcc, 0x40, 0x26, 0x83, 0x01, 0x06, 0x06, 0x01, 0x06, 0x06, 0x7c, 0xb0, 0x68, 0x7c, 0x60, 0xcc, 0x80, 0x19, 0x83, 0x01, 0x06, 0x06, 0x7c, 0xf8, 0xf9, 0x7c, 0x60, 0xcc,
0xfc, 0x61, 0x00, 0x7f, 0xe0, 0xcf, 0xcf, 0x36, 0x83, 0x1f, 0x06, 0x06, 0x8f, 0x19, 0xbf, 0x1f, 0x06, 0x06, 0x7c, 0x98, 0xcd, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xcc, 0xcc,
0xfc, 0x60, 0x00, 0x7e, 0x60, 0xcc, 0xc0, 0x36, 0x83, 0x01, 0x06, 0x06, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xcc, 0x66, 0x7c, 0xe0, 0x87, 0x81, 0x67, 0x0c, 0xc3, 0xcf, 0x0f,
0xfc, 0x30, 0x00, 0x7e, 0x60, 0xcc, 0x80, 0x19, 0x83, 0x01, 0x06, 0x06, 0x7c, 0x66, 0x66, 0x7c, 0x60, 0xcc, 0xc3, 0x6c, 0x86, 0xc7, 0xd8, 0x18, 0x7c, 0x66, 0x3f, 0x7e, 0x60, 0x4c, 0x62, 0x60, 0x83,
0x7c, 0xb0, 0x68, 0x7c, 0x60, 0xcc, 0x80, 0x19, 0x83, 0x01, 0x06, 0x06, 0xc4, 0xd8, 0x30, 0xfc, 0x00, 0x03, 0x7e, 0x60, 0x6c, 0x66, 0xe0, 0xc1, 0xcc, 0xd8, 0x30, 0xfc, 0x80, 0x01, 0x7f, 0xe0, 0x67,
0x7c, 0xf8, 0xf9, 0x7c, 0x60, 0xcc, 0x8f, 0x19, 0xbf, 0x1f, 0x06, 0x06, 0x66, 0xe0, 0xc1, 0xcc, 0xcf, 0x30, 0xfc, 0x81, 0x81, 0x7f, 0x60, 0xe0, 0x67, 0x60, 0xc3, 0xcf, 0xcc, 0x30, 0xfc, 0xc3, 0xc0,
0x7c, 0x98, 0xcd, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7f, 0x60, 0x30, 0x6c, 0x60, 0x66, 0xd8, 0xd8, 0x30, 0xfc, 0xcf, 0xf0, 0x7f, 0x60, 0x30, 0xcc, 0x6c, 0x6c, 0xd8, 0xd8, 0x18,
0x7c, 0xcc, 0xcc, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x6f, 0xfe, 0x3f, 0x60, 0x30, 0x8c, 0x67, 0x78, 0xd8, 0xd8, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x7c, 0xcc, 0x66, 0x7c, 0xe0, 0x87, 0x81, 0x67, 0x0c, 0xc3, 0xcf, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
0x7c, 0x66, 0x66, 0x7c, 0x60, 0xcc, 0xc3, 0x6c, 0x86, 0xc7, 0xd8, 0x18,
0x7c, 0x66, 0x3f, 0x7e, 0x60, 0x4c, 0x62, 0x60, 0x83, 0xc4, 0xd8, 0x30,
0xfc, 0x00, 0x03, 0x7e, 0x60, 0x6c, 0x66, 0xe0, 0xc1, 0xcc, 0xd8, 0x30,
0xfc, 0x80, 0x01, 0x7f, 0xe0, 0x67, 0x66, 0xe0, 0xc1, 0xcc, 0xcf, 0x30,
0xfc, 0x81, 0x81, 0x7f, 0x60, 0xe0, 0x67, 0x60, 0xc3, 0xcf, 0xcc, 0x30,
0xfc, 0xc3, 0xc0, 0x7f, 0x60, 0x30, 0x6c, 0x60, 0x66, 0xd8, 0xd8, 0x30,
0xfc, 0xcf, 0xf0, 0x7f, 0x60, 0x30, 0xcc, 0x6c, 0x6c, 0xd8, 0xd8, 0x18,
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 };
#define hp48sx_width 42 #define hp48sx_width 42
#define hp48sx_height 10 #define hp48sx_height 10
static unsigned char hp48sx_bitmap[] = { static unsigned char hp48sx_bitmap[] = { 0xe0, 0xf1, 0xc3, 0x3f, 0x87, 0x03, 0xf0, 0xf9, 0xe7, 0x7f, 0xc7, 0x01, 0xf8, 0x39, 0xe7,
0xe0, 0xf1, 0xc3, 0x3f, 0x87, 0x03, 0xf0, 0xf9, 0xe7, 0x7f, 0xc7, 0x01, 0x70, 0xee, 0x00, 0xdc, 0x39, 0xe7, 0x00, 0x7e, 0x00, 0xee, 0xf0, 0xe3, 0x0f, 0x3c, 0x00,
0xf8, 0x39, 0xe7, 0x70, 0xee, 0x00, 0xdc, 0x39, 0xe7, 0x00, 0x7e, 0x00, 0xe7, 0xf8, 0xc1, 0x1f, 0x1c, 0x00, 0xff, 0x9d, 0x03, 0x1c, 0x3e, 0x00, 0xff, 0x9d, 0x3b,
0xee, 0xf0, 0xe3, 0x0f, 0x3c, 0x00, 0xe7, 0xf8, 0xc1, 0x1f, 0x1c, 0x00, 0x1c, 0x3f, 0x00, 0x70, 0xfc, 0xfb, 0x9f, 0x73, 0x00, 0x70, 0xf8, 0xf1, 0xcf, 0x71, 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 };
#define hp48gx_width 44 #define hp48gx_width 44
#define hp48gx_height 14 #define hp48gx_height 14
static unsigned char hp48gx_bitmap[] = { static unsigned char hp48gx_bitmap[] = {
0x00, 0xc3, 0x03, 0x7c, 0x0c, 0x0c, 0x80, 0xe3, 0x07, 0xff, 0x0c, 0x0e, 0x00, 0xc3, 0x03, 0x7c, 0x0c, 0x0c, 0x80, 0xe3, 0x07, 0xff, 0x0c, 0x0e, 0xc0, 0x33, 0x86, 0xc3, 0x1c, 0x06, 0xe0, 0x31, 0xc6,
0xc0, 0x33, 0x86, 0xc3, 0x1c, 0x06, 0xe0, 0x31, 0xc6, 0xc0, 0x18, 0x03, 0xc0, 0x18, 0x03, 0xb0, 0x31, 0xe6, 0x00, 0xb0, 0x01, 0x98, 0x31, 0x63, 0x00, 0xf0, 0x01, 0x8c, 0xe1, 0x61, 0x00, 0xe0, 0x00,
0xb0, 0x31, 0xe6, 0x00, 0xb0, 0x01, 0x98, 0x31, 0x63, 0x00, 0xf0, 0x01, 0xc6, 0xb8, 0x31, 0xfc, 0x70, 0x00, 0xc7, 0x18, 0x33, 0xfc, 0xf8, 0x00, 0xff, 0x0d, 0x33, 0x60, 0xd8, 0x00, 0xff, 0x0d, 0x73,
0x8c, 0xe1, 0x61, 0x00, 0xe0, 0x00, 0xc6, 0xb8, 0x31, 0xfc, 0x70, 0x00, 0x60, 0x8c, 0x01, 0x60, 0x8c, 0x63, 0x30, 0x86, 0x03, 0x60, 0xfc, 0xe1, 0x3f, 0x07, 0x03, 0x60, 0xf8, 0x80, 0x37, 0x03, 0x03 };
0xc7, 0x18, 0x33, 0xfc, 0xf8, 0x00, 0xff, 0x0d, 0x33, 0x60, 0xd8, 0x00,
0xff, 0x0d, 0x73, 0x60, 0x8c, 0x01, 0x60, 0x8c, 0x63, 0x30, 0x86, 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
static unsigned char science_bitmap[] = { static unsigned char science_bitmap[] = {
0x38, 0x1c, 0xf2, 0x09, 0x7d, 0x79, 0xe2, 0x80, 0x2f, 0xe4, 0x41, 0x08, 0x38, 0x1c, 0xf2, 0x09, 0x7d, 0x79, 0xe2, 0x80, 0x2f, 0xe4, 0x41, 0x08, 0x79, 0x20, 0x3c, 0xc2, 0x07, 0x44, 0x22, 0x12,
0x79, 0x20, 0x3c, 0xc2, 0x07, 0x44, 0x22, 0x12, 0x08, 0x11, 0x09, 0x12, 0x08, 0x11, 0x09, 0x12, 0x81, 0x20, 0x22, 0x62, 0x08, 0x89, 0x30, 0x44, 0x42, 0x00, 0x02, 0x01, 0x09, 0x94, 0x88, 0x04,
0x81, 0x20, 0x22, 0x62, 0x08, 0x89, 0x30, 0x44, 0x42, 0x00, 0x02, 0x01, 0x09, 0x40, 0x40, 0x11, 0x52, 0x94, 0x88, 0x28, 0x42, 0x21, 0x00, 0x1c, 0x01, 0xf9, 0x94, 0x88, 0x3c, 0x09, 0xc0, 0xc7,
0x09, 0x94, 0x88, 0x04, 0x09, 0x40, 0x40, 0x11, 0x52, 0x94, 0x88, 0x28, 0xf0, 0x51, 0x94, 0x84, 0x28, 0x3e, 0xe1, 0x03, 0xa0, 0x00, 0x09, 0x94, 0x88, 0x04, 0x05, 0x40, 0xc0, 0x10, 0x48, 0x94,
0x42, 0x21, 0x00, 0x1c, 0x01, 0xf9, 0x94, 0x88, 0x3c, 0x09, 0xc0, 0xc7, 0x44, 0x24, 0x22, 0x21, 0x00, 0xa1, 0xa0, 0x04, 0xa2, 0x44, 0x82, 0x04, 0x21, 0xa0, 0x08, 0xfc, 0xa2, 0x42, 0x7e, 0xa1,
0xf0, 0x51, 0x94, 0x84, 0x28, 0x3e, 0xe1, 0x03, 0xa0, 0x00, 0x09, 0x94, 0x10, 0x00, 0x91, 0x90, 0x04, 0x42, 0x44, 0x82, 0x84, 0x20, 0x10, 0x09, 0x84, 0x42, 0x22, 0x42, 0xb1, 0x10, 0x00, 0x0e,
0x88, 0x04, 0x05, 0x40, 0xc0, 0x10, 0x48, 0x94, 0x44, 0x24, 0x22, 0x21, 0x8f, 0x7c, 0x42, 0x44, 0x82, 0x78, 0xe0, 0x0b, 0x09, 0x82, 0x42, 0x1e, 0x41, 0x9f, 0xf7, 0x01 };
0x00, 0xa1, 0xa0, 0x04, 0xa2, 0x44, 0x82, 0x04, 0x21, 0xa0, 0x08, 0xfc,
0xa2, 0x42, 0x7e, 0xa1, 0x10, 0x00, 0x91, 0x90, 0x04, 0x42, 0x44, 0x82,
0x84, 0x20, 0x10, 0x09, 0x84, 0x42, 0x22, 0x42, 0xb1, 0x10, 0x00, 0x0e,
0x8f, 0x7c, 0x42, 0x44, 0x82, 0x78, 0xe0, 0x0b, 0x09, 0x82, 0x42, 0x1e,
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
#define gx_128K_ram_width 43 #define gx_128K_ram_width 43
#define gx_128K_ram_height 31 #define gx_128K_ram_height 31
static unsigned char gx_128K_ram_bitmap[] = { static unsigned char gx_128K_ram_bitmap[] = {
0xfe, 0xdf, 0xff, 0xff, 0x03, 0x00, 0xfe, 0xdf, 0xff, 0xff, 0x03, 0x00, 0xfe, 0xdf, 0xff, 0xff, 0x03, 0x00, 0xfe, 0xdf, 0xff, 0xff, 0x03, 0x00, 0xfe, 0xdf, 0xff, 0xff, 0x03, 0x00, 0xe2, 0xdf, 0xff,
0xfe, 0xdf, 0xff, 0xff, 0x03, 0x00, 0xe2, 0xdf, 0xff, 0xff, 0x03, 0x00, 0xff, 0x03, 0x00, 0x9c, 0xdf, 0xff, 0xff, 0x03, 0x00, 0x7e, 0xdf, 0xff, 0xff, 0x01, 0x00, 0x7e, 0xdf, 0xff, 0xff, 0x01, 0x00,
0x9c, 0xdf, 0xff, 0xff, 0x03, 0x00, 0x7e, 0xdf, 0xff, 0xff, 0x01, 0x00, 0xfe, 0xde, 0xff, 0xff, 0x02, 0x00, 0xfe, 0xde, 0xff, 0xff, 0x02, 0x00, 0xfe, 0xdd, 0xff, 0x7f, 0x03, 0x00, 0x00, 0x00, 0x00,
0x7e, 0xdf, 0xff, 0xff, 0x01, 0x00, 0xfe, 0xde, 0xff, 0xff, 0x02, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xdd, 0xff, 0xbf, 0x03, 0x00, 0xfe, 0xdb, 0xff, 0xdf, 0x03, 0x00, 0xfe, 0xdb, 0xff, 0xef, 0x03, 0x00,
0xfe, 0xde, 0xff, 0xff, 0x02, 0x00, 0xfe, 0xdd, 0xff, 0x7f, 0x03, 0x00, 0xfe, 0xd7, 0xff, 0xf7, 0x03, 0x00, 0xfe, 0xcf, 0xff, 0xfb, 0x03, 0x00, 0xfe, 0xcf, 0xff, 0xfc, 0x03, 0x00, 0xfe, 0x1f, 0x3f,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xdd, 0xff, 0xbf, 0x03, 0x00, 0xff, 0x03, 0x00, 0xfe, 0xdf, 0xc0, 0xff, 0x03, 0x00, 0xfe, 0xdf, 0xff, 0xff, 0x03, 0x00, 0xfe, 0xdf, 0xff, 0xff, 0x03, 0x00,
0xfe, 0xdb, 0xff, 0xdf, 0x03, 0x00, 0xfe, 0xdb, 0xff, 0xef, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xfe, 0xd7, 0xff, 0xf7, 0x03, 0x00, 0xfe, 0xcf, 0xff, 0xfb, 0x03, 0x00, 0x00, 0x00, 0x00, 0xc4, 0x30, 0x12, 0x1c, 0x44, 0x04, 0x27, 0x49, 0x0a, 0x24, 0x46, 0x04, 0x84, 0x39, 0x06, 0x24, 0xc9, 0x06,
0xfe, 0xcf, 0xff, 0xfc, 0x03, 0x00, 0xfe, 0x1f, 0x3f, 0xff, 0x03, 0x00, 0x62, 0x24, 0x07, 0x9e, 0xaf, 0x06, 0x12, 0x24, 0x09, 0x92, 0xa8, 0x05, 0xf2, 0x18, 0x11, 0x52, 0x28, 0x05 };
0xfe, 0xdf, 0xc0, 0xff, 0x03, 0x00, 0xfe, 0xdf, 0xff, 0xff, 0x03, 0x00,
0xfe, 0xdf, 0xff, 0xff, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc4, 0x30, 0x12, 0x1c, 0x44, 0x04,
0x27, 0x49, 0x0a, 0x24, 0x46, 0x04, 0x84, 0x39, 0x06, 0x24, 0xc9, 0x06,
0x62, 0x24, 0x07, 0x9e, 0xaf, 0x06, 0x12, 0x24, 0x09, 0x92, 0xa8, 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
#define gx_silver_width 35 #define gx_silver_width 35
#define gx_silver_height 21 #define gx_silver_height 21
static unsigned char gx_silver_bitmap[] = { static unsigned char gx_silver_bitmap[] = {
0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x38, 0x40, 0x00, 0x00, 0x00, 0xc4,
0x00, 0x00, 0x00, 0x38, 0x40, 0x00, 0x00, 0x00, 0xc4, 0x40, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x02, 0x41, 0x00, 0x00, 0x04, 0x02, 0x41, 0x00, 0x00, 0x04, 0x02, 0x42, 0x00, 0x00, 0x02, 0x01, 0x42,
0x00, 0x02, 0x41, 0x00, 0x00, 0x04, 0x02, 0x41, 0x00, 0x00, 0x04, 0x02, 0x00, 0x00, 0x02, 0x01, 0x44, 0x00, 0x00, 0x01, 0xfd, 0xff, 0xff, 0xff, 0x07, 0x01, 0x44, 0x00, 0x80, 0x00, 0x01, 0x48, 0x00,
0x42, 0x00, 0x00, 0x02, 0x01, 0x42, 0x00, 0x00, 0x02, 0x01, 0x44, 0x00, 0x40, 0x00, 0x01, 0x48, 0x00, 0x20, 0x00, 0x00, 0x50, 0x00, 0x10, 0x00, 0x00, 0x60, 0x00, 0x08, 0x00, 0x00, 0x60, 0x00, 0x06,
0x00, 0x01, 0xfd, 0xff, 0xff, 0xff, 0x07, 0x01, 0x44, 0x00, 0x80, 0x00, 0x00, 0x00, 0xc0, 0x81, 0x01, 0x00, 0x00, 0x40, 0x7e, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00 };
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, 0x00, 0xc0, 0x81, 0x01, 0x00, 0x00, 0x40, 0x7e, 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_bitmap[] = { static unsigned char gx_green_bitmap[] = {
0xff, 0xff, 0xff, 0xff, 0x03, 0xff, 0xff, 0xff, 0xff, 0x03, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0xff, 0xff, 0xff, 0xff, 0x03, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff,
0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x00, 0xfc,
0xff, 0xff, 0x03, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0xf0, 0x03, 0x00, 0x00, 0x00, 0xf0, 0x03, 0x00, 0x00, 0x00, 0xf0, 0x03, 0x00, 0x00, 0x00, 0xf0, 0x03, 0x00,
0xfc, 0x03, 0x00, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x00, 0xfc, 0x00, 0x00, 0xf0, 0x03, 0x00, 0x00, 0x00, 0xf0, 0x03, 0x00, 0x00, 0x00, 0xf0, 0x03, 0x00, 0x00, 0x00, 0xf0, 0x03, 0x00, 0x00, 0x00,
0x03, 0x00, 0x00, 0x00, 0xf0, 0x03, 0x00, 0x00, 0x00, 0xf0, 0x03, 0xf0, 0x03, 0x00, 0x00, 0x00, 0xf0, 0x03, 0x00, 0x00, 0x00, 0xf0, 0x03, 0x00, 0x00, 0x00, 0xf0, 0x03, 0x00, 0x00, 0x00, 0xf0, 0x03 };
0x00, 0x00, 0x00, 0xf0, 0x03, 0x00, 0x00, 0x00, 0xf0, 0x03, 0x00,
0x00, 0x00, 0xf0, 0x03, 0x00, 0x00, 0x00, 0xf0, 0x03, 0x00, 0x00,
0x00, 0xf0, 0x03, 0x00, 0x00, 0x00, 0xf0, 0x03, 0x00, 0x00, 0x00,
0xf0, 0x03, 0x00, 0x00, 0x00, 0xf0, 0x03, 0x00, 0x00, 0x00, 0xf0,
0x03, 0x00, 0x00, 0x00, 0xf0, 0x03, 0x00, 0x00, 0x00, 0xf0, 0x03 };
/* #endif /\* !_HP_H *\/ */ /* #endif /\* !_HP_H *\/ */
@ -224,38 +188,32 @@ static unsigned char gx_green_bitmap[] = {
#define ann_alpha_width 15 #define ann_alpha_width 15
#define ann_alpha_height 12 #define ann_alpha_height 12
static unsigned char ann_alpha_bitmap[] = { static unsigned char ann_alpha_bitmap[] = { 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_bitmap[] = { static unsigned char ann_battery_bitmap[] = { 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_bitmap[] = { static unsigned char ann_busy_bitmap[] = { 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_bitmap[] = { static unsigned char ann_io_bitmap[] = { 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_bitmap[] = { static unsigned char ann_left_bitmap[] = { 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_bitmap[] = { static unsigned char ann_right_bitmap[] = { 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 *\/ */
@ -265,134 +223,107 @@ static unsigned char ann_right_bitmap[] = {
#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_bitmap[] = { static unsigned char menu_label_bitmap[] = { 0xfe, 0xff, 0x7f, 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, 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_bitmap[] = { static unsigned char up_bitmap[] = { 0x20, 0x00, 0x20, 0x00, 0x70, 0x00, 0x70, 0x00, 0xf8, 0x00, 0xf8,
0x20, 0x00, 0x20, 0x00, 0x70, 0x00, 0x70, 0x00, 0xf8, 0x00, 0xf8,
0x00, 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_bitmap[] = { static unsigned char down_bitmap[] = { 0xff, 0x07, 0xfe, 0x03, 0xfe, 0x03, 0xfc, 0x01, 0xfc, 0x01, 0xf8,
0xff, 0x07, 0xfe, 0x03, 0xfe, 0x03, 0xfc, 0x01, 0xfc, 0x01, 0xf8,
0x00, 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_bitmap[] = { static unsigned char left_bitmap[] = { 0x00, 0x04, 0x00, 0x07, 0xc0, 0x07, 0xf0, 0x07, 0xfc, 0x07, 0xff,
0x00, 0x04, 0x00, 0x07, 0xc0, 0x07, 0xf0, 0x07, 0xfc, 0x07, 0xff,
0x07, 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_bitmap[] = { static unsigned char right_bitmap[] = { 0x01, 0x00, 0x07, 0x00, 0x1f, 0x00, 0x7f, 0x00, 0xff, 0x01, 0xff,
0x01, 0x00, 0x07, 0x00, 0x1f, 0x00, 0x7f, 0x00, 0xff, 0x01, 0xff,
0x07, 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_bitmap[] = { static unsigned char sqrt_bitmap[] = { 0x00, 0xff, 0x0f, 0x00, 0x01, 0x08, 0x00, 0x01, 0x08, 0x80, 0x8c, 0x01, 0x80, 0x58, 0x01, 0x80, 0x38,
0x00, 0xff, 0x0f, 0x00, 0x01, 0x08, 0x00, 0x01, 0x08, 0x80, 0x8c, 0x00, 0x47, 0x30, 0x00, 0x4c, 0x30, 0x00, 0x58, 0x78, 0x00, 0x30, 0x6a, 0x01, 0x20, 0xc6, 0x00 };
0x01, 0x80, 0x58, 0x01, 0x80, 0x38, 0x00, 0x47, 0x30, 0x00, 0x4c,
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_bitmap[] = { static unsigned char power_bitmap[] = { 0x00, 0x8c, 0x01, 0x00, 0x58, 0x01, 0x00, 0x38, 0x00, 0xc8, 0x30, 0x00, 0x9c, 0x30,
0x00, 0x8c, 0x01, 0x00, 0x58, 0x01, 0x00, 0x38, 0x00, 0xc8, 0x30, 0x00, 0x98, 0x78, 0x00, 0x58, 0x6a, 0x01, 0x58, 0xc6, 0x00, 0x38, 0x00, 0x00, 0x30,
0x00, 0x9c, 0x30, 0x00, 0x98, 0x78, 0x00, 0x58, 0x6a, 0x01, 0x58, 0x00, 0x00, 0x10, 0x00, 0x00, 0x08, 0x00, 0x00, 0x05, 0x00, 0x00, 0x03, 0x00, 0x00 };
0xc6, 0x00, 0x38, 0x00, 0x00, 0x30, 0x00, 0x00, 0x10, 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_bitmap[] = { static unsigned char inv_bitmap[] = { 0x0c, 0x04, 0x00, 0x0f, 0x06, 0x00, 0x0c, 0x02, 0x00, 0x0c, 0x03, 0x00, 0x0c,
0x0c, 0x04, 0x00, 0x0f, 0x06, 0x00, 0x0c, 0x02, 0x00, 0x0c, 0x01, 0x00, 0x8c, 0x19, 0x03, 0x8c, 0xb0, 0x02, 0xcc, 0x70, 0x00, 0x40, 0x60,
0x03, 0x00, 0x0c, 0x01, 0x00, 0x8c, 0x19, 0x03, 0x8c, 0xb0, 0x00, 0x60, 0x60, 0x00, 0x20, 0xf0, 0x00, 0x30, 0xd4, 0x02, 0x10, 0x8c, 0x01 };
0x02, 0xcc, 0x70, 0x00, 0x40, 0x60, 0x00, 0x60, 0x60, 0x00,
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_bitmap[] = { static unsigned char neg_bitmap[] = { 0x18, 0x00, 0x00, 0x18, 0x30, 0x00, 0x18, 0x30, 0x00, 0xff, 0x18, 0x00, 0xff, 0x18, 0x00, 0x18, 0x0c,
0x18, 0x00, 0x00, 0x18, 0x30, 0x00, 0x18, 0x30, 0x00, 0xff, 0x18, 0x00, 0x18, 0x0c, 0x00, 0x18, 0xc6, 0x1f, 0x00, 0xc6, 0x1f, 0x00, 0x03, 0x00, 0x00, 0x03, 0x00 };
0x00, 0xff, 0x18, 0x00, 0x18, 0x0c, 0x00, 0x18, 0x0c, 0x00, 0x18,
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_bitmap[] = { static unsigned char bs_bitmap[] = { 0x20, 0x00, 0x30, 0x00, 0x38, 0x00, 0xfc, 0x07, 0xfe, 0x07, 0xff,
0x20, 0x00, 0x30, 0x00, 0x38, 0x00, 0xfc, 0x07, 0xfe, 0x07, 0xff,
0x07, 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_bitmap[] = { static unsigned char alpha_bitmap[] = { 0x78, 0x00, 0x84, 0x08, 0x82, 0x09, 0x83, 0x05, 0x83, 0x05,
0x78, 0x00, 0x84, 0x08, 0x82, 0x09, 0x83, 0x05, 0x83, 0x05,
0x83, 0x03, 0x83, 0x01, 0x83, 0x01, 0x46, 0x09, 0x3c, 0x06 }; 0x83, 0x03, 0x83, 0x01, 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_bitmap[] = { 0x30, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, static unsigned char div_bitmap[] = { 0x30, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x03,
0x00, 0xff, 0x03, 0xff, 0x03, 0x00, 0x00, 0xff, 0x03, 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_bitmap[] = { static unsigned char shl_bitmap[] = { 0xfe, 0xff, 0x7f, 0xff, 0xfc, 0xff, 0x7f, 0xfc, 0xff, 0x3f, 0xfe, 0xff, 0x1f, 0xff,
0xfe, 0xff, 0x7f, 0xff, 0xfc, 0xff, 0x7f, 0xfc, 0xff, 0x3f, 0xfe, 0xff, 0x0f, 0x00, 0xfc, 0x07, 0x00, 0xf8, 0x0f, 0x00, 0xf0, 0x1f, 0xff, 0xf1, 0x3f,
0xff, 0x1f, 0xff, 0xff, 0x0f, 0x00, 0xfc, 0x07, 0x00, 0xf8, 0x0f, 0xfe, 0xf1, 0x7f, 0xfc, 0xf1, 0xff, 0xfc, 0xf1, 0xff, 0xff, 0xf1, 0xfe, 0xff, 0x71 };
0x00, 0xf0, 0x1f, 0xff, 0xf1, 0x3f, 0xfe, 0xf1, 0x7f, 0xfc, 0xf1,
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_bitmap[] = { 0x03, 0x03, 0x87, 0x03, 0xce, 0x01, 0xfc, static unsigned char mul_bitmap[] = { 0x03, 0x03, 0x87, 0x03, 0xce, 0x01, 0xfc, 0x00, 0x78, 0x00,
0x00, 0x78, 0x00, 0x78, 0x00, 0xfc, 0x00, 0x78, 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_bitmap[] = { static unsigned char shr_bitmap[] = { 0xfe, 0xff, 0x7f, 0xff, 0x3f, 0xff, 0xff, 0x3f, 0xfe, 0xff, 0x7f, 0xfc, 0xff, 0xff,
0xfe, 0xff, 0x7f, 0xff, 0x3f, 0xff, 0xff, 0x3f, 0xfe, 0xff, 0x7f, 0xf8, 0x3f, 0x00, 0xf0, 0x1f, 0x00, 0xe0, 0x0f, 0x00, 0xf0, 0x8f, 0xff, 0xf8, 0x8f,
0xfc, 0xff, 0xff, 0xf8, 0x3f, 0x00, 0xf0, 0x1f, 0x00, 0xe0, 0x0f, 0x7f, 0xfc, 0x8f, 0x3f, 0xfe, 0x8f, 0x3f, 0xff, 0x8f, 0xff, 0xff, 0x8e, 0xff, 0x7f };
0x00, 0xf0, 0x8f, 0xff, 0xf8, 0x8f, 0x7f, 0xfc, 0x8f, 0x3f, 0xfe,
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_bitmap[] = { static unsigned char minus_bitmap[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x03,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x03,
0xff, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; 0xff, 0x03, 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_bitmap[] = { 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, static unsigned char plus_bitmap[] = { 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0xff, 0x03,
0x00, 0xff, 0x03, 0xff, 0x03, 0x30, 0x00, 0xff, 0x03, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00 };
0x30, 0x00, 0x30, 0x00, 0x30, 0x00 };
#define colon_width 2 #define colon_width 2
#define colon_height 10 #define colon_height 10
static unsigned char colon_bitmap[] = { 0x03, 0x03, 0x03, 0x03, 0x00, static unsigned char colon_bitmap[] = { 0x03, 0x03, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
0x00, 0x00, 0x00, 0x00, 0x00 };
/* Below used only for X11 */ /* Below used only for X11 */
#define last_width 120 #define last_width 120
#define last_height 6 #define last_height 6
static unsigned char last_bitmap[] = { static unsigned char last_bitmap[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0xc6, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0xc6, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x29, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x29, 0x09, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x11, 0x49, 0x08, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x8f, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
0x11, 0x49, 0x08, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x29, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
0x00, 0x00, 0x00, 0x10, 0x8f, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0xc9, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80 };
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, 0x00, 0x00, 0x00, 0x80 };
/* #endif /\* !_BUTTONS_H *\/ */ /* #endif /\* !_BUTTONS_H *\/ */
@ -404,48 +335,39 @@ static unsigned char last_bitmap[] = {
#define blank_width 4 #define blank_width 4
#define blank_height 7 #define blank_height 7
static unsigned char blank_bitmap[] = { 0x00, 0x00, 0x00, 0x00, static unsigned char blank_bitmap[] = { 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_bitmap[] = { 0x00, 0x0a, 0x1f, 0x0a, static unsigned char hash_bitmap[] = { 0x00, 0x0a, 0x1f, 0x0a, 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_bitmap[] = { 0x04, 0x02, 0x01, 0x01, static unsigned char lbrace_bitmap[] = { 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_bitmap[] = { 0x01, 0x02, 0x04, 0x04, static unsigned char rbrace_bitmap[] = { 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_bitmap[] = { 0x00, 0x00, 0x00, 0x00, static unsigned char comma_bitmap[] = { 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_bitmap[] = { 0x04, 0x04, 0x02, 0x02, static unsigned char slash_bitmap[] = { 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_bitmap[] = { 0x0e, 0x11, 0x10, 0x08, static unsigned char two_bitmap[] = { 0x0e, 0x11, 0x10, 0x08, 0x04, 0x02, 0x1f };
0x04, 0x02, 0x1f };
#define three_width 5 #define three_width 5
#define three_height 7 #define three_height 7
static unsigned char three_bitmap[] = { 0x0e, 0x11, 0x10, 0x0c, static unsigned char three_bitmap[] = { 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_bitmap[] = { 0x00, 0x03, 0x03, 0x00, static unsigned char small_colon_bitmap[] = { 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
@ -553,81 +475,64 @@ static unsigned char Z_bitmap[] = { 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_bitmap[] = { 0x07, 0x01, 0x01, 0x01, static unsigned char lbracket_bitmap[] = { 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_bitmap[] = { 0x07, 0x04, 0x04, 0x04, static unsigned char rbracket_bitmap[] = { 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_bitmap[] = { 0x00, 0x08, 0x18, 0x3f, static unsigned char arrow_bitmap[] = { 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_bitmap[] = { 0x0e, 0x10, 0x10, 0x1e, static unsigned char diff_bitmap[] = { 0x0e, 0x10, 0x10, 0x1e, 0x11, 0x11, 0x0e };
0x11, 0x11, 0x0e };
#define integral_width 5 #define integral_width 5
#define integral_height 8 #define integral_height 8
static unsigned char integral_bitmap[] = { 0x0c, 0x12, 0x02, 0x04, static unsigned char integral_bitmap[] = { 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_bitmap[] = { 0x3f, 0x21, 0x02, 0x04, 0x08, static unsigned char sigma_bitmap[] = { 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_bitmap[] = { 0x00, 0x03, 0x80, 0x04, 0x00, 0x04, 0x00, static unsigned char sqr_bitmap[] = { 0x00, 0x03, 0x80, 0x04, 0x00, 0x04, 0x00, 0x02, 0x26, 0x01,
0x02, 0x26, 0x01, 0x94, 0x07, 0x08, 0x00, 0x94, 0x07, 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_bitmap[] = { static unsigned char root_bitmap[] = { 0x26, 0x00, 0x00, 0x14, 0x00, 0x00, 0x08, 0xfe, 0x03, 0x14, 0x02, 0x02, 0x53,
0x26, 0x00, 0x00, 0x14, 0x00, 0x00, 0x08, 0xfe, 0x03, 0x14, 0x02, 0x00, 0x21, 0x99, 0x00, 0x00, 0x91, 0x00, 0x10, 0x91, 0x00, 0xa0, 0x50,
0x02, 0x02, 0x53, 0x02, 0x00, 0x21, 0x99, 0x00, 0x00, 0x91, 0x00, 0xc0, 0x60, 0x00, 0x80, 0x20, 0x00, 0x00, 0x14, 0x00, 0x00, 0x0c, 0x00 };
0x00, 0x10, 0x91, 0x00, 0xa0, 0x50, 0x00, 0xc0, 0x60, 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_bitmap[] = { 0x00, 0x12, 0x00, 0x0c, 0x32, 0x04, static unsigned char pow10_bitmap[] = { 0x00, 0x12, 0x00, 0x0c, 0x32, 0x04, 0x4b, 0x0a, 0x4a,
0x4b, 0x0a, 0x4a, 0x09, 0x4a, 0x00, 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_bitmap[] = { 0x80, 0x04, 0x00, 0x03, 0x00, 0x01, static unsigned char exp_bitmap[] = { 0x80, 0x04, 0x00, 0x03, 0x00, 0x01, 0x8c, 0x02, 0x52,
0x8c, 0x02, 0x52, 0x02, 0x09, 0x00, 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_bitmap[] = { 0x00, 0x00, 0x00, 0x00, static unsigned char under_bitmap[] = { 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_bitmap[] = { 0x48, 0x12, 0x24, 0x24, 0x12, static unsigned char prog_bitmap[] = { 0x48, 0x12, 0x24, 0x24, 0x12, 0x48, 0x09, 0x90, 0x12, 0x48, 0x24, 0x24, 0x48, 0x12 };
0x48, 0x09, 0x90, 0x12, 0x48,
0x24, 0x24, 0x48, 0x12 };
#define string_width 10 #define string_width 10
#define string_height 7 #define string_height 7
static unsigned char string_bitmap[] = { 0x85, 0x02, 0x85, 0x02, 0x85, static unsigned char string_bitmap[] = { 0x85, 0x02, 0x85, 0x02, 0x85, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
0x02, 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_bitmap[] = { 0x00, 0x1f, 0x00, 0x00, static unsigned char equal_bitmap[] = { 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
@ -639,128 +544,105 @@ static unsigned char pi_bitmap[] = { 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_bitmap[] = { 0x40, 0x20, 0x10, 0x28, static unsigned char angle_bitmap[] = { 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_bitmap[] = { 0x18, 0x04, 0x04, 0x02, static unsigned char lcurly_bitmap[] = { 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_bitmap[] = { 0x03, 0x04, 0x04, 0x08, static unsigned char rcurly_bitmap[] = { 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_bitmap[] = { static unsigned char sqr_gx_bitmap[] = { 0x00, 0x03, 0x80, 0x04, 0x00, 0x04, 0x00, 0x02, 0x00, 0x01, 0x80, 0x07, 0x00,
0x00, 0x03, 0x80, 0x04, 0x00, 0x04, 0x00, 0x02, 0x00, 0x00, 0x66, 0x00, 0x14, 0x00, 0x08, 0x00, 0x14, 0x00, 0x53, 0x00, 0x21, 0x00 };
0x01, 0x80, 0x07, 0x00, 0x00, 0x66, 0x00, 0x14, 0x00,
0x08, 0x00, 0x14, 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
static unsigned char root_gx_bitmap[] = { static unsigned char root_gx_bitmap[] = { 0x66, 0x00, 0x00, 0x14, 0x00, 0x00, 0x08, 0x00, 0x00, 0x14, 0x00, 0x00, 0x53, 0xfe, 0x03,
0x66, 0x00, 0x00, 0x14, 0x00, 0x00, 0x08, 0x00, 0x00, 0x14, 0x00, 0x00, 0x21, 0x02, 0x02, 0x00, 0x02, 0x00, 0x00, 0x99, 0x00, 0x00, 0x91, 0x00, 0x10, 0x91, 0x00,
0x53, 0xfe, 0x03, 0x21, 0x02, 0x02, 0x00, 0x02, 0x00, 0x00, 0x99, 0x00, 0xa0, 0x50, 0x00, 0xc0, 0x60, 0x00, 0x80, 0x20, 0x00, 0x00, 0x14, 0x00, 0x00, 0x0c, 0x00 };
0x00, 0x91, 0x00, 0x10, 0x91, 0x00, 0xa0, 0x50, 0x00, 0xc0, 0x60, 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_bitmap[] = { static unsigned char pow10_gx_bitmap[] = { 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_bitmap[] = { static unsigned char exp_gx_bitmap[] = { 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_bitmap[] = { static unsigned char parens_gx_bitmap[] = { 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_bitmap[] = { 0x00, 0x00, 0x48, 0x48, 0xfe, 0x24, static unsigned char hash_gx_bitmap[] = { 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_bitmap[] = { static unsigned char bracket_gx_bitmap[] = { 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_bitmap[] = { static unsigned char under_gx_bitmap[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 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_bitmap[] = { static unsigned char prog_gx_bitmap[] = { 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_bitmap[] = { static unsigned char quote_gx_bitmap[] = { 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_bitmap[] = { static unsigned char curly_gx_bitmap[] = { 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_bitmap[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0xc3, static unsigned char colon_gx_bitmap[] = { 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_bitmap[] = { static unsigned char angle_gx_bitmap[] = { 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_bitmap[] = { static unsigned char pi_gx_bitmap[] = { 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_bitmap[] = { static unsigned char nl_gx_bitmap[] = { 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_bitmap[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, static unsigned char comma_gx_bitmap[] = { 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_bitmap[] = { static unsigned char arrow_gx_bitmap[] = { 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_bitmap[] = { 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, static unsigned char equal_gx_bitmap[] = { 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00 };
0x00, 0xff, 0xff, 0x00, 0x00, 0x00 };
/*************/ /*************/
/* functions */ /* functions */

1530
src/ui_sdl.c
View file

File diff suppressed because it is too large Load diff

408
src/ui_text.c
View file

@ -1,19 +1,19 @@
#include <ctype.h>
#include <fcntl.h> #include <fcntl.h>
#include <pwd.h> #include <pwd.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <unistd.h>
#include <ctype.h>
#include <sys/stat.h> #include <sys/stat.h>
#include <sys/types.h> #include <sys/types.h>
#include <sys/utsname.h> #include <sys/utsname.h>
#include <unistd.h>
#include <ncurses.h> #include <ncurses.h>
#include "runtime_options.h"
#include "emulator.h" #include "emulator.h"
#include "romio.h" #include "romio.h"
#include "runtime_options.h"
#include "ui.h" #include "ui.h"
#include "ui_inner.h" #include "ui_inner.h"
@ -32,24 +32,24 @@ typedef struct tui_button_t {
short pressed; short pressed;
int code; int code;
int x; /* int x; */
int y; /* int y; */
unsigned int w; /* unsigned int w; */
unsigned int h; /* unsigned int h; */
int lc; /* int lc; */
const char* label; /* const char* label; */
short font_size; /* short font_size; */
unsigned int lw; /* unsigned int lw; */
unsigned int lh; /* unsigned int lh; */
unsigned char* lb; /* unsigned char* lb; */
const char* letter; /* const char* letter; */
const char* left; /* const char* left; */
short is_menu; /* short is_menu; */
const char* right; /* const char* right; */
const char* sub; /* const char* sub; */
} tui_button_t; } tui_button_t;
/*************/ /*************/
@ -62,233 +62,146 @@ static tui_ann_struct_t ann_tbl[] = {
{ ANN_BATTERY, 151, 4, 'B'}, /* '🪫' */ { ANN_BATTERY, 151, 4, 'B'}, /* '🪫' */
{ ANN_BUSY, 196, 4, '*'}, /* '⌛' */ { ANN_BUSY, 196, 4, '*'}, /* '⌛' */
{ ANN_IO, 241, 4, '^'}, /* '☃' */ { ANN_IO, 241, 4, '^'}, /* '☃' */
{ 0 } }; /* { 0 } */
};
static tui_button_t* buttons = 0; static tui_button_t* buttons = 0;
static tui_button_t buttons_sx[] = { static tui_button_t buttons_sx[] = {
{ "A", 0, 0x14, 0, 0, 36, 23, WHITE, 0, 0, menu_label_width, {"A", 0, 0x14 },
menu_label_height, menu_label_bitmap, "A", 0, 0, 0, 0 }, { "B", 0, 0x84 },
{ "B", 0, 0x84, 50, 0, 36, 23, WHITE, 0, 0, menu_label_width, { "C", 0, 0x83 },
menu_label_height, menu_label_bitmap, "B", 0, 0, 0, 0 }, { "D", 0, 0x82 },
{ "C", 0, 0x83, 100, 0, 36, 23, WHITE, 0, 0, menu_label_width, { "E", 0, 0x81 },
menu_label_height, menu_label_bitmap, "C", 0, 0, 0, 0 }, { "F", 0, 0x80 },
{ "D", 0, 0x82, 150, 0, 36, 23, WHITE, 0, 0, menu_label_width,
menu_label_height, menu_label_bitmap, "D", 0, 0, 0, 0 },
{ "E", 0, 0x81, 200, 0, 36, 23, WHITE, 0, 0, menu_label_width,
menu_label_height, menu_label_bitmap, "E", 0, 0, 0, 0 },
{ "F", 0, 0x80, 250, 0, 36, 23, WHITE, 0, 0, menu_label_width,
menu_label_height, menu_label_bitmap, "F", 0, 0, 0, 0 },
{ "MTH", 0, 0x24, 0, 50, 36, 26, WHITE, "MTH", 0, 0, 0, 0, "G", "PRINT", { "MTH", 0, 0x24 },
1, 0, 0 }, { "PRG", 0, 0x74 },
{ "PRG", 0, 0x74, 50, 50, 36, 26, WHITE, "PRG", 0, 0, 0, 0, "H", "I/O", { "CST", 0, 0x73 },
1, 0, 0 }, { "VAR", 0, 0x72 },
{ "CST", 0, 0x73, 100, 50, 36, 26, WHITE, "CST", 0, 0, 0, 0, "I", { "UP", 0, 0x71 },
"MODES", 1, 0, 0 }, { "NXT", 0, 0x70 },
{ "VAR", 0, 0x72, 150, 50, 36, 26, WHITE, "VAR", 0, 0, 0, 0, "J",
"MEMORY", 1, 0, 0 },
{ "UP", 0, 0x71, 200, 50, 36, 26, WHITE, 0, 0, up_width, up_height,
up_bitmap, "K", "LIBRARY", 1, 0, 0 },
{ "NXT", 0, 0x70, 250, 50, 36, 26, WHITE, "NXT", 0, 0, 0, 0, "L", "PREV",
0, 0, 0 },
{ "COLON", 0, 0x04, 0, 100, 36, 26, WHITE, 0, 0, colon_width, { "COLON", 0, 0x04 },
colon_height, colon_bitmap, "M", "UP", 0, "HOME", 0 }, { "STO", 0, 0x64 },
{ "STO", 0, 0x64, 50, 100, 36, 26, WHITE, "STO", 0, 0, 0, 0, "N", "DEF", { "EVAL", 0, 0x63 },
0, "RCL", 0 }, { "LEFT", 0, 0x62 },
{ "EVAL", 0, 0x63, 100, 100, 36, 26, WHITE, "EVAL", 0, 0, 0, 0, "O", { "DOWN", 0, 0x61 },
"aQ", 0, "aNUM", 0 }, { "RIGHT", 0, 0x60 },
{ "LEFT", 0, 0x62, 150, 100, 36, 26, WHITE, 0, 0, left_width,
left_height, left_bitmap, "P", "GRAPH", 0, 0, 0 },
{ "DOWN", 0, 0x61, 200, 100, 36, 26, WHITE, 0, 0, down_width,
down_height, down_bitmap, "Q", "REVIEW", 0, 0, 0 },
{ "RIGHT", 0, 0x60, 250, 100, 36, 26, WHITE, 0, 0, right_width,
right_height, right_bitmap, "R", "SWAP", 0, 0, 0 },
{ "SIN", 0, 0x34, 0, 150, 36, 26, WHITE, "SIN", 0, 0, 0, 0, "S", "ASIN", { "SIN", 0, 0x34 },
0, "b", 0 }, { "COS", 0, 0x54 },
{ "COS", 0, 0x54, 50, 150, 36, 26, WHITE, "COS", 0, 0, 0, 0, "T", "ACOS", { "TAN", 0, 0x53 },
0, "c", 0 }, { "SQRT", 0, 0x52 },
{ "TAN", 0, 0x53, 100, 150, 36, 26, WHITE, "TAN", 0, 0, 0, 0, "U", { "POWER", 0, 0x51 },
"ATAN", 0, "d", 0 }, { "INV", 0, 0x50 },
{ "SQRT", 0, 0x52, 150, 150, 36, 26, WHITE, 0, 0, sqrt_width,
sqrt_height, sqrt_bitmap, "V", "e", 0, "f", 0 },
{ "POWER", 0, 0x51, 200, 150, 36, 26, WHITE, 0, 0, power_width,
power_height, power_bitmap, "W", "g", 0, "LOG", 0 },
{ "INV", 0, 0x50, 250, 150, 36, 26, WHITE, 0, 0, inv_width, inv_height,
inv_bitmap, "X", "h", 0, "LN", 0 },
{ "ENTER", 0, 0x44, 0, 200, 86, 26, WHITE, "ENTER", 2, 0, 0, 0, 0, { "ENTER", 0, 0x44 },
"EQUATION", 0, "MATRIX", 0 }, { "NEG", 0, 0x43 },
{ "NEG", 0, 0x43, 100, 200, 36, 26, WHITE, 0, 0, neg_width, neg_height, { "EEX", 0, 0x42 },
neg_bitmap, "Y", "EDIT", 0, "VISIT", 0 }, { "DEL", 0, 0x41 },
{ "EEX", 0, 0x42, 150, 200, 36, 26, WHITE, "EEX", 0, 0, 0, 0, "Z", "2D", { "BS", 0, 0x40 },
0, "3D", 0 },
{ "DEL", 0, 0x41, 200, 200, 36, 26, WHITE, "DEL", 0, 0, 0, 0, 0, "PURGE",
0, 0, 0 },
{ "BS", 0, 0x40, 250, 200, 36, 26, WHITE, 0, 0, bs_width, bs_height,
bs_bitmap, 0, "DROP", 0, "CLR", 0 },
{ "ALPHA", 0, 0x35, 0, 250, 36, 26, WHITE, 0, 0, alpha_width, { "ALPHA", 0, 0x35 },
alpha_height, alpha_bitmap, 0, "USR", 0, "ENTRY", 0 }, { "7", 0, 0x33 },
{ "7", 0, 0x33, 60, 250, 46, 26, WHITE, "7", 1, 0, 0, 0, 0, "SOLVE", 1, { "8", 0, 0x32 },
0, 0 }, { "9", 0, 0x31 },
{ "8", 0, 0x32, 120, 250, 46, 26, WHITE, "8", 1, 0, 0, 0, 0, "PLOT", 1, { "DIV", 0, 0x30 },
0, 0 },
{ "9", 0, 0x31, 180, 250, 46, 26, WHITE, "9", 1, 0, 0, 0, 0, "ALGEBRA",
1, 0, 0 },
{ "DIV", 0, 0x30, 240, 250, 46, 26, WHITE, 0, 0, div_width, div_height,
div_bitmap, 0, "( )", 0, "#", 0 },
{ "SHL", 0, 0x25, 0, 300, 36, 26, LEFT, 0, 0, shl_width, shl_height, { "SHL", 0, 0x25 },
shl_bitmap, 0, 0, 0, 0, 0 }, { "4", 0, 0x23 },
{ "4", 0, 0x23, 60, 300, 46, 26, WHITE, "4", 1, 0, 0, 0, 0, "TIME", 1, 0, { "5", 0, 0x22 },
0 }, { "6", 0, 0x21 },
{ "5", 0, 0x22, 120, 300, 46, 26, WHITE, "5", 1, 0, 0, 0, 0, "STAT", 1, { "MUL", 0, 0x20 },
0, 0 },
{ "6", 0, 0x21, 180, 300, 46, 26, WHITE, "6", 1, 0, 0, 0, 0, "UNITS", 1,
0, 0 },
{ "MUL", 0, 0x20, 240, 300, 46, 26, WHITE, 0, 0, mul_width, mul_height,
mul_bitmap, 0, "[ ]", 0, "_", 0 },
{ "SHR", 0, 0x15, 0, 350, 36, 26, RIGHT, 0, 0, shr_width, shr_height, { "SHR", 0, 0x15 },
shr_bitmap, 0, 0, 0, 0, 0 }, { "1", 0, 0x13 },
{ "1", 0, 0x13, 60, 350, 46, 26, WHITE, "1", 1, 0, 0, 0, 0, "RAD", 0, { "2", 0, 0x12 },
"POLAR", 0 }, { "3", 0, 0x11 },
{ "2", 0, 0x12, 120, 350, 46, 26, WHITE, "2", 1, 0, 0, 0, 0, "STACK", 0, { "MINUS", 0, 0x10 },
"ARG", 0 },
{ "3", 0, 0x11, 180, 350, 46, 26, WHITE, "3", 1, 0, 0, 0, 0, "CMD", 0,
"MENU", 0 },
{ "MINUS", 0, 0x10, 240, 350, 46, 26, WHITE, 0, 0, minus_width,
minus_height, minus_bitmap, 0, "i", 0, "j", 0 },
{ "ON", 0, 0x8000, 0, 400, 36, 26, WHITE, "ON", 0, 0, 0, 0, 0, "CONT", 0, { "ON", 0, 0x8000},
"OFF", "ATTN" }, { "0", 0, 0x03 },
{ "0", 0, 0x03, 60, 400, 46, 26, WHITE, "0", 1, 0, 0, 0, 0, "= ", 0, { "PERIOD", 0, 0x02 },
" a", 0 }, { "SPC", 0, 0x01 },
{ "PERIOD", 0, 0x02, 120, 400, 46, 26, WHITE, ".", 1, 0, 0, 0, 0, ", ", { "PLUS", 0, 0x00 },
0, " k", 0 }, /* { 0 } */
{ "SPC", 0, 0x01, 180, 400, 46, 26, WHITE, "SPC", 0, 0, 0, 0, 0, "l ", 0, };
" m", 0 },
{ "PLUS", 0, 0x00, 240, 400, 46, 26, WHITE, 0, 0, plus_width,
plus_height, plus_bitmap, 0, "{ }", 0, ": :", 0 } };
static tui_button_t buttons_gx[] = { static tui_button_t buttons_gx[] = {
{ "A", 0, 0x14, 0, 0, 36, 23, WHITE, 0, 0, menu_label_width, {"A", 0, 0x14 },
menu_label_height, menu_label_bitmap, "A", 0, 0, 0, 0 }, { "B", 0, 0x84 },
{ "B", 0, 0x84, 50, 0, 36, 23, WHITE, 0, 0, menu_label_width, { "C", 0, 0x83 },
menu_label_height, menu_label_bitmap, "B", 0, 0, 0, 0 }, { "D", 0, 0x82 },
{ "C", 0, 0x83, 100, 0, 36, 23, WHITE, 0, 0, menu_label_width, { "E", 0, 0x81 },
menu_label_height, menu_label_bitmap, "C", 0, 0, 0, 0 }, { "F", 0, 0x80 },
{ "D", 0, 0x82, 150, 0, 36, 23, WHITE, 0, 0, menu_label_width,
menu_label_height, menu_label_bitmap, "D", 0, 0, 0, 0 },
{ "E", 0, 0x81, 200, 0, 36, 23, WHITE, 0, 0, menu_label_width,
menu_label_height, menu_label_bitmap, "E", 0, 0, 0, 0 },
{ "F", 0, 0x80, 250, 0, 36, 23, WHITE, 0, 0, menu_label_width,
menu_label_height, menu_label_bitmap, "F", 0, 0, 0, 0 },
{ "MTH", 0, 0x24, 0, 50, 36, 26, WHITE, "MTH", 0, 0, 0, 0, "G", "RAD", 0, { "MTH", 0, 0x24 },
"POLAR", 0 }, { "PRG", 0, 0x74 },
{ "PRG", 0, 0x74, 50, 50, 36, 26, WHITE, "PRG", 0, 0, 0, 0, "H", 0, 0, { "CST", 0, 0x73 },
"CHARS", 0 }, { "VAR", 0, 0x72 },
{ "CST", 0, 0x73, 100, 50, 36, 26, WHITE, "CST", 0, 0, 0, 0, "I", 0, 0, { "UP", 0, 0x71 },
"MODES", 0 }, { "NXT", 0, 0x70 },
{ "VAR", 0, 0x72, 150, 50, 36, 26, WHITE, "VAR", 0, 0, 0, 0, "J", 0, 0,
"MEMORY", 0 },
{ "UP", 0, 0x71, 200, 50, 36, 26, WHITE, 0, 0, up_width, up_height,
up_bitmap, "K", 0, 0, "STACK", 0 },
{ "NXT", 0, 0x70, 250, 50, 36, 26, WHITE, "NXT", 0, 0, 0, 0, "L", "PREV",
0, "MENU", 0 },
{ "COLON", 0, 0x04, 0, 100, 36, 26, WHITE, 0, 0, colon_width, { "COLON", 0, 0x04 },
colon_height, colon_bitmap, "M", "UP", 0, "HOME", 0 }, { "STO", 0, 0x64 },
{ "STO", 0, 0x64, 50, 100, 36, 26, WHITE, "STO", 0, 0, 0, 0, "N", "DEF", { "EVAL", 0, 0x63 },
0, "RCL", 0 }, { "LEFT", 0, 0x62 },
{ "EVAL", 0, 0x63, 100, 100, 36, 26, WHITE, "EVAL", 0, 0, 0, 0, "O", { "DOWN", 0, 0x61 },
"aNUM", 0, "UNDO", 0 }, { "RIGHT", 0, 0x60 },
{ "LEFT", 0, 0x62, 150, 100, 36, 26, WHITE, 0, 0, left_width,
left_height, left_bitmap, "P", "PICTURE", 0, 0, 0 },
{ "DOWN", 0, 0x61, 200, 100, 36, 26, WHITE, 0, 0, down_width,
down_height, down_bitmap, "Q", "VIEW", 0, 0, 0 },
{ "RIGHT", 0, 0x60, 250, 100, 36, 26, WHITE, 0, 0, right_width,
right_height, right_bitmap, "R", "SWAP", 0, 0, 0 },
{ "SIN", 0, 0x34, 0, 150, 36, 26, WHITE, "SIN", 0, 0, 0, 0, "S", "ASIN", { "SIN", 0, 0x34 },
0, "b", 0 }, { "COS", 0, 0x54 },
{ "COS", 0, 0x54, 50, 150, 36, 26, WHITE, "COS", 0, 0, 0, 0, "T", "ACOS", { "TAN", 0, 0x53 },
0, "c", 0 }, { "SQRT", 0, 0x52 },
{ "TAN", 0, 0x53, 100, 150, 36, 26, WHITE, "TAN", 0, 0, 0, 0, "U", { "POWER", 0, 0x51 },
"ATAN", 0, "d", 0 }, { "INV", 0, 0x50 },
{ "SQRT", 0, 0x52, 150, 150, 36, 26, WHITE, 0, 0, sqrt_width,
sqrt_height, sqrt_bitmap, "V", "n", 0, "o", 0 },
{ "POWER", 0, 0x51, 200, 150, 36, 26, WHITE, 0, 0, power_width,
power_height, power_bitmap, "W", "p", 0, "LOG", 0 },
{ "INV", 0, 0x50, 250, 150, 36, 26, WHITE, 0, 0, inv_width, inv_height,
inv_bitmap, "X", "q", 0, "LN", 0 },
{ "ENTER", 0, 0x44, 0, 200, 86, 26, WHITE, "ENTER", 2, 0, 0, 0, 0, { "ENTER", 0, 0x44 },
"EQUATION", 0, "MATRIX", 0 }, { "NEG", 0, 0x43 },
{ "NEG", 0, 0x43, 100, 200, 36, 26, WHITE, 0, 0, neg_width, neg_height, { "EEX", 0, 0x42 },
neg_bitmap, "Y", "EDIT", 0, "CMD", 0 }, { "DEL", 0, 0x41 },
{ "EEX", 0, 0x42, 150, 200, 36, 26, WHITE, "EEX", 0, 0, 0, 0, "Z", { "BS", 0, 0x40 },
"PURG", 0, "ARG", 0 },
{ "DEL", 0, 0x41, 200, 200, 36, 26, WHITE, "DEL", 0, 0, 0, 0, 0, "CLEAR",
0, 0, 0 },
{ "BS", 0, 0x40, 250, 200, 36, 26, WHITE, 0, 0, bs_width, bs_height,
bs_bitmap, 0, "DROP", 0, 0, 0 },
{ "ALPHA", 0, 0x35, 0, 250, 36, 26, WHITE, 0, 0, alpha_width, { "ALPHA", 0, 0x35 },
alpha_height, alpha_bitmap, 0, "USER", 0, "ENTRY", 0 }, { "7", 0, 0x33 },
{ "7", 0, 0x33, 60, 250, 46, 26, WHITE, "7", 1, 0, 0, 0, 0, 0, 1, { "8", 0, 0x32 },
"SOLVE", 0 }, { "9", 0, 0x31 },
{ "8", 0, 0x32, 120, 250, 46, 26, WHITE, "8", 1, 0, 0, 0, 0, 0, 1, { "DIV", 0, 0x30 },
"PLOT", 0 },
{ "9", 0, 0x31, 180, 250, 46, 26, WHITE, "9", 1, 0, 0, 0, 0, 0, 1,
"SYMBOLIC", 0 },
{ "DIV", 0, 0x30, 240, 250, 46, 26, WHITE, 0, 0, div_width, div_height,
div_bitmap, 0, "r ", 0, "s", 0 },
{ "SHL", 0, 0x25, 0, 300, 36, 26, LEFT, 0, 0, shl_width, shl_height, { "SHL", 0, 0x25 },
shl_bitmap, 0, 0, 0, 0, 0 }, { "4", 0, 0x23 },
{ "4", 0, 0x23, 60, 300, 46, 26, WHITE, "4", 1, 0, 0, 0, 0, 0, 1, "TIME", { "5", 0, 0x22 },
0 }, { "6", 0, 0x21 },
{ "5", 0, 0x22, 120, 300, 46, 26, WHITE, "5", 1, 0, 0, 0, 0, 0, 1, { "MUL", 0, 0x20 },
"STAT", 0 },
{ "6", 0, 0x21, 180, 300, 46, 26, WHITE, "6", 1, 0, 0, 0, 0, 0, 1,
"UNITS", 0 },
{ "MUL", 0, 0x20, 240, 300, 46, 26, WHITE, 0, 0, mul_width, mul_height,
mul_bitmap, 0, "t ", 0, "u", 0 },
{ "SHR", 0, 0x15, 0, 350, 36, 26, RIGHT, 0, 0, shr_width, shr_height, { "SHR", 0, 0x15 },
shr_bitmap, 0, 0, 1, " ", 0 }, { "1", 0, 0x13 },
{ "1", 0, 0x13, 60, 350, 46, 26, WHITE, "1", 1, 0, 0, 0, 0, 0, 1, "I/O", { "2", 0, 0x12 },
0 }, { "3", 0, 0x11 },
{ "2", 0, 0x12, 120, 350, 46, 26, WHITE, "2", 1, 0, 0, 0, 0, 0, 1, { "MINUS", 0, 0x10 },
"LIBRARY", 0 },
{ "3", 0, 0x11, 180, 350, 46, 26, WHITE, "3", 1, 0, 0, 0, 0, 0, 1,
"EQ LIB", 0 },
{ "MINUS", 0, 0x10, 240, 350, 46, 26, WHITE, 0, 0, minus_width,
minus_height, minus_bitmap, 0, "v ", 0, "w", 0 },
{ "ON", 0, 0x8000, 0, 400, 36, 26, WHITE, "ON", 0, 0, 0, 0, 0, "CONT", 0, { "ON", 0, 0x8000},
"OFF", "CANCEL" }, { "0", 0, 0x03 },
{ "0", 0, 0x03, 60, 400, 46, 26, WHITE, "0", 1, 0, 0, 0, 0, "\004 ", 0, { "PERIOD", 0, 0x02 },
"\003", 0 }, { "SPC", 0, 0x01 },
{ "PERIOD", 0, 0x02, 120, 400, 46, 26, WHITE, ".", 1, 0, 0, 0, 0, { "PLUS", 0, 0x00 },
"\002 ", 0, "\001", 0 }, /* { 0 } */
{ "SPC", 0, 0x01, 180, 400, 46, 26, WHITE, "SPC", 0, 0, 0, 0, 0, "\005 ", };
0, "z", 0 },
{ "PLUS", 0, 0x00, 240, 400, 46, 26, WHITE, 0, 0, plus_width,
plus_height, plus_bitmap, 0, "x ", 0, "y", 0 },
{ 0 } };
/****************************/ /****************************/
/* functions implementation */ /* functions implementation */
/****************************/ /****************************/
static inline void draw_nibble( int c, int r, int val ) { static int tui_draw_nibble( int x, int y, int val )
{
/* TODO */
return 0;
}
static inline void draw_nibble( int c, int r, int val )
{
int x, y; int x, y;
x = ( c * 4 ); // x: start in pixels x = ( c * 4 ); // x: start in pixels
@ -301,11 +214,12 @@ static inline void draw_nibble( int c, int r, int val ) {
if ( val != lcd_buffer[ r ][ c ] ) { if ( val != lcd_buffer[ r ][ c ] ) {
lcd_buffer[ r ][ c ] = val; lcd_buffer[ r ][ c ] = val;
/* TEXTDrawNibble( x, y, val ); */ tui_draw_nibble( x, y, 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;
@ -321,7 +235,8 @@ static inline void draw_row( long addr, int row ) {
} }
} }
static void tui_button_pressed( int b ) { static void tui_button_pressed( int b )
{
// Check not already pressed (may be important: avoids a useless do_kbd_int) // Check not already pressed (may be important: avoids a useless do_kbd_int)
if ( buttons[ b ].pressed == 1 ) if ( buttons[ b ].pressed == 1 )
return; return;
@ -347,7 +262,8 @@ static void tui_button_pressed( int b ) {
} }
} }
static void tui_button_released( int b ) { static void tui_button_released( int b )
{
// Check not already released (not critical) // Check not already released (not critical)
if ( buttons[ b ].pressed == 0 ) if ( buttons[ b ].pressed == 0 )
return; return;
@ -365,7 +281,8 @@ static void tui_button_released( int b ) {
} }
} }
static void tui_button_release_all( void ) { static void tui_button_release_all( void )
{
for ( int b = FIRST_BUTTON; b <= LAST_BUTTON; b++ ) for ( int b = FIRST_BUTTON; b <= LAST_BUTTON; b++ )
if ( buttons[ b ].pressed ) if ( buttons[ b ].pressed )
tui_button_released( b ); tui_button_released( b );
@ -374,7 +291,8 @@ static void tui_button_release_all( void ) {
/**********/ /**********/
/* public */ /* public */
/**********/ /**********/
int text_get_event( void ) { int text_get_event( void )
{
int hpkey = -1; int hpkey = -1;
/* check for input */ /* check for input */
@ -581,7 +499,8 @@ int text_get_event( void ) {
void text_adjust_contrast() {} void text_adjust_contrast() {}
void text_init_LCD( void ) { void text_init_LCD( 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 );
@ -592,14 +511,11 @@ void text_init_LCD( void ) {
display.lines = 63; display.lines = 63;
if ( display.offset > 3 ) if ( display.offset > 3 )
display.nibs_per_line = display.nibs_per_line = ( NIBBLES_PER_ROW + saturn.line_offset + 2 ) & 0xfff;
( NIBBLES_PER_ROW + saturn.line_offset + 2 ) & 0xfff;
else else
display.nibs_per_line = display.nibs_per_line = ( NIBBLES_PER_ROW + saturn.line_offset ) & 0xfff;
( 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;
@ -613,7 +529,8 @@ void text_init_LCD( void ) {
memset( lcd_buffer, 0xf0, sizeof( lcd_buffer ) ); memset( lcd_buffer, 0xf0, sizeof( lcd_buffer ) );
} }
void text_update_LCD( void ) { void text_update_LCD( void )
{
int i, j; int i, j;
long addr; long addr;
static int old_offset = -1; static int old_offset = -1;
@ -622,17 +539,13 @@ void text_update_LCD( void ) {
if ( display.on ) { if ( display.on ) {
addr = display.disp_start; addr = display.disp_start;
if ( display.offset != old_offset ) { if ( display.offset != old_offset ) {
memset( disp_buf, 0xf0, memset( disp_buf, 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 ) );
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, memset( &disp_buf[ 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 ) );
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++ ) {
@ -658,7 +571,8 @@ void text_update_LCD( void ) {
void text_refresh_LCD( void ) {} void text_refresh_LCD( void ) {}
void text_disp_draw_nibble( word_20 addr, word_4 val ) { void text_disp_draw_nibble( word_20 addr, word_4 val )
{
long offset; long offset;
int x, y; int x, y;
@ -684,7 +598,8 @@ void text_disp_draw_nibble( word_20 addr, word_4 val ) {
} }
} }
void text_menu_draw_nibble( word_20 addr, word_4 val ) { void text_menu_draw_nibble( word_20 addr, word_4 val )
{
long offset; long offset;
int x, y; int x, y;
@ -697,7 +612,8 @@ void text_menu_draw_nibble( word_20 addr, word_4 val ) {
} }
} }
void text_draw_annunc( void ) { void text_draw_annunc( void )
{
int val; int val;
val = display.annunc; val = display.annunc;
@ -709,13 +625,13 @@ void text_draw_annunc( void ) {
char annuncstate[ 6 ]; char annuncstate[ 6 ];
for ( int i = 0; ann_tbl[ i ].bit; i++ ) for ( int i = 0; ann_tbl[ i ].bit; i++ )
annuncstate[ i ] = annuncstate[ i ] = ( ( ann_tbl[ i ].bit & val ) == ann_tbl[ i ].bit ) ? 1 : 0;
( ( ann_tbl[ i ].bit & val ) == ann_tbl[ i ].bit ) ? 1 : 0;
/* TEXTDrawAnnunc( annuncstate ); */ /* TEXTDrawAnnunc( annuncstate ); */
} }
void init_text_ui( int argc, char** argv ) { void init_text_ui( int argc, char** argv )
{
buttons = ( tui_button_t* )malloc( sizeof( buttons_gx ) ); buttons = ( tui_button_t* )malloc( sizeof( buttons_gx ) );
if ( opt_gx ) if ( opt_gx )

2534
src/ui_x11.c
View file

File diff suppressed because it is too large Load diff