/* @(#) $Id: FMEM.C,v 1.17 2013/01/13 18:31:09 peschau Exp $ */
/*=========================================================================*/
/* Fellow                                                                  */
/* Virtual Memory System                                                   */
/*                                                                         */
/* Authors: Petter Schau, Torsten Enderling                                */
/*                                                                         */
/* This program is free software; you can redistribute it and/or modify    */
/* it under the terms of the GNU General Public License as published by    */
/* the Free Software Foundation; either version 2, or (at your option)     */
/* any later version.                                                      */
/*                                                                         */
/* This program is distributed in the hope that it will be useful,         */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of          */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           */
/* GNU General Public License for more details.                            */
/*                                                                         */
/* You should have received a copy of the GNU General Public License       */
/* along with this program; if not, write to the Free Software Foundation, */
/* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.          */
/*=========================================================================*/

#include "defs.h"
#include "fellow.h"
#include "draw.h"
#include "CpuModule.h"
#include "CpuIntegration.h"
#include "fhfile.h"
#include "graph.h"
#include "floppy.h"
#include "copper.h"
#include "cia.h"
#include "blit.h"
#include "fmem.h"
#include "fswrap.h"
#include "wgui.h"

#ifdef WIN32
#include <tchar.h>
#endif

/*============================================================================*/
/* Holds configuration for memory                                             */
/*============================================================================*/

ULO memory_chipsize;
ULO memory_fastsize;
ULO memory_slowsize;
BOOLE memory_useautoconfig;
BOOLE memory_address32bit;
STR memory_kickimage[CFG_FILENAME_LENGTH];
STR memory_key[256];


/*============================================================================*/
/* Holds actual memory                                                        */
/*============================================================================*/

UBY memory_chip[0x200000 + 32];
UBY memory_slow[0x1c0000 + 32];
UBY memory_kick[0x080000 + 32];
UBY *memory_fast = NULL;
ULO memory_fast_baseaddress;
ULO memory_fastallocatedsize;


/*============================================================================*/
/* Autoconfig data                                                            */
/*============================================================================*/

#define EMEM_MAXARDS 4
UBY memory_emem[0x10000];
memoryEmemCardInitFunc memory_ememard_initfunc[EMEM_MAXARDS];
memoryEmemCardMapFunc memory_ememard_mapfunc[EMEM_MAXARDS];
ULO memory_ememardcount;                                /* Number of cards */
ULO memory_ememards_finishedcount;                         /* Current card */


/*============================================================================*/
/* Device memory data                                                         */
/*============================================================================*/

#define MEMORY_DMEM_OFFSET 0xf40000

UBY memory_dmem[65536];
ULO memory_dmemcounter;


/*============================================================================*/
/* Additional Kickstart data                                                  */
/*============================================================================*/

