$ ./configure
$ gcc -shared -o blah.test -Iinclude/ opcodes?.c cpu.c rw.c
$ objdump -x blah.test | grep "*UND*"

$000000-$0FFFFF: RAM
$100000-$1FFFFF: Console Output Ports
$200000-$2FFFFF: Console Input Ports (blocking)
$300000-$3FFFFF: Console Input ports (non-blocking)
$400000-$FFFFFF: unused/unspecified

PrintError:
    LDX #Msg12 & $FFFF
    LDY #0
    LDA #Msg12Length-1
    MVP $00,$10  ; Print the message!
    RTS

#include <stdio.h>
#include "cpu.h"

byte addressSpace[1048576];

byte BlockingRead( void )
{
    return (byte)( getchar() );
}   

byte NonBlockingRead( void )
{
    return 0x00;
}   

void Emit( byte b )
{
    putchar( (int)b );
}   

void EMUL_handleWDM( void )
{
}

void EMUL_hardwareUpdate( void )
{
}

byte MEM_readMem( word32 address )
{
    if( address > 0x3FFFFF )    return 0x00;
    if( address > 0x2FFFFF )    return NonBlockingRead();
    if( address > 0x1FFFFF )    return BlockingRead();
    if( address > 0x0FFFFF )    return 0x00; /* unused at the moment */

    return addressSpace[address];
}

void MEM_writeMem( word32 address, byte b )
{
    if( address > 0x1FFFFF )    return; /* unused at the moment */
    if( address > 0x0FFFFF ) {  Emit(b); return; }

    addressSpace[address] = b;
}

void LoadROMs( void )
{
    union { int I; struct { char B0, B1, B2, B3; } B; } loadAddress;
    FILE *fh;

    fprintf( stderr, "Reading ROM.PRG\n" );
    fh = fopen( "ROM.PRG", "rb" );
    if( fh != NULL )
    {
        fread( &(loadAddress.B.B0), 1, 1, fh );
        fread( &(loadAddress.B.B1), 1, 1, fh );
        loadAddress.I &= 0xFFFF;

        while( !feof( fh ) )
        {   
            fread( &addressSpace[ loadAddress.I ], 1, 1, fh );
            printf( ".M %04lX %02lX\n", loadAddress.I, addressSpace[ loadAddress.I ] );
            loadAddress.I = (loadAddress.I+1) & 0xFFFF;
        }   

        fclose( fh );
    }
}

int main( void )
{
    LoadROMs();

    fprintf( stderr, "WARP FACTOR 5\n" );
    CPU_reset();
    CPU_run();

    return 0;
}

    !cpu    65816
    !to     "ROM.PRG"

    *=$F000

cold:
    lda     #<msg
    sta     0
    lda     #>msg
    sta     1
    ldy     #0
next:
    lda     (0),y
    beq     cold
    sta     $100000 ; store in "output byte" port
    iny
    jmp     next

msg:
    !text    "Hello world!"
    !byte   10,0

    *=$FFF0     ; ROM vectors -- don't remember which ones are
                ; which, so I'm shot-gunning it.

    !wo     cold, cold, cold, cold
    !wo     cold, cold, cold, cold

int main( void )
{
    CPUEvent_initialize(); // now needed
    LoadROMs();

    fprintf( stderr, "WARP FACTOR 5\n" );
    CPU_reset();
    CPU_run();

    return 0;
}

21c21
< void EMUL_handleWDM( void )
---
> void EMUL_handleWDM( byte opcode, word32 timestamp )
25c25
< void EMUL_hardwareUpdate( void )
---
> void EMUL_hardwareUpdate( word32 timestamp )
29c29,30
< byte MEM_readMem( word32 address )
---
>
> byte MEM_readMem( word32 address, word32 timestamp )
39c40
< void MEM_writeMem( word32 address, byte b )
---
> void MEM_writeMem( word32 address, byte b, word32 timestamp )

  FROM  | Description                                       |   TO   
--------+---------------------------------------------------+--------
 000000 | As currently understood for a stock Commodore 64. | 00FFFF
 010000 | Available RAM                                     | FEFFFF
 F00000 | Reads return $00, writes ignored                  | FEFFFF
 FF0000 | Expanded I/O space                                | FFFFFF
--------+---------------------------------------------------+--------

  FROM  | Description                                       |   TO   
--------+---------------------------------------------------+--------
 FF0000 | Mirror of C64's $D000-$DFFF I/O space.            | FF0FFF
 FF1000 | Mirror of C64's $D000-$DFFF color RAM space.      | FF1FFF
 FF2000 | Emulator-defined I/O devices, as we'd like        | FFFFFF
--------+---------------------------------------------------+--------