ULO memory_initial_PC;
ULO memory_initial_SP;
BOOLE memory_kickimage_none;
ULO memory_kickimage_size;
ULO memory_kickimage_version;
STR memory_kickimage_versionstr[80];
ULO memory_kickimage_basebank;
const STR *memory_kickimage_versionstrings[14] = {
  "Kickstart, version information unavailable",
  "Kickstart Pre-V1.0",
  "Kickstart V1.0",
  "Kickstart V1.1 (NTSC)",
  "Kickstart V1.1 (PAL)",
  "Kickstart V1.2",
  "Kickstart V1.3",
  "Kickstart V1.3",
  "Kickstart V2.0",
  "Kickstart V2.04",
  "Kickstart V2.1",
  "Kickstart V3.0",
  "Kickstart V3.1",
  "Kickstart Post-V3.1"};
  void memoryKickSettingsClear(void);


  /*============================================================================*/
  /* Illegal read / write fault information                                     */
  /*============================================================================*/

  BOOLE memory_fault_read;                       /* TRUE - read / FALSE - write */
  ULO memory_fault_address;


  /*============================================================================*/
  /* Some run-time scratch variables                                            */
  /*============================================================================*/

  ULO memory_mystery_value;          /* Pattern needed in an unknown bank (hmm) */
  ULO memory_noise[2];                     /* Returns alternating bitpattern in */
  ULO memory_noisecounter;    /* unused IO-registers to keep apps from hanging */
  ULO memory_undefined_io_writecounter = 0;

  void memoryWriteByteToPointer(UBY data, UBY *address)
  {
    address[0] = data;
  }

  void memoryWriteWordToPointer(UWO data, UBY *address)
  {
    address[0] = (UBY) (data >> 8);
    address[1] = (UBY) data;
  }

  void memoryWriteLongToPointer(ULO data, UBY *address)
  {
    address[0] = (UBY) (data >> 24);
    address[1] = (UBY) (data >> 16);
    address[2] = (UBY) (data >> 8);
    address[3] = (UBY) data;
  }

  /*----------------------------
  Chip read register functions	
  ----------------------------*/

  UWO rintreqr(ULO address)
  {
    return (UWO) intreq;
  }

  /* SERDATR
  $dff018 */

  UWO rserdatr(ULO address)
  {
    return 0x2000;
  }

  /* INTENAR
  $dff01c */

  UWO rintenar(ULO address)
  {
    return (UWO) intenar;
  }

  // To simulate noise, return 0 and -1 every second time.
  // Why? Bugged demos test write-only registers for various bit-values
  // and to break out of loops, both 0 and 1 values must be returned.

  UWO rdefault(ULO address)
  {
    memory_noisecounter++;
    return (UWO) memory_noise[memory_noisecounter & 0x1];
  }

  void wdefault(UWO data, ULO address)
  {
    memory_undefined_io_writecounter++;
  }

  /*
  ======
  INTREQ
  ======

  $dff09c - Read from $dff01e

  Paula
  */

  void wintreq(UWO data, ULO address)
  {
    if (data & 0x8000)
    {
      intreq = intreq | (data & 0x7fff);
    }
    else
    {
      intreq = intreq & ~(data & 0x7fff);
      ciaUpdateIRQ(0);
      ciaUpdateIRQ(1);
    }
    cpuIntegrationCheckPendingInterrupts();
  }

  /*
  ======
  INTENA
  ======

  $dff09a - Read from $dff01c

  Paula
  */

  // If master bit is off, then INTENA is 0, else INTENA = INTENAR
  // The master bit can not be read, the memory test in the kickstart
  // depends on this.

  void wintena(UWO data, ULO address)
  {
    if (data & 0x8000)
    {
      intenar = intenar | (data & 0x7fff);
    }
    else
    {
      intenar = intenar & ~(data & 0x7fff); 
    }

    if ((intenar & 0x00004000) == 0x00004000)
    {
      // Interrupts are enabled, check if any has not been serviced
      intena = intenar;
      cpuIntegrationCheckPendingInterrupts();
    }
    else
    {
      intena = 0;
    }
  }

  /*============================================================================*/
  /* Table of register read/write functions                                     */
  /*============================================================================*/

  memoryIoReadFunc memory_iobank_read[257]; // Account for long writes to the last
  memoryIoWriteFunc memory_iobank_write[257]; // word

  /*============================================================================*/
  /* Memory mapping tables                                                      */
  /*============================================================================*/

  memoryReadByteFunc memory_bank_readbyte[65536];
  memoryReadWordFunc memory_bank_readword[65536];
  memoryReadLongFunc memory_bank_readlong[65536];
  memoryWriteByteFunc memory_bank_writebyte[65536];
  memoryWriteWordFunc memory_bank_writeword[65536];
  memoryWriteLongFunc memory_bank_writelong[65536];
  UBY *memory_bank_pointer[65536];                   /* Used by the filesystem */
  BOOLE memory_bank_pointer_can_write[65536];

  /* Variables that correspond to various registers */

  ULO intenar, intena, intreq;


  /*============================================================================*/
  /* Memory bank mapping functions                                              */
  /*============================================================================*/

  /*============================================================================*/
  /* Set read and write stubs for a bank, as well as a direct pointer to        */
  /* its memory. NULL pointer is passed when the memory must always be          */
  /* read through the stubs, like in a bank of registers where writing           */
  /* or reading the value generates side-effects.                               */
  /* Datadirect is TRUE when data accesses can be made through a pointer        */
  /*============================================================================*/

  void memoryBankSet(memoryReadByteFunc rb, 
    memoryReadWordFunc rw, 
    memoryReadLongFunc rl, 
    memoryWriteByteFunc wb,
    memoryWriteWordFunc ww, 
    memoryWriteLongFunc wl, 
    UBY *basep, 
    ULO bank,
    ULO basebank,
    BOOLE pointer_can_write)
  {
    ULO i, j;

    j = (memoryGetAddress32Bit()) ? 65536 : 256;
    for (i = bank; i < 65536; i += j)
    {
      memory_bank_readbyte[i] = rb;
      memory_bank_readword[i] = rw;
      memory_bank_readlong[i] = rl;
      memory_bank_writebyte[i] = wb;
      memory_bank_writeword[i] = ww;
      memory_bank_writelong[i] = wl;
      memory_bank_pointer_can_write[i] = pointer_can_write;

      if (basep != NULL)
      {
	memory_bank_pointer[i] = basep - (basebank<<16);
      }
      else
      {
	memory_bank_pointer[i] = NULL;
      }
      basebank += j;
    }
  }


  /*============================================================================*/
  /* Clear one bank data to safe "do-nothing" values                            */
  /*============================================================================*/

  /* Unmapped memory interface */

  UBY memoryUnmappedReadByte(ULO address)
  {
    memory_mystery_value = ~memory_mystery_value;
    return (UBY) memory_mystery_value;
  }

  UWO memoryUnmappedReadWord(ULO address)
  {
    return 0x6100;
  }

  ULO memoryUnmappedReadLong(ULO address)
  {
    return 0x61006100;
  }

  void memoryUnmappedWriteByte(UBY data, ULO address)
  {
    // NOP
  }

  void memoryUnmappedWriteWord(UWO data, ULO address)
  {
    // NOP
  }

  void memoryUnmappedWriteLong(ULO data, ULO address)
  {
    // NOP
  }

  void memoryBankClear(ULO bank)
  {
    memoryBankSet(memoryUnmappedReadByte,
      memoryUnmappedReadWord,
      memoryUnmappedReadLong, 
      memoryUnmappedWriteByte,
      memoryUnmappedWriteWord, 
      memoryUnmappedWriteLong, 
      NULL,
      bank,
      0,
      FALSE);
  }

  /*============================================================================*/
  /* Clear all bank data to safe "do-nothing" values                            */
  /*============================================================================*/

  void memoryBankClearAll(void)
  {
    ULO bank;
    ULO hilim = (memoryGetAddress32Bit()) ? 65536 : 256;
    for (bank = 0; bank < hilim; bank++)
      memoryBankClear(bank);
  }


  /*============================================================================*/
  /* Expansion cards autoconfig                                                 */
  /*============================================================================*/


  /*============================================================================*/
  /* Clear the expansion config bank                                            */
  /*============================================================================*/

  void memoryEmemClear(void)
  {
    memset(memory_emem, 0xff, 65536);
  }

  /*============================================================================*/
  /* Add card to table                                                          */
  /*============================================================================*/

  void memoryEmemCardAdd(memoryEmemCardInitFunc cardinit,
    memoryEmemCardMapFunc cardmap)
  {
    if (memory_ememardcount < EMEM_MAXARDS)
    {
      memory_ememard_initfunc[memory_ememardcount] = cardinit;
      memory_ememard_mapfunc[memory_ememardcount] = cardmap;
      memory_ememardcount++;
    }
  }

  /*============================================================================*/
  /* Advance the card pointer                                                   */
  /*============================================================================*/

  void memoryEmemCardNext(void)
  {
    memory_ememards_finishedcount++;
  }


  /*============================================================================*/
  /* Init the current card                                                      */
  /*============================================================================*/

  void memoryEmemCardInit(void)
  {
    memoryEmemClear();
    if (memory_ememards_finishedcount != memory_ememardcount)
      memory_ememard_initfunc[memory_ememards_finishedcount]();
  } 

  /*============================================================================*/
  /* Map this card                                                              */
  /* Mapping is bank number set by AmigaOS                                      */
  /*============================================================================*/

  void memoryEmemCardMap(ULO mapping)
  {
    if (memory_ememards_finishedcount == memory_ememardcount)
      memoryEmemClear();
    else
      memory_ememard_mapfunc[memory_ememards_finishedcount](mapping);
  }

  /*============================================================================*/
  /* Reset card setup                                                           */
  /*============================================================================*/

  void memoryEmemCardsReset(void)
  {
    memory_ememards_finishedcount = 0;
    memoryEmemCardInit();
  }

  /*============================================================================*/
  /* Clear the card table                                                       */
  /*============================================================================*/

  void memoryEmemCardsRemove(void)
  {
    memory_ememardcount = memory_ememards_finishedcount = 0;
  }

  /*============================================================================*/
  /* Set a byte in autoconfig space, for initfunc routines                      */
  /* so they can make their configuration visible                               */
  /*============================================================================*/

  void memoryEmemSet(ULO index, ULO value)
  {
    index &= 0xffff;
    switch (index)
    {
    case 0:
    case 2:
    case 0x40:
    case 0x42:
      memory_emem[index] = (UBY) (value & 0xf0);
      memory_emem[index + 2] = (UBY) ((value & 0xf)<<4);
      break;
    default:
      memory_emem[index] = (UBY) (~(value & 0xf0));
      memory_emem[index + 2] = (UBY) (~((value & 0xf)<<4));
      break;
    }
  }

  /*============================================================================*/
  /* Copy data into emem space                                                  */
  /*============================================================================*/

  void memoryEmemMirror(ULO emem_offset, UBY *src, ULO size)
  {
    memcpy(memory_emem + emem_offset, src, size);
  }

  /*============================================================================*/
  /* Read/Write stubs for autoconfig memory                                     */
  /*============================================================================*/

  UBY memoryEmemReadByte(ULO address)
  {
    UBY *p = memory_emem + (address & 0xffff);
    return memoryReadByteFromPointer(p);
  }

  UWO memoryEmemReadWord(ULO address)
  {
    UBY *p = memory_emem + (address & 0xffff);
    return memoryReadWordFromPointer(p);
  }

  ULO memoryEmemReadLong(ULO address)
  {
    UBY *p = memory_emem + (address & 0xffff);
    return memoryReadLongFromPointer(p);
  }

  void memoryEmemWriteByte(UBY data, ULO address)
  {
    static ULO mapping;

    switch (address & 0xffff)
    {
    case 0x30:
    case 0x32:
      mapping = data = 0;
    case 0x48:
      mapping = (mapping & 0xff) | (((ULO)data) << 8);
      memoryEmemCardMap(mapping);
      memoryEmemCardNext();
      memoryEmemCardInit();
      break;
    case 0x4a:
      mapping = (mapping & 0xff00) | ((ULO)data);
      break;
    case 0x4c:
      memoryEmemCardNext();
      memoryEmemCardInit();
      break;
    }
  }

  void memoryEmemWriteWord(UWO data, ULO address)
  {
  }

  void memoryEmemWriteLong(ULO data, ULO address)
  {
  }

  /*===========================================================================*/
  /* Map the autoconfig memory bank into memory                                */
  /*===========================================================================*/

  void memoryEmemMap(void)
  {
    if (memoryGetKickImageBaseBank() >= 0xf8)
      memoryBankSet(memoryEmemReadByte,
      memoryEmemReadWord,
      memoryEmemReadLong,
      memoryEmemWriteByte,
      memoryEmemWriteWord,
      memoryEmemWriteLong,
      NULL,
      0xe8,
      0xe8,
      FALSE);
  }


  /*===================*/
  /* End of autoconfig */
  /*===================*/


  /*============================================================================*/
  /* dmem is the data area used by the hardfile device to communicate info      */
  /* about itself with the Amiga                                                */
  /*============================================================================*/

  /*============================================================================*/
  /* Functions to set data in dmem by the native device drivers                 */
  /*============================================================================*/

  UBY memoryDmemReadByte(ULO address)
  {
    UBY *p = memory_dmem + (address & 0xffff);
    return memoryReadByteFromPointer(p);
  }

  UWO memoryDmemReadWord(ULO address)
  {
    UBY *p = memory_dmem + (address & 0xffff);
    return memoryReadWordFromPointer(p);
  }

  ULO memoryDmemReadLong(ULO address)
  {
    UBY *p = memory_dmem + (address & 0xffff);
    return memoryReadLongFromPointer(p);
  }

  void memoryDmemWriteByte(UBY data, ULO address)
  {
    // NOP
  }

  void memoryDmemWriteWord(UWO data, ULO address)
  {
    // NOP
  }

  /*============================================================================*/
  /* Writing a long to $f40000 runs a native function                           */
  /*============================================================================*/

  void memoryDmemWriteLong(ULO data, ULO address)
  {
    if ((address & 0xffffff) == 0xf40000)
    {
      switch (data>>16)
      {
      case 0x0001:    fhfileDo(data);
	break;
      default:        break;
      }
    }
  }

  void memoryDmemClear(void)
  {
    memset(memory_dmem, 0, 4096);
  }

  void memoryDmemSetCounter(ULO c)
  {
    memory_dmemcounter = c;
  }

  ULO memoryDmemGetCounter(void)
  {
    return memory_dmemcounter + MEMORY_DMEM_OFFSET;
  }

  void memoryDmemSetString(STR *st)
  {
    strcpy((STR *) (memory_dmem + memory_dmemcounter), st);
    memory_dmemcounter += (ULO) strlen(st) + 1;
    if (memory_dmemcounter & 1) memory_dmemcounter++;
  }

  void memoryDmemSetByte(UBY data)
  {
    memory_dmem[memory_dmemcounter++] = data;
  }

  void memoryDmemSetWord(UWO data)
  {
    memoryWriteWordToPointer(data, memory_dmem + memory_dmemcounter);
    memory_dmemcounter += 2;
  }

  void memoryDmemSetLong(ULO data)
  {
    memoryWriteLongToPointer(data, memory_dmem + memory_dmemcounter);
    memory_dmemcounter += 4;
  }

  void memoryDmemSetLongNoCounter(ULO data, ULO offset)
  {
    memoryWriteLongToPointer(data, memory_dmem + offset);
  }

  void memoryDmemMap(void)
  {
    ULO bank = 0xf40000>>16;

    if (memory_useautoconfig && (memory_kickimage_basebank >= 0xf8))
      memoryBankSet(memoryDmemReadByte,
      memoryDmemReadWord,
      memoryDmemReadLong,
      memoryDmemWriteByte,
      memoryDmemWriteWord,
      memoryDmemWriteLong,
      memory_dmem,
      bank,
      bank,
      FALSE);
  }

  /*============================================================================*/
  /* Converts an address to a direct pointer to memory. Used by hardfile device */
  /*============================================================================*/

  UBY *memoryAddressToPtr(ULO address)
  {
    UBY *result;

    if ((result = memory_bank_pointer[address>>16]) != NULL)
      result += address;
    return result;
  }

  /*============================================================================*/
  /* Chip memory handling                                                       */
  /*============================================================================*/

  UBY memoryChipReadByte(ULO address)
  {
    UBY *p = memory_chip + (address & 0x1fffff);
    return memoryReadByteFromPointer(p);
  }

  UWO memoryChipReadWord(ULO address)
  {
    UBY *p = memory_chip + (address & 0x1fffff);
    return memoryReadWordFromPointer(p);
  }

  ULO memoryChipReadLong(ULO address)
  {
    UBY *p = memory_chip + (address & 0x1fffff);
    return memoryReadLongFromPointer(p);
  }

  void memoryChipWriteByte(UBY data, ULO address)
  {
    UBY *p = memory_chip + (address & 0x1fffff);
    memoryWriteByteToPointer(data, p);
  }

  void memoryChipWriteWord(UWO data, ULO address)
  {
    UBY *p = memory_chip + (address & 0x1fffff);
    memoryWriteWordToPointer(data, p);
  }

  void memoryChipWriteLong(ULO data, ULO address)
  {
    UBY *p = memory_chip + (address & 0x1fffff);
    memoryWriteLongToPointer(data, p);
  }

  void memoryChipClear(void)
  {
    memset(memory_chip, 0, memoryGetChipSize());
  }

  UBY memoryOverlayReadByte(ULO address)
  {
    UBY *p = memory_kick + (address & 0xffffff);
    return memoryReadByteFromPointer(p);
  }

  UWO memoryOverlayReadWord(ULO address)
  {
    UBY *p = memory_kick + (address & 0xffffff);
    return memoryReadWordFromPointer(p);
  }

  ULO memoryOverlayReadLong(ULO address)
  {
    UBY *p = memory_kick + (address & 0xffffff);
    return memoryReadLongFromPointer(p);
  }

  void memoryOverlayWriteByte(UBY data, ULO address)
  {
    // NOP
  }

  void memoryOverlayWriteWord(UWO data, ULO address)
  {
    // NOP
  }

  void memoryOverlayWriteLong(ULO data, ULO address)
  {
    // NOP
  }

  void memoryChipMap(BOOLE overlay)
  {
    ULO bank, lastbank;

    if (overlay)
    {
      for (bank = 0; bank < 8; bank++)
	memoryBankSet(memoryOverlayReadByte,
	memoryOverlayReadWord,
	memoryOverlayReadLong,
	memoryOverlayWriteByte,
	memoryOverlayWriteWord,
	memoryOverlayWriteLong,
	memory_kick,
	bank,
	0,
	FALSE);
    }

    if (memoryGetChipSize() > 0x200000) lastbank = 0x200000>>16;
    else lastbank = memoryGetChipSize()>>16;

    for (bank = (overlay) ? 8 : 0; bank < lastbank; bank++)
      memoryBankSet(memoryChipReadByte,
      memoryChipReadWord, 
      memoryChipReadLong,
      memoryChipWriteByte, 
      memoryChipWriteWord, 
      memoryChipWriteLong,
      memory_chip,
      bank, 
      0,
      TRUE);
  }

  /*============================================================================*/
  /* Fast memory handling                                                       */
  /*============================================================================*/

  UBY memoryFastReadByte(ULO address)
  {
    UBY *p = memory_fast + ((address & 0xffffff) - memory_fast_baseaddress);
    return memoryReadByteFromPointer(p);
  }

  UWO memoryFastReadWord(ULO address)
  {
    UBY *p = memory_fast + ((address & 0xffffff) - memory_fast_baseaddress);
    return memoryReadWordFromPointer(p);
  }

  ULO memoryFastReadLong(ULO address)
  {
    UBY *p = memory_fast + ((address & 0xffffff) - memory_fast_baseaddress);
    return memoryReadLongFromPointer(p);
  }

  void memoryFastWriteByte(UBY data, ULO address)
  {
    UBY *p = memory_fast + ((address & 0xffffff) - memory_fast_baseaddress);
    memoryWriteByteToPointer(data, p);
  }

  void memoryFastWriteWord(UWO data, ULO address)
  {
    UBY *p = memory_fast + ((address & 0xffffff) - memory_fast_baseaddress);
    memoryWriteWordToPointer(data, p);
  }

  void memoryFastWriteLong(ULO data, ULO address)
  {
    UBY *p = memory_fast + ((address & 0xffffff) - memory_fast_baseaddress);
    memoryWriteLongToPointer(data, p);
  }

  /*============================================================================*/
  /* Set up autoconfig values for fastmem card                                  */
  /*============================================================================*/

  void memoryFastCardInit(void)
  {
    if (memoryGetFastSize() == 0x100000) memoryEmemSet(0, 0xe5);
    else if (memoryGetFastSize() == 0x200000) memoryEmemSet(0, 0xe6);
    else if (memoryGetFastSize() == 0x400000) memoryEmemSet(0, 0xe7);
    else if (memoryGetFastSize() == 0x800000) memoryEmemSet(0, 0xe0);
    memoryEmemSet(8, 128);
    memoryEmemSet(4, 1);
    memoryEmemSet(0x10, 2011>>8);
    memoryEmemSet(0x14, 2011 & 0xf);
    memoryEmemSet(0x18, 0);
    memoryEmemSet(0x1c, 0);
    memoryEmemSet(0x20, 0);
    memoryEmemSet(0x24, 1);
    memoryEmemSet(0x28, 0);
    memoryEmemSet(0x2c, 0);
    memoryEmemSet(0x40, 0);
  }

  /*============================================================================*/
  /* Allocate memory for the fast card memory                                   */
  /*============================================================================*/

  void memoryFastClear(void)
  {
    if (memory_fast != NULL)
      memset(memory_fast, 0, memoryGetFastSize());
  }

  void memoryFastFree(void)
  {
    if (memory_fast != NULL)
    {
      free(memory_fast);
      memory_fast = NULL;
      memory_fast_baseaddress = 0;
      memorySetFastAllocatedSize(0);
    }
  }

  void memoryFastAllocate(void)
  {
    if (memoryGetFastSize() != memoryGetFastAllocatedSize())
    {
      memoryFastFree();
      memory_fast = (UBY *) malloc(memoryGetFastSize());
      if (memory_fast == NULL) memorySetFastSize(0);
      else memoryFastClear();
      memorySetFastAllocatedSize((memory_fast == NULL) ? 0 : memoryGetFastSize());
    }
  }

  /*============================================================================*/
  /* Map fastcard.							      */
  /*============================================================================*/

  void memoryFastCardMap(ULO mapping)
  {
    ULO bank, lastbank;

    memory_fast_baseaddress = (mapping >> 8) << 16;
    if (memoryGetFastSize() > 0x800000) lastbank = 0xa00000>>16;
    else lastbank = (memory_fast_baseaddress + memoryGetFastSize())>>16;
    for (bank = memory_fast_baseaddress>>16; bank < lastbank; bank++)
      memoryBankSet(memoryFastReadByte,
      memoryFastReadWord,
      memoryFastReadLong,
      memoryFastWriteByte,
      memoryFastWriteWord, 
      memoryFastWriteLong,
      memory_fast, 
      bank, 
      memory_fast_baseaddress>>16,
      TRUE);
    memset(memory_fast, 0, memoryGetFastSize());
  }

  void memoryFastCardAdd(void)
  {
    if (memoryGetFastSize() != 0)
      memoryEmemCardAdd(memoryFastCardInit, memoryFastCardMap);
  }

  /*============================================================================*/
  /* Slow memory handling                                                       */
  /*============================================================================*/

  UBY memorySlowReadByte(ULO address)
  {
    UBY *p = memory_slow + ((address & 0xffffff) - 0xc00000);
    return memoryReadByteFromPointer(p);
  }

  UWO memorySlowReadWord(ULO address)
  {
    UBY *p = memory_slow + ((address & 0xffffff) - 0xc00000);
    return memoryReadWordFromPointer(p);
  }

  ULO memorySlowReadLong(ULO address)
  {
    UBY *p = memory_slow + ((address & 0xffffff) - 0xc00000);
    return memoryReadLongFromPointer(p);
  }

  void memorySlowWriteByte(UBY data, ULO address)
  {
    UBY *p = memory_slow + ((address & 0xffffff) - 0xc00000);
    memoryWriteByteToPointer(data, p);
  }

  void memorySlowWriteWord(UWO data, ULO address)
  {
    UBY *p = memory_slow + ((address & 0xffffff) - 0xc00000);
    memoryWriteWordToPointer(data, p);
  }

  void memorySlowWriteLong(ULO data, ULO address)
  {
    UBY *p = memory_slow + ((address & 0xffffff) - 0xc00000);
    memoryWriteLongToPointer(data, p);
  }

  void memorySlowClear(void)
  {
    memset(memory_slow, 0, memoryGetSlowSize());
  }

  void memorySlowMap(void)
  {
    ULO bank, lastbank;

    if (memoryGetSlowSize() > 0x1c0000) lastbank = 0xdc0000>>16;
    else lastbank = (0xc00000 + memoryGetSlowSize())>>16;
    for (bank = 0xc00000>>16; bank < lastbank; bank++)
      memoryBankSet(memorySlowReadByte,
      memorySlowReadWord,
      memorySlowReadLong,
      memorySlowWriteByte,
      memorySlowWriteWord,
      memorySlowWriteLong,
      memory_slow,
      bank, 
      0xc00000>>16,
      TRUE);
  }

  /*============================================================================*/
  /* Probably a disk controller, we need it to pass dummy values to get past    */
  /* the bootstrap of some Kickstart versions.                                  */
  /*============================================================================*/

  UBY memoryMysteryReadByte(ULO address)
  {
    memory_mystery_value = ~memory_mystery_value;
    return (UBY) memory_mystery_value;
  }

  UWO memoryMysteryReadWord(ULO address)
  {
    memory_mystery_value = ~memory_mystery_value;
    return (UWO) memory_mystery_value;
  }

  ULO memoryMysteryReadLong(ULO address)
  {
    memory_mystery_value = ~memory_mystery_value;
    return memory_mystery_value;
  }

  void memoryMysteryWriteByte(UBY data, ULO address)
  {
    // NOP
  }

  void memoryMysteryWriteWord(UWO data, ULO address)
  {
    // NOP
  }

  void memoryMysteryWriteLong(ULO data, ULO address)
  {
    // NOP
  }

  void memoryMysteryMap(void)
  {
    memoryBankSet(memoryMysteryReadByte,
      memoryMysteryReadWord,
      memoryMysteryReadLong,
      memoryMysteryWriteByte, 
      memoryMysteryWriteWord, 
      memoryMysteryWriteLong,
      NULL, 
      0xe9, 
      0,
      FALSE);
    memoryBankSet(memoryMysteryReadByte, 
      memoryMysteryReadWord, 
      memoryMysteryReadLong,
      memoryMysteryWriteByte, 
      memoryMysteryWriteWord, 
      memoryMysteryWriteLong,
      NULL, 
      0xde, 
      0,
      FALSE);
  }

  /*============================================================================*/
  /* IO Registers                                                               */
  /*============================================================================*/

  UBY memoryIoReadByte(ULO address)
  {
    ULO adr = address & 0x1fe;
    if (address & 0x1)
    { // Odd address
      return (UBY) memory_iobank_read[adr >> 1](adr);
    }
    else
    { // Even address
      return (UBY) (memory_iobank_read[adr >> 1](adr) >> 8);
    }
  }

  UWO memoryIoReadWord(ULO address)
  {
    return memory_iobank_read[(address & 0x1fe) >> 1](address & 0x1fe);
  }

  ULO memoryIoReadLong(ULO address)
  {
    ULO adr = address & 0x1fe;
    ULO r1 = (ULO)memory_iobank_read[adr >> 1](adr);
    ULO r2 = (ULO)memory_iobank_read[(adr + 2) >> 1](adr + 2);
    return (r1 << 16) | r2;
  }

  void memoryIoWriteByte(UBY data, ULO address)
  {
    ULO adr = address & 0x1fe;
    if (address & 0x1)
    { // Odd address
      memory_iobank_write[adr >> 1]((UWO) data, adr);
    }
    else
    { // Even address
      memory_iobank_write[adr >> 1](((UWO) data) << 8, adr);
    }
  }

  void memoryIoWriteWord(UWO data, ULO address)
  {
    ULO adr = address & 0x1fe;
    memory_iobank_write[adr >> 1](data, adr);
  }

  void memoryIoWriteLong(ULO data, ULO address)
  {
    ULO adr = address & 0x1fe;
    memory_iobank_write[adr >> 1]((UWO)(data >> 16), adr);
    memory_iobank_write[(adr + 2) >> 1]((UWO)data, adr + 2);
  }

  void memoryIoMap(void)
  {
    ULO bank, lastbank;

    if (memoryGetSlowSize() > 0x1c0000) lastbank = 0xdc0000>>16;
    else lastbank = (0xc00000 + memoryGetSlowSize())>>16;
    for (bank = lastbank; bank < 0xe00000>>16; bank++)
      memoryBankSet(memoryIoReadByte,
      memoryIoReadWord, 
      memoryIoReadLong,
      memoryIoWriteByte, 
      memoryIoWriteWord, 
      memoryIoWriteLong,
      NULL,
      bank,
      0,
      FALSE);
  }

  /*===========================================================================*/
  /* Initializes one entry in the IO register access table                     */
  /*===========================================================================*/

  void memorySetIoReadStub(ULO index, memoryIoReadFunc ioreadfunction)
  {
    memory_iobank_read[index>>1] = ioreadfunction;
  }

  void memorySetIoWriteStub(ULO index, memoryIoWriteFunc iowritefunction)
  {
    memory_iobank_write[index>>1] = iowritefunction;
  }

  /*===========================================================================*/
  /* Clear all IO-register accessors                                           */
  /*===========================================================================*/

  void memoryIoClear(void)
  {
    ULO i;

    // Array has 257 elements to account for long writes to the last address.
    for (i = 0; i <= 512; i += 2) {
      memorySetIoReadStub(i, rdefault);
      memorySetIoWriteStub(i, wdefault);
    }
  }

  /*============================================================================*/
  /* Kickstart handling                                                         */
  /*============================================================================*/

  /*============================================================================*/
  /* Map the Kickstart image into Amiga memory                                  */
  /*============================================================================*/

  UBY memoryKickReadByte(ULO address)
  {
    UBY *p = memory_kick + ((address & 0xffffff) - 0xf80000);
    return memoryReadByteFromPointer(p);
  }

  UWO memoryKickReadWord(ULO address)
  {
    UBY *p = memory_kick + ((address & 0xffffff) - 0xf80000);
    return memoryReadWordFromPointer(p);
  }

  ULO memoryKickReadLong(ULO address)
  {
    UBY *p = memory_kick + ((address & 0xffffff) - 0xf80000);
    return memoryReadLongFromPointer(p);
  }

  void memoryKickWriteByte(UBY data, ULO address)
  {
    // NOP
  }

  void memoryKickWriteWord(UWO data, ULO address)
  {
    // NOP
  }

  void memoryKickWriteLong(ULO data, ULO address)
  {
    // NOP
  }

  void memoryKickMap(void)
  {
    ULO bank, basebank;

    basebank = memory_kickimage_basebank & 0xf8;
    for (bank = basebank;
      bank < (basebank + 8);
      bank++)
      memoryBankSet(memoryKickReadByte,
      memoryKickReadWord,
      memoryKickReadLong,
      memoryKickWriteByte,
      memoryKickWriteWord,
      memoryKickWriteLong,
      memory_kick,
      bank,
      memory_kickimage_basebank,
      FALSE);
  }

  /*============================================================================*/
  /* An error occurred during loading a kickstart file. Uses GUI to display      */
  /* an errorstring.                                                            */
  /*============================================================================*/

  void memoryKickError(ULO errorcode, ULO data)
  {
    static STR error1[80], error2[160], error3[160];

    sprintf(error1, "Kickstart file could not be loaded");
    sprintf(error2, "%s", memory_kickimage);
    error3[0] = '\0';
    switch (errorcode)
    {
    case MEMORY_ROM_ERROR_SIZE:
      sprintf(error3,
	"Illegal size: %d bytes, size must be either 256K or 512K",
	data);
      break;
    case MEMORY_ROM_ERROR_AMIROM_VERSION:
      sprintf(error3, "Unsupported encryption method, version found was %d",
	data);
      break;
    case MEMORY_ROM_ERROR_AMIROM_READ:
      sprintf(error3, "Read error in encrypted Kickstart or keyfile");
      break;
    case MEMORY_ROM_ERROR_KEYFILE:
      sprintf(error3, "Unable to access keyfile %s", memory_key);
      break;
    case MEMORY_ROM_ERROR_EXISTS_NOT:
      sprintf(error3, "File does not exist");
      break;
    case MEMORY_ROM_ERROR_FILE:
      sprintf(error3, "File is a directory");
      break;
    case MEMORY_ROM_ERROR_KICKDISK_NOT:
      sprintf(error3, "The ADF-image is not a kickdisk");
      break;
    case MEMORY_ROM_ERROR_CHECKSUM:
      sprintf(error3,
	"The Kickstart image has a checksum error, checksum is %X",
	data);
      break;
    case MEMORY_ROM_ERROR_KICKDISK_SUPER:
      sprintf(error3,
	"The ADF-image contains a superkickstart. Fellow can not handle it.");
      break;
    case MEMORY_ROM_ERROR_BAD_BANK:
      sprintf(error3, "The ROM has a bad baseaddress: %X",
	memory_kickimage_basebank*0x10000);
      break;
    }
    wguiRequester(error1, error2, error3);
    memoryKickSettingsClear();
  }

  /*============================================================================*/
  /* Returns the checksum of the current kickstart image.                       */
  /*============================================================================*/

  ULO memoryKickChksum(void)
  {
    ULO sum, lastsum, i;

    sum = lastsum = 0;
    for (i = 0; i < 0x80000; i += 4) {
      UBY *p = memory_kick + i;
      sum += memoryReadLongFromPointer(p);
      if (sum < lastsum) sum++;
      lastsum = sum;
    }
    return ~sum;
  }

  /*============================================================================*/
  /* Identifies a loaded Kickstart                                              */
  /*============================================================================*/

  STR *memoryKickIdentify(STR *s)
  {
    UBY *rom = memory_kick;
    ULO ver, rev;

    ver = (rom[12] << 8) | rom[13];
    rev = (rom[14] << 8) | rom[15];
    if (ver == 65535) memory_kickimage_version = 28;
    else if (ver < 29) memory_kickimage_version = 29;
    else if (ver > 41) memory_kickimage_version = 41;
    else memory_kickimage_version = ver;
    sprintf(s, 
      "%s (%d.%d)",
      memory_kickimage_versionstrings[memory_kickimage_version - 28],
      ver,
      rev);
    return s;
  }

  /*============================================================================*/
  /* Verifies that a loaded Kickstart is OK                                     */
  /*============================================================================*/

  void memoryKickOK(void)
  {
    ULO chksum, basebank;

    if ((chksum = memoryKickChksum()) != 0)
      memoryKickError(MEMORY_ROM_ERROR_CHECKSUM, chksum);
    else
    {
      basebank = memory_kick[5];
      if ((basebank == 0xf8) || (basebank == 0xfc)) {
	memory_kickimage_basebank = basebank;
	memory_kickimage_none = FALSE;
	memoryKickIdentify(memory_kickimage_versionstr);
	memory_initial_PC = memoryReadLongFromPointer((memory_kick + 4));
	memory_initial_SP = memoryReadLongFromPointer(memory_kick);
      }
      else
	memoryKickError(MEMORY_ROM_ERROR_BAD_BANK, basebank);
    }
  }

  /*============================================================================*/
  /* Returns size of decoded kickstart                                          */
  /*============================================================================*/

  int memoryKickDecodeAF(STR *filename, STR *keyfile)
  {
    STR *keybuffer = NULL;
    ULO keysize, filesize = 0, keypos = 0, c;
    FILE *KF, *RF;

    /* Read key */

    if ((KF = fopen(keyfile, "rb")) != NULL)
    {
      fseek(KF, 0, SEEK_END);
      keysize = ftell(KF);
      keybuffer = (STR*)malloc(keysize);
      if (keybuffer != NULL)
      {
	      fseek(KF, 0, SEEK_SET);
	      fread(keybuffer, 1, keysize, KF);
      }
      fclose(KF);
    }
    else
    {
#ifdef WIN32
      HMODULE hAmigaForeverDLL;
      STR *strLibName = TEXT("amigaforever.dll");
      STR strPath[CFG_FILENAME_LENGTH];

      hAmigaForeverDLL = LoadLibrary(strLibName);
      if (!hAmigaForeverDLL)
      {
	      DWORD dwRet;
        STR strAmigaForeverRoot[CFG_FILENAME_LENGTH] = "";
        dwRet = GetEnvironmentVariable("AMIGAFOREVERROOT", strAmigaForeverRoot, CFG_FILENAME_LENGTH);
	      if((dwRet > 0) && strAmigaForeverRoot) {
		      TCHAR strTemp[CFG_FILENAME_LENGTH];
		      _tcscpy(strTemp, strAmigaForeverRoot);
        	if (strTemp[_tcslen(strTemp) - 1] == '/' || strTemp[_tcslen(strTemp) - 1] == '\\')
        	_tcscat(strTemp, TEXT("\\"));
		      _stprintf(strPath, TEXT("%sPlayer\\%s"), strTemp, strLibName);
		      hAmigaForeverDLL = LoadLibrary(strPath);
	      }

	      if (hAmigaForeverDLL)
        {
	        typedef DWORD (STDAPICALLTYPE *PFN_GetKey)(LPVOID lpvBuffer, DWORD dwSize);
				  PFN_GetKey pfnGetKey = (PFN_GetKey)GetProcAddress(hAmigaForeverDLL, "GetKey");
				  if (pfnGetKey)
				  {
					  keysize = pfnGetKey(NULL, 0);
					  if (keysize)
					  {
						  keybuffer = (STR*)malloc(keysize);
 
						  if (keybuffer)
						  {
							  if (pfnGetKey(keybuffer, keysize) == keysize)
							  {
								  // key successfully retrieved
							  }
                else
                {
                  memoryKickError(MEMORY_ROM_ERROR_KEYFILE, 0);
                  return -1;
                }
						  }
					  }
				  }
				  FreeLibrary(hAmigaForeverDLL);
        }
#endif
      }

      if (!keybuffer)
      {
        memoryKickError(MEMORY_ROM_ERROR_KEYFILE, 0);
        return -1;
      }
    }

    if (!keybuffer)
      return -1;  

    /* Read file */

    if ((RF = fopen(filename, "rb")) != NULL)
    {
      fseek(RF, 11, SEEK_SET);
      while (((c = fgetc(RF)) != EOF) && filesize < 524288)
      {
	      if (keysize != 0)
	        c ^= keybuffer[keypos++];
	      if (keypos == keysize)
	        keypos = 0;
  	    memory_kick[filesize++] = (UBY) c;
      }
      while ((c = fgetc(RF)) != EOF)
	      filesize++;
      fclose(RF);
      free(keybuffer);
      return filesize;
    }
    free(keybuffer);
    return -1;
  }

  /*============================================================================*/
  /* Load Amiga Forever encrypted ROM-files                                     */
  /* Return TRUE if file was handled, that is both if the file is               */
  /* valid, or has wrong version                                                */
  /*============================================================================*/

  int memoryKickLoadAF2(FILE *F)
  {
    ULO version;
    STR IDString[12];

    fread(IDString, 11, 1, F);
    version = IDString[10] - '0';
    IDString[10] = '\0';
    if (stricmp(IDString, "AMIROMTYPE") == 0)
    { /* Header seems OK */
      if (version != 1)
      {
	memoryKickError(MEMORY_ROM_ERROR_AMIROM_VERSION, version);
	return TRUE;  /* File was handled */
      }
      else
      { /* Seems to be a file we can handle */
	ULO size;

	fclose(F);

	size = memoryKickDecodeAF(memory_kickimage,
	  memory_key);
	if (size == -1)
	{
	  memoryKickError(MEMORY_ROM_ERROR_AMIROM_READ, 0);
	  return TRUE;
	}
	if (size != 262144 && size != 524288)
	{
	  memoryKickError(MEMORY_ROM_ERROR_SIZE, size);
	  return TRUE;
	}
	if (size == 262144)
	  memcpy(memory_kick + 262144, memory_kick, 262144);
	memory_kickimage_none = FALSE;
	memoryKickIdentify(memory_kickimage_versionstr);
	return TRUE;
      }
    }
    /* Here, header was not recognized */
    return FALSE;
  }

  /*============================================================================*/
  /* Detect and load kickdisk                                                   */
  /* Based on information provided by Jerry Lawrence                            */
  /*============================================================================*/

  void memoryKickDiskLoad(FILE *F)
  {
    STR head[5];

    /* Check header */

    fseek(F, 0, SEEK_SET);
    fread(head, 4, 1, F);
    head[4] = '\0';
    if (strcmp(head, "KICK") != 0)
    {
      memoryKickError(MEMORY_ROM_ERROR_KICKDISK_NOT, 0);
      return;
    }
    fread(head, 3, 1, F);
    head[3] = '\0';
    if (strcmp(head, "SUP") == 0)
    {
      memoryKickError(MEMORY_ROM_ERROR_KICKDISK_SUPER, 0);
      return;
    }
    fseek(F, 512, SEEK_SET); /* Load image */
    fread(memory_kick, 262144, 1, F);
    memcpy(memory_kick + 262144, memory_kick, 262144);
  }

  /*============================================================================*/
  /* memory_kickimage is the file we want to load                               */
  /*============================================================================*/

  void memoryKickLoad(void)
  {
    FILE *F;
    BOOLE kickdisk = FALSE;
    STR *suffix, *lastsuffix;
    BOOLE afkick = FALSE;

    /* New file is different from previous */
    /* Must load file */

    fs_navig_point *fsnp;

    memory_kickimage_none = FALSE;/* Initially Kickstart is expected to be OK */
    if ((fsnp = fsWrapMakePoint(memory_kickimage)) == NULL)
      memoryKickError(MEMORY_ROM_ERROR_EXISTS_NOT, 0);
    else
    {
      if (fsnp->type != FS_NAVIG_FILE)
	memoryKickError(MEMORY_ROM_ERROR_FILE, 0);
      else
      { /* File passed initial tests */
	if ((F = fopen(memory_kickimage, "rb")) == NULL)
	  memoryKickError(MEMORY_ROM_ERROR_EXISTS_NOT, 0);
	else memory_kickimage_size = fsnp->size;
      }
      free(fsnp);
    }

    /* Either the file is open, or memory_kickimage_none is TRUE */ 

    if (!memory_kickimage_none)
    {

      /* File opened successfully */

      /* Kickdisk flag */

      suffix = strchr(memory_kickimage, '.');
      if (suffix != NULL)
      {
	lastsuffix = suffix;
	while ((suffix = strchr(lastsuffix + 1, '.')) != NULL)
	  lastsuffix = suffix;
	kickdisk = (stricmp(lastsuffix + 1, "ADF") == 0);
      }
      /* mem_loadrom_af2 will return TRUE if file was handled */
      /* Handled also means any error conditions */
      /* The result can be that no kickstart was loaded */

      if (kickdisk)
	memoryKickDiskLoad(F);
      else
	afkick = memoryKickLoadAF2(F);
      if (!kickdisk && !afkick)
      { /* Normal kickstart image */
	fseek(F, 0, SEEK_SET);
	if (memory_kickimage_size == 262144)
	{   /* Load 256k ROM */
	  fread(memory_kick, 1, 262144, F);
	  memcpy(memory_kick + 262144, memory_kick, 262144);
	}
	else if (memory_kickimage_size == 524288)/* Load 512k ROM */
	  fread(memory_kick, 1, 524288, F);
	else
	{                                     /* Rom size is wrong */
	  memoryKickError(MEMORY_ROM_ERROR_SIZE, memory_kickimage_size);
	}
	fclose(F);
      }
    }
    if (!memory_kickimage_none)
      memoryKickOK();
  }

  /*============================================================================*/
  /* Clear memory used for kickstart image                                      */
  /*============================================================================*/

  void memoryKickClear(void)
  {
    memset(memory_kick, 0, 0x80000);
  }

  /*============================================================================*/
  /* Top-level memory access functions                                          */
  /*============================================================================*/

  /*==============================================================================
  Raises exception 3 when a word or long is accessing an odd address
  and the CPU is < 020
  ==============================================================================*/

  static void memoryOddRead(ULO address)
  {
    if (address & 1)
    {
      if (cpuGetModelMajor() < 2)
      {
	memory_fault_read = TRUE;
	memory_fault_address = address;
	cpuThrowAddressErrorException();
      }
    }
  }

  static void memoryOddWrite(ULO address)
  {
    if (address & 1)
    {
      if (cpuGetModelMajor() < 2)
      {
	memory_fault_read = FALSE;
	memory_fault_address = address;
	cpuThrowAddressErrorException();
      }
    }
  }

  UBY memoryReadByteViaBankHandler(ULO address)
  {
    return memory_bank_readbyte[address >> 16](address);
  }

__inline  UBY memoryReadByte(ULO address)
  {
    UBY *memory_ptr = memory_bank_pointer[address>>16];
    if (memory_ptr != NULL)
    {
      UBY *p = memory_ptr + address;
      return memoryReadByteFromPointer(p);
    }
    return memoryReadByteViaBankHandler(address);
  }

  UWO memoryReadWordViaBankHandler(ULO address)
  {
    memoryOddRead(address);
    return memory_bank_readword[address >> 16](address);
  }

__inline  UWO memoryReadWord(ULO address)
  {
    UBY *memory_ptr = memory_bank_pointer[address>>16];
    if ((memory_ptr != NULL) && !(address & 1))
    {
      UBY *p = memory_ptr + address;
      return memoryReadWordFromPointer(p);
    }
    return memoryReadWordViaBankHandler(address);
  }

  ULO memoryReadLongViaBankHandler(ULO address)
  {
    memoryOddRead(address);
    return memory_bank_readlong[address >> 16](address);
  }

  __inline ULO memoryReadLong(ULO address)
  {
    UBY *memory_ptr = memory_bank_pointer[address>>16];
    if ((memory_ptr != NULL) && !(address & 1))
    {
      UBY *p = memory_ptr + address;
      return memoryReadLongFromPointer(p);
    }
    return memoryReadLongViaBankHandler(address);
  }

  void memoryWriteByte(UBY data, ULO address)
  {
    ULO bank = address>>16;
    if (memory_bank_pointer_can_write[bank])
    {
      memoryWriteByteToPointer(data, memory_bank_pointer[bank] + address);
    }
    else
    {
      memory_bank_writebyte[bank](data, address);
    }
  }

  void memoryWriteWordViaBankHandler(UWO data, ULO address)
  {
    memoryOddWrite(address);
    memory_bank_writeword[address >> 16](data, address);
  }

  void memoryWriteWord(UWO data, ULO address)
  {
    ULO bank = address>>16;
    if (memory_bank_pointer_can_write[bank] && !(address & 1))
    {
      memoryWriteWordToPointer(data, memory_bank_pointer[bank] + address);
    }
    else
    {
      memoryWriteWordViaBankHandler(data, address);
    }
  }

  void memoryWriteLongViaBankHandler(ULO data, ULO address)
  {
    memoryOddWrite(address);
    memory_bank_writelong[address >> 16](data, address);
  }

  void memoryWriteLong(ULO data, ULO address)
  {
    ULO bank = address>>16;
    if (memory_bank_pointer_can_write[bank] && !(address & 1))
    {
      memoryWriteLongToPointer(data, memory_bank_pointer[bank] + address);
    }
    else
    {
      memoryWriteLongViaBankHandler(data, address);
    }
  }

  /*============================================================================*/
  /* Memory configuration interface                                             */
  /*============================================================================*/

  BOOLE memorySetChipSize(ULO chipsize)
  {
    BOOLE needreset = (memory_chipsize != chipsize);
    memory_chipsize = chipsize;
    return needreset;
  }

  ULO memoryGetChipSize(void)
  {
    return memory_chipsize;
  }

  BOOLE memorySetFastSize(ULO fastsize)
  {
    BOOLE needreset = (memory_fastsize != fastsize);
    memory_fastsize = fastsize;
    if (needreset) memoryFastAllocate();
    return needreset;
  }

  ULO memoryGetFastSize(void)
  {
    return memory_fastsize;
  }

  void memorySetFastAllocatedSize(ULO fastallocatedsize)
  {
    memory_fastallocatedsize = fastallocatedsize;
  }

  ULO memoryGetFastAllocatedSize(void)
  {
    return memory_fastallocatedsize;
  }

  BOOLE memorySetSlowSize(ULO slowsize)
  {
    BOOLE needreset = (memory_slowsize != slowsize);
    memory_slowsize = slowsize;
    return needreset;
  }

  ULO memoryGetSlowSize(void)
  {
    return memory_slowsize;
  }

  BOOLE memorySetUseAutoconfig(BOOLE useautoconfig)
  {
    BOOLE needreset = memory_useautoconfig != useautoconfig;
    memory_useautoconfig = useautoconfig;
    return needreset;
  }

  BOOLE memoryGetUseAutoconfig(void)
  {
    return memory_useautoconfig;
  }

  BOOLE memorySetAddress32Bit(BOOLE address32bit)
  {
    BOOLE needreset = memory_address32bit != address32bit;
    memory_address32bit = address32bit;
    return needreset;
  }

  BOOLE memoryGetAddress32Bit(void)
  {
    return memory_address32bit;
  }

  BOOLE memorySetKickImage(STR *kickimage)
  {
    BOOLE needreset = !!strncmp(memory_kickimage, kickimage, CFG_FILENAME_LENGTH);
    strncpy(memory_kickimage, kickimage, CFG_FILENAME_LENGTH);
    if (needreset) memoryKickLoad();
    return needreset;
  }

  STR *memoryGetKickImage(void)
  {
    return memory_kickimage;
  }

  void memorySetKey(STR *key)
  {
    strncpy(memory_key, key, CFG_FILENAME_LENGTH);
  }

  STR *memoryGetKey(void)
  {
    return memory_key;
  }

  ULO memoryGetKickImageBaseBank(void)
  {
    return memory_kickimage_basebank;
  }

  ULO memoryGetKickImageVersion(void)
  {
    return memory_kickimage_version;
  }

  BOOLE memoryGetKickImageOK(void)
  {
    return !memory_kickimage_none;
  }

  ULO memoryInitialPC(void)
  {
    return memory_initial_PC;
  }

  ULO memoryInitialSP(void)
  {
    return memory_initial_SP;
  }

  /*============================================================================*/
  /* Sets all settings a clean state                                            */
  /*============================================================================*/

  void memoryChipSettingsClear(void)
  {
    memorySetChipSize(0x200000);
    memoryChipClear();
  }

  void memoryFastSettingsClear(void)
  {
    memory_fast = NULL;
    memory_fast_baseaddress = 0;
    memorySetFastAllocatedSize(0);
    memorySetFastSize(0);
  }

  void memorySlowSettingsClear(void)
  {
    memorySetSlowSize(0x1c0000);
    memorySlowClear();
  }

  void memoryIoSettingsClear(void)
  {
    memoryIoClear();
  }

  void memoryKickSettingsClear(void)
  {
    memory_kickimage[0] = '\0';
    memory_kickimage_none = TRUE;
    memoryKickClear();
  }

  void memoryEmemSettingsClear(void)
  {
    memoryEmemCardsRemove();
    memoryEmemClear();
  }

  void memoryDmemSettingsClear(void)
  {
    memoryDmemSetCounter(0);
    memoryDmemClear();
  }

  void memoryNoiseSettingsClear(void)
  {
    memory_noise[0] = 0;
    memory_noise[1] = 0xffffffff;
    memory_noisecounter = 0;
  }

  void memoryMysterySettingsClear(void)
  {
    memory_mystery_value = 0xff00ff00;
  }

  void memoryBankSettingsClear(void)
  {
    memoryBankClearAll();
  }

  void memoryIoHandlersInstall(void)
  {
    memorySetIoReadStub(0x018, rserdatr);
    memorySetIoReadStub(0x01c, rintenar);
    memorySetIoReadStub(0x01e, rintreqr);
    memorySetIoWriteStub(0x09a, wintena);
    memorySetIoWriteStub(0x09c, wintreq);
  }

  /*==============*/
  /* Generic init */
  /*==============*/

  void memorySaveState(FILE *F)
  {
    fwrite(&memory_chipsize, sizeof(memory_chipsize), 1, F);
    fwrite(&memory_slowsize, sizeof(memory_slowsize), 1, F);
    fwrite(&memory_fastsize, sizeof(memory_fastsize), 1, F);
    if (memory_chipsize > 0)
    {
      fwrite(&memory_chip[0], sizeof(UBY), memory_chipsize, F);
    }
    if (memory_slowsize > 0)
    {
      fwrite(&memory_slow[0], sizeof(UBY), memory_slowsize, F);
    }
    if (memory_fastsize > 0)
    {
      fwrite(memory_fast, sizeof(UBY), memory_fastsize, F);
    }
  }

  void memoryLoadState(FILE *F)
  {
    fread(&memory_chipsize, sizeof(memory_chipsize), 1, F);
    fread(&memory_slowsize, sizeof(memory_slowsize), 1, F);
    fread(&memory_fastsize, sizeof(memory_fastsize), 1, F);
    if (memory_chipsize > 0)
    {
      fread(&memory_chip[0], sizeof(UBY), memory_chipsize, F);
    }
    if (memory_slowsize > 0)
    {
      fread(&memory_slow[0], sizeof(UBY), memory_slowsize, F);
    }
    if (memory_fastsize > 0)
    {
      fread(memory_fast, sizeof(UBY), memory_fastsize, F);
    }
  }

  void memoryEmulationStart(void)
  {
    memoryIoClear();
    memoryIoHandlersInstall();
  }

  void memoryEmulationStop(void)
  {
  }

  void memorySoftReset(void)
  {
    memoryDmemClear();
    memoryEmemClear();
    memoryEmemCardsRemove();
    memoryFastCardAdd();
    intreq = intena = intenar = 0;
    memoryBankClearAll();
    memoryChipMap(TRUE);
    memorySlowMap();
    memoryIoMap();
    memoryEmemMap();
    memoryDmemMap();
    memoryMysteryMap();
    memoryKickMap();
  }

  void memoryHardReset(void)
  {
    memoryChipClear(),
    memoryFastClear();
    memorySlowClear();
    memoryDmemClear();
    memoryEmemClear();
    memoryEmemCardsRemove();
    memoryFastCardAdd();
    intreq = intena = intenar = 0;
    memoryBankClearAll();
    memoryChipMap(TRUE);
    memorySlowMap();
    memoryIoMap();
    memoryEmemMap();
    memoryDmemMap();
    memoryMysteryMap();
    memoryKickMap();
  }

  void memoryHardResetPost(void)
  {
    memoryEmemCardInit();
  }

  void memoryStartup(void)
  {
    memorySetAddress32Bit(TRUE);
    memoryBankSettingsClear();
    memorySetAddress32Bit(FALSE);
    memoryChipSettingsClear();
    memoryFastSettingsClear();
    memorySlowSettingsClear();
    memoryIoSettingsClear();
    memoryKickSettingsClear();
    memoryEmemSettingsClear();
    memoryDmemSettingsClear();
    memoryNoiseSettingsClear();
    memoryMysterySettingsClear(); /* ;-) */
  }

  void memoryShutdown(void)
  {
    memoryFastFree();
  }