Update to bsnes v028 release.

Changelog:
    - OpenGL (with hardware filter mode support) and SDL video drivers added to Linux port
    - OpenAL (with speed regulation disable support) and OSS audio drivers added to Linux port [Nach]
    - SDL input driver (with joypad support) added to Linux port
    - Emulator pause option added
    - Added option to select behavior of bsnes when idle: allow input, ignore input or pause emulator
    - Added support to remap common GUI actions to key/joypad presses on the "Input Configuration" screen
    - bsnes will now clamp the video output size when it is larger than the screen resolution
    - GUI library has been enhanced, and renamed to hiro
    - Fullscreen mode now always centers video, rather than approximates
    - Fullscreen mode now works correctly on Linux/Openbox
    - Extra layer of abstraction in src/ui has been removed, as GUI lib unifies all ports anyway
    - Video, audio and input drivers unified into standard library, named ruby
    - All custom headers have been merged into a new template library, named nall
    - Makefile rewritten, vastly improved. Allows quick toggling of compiled-in drivers
    - Makefile: all object files now placed in /src/obj, binary placed in /
    - libco greatly enhanced, no longer requires an assembler to build [byuu, blargg, Nach]
    - libco SJLJ driver added; bsnes should now build on any Unix-derivative now (Solaris, OS X, PS3, etc) [Nach]
    - Fixed register $213e.d4 PPU1 open bus behavior [zones]
    - Windows port will not activate screensaver while bsnes is running [Nightcrawler]
    - Visual C++ target no longer requires stdint.h
    - And lots more -- mostly code refactoring related

license.txt

@@ -0,0 +1,86 @@
+bsnes (TM) Reference License
+Copyright (C) 2004 - 2008 byuu
+All rights reserved
+
+1. Definitions
+
+The terms "reproduce", "reproduction", "distribute" and "distribution" have the
+same meaning here as under U.S. copyright law.
+
+"The software" means this software package as a whole, including, but not
+limited to, this license, binaries, source code, documentation, and data.
+
+"You" means the licensee of the software.
+
+"The licensor" means the copyright holder of the software, byuu.
+
+2. Grant of Rights
+
+Subject to the terms of this license, the licensor grants you a
+non-transferable, non-exclusive, worldwide, royalty-free copyright license to
+reproduce the software for non-commercial use only, provided the software
+remains unmodified, and there is no charge for the software itself, its' use,
+nor for the medium upon which the software is distributed. The reproduction of
+modified or derivative works of the software is strictly prohibited, except when
+transmitted solely to the licensor.
+
+3. Limitations
+
+This license does not grant you any rights to use the licensor's name, logo or
+trademarks.
+
+The software is provided "as is", and any express or implied warranties,
+including, but not limited to, the implied warranties of merchantability and
+fitness for a particular purpose are disclaimed. In no event shall the licensor
+be liable for any direct, indirect, incidental, special, exemplary, or
+consequential damages (including, but not limited to, procurement of substitute
+goods or services; loss of use, data, or profits; or business interruption)
+however caused and on any theory of liability, whether in contract, strict
+liability, or tort (including negligence or otherwise) arising in any way out of
+the use of the software, even if advised of the possibility of such damage.
+
+In the event that this license is determined to be invalid or unenforceable, the
+Grant of Rights will become null and void, and no rights shall be granted to the
+licensee, within the scope of U.S. copyright law.
+
+4. Exemptions
+
+The software includes the work of other copyright holders, which is licensed
+under different agreements, and exempt from this license. Below is a complete
+list of all such software, and their respective copyright holders and licenses.
+Further, respective source code files are labeled with their correct licensing
+information in the header. The lack of such a header indicates said file falls
+under the bsnes license.
+
+HQ2x filter, author: MaxST, license: LGPL
+JMA decompressor, author: NSRT Team, license: GPL (*)
+NTSC filter, author: blargg, license: LGPL
+zlib decompressor, license: zlib license
+
+(*) bsnes has received an exemption from the copyright holder to use this work.
+
+The software also includes works which have been released to the public domain,
+which are not bound to any licensing agreements. Below is a complete list of all
+such software.
+
+libco, author: byuu
+libui, author: byuu
+OBC-1 emu, author: byuu
+S-DD1 emu, author: Andreas Naive
+S-RTC emu, author: byuu
+
+Any software listed above as exemptions may be relicensed individually from
+bsnes under their respective terms. However, no bsnes licensed portions can be
+combined with such a derivative work.
+
+The software also includes the work of other copyright holders, which is
+licensed under the terms of the bsnes license, with permission to do so from the
+respective authors. Below is a complete list of all such software.
+
+Cx4 emu, authors: anomie, Overload, zsKnight, Nach
+DSP-1 emu, authors: Overload, John Weidman, Neviksti, Andreas Naive
+DSP-2 emu, author: Overload
+DSP-3 emu, authors: John Weidman, Kris Bleakley, Lancer, z80 gaiden
+DSP-4 emu, authors: Dreamer Nom, John Weidman, Kris Bleakley, Nach, z80 gaiden
+S-DSP emu, author: blargg
+ST-010 emu, authors: John Weidman, Matthew Kendora, Overload, Feather

readme.txt

@@ -0,0 +1,78 @@
+bsnes
+Version: 0.028
+Author: byuu
+
+--------
+General:
+--------
+bsnes is a Super Nintendo / Super Famicom emulator that began on
+October 14th, 2004.
+
+The latest version can be downloaded from:
+http://byuu.org/
+
+Please see license.txt for important licensing information.
+
+------------------
+Known Limitations:
+------------------
+S-CPU
+- Invalid DMA / HDMA transfers not fully emulated
+- Multiply / Divide register delays not implemented
+
+S-PPU
+- Uses scanline-based renderer. This is very inaccurate, but few (if any)
+  games rely on mid-scanline writes to function correctly
+- Does not support FirstSprite+Y priority
+- OAM / CGRAM accesses during active display not supported correctly
+- RTO flags are not calculated on frames that are skipped when frameskipping
+  is enabled. This provides a major speedup, however it will cause in issues
+  in games that test these flags, eg the SNES Test Program Electronics Test.
+  Turning frameskipping off will allow RTO flag calculation on every frame
+
+Hardware Bugs
+- S-CPU.r1 HDMA crashing bug not emulated
+- S-CPU<>S-SMP communication bus conflicts not emulated
+
+---------------------
+Unsupported Hardware:
+---------------------
+SA-1
+Coprocessor used in many popular games, including:
+- Dragon Ball Z Hyper Dimension
+- Kirby Super Star
+- Kirby's Dreamland 3
+- Marvelous
+- SD Gundam G-NEXT
+- Super Mario RPG
+
+Super FX
+Coprocessor used in many popular games, including:
+- Doom
+- Star Fox
+- Star Fox 2 (unreleased beta)
+- Super Mario World 2: Yoshi's Island
+
+SPC7110
+Coprocessor used only by the following games:
+- Far East of Eden Zero
+- Far East of Eden Zero: Shounen Jump no Shou
+- Momotarou Densetsu Happy
+- Super Power League 4
+
+ST-011
+SETA DSP used only by Quick-move Shogi Match with Nidan Rank-holder Morita
+
+ST-018
+SETA RISC CPU used only by Quick-move Shogi Match with Nidan Rank-holder Morita 2
+
+Super Gameboy
+Cartridge passthrough used for playing Gameboy games
+
+------------------------
+Unsupported Controllers:
+------------------------
+Mouse
+Super Scope
+Justifier
+Multitap (4-port and 5-port)

src/Makefile

@@ -1,274 +1,303 @@
-######################
-### bsnes makefile ###
-######################
-
-ifeq ($(PLATFORM),)
-_null_: help
-endif
-
-##################################
-### platform-specific settings ###
-##################################
-
-ifeq ($(PLATFORM),x-gcc-lui)
-OS = unix
-CC = gcc
-CFLAGS = -O3 -fomit-frame-pointer -ffast-math -DPLATFORM_X -DCOMPILER_GCC -DPROCESSOR_X86 -DUI_LUI `pkg-config --cflags gtk+-2.0`
-AS = nasm
-ASFLAGS = -f elf
-LIBS = `pkg-config --libs gtk+-2.0` -lXv -lao
-LIBCO = libco_x86
-LIBUI = libui_gtk
-endif
-
-ifeq ($(PLATFORM),x-gcc-lui-x64)
-OS = unix
-CC = gcc
-CFLAGS = -O3 -fomit-frame-pointer -ffast-math -DPLATFORM_X -DCOMPILER_GCC -DPROCESSOR_X86_64 -DUI_LUI `pkg-config --cflags gtk+-2.0`
-AS = yasm
-ASFLAGS = -f elf64
-LIBS = `pkg-config --libs gtk+-2.0` -lXv -lao
-LIBCO = libco_x86_64
-LIBUI = libui_gtk
-endif
-
-ifeq ($(PLATFORM),win-visualc-lui)
-OS = win
-CC = cl
-CFLAGS = /nologo /wd4996 /O2 /EHsc /DPLATFORM_WIN /DCOMPILER_VISUALC /DPROCESSOR_X86 /DUI_LUI
-AS = nasm
-ASFLAGS = -f win32 -DWIN32
-LIBS = d3d9.lib ddraw.lib dsound.lib dinput8.lib dxguid.lib
-LIBCO = libco_x86
-LIBUI = libui_win
-endif
-
-ifeq ($(PLATFORM),win-visualc-lui-pgi)
-OS = win
-CC = cl
-CFLAGS = /nologo /wd4996 /O2 /GL /EHsc /DPLATFORM_WIN /DCOMPILER_VISUALC /DPROCESSOR_X86 /DUI_LUI
-AS = nasm
-ASFLAGS = -f win32 -DWIN32
-LIBS = d3d9.lib ddraw.lib dsound.lib dinput8.lib dxguid.lib
-LINK = /link /PGD:bsnes.pgd /LTCG:PGINSTRUMENT
-LIBCO = libco_x86
-LIBUI = libui_win
-endif
-
-ifeq ($(PLATFORM),win-visualc-lui-pgo)
-OS = win
-CC = cl
-CFLAGS = /nologo /wd4996 /O2 /GL /EHsc /DPLATFORM_WIN /DCOMPILER_VISUALC /DPROCESSOR_X86 /DUI_LUI
-AS = nasm
-ASFLAGS = -f win32 -DWIN32
-LIBS = d3d9.lib ddraw.lib dsound.lib dinput8.lib dxguid.lib
-LINK = /link /PGD:bsnes.pgd /LTCG:PGOPTIMIZE
-LIBCO = libco_x86
-LIBUI = libui_win
-endif
-
-#####################################
-### compiler / assembler switches ###
-#####################################
-
-ifeq ($(CC),gcc)
-OUT = -obsnes
-CPP = g++
-OBJ = o
-CARGS = -c $< -o $@
-DEFINE = -D
-endif
-
-ifeq ($(CC),cl)
-OUT = /Febsnes
-CPP = cl
-OBJ = obj
-CARGS = /c $< /Fo$@
-DEFINE = /D
-endif
-
-ifeq ($(AS),nasm)
-ASARGS = $< -o $@
-endif
-
-ifeq ($(AS),yasm)
-ASARGS = $< -o $@
-endif
-
-###################
-### OS switches ###
-###################
-
-ifeq ($(OS),unix)
-RM = rm -f
-endif
-
-ifeq ($(OS),win)
-OUT := $(OUT).exe
-RM = del
-LIBS += kernel32.lib user32.lib gdi32.lib shell32.lib winmm.lib comdlg32.lib comctl32.lib
-endif
-
-####################################
-### main target and dependencies ###
-####################################
-
-OBJECTS = main.$(OBJ) $(LIBCO).$(OBJ) $(LIBUI).$(OBJ) \
-  libstring.$(OBJ) \
-  reader.$(OBJ) cart.$(OBJ) cheat.$(OBJ) memory.$(OBJ) bmemory.$(OBJ) \
-  cpu.$(OBJ) scpu.$(OBJ) smp.$(OBJ) ssmp.$(OBJ) bdsp.$(OBJ) ppu.$(OBJ) \
-  bppu.$(OBJ) snes.$(OBJ) srtc.$(OBJ) sdd1.$(OBJ) c4.$(OBJ) dsp1.$(OBJ) \
-  dsp2.$(OBJ) obc1.$(OBJ)
-
-ifeq ($(GZIP_SUPPORT),true)
-  OBJECTS += adler32.$(OBJ) compress.$(OBJ) crc32.$(OBJ) deflate.$(OBJ) \
-    gzio.$(OBJ) inffast.$(OBJ) inflate.$(OBJ) inftrees.$(OBJ) ioapi.$(OBJ) \
-    trees.$(OBJ) unzip.$(OBJ) zip.$(OBJ) zutil.$(OBJ)
-  CFLAGS += $(DEFINE)GZIP_SUPPORT
-endif
-
-ifeq ($(JMA_SUPPORT),true)
-  OBJECTS += jma.$(OBJ) jcrc32.$(OBJ) lzmadec.$(OBJ) 7zlzma.$(OBJ) \
-    iiostrm.$(OBJ) inbyte.$(OBJ) lzma.$(OBJ) winout.$(OBJ)
-  CFLAGS += $(DEFINE)JMA_SUPPORT
-endif
-
-ifeq ($(OS),win)
-  ifeq ($(CC),cl)
-    OBJECTS += bsnes.res
-  endif
-endif
-
-all: $(OBJECTS)
-	$(CPP) $(OUT) $(CFLAGS) $(OBJECTS) $(LIBS) $(LINK)
-#	mt -nologo -manifest bsnes.exe.manifest -outputresource:bsnes.exe;1
-
-######################
-### implicit rules ###
-######################
-
-%.$(OBJ): $<
-	$(if $(filter %.asm,$<),$(AS) $(ASFLAGS) $(ASARGS))
-	$(if $(filter %.c,$<),$(CC) $(CFLAGS) $(CARGS))
-	$(if $(filter %.cpp,$<),$(CPP) $(CFLAGS) $(CARGS))
-
-#########################
-### platform-specific ###
-#########################
-main.$(OBJ): ui/main.cpp config/* ui/* ui/video/* ui/audio/* ui/input/* \
-ui/lui/* ui/lui/settings/* \
-ui/win/* ui/win/settings/* ui/win/debugger/*
-bsnes.res  : ui/bsnes.rc ; rc /r /fobsnes.res ui/bsnes.rc
-
-#############
-### libco ###
-#############
-libco_x86.$(OBJ)   : lib/libco_x86.asm lib/*
-libco_x86_64.$(OBJ): lib/libco_x86_64.asm lib/*
-
-#############
-### libui ###
-#############
-libui_gtk.$(OBJ): lib/libui_gtk.cpp lib/*
-libui_win.$(OBJ): lib/libui_win.cpp lib/*
-
-#################
-### libraries ###
-#################
-libstring.$(OBJ): lib/libstring.cpp lib/*
-
-#################
-### utilities ###
-#################
-reader.$(OBJ): reader/reader.cpp reader/*
-cart.$(OBJ)  : cart/cart.cpp cart/*
-cheat.$(OBJ) : cheat/cheat.cpp cheat/*
-
-##############
-### memory ###
-##############
-memory.$(OBJ) : memory/memory.cpp memory/*
-bmemory.$(OBJ): memory/bmemory/bmemory.cpp memory/bmemory/* memory/bmemory/mapper/*
-
-###########
-### cpu ###
-###########
-cpu.$(OBJ) : cpu/cpu.cpp cpu/*
-scpu.$(OBJ): cpu/scpu/scpu.cpp cpu/scpu/* cpu/scpu/core/* cpu/scpu/dma/* cpu/scpu/memory/* cpu/scpu/mmio/* cpu/scpu/timing/*
-
-###########
-### smp ###
-###########
-smp.$(OBJ) : smp/smp.cpp smp/*
-ssmp.$(OBJ): smp/ssmp/ssmp.cpp smp/ssmp/* smp/ssmp/core/* smp/ssmp/memory/* smp/ssmp/timing/*
-
-###########
-### dsp ###
-###########
-adsp.$(OBJ): dsp/adsp/adsp.cpp dsp/adsp/*
-bdsp.$(OBJ): dsp/bdsp/bdsp.cpp dsp/bdsp/*
-
-###########
-### ppu ###
-###########
-ppu.$(OBJ) : ppu/ppu.cpp ppu/*
-bppu.$(OBJ): ppu/bppu/bppu.cpp ppu/bppu/*
-
-############
-### snes ###
-############
-snes.$(OBJ): snes/snes.cpp snes/* snes/scheduler/* snes/video/* snes/audio/* snes/input/*
-
-#####################
-### special chips ###
-#####################
-srtc.$(OBJ): chip/srtc/srtc.cpp chip/srtc/*
-sdd1.$(OBJ): chip/sdd1/sdd1.cpp chip/sdd1/*
-c4.$(OBJ)  : chip/c4/c4.cpp chip/c4/*
-dsp1.$(OBJ): chip/dsp1/dsp1.cpp chip/dsp1/*
-dsp2.$(OBJ): chip/dsp2/dsp2.cpp chip/dsp2/*
-obc1.$(OBJ): chip/obc1/obc1.cpp chip/obc1/*
-
-############
-### zlib ###
-############
-adler32.$(OBJ) : reader/zlib/adler32.c reader/zlib/*
-compress.$(OBJ): reader/zlib/compress.c reader/zlib/*
-crc32.$(OBJ)   : reader/zlib/crc32.c reader/zlib/*
-deflate.$(OBJ) : reader/zlib/deflate.c reader/zlib/*
-gzio.$(OBJ)    : reader/zlib/gzio.c reader/zlib/*
-inffast.$(OBJ) : reader/zlib/inffast.c reader/zlib/*
-inflate.$(OBJ) : reader/zlib/inflate.c reader/zlib/*
-inftrees.$(OBJ): reader/zlib/inftrees.c reader/zlib/*
-ioapi.$(OBJ)   : reader/zlib/ioapi.c reader/zlib/*
-trees.$(OBJ)   : reader/zlib/trees.c reader/zlib/*
-unzip.$(OBJ)   : reader/zlib/unzip.c reader/zlib/*
-zip.$(OBJ)     : reader/zlib/zip.c reader/zlib/*
-zutil.$(OBJ)   : reader/zlib/zutil.c reader/zlib/*
-
-###########
-### jma ###
-###########
-jma.$(OBJ)    : reader/jma/jma.cpp reader/jma/*
-jcrc32.$(OBJ) : reader/jma/jcrc32.cpp reader/jma/*
-lzmadec.$(OBJ): reader/jma/lzmadec.cpp reader/jma/*
-7zlzma.$(OBJ) : reader/jma/7zlzma.cpp reader/jma/*
-iiostrm.$(OBJ): reader/jma/iiostrm.cpp reader/jma/*
-inbyte.$(OBJ) : reader/jma/inbyte.cpp reader/jma/*
-lzma.$(OBJ)   : reader/jma/lzma.cpp reader/jma/*
-winout.$(OBJ) : reader/jma/winout.cpp reader/jma/*
-
-####################
-### misc targets ###
-####################
-clean:
-	-@$(RM) *.$(OBJ)
-	-@$(RM) *.res
-	-@$(RM) *.pgd
-	-@$(RM) *.pgc
-	-@$(RM) *.ilk
-	-@$(RM) *.pdb
-	-@$(RM) *.manifest
-
-help:
-	@echo Please specify which platform to compile for with PLATFORM=platform_name
+include lib/nall/Makefile.string
+
+prefix = /usr/local
+arch = ARCH_LSB
+
+################
+### compiler ###
+################
+
+ifneq ($(findstring gcc,$(compiler)),) # GCC family
+  flags = -O3 -fomit-frame-pointer -Ilib
+  c = $(compiler) $(flags)
+  cpp = $(subst cc,++,$(compiler)) $(flags)
+  obj = o
+  rule = -c $< -o $@
+  link =
+  mkbin = -o$1
+  mkdef = -D$1
+  mklib = -l$1
+else ifeq ($(compiler),cl) # Visual C++
+  flags = /nologo /wd4355 /wd4996 /O2 /EHsc /Ilib
+  c = cl $(flags)
+  cpp = cl $(flags)
+  obj = obj
+  rule = /c $< /Fo$@
+  link = /link
+  mkbin = /Fe$1
+  mkdef = /D$1
+  mklib = $1.lib
+else
+  unknown_compiler: help;
+endif
+
+##########
+### os ###
+##########
+
+ifeq ($(platform),x) # X11
+  ruby = video.glx video.xv video.sdl audio.openal audio.oss audio.ao input.sdl input.x
+  arch += PLATFORM_X
+  link += `pkg-config --libs gtk+-2.0`
+  delete = rm -f $1
+else ifeq ($(platform),win) # Windows
+  ruby = video.direct3d video.directdraw video.gdi audio.directsound input.directinput
+  arch += PLATFORM_WIN
+  link += $(if $(findstring mingw,$(compiler)),-mwindows)
+  link += $(call mklib,uuid)
+  link += $(call mklib,kernel32)
+  link += $(call mklib,user32)
+  link += $(call mklib,gdi32)
+  link += $(call mklib,shell32)
+  link += $(call mklib,winmm)
+  link += $(call mklib,comdlg32)
+  link += $(call mklib,comctl32)
+  delete = $(if $(findstring i586-mingw-gcc,$(compiler)),rm -f $1,del $(subst /,\,$1))
+else
+  unknown_platform: help;
+endif
+
+############
+### ruby ###
+############
+
+link += $(if $(findstring video.direct3d,$(ruby)),$(call mklib,d3d9))
+link += $(if $(findstring video.directdraw,$(ruby)),$(call mklib,ddraw))
+link += $(if $(findstring video.glx,$(ruby)),$(call mklib,GL))
+link += $(if $(findstring video.xv,$(ruby)),$(call mklib,Xv))
+link += $(if $(findstring audio.ao,$(ruby)),$(call mklib,ao))
+link += $(if $(findstring audio.directsound,$(ruby)),$(call mklib,dsound))
+link += $(if $(findstring audio.openal,$(ruby)),$(call mklib,openal) $(call mklib,alut))
+link += $(if $(findstring input.directinput,$(ruby)),$(call mklib,dinput8) $(call mklib,dxguid))
+link += $(if $(findstring input.sdl,$(ruby)),`sdl-config --libs`)
+
+####################################
+### main target and dependencies ###
+####################################
+
+objects = main libco hiro ruby $(ruby) string reader cart cheat \
+  memory smemory cpu scpu smp ssmp bdsp ppu bppu snes \
+  bsx srtc sdd1 cx4 dsp1 dsp2 dsp3 dsp4 obc1 st010
+
+ifeq ($(enable_gzip),true)
+  objects += adler32 compress crc32 deflate gzio inffast inflate inftrees ioapi trees unzip zip zutil
+  flags += $(call mkdef,GZIP_SUPPORT)
+endif
+
+ifeq ($(enable_jma),true)
+  objects += jma jcrc32 lzmadec 7zlzma iiostrm inbyte lzma winout
+  flags += $(call mkdef,JMA_SUPPORT)
+endif
+
+arch := $(patsubst %,$(call mkdef,%),$(arch))
+objects := $(patsubst %,obj/%.$(obj),$(objects))
+rubydef := $(foreach c,$(subst .,_,$(call strupper,$(ruby))),$(call mkdef,$c))
+
+# Windows resource file
+ifeq ($(platform),win)
+  ifeq ($(compiler),cl)
+    objects += obj/bsnes.res
+  else ifneq ($(findstring gcc,$(compiler)),)
+    objects += obj/bsnesrc.$(obj)
+  endif
+endif
+
+################
+### implicit ###
+################
+
+compile = \
+  $(strip \
+    $(if $(filter %.c,$<), \
+      $(c) $1 $(rule), \
+      $(if $(filter %.cpp,$<), \
+        $(cpp) $1 $(rule) \
+      ) \
+    ) \
+  )
+
+%.$(obj): $<; $(call compile)
+
+all: build;
+
+############
+### main ###
+############
+
+obj/main.$(obj): ui/main.cpp config/* lib/nall/* lib/ruby/* ui/* ui/loader/* ui/settings/*
+	$(call compile,$(arch))
+
+obj/bsnes.res     : ui/bsnes.rc; rc /r /foobj/bsnes.res ui/bsnes.rc
+obj/bsnesrc.$(obj): ui/bsnes.rc; windres -I data ui/bsnes.rc obj/bsnesrc.$(obj)
+
+############
+### ruby ###
+############
+
+obj/ruby.$(obj)             : lib/ruby/ruby.cpp lib/ruby/*
+	$(call compile,$(rubydef))
+obj/video.direct3d.$(obj)   : lib/ruby/video/direct3d.cpp lib/ruby/video/direct3d.*
+obj/video.directdraw.$(obj) : lib/ruby/video/directdraw.cpp lib/ruby/video/directdraw.*
+obj/video.gdi.$(obj)        : lib/ruby/video/gdi.cpp lib/ruby/video/gdi.*
+obj/video.glx.$(obj)        : lib/ruby/video/glx.cpp lib/ruby/video/glx.*
+obj/video.sdl.$(obj)        : lib/ruby/video/sdl.cpp lib/ruby/video/sdl.*
+	$(call compile,`sdl-config --cflags`)
+obj/video.xv.$(obj)         : lib/ruby/video/xv.cpp lib/ruby/video/xv.*
+obj/audio.ao.$(obj)         : lib/ruby/audio/ao.cpp lib/ruby/audio/ao.*
+obj/audio.directsound.$(obj): lib/ruby/audio/directsound.cpp lib/ruby/audio/directsound.*
+obj/audio.openal.$(obj)     : lib/ruby/audio/openal.cpp lib/ruby/audio/openal.*
+obj/audio.oss.$(obj)        : lib/ruby/audio/oss.cpp lib/ruby/audio/oss.*
+obj/input.directinput.$(obj): lib/ruby/input/directinput.cpp lib/ruby/input/directinput.*
+obj/input.sdl.$(obj)        : lib/ruby/input/sdl.cpp lib/ruby/input/sdl.*
+	$(call compile,`sdl-config --cflags`)
+obj/input.x.$(obj)          : lib/ruby/input/x.cpp lib/ruby/input/x.*
+
+############
+### hiro ###
+############
+
+obj/hiro.$(obj): lib/hiro.cpp lib/hiro.* lib/hiro_gtk/* lib/hiro_win/*
+	$(call compile,$(if $(call streq,$(platform),x),`pkg-config --cflags gtk+-2.0`))
+
+#################
+### libraries ###
+#################
+
+obj/libco.$(obj): lib/libco.c lib/libco.* lib/libco/*
+obj/string.$(obj): lib/nall/string.cpp lib/nall/*
+
+#################
+### utilities ###
+#################
+
+obj/reader.$(obj): reader/reader.cpp reader/*
+obj/cart.$(obj)  : cart/cart.cpp cart/*
+obj/cheat.$(obj) : cheat/cheat.cpp cheat/*
+
+##############
+### memory ###
+##############
+
+obj/memory.$(obj) : memory/memory.cpp memory/*
+obj/bmemory.$(obj): memory/bmemory/bmemory.cpp memory/bmemory/* memory/bmemory/mapper/*
+obj/smemory.$(obj): memory/smemory/smemory.cpp memory/smemory/* memory/smemory/mapper/*
+
+###########
+### cpu ###
+###########
+
+obj/cpu.$(obj) : cpu/cpu.cpp cpu/*
+obj/scpu.$(obj): cpu/scpu/scpu.cpp cpu/scpu/* cpu/scpu/core/* cpu/scpu/dma/* cpu/scpu/memory/* cpu/scpu/mmio/* cpu/scpu/timing/*
+
+###########
+### smp ###
+###########
+
+obj/smp.$(obj) : smp/smp.cpp smp/*
+obj/ssmp.$(obj): smp/ssmp/ssmp.cpp smp/ssmp/* smp/ssmp/core/* smp/ssmp/memory/* smp/ssmp/timing/*
+
+###########
+### dsp ###
+###########
+
+obj/adsp.$(obj): dsp/adsp/adsp.cpp dsp/adsp/*
+obj/bdsp.$(obj): dsp/bdsp/bdsp.cpp dsp/bdsp/*
+
+###########
+### ppu ###
+###########
+
+obj/ppu.$(obj) : ppu/ppu.cpp ppu/*
+obj/bppu.$(obj): ppu/bppu/bppu.cpp ppu/bppu/*
+
+############
+### snes ###
+############
+
+obj/snes.$(obj): snes/snes.cpp snes/* snes/scheduler/* snes/video/* snes/audio/* snes/input/*
+
+#####################
+### special chips ###
+#####################
+
+obj/bsx.$(obj)  : chip/bsx/bsx.cpp chip/bsx/*
+obj/srtc.$(obj) : chip/srtc/srtc.cpp chip/srtc/*
+obj/sdd1.$(obj) : chip/sdd1/sdd1.cpp chip/sdd1/*
+obj/cx4.$(obj)  : chip/cx4/cx4.cpp chip/cx4/*
+obj/dsp1.$(obj) : chip/dsp1/dsp1.cpp chip/dsp1/*
+obj/dsp2.$(obj) : chip/dsp2/dsp2.cpp chip/dsp2/*
+obj/dsp3.$(obj) : chip/dsp3/dsp3.cpp chip/dsp3/*
+obj/dsp4.$(obj) : chip/dsp4/dsp4.cpp chip/dsp4/*
+obj/obc1.$(obj) : chip/obc1/obc1.cpp chip/obc1/*
+obj/st010.$(obj): chip/st010/st010.cpp chip/st010/*
+
+############
+### zlib ###
+############
+
+obj/adler32.$(obj) : reader/zlib/adler32.c reader/zlib/*
+obj/compress.$(obj): reader/zlib/compress.c reader/zlib/*
+obj/crc32.$(obj)   : reader/zlib/crc32.c reader/zlib/*
+obj/deflate.$(obj) : reader/zlib/deflate.c reader/zlib/*
+obj/gzio.$(obj)    : reader/zlib/gzio.c reader/zlib/*
+obj/inffast.$(obj) : reader/zlib/inffast.c reader/zlib/*
+obj/inflate.$(obj) : reader/zlib/inflate.c reader/zlib/*
+obj/inftrees.$(obj): reader/zlib/inftrees.c reader/zlib/*
+obj/ioapi.$(obj)   : reader/zlib/ioapi.c reader/zlib/*
+obj/trees.$(obj)   : reader/zlib/trees.c reader/zlib/*
+obj/unzip.$(obj)   : reader/zlib/unzip.c reader/zlib/*
+obj/zip.$(obj)     : reader/zlib/zip.c reader/zlib/*
+obj/zutil.$(obj)   : reader/zlib/zutil.c reader/zlib/*
+
+###########
+### jma ###
+###########
+
+obj/jma.$(obj)    : reader/jma/jma.cpp reader/jma/*
+obj/jcrc32.$(obj) : reader/jma/jcrc32.cpp reader/jma/*
+obj/lzmadec.$(obj): reader/jma/lzmadec.cpp reader/jma/*
+obj/7zlzma.$(obj) : reader/jma/7zlzma.cpp reader/jma/*
+obj/iiostrm.$(obj): reader/jma/iiostrm.cpp reader/jma/*
+obj/inbyte.$(obj) : reader/jma/inbyte.cpp reader/jma/*
+obj/lzma.$(obj)   : reader/jma/lzma.cpp reader/jma/*
+obj/winout.$(obj) : reader/jma/winout.cpp reader/jma/*
+
+###############
+### targets ###
+###############
+
+build: $(objects)
+	$(strip $(cpp) $(call mkbin,../bsnes) $(objects) $(link))
+
+install:
+	install -m 755 ../bsnes $(prefix)/bin/bsnes
+	install -m 644 data/bsnes.png $(prefix)/share/icons/bsnes.png
+
+clean:
+	-@$(call delete,obj/*.$(obj))
+	-@$(call delete,*.res)
+	-@$(call delete,*.pgd)
+	-@$(call delete,*.pgc)
+	-@$(call delete,*.ilk)
+	-@$(call delete,*.pdb)
+	-@$(call delete,*.manifest)
+
+help:
+	@echo "Usage: $(MAKE) platform=(os) compiler=(cc) [options]"
+	@echo ""
+	@echo "Supported platforms:"
+	@echo "  x   - Linux / BSD (x86, x86-64)"
+	@echo "  win - Windows (x86, x86-64)"
+	@echo ""
+	@echo "Supported compilers:"
+	@echo "  gcc              - GCC compiler"
+	@echo "  mingw32-gcc      - MinGW compiler"
+	@echo "  i586-mingw32-gcc - MinGW cross compiler"
+	@echo "  cl               - Visual C++"
+	@echo ""
+	@echo "Available options:"
+	@echo "  enable_gzip=[true|false] - Enable ZIP / GZ support (default=false)"
+	@echo "  enable_jma=[true|false]  - Enable JMA support (default=false)"
+	@echo ""
+	@echo "Example: $(MAKE) platform=x compiler=gcc enable_gzip=true"
+	@echo ""

src/base.h

@@ -1,60 +1,55 @@
-#define BSNES_VERSION "0.020"
-#define BSNES_TITLE   "bsnes v" BSNES_VERSION
-
-#define MEMCORE bMemBus
-#define CPUCORE sCPU
-#define SMPCORE sSMP
-#define DSPCORE bDSP
-#define PPUCORE bPPU
-
-//#define FAVOR_ACCURACY
-#define FAVOR_SPEED
-
-//game genie + pro action replay code support (~1-3% speed hit)
-#define CHEAT_SYSTEM
-
-//snes core polymorphism
-//(allow runtime cpu/smp/dsp/ppu/bus selection, ~10% speed hit)
-//#define POLYMORPHISM
-
-#include "lib/libbase.h"
-
-#if defined(PROCESSOR_X86)
-  #define ARCH_LSB
-  #include "lib/libco_x86.h"
-#elif defined(PROCESSOR_X86_64)
-  #define ARCH_LSB
-  #include "lib/libco_x86_64.h"
-#elif defined(PROCESSOR_G5)
-  #define ARCH_MSB
-#else
-  #error "unsupported processor"
-#endif
-
-#include "lib/libinterp.h"
-#include "lib/libsort.h"
-#include "lib/libarray.h"
-#include "lib/libvector.h"
-#include "lib/libfile.h"
-#include "lib/libstring.h"
-#include "lib/libconfig.h"
-
-//platform-specific global functions
-void alert(char*, ...);
-void dprintf(char*, ...);
-void dprintf(uint, char*, ...);
-
-namespace source {
-  enum {
-    none = 0,
-    debug,
-    cpu,
-    ppu,
-    smp,
-    dsp,
-    bus,
-  };
-};
-
-//various class interfaces
-#include "interface.h"
+#define BSNES_VERSION "0.028"
+#define BSNES_TITLE   "bsnes v" BSNES_VERSION
+
+#define BUSCORE sBus
+#define CPUCORE sCPU
+#define SMPCORE sSMP
+#define DSPCORE bDSP
+#define PPUCORE bPPU
+
+//FAVOR_ACCURACY calculates RTO during frameskip, whereas FAVOR_SPEED does not
+//frameskip offers near-zero speedup if RTO is calculated
+//accuracy is not affected by this define when frameskipping is off
+
+//#define FAVOR_ACCURACY
+#define FAVOR_SPEED
+
+//game genie + pro action replay code support (~1-3% speed hit)
+#define CHEAT_SYSTEM
+
+#if !defined(ARCH_LSB) && !defined(ARCH_MSB)
+  #define ARCH_LSB //guess
+#endif
+
+#include <nall/algorithm.hpp>
+#include <nall/array.hpp>
+#include <nall/bit.hpp>
+#include <nall/config.hpp>
+#include <nall/function.hpp>
+#include <nall/new.hpp>
+#include <nall/sort.hpp>
+#include <nall/string.hpp>
+#include <nall/vector.hpp>
+using namespace nall;
+
+#include <libco.h>
+#include <bbase.h>
+
+//platform-specific global functions
+void alert(const char*, ...);
+void dprintf(const char*, ...);
+void dprintf(uint, const char*, ...);
+
+namespace source {
+  enum {
+    none = 0,
+    debug,
+    cpu,
+    ppu,
+    smp,
+    dsp,
+    bus,
+  };
+};
+
+#include "interface.h"

src/cart/cart.cpp

@@ -1,156 +1,135 @@
 #include "../base.h"
-#include "database.cpp"
 
 #include "cart_normal.cpp"
+#include "cart_bsx.cpp"
+#include "cart_bsc.cpp"
 #include "cart_st.cpp"
-#include "cart_stdual.cpp"
 
 #include "cart_file.cpp"
 #include "cart_header.cpp"
 
+namespace memory {
+  MappedRAM cartrom, cartram;
+  MappedRAM bscram;
+  MappedRAM stArom, stAram;
+  MappedRAM stBrom, stBram;
+};
+
 Cartridge cartridge;
 
-void Cartridge::load_begin(uint cart_type) {
-  if(loaded() == true)return;
+Cartridge::MemoryMapper Cartridge::mapper() { return info.mapper; }
+Cartridge::Region Cartridge::region() { return info.region; }
+
+bool Cartridge::loaded() { return cart.loaded; }
+
+void Cartridge::load_begin(CartridgeType cart_type) {
+  cart.rom = cart.ram = 0;
+  bs.ram   = 0;
+  stA.rom  = stA.ram  = 0;
+  stB.rom  = stB.ram  = 0;
+
+  cart.rom_size = cart.ram_size = 0;
+  bs.ram_size   = 0;
+  stA.rom_size  = stA.ram_size  = 0;
+  stB.rom_size  = stB.ram_size  = 0;
 
   info.type = cart_type;
 
-  info.srtc = false;
-  info.sdd1 = false;
-  info.c4   = false;
-  info.dsp1 = false;
-  info.dsp2 = false;
-  info.obc1 = false;
+  info.bsxbase  = false;
+  info.bsxcart  = false;
+  info.bsxflash = false;
+  info.st       = false;
 
-  info.dsp1_mapper = 0;
+  info.superfx = false;
+  info.sa1     = false;
+  info.srtc    = false;
+  info.sdd1    = false;
+  info.cx4     = false;
+  info.dsp1    = false;
+  info.dsp2    = false;
+  info.dsp3    = false;
+  info.dsp4    = false;
+  info.obc1    = false;
+  info.st010   = false;
+  info.st011   = false;
+  info.st018   = false;
+
+  info.dsp1_mapper = DSP1Unmapped;
 
   info.header_index = 0xffc0;
-  info.mapper = PCB;
-  strcpy(info.name, "");
-  strcpy(info.pcb,  "");
+  info.mapper = LoROM;
+  info.name[0] = 0;
   info.region = NTSC;
-  info.cart_mmio = false;
 
   info.rom_size = 0;
   info.ram_size = 0;
-
-  file.count = 0;
-  for(int i = 0; i < 8; i++) {
-    strcpy(file.rom_name[i], "");
-    strcpy(file.ram_name[i], "");
-    file.rom_size[i] = 0;
-    file.ram_size[i] = 0;
-    file.rom_data[i] = 0;
-    file.ram_data[i] = 0;
-  }
 }
 
-void Cartridge::load(const char *rom_fn) {
-  if(!rom_fn || !*rom_fn)return;
+void Cartridge::load_end() {
+  memory::cartrom.map(cart.rom, cart.rom_size);
+  memory::cartram.map(cart.ram, cart.ram_size);
+  memory::bscram.map(bs.ram, bs.ram_size);
+  memory::stArom.map(stA.rom, stA.rom_size);
+  memory::stAram.map(stA.ram, stA.ram_size);
+  memory::stBrom.map(stB.rom, stB.rom_size);
+  memory::stBram.map(stB.ram, stB.ram_size);
 
-char fn[4096], ram_fn[4096];
-  strcpy(fn, rom_fn);
-//correct folder slashes
-  for(int i = strlen(fn) - 1; i >= 0; i--) {
-    if(fn[i] == '\\')fn[i] = '/';
-  }
+  memory::cartrom.write_protect(true);
+  memory::cartram.write_protect(false);
+  memory::bscram.write_protect(true);
+  memory::stArom.write_protect(true);
+  memory::stAram.write_protect(false);
+  memory::stBrom.write_protect(true);
+  memory::stBram.write_protect(false);
 
-uint i = file.count++;
-  strcpy(file.rom_name[i], fn);
-
-  strcpy(fn, rom_fn);
-//remove ROM extension
-  for(int i = strlen(fn) - 1; i >= 0; i--) {
-    if(fn[i] == '.') {
-      fn[i] = 0;
-      break;
-    }
-  }
-
-  if(i == 0) {
-    strcpy(file.patch_name, fn);
-    strcat(file.patch_name, ".ups");
-  }
-  strcpy(fn, strptr(config::file_updatepath(fn, config::path.save)));
-  if(i == 0) {
-    strcpy(file.cheat_name, fn);
-    strcat(file.cheat_name, ".cht");
-  }
-  strcpy(file.ram_name[i], fn);
-  strcat(file.ram_name[i], ".");
-  strcat(file.ram_name[i], config::path.save_ext);
-}
-
-bool Cartridge::load_end() {
-  for(int i = 0; i < file.count; i++) {
-    load_file(file.rom_name[i], file.rom_data[i], file.rom_size[i]);
-  }
-
-  if(fexists(file.cheat_name) == true) {
+char fn[PATH_MAX];
+  strcpy(fn, cart.fn);
+  modify_extension(fn, "cht");
+  if(fexists(fn)) {
     cheat.clear();
-    cheat.load(file.cheat_name);
+    cheat.load(fn);
   }
 
-  switch(info.type) {
-  case CART_NORMAL: {
-    load_rom_normal();
-    load_ram_normal();
-  } break;
-  case CART_ST: {
-    load_rom_st();
-    load_ram_st();
-  } break;
-  case CART_STDUAL: {
-    load_rom_stdual();
-    load_ram_stdual();
-  } break;
-  }
-
-  cart_loaded = true;
-  r_mem->load_cart();
-  return true;
+  cart.loaded = true;
+  bus.load_cart();
 }
 
 bool Cartridge::unload() {
-  if(cart_loaded == false)return false;
+  if(cart.loaded == false) return false;
 
-  r_mem->unload_cart();
+  bus.unload_cart();
 
   switch(info.type) {
-  case CART_NORMAL: {
-    save_ram_normal();
-  } break;
-  case CART_ST: {
-    save_ram_st();
-  } break;
-  case CART_STDUAL: {
-    save_ram_stdual();
-  } break;
+    case CartridgeNormal: unload_cart_normal(); break;
+    case CartridgeBSX: unload_cart_bsx(); break;
+    case CartridgeBSC: unload_cart_bsc(); break;
+    case CartridgeSufamiTurbo: unload_cart_st(); break;
   }
 
-  safe_free(rom);
-  safe_free(ram);
+  safe_free(cart.rom);
+  safe_free(cart.ram);
+  safe_free(bs.ram);
+  safe_free(stA.rom);
+  safe_free(stA.ram);
+  safe_free(stB.rom);
+  safe_free(stB.ram);
 
-  if(cheat.count() > 0 || fexists(file.cheat_name) == true) {
-    cheat.save(file.cheat_name);
+char fn[PATH_MAX];
+  strcpy(fn, cart.fn);
+  modify_extension(fn, "cht");
+  if(cheat.count() > 0 || fexists(fn)) {
+    cheat.save(fn);
     cheat.clear();
   }
 
-  cart_loaded = false;
+  cart.loaded = false;
   return true;
 }
 
 Cartridge::Cartridge() {
-  load_database();
-
-  cart_loaded = false;
-
-  rom = 0;
-  ram = 0;
+  cart.loaded = false;
 }
 
 Cartridge::~Cartridge() {
-  if(cart_loaded == true) {
-    unload();
-  }
+  if(cart.loaded == true) unload();
 }

src/cart/cart.h

@@ -1,125 +1,142 @@
 class Cartridge {
 public:
+  enum CartridgeType {
+    CartridgeNormal,
+    CartridgeBSX,
+    CartridgeBSC,
+    CartridgeSufamiTurbo,
+  };
 
-/*****
- * cart database
- *****/
+  enum HeaderField {
+    CART_NAME = 0x00,
+    MAPPER    = 0x15,
+    ROM_TYPE  = 0x16,
+    ROM_SIZE  = 0x17,
+    RAM_SIZE  = 0x18,
+    REGION    = 0x19,
+    COMPANY   = 0x1a,
+    VERSION   = 0x1b,
+    ICKSUM    = 0x1c,
+    CKSUM     = 0x1e,
+    RESL      = 0x3c,
+    RESH      = 0x3d,
+  };
 
-#include "db/db.h"
-db_item dbi;
-  uint8 *database;
-  uint   database_size;
-  uint   database_blocksize;
-  void   load_database();
-  bool   read_database();
+  enum Region {
+    NTSC,
+    PAL,
+  };
 
-//
+  enum MemoryMapper {
+    LoROM,
+    HiROM,
+    ExLoROM,
+    ExHiROM,
+    BSXROM,
+    BSCLoROM,
+    BSCHiROM,
+    STROM,
+  };
 
-enum {
-  CART_NORMAL,
-  CART_ST,
-  CART_STDUAL,
-};
+  enum DSP1MemoryMapper {
+    DSP1Unmapped,
+    DSP1LoROM1MB,
+    DSP1LoROM2MB,
+    DSP1HiROM,
+  };
 
-bool cart_loaded;
+  struct {
+    bool loaded;
+    char fn[PATH_MAX];
+    uint8 *rom, *ram;
+    uint rom_size, ram_size;
+  } cart;
 
-uint8 rom_header[512], *rom, *ram;
+  struct {
+    char fn[PATH_MAX];
+    uint8 *ram;
+    uint ram_size;
+  } bs;
 
-enum {
-//header fields
-  CART_NAME = 0x00,
-  MAPPER    = 0x15,
-  ROM_TYPE  = 0x16,
-  ROM_SIZE  = 0x17,
-  RAM_SIZE  = 0x18,
-  REGION    = 0x19,
-  LICENSE   = 0x1a,
-  VERSION   = 0x1b,
-  ICKSUM    = 0x1c,
-  CKSUM     = 0x1e,
-  RESL      = 0x3c,
-  RESH      = 0x3d,
+  struct {
+    char fn[PATH_MAX];
+    uint8 *rom, *ram;
+    uint rom_size, ram_size;
+  } stA, stB;
 
-//regions
-  NTSC = 0,
-  PAL  = 1,
+  struct {
+    CartridgeType type;
 
-//memory mappers
-  PCB     = 0x00,
-  LOROM   = 0x20,
-  HIROM   = 0x21,
-  EXLOROM = 0x22,
-  EXHIROM = 0x25,
+    uint32 crc32;
+    char name[128];
 
-//special chip memory mappers
-  DSP1_LOROM_1MB = 1,
-  DSP1_LOROM_2MB = 2,
-  DSP1_HIROM     = 3,
-};
+    Region region;
+    MemoryMapper mapper;
+    uint rom_size;
+    uint ram_size;
 
-struct {
-  uint   count;
-  char   cheat_name[4096], patch_name[4096];
-  char   rom_name[8][4096], ram_name[8][4096];
-  uint   rom_size[8],  ram_size[8];
-  uint8 *rom_data[8], *ram_data[8];
-} file;
+    bool bsxbase;
+    bool bsxcart;
+    bool bsxflash;
+    bool st;
+    bool superfx;
+    bool sa1;
+    bool srtc;
+    bool sdd1;
+    bool cx4;
+    bool dsp1;
+    bool dsp2;
+    bool dsp3;
+    bool dsp4;
+    bool obc1;
+    bool st010;
+    bool st011;
+    bool st018;
 
-struct {
-  uint   type;
+    DSP1MemoryMapper dsp1_mapper;
 
-//cart information
-  uint32 crc32;
-  char   name[128];
-  char   pcb[32];
+    uint header_index;
+  } info;
 
-  uint   region;
-  uint   mapper;
-  uint   rom_size;
-  uint   ram_size;
+  MemoryMapper mapper();
+  Region region();
 
-//set to true for games that need cart MMIO mapping (c4, dsp-n, ...),
-//for games that map outside the standard MMIO range of $2000-$5fff
-  bool   cart_mmio;
-  bool   srtc;
-  bool   sdd1;
-  bool   c4;
-  bool   dsp1;
-  bool   dsp2;
-  bool   obc1;
+  void load_cart_normal(const char*);
+  void load_cart_bsx(const char*, const char*);
+  void load_cart_bsc(const char*, const char*);
+  void load_cart_st(const char*, const char*, const char*);
 
-  uint   dsp1_mapper;
+  void unload_cart_normal();
+  void unload_cart_bsx();
+  void unload_cart_bsc();
+  void unload_cart_st();
 
-//HiROM / LoROM specific code
-  uint   header_index;
-} info;
-
-  bool load_file(const char *fn, uint8 *&data, uint &size);
-  bool save_file(const char *fn, uint8 *data, uint size);
-
-  void load_rom_normal();
-  void load_ram_normal();
-  void save_ram_normal();
-
-  void load_rom_st();
-  void load_ram_st();
-  void save_ram_st();
-
-  void load_rom_stdual();
-  void load_ram_stdual();
-  void save_ram_stdual();
+  bool loaded();
+  void load_begin(CartridgeType);
+  void load_end();
+  bool unload();
 
   void find_header();
   void read_header();
+  void read_extended_header();
 
-  bool loaded() { return cart_loaded; }
-  void load_begin(uint cart_type);
-  void load(const char *rom_fn);
-  bool load_end();
-  bool unload();
+  bool load_file(const char *fn, uint8 *&data, uint &size);
+  bool save_file(const char *fn, uint8 *data, uint size);
+  char* modify_extension(char *filename, const char *extension);
+  char* get_save_filename(const char *source, const char *extension);
 
   Cartridge();
   ~Cartridge();
+
+private:
+  char savefn[PATH_MAX];
+};
+
+namespace memory {
+  extern MappedRAM cartrom, cartram;
+  extern MappedRAM bscram;
+  extern MappedRAM stArom, stAram;
+  extern MappedRAM stBrom, stBram;
 };
 
 extern Cartridge cartridge;

src/cart/cart_bsc.cpp

@@ -0,0 +1,41 @@
+void Cartridge::load_cart_bsc(const char *base, const char *slot) {
+  if(!base || !*base) return;
+
+  strcpy(cart.fn, base);
+  strcpy(bs.fn, slot ? slot : "");
+  load_begin(CartridgeBSC);
+
+uint8 *data;
+uint size;
+  load_file(cart.fn, data, size);
+  cart.rom = data, cart.rom_size = size;
+
+  if(*bs.fn) {
+    if(load_file(bs.fn, data, size) == true) {
+      info.bsxflash = true;
+      bs.ram = data, bs.ram_size = size;
+    }
+  }
+
+  find_header();
+  read_header();
+
+  info.mapper = cartridge.info.header_index == 0x7fc0 ? BSCLoROM : BSCHiROM;
+  info.region = NTSC;
+
+  if(info.ram_size > 0) {
+    cart.ram = (uint8*)malloc(cart.ram_size = info.ram_size);
+    memset(cart.ram, 0xff, cart.ram_size);
+
+    if(load_file(get_save_filename(cart.fn, "srm"), data, size) == true) {
+      memcpy(cart.ram, data, min(size, cart.ram_size));
+      safe_free(data);
+    }
+  }
+
+  load_end();
+}
+
+void Cartridge::unload_cart_bsc() {
+  if(cart.ram) save_file(get_save_filename(cart.fn, "srm"), cart.ram, cart.ram_size);
+}

src/cart/cart_bsx.cpp

@@ -0,0 +1,45 @@
+void Cartridge::load_cart_bsx(const char *base, const char *slot) {
+  if(!base || !*base) return;
+
+  strcpy(cart.fn, base);
+  strcpy(bs.fn, slot ? slot : "");
+
+  load_begin(CartridgeBSX);
+  info.bsxbase = true;
+  info.bsxcart = true;
+  info.mapper = BSXROM;
+  info.region = NTSC;
+
+uint8 *data;
+uint size;
+  load_file(cart.fn, data, size);
+  cart.rom = data, cart.rom_size = size;
+  cart.ram = 0, cart.ram_size = 0;
+
+  memset(bsxcart.sram.handle (), 0x00, bsxcart.sram.size ());
+  memset(bsxcart.psram.handle(), 0x00, bsxcart.psram.size());
+
+  if(load_file(get_save_filename(cart.fn, "srm"), data, size) == true) {
+    memcpy(bsxcart.sram.handle (), data, min(bsxcart.sram.size (), size));
+    safe_free(data);
+  }
+
+  if(load_file(get_save_filename(cart.fn, "psr"), data, size) == true) {
+    memcpy(bsxcart.psram.handle(), data, min(bsxcart.psram.size(), size));
+    safe_free(data);
+  }
+
+  if(*bs.fn) {
+    if(load_file(bs.fn, data, size) == true) {
+      info.bsxflash = true;
+      bs.ram = data, bs.ram_size = size;
+    }
+  }
+
+  load_end();
+}
+
+void Cartridge::unload_cart_bsx() {
+  save_file(get_save_filename(cart.fn, "srm"), bsxcart.sram.handle (), bsxcart.sram.size ());
+  save_file(get_save_filename(cart.fn, "psr"), bsxcart.psram.handle(), bsxcart.psram.size());
+}

src/cart/cart_file.cpp

@@ -9,56 +9,91 @@
   #include "../reader/jmareader.h"
 #endif
 
+char* Cartridge::modify_extension(char *filename, const char *extension) {
+int i;
+  for(i = strlen(filename); i >= 0; i--) {
+    if(filename[i] == '.') break;
+    if(filename[i] == '/') break;
+    if(filename[i] == '\\') break;
+  }
+  if(i > 0 && filename[i] == '.') filename[i] = 0;
+  strcat(filename, ".");
+  strcat(filename, extension);
+  return filename;
+}
+
+char* Cartridge::get_save_filename(const char *source, const char *extension) {
+  strcpy(savefn, source);
+  for(char *p = savefn; *p; p++) { if(*p == '\\') *p = '/'; }
+  modify_extension(savefn, extension);
+
+//override path with user-specified folder, if one was defined
+  if(config::path.save != "") {
+  lstring part;
+    split(part, "/", savefn);
+  string fn = (const char*)config::path.save;
+    if(strend(fn, "/") == false) strcat(fn, "/");
+    strcat(fn, part[count(part) - 1]);
+    strcpy(savefn, fn);
+
+  //resolve relative path, if found
+    if(strbegin(fn, "./") == true) {
+      ltrim(fn, "./");
+      strcpy(savefn, config::path.base);
+      strcat(savefn, fn);
+    }
+  }
+
+  return savefn;
+}
+
 bool Cartridge::load_file(const char *fn, uint8 *&data, uint &size) {
   dprintf("* Loading \"%s\"...", fn);
 
-  if(fexists(fn) == false) {
-    return false;
-  }
+  if(fexists(fn) == false) return false;
 
   switch(Reader::detect(fn)) {
+    default:
+    case Reader::RF_NORMAL: {
+    FileReader ff(fn);
+      if(!ff.ready()) {
+        alert("Error loading image file (%s)!", fn);
+        return false;
+      }
+      size = ff.size();
+      data = ff.read();
+    } break;
 
-  case Reader::RF_NORMAL: {
-  FileReader ff(fn);
-    if(!ff.ready()) {
-      alert("Error loading image file (%s)!", fn);
-      return false;
-    }
-    size = ff.size();
-    data = ff.read();
-  } break;
+  #ifdef GZIP_SUPPORT
+    case Reader::RF_GZ: {
+    GZReader gf(fn);
+      if(!gf.ready()) {
+        alert("Error loading image file (%s)!", fn);
+        return false;
+      }
+      size = gf.size();
+      data = gf.read();
+    } break;
 
-#ifdef GZIP_SUPPORT
-  case Reader::RF_GZ: {
-  GZReader gf(fn);
-    if(!gf.ready()) {
-      alert("Error loading image file (%s)!", fn);
-      return false;
-    }
-    size = gf.size();
-    data = gf.read();
-  } break;
-
-  case Reader::RF_ZIP: {
-  ZipReader zf(fn);
-    size = zf.size();
-    data = zf.read();
-  } break;
-#endif
-
-#ifdef JMA_SUPPORT
-  case Reader::RF_JMA: {
-    try {
-    JMAReader jf(fn);
-      size = jf.size();
-      data = jf.read();
-    } catch(JMA::jma_errors jma_error) {
-      alert("Error loading image file (%s)!", fn);
-      return false;
-    }
-  } break;
-#endif
+    case Reader::RF_ZIP: {
+    ZipReader zf(fn);
+      size = zf.size();
+      data = zf.read();
+    } break;
+  #endif
 
+  #ifdef JMA_SUPPORT
+    case Reader::RF_JMA: {
+      try {
+      JMAReader jf(fn);
+        size = jf.size();
+        data = jf.read();
+      } catch(JMA::jma_errors jma_error) {
+        alert("Error loading image file (%s)!", fn);
+        return false;
+      }
+    } break;
+  #endif
   }
 
   return true;

src/cart/cart_header.cpp

@@ -1,32 +1,46 @@
 void Cartridge::read_header() {
-  info.srtc = false;
-  info.sdd1 = false;
-  info.c4   = false;
-  info.dsp1 = false;
-  info.dsp2 = false;
-  info.obc1 = false;
+uint8 *rom = cart.rom;
+uint index = info.header_index;
+uint8 mapper   = rom[index + MAPPER];
+uint8 rom_type = rom[index + ROM_TYPE];
+uint8 company  = rom[index + COMPANY];
+uint8 region   = rom[index + REGION] & 0x7f;
 
-  info.dsp1_mapper = 0;
-
-  if(info.header_index == 0x7fc0 && info.rom_size >= 0x401000) {
-    info.mapper = EXLOROM;
-    strcpy(info.pcb, "UNL-EXLOROM");
-  } else if(info.header_index == 0x7fc0 && rom[info.header_index + MAPPER] == 0x32) {
-    info.mapper = EXLOROM;
-    strcpy(info.pcb, "UNL-EXLOROM");
-  } else if(info.header_index == 0x7fc0) {
-    info.mapper = LOROM;
-    strcpy(info.pcb, "UNL-LOROM");
-  } else if(info.header_index == 0xffc0) {
-    info.mapper = HIROM;
-    strcpy(info.pcb, "UNL-HIROM");
-  } else { //info.header_index == 0x40ffc0
-    info.mapper = EXHIROM;
-    strcpy(info.pcb, "UNL-EXHIROM");
+//detect presence of BS-X flash cartridge connector (reads extended header information)
+bool has_bsxflash = false;
+  if(rom[index - 14] == 'Z') {
+    if(rom[index - 11] == 'J') {
+    uint8 n13 = rom[index - 13];
+      if((n13 >= 'A' && n13 <= 'Z') || (n13 >= '0' && n13 <= '9')) {
+        if(company == 0x33 || (rom[index - 10] == 0x00 && rom[index - 4] == 0x00)) {
+          has_bsxflash = true;
+        }
+      }
+    }
+  }
+
+  if(has_bsxflash == true) {
+    info.mapper = index == 0x7fc0 ? BSCLoROM : BSCHiROM;
+  } else if(index == 0x7fc0 && cart.rom_size >= 0x401000) {
+    info.mapper = ExLoROM;
+  } else if(index == 0x7fc0 && mapper == 0x32) {
+    info.mapper = ExLoROM;
+  } else if(index == 0x7fc0) {
+    info.mapper = LoROM;
+  } else if(index == 0xffc0) {
+    info.mapper = HiROM;
+  } else { //index == 0x40ffc0
+    info.mapper = ExHiROM;
+  }
+
+  if(mapper == 0x20 && (rom_type == 0x13 || rom_type == 0x14 || rom_type == 0x15 || rom_type == 0x1a)) {
+    info.superfx = true;
+  }
+
+  if(mapper == 0x23 && (rom_type == 0x34 || rom_type == 0x35)) {
+    info.sa1 = true;
   }
 
-uint8 mapper   = rom[info.header_index + MAPPER];
-uint8 rom_type = rom[info.header_index + ROM_TYPE];
   if(mapper == 0x35 && rom_type == 0x55) {
     info.srtc = true;
   }
@@ -36,14 +50,14 @@ uint8 rom_type = rom[info.header_index + ROM_TYPE];
   }
 
   if(mapper == 0x20 && rom_type == 0xf3) {
-    info.c4 = true;
+    info.cx4 = true;
   }
 
   if((mapper == 0x20 || mapper == 0x21) && rom_type == 0x03) {
     info.dsp1 = true;
   }
 
-  if(mapper == 0x30 && rom_type == 0x05) {
+  if(mapper == 0x30 && rom_type == 0x05 && company != 0xb2) {
     info.dsp1 = true;
   }
 
@@ -52,12 +66,12 @@ uint8 rom_type = rom[info.header_index + ROM_TYPE];
   }
 
   if(info.dsp1 == true) {
-    if((mapper & 0x2f) == 0x20 && info.rom_size <= 0x100000) {
-      info.dsp1_mapper = DSP1_LOROM_1MB;
+    if((mapper & 0x2f) == 0x20 && cart.rom_size <= 0x100000) {
+      info.dsp1_mapper = DSP1LoROM1MB;
     } else if((mapper & 0x2f) == 0x20) {
-      info.dsp1_mapper = DSP1_LOROM_2MB;
+      info.dsp1_mapper = DSP1LoROM2MB;
     } else if((mapper & 0x2f) == 0x21) {
-      info.dsp1_mapper = DSP1_HIROM;
+      info.dsp1_mapper = DSP1HiROM;
     }
   }
 
@@ -65,11 +79,28 @@ uint8 rom_type = rom[info.header_index + ROM_TYPE];
     info.dsp2 = true;
   }
 
+  if(mapper == 0x30 && rom_type == 0x05 && company == 0xb2) {
+    info.dsp3 = true;
+  }
+
+  if(mapper == 0x30 && rom_type == 0x03) {
+    info.dsp4 = true;
+  }
+
   if(mapper == 0x30 && rom_type == 0x25) {
     info.obc1 = true;
   }
 
-  info.cart_mmio = info.c4 | info.dsp1 | info.dsp2 | info.obc1;
+  if(mapper == 0x30 && rom_type == 0xf6) {
+  //TODO: both ST010 and ST011 share the same mapper + rom_type
+  //need way to determine which is which
+  //for now, default to supported ST010
+    info.st010 = true;
+  }
+
+  if(mapper == 0x30 && rom_type == 0xf5) {
+    info.st018 = true;
+  }
 
   if(rom[info.header_index + RAM_SIZE] & 7) {
     info.ram_size = 1024 << (rom[info.header_index + RAM_SIZE] & 7);
@@ -77,6 +108,9 @@ uint8 rom_type = rom[info.header_index + ROM_TYPE];
     info.ram_size = 0;
   }
 
+//0, 1, 13 = NTSC; 2 - 12 = PAL
+  info.region = (region <= 1 || region >= 13) ? NTSC : PAL;
+
   memcpy(&info.name, &rom[info.header_index + CART_NAME], 21);
   info.name[21] = 0;
 
@@ -91,8 +125,9 @@ void Cartridge::find_header() {
 int32 score_lo = 0,
       score_hi = 0,
       score_ex = 0;
+uint8 *rom = cart.rom;
 
-  if(info.rom_size < 0x010000) {
+  if(cart.rom_size < 0x010000) {
   //cart too small to be anything but lorom
     info.header_index = 0x007fc0;
     return;
@@ -113,8 +148,8 @@ int32 score_lo = 0,
   if(rom[0x7fc0 + REGION] < 14)score_lo++;
   if(rom[0xffc0 + REGION] < 14)score_hi++;
 
-  if(rom[0x7fc0 + LICENSE] < 3)score_lo++;
-  if(rom[0xffc0 + LICENSE] < 3)score_hi++;
+  if(rom[0x7fc0 + COMPANY] < 3)score_lo++;
+  if(rom[0xffc0 + COMPANY] < 3)score_hi++;
 
   if(rom[0x7fc0 + RESH] & 0x80)score_lo += 2;
   if(rom[0xffc0 + RESH] & 0x80)score_hi += 2;
@@ -132,7 +167,7 @@ uint16 cksum, icksum;
     score_hi += 8;
   }
 
-  if(info.rom_size < 0x401000) {
+  if(cart.rom_size < 0x401000) {
     score_ex = 0;
   } else {
     if(rom[0x7fc0 + MAPPER] == 0x32)score_lo++;

src/cart/cart_normal.cpp

@@ -1,66 +1,41 @@
-void Cartridge::load_rom_normal() {
-uint size = 0;
-  for(int i = 0; i < file.count; i++) {
-    size += file.rom_size[i] - (((file.rom_size[i] & 0x7fff) == 512) ? 512 : 0);
-  }
-
-  info.rom_size = size;
-  rom = (uint8*)malloc(info.rom_size);
-  memset(rom, 0, info.rom_size);
-
-uint offset = 0;
-  for(int i = 0; i < file.count; i++) {
-  uint8 *data = file.rom_data[i] + (((file.rom_size[i] & 0x7fff) == 512) ? 512 : 0);
-  uint   size = file.rom_size[i] - (((file.rom_size[i] & 0x7fff) == 512) ? 512 : 0);
-    memcpy(rom + offset, data, size);
-    offset += size;
-    safe_free(file.rom_data[i]);
-  }
-
-  info.crc32 = crc32_calculate(rom, info.rom_size);
-
-  if(read_database() == true) {
-    info.srtc = false;
-    info.sdd1 = false;
-    info.c4   = false;
-    info.dsp1 = false;
-    info.dsp2 = false;
-    info.obc1 = false;
-
-    info.dsp1_mapper = 0;
-
-    info.header_index = 0xffc0;
-    info.mapper = PCB;
-    strcpy(info.name, dbi.name);
-    strcpy(info.pcb,  dbi.pcb);
-    info.region = NTSC;
-    info.cart_mmio = false;
-
-    info.rom_size = dbi.rom;
-    info.ram_size = dbi.ram;
-  } else {
-    find_header();
-    read_header();
-  }
-}
-
-void Cartridge::load_ram_normal() {
-  if(info.ram_size == 0) {
-    ram = 0;
-    return;
-  }
-
-  ram = (uint8*)malloc(info.ram_size);
-  memset(ram, 0xff, info.ram_size);
-
-  if(load_file(file.ram_name[0], file.ram_data[0], file.ram_size[0]) == true) {
-    memcpy(ram, file.ram_data[0], min(info.ram_size, file.ram_size[0]));
-    safe_free(file.ram_data[0]);
-  }
-}
-
-void Cartridge::save_ram_normal() {
-  if(info.ram_size == 0)return;
-
-  save_file(file.ram_name[0], ram, info.ram_size);
-}
+void Cartridge::load_cart_normal(const char *filename) {
+  if(!filename || !*filename) return;
+
+uint8 *data;
+uint size;
+  if(load_file(filename, data, size) == false) return;
+  strcpy(cart.fn, filename);
+
+  load_begin(CartridgeNormal);
+
+//load ROM data, ignore 512-byte header if detected
+  if((size & 0x7fff) != 512) {
+    cart.rom = (uint8*)malloc(cart.rom_size = size);
+    memcpy(cart.rom, data, size);
+  } else {
+    cart.rom = (uint8*)malloc(cart.rom_size = size - 512);
+    memcpy(cart.rom, data + 512, size - 512);
+  }
+  safe_free(data);
+
+  info.crc32 = crc32_calculate(cart.rom, cart.rom_size);
+
+  find_header();
+  read_header();
+
+  if(info.ram_size > 0) {
+    cart.ram = (uint8*)malloc(cart.ram_size = info.ram_size);
+    memset(cart.ram, 0xff, cart.ram_size);
+
+    if(load_file(get_save_filename(cart.fn, "srm"), data, size) == true) {
+      memcpy(cart.ram, data, min(size, cart.ram_size));
+      safe_free(data);
+    }
+  }
+
+  load_end();
+}
+
+void Cartridge::unload_cart_normal() {
+  if(cart.ram) save_file(get_save_filename(cart.fn, "srm"), cart.ram, cart.ram_size);
+}

src/cart/cart_st.cpp

@@ -1,45 +1,59 @@
-void Cartridge::load_rom_st() {
-uint8 *data;
-uint   size;
-string bios = config::file_updatepath("stbios.bin", config::path.bios);
-  info.rom_size = 0x200000;
-  rom = (uint8*)malloc(info.rom_size);
-  memset(rom, 0, info.rom_size);
-
-  load_file(strptr(bios), data, size);
-  memcpy(rom, data, min(size, 0x040000));
-  safe_free(data);
-
-  memcpy(rom + 0x100000, file.rom_data[0], min(file.rom_size[0], 0x100000));
-  safe_free(file.rom_data[0]);
-
-//
-  strcpy(info.name, "???");
-  strcpy(info.pcb,  "STC-SOLO");
-
-  info.mapper = PCB;
-  info.region = NTSC;
-
-  info.rom_size = 0x200000;
-  info.ram_size = 0x020000;
-//
-
-  info.crc32 = crc32_calculate(rom + 0x100000, file.rom_size[0]);
-  if(read_database() == true) {
-    strcpy(info.name, dbi.name);
-  }
-}
-
-void Cartridge::load_ram_st() {
-  ram = (uint8*)malloc(info.ram_size);
-  memset(ram, 0xff, info.ram_size);
-
-  if(load_file(file.ram_name[0], file.ram_data[0], file.ram_size[0]) == true) {
-    memcpy(ram, file.ram_data[0], min(file.ram_size[0], 0x020000));
-    safe_free(file.ram_data[0]);
-  }
-}
-
-void Cartridge::save_ram_st() {
-  save_file(file.ram_name[0], ram, 0x020000);
-}
+void Cartridge::load_cart_st(const char *base, const char *slotA, const char *slotB) {
+  if(!base || !*base) return;
+
+  strcpy(cart.fn, base);
+  strcpy(stA.fn, slotA ? slotA : "");
+  strcpy(stB.fn, slotB ? slotB : "");
+
+  load_begin(CartridgeSufamiTurbo);
+  info.st = true;
+  info.mapper = STROM;
+  info.region = NTSC;
+
+uint8 *data;
+uint size;
+  if(load_file(cart.fn, data, size) == true) {
+    cart.rom = (uint8*)malloc(cart.rom_size = 0x040000);
+    memcpy(cart.rom, data, min(size, cart.rom_size));
+    safe_free(data);
+  }
+
+  if(*stA.fn) {
+    if(load_file(stA.fn, data, size) == true) {
+      stA.rom = (uint8*)malloc(stA.rom_size = 0x100000);
+      memcpy(stA.rom, data, min(size, stA.rom_size));
+      safe_free(data);
+
+      stA.ram = (uint8*)malloc(stA.ram_size = 0x020000);
+      memset(stA.ram, 0xff, stA.ram_size);
+
+      if(load_file(get_save_filename(stA.fn, "srm"), data, size) == true) {
+        memcpy(stA.ram, data, min(size, 0x020000U));
+        safe_free(data);
+      }
+    }
+  }
+
+  if(*stB.fn) {
+    if(load_file(stB.fn, data, size) == true) {
+      stB.rom = (uint8*)malloc(stB.rom_size = 0x100000);
+      memcpy(stB.rom, data, min(size, stB.rom_size));
+      safe_free(data);
+
+      stB.ram = (uint8*)malloc(stB.ram_size = 0x020000);
+      memset(stB.ram, 0xff, stB.ram_size);
+
+      if(load_file(get_save_filename(stB.fn, "srm"), data, size) == true) {
+        memcpy(stB.ram, data, min(size, 0x020000U));
+        safe_free(data);
+      }
+    }
+  }
+
+  load_end();
+}
+
+void Cartridge::unload_cart_st() {
+  if(stA.ram) save_file(get_save_filename(stA.fn, "srm"), stA.ram, stA.ram_size);
+  if(stB.ram) save_file(get_save_filename(stB.fn, "srm"), stB.ram, stB.ram_size);
+}

src/cart/cart_stdual.cpp

@@ -1,66 +0,0 @@
-void Cartridge::load_rom_stdual() {
-uint8 *data;
-uint   size;
-string bios = config::file_updatepath("stbios.bin", config::path.bios);
-  info.rom_size = 0x300000;
-  rom = (uint8*)malloc(info.rom_size);
-  memset(rom, 0, info.rom_size);
-
-  load_file(strptr(bios), data, size);
-  memcpy(rom, data, min(size, 0x040000));
-  safe_free(data);
-
-  memcpy(rom + 0x100000, file.rom_data[0], min(file.rom_size[0], 0x100000));
-  safe_free(file.rom_data[0]);
-
-  memcpy(rom + 0x200000, file.rom_data[1], min(file.rom_size[1], 0x100000));
-  safe_free(file.rom_data[1]);
-
-char name_a[4096], name_b[4096];
-  strcpy(name_a, "???");
-  strcpy(name_b, "???");
-//
-  info.mapper = PCB;
-  info.region = NTSC;
-
-  info.rom_size = 0x300000;
-  info.ram_size = 0x040000;
-//
-
-  info.crc32 = crc32_calculate(rom + 0x100000, file.rom_size[0]);
-  if(read_database() == true) {
-    strcpy(name_a, dbi.name);
-  }
-
-  info.crc32 = crc32_calculate(rom + 0x200000, file.rom_size[1]);
-  if(read_database() == true) {
-    strcpy(name_b, dbi.name);
-  }
-
-//
-  info.crc32 = 0;
-  strcpy(info.name, name_a);
-  strcat(info.name, " + ");
-  strcat(info.name, name_b);
-  strcpy(info.pcb, "STC-DUAL");
-}
-
-void Cartridge::load_ram_stdual() {
-  ram = (uint8*)malloc(info.ram_size);
-  memset(ram, 0xff, info.ram_size);
-
-  if(load_file(file.ram_name[0], file.ram_data[0], file.ram_size[0]) == true) {
-    memcpy(ram + 0x000000, file.ram_data[0], min(file.ram_size[0], 0x020000));
-    safe_free(file.ram_data[0]);
-  }
-
-  if(load_file(file.ram_name[1], file.ram_data[1], file.ram_size[1]) == true) {
-    memcpy(ram + 0x020000, file.ram_data[1], min(file.ram_size[1], 0x020000));
-    safe_free(file.ram_data[1]);
-  }
-}
-
-void Cartridge::save_ram_stdual() {
-  save_file(file.ram_name[0], ram + 0x000000, 0x020000);
-  save_file(file.ram_name[1], ram + 0x020000, 0x020000);
-}

src/cart/database.cpp

@@ -1,37 +0,0 @@
-void Cartridge::load_database() {
-  database      = 0;
-  database_size = 0;
-
-FILE *fp;
-  fp = fopen("cart.db", "rb");
-  if(!fp)return;
-
-uint size = fsize(fp);
-  if(size < 8) {
-    fclose(fp);
-    return;
-  }
-
-  database = (uint8*)malloc(size);
-  fread(database, 1, size, fp);
-  fclose(fp);
-
-  database_blocksize = (database[6] << 0) | (database[7] << 8);
-  database_size      = (size - 8) / database_blocksize;
-}
-
-bool Cartridge::read_database() {
-uint i, crc32;
-  for(i = 0; i < database_size; i++) {
-  uint8 *p = database + 8 + (i * database_blocksize);
-    crc32  = *(p++) <<  0;
-    crc32 |= *(p++) <<  8;
-    crc32 |= *(p++) << 16;
-    crc32 |= *(p++) << 24;
-    if(crc32 == cartridge.info.crc32)break;
-  }
-  if(i >= database_size)return false;
-
-  db_read(dbi, database + 8 + (i * database_blocksize));
-  return true;
-}

src/cart/db/cartdb.txt

@@ -1,113 +0,0 @@
-[0xbb5c4238]
-name = "Bishoujo Senshi Sailor Moon Sailor Stars - Fuwa Fuwa Panic 2 (Japan)"
-pcb  = "STC-????"
-rom  =  8mbit
-ram  = 32kbit
-
-[0x8eb753f3]
-name = "Crayon Shin-chan - Nagagutsu Dobon!! (Japan)"
-pcb  = "STC-????"
-rom  = 4mbit
-ram  = 8kbit
-
-[0x7aedd703]
-name = "Der Langrisser (Japan) [!]"
-pcb  = "SHVC-1A3M-30"
-rom  = 16mbit
-ram  = 64kbit
-
-[0x19bdcb19]
-name = "Derby Stallion '96 (Japan) [!]"
-pcb  = "BSC-1A5M-01"
-rom  =  24mbit
-ram  = 256kbit
-
-[0x4296500d]
-name = "Gegege no Kitarou - Youkai Donjara (Japan)"
-pcb  = "STC-????"
-rom  =  4mbit
-ram  = 16kbit
-
-[0x14c66fca]
-name = "Gekisou Sentai Car Rangers (Japan)"
-pcb  = "STC-????"
-rom  = 4mbit
-ram  = 8kbit
-
-[0x32b2b3dd]
-name = "Poi Poi Ninja World (Japan)"
-pcb  = "STC-????"
-rom  = 4mbit
-ram  = 8kbit
-
-[0x9684526d]
-name = "Romancing SaGa (Japan) (V1.1) [!]"
-pcb  = "SHVC-1A3B-12"
-rom  =  8mbit
-ram  = 64kbit
-
-[0xafd74dcb]
-name = "SD Gundam Generation A - Ichinen Sensouki (Japan)"
-pcb  = "STC-????"
-rom  = 4mbit
-ram  = 8kbit
-
-[0x48ecae44]
-name = "SD Gundam Generation B - Grips Senki (Japan)"
-pcb  = "STC-????"
-rom  = 4mbit
-ram  = 8kbit
-
-[0x72b4235f]
-name = "SD Gundam Generation C - Axis Senki (Japan)"
-pcb  = "STC-????"
-rom  = 4mbit
-ram  = 8kbit
-
-[0x792d884c]
-name = "SD Gundam Generation D - Babylonia Kenkoku Senki (Japan)"
-pcb  = "STC-????"
-rom  = 4mbit
-ram  = 8kbit
-
-[0xefd3a865]
-name = "SD Gundam Generation E - Zanskar Senki (Japan)"
-pcb  = "STC-????"
-rom  = 4mbit
-ram  = 8kbit
-
-[0xc5dfa8fd]
-name = "SD Gundam Generation F - Colony Kakutouki (Japan)"
-pcb  = "STC-????"
-rom  = 4mbit
-ram  = 8kbit
-
-[0x43ad5a45]
-name = "SD Ultra Battle - Seven Densetsu (Japan)"
-pcb  = "STC-????"
-rom  = 4mbit
-ram  = 8kbit
-
-[0x04939d14]
-name = "SD Ultra Battle - Ultra Densetsu (Japan)"
-pcb  = "STC-????"
-rom  = 4mbit
-ram  = 8kbit
-
-[0xa5c0045e]
-name = "Secret of Evermore (USA) [!]"
-pcb  = "SHVC-1J3M-20"
-rom  = 32mbit
-ram  = 64kbit
-
-[0x5ebf7246]
-name = "Sound Novel Tsukuru (Japan) [!]"
-pcb  = "BSC-1A7M-10"
-rom  =  24mbit
-ram  = 512kbit
-
-[0x64a91e64]
-name = "Wanderers from Ys (USA) [!]"
-pcb  = "SHVC-1A3B-12"
-rom  =  8mbit
-ram  = 64kbit

src/cart/db/cc.bat

@@ -1,3 +0,0 @@
-cl /nologo /O2 dbcreate.cpp
-@pause
-@del *.obj

src/cart/db/clean.bat

@@ -1 +0,0 @@
-@del *.exe

src/cart/db/create.bat

@@ -1,2 +0,0 @@
-dbcreate
-@copy cart.db ..\..\..\cart.db

src/cart/db/db.h

@@ -1,47 +0,0 @@
-struct db_item {
-  uint32 crc32;
-  char   name[128];
-  char   pcb [32];
-  uint32 rom;
-  uint32 ram;
-};
-
-void db_write(FILE *fp, db_item &dbi) {
-  fputc(dbi.crc32 >>  0, fp);
-  fputc(dbi.crc32 >>  8, fp);
-  fputc(dbi.crc32 >> 16, fp);
-  fputc(dbi.crc32 >> 24, fp);
-
-  fwrite(dbi.name, 1, 128, fp);
-  fwrite(dbi.pcb,  1,  32, fp);
-
-  fputc(dbi.rom >>  0, fp);
-  fputc(dbi.rom >>  8, fp);
-  fputc(dbi.rom >> 16, fp);
-  fputc(dbi.rom >> 24, fp);
-
-  fputc(dbi.ram >>  0, fp);
-  fputc(dbi.ram >>  8, fp);
-  fputc(dbi.ram >> 16, fp);
-  fputc(dbi.ram >> 24, fp);
-}
-
-void db_read(db_item &dbi, uint8 *data) {
-  dbi.crc32  = (*data++) <<  0;
-  dbi.crc32 |= (*data++) <<  8;
-  dbi.crc32 |= (*data++) << 16;
-  dbi.crc32 |= (*data++) << 24;
-
-  memcpy(dbi.name, data, 128); dbi.name[127] = 0; data += 128;
-  memcpy(dbi.pcb,  data,  32); dbi.pcb [ 31] = 0; data +=  32;
-
-  dbi.rom  = (*data++) <<  0;
-  dbi.rom |= (*data++) <<  8;
-  dbi.rom |= (*data++) << 16;
-  dbi.rom |= (*data++) << 24;
-
-  dbi.ram  = (*data++) <<  0;
-  dbi.ram |= (*data++) <<  8;
-  dbi.ram |= (*data++) << 16;
-  dbi.ram |= (*data++) << 24;
-}

src/cart/db/dbcreate.cpp

@@ -1,117 +0,0 @@
-#include "../../lib/libbase.h"
-#include "../../lib/libvector.h"
-#include "../../lib/libstring.h"
-
-#include "../../lib/libstring.cpp"
-
-#include "db.h"
-
-FILE *fp;
-
-uint decode_size(string &str) {
-//hex encoding
-  if(strbegin(str, "0x")) {
-    strltrim(str, "0x");
-    return strhex(str);
-  }
-
-//mbit encoding
-  if(strend(str, "mbit")) {
-    strrtrim(str, "mbit");
-    return strdec(str) * 1024 * 1024 / 8;
-  }
-
-//kbit encoding
-  if(strend(str, "kbit")) {
-    strrtrim(str, "kbit");
-    return strdec(str) * 1024 / 8;
-  }
-
-//decimal encoding
-  return strdec(str);
-}
-
-void build_block(string &block) {
-stringarray line, hashpart, part;
-  split(line, "\n", block);
-
-  if(strbegin(line[0], "[") == false) {
-    printf("error: invalid block detected: '%s'\n", strptr(line[0]));
-    return;
-  }
-
-  strltrim(line[0], "[");
-  strrtrim(line[0], "]");
-  replace(line[0], "0x", "");
-  split(hashpart, ",", line[0]);
-
-db_item dbi;
-  dbi.crc32 = 0;
- *dbi.name  = 0;
- *dbi.pcb   = 0;
-  dbi.rom   = 0;
-  dbi.ram   = 0;
-
-  for(int i = 1; i < count(line); i++) {
-  uint pos;
-    if(strpos(line[i], ";", pos) == true) {
-      strset(line[i], pos, 0);
-    }
-
-    if(line[i] == "")continue;
-
-    split(part, "=", line[i]);
-    strunquote(part[1]);
-
-    if(part[0] == "name") {
-      strncpy(dbi.name, strptr(part[1]), 128);
-      dbi.name[128] = 0;
-    }
-
-    if(part[0] == "pcb") {
-      strncpy(dbi.pcb, strptr(part[1]), 32);
-      dbi.pcb[31] = 0;
-    }
-
-    if(part[0] == "rom") {
-      dbi.rom = decode_size(part[1]);
-    }
-
-    if(part[0] == "ram") {
-      dbi.ram = decode_size(part[1]);
-    }
-  }
-
-  for(int i = 0; i < count(hashpart); i++) {
-    dbi.crc32 = strhex(hashpart[i]);
-    db_write(fp, dbi);
-  }
-}
-
-void build_database() {
-stringarray data, block;
-  if(strfread(data, "cartdb.txt") == false)return;
-
-  fp = fopen("cart.db", "wb");
-  fprintf(fp, "SNESDB");
-
-uint blocksize = 4 + 128 + 32 + 4 + 4;
-  fputc(blocksize >> 0, fp);
-  fputc(blocksize >> 8, fp);
-
-  replace (data, "\r", "");
-  qreplace(data, " ",  "");
-  qreplace(data, "\t", "");
-  split(block, "\n\n", data);
-
-  for(int i = 0; i < count(block); i++) {
-    build_block(block[i]);
-  }
-
-  fclose(fp);
-}
-
-int main() {
-  build_database();
-  return 0;
-}

src/cc.bat

@@ -1,3 +1,3 @@
-@make -r PLATFORM=win-visualc-lui
-@move bsnes.exe ../bsnes.exe>nul
-@pause
+@make platform=win compiler=mingw32-gcc
+::@make platform=win compiler=mingw32-gcc enable_gzip=true enable_jma=true
+@pause

src/cc.sh

@@ -1,2 +1,2 @@
-#!/bin/sh
-make PLATFORM=x-gcc-lui
+make platform=x compiler=gcc
+#make platform=x compiler=gcc enable_gzip=true enable_jma=true

src/cheat/cheat.cpp

@@ -10,21 +10,21 @@ Cheat cheat;
  *****/
 
 bool Cheat::decode(char *str, uint32 &addr, uint8 &data, uint8 &type) {
-stringarray t, part;
+string t, part;
   strcpy(t, str);
-  strlower(t);
-  if(strlen(t) == 8 || (strlen(t) == 9 && strptr(t)[6] == ':')) {
+  strlower(t());
+  if(strlen(t) == 8 || (strlen(t) == 9 && t()[6] == ':')) {
     type = CT_PRO_ACTION_REPLAY;
     replace(t, ":", "");
-  uint32 r = strhex(t);
+  uint32 r = strhex((const char*)t);
     addr = r >> 8;
     data = r & 0xff;
     return true;
-  } else if(strlen(t) == 9 && strptr(t)[4] == '-') {
+  } else if(strlen(t) == 9 && t()[4] == '-') {
     type = CT_GAME_GENIE;
     replace(t, "-", "");
     strtr(t, "df4709156bc8a23e", "0123456789abcdef");
-  uint32 r = strhex(t);
+  uint32 r = strhex((const char*)t);
   //8421 8421 8421 8421 8421 8421
   //abcd efgh ijkl mnop qrst uvwx
   //ijkl qrst opab cduv wxef ghmn
@@ -269,51 +269,40 @@ void Cheat::disable(uint32 n) {
  * cheat file manipulation routines
  *****/
 
+/* file format: */
+/* nnnn-nnnn = status, "description" \r\n */
+/* ... */
+
 bool Cheat::load(const char *fn) {
-FileReader rf(fn);
-  if(!rf.ready())return false;
-
-uint8 *raw_data = rf.read();
-stringarray data, line;
-  raw_data[rf.size()] = 0;
-  strcpy(data, (char*)raw_data);
-  safe_free(raw_data);
+string data;
+  if(!fread(data, fn)) return false;
   replace(data, "\r\n", "\n");
+  qreplace(data, "=", ",");
+  qreplace(data, " ", "");
 
+lstring line;
   split(line, "\n", data);
   for(int i = 0; i < ::count(line); i++) {
-  stringarray part;
-  uint8  en = *(strptr(line[i]));
-    if(en == '+') {
-      strltrim(line[i], "+");
-    } else if(en == '-') {
-      strltrim(line[i], "-");
-    } else {
-      continue;
-    }
-    qreplace(line[i], " ", "");
-    qsplit(part, ",", line[i]);
-    if(::count(part) != 2)continue;
-    strunquote(part[1]);
-    add(en == '+', strptr(part[0]), strptr(part[1]));
+  lstring part;
+    split(part, ",", line[i]);
+    if(::count(part) != 3) continue;
+    trim(part[2], "\"");
+    add(part[1] == "enabled", part[0](), part[2]());
   }
 
   return true;
 }
 
 bool Cheat::save(const char *fn) {
-FileWriter wf(fn);
-  if(!wf.ready())return false;
-
-string data;
-char   t[4096];
-  strcpy(data, "");
+FILE *fp = fopen(fn, "wb");
+  if(!fp) return false;
   for(int i = 0; i < cheat_count; i++) {
-    sprintf(t, "%c%s, \"%s\"\r\n", index[i].enabled ? '+' : '-', index[i].code, index[i].desc);
-    strcat(data, t);
+    fprintf(fp, "%9s = %8s, \"%s\"\r\n",
+      index[i].code,
+      index[i].enabled ? "enabled" : "disabled",
+      index[i].desc);
   }
-
-  wf.write((uint8*)strptr(data), strlen(data));
+  fclose(fp);
   return true;
 }
 
@@ -323,12 +312,12 @@ char   t[4096];
 
 void Cheat::clear() {
   cheat_enabled = false;
-  cheat_count   = 0;
+  cheat_count = 0;
   memset(mask, 0, 0x200000);
-  for(int i = 0; i < CHEAT_LIMIT + 1; i++) {
+  for(int i = 0; i <= CHEAT_LIMIT; i++) {
     index[i].enabled = false;
-    index[i].addr    = 0x000000;
-    index[i].data    = 0x00;
+    index[i].addr = 0x000000;
+    index[i].data = 0x00;
     strcpy(index[i].code, "");
     strcpy(index[i].desc, "");
   }

src/cheat/cheat.h

@@ -2,18 +2,22 @@
 
 class Cheat {
 public:
-enum { CT_PRO_ACTION_REPLAY, CT_GAME_GENIE };
+  enum {
+    CT_PRO_ACTION_REPLAY,
+    CT_GAME_GENIE
+  };
 
-struct CheatIndex {
-  bool   enabled;
-  uint32 addr;
-  uint8  data;
-  char   code[ 16 + 1];
-  char   desc[128 + 1];
-} index[CHEAT_LIMIT + 1];
-bool   cheat_enabled;
-uint32 cheat_count;
-uint8  mask[0x200000];
+  struct CheatIndex {
+    bool   enabled;
+    uint32 addr;
+    uint8  data;
+    char   code[ 16 + 1];
+    char   desc[128 + 1];
+  } index[CHEAT_LIMIT + 1];
+
+  bool   cheat_enabled;
+  uint32 cheat_count;
+  uint8  mask[0x200000];
 
   inline bool enabled() { return cheat_enabled; }
   inline uint count() { return cheat_count; }
@@ -22,12 +26,6 @@ uint8  mask[0x200000];
   bool  decode(char *str, uint32 &addr, uint8 &data, uint8 &type);
   bool  encode(char *str, uint32  addr, uint8  data, uint8  type);
 
-private:
-  uint  mirror_address(uint addr);
-  void  set(uint32 addr);
-  void  clear(uint32 addr);
-public:
-
   bool  read(uint32 addr, uint8 &data);
 
   void  update_cheat_status();
@@ -42,7 +40,12 @@ public:
   bool  save(const char *fn);
   void  clear();
 
-  Cheat();
+  Cheat();
+
+private:
+  uint  mirror_address(uint addr);
+  void  set(uint32 addr);
+  void  clear(uint32 addr);
 };
 
 extern Cheat cheat;

src/chip/bsx/bsx.cpp

@@ -0,0 +1,5 @@
+#include "../../base.h"
+
+#include "bsx_base.cpp"
+#include "bsx_cart.cpp"
+#include "bsx_flash.cpp"

src/chip/bsx/bsx.h

@@ -0,0 +1,77 @@
+class BSXBase : public MMIO {
+public:
+  void init();
+  void enable();
+  void power();
+  void reset();
+
+  uint8 mmio_read(uint addr);
+  void mmio_write(uint addr, uint8 data);
+
+private:
+  struct {
+    uint8 r2188, r2189, r218a, r218b;
+    uint8 r218c, r218d, r218e, r218f;
+    uint8 r2190, r2191, r2192, r2193;
+    uint8 r2194, r2195, r2196, r2197;
+    uint8 r2198, r2199, r219a, r219b;
+    uint8 r219c, r219d, r219e, r219f;
+
+    uint8 r2192_counter;
+    uint8 r2192_hour, r2192_minute, r2192_second;
+  } regs;
+};
+
+class BSXCart : public MMIO {
+public:
+  void init();
+  void enable();
+  void power();
+  void reset();
+
+  uint8 mmio_read(uint addr);
+  void mmio_write(uint addr, uint8 data);
+
+  MappedRAM sram;
+  MappedRAM psram;
+
+  BSXCart();
+  ~BSXCart();
+
+private:
+  uint8 *sram_data;  //256kbit SRAM
+  uint8 *psram_data; //  4mbit PSRAM
+
+  struct {
+    uint8 r[16];
+  } regs;
+
+  void update_memory_map();
+};
+
+class BSXFlash : public Memory {
+public:
+  void init();
+  void enable();
+  void power();
+  void reset();
+
+  uint size();
+  uint8 read(uint addr);
+  void write(uint addr, uint8 data);
+
+private:
+  struct {
+    uint command;
+    uint8 write_old;
+    uint8 write_new;
+
+    bool flash_enable;
+    bool read_enable;
+    bool write_enable;
+  } regs;
+};
+
+extern BSXBase  bsxbase;
+extern BSXCart  bsxcart;
+extern BSXFlash bsxflash;

src/chip/bsx/bsx_base.cpp

@@ -0,0 +1,133 @@
+void BSXBase::init() {
+}
+
+void BSXBase::enable() {
+  for(uint16 i = 0x2188; i <= 0x219f; i++) memory::mmio.map(i, *this);
+}
+
+void BSXBase::power() {
+  reset();
+}
+
+void BSXBase::reset() {
+  memset(&regs, 0x00, sizeof regs);
+}
+
+uint8 BSXBase::mmio_read(uint addr) {
+  addr &= 0xffff;
+
+  switch(addr) {
+    case 0x2188: return regs.r2188;
+    case 0x2189: return regs.r2189;
+    case 0x218a: return regs.r218a;
+    case 0x218c: return regs.r218c;
+    case 0x218e: return regs.r218e;
+    case 0x218f: return regs.r218f;
+    case 0x2190: return regs.r2190;
+
+    case 0x2192: {
+    uint counter = regs.r2192_counter++;
+      if(regs.r2192_counter >= 18) regs.r2192_counter = 0;
+
+      if(counter == 0) {
+      time_t rawtime;
+        time(&rawtime);
+      tm *t = localtime(&rawtime);
+
+        regs.r2192_hour   = t->tm_hour;
+        regs.r2192_minute = t->tm_min;
+        regs.r2192_second = t->tm_sec;
+      }
+
+      switch(counter) {
+        case  0: return 0x00; //???
+        case  1: return 0x00; //???
+        case  2: return 0x00; //???
+        case  3: return 0x00; //???
+        case  4: return 0x00; //???
+        case  5: return 0x01;
+        case  6: return 0x01;
+        case  7: return 0x00;
+        case  8: return 0x00;
+        case  9: return 0x00;
+        case 10: return regs.r2192_second;
+        case 11: return regs.r2192_minute;
+        case 12: return regs.r2192_hour;
+        case 13: return 0x00; //???
+        case 14: return 0x00; //???
+        case 15: return 0x00; //???
+        case 16: return 0x00; //???
+        case 17: return 0x00; //???
+      }
+    } break;
+
+    case 0x2193: return regs.r2193 & ~0x0c;
+    case 0x2194: return regs.r2194;
+    case 0x2196: return regs.r2196;
+    case 0x2197: return regs.r2197;
+    case 0x2199: return regs.r2199;
+  }
+
+  return cpu.regs.mdr;
+}
+
+void BSXBase::mmio_write(uint addr, uint8 data) {
+  addr &= 0xffff;
+
+  switch(addr) {
+    case 0x2188: {
+      regs.r2188 = data;
+    } break;
+
+    case 0x2189: {
+      regs.r2189 = data;
+    } break;
+
+    case 0x218a: {
+      regs.r218a = data;
+    } break;
+
+    case 0x218b: {
+      regs.r218b = data;
+    } break;
+
+    case 0x218c: {
+      regs.r218c = data;
+    } break;
+
+    case 0x218e: {
+      regs.r218e = data;
+    } break;
+
+    case 0x218f: {
+      regs.r218e >>= 1;
+      regs.r218e = regs.r218f - regs.r218e;
+      regs.r218f >>= 1;
+    } break;
+
+    case 0x2191: {
+      regs.r2191 = data;
+      regs.r2192_counter = 0;
+    } break;
+
+    case 0x2192: {
+      regs.r2190 = 0x80;
+    } break;
+
+    case 0x2193: {
+      regs.r2193 = data;
+    } break;
+
+    case 0x2194: {
+      regs.r2194 = data;
+    } break;
+
+    case 0x2197: {
+      regs.r2197 = data;
+    } break;
+
+    case 0x2199: {
+      regs.r2199 = data;
+    } break;
+  }
+}

src/chip/bsx/bsx_cart.cpp

@@ -0,0 +1,95 @@
+void BSXCart::init() {
+}
+
+void BSXCart::enable() {
+  for(uint16 i = 0x5000; i <= 0x5fff; i++) memory::mmio.map(i, *this);
+}
+
+void BSXCart::power() {
+  reset();
+}
+
+void BSXCart::reset() {
+  for(uint i = 0; i < 16; i++) regs.r[i] = 0x00;
+  regs.r[0x07] = 0x80;
+  regs.r[0x08] = 0x80;
+
+  update_memory_map();
+}
+
+void BSXCart::update_memory_map() {
+Memory &cart = (regs.r[0x01] & 0x80) == 0x00 ? (Memory&)bsxflash : (Memory&)psram;
+
+  if((regs.r[0x02] & 0x80) == 0x00) { //LoROM mapping
+    bus.map(Bus::MapLinear, 0x00, 0x7d, 0x8000, 0xffff, cart);
+    bus.map(Bus::MapLinear, 0x80, 0xff, 0x8000, 0xffff, cart);
+  } else { //HiROM mapping
+    bus.map(Bus::MapShadow, 0x00, 0x3f, 0x8000, 0xffff, cart);
+    bus.map(Bus::MapLinear, 0x40, 0x7d, 0x0000, 0xffff, cart);
+    bus.map(Bus::MapShadow, 0x80, 0xbf, 0x8000, 0xffff, cart);
+    bus.map(Bus::MapLinear, 0xc0, 0xff, 0x0000, 0xffff, cart);
+  }
+
+  if(regs.r[0x03] & 0x80) {
+    bus.map(Bus::MapLinear, 0x60, 0x6f, 0x0000, 0xffff, psram);
+  //bus.map(Bus::MapLinear, 0x70, 0x77, 0x0000, 0xffff, psram);
+  }
+
+  if((regs.r[0x05] & 0x80) == 0x00) {
+    bus.map(Bus::MapLinear, 0x40, 0x4f, 0x0000, 0xffff, psram);
+  }
+
+  if((regs.r[0x06] & 0x80) == 0x00) {
+    bus.map(Bus::MapLinear, 0x50, 0x5f, 0x0000, 0xffff, psram);
+  }
+
+  if(regs.r[0x07] & 0x80) {
+    bus.map(Bus::MapLinear, 0x00, 0x1f, 0x8000, 0xffff, memory::cartrom);
+  }
+
+  if(regs.r[0x08] & 0x80) {
+    bus.map(Bus::MapLinear, 0x80, 0x9f, 0x8000, 0xffff, memory::cartrom);
+  }
+
+  bus.map(Bus::MapShadow, 0x20, 0x3f, 0x6000, 0x7fff, psram);
+  bus.map(Bus::MapLinear, 0x70, 0x77, 0x0000, 0xffff, psram);
+}
+
+uint8 BSXCart::mmio_read(uint addr) {
+  if((addr & 0xf0ffff) == 0x005000) { //$[00-0f]:5000 MMIO
+  uint8 n = (addr >> 16) & 15;
+    return regs.r[n];
+  }
+
+  if((addr & 0xf8f000) == 0x105000) { //$[10-17]:[5000-5fff] SRAM
+    return sram.read(((addr >> 16) & 7) * 0x1000 + (addr & 0xfff));
+  }
+
+  return 0x00;
+}
+
+void BSXCart::mmio_write(uint addr, uint8 data) {
+  if((addr & 0xf0ffff) == 0x005000) { //$[00-0f]:5000 MMIO
+  uint8 n = (addr >> 16) & 15;
+    regs.r[n] = data;
+    if(n == 0x0e && data & 0x80) update_memory_map();
+    return;
+  }
+
+  if((addr & 0xf8f000) == 0x105000) { //$[10-17]:[5000-5fff] SRAM
+    return sram.write(((addr >> 16) & 7) * 0x1000 + (addr & 0xfff), data);
+  }
+}
+
+BSXCart::BSXCart() {
+  sram_data  = (uint8*)malloc( 32 * 1024);
+  psram_data = (uint8*)malloc(512 * 1024);
+
+  sram.map (sram_data,   32 * 1024);
+  psram.map(psram_data, 512 * 1024);
+}
+
+BSXCart::~BSXCart() {
+  safe_free(sram_data);
+  safe_free(psram_data);
+}

src/chip/bsx/bsx_flash.cpp

@@ -0,0 +1,109 @@
+void BSXFlash::init() {}
+void BSXFlash::enable() {}
+
+void BSXFlash::power() {
+  reset();
+}
+
+void BSXFlash::reset() {
+  regs.command   = 0;
+  regs.write_old = 0x00;
+  regs.write_new = 0x00;
+
+  regs.flash_enable = false;
+  regs.read_enable  = false;
+  regs.write_enable = false;
+}
+
+uint BSXFlash::size() {
+  return memory::bscram.size();
+}
+
+uint8 BSXFlash::read(uint addr) {
+  if(addr == 0x0002) {
+    if(regs.flash_enable) return 0x80;
+  }
+
+  if(addr == 0x5555) {
+    if(regs.flash_enable) return 0x80;
+  }
+
+  if(regs.read_enable && addr >= 0xff00 && addr <= 0xff13) {
+  //read flash cartridge vendor information
+    switch(addr - 0xff00) {
+      case 0x00: return 0x4d;
+      case 0x01: return 0x00;
+      case 0x02: return 0x50;
+      case 0x03: return 0x00;
+      case 0x04: return 0x00;
+      case 0x05: return 0x00;
+      case 0x06: return 0x2a; //0x2a = 8mbit, 0x2b = 16mbit (not known to exist, though BIOS recognizes ID)
+      case 0x07: return 0x00;
+      default:   return 0x00;
+    }
+  }
+
+  return memory::bscram.read(addr);
+}
+
+void BSXFlash::write(uint addr, uint8 data) {
+//there exist both read-only and read-write BS-X flash cartridges ...
+//unfortunately, the vendor info is not stored inside memory dumps
+//of BS-X flashcarts, so it is impossible to determine whether a
+//given flashcart is writeable.
+//however, it has been observed that LoROM-mapped BS-X carts always
+//use read-write flashcarts, and HiROM-mapped BS-X carts always use
+//read-only flashcarts.
+//below is an unfortunately necessary workaround to this problem.
+  if(cartridge.mapper() == Cartridge::BSCHiROM) return;
+
+  if((addr & 0xff0000) == 0) {
+    regs.write_old = regs.write_new;
+    regs.write_new = data;
+
+    if(regs.write_enable && regs.write_old == regs.write_new) {
+      return memory::bscram.write(addr, data);
+    }
+  } else {
+    if(regs.write_enable) {
+      return memory::bscram.write(addr, data);
+    }
+  }
+
+  if(addr == 0x0000) {
+    regs.command <<= 8;
+    regs.command  |= data;
+
+    if((regs.command & 0xffff) == 0x38d0) {
+      regs.flash_enable = true;
+      regs.read_enable  = true;
+    }
+  }
+
+  if(addr == 0x2aaa) {
+    regs.command <<= 8;
+    regs.command  |= data;
+  }
+
+  if(addr == 0x5555) {
+    regs.command <<= 8;
+    regs.command  |= data;
+
+    if((regs.command & 0xffffff) == 0xaa5570) {
+      regs.write_enable = false;
+    }
+
+    if((regs.command & 0xffffff) == 0xaa55a0) {
+      regs.write_old = 0x00;
+      regs.write_new = 0x00;
+      regs.flash_enable = true;
+      regs.write_enable = true;
+    }
+
+    if((regs.command & 0xffffff) == 0xaa55f0) {
+      regs.flash_enable = false;
+      regs.read_enable  = false;
+      regs.write_enable = false;
+    }
+  }
+}

src/chip/chip.h

@@ -0,0 +1,10 @@
+#include "bsx/bsx.h"
+#include "srtc/srtc.h"
+#include "sdd1/sdd1.h"
+#include "cx4/cx4.h"
+#include "dsp1/dsp1.h"
+#include "dsp2/dsp2.h"
+#include "dsp3/dsp3.h"
+#include "dsp4/dsp4.h"
+#include "obc1/obc1.h"
+#include "st010/st010.h"

src/chip/cx4/cx4.cpp

@@ -7,29 +7,27 @@
 
 #include "../../base.h"
 
-C4 *c4;
+#include "cx4data.cpp"
+#include "cx4fn.cpp"
+#include "cx4oam.cpp"
+#include "cx4ops.cpp"
 
-#include "c4data.cpp"
-#include "c4fn.cpp"
-#include "c4oam.cpp"
-#include "c4ops.cpp"
+void Cx4::init() {}
+void Cx4::enable() {}
 
-void C4::init() {}
-void C4::enable() {}
-
-uint32 C4::ldr(uint8 r) {
+uint32 Cx4::ldr(uint8 r) {
 uint16 addr = 0x0080 + (r * 3);
   return (reg[addr]) | (reg[addr + 1] << 8) | (reg[addr + 2] << 16);
 }
 
-void C4::str(uint8 r, uint32 data) {
+void Cx4::str(uint8 r, uint32 data) {
 uint16 addr = 0x0080 + (r * 3);
   reg[addr    ] = (data);
   reg[addr + 1] = (data >> 8);
   reg[addr + 2] = (data >> 16);
 }
 
-void C4::mul(uint32 x, uint32 y, uint32 &rl, uint32 &rh) {
+void Cx4::mul(uint32 x, uint32 y, uint32 &rl, uint32 &rh) {
 int64 rx = x & 0xffffff;
 int64 ry = y & 0xffffff;
   if(rx & 0x800000)rx |= ~0x7fffff;
@@ -41,7 +39,7 @@ int64 ry = y & 0xffffff;
   rh = (rx >> 24) & 0xffffff;
 }
 
-uint32 C4::sin(uint32 rx) {
+uint32 Cx4::sin(uint32 rx) {
   r0 = rx & 0x1ff;
   if(r0 & 0x100)r0 ^= 0x1ff;
   if(r0 & 0x080)r0 ^= 0x0ff;
@@ -52,13 +50,13 @@ uint32 C4::sin(uint32 rx) {
   }
 }
 
-uint32 C4::cos(uint32 rx) {
+uint32 Cx4::cos(uint32 rx) {
   return sin(rx + 0x080);
 }
 
-void C4::immediate_reg(uint32 start) {
+void Cx4::immediate_reg(uint32 start) {
   r0 = ldr(0);
-  for(uint32 i=start;i<48;i++) {
+  for(uint32 i = start; i < 48; i++) {
     if((r0 & 0x0fff) < 0x0c00) {
       ram[r0 & 0x0fff] = immediate_data[i];
     }
@@ -67,7 +65,7 @@ void C4::immediate_reg(uint32 start) {
   str(0, r0);
 }
 
-void C4::transfer_data() {
+void Cx4::transfer_data() {
 uint32 src;
 uint16 dest, count;
   src   = (reg[0x40]) | (reg[0x41] << 8) | (reg[0x42] << 16);
@@ -75,11 +73,11 @@ uint16 dest, count;
   dest  = (reg[0x45]) | (reg[0x46] << 8);
 
   for(uint32 i=0;i<count;i++) {
-    write(dest++, r_mem->read(src++));
+    write(dest++, bus.read(src++));
   }
 }
 
-void C4::write(uint16 addr, uint8 data) {
+void Cx4::write(uint addr, uint8 data) {
   addr &= 0x1fff;
 
   if(addr < 0x0c00) {
@@ -111,57 +109,57 @@ void C4::write(uint16 addr, uint8 data) {
     }
 
     switch(data) {
-    case 0x00:op00();break;
-    case 0x01:op01();break;
-    case 0x05:op05();break;
-    case 0x0d:op0d();break;
-    case 0x10:op10();break;
-    case 0x13:op13();break;
-    case 0x15:op15();break;
-    case 0x1f:op1f();break;
-    case 0x22:op22();break;
-    case 0x25:op25();break;
-    case 0x2d:op2d();break;
-    case 0x40:op40();break;
-    case 0x54:op54();break;
-    case 0x5c:op5c();break;
-    case 0x5e:op5e();break;
-    case 0x60:op60();break;
-    case 0x62:op62();break;
-    case 0x64:op64();break;
-    case 0x66:op66();break;
-    case 0x68:op68();break;
-    case 0x6a:op6a();break;
-    case 0x6c:op6c();break;
-    case 0x6e:op6e();break;
-    case 0x70:op70();break;
-    case 0x72:op72();break;
-    case 0x74:op74();break;
-    case 0x76:op76();break;
-    case 0x78:op78();break;
-    case 0x7a:op7a();break;
-    case 0x7c:op7c();break;
-    case 0x89:op89();break;
+      case 0x00: op00(); break;
+      case 0x01: op01(); break;
+      case 0x05: op05(); break;
+      case 0x0d: op0d(); break;
+      case 0x10: op10(); break;
+      case 0x13: op13(); break;
+      case 0x15: op15(); break;
+      case 0x1f: op1f(); break;
+      case 0x22: op22(); break;
+      case 0x25: op25(); break;
+      case 0x2d: op2d(); break;
+      case 0x40: op40(); break;
+      case 0x54: op54(); break;
+      case 0x5c: op5c(); break;
+      case 0x5e: op5e(); break;
+      case 0x60: op60(); break;
+      case 0x62: op62(); break;
+      case 0x64: op64(); break;
+      case 0x66: op66(); break;
+      case 0x68: op68(); break;
+      case 0x6a: op6a(); break;
+      case 0x6c: op6c(); break;
+      case 0x6e: op6e(); break;
+      case 0x70: op70(); break;
+      case 0x72: op72(); break;
+      case 0x74: op74(); break;
+      case 0x76: op76(); break;
+      case 0x78: op78(); break;
+      case 0x7a: op7a(); break;
+      case 0x7c: op7c(); break;
+      case 0x89: op89(); break;
     }
   }
 }
 
-void C4::writeb(uint16 addr, uint8 data) {
+void Cx4::writeb(uint16 addr, uint8 data) {
   write(addr,     data);
 }
 
-void C4::writew(uint16 addr, uint16 data) {
+void Cx4::writew(uint16 addr, uint16 data) {
   write(addr,     data);
   write(addr + 1, data >> 8);
 }
 
-void C4::writel(uint16 addr, uint32 data) {
+void Cx4::writel(uint16 addr, uint32 data) {
   write(addr,     data);
   write(addr + 1, data >>  8);
   write(addr + 2, data >> 16);
 }
 
-uint8 C4::read(uint16 addr) {
+uint8 Cx4::read(uint addr) {
   addr &= 0x1fff;
 
   if(addr < 0x0c00) {
@@ -172,28 +170,26 @@ uint8 C4::read(uint16 addr) {
     return reg[addr & 0xff];
   }
 
-  return r_cpu->regs.mdr;
+  return cpu.regs.mdr;
 }
 
-uint8 C4::readb(uint16 addr) {
+uint8 Cx4::readb(uint16 addr) {
   return read(addr);
 }
 
-uint16 C4::readw(uint16 addr) {
+uint16 Cx4::readw(uint16 addr) {
   return read(addr) | (read(addr + 1) << 8);
 }
 
-uint32 C4::readl(uint16 addr) {
+uint32 Cx4::readl(uint16 addr) {
   return read(addr) | (read(addr + 1) << 8) + (read(addr + 2) << 16);
 }
 
-void C4::power() {
+void Cx4::power() {
   reset();
 }
 
-void C4::reset() {
+void Cx4::reset() {
   memset(ram, 0, 0x0c00);
   memset(reg, 0, 0x0100);
 }
-
-C4::C4() {}

src/chip/cx4/cx4.h

@@ -1,29 +1,29 @@
-class C4 {
+class Cx4 : public Memory {
 private:
-uint8  ram[0x0c00];
-uint8  reg[0x0100];
-uint32 r0, r1, r2,  r3,  r4,  r5,  r6,  r7,
-       r8, r9, r10, r11, r12, r13, r14, r15;
+  uint8  ram[0x0c00];
+  uint8  reg[0x0100];
+  uint32 r0, r1, r2,  r3,  r4,  r5,  r6,  r7,
+         r8, r9, r10, r11, r12, r13, r14, r15;
 
-static const uint8  immediate_data[48];
-static const uint16 wave_data[40];
-static const uint32 sin_table[256];
+  static const uint8  immediate_data[48];
+  static const uint16 wave_data[40];
+  static const uint32 sin_table[256];
 
-static const int16 SinTable[512];
-static const int16 CosTable[512];
+  static const int16 SinTable[512];
+  static const int16 CosTable[512];
 
-int16 C4WFXVal, C4WFYVal, C4WFZVal, C4WFX2Val, C4WFY2Val, C4WFDist, C4WFScale;
-int16 C41FXVal, C41FYVal, C41FAngleRes, C41FDist, C41FDistVal;
+  int16 C4WFXVal, C4WFYVal, C4WFZVal, C4WFX2Val, C4WFY2Val, C4WFDist, C4WFScale;
+  int16 C41FXVal, C41FYVal, C41FAngleRes, C41FDist, C41FDistVal;
 
-double tanval;
-double c4x,c4y,c4z, c4x2,c4y2,c4z2;
+  double tanval;
+  double c4x,c4y,c4z, c4x2,c4y2,c4z2;
 
-void C4TransfWireFrame();
-void C4TransfWireFrame2();
-void C4CalcWireFrame();
-void C4DrawLine(int32 X1, int32 Y1, int16 Z1, int32 X2, int32 Y2, int16 Z2, uint8 Color);
-void C4DrawWireFrame();
-void C4DoScaleRotate(int row_padding);
+  void C4TransfWireFrame();
+  void C4TransfWireFrame2();
+  void C4CalcWireFrame();
+  void C4DrawLine(int32 X1, int32 Y1, int16 Z1, int32 X2, int32 Y2, int16 Z2, uint8 Color);
+  void C4DrawWireFrame();
+  void C4DoScaleRotate(int row_padding);
 
 public:
   uint32 ldr(uint8 r);
@@ -75,22 +75,23 @@ public:
   void   op7c();
   void   op89();
 
+  uint8  readb(uint16 addr);
+  uint16 readw(uint16 addr);
+  uint32 readl(uint16 addr);
+
+  void   writeb(uint16 addr, uint8 data);
+  void   writew(uint16 addr, uint16 data);
+  void   writel(uint16 addr, uint32 data);
+
+//
+
   void   init();
   void   enable();
   void   power();
   void   reset();
 
-  void   write (uint16 addr, uint8 data);
-  void   writeb(uint16 addr, uint8 data);
-  void   writew(uint16 addr, uint16 data);
-  void   writel(uint16 addr, uint32 data);
-
-  uint8  read (uint16 addr);
-  uint8  readb(uint16 addr);
-  uint16 readw(uint16 addr);
-  uint32 readl(uint16 addr);
-
-  C4();
+  uint8  read (uint addr);
+  void   write(uint addr, uint8 data);
 };
 
-extern C4 *c4;
+extern Cx4 cx4;

src/chip/cx4/cx4data.cpp

@@ -1,11 +1,11 @@
-const uint8 C4::immediate_data[48] = {
+const uint8 Cx4::immediate_data[48] = {
   0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff,
   0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x80, 0xff, 0xff, 0x7f,
   0x00, 0x80, 0x00, 0xff, 0x7f, 0x00, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0xff,
   0x00, 0x00, 0x01, 0xff, 0xff, 0xfe, 0x00, 0x01, 0x00, 0xff, 0xfe, 0x00
 };
 
-const uint16 C4::wave_data[40] = {
+const uint16 Cx4::wave_data[40] = {
   0x0000, 0x0002, 0x0004, 0x0006, 0x0008, 0x000a, 0x000c, 0x000e,
   0x0200, 0x0202, 0x0204, 0x0206, 0x0208, 0x020a, 0x020c, 0x020e,
   0x0400, 0x0402, 0x0404, 0x0406, 0x0408, 0x040a, 0x040c, 0x040e,
@@ -13,7 +13,7 @@ const uint16 C4::wave_data[40] = {
   0x0800, 0x0802, 0x0804, 0x0806, 0x0808, 0x080a, 0x080c, 0x080e
 };
 
-const uint32 C4::sin_table[256] = {
+const uint32 Cx4::sin_table[256] = {
   0x000000, 0x000324, 0x000648, 0x00096c, 0x000c8f, 0x000fb2, 0x0012d5, 0x0015f6,
   0x001917, 0x001c37, 0x001f56, 0x002273, 0x002590, 0x0028aa, 0x002bc4, 0x002edb,
   0x0031f1, 0x003505, 0x003817, 0x003b26, 0x003e33, 0x00413e, 0x004447, 0x00474d,
@@ -48,7 +48,7 @@ const uint32 C4::sin_table[256] = {
   0xff013b, 0xff00f1, 0xff00b1, 0xff007b, 0xff004e, 0xff002c, 0xff0013, 0xff0004
 };
 
-const int16 C4::SinTable[512] = {
+const int16 Cx4::SinTable[512] = {
        0,    402,    804,   1206,   1607,   2009,   2410,   2811,
     3211,   3611,   4011,   4409,   4808,   5205,   5602,   5997,
     6392,   6786,   7179,   7571,   7961,   8351,   8739,   9126,
@@ -115,7 +115,7 @@ const int16 C4::SinTable[512] = {
    -3211,  -2811,  -2410,  -2009,  -1607,  -1206,   -804,   -402
 };
 
-const int16 C4::CosTable[512] = {
+const int16 Cx4::CosTable[512] = {
    32767,  32765,  32758,  32745,  32728,  32706,  32679,  32647,
    32610,  32568,  32521,  32469,  32413,  32351,  32285,  32214,
    32138,  32057,  31971,  31881,  31785,  31685,  31581,  31471,

src/chip/cx4/cx4fn.cpp

@@ -7,7 +7,7 @@
 #define PI 3.1415926535897932384626433832795
 
 //Wireframe Helpers
-void C4::C4TransfWireFrame() {
+void Cx4::C4TransfWireFrame() {
   c4x = (double)C4WFXVal;
   c4y = (double)C4WFYVal;
   c4z = (double)C4WFZVal - 0x95;
@@ -32,7 +32,7 @@ void C4::C4TransfWireFrame() {
   C4WFYVal = (int16)(c4y * C4WFScale / (0x90 * (c4z + 0x95)) * 0x95);
 }
 
-void C4::C4CalcWireFrame() {
+void Cx4::C4CalcWireFrame() {
   C4WFXVal = C4WFX2Val - C4WFXVal;
   C4WFYVal = C4WFY2Val - C4WFYVal;
 
@@ -49,7 +49,7 @@ void C4::C4CalcWireFrame() {
   }
 }
 
-void C4::C4TransfWireFrame2() {
+void Cx4::C4TransfWireFrame2() {
   c4x = (double)C4WFXVal;
   c4y = (double)C4WFYVal;
   c4z = (double)C4WFZVal;
@@ -74,34 +74,34 @@ void C4::C4TransfWireFrame2() {
   C4WFYVal = (int16)(c4y * C4WFScale / 0x100);
 }
 
-void C4::C4DrawWireFrame() {
+void Cx4::C4DrawWireFrame() {
 uint32 line = readl(0x1f80);
 uint32 point1, point2;
 int16 X1, Y1, Z1;
 int16 X2, Y2, Z2;
 uint8 Color;
   for(int32 i = ram[0x0295]; i > 0; i--, line += 5) {
-    if(r_mem->read(line) == 0xff && r_mem->read(line + 1) == 0xff) {
+    if(bus.read(line) == 0xff && bus.read(line + 1) == 0xff) {
     int32 tmp = line - 5;
-      while(r_mem->read(tmp + 2) == 0xff && r_mem->read(tmp + 3) == 0xff && (tmp + 2) >= 0) { tmp -= 5; }
-      point1 = (read(0x1f82) << 16) | (r_mem->read(tmp + 2) << 8) | r_mem->read(tmp + 3);
+      while(bus.read(tmp + 2) == 0xff && bus.read(tmp + 3) == 0xff && (tmp + 2) >= 0) { tmp -= 5; }
+      point1 = (read(0x1f82) << 16) | (bus.read(tmp + 2) << 8) | bus.read(tmp + 3);
     } else {
-      point1 = (read(0x1f82) << 16) | (r_mem->read(line) << 8) | r_mem->read(line + 1);
+      point1 = (read(0x1f82) << 16) | (bus.read(line) << 8) | bus.read(line + 1);
     }
-    point2 = (read(0x1f82) << 16) | (r_mem->read(line + 2) << 8) | r_mem->read(line + 3);
+    point2 = (read(0x1f82) << 16) | (bus.read(line + 2) << 8) | bus.read(line + 3);
 
-    X1=(r_mem->read(point1 + 0) << 8) | r_mem->read(point1 + 1);
-    Y1=(r_mem->read(point1 + 2) << 8) | r_mem->read(point1 + 3);
-    Z1=(r_mem->read(point1 + 4) << 8) | r_mem->read(point1 + 5);
-    X2=(r_mem->read(point2 + 0) << 8) | r_mem->read(point2 + 1);
-    Y2=(r_mem->read(point2 + 2) << 8) | r_mem->read(point2 + 3);
-    Z2=(r_mem->read(point2 + 4) << 8) | r_mem->read(point2 + 5);
-    Color = r_mem->read(line + 4);
+    X1=(bus.read(point1 + 0) << 8) | bus.read(point1 + 1);
+    Y1=(bus.read(point1 + 2) << 8) | bus.read(point1 + 3);
+    Z1=(bus.read(point1 + 4) << 8) | bus.read(point1 + 5);
+    X2=(bus.read(point2 + 0) << 8) | bus.read(point2 + 1);
+    Y2=(bus.read(point2 + 2) << 8) | bus.read(point2 + 3);
+    Z2=(bus.read(point2 + 4) << 8) | bus.read(point2 + 5);
+    Color = bus.read(line + 4);
     C4DrawLine(X1, Y1, Z1, X2, Y2, Z2, Color);
   }
 }
 
-void C4::C4DrawLine(int32 X1, int32 Y1, int16 Z1, int32 X2, int32 Y2, int16 Z2, uint8 Color) {
+void Cx4::C4DrawLine(int32 X1, int32 Y1, int16 Z1, int32 X2, int32 Y2, int16 Z2, uint8 Color) {
 //Transform coordinates
   C4WFXVal  = (int16)X1;
   C4WFYVal  = (int16)Y1;
@@ -145,7 +145,7 @@ void C4::C4DrawLine(int32 X1, int32 Y1, int16 Z1, int32 X2, int32 Y2, int16 Z2,
   }
 }
 
-void C4::C4DoScaleRotate(int row_padding) {
+void Cx4::C4DoScaleRotate(int row_padding) {
 int16 A, B, C, D;
 
 //Calculate matrix

src/chip/cx4/cx4oam.cpp

@@ -1,5 +1,5 @@
 //Build OAM
-void C4::op00_00() {
+void Cx4::op00_00() {
 uint32 oamptr = ram[0x626] << 2;
   for(int32 i = 0x1fd; i > oamptr && i >= 0; i -= 4) {
   //clear oam-to-be
@@ -27,28 +27,28 @@ uint32 srcptr = 0x220;
     sprattr = ram[srcptr + 4] | ram[srcptr + 6];
 
   uint32 spraddr = readl(srcptr + 7);
-    if(r_mem->read(spraddr)) {
+    if(bus.read(spraddr)) {
     int16 x, y;
-      for(int sprcnt = r_mem->read(spraddr++); sprcnt > 0 && sprcount > 0; sprcnt--, spraddr += 4) {
-        x = (int8)r_mem->read(spraddr + 1);
+      for(int sprcnt = bus.read(spraddr++); sprcnt > 0 && sprcount > 0; sprcnt--, spraddr += 4) {
+        x = (int8)bus.read(spraddr + 1);
         if(sprattr & 0x40) {
-          x = -x - ((r_mem->read(spraddr) & 0x20) ? 16 : 8);
+          x = -x - ((bus.read(spraddr) & 0x20) ? 16 : 8);
         }
         x += sprx;
         if(x >= -16 && x <= 272) {
-          y = (int8)r_mem->read(spraddr + 2);
+          y = (int8)bus.read(spraddr + 2);
           if(sprattr & 0x80) {
-            y = -y - ((r_mem->read(spraddr) & 0x20) ? 16 : 8);
+            y = -y - ((bus.read(spraddr) & 0x20) ? 16 : 8);
           }
           y += spry;
           if(y >= -16 && y <= 224) {
             ram[oamptr    ] = (uint8)x;
             ram[oamptr + 1] = (uint8)y;
-            ram[oamptr + 2] = sprname + r_mem->read(spraddr + 3);
-            ram[oamptr + 3] = sprattr ^ (r_mem->read(spraddr) & 0xc0);
+            ram[oamptr + 2] = sprname + bus.read(spraddr + 3);
+            ram[oamptr + 3] = sprattr ^ (bus.read(spraddr) & 0xc0);
             ram[oamptr2] &= ~(3 << offset);
             if(x & 0x100)ram[oamptr2] |= 1 << offset;
-            if(r_mem->read(spraddr) & 0x20)ram[oamptr2] |= 2 << offset;
+            if(bus.read(spraddr) & 0x20)ram[oamptr2] |= 2 << offset;
             oamptr += 4;
             sprcount--;
             offset = (offset + 2) & 6;
@@ -73,12 +73,12 @@ uint32 srcptr = 0x220;
 }
 
 //Scale and Rotate
-void C4::op00_03() {
+void Cx4::op00_03() {
   C4DoScaleRotate(0);
 }
 
 //Transform Lines
-void C4::op00_05() {
+void Cx4::op00_05() {
   C4WFX2Val = read(0x1f83);
   C4WFY2Val = read(0x1f86);
   C4WFDist  = read(0x1f89);
@@ -119,17 +119,17 @@ uint32 ptr2 = 0;
 }
 
 //Scale and Rotate
-void C4::op00_07() {
+void Cx4::op00_07() {
   C4DoScaleRotate(64);
 }
 
 //Draw Wireframe
-void C4::op00_08() {
+void Cx4::op00_08() {
   C4DrawWireFrame();
 }
 
 //Disintegrate
-void C4::op00_0b() {
+void Cx4::op00_0b() {
 uint8  width, height;
 uint32 startx, starty;
 uint32 srcptr;
@@ -169,7 +169,7 @@ int32  i, j;
 }
 
 //Bitplane Wave
-void C4::op00_0c() {
+void Cx4::op00_0c() {
 uint32 destptr = 0;
 uint32 waveptr = read(0x1f83);
 uint16 mask1   = 0xc0c0;

src/chip/cx4/cx4ops.cpp

@@ -1,5 +1,5 @@
 //Sprite Functions
-void C4::op00() {
+void Cx4::op00() {
   switch(reg[0x4d]) {
   case 0x00:op00_00();break;
   case 0x03:op00_03();break;
@@ -12,13 +12,13 @@ void C4::op00() {
 }
 
 //Draw Wireframe
-void C4::op01() {
+void Cx4::op01() {
   memset(ram + 0x300, 0, 2304);
   C4DrawWireFrame();
 }
 
 //Propulsion
-void C4::op05() {
+void Cx4::op05() {
 int32 temp = 0x10000;
   if(readw(0x1f83)) {
     temp = sar((temp / readw(0x1f83)) * readw(0x1f81), 8);
@@ -27,7 +27,7 @@ int32 temp = 0x10000;
 }
 
 //Set Vector length
-void C4::op0d() {
+void Cx4::op0d() {
   C41FXVal    = readw(0x1f80);
   C41FYVal    = readw(0x1f83);
   C41FDistVal = readw(0x1f86);
@@ -40,7 +40,7 @@ void C4::op0d() {
 }
 
 //Triangle
-void C4::op10() {
+void Cx4::op10() {
   r0 = ldr(0);
   r1 = ldr(1);
 
@@ -64,7 +64,7 @@ void C4::op10() {
 }
 
 //Triangle
-void C4::op13() {
+void Cx4::op13() {
   r0 = ldr(0);
   r1 = ldr(1);
 
@@ -87,7 +87,7 @@ void C4::op13() {
 }
 
 //Pythagorean
-void C4::op15() {
+void Cx4::op15() {
   C41FXVal = readw(0x1f80);
   C41FYVal = readw(0x1f83);
   C41FDist = (int16)sqrt((double)C41FXVal * (double)C41FXVal + (double)C41FYVal * (double)C41FYVal);
@@ -95,7 +95,7 @@ void C4::op15() {
 }
 
 //Calculate distance
-void C4::op1f() {
+void Cx4::op1f() {
   C41FXVal = readw(0x1f80);
   C41FYVal = readw(0x1f83);
   if(!C41FXVal) {
@@ -113,7 +113,7 @@ void C4::op1f() {
 }
 
 //Trapezoid
-void C4::op22() {
+void Cx4::op22() {
 int16 angle1 = readw(0x1f8c) & 0x1ff;
 int16 angle2 = readw(0x1f8f) & 0x1ff;
 int32 tan1 = Tan(angle1);
@@ -152,7 +152,7 @@ int16 left, right;
 }
 
 //Multiply
-void C4::op25() {
+void Cx4::op25() {
   r0 = ldr(0);
   r1 = ldr(1);
   mul(r0, r1, r0, r1);
@@ -161,7 +161,7 @@ void C4::op25() {
 }
 
 //Transform Coords
-void C4::op2d() {
+void Cx4::op2d() {
   C4WFXVal  = readw(0x1f81);
   C4WFYVal  = readw(0x1f84);
   C4WFZVal  = readw(0x1f87);
@@ -175,7 +175,7 @@ void C4::op2d() {
 }
 
 //Sum
-void C4::op40() {
+void Cx4::op40() {
   r0 = 0;
   for(uint32 i=0;i<0x800;i++) {
     r0 += ram[i];
@@ -184,7 +184,7 @@ void C4::op40() {
 }
 
 //Square
-void C4::op54() {
+void Cx4::op54() {
   r0 = ldr(0);
   mul(r0, r0, r1, r2);
   str(1, r1);
@@ -192,31 +192,31 @@ void C4::op54() {
 }
 
 //Immediate Register
-void C4::op5c() {
+void Cx4::op5c() {
   str(0, 0x000000);
   immediate_reg(0);
 }
 
 //Immediate Register (Multiple)
-void C4::op5e() { immediate_reg( 0); }
-void C4::op60() { immediate_reg( 3); }
-void C4::op62() { immediate_reg( 6); }
-void C4::op64() { immediate_reg( 9); }
-void C4::op66() { immediate_reg(12); }
-void C4::op68() { immediate_reg(15); }
-void C4::op6a() { immediate_reg(18); }
-void C4::op6c() { immediate_reg(21); }
-void C4::op6e() { immediate_reg(24); }
-void C4::op70() { immediate_reg(27); }
-void C4::op72() { immediate_reg(30); }
-void C4::op74() { immediate_reg(33); }
-void C4::op76() { immediate_reg(36); }
-void C4::op78() { immediate_reg(39); }
-void C4::op7a() { immediate_reg(42); }
-void C4::op7c() { immediate_reg(45); }
+void Cx4::op5e() { immediate_reg( 0); }
+void Cx4::op60() { immediate_reg( 3); }
+void Cx4::op62() { immediate_reg( 6); }
+void Cx4::op64() { immediate_reg( 9); }
+void Cx4::op66() { immediate_reg(12); }
+void Cx4::op68() { immediate_reg(15); }
+void Cx4::op6a() { immediate_reg(18); }
+void Cx4::op6c() { immediate_reg(21); }
+void Cx4::op6e() { immediate_reg(24); }
+void Cx4::op70() { immediate_reg(27); }
+void Cx4::op72() { immediate_reg(30); }
+void Cx4::op74() { immediate_reg(33); }
+void Cx4::op76() { immediate_reg(36); }
+void Cx4::op78() { immediate_reg(39); }
+void Cx4::op7a() { immediate_reg(42); }
+void Cx4::op7c() { immediate_reg(45); }
 
 //Immediate ROM
-void C4::op89() {
+void Cx4::op89() {
   str(0, 0x054336);
   str(1, 0xffffff);
 }

src/chip/dsp1/dsp1.cpp

@@ -1,7 +1,5 @@
 #include "../../base.h"
 
-DSP1 *dsp1;
-
 #include "dsp1emu.cpp"
 
 void DSP1::init() {}
@@ -28,29 +26,30 @@ void DSP1::reset() {
  *****/
 bool DSP1::addr_decode(uint16 addr) {
   switch(cartridge.info.dsp1_mapper) {
+    case Cartridge::DSP1LoROM1MB: {
+    //$[20-3f]:[8000-bfff] = DR, $[20-3f]:[c000-ffff] = SR
+      return (addr >= 0xc000);
+    }
 
-  case Cartridge::DSP1_LOROM_1MB:
-  //$[20-3f]:[8000-bfff] = DR, $[20-3f]:[c000-ffff] = SR
-    return (addr >= 0xc000);
-
-  case Cartridge::DSP1_LOROM_2MB:
-  //$[60-6f]:[0000-3fff] = DR, $[60-6f]:[4000-7fff] = SR
-    return (addr >= 0x4000);
-
-  case Cartridge::DSP1_HIROM:
-  //$[00-1f]:[6000-6fff] = DR, $[00-1f]:[7000-7fff] = SR
-    return (addr >= 0x7000);
+    case Cartridge::DSP1LoROM2MB: {
+    //$[60-6f]:[0000-3fff] = DR, $[60-6f]:[4000-7fff] = SR
+      return (addr >= 0x4000);
+    }
 
+    case Cartridge::DSP1HiROM: {
+    //$[00-1f]:[6000-6fff] = DR, $[00-1f]:[7000-7fff] = SR
+      return (addr >= 0x7000);
+    }
   }
 
   return 0;
 }
 
-uint8 DSP1::read(uint16 addr) {
+uint8 DSP1::read(uint addr) {
   return (addr_decode(addr) == 0) ? dsp1.getDr() : dsp1.getSr();
 }
 
-void DSP1::write(uint16 addr, uint8 data) {
+void DSP1::write(uint addr, uint8 data) {
   if(addr_decode(addr) == 0) {
     dsp1.setDr(data);
   }

src/chip/dsp1/dsp1.h

@@ -1,18 +1,18 @@
 #include "dsp1emu.h"
 
-class DSP1 {
+class DSP1 : public Memory {
 private:
-Dsp1 dsp1;
+  Dsp1 dsp1;
+  bool addr_decode(uint16 addr);
 
 public:
-  void   init();
-  void   enable();
-  void   power();
-  void   reset();
+  void init();
+  void enable();
+  void power();
+  void reset();
 
-  bool   addr_decode(uint16 addr);
-  uint8  read (uint16 addr);
-  void   write(uint16 addr, uint8 data);
+  uint8 read(uint addr);
+  void write(uint addr, uint8 data);
 };
 
-extern DSP1 *dsp1;
+extern DSP1 dsp1;

src/chip/dsp2/dsp2.cpp

@@ -1,7 +1,5 @@
 #include "../../base.h"
 
-DSP2 *dsp2;
-
 #include "dsp2_op.cpp"
 
 void DSP2::init() {}
@@ -30,7 +28,7 @@ void DSP2::reset() {
   status.op0dinlen       = 0;
 }
 
-uint8 DSP2::read(uint16 addr) {
+uint8 DSP2::read(uint addr) {
 uint8 r = 0xff;
   if(status.out_count) {
     r = status.output[status.out_index++];
@@ -42,7 +40,7 @@ uint8 r = 0xff;
   return r;
 }
 
-void DSP2::write(uint16 addr, uint8 data) {
+void DSP2::write(uint addr, uint8 data) {
   if(status.waiting_for_command) {
     status.command  = data;
     status.in_index = 0;

src/chip/dsp2/dsp2.h

@@ -1,43 +1,44 @@
-class DSP2 {
+class DSP2 : public Memory {
 public:
-struct {
-  bool   waiting_for_command;
-  uint   command;
-  uint   in_count,  in_index;
-  uint   out_count, out_index;
+  struct {
+    bool   waiting_for_command;
+    uint   command;
+    uint   in_count,  in_index;
+    uint   out_count, out_index;
 
-  uint8  parameters[512];
-  uint8  output[512];
+    uint8  parameters[512];
+    uint8  output[512];
 
-  uint8  op05transparent;
-  bool   op05haslen;
-  int    op05len;
-  bool   op06haslen;
-  int    op06len;
-  uint16 op09word1;
-  uint16 op09word2;
-  bool   op0dhaslen;
-  int    op0doutlen;
-  int    op0dinlen;
-} status;
+    uint8  op05transparent;
+    bool   op05haslen;
+    int    op05len;
+    bool   op06haslen;
+    int    op06len;
+    uint16 op09word1;
+    uint16 op09word2;
+    bool   op0dhaslen;
+    int    op0doutlen;
+    int    op0dinlen;
+  } status;
 
-  void   init();
-  void   enable();
-  void   power();
-  void   reset();
+  void init();
+  void enable();
+  void power();
+  void reset();
 
-  void   op01();
-  void   op03();
-  void   op05();
-  void   op06();
-  void   op09();
-  void   op0d();
-
-  uint8  read (uint16 addr);
-  void   write(uint16 addr, uint8 data);
+  uint8 read(uint addr);
+  void write(uint addr, uint8 data);
 
   DSP2();
   ~DSP2();
+
+protected:
+  void op01();
+  void op03();
+  void op05();
+  void op06();
+  void op09();
+  void op0d();
 };
 
-extern DSP2 *dsp2;
+extern DSP2 dsp2;

src/chip/dsp3/dsp3.cpp

@@ -0,0 +1,33 @@
+#include "../../base.h"
+
+namespace DSP3i {
+  #define bool8 uint8
+  #include "dsp3emu.c"
+  #undef bool8
+};
+
+void DSP3::init() {
+}
+
+void DSP3::enable() {
+}
+
+void DSP3::power() {
+  reset();
+}
+
+void DSP3::reset() {
+  DSP3i::DSP3_Reset();
+}
+
+uint8 DSP3::read(uint addr) {
+  DSP3i::dsp3_address = addr & 0xffff;
+  DSP3i::DSP3GetByte();
+  return DSP3i::dsp3_byte;
+}
+
+void DSP3::write(uint addr, uint8 data) {
+  DSP3i::dsp3_address = addr & 0xffff;
+  DSP3i::dsp3_byte = data;
+  DSP3i::DSP3SetByte();
+}

src/chip/dsp3/dsp3.h

@@ -0,0 +1,12 @@
+class DSP3 : public Memory {
+public:
+  void init();
+  void enable();
+  void power();
+  void reset();
+
+  uint8 read (uint addr);
+  void  write(uint addr, uint8 data);
+};
+
+extern DSP3 dsp3;

src/chip/dsp4/dsp4.cpp

@@ -0,0 +1,53 @@
+#include "../../base.h"
+
+namespace DSP4i {
+  inline uint16 READ_WORD(uint8 *addr) {
+    return (addr[0]) + (addr[1] << 8);
+  }
+
+  inline uint32 READ_DWORD(uint8 *addr) {
+    return (addr[0]) + (addr[1] << 8) + (addr[2] << 16) + (addr[3] << 24);
+  }
+
+  inline void WRITE_WORD(uint8 *addr, uint16 data) {
+    addr[0] = data;
+    addr[1] = data >> 8;
+  }
+
+  #define bool8 uint8
+  #include "dsp4emu.c"
+  #undef bool8
+};
+
+void DSP4::init() {
+}
+
+void DSP4::enable() {
+}
+
+void DSP4::power() {
+  reset();
+}
+
+void DSP4::reset() {
+  DSP4i::InitDSP4();
+}
+
+uint8 DSP4::read(uint addr) {
+  addr &= 0xffff;
+  if(addr < 0xc000) {
+    DSP4i::dsp4_address = addr;
+    DSP4i::DSP4GetByte();
+    return DSP4i::dsp4_byte;
+  }
+  return 0x80;
+}
+
+void DSP4::write(uint addr, uint8 data) {
+  addr &= 0xffff;
+  if(addr < 0xc000) {
+    DSP4i::dsp4_address = addr;
+    DSP4i::dsp4_byte = data;
+    DSP4i::DSP4SetByte();
+  }
+}

src/chip/dsp4/dsp4.h

@@ -0,0 +1,12 @@
+class DSP4 : public Memory {
+public:
+  void init();
+  void enable();
+  void power();
+  void reset();
+
+  uint8 read (uint addr);
+  void  write(uint addr, uint8 data);
+};
+
+extern DSP4 dsp4;

src/chip/dsp4/dsp4emu.h

@@ -0,0 +1,108 @@
+//DSP-4 emulator code
+//Copyright (c) 2004-2006 Dreamer Nom, John Weidman, Kris Bleakley, Nach, z80 gaiden
+
+#ifndef DSP4EMU_H
+#define DSP4EMU_H
+
+#undef TRUE
+#undef FALSE
+#define TRUE  true
+#define FALSE false
+
+struct DSP4_t
+{
+  bool8 waiting4command;
+  bool8 half_command;
+  uint16 command;
+  uint32 in_count;
+  uint32 in_index;
+  uint32 out_count;
+  uint32 out_index;
+  uint8 parameters[512];
+  uint8 output[512];
+};
+
+extern struct DSP4_t DSP4;
+
+struct DSP4_vars_t
+{
+  // op control
+  int8 DSP4_Logic;            // controls op flow
+
+
+  // projection format
+  int16 lcv;                  // loop-control variable
+  int16 distance;             // z-position into virtual world
+  int16 raster;               // current raster line
+  int16 segments;             // number of raster lines drawn
+
+  // 1.15.16 or 1.15.0 [sign, integer, fraction]
+  int32 world_x;              // line of x-projection in world
+  int32 world_y;              // line of y-projection in world
+  int32 world_dx;             // projection line x-delta
+  int32 world_dy;             // projection line y-delta
+  int16 world_ddx;            // x-delta increment
+  int16 world_ddy;            // y-delta increment
+  int32 world_xenv;           // world x-shaping factor
+  int16 world_yofs;           // world y-vertical scroll
+
+  int16 view_x1;              // current viewer-x
+  int16 view_y1;              // current viewer-y
+  int16 view_x2;              // future viewer-x
+  int16 view_y2;              // future viewer-y
+  int16 view_dx;              // view x-delta factor
+  int16 view_dy;              // view y-delta factor
+  int16 view_xofs1;           // current viewer x-vertical scroll
+  int16 view_yofs1;           // current viewer y-vertical scroll
+  int16 view_xofs2;           // future viewer x-vertical scroll
+  int16 view_yofs2;           // future viewer y-vertical scroll
+  int16 view_yofsenv;         // y-scroll shaping factor
+  int16 view_turnoff_x;       // road turnoff data
+  int16 view_turnoff_dx;      // road turnoff delta factor
+
+
+  // drawing area
+
+  int16 viewport_cx;          // x-center of viewport window
+  int16 viewport_cy;          // y-center of render window
+  int16 viewport_left;        // x-left of viewport
+  int16 viewport_right;       // x-right of viewport
+  int16 viewport_top;         // y-top of viewport
+  int16 viewport_bottom;      // y-bottom of viewport
+
+
+  // sprite structure
+
+  int16 sprite_x;             // projected x-pos of sprite
+  int16 sprite_y;             // projected y-pos of sprite
+  int16 sprite_attr;          // obj attributes
+  bool8 sprite_size;          // sprite size: 8x8 or 16x16
+  int16 sprite_clipy;         // visible line to clip pixels off
+  int16 sprite_count;
+
+  // generic projection variables designed for
+  // two solid polygons + two polygon sides
+
+  int16 poly_clipLf[2][2];    // left clip boundary
+  int16 poly_clipRt[2][2];    // right clip boundary
+  int16 poly_ptr[2][2];       // HDMA structure pointers
+  int16 poly_raster[2][2];    // current raster line below horizon
+  int16 poly_top[2][2];       // top clip boundary
+  int16 poly_bottom[2][2];    // bottom clip boundary
+  int16 poly_cx[2][2];        // center for left/right points
+  int16 poly_start[2];        // current projection points
+  int16 poly_plane[2];        // previous z-plane distance
+
+
+  // OAM
+  int16 OAM_attr[16];         // OAM (size,MSB) data
+  int16 OAM_index;            // index into OAM table
+  int16 OAM_bits;             // offset into OAM table
+
+  int16 OAM_RowMax;           // maximum number of tiles per 8 aligned pixels (row)
+  int16 OAM_Row[32];          // current number of tiles per row
+};
+
+extern struct DSP4_vars_t DSP4_vars;
+
+#endif

src/chip/obc1/obc1.cpp

@@ -1,7 +1,5 @@
 #include "../../base.h"
 
-OBC1 *obc1;
-
 void OBC1::init() {}
 void OBC1::enable() {}
 
@@ -10,81 +8,82 @@ void OBC1::power() {
 }
 
 void OBC1::reset() {
-  memset(cartridge.ram, 0xff, 0x2000);
-  status.baseptr = (cartridge.ram[0x1ff5] & 1) ? 0x1800 : 0x1c00;
-  status.address = (cartridge.ram[0x1ff6] & 0x7f);
-  status.shift   = (cartridge.ram[0x1ff6] & 3) << 1;
+  for(uint i = 0x0000; i <= 0x1fff; i++) ram_write(i, 0xff);
+
+  status.baseptr = (ram_read(0x1ff5) & 1) ? 0x1800 : 0x1c00;
+  status.address = (ram_read(0x1ff6) & 0x7f);
+  status.shift   = (ram_read(0x1ff6) & 3) << 1;
 }
 
-uint8 OBC1::read(uint16 addr) {
+uint8 OBC1::read(uint addr) {
   addr &= 0x1fff;
-
-  if((addr & 0x1ff8) != 0x1ff0) {
-    return cartridge.ram[addr];
-  }
+  if((addr & 0x1ff8) != 0x1ff0) return ram_read(addr);
 
   switch(addr) {
   case 0x1ff0:
-    return cartridge.ram[status.baseptr + (status.address << 2) + 0];
+    return ram_read(status.baseptr + (status.address << 2) + 0);
   case 0x1ff1:
-    return cartridge.ram[status.baseptr + (status.address << 2) + 1];
+    return ram_read(status.baseptr + (status.address << 2) + 1);
   case 0x1ff2:
-    return cartridge.ram[status.baseptr + (status.address << 2) + 2];
+    return ram_read(status.baseptr + (status.address << 2) + 2);
   case 0x1ff3:
-    return cartridge.ram[status.baseptr + (status.address << 2) + 3];
+    return ram_read(status.baseptr + (status.address << 2) + 3);
   case 0x1ff4:
-    return cartridge.ram[status.baseptr + (status.address >> 2) + 0x200];
+    return ram_read(status.baseptr + (status.address >> 2) + 0x200);
   case 0x1ff5:
   case 0x1ff6:
   case 0x1ff7:
-    return cartridge.ram[addr];
+    return ram_read(addr);
   }
 
-//never used, blocks compiler warning
-  return 0x00;
+  return 0x00; //never used, avoids compiler warning
 }
 
-void OBC1::write(uint16 addr, uint8 data) {
+void OBC1::write(uint addr, uint8 data) {
   addr &= 0x1fff;
-
-  if((addr & 0x1ff8) != 0x1ff0) {
-    cartridge.ram[addr] = data;
-    return;
-  }
+  if((addr & 0x1ff8) != 0x1ff0) return ram_write(addr, data);
 
   switch(addr) {
   case 0x1ff0:
-    cartridge.ram[status.baseptr + (status.address << 2) + 0] = data;
+    ram_write(status.baseptr + (status.address << 2) + 0, data);
     break;
   case 0x1ff1:
-    cartridge.ram[status.baseptr + (status.address << 2) + 1] = data;
+    ram_write(status.baseptr + (status.address << 2) + 1, data);
     break;
   case 0x1ff2:
-    cartridge.ram[status.baseptr + (status.address << 2) + 2] = data;
+    ram_write(status.baseptr + (status.address << 2) + 2, data);
     break;
   case 0x1ff3:
-    cartridge.ram[status.baseptr + (status.address << 2) + 3] = data;
+    ram_write(status.baseptr + (status.address << 2) + 3, data);
     break;
   case 0x1ff4: {
   uint8 temp;
-    temp = cartridge.ram[status.baseptr + (status.address >> 2) + 0x200];
+    temp = ram_read(status.baseptr + (status.address >> 2) + 0x200);
     temp = (temp & ~(3 << status.shift)) | ((data & 3) << status.shift);
-    cartridge.ram[status.baseptr + (status.address >> 2) + 0x200] = temp;
+    ram_write(status.baseptr + (status.address >> 2) + 0x200, temp);
   } break;
   case 0x1ff5:
     status.baseptr = (data & 1) ? 0x1800 : 0x1c00;
-    cartridge.ram[addr] = data;
+    ram_write(addr, data);
     break;
   case 0x1ff6:
     status.address = (data & 0x7f);
     status.shift   = (data & 3) << 1;
-    cartridge.ram[addr] = data;
+    ram_write(addr, data);
     break;
   case 0x1ff7:
-    cartridge.ram[addr] = data;
+    ram_write(addr, data);
     break;
   }
 }
 
+uint8 OBC1::ram_read(uint addr) {
+  return memory::cartram.read(addr & 0x1fff);
+}
+
+void OBC1::ram_write(uint addr, uint8 data) {
+  memory::cartram.write(addr & 0x1fff, data);
+}
+
 OBC1::OBC1() {}
 OBC1::~OBC1() {}

src/chip/obc1/obc1.h

@@ -1,20 +1,25 @@
-class OBC1 {
+class OBC1 : public Memory {
 public:
-struct {
-  uint16 address;
-  uint16 baseptr;
-  uint16 shift;
-} status;
-  void   init();
-  void   enable();
-  void   power();
-  void   reset();
+  void init();
+  void enable();
+  void power();
+  void reset();
 
-  uint8  read (uint16 addr);
-  void   write(uint16 addr, uint8 data);
+  uint8 read(uint addr);
+  void write(uint addr, uint8 data);
 
   OBC1();
   ~OBC1();
+
+private:
+  uint8 ram_read(uint addr);
+  void ram_write(uint addr, uint8 data);
+
+  struct {
+    uint16 address;
+    uint16 baseptr;
+    uint16 shift;
+  } status;
 };
 
-extern OBC1 *obc1;
+extern OBC1 obc1;

src/chip/sdd1/sdd1.cpp

@@ -1,15 +1,11 @@
 #include "../../base.h"
 
-SDD1 *sdd1;
-
 #include "sdd1emu.cpp"
 
 void SDD1::init() {}
 
 void SDD1::enable() {
-  for(int i = 0x4800; i <= 0x4807; i++) {
-    r_mem->set_mmio_mapper(i, this);
-  }
+  for(int i = 0x4800; i <= 0x4807; i++) memory::mmio.map(i, *this);
 }
 
 void SDD1::power() {
@@ -17,59 +13,80 @@ void SDD1::power() {
 }
 
 void SDD1::reset() {
-  sdd1.index[0] = 0x000000;
-  sdd1.index[1] = 0x100000;
-  sdd1.index[2] = 0x200000;
-  sdd1.index[3] = 0x300000;
-
-  for(int i=0;i<8;i++) {
-    sdd1.active[i] = false;
-  }
-
   sdd1.dma_active = false;
+
+  regs.r4800 = 0x00;
+  regs.r4801 = 0x00;
+
+  regs.r4804 = 0x00;
+  regs.r4805 = 0x01;
+  regs.r4806 = 0x02;
+  regs.r4807 = 0x03;
+
+  bus.map(Bus::MapLinear, 0xc0, 0xcf, 0x0000, 0xffff, memory::cartrom, (regs.r4804 & 7) << 20);
+  bus.map(Bus::MapLinear, 0xd0, 0xdf, 0x0000, 0xffff, memory::cartrom, (regs.r4805 & 7) << 20);
+  bus.map(Bus::MapLinear, 0xe0, 0xef, 0x0000, 0xffff, memory::cartrom, (regs.r4806 & 7) << 20);
+  bus.map(Bus::MapLinear, 0xf0, 0xff, 0x0000, 0xffff, memory::cartrom, (regs.r4807 & 7) << 20);
 }
 
-uint32 SDD1::offset(uint32 addr) {
-uint8 b = (addr >> 16) & 0xff;
-  if(b <= 0xbf)return 0;
-
-  b  -= 0xc0; //b = 0x00-0x3f
-  b >>= 4;    //b = 0-3
-  b  &= 3;    //bitmask
-
-  return sdd1.index[b] + (addr & 0x0fffff);
-}
-
-uint8 SDD1::mmio_read(uint16 addr) {
-  switch(addr) {
-  //>>20 == 0x100000 == 1mb
-  case 0x4804:return (sdd1.index[0] >> 20) & 7;
-  case 0x4805:return (sdd1.index[1] >> 20) & 7;
-  case 0x4806:return (sdd1.index[2] >> 20) & 7;
-  case 0x4807:return (sdd1.index[3] >> 20) & 7;
+uint8 SDD1::mmio_read(uint addr) {
+  switch(addr & 0xffff) {
+    case 0x4804: return regs.r4804;
+    case 0x4805: return regs.r4805;
+    case 0x4806: return regs.r4806;
+    case 0x4807: return regs.r4807;
   }
 
-  return r_cpu->regs.mdr;
+  return cpu.regs.mdr;
 }
 
-void SDD1::mmio_write(uint16 addr, uint8 data) {
-  switch(addr) {
-  case 0x4801:
-    for(int i = 0; i < 8; i++) {
-      sdd1.active[i] = !!(data & (1 << i));
-    }
-    break;
-  //<<20 == 0x100000 == 1mb
-  case 0x4804:sdd1.index[0] = (data & 7) << 20;break;
-  case 0x4805:sdd1.index[1] = (data & 7) << 20;break;
-  case 0x4806:sdd1.index[2] = (data & 7) << 20;break;
-  case 0x4807:sdd1.index[3] = (data & 7) << 20;break;
+void SDD1::mmio_write(uint addr, uint8 data) {
+  switch(addr & 0xffff) {
+    case 0x4800: {
+      regs.r4800 = data;
+    } break;
+
+    case 0x4801: {
+      regs.r4801 = data;
+    } break;
+
+    case 0x4804: {
+      if(regs.r4804 != data) {
+        regs.r4804 = data;
+        bus.map(Bus::MapLinear, 0xc0, 0xcf, 0x0000, 0xffff,
+          memory::cartrom, (regs.r4804 & 7) << 20);
+      }
+    } break;
+
+    case 0x4805: {
+      if(regs.r4805 != data) {
+        regs.r4805 = data;
+        bus.map(Bus::MapLinear, 0xd0, 0xdf, 0x0000, 0xffff,
+          memory::cartrom, (regs.r4805 & 7) << 20);
+      }
+    } break;
+
+    case 0x4806: {
+      if(regs.r4806 != data) {
+        regs.r4806 = data;
+        bus.map(Bus::MapLinear, 0xe0, 0xef, 0x0000, 0xffff,
+          memory::cartrom, (regs.r4806 & 7) << 20);
+      }
+    } break;
+
+    case 0x4807: {
+      if(regs.r4807 != data) {
+        regs.r4807 = data;
+        bus.map(Bus::MapLinear, 0xf0, 0xff, 0x0000, 0xffff,
+          memory::cartrom, (regs.r4807 & 7) << 20);
+      }
+    } break;
   }
 }
 
 void SDD1::dma_begin(uint8 channel, uint32 addr, uint16 length) {
-  if(sdd1.active[channel] == true) {
-    sdd1.active[channel] = false;
+  if(regs.r4800 & (1 << channel) && regs.r4801 & (1 << channel)) {
+    regs.r4801 &= ~(1 << channel);
     sdd1.dma_active   = true;
     sdd1.buffer_index = 0;
     sdd1.buffer_size  = length;
@@ -82,9 +99,7 @@ bool SDD1::dma_active() {
 }
 
 uint8 SDD1::dma_read() {
-  if(--sdd1.buffer_size == 0) {
-    sdd1.dma_active = false;
-  }
+  if(--sdd1.buffer_size == 0) sdd1.dma_active = false;
 
 //sdd1.buffer[] is 65536 bytes, and sdd1.buffer_index
 //is of type uint16, so no buffer overflow is possible

src/chip/sdd1/sdd1.h

@@ -2,31 +2,38 @@
 
 class SDD1 : public MMIO {
 public:
-SDD1emu sdd1emu;
+  void init();
+  void enable();
+  void power();
+  void reset();
 
-struct {
-  uint32 index[4];      //memory mapping registers
-  uint8  buffer[65536]; //pointer to decompressed S-DD1 data,
-                        //max. DMA length is 65536
-  uint16 buffer_index;  //DMA read index into S-DD1 decompression buffer
-  uint16 buffer_size;
-  bool   active[8];     //true when DMA channel should pass through S-DD1
-  bool   dma_active;
-} sdd1;
-  void   init();
-  void   enable();
-  void   power();
-  void   reset();
-  uint32 offset(uint32 addr);
+  uint8 mmio_read (uint addr);
+  void  mmio_write(uint addr, uint8 data);
 
-  void   dma_begin(uint8 channel, uint32 addr, uint16 length);
-  bool   dma_active();
-  uint8  dma_read();
-
-  uint8  mmio_read (uint16 addr);
-  void   mmio_write(uint16 addr, uint8 data);
+  void  dma_begin(uint8 channel, uint32 addr, uint16 length);
+  bool  dma_active();
+  uint8 dma_read();
 
   SDD1();
+
+private:
+  SDD1emu sdd1emu;
+
+  struct {
+    uint8  buffer[65536]; //pointer to decompressed S-DD1 data, max DMA length is 65536
+    uint16 buffer_index;  //DMA read index into S-DD1 decompression buffer
+    uint16 buffer_size;
+    bool   dma_active;
+  } sdd1;
+
+  struct {
+    uint8 r4800;
+    uint8 r4801;
+    uint8 r4804;
+    uint8 r4805;
+    uint8 r4806;
+    uint8 r4807;
+  } regs;
 };
 
-extern SDD1 *sdd1;
+extern SDD1 sdd1;

src/chip/sdd1/sdd1emu.cpp

@@ -28,7 +28,7 @@ understood.
 
 ************************************************************************/
 
-#define SDD1_read(__addr) (r_mem->read(__addr))
+#define SDD1_read(__addr) (bus.read(__addr))
 
 ////////////////////////////////////////////////////
 

src/chip/srtc/srtc.cpp

@@ -52,8 +52,6 @@
 
 #include "../../base.h"
 
-SRTC *srtc;
-
 void SRTC::set_time() {
 time_t rawtime;
 tm *t;
@@ -79,8 +77,8 @@ tm *t;
 void SRTC::init() {}
 
 void SRTC::enable() {
-  r_mem->set_mmio_mapper(0x2800, this);
-  r_mem->set_mmio_mapper(0x2801, this);
+  memory::mmio.map(0x2800, *this);
+  memory::mmio.map(0x2801, *this);
 }
 
 void SRTC::power() {
@@ -93,8 +91,8 @@ void SRTC::reset() {
   srtc.mode  = SRTC_READ;
 }
 
-uint8 SRTC::mmio_read(uint16 addr) {
-  switch(addr) {
+uint8 SRTC::mmio_read(uint addr) {
+  switch(addr & 0xffff) {
 
   case 0x2800: {
     if(srtc.mode == SRTC_READ) {
@@ -118,7 +116,7 @@ uint8 SRTC::mmio_read(uint16 addr) {
 
   }
 
-  return r_cpu->regs.mdr;
+  return cpu.regs.mdr;
 }
 
 //Please see notes above about the implementation of the S-RTC
@@ -126,8 +124,8 @@ uint8 SRTC::mmio_read(uint16 addr) {
 //as reads will refresh the data array with the current system
 //time. The write method is only here for the sake of faux
 //emulation of the real hardware.
-void SRTC::mmio_write(uint16 addr, uint8 data) {
-  switch(addr) {
+void SRTC::mmio_write(uint addr, uint8 data) {
+  switch(addr & 0xffff) {
 
   case 0x2800: {
   } break;

src/chip/srtc/srtc.h

@@ -43,10 +43,10 @@ struct {
   void  power();
   void  reset();
 
-  uint8 mmio_read (uint16 addr);
-  void  mmio_write(uint16 addr, uint8 data);
+  uint8 mmio_read (uint addr);
+  void  mmio_write(uint addr, uint8 data);
 
   SRTC();
 };
 
-extern SRTC *srtc;
+extern SRTC srtc;

src/chip/st010/st010.cpp

@@ -0,0 +1,84 @@
+#include "../../base.h"
+#include "st010_data.h"
+#include "st010_op.cpp"
+
+int16 ST010::sin(int16 theta) {
+  return sin_table[(theta >> 8) & 0xff];
+}
+
+int16 ST010::cos(int16 theta) {
+  return sin_table[((theta + 0x4000) >> 8) & 0xff];
+}
+
+uint8 ST010::readb(uint16 addr) {
+  return ram[addr & 0xfff];
+}
+
+uint16 ST010::readw(uint16 addr) {
+  return (readb(addr + 0) <<  0) |
+         (readb(addr + 1) <<  8);
+}
+
+uint32 ST010::readd(uint16 addr) {
+  return (readb(addr + 0) <<  0) |
+         (readb(addr + 1) <<  8) |
+         (readb(addr + 2) << 16) |
+         (readb(addr + 3) << 24);
+}
+
+void ST010::writeb(uint16 addr, uint8 data) {
+  ram[addr & 0xfff] = data;
+}
+
+void ST010::writew(uint16 addr, uint16 data) {
+  writeb(addr + 0, data);
+  writeb(addr + 1, data >> 8);
+}
+
+void ST010::writed(uint16 addr, uint32 data) {
+  writeb(addr + 0, data);
+  writeb(addr + 1, data >> 8);
+  writeb(addr + 2, data >> 16);
+  writeb(addr + 3, data >> 24);
+}
+
+//
+
+void ST010::init() {
+}
+
+void ST010::enable() {
+}
+
+void ST010::power() {
+  reset();
+}
+
+void ST010::reset() {
+  memset(ram, 0x00, sizeof ram);
+}
+
+//
+
+uint8 ST010::read(uint addr) {
+  return readb(addr);
+}
+
+void ST010::write(uint addr, uint8 data) {
+  writeb(addr, data);
+
+  if((addr & 0xfff) == 0x0021 && (data & 0x80)) {
+    switch(ram[0x0020]) {
+      case 0x01: op_01(); break;
+      case 0x02: op_02(); break;
+      case 0x03: op_03(); break;
+      case 0x04: op_04(); break;
+      case 0x05: op_05(); break;
+      case 0x06: op_06(); break;
+      case 0x07: op_07(); break;
+      case 0x08: op_08(); break;
+    }
+
+    ram[0x0021] &= ~0x80;
+  }
+}

src/chip/st010/st010.h

@@ -0,0 +1,42 @@
+class ST010 : public Memory {
+public:
+  void init();
+  void enable();
+  void power();
+  void reset();
+
+  uint8 read (uint addr);
+  void  write(uint addr, uint8 data);
+
+private:
+  uint8 ram[0x1000];
+  static const int16 sin_table[256];
+  static const int16 mode7_scale[176];
+  static const uint8 arctan[32][32];
+
+//interfaces to sin table
+  int16 sin(int16 theta);
+  int16 cos(int16 theta);
+
+//interfaces to ram buffer
+  uint8  readb (uint16 addr);
+  uint16 readw (uint16 addr);
+  uint32 readd (uint16 addr);
+  void   writeb(uint16 addr, uint8  data);
+  void   writew(uint16 addr, uint16 data);
+  void   writed(uint16 addr, uint32 data);
+
+//opcodes
+  void op_01();
+  void op_02();
+  void op_03();
+  void op_04();
+  void op_05();
+  void op_06();
+  void op_07();
+  void op_08();
+
+  void op_01(int16 x0, int16 y0, int16 &x1, int16 &y1, int16 &quadrant, int16 &theta);
+};
+
+extern ST010 st010;

src/chip/st010/st010_data.h

@@ -0,0 +1,126 @@
+const int16 ST010::sin_table[256] = {
+   0x0000,  0x0324,  0x0648,  0x096a,  0x0c8c,  0x0fab,  0x12c8,  0x15e2,
+   0x18f9,  0x1c0b,  0x1f1a,  0x2223,  0x2528,  0x2826,  0x2b1f,  0x2e11,
+   0x30fb,  0x33df,  0x36ba,  0x398c,  0x3c56,  0x3f17,  0x41ce,  0x447a,
+   0x471c,  0x49b4,  0x4c3f,  0x4ebf,  0x5133,  0x539b,  0x55f5,  0x5842,
+   0x5a82,  0x5cb3,  0x5ed7,  0x60eb,  0x62f1,  0x64e8,  0x66cf,  0x68a6,
+   0x6a6d,  0x6c23,  0x6dc9,  0x6f5e,  0x70e2,  0x7254,  0x73b5,  0x7504,
+   0x7641,  0x776b,  0x7884,  0x7989,  0x7a7c,  0x7b5c,  0x7c29,  0x7ce3,
+   0x7d89,  0x7e1d,  0x7e9c,  0x7f09,  0x7f61,  0x7fa6,  0x7fd8,  0x7ff5,
+   0x7fff,  0x7ff5,  0x7fd8,  0x7fa6,  0x7f61,  0x7f09,  0x7e9c,  0x7e1d,
+   0x7d89,  0x7ce3,  0x7c29,  0x7b5c,  0x7a7c,  0x7989,  0x7884,  0x776b,
+   0x7641,  0x7504,  0x73b5,  0x7254,  0x70e2,  0x6f5e,  0x6dc9,  0x6c23,
+   0x6a6d,  0x68a6,  0x66cf,  0x64e8,  0x62f1,  0x60eb,  0x5ed7,  0x5cb3,
+   0x5a82,  0x5842,  0x55f5,  0x539b,  0x5133,  0x4ebf,  0x4c3f,  0x49b4,
+   0x471c,  0x447a,  0x41ce,  0x3f17,  0x3c56,  0x398c,  0x36ba,  0x33df,
+   0x30fb,  0x2e11,  0x2b1f,  0x2826,  0x2528,  0x2223,  0x1f1a,  0x1c0b,
+   0x18f8,  0x15e2,  0x12c8,  0x0fab,  0x0c8c,  0x096a,  0x0648,  0x0324,
+   0x0000, -0x0324, -0x0648, -0x096b, -0x0c8c, -0x0fab, -0x12c8, -0x15e2,
+  -0x18f9, -0x1c0b, -0x1f1a, -0x2223, -0x2528, -0x2826, -0x2b1f, -0x2e11,
+  -0x30fb, -0x33df, -0x36ba, -0x398d, -0x3c56, -0x3f17, -0x41ce, -0x447a,
+  -0x471c, -0x49b4, -0x4c3f, -0x4ebf, -0x5133, -0x539b, -0x55f5, -0x5842,
+  -0x5a82, -0x5cb3, -0x5ed7, -0x60ec, -0x62f1, -0x64e8, -0x66cf, -0x68a6,
+  -0x6a6d, -0x6c23, -0x6dc9, -0x6f5e, -0x70e2, -0x7254, -0x73b5, -0x7504,
+  -0x7641, -0x776b, -0x7884, -0x7989, -0x7a7c, -0x7b5c, -0x7c29, -0x7ce3,
+  -0x7d89, -0x7e1d, -0x7e9c, -0x7f09, -0x7f61, -0x7fa6, -0x7fd8, -0x7ff5,
+  -0x7fff, -0x7ff5, -0x7fd8, -0x7fa6, -0x7f61, -0x7f09, -0x7e9c, -0x7e1d,
+  -0x7d89, -0x7ce3, -0x7c29, -0x7b5c, -0x7a7c, -0x7989, -0x7883, -0x776b,
+  -0x7641, -0x7504, -0x73b5, -0x7254, -0x70e2, -0x6f5e, -0x6dc9, -0x6c23,
+  -0x6a6d, -0x68a6, -0x66cf, -0x64e8, -0x62f1, -0x60eb, -0x5ed7, -0x5cb3,
+  -0x5a82, -0x5842, -0x55f5, -0x539a, -0x5133, -0x4ebf, -0x4c3f, -0x49b3,
+  -0x471c, -0x447a, -0x41cd, -0x3f17, -0x3c56, -0x398c, -0x36b9, -0x33de,
+  -0x30fb, -0x2e10, -0x2b1f, -0x2826, -0x2527, -0x2223, -0x1f19, -0x1c0b,
+  -0x18f8, -0x15e2, -0x12c8, -0x0fab, -0x0c8b, -0x096a, -0x0647, -0x0324
+};
+
+const int16 ST010::mode7_scale[176] = {
+  0x0380,  0x0325,  0x02da,  0x029c,  0x0268,  0x023b,  0x0215,  0x01f3,
+  0x01d5,  0x01bb,  0x01a3,  0x018e,  0x017b,  0x016a,  0x015a,  0x014b,
+  0x013e,  0x0132,  0x0126,  0x011c,  0x0112,  0x0109,  0x0100,  0x00f8,
+  0x00f0,  0x00e9,  0x00e3,  0x00dc,  0x00d6,  0x00d1,  0x00cb,  0x00c6,
+  0x00c1,  0x00bd,  0x00b8,  0x00b4,  0x00b0,  0x00ac,  0x00a8,  0x00a5,
+  0x00a2,  0x009e,  0x009b,  0x0098,  0x0095,  0x0093,  0x0090,  0x008d,
+  0x008b,  0x0088,  0x0086,  0x0084,  0x0082,  0x0080,  0x007e,  0x007c,
+  0x007a,  0x0078,  0x0076,  0x0074,  0x0073,  0x0071,  0x006f,  0x006e,
+  0x006c,  0x006b,  0x0069,  0x0068,  0x0067,  0x0065,  0x0064,  0x0063,
+  0x0062,  0x0060,  0x005f,  0x005e,  0x005d,  0x005c,  0x005b,  0x005a,
+  0x0059,  0x0058,  0x0057,  0x0056,  0x0055,  0x0054,  0x0053,  0x0052,
+  0x0051,  0x0051,  0x0050,  0x004f,  0x004e,  0x004d,  0x004d,  0x004c,
+  0x004b,  0x004b,  0x004a,  0x0049,  0x0048,  0x0048,  0x0047,  0x0047,
+  0x0046,  0x0045,  0x0045,  0x0044,  0x0044,  0x0043,  0x0042,  0x0042,
+  0x0041,  0x0041,  0x0040,  0x0040,  0x003f,  0x003f,  0x003e,  0x003e,
+  0x003d,  0x003d,  0x003c,  0x003c,  0x003b,  0x003b,  0x003a,  0x003a,
+  0x003a,  0x0039,  0x0039,  0x0038,  0x0038,  0x0038,  0x0037,  0x0037,
+  0x0036,  0x0036,  0x0036,  0x0035,  0x0035,  0x0035,  0x0034,  0x0034,
+  0x0034,  0x0033,  0x0033,  0x0033,  0x0032,  0x0032,  0x0032,  0x0031,
+  0x0031,  0x0031,  0x0030,  0x0030,  0x0030,  0x0030,  0x002f,  0x002f,
+  0x002f,  0x002e,  0x002e,  0x002e,  0x002e,  0x002d,  0x002d,  0x002d,
+  0x002d,  0x002c,  0x002c,  0x002c,  0x002c,  0x002b,  0x002b,  0x002b
+};
+
+const uint8 ST010::arctan[32][32] = {
+  { 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
+    0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80 },
+  { 0x80, 0xa0, 0xad, 0xb3, 0xb6, 0xb8, 0xb9, 0xba, 0xbb, 0xbb, 0xbc, 0xbc, 0xbd, 0xbd, 0xbd, 0xbd,
+    0xbd, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbf, 0xbf, 0xbf, 0xbf },
+  { 0x80, 0x93, 0xa0, 0xa8, 0xad, 0xb0, 0xb3, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xb9, 0xba, 0xba, 0xbb,
+    0xbb, 0xbb, 0xbb, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd },
+  { 0x80, 0x8d, 0x98, 0xa0, 0xa6, 0xaa, 0xad, 0xb0, 0xb1, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb7, 0xb8,
+    0xb8, 0xb9, 0xb9, 0xba, 0xba, 0xba, 0xba, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbc, 0xbc, 0xbc, 0xbc },
+  { 0x80, 0x8a, 0x93, 0x9a, 0xa0, 0xa5, 0xa8, 0xab, 0xad, 0xaf, 0xb0, 0xb2, 0xb3, 0xb4, 0xb5, 0xb5,
+    0xb6, 0xb7, 0xb7, 0xb8, 0xb8, 0xb8, 0xb9, 0xb9, 0xb9, 0xba, 0xba, 0xba, 0xba, 0xba, 0xbb, 0xbb },
+  { 0x80, 0x88, 0x90, 0x96, 0x9b, 0xa0, 0xa4, 0xa7, 0xa9, 0xab, 0xad, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3,
+    0xb4, 0xb4, 0xb5, 0xb6, 0xb6, 0xb6, 0xb7, 0xb7, 0xb8, 0xb8, 0xb8, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9 },
+  { 0x80, 0x87, 0x8d, 0x93, 0x98, 0x9c, 0xa0, 0xa3, 0xa6, 0xa8, 0xaa, 0xac, 0xad, 0xae, 0xb0, 0xb0,
+    0xb1, 0xb2, 0xb3, 0xb4, 0xb4, 0xb5, 0xb5, 0xb6, 0xb6, 0xb6, 0xb7, 0xb7, 0xb7, 0xb8, 0xb8, 0xb8 },
+  { 0x80, 0x86, 0x8b, 0x90, 0x95, 0x99, 0x9d, 0xa0, 0xa3, 0xa5, 0xa7, 0xa9, 0xaa, 0xac, 0xad, 0xae,
+    0xaf, 0xb0, 0xb1, 0xb2, 0xb2, 0xb3, 0xb3, 0xb4, 0xb4, 0xb5, 0xb5, 0xb6, 0xb6, 0xb6, 0xb7, 0xb7 },
+  { 0x80, 0x85, 0x8a, 0x8f, 0x93, 0x97, 0x9a, 0x9d, 0xa0, 0xa2, 0xa5, 0xa6, 0xa8, 0xaa, 0xab, 0xac,
+    0xad, 0xae, 0xaf, 0xb0, 0xb0, 0xb1, 0xb2, 0xb2, 0xb3, 0xb3, 0xb4, 0xb4, 0xb5, 0xb5, 0xb5, 0xb5 },
+  { 0x80, 0x85, 0x89, 0x8d, 0x91, 0x95, 0x98, 0x9b, 0x9e, 0xa0, 0xa0, 0xa4, 0xa6, 0xa7, 0xa9, 0xaa,
+    0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb0, 0xb1, 0xb1, 0xb2, 0xb2, 0xb3, 0xb3, 0xb4, 0xb4, 0xb4 },
+  { 0x80, 0x84, 0x88, 0x8c, 0x90, 0x93, 0x96, 0x99, 0x9b, 0x9e, 0xa0, 0xa2, 0xa4, 0xa5, 0xa7, 0xa8,
+    0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xaf, 0xb0, 0xb0, 0xb1, 0xb2, 0xb2, 0xb2, 0xb3, 0xb3 },
+  { 0x80, 0x84, 0x87, 0x8b, 0x8e, 0x91, 0x94, 0x97, 0x9a, 0x9c, 0x9e, 0xa0, 0xa2, 0xa3, 0xa5, 0xa6,
+    0xa7, 0xa9, 0xaa, 0xab, 0xac, 0xac, 0xad, 0xae, 0xae, 0xaf, 0xb0, 0xb0, 0xb1, 0xb1, 0xb2, 0xb2 },
+  { 0x80, 0x83, 0x87, 0x8a, 0x8d, 0x90, 0x93, 0x96, 0x98, 0x9a, 0x9c, 0x9e, 0xa0, 0xa2, 0xa3, 0xa5,
+    0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xac, 0xad, 0xae, 0xae, 0xaf, 0xb0, 0xb0, 0xb0, 0xb1 },
+  { 0x80, 0x83, 0x86, 0x89, 0x8c, 0x8f, 0x92, 0x94, 0x96, 0x99, 0x9b, 0x9d, 0x9e, 0xa0, 0xa2, 0xa3,
+    0xa4, 0xa5, 0xa7, 0xa8, 0xa9, 0xa9, 0xaa, 0xab, 0xac, 0xac, 0xad, 0xae, 0xae, 0xaf, 0xaf, 0xb0 },
+  { 0x80, 0x83, 0x86, 0x89, 0x8b, 0x8e, 0x90, 0x93, 0x95, 0x97, 0x99, 0x9b, 0x9d, 0x9e, 0xa0, 0xa1,
+    0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xaa, 0xab, 0xac, 0xad, 0xad, 0xae, 0xae, 0xaf },
+  { 0x80, 0x83, 0x85, 0x88, 0x8b, 0x8d, 0x90, 0x92, 0x94, 0x96, 0x98, 0x9a, 0x9b, 0x9d, 0x9f, 0xa0,
+    0xa1, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa8, 0xa9, 0xaa, 0xab, 0xab, 0xac, 0xad, 0xad, 0xae },
+  { 0x80, 0x83, 0x85, 0x88, 0x8a, 0x8c, 0x8f, 0x91, 0x93, 0x95, 0x97, 0x99, 0x9a, 0x9c, 0x9d, 0x9f,
+    0xa0, 0xa1, 0xa2, 0xa3, 0xa5, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xaa, 0xab, 0xab, 0xac, 0xad },
+  { 0x80, 0x82, 0x85, 0x87, 0x89, 0x8c, 0x8e, 0x90, 0x92, 0x94, 0x96, 0x97, 0x99, 0x9b, 0x9c, 0x9d,
+    0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa8, 0xa9, 0xaa, 0xaa, 0xab, 0xac },
+  { 0x80, 0x82, 0x85, 0x87, 0x89, 0x8b, 0x8d, 0x8f, 0x91, 0x93, 0x95, 0x96, 0x98, 0x99, 0x9b, 0x9c,
+    0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa7, 0xa8, 0xa9, 0xa9, 0xaa, 0xab },
+  { 0x80, 0x82, 0x84, 0x86, 0x88, 0x8a, 0x8c, 0x8e, 0x90, 0x92, 0x94, 0x95, 0x97, 0x98, 0x9a, 0x9b,
+    0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa6, 0xa7, 0xa8, 0xa8, 0xa9, 0xaa },
+  { 0x80, 0x82, 0x84, 0x86, 0x88, 0x8a, 0x8c, 0x8e, 0x90, 0x91, 0x93, 0x94, 0x96, 0x97, 0x99, 0x9a,
+    0x9b, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa5, 0xa6, 0xa7, 0xa7, 0xa8, 0xa9 },
+  { 0x80, 0x82, 0x84, 0x86, 0x88, 0x8a, 0x8b, 0x8d, 0x8f, 0x90, 0x92, 0x94, 0x95, 0x97, 0x98, 0x99,
+    0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa4, 0xa5, 0xa6, 0xa6, 0xa7, 0xa8 },
+  { 0x80, 0x82, 0x84, 0x86, 0x87, 0x89, 0x8b, 0x8d, 0x8e, 0x90, 0x91, 0x93, 0x94, 0x96, 0x97, 0x98,
+    0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa3, 0xa4, 0xa5, 0xa6, 0xa6, 0xa7 },
+  { 0x80, 0x82, 0x84, 0x85, 0x87, 0x89, 0x8a, 0x8c, 0x8e, 0x8f, 0x91, 0x92, 0x94, 0x95, 0x96, 0x98,
+    0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa2, 0xa3, 0xa4, 0xa5, 0xa5, 0xa6 },
+  { 0x80, 0x82, 0x83, 0x85, 0x87, 0x88, 0x8a, 0x8c, 0x8d, 0x8f, 0x90, 0x92, 0x93, 0x94, 0x96, 0x97,
+    0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa2, 0xa3, 0xa4, 0xa5, 0xa5 },
+  { 0x80, 0x82, 0x83, 0x85, 0x86, 0x88, 0x8a, 0x8b, 0x8d, 0x8e, 0x90, 0x91, 0x92, 0x94, 0x95, 0x96,
+    0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa2, 0xa3, 0xa4, 0xa4 },
+  { 0x80, 0x82, 0x83, 0x85, 0x86, 0x88, 0x89, 0x8b, 0x8c, 0x8e, 0x8f, 0x90, 0x92, 0x93, 0x94, 0x95,
+    0x96, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa2, 0xa3, 0xa4 },
+  { 0x80, 0x82, 0x83, 0x85, 0x86, 0x87, 0x89, 0x8a, 0x8c, 0x8d, 0x8e, 0x90, 0x91, 0x92, 0x93, 0x95,
+    0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9e, 0x9f, 0xa0, 0xa1, 0xa1, 0xa2, 0xa3 },
+  { 0x80, 0x81, 0x83, 0x84, 0x86, 0x87, 0x89, 0x8a, 0x8b, 0x8d, 0x8e, 0x8f, 0x90, 0x92, 0x93, 0x94,
+    0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9e, 0x9f, 0xa0, 0xa1, 0xa1, 0xa2 },
+  { 0x80, 0x81, 0x83, 0x84, 0x86, 0x87, 0x88, 0x8a, 0x8b, 0x8c, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93,
+    0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0x9f, 0xa0, 0xa1, 0xa1 },
+  { 0x80, 0x81, 0x83, 0x84, 0x85, 0x87, 0x88, 0x89, 0x8b, 0x8c, 0x8d, 0x8e, 0x90, 0x91, 0x92, 0x93,
+    0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0x9f, 0xa0, 0xa1 },
+  { 0x80, 0x81, 0x83, 0x84, 0x85, 0x87, 0x88, 0x89, 0x8a, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92,
+    0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9c, 0x9d, 0x9e, 0x9f, 0x9f, 0xa0 }
+};

src/chip/st010/st010_op.cpp

@@ -0,0 +1,257 @@
+//ST-010 emulation code - Copyright (C) 2003 The Dumper, Matthew Kendora, Overload, Feather
+//bsnes port - Copyright (C) 2007 byuu
+
+void ST010::op_01(int16 x0, int16 y0, int16 &x1, int16 &y1, int16 &quadrant, int16 &theta) {
+  if((x0 < 0) && (y0 < 0)) {
+    x1 = -x0;
+    y1 = -y0;
+    quadrant = -0x8000;
+  } else if(x0 < 0) {
+    x1 = y0;
+    y1 = -x0;
+    quadrant = -0x4000;
+  } else if(y0 < 0) {
+    x1 = -y0;
+    y1 = x0;
+    quadrant = 0x4000;
+  } else {
+    x1 = x0;
+    y1 = y0;
+    quadrant = 0x0000;
+  }
+
+  while((x1 > 0x1f) || (y1 > 0x1f)) {
+    if(x1 > 1) { x1 >>= 1; }
+    if(y1 > 1) { y1 >>= 1; }
+  }
+
+  if(y1 == 0) { quadrant += 0x4000; }
+
+  theta = (arctan[y1][x1] << 8) ^ quadrant;
+}
+
+//
+
+void ST010::op_01() {
+int16 x0 = readw(0x0000);
+int16 y0 = readw(0x0002);
+int16 x1, y1, quadrant, theta;
+
+  op_01(x0, y0, x1, y1, quadrant, theta);
+
+  writew(0x0000, x1);
+  writew(0x0002, y1);
+  writew(0x0004, quadrant);
+//writew(0x0006, y0); //Overload's docs note this write occurs, SNES9x disagrees
+  writew(0x0010, theta);
+}
+
+void ST010::op_02() {
+int16 positions = readw(0x0024);
+uint16 *places  = (uint16*)(ram + 0x0040);
+uint16 *drivers = (uint16*)(ram + 0x0080);
+
+bool sorted;
+uint16 temp;
+  if(positions > 1) {
+    do {
+      sorted = true;
+      for(int i = 0; i < positions - 1; i++) {
+        if(places[i] < places[i + 1]) {
+          temp = places[i + 1];
+          places[i + 1] = places[i];
+          places[i] = temp;
+
+          temp = drivers[i + 1];
+          drivers[i + 1] = drivers[i];
+          drivers[i] = temp;
+
+          sorted = false;
+        }
+      }
+      positions--;
+    } while(!sorted);
+  }
+}
+
+void ST010::op_03() {
+int16 x0 = readw(0x0000);
+int16 y0 = readw(0x0002);
+int16 multiplier = readw(0x0004);
+int32 x1, y1;
+
+  x1 = x0 * multiplier << 1;
+  y1 = y0 * multiplier << 1;
+
+  writed(0x0010, x1);
+  writed(0x0014, y1);
+}
+
+void ST010::op_04() {
+int16 x = readw(0x0000);
+int16 y = readw(0x0002);
+int16 square;
+//calculate the vector length of (x,y)
+  square = (int16)sqrt((double)(y * y + x * x));
+
+  writew(0x0010, square);
+}
+
+void ST010::op_05() {
+int32 dx, dy;
+int16 a1, b1, c1;
+uint16 o1;
+bool wrap = false;
+
+//target (x,y) coordinates
+int16 ypos_max = readw(0x00c0);
+int16 xpos_max = readw(0x00c2);
+
+//current coordinates and direction
+int32 ypos = readd(0x00c4);
+int32 xpos = readd(0x00c8);
+uint16 rot = readw(0x00cc);
+
+//physics
+uint16 speed = readw(0x00d4);
+uint16 accel = readw(0x00d6);
+uint16 speed_max = readw(0x00d8);
+
+//special condition acknowledgement
+int16 system = readw(0x00da);
+int16 flags = readw(0x00dc);
+
+//new target coordinates
+int16 ypos_new = readw(0x00de);
+int16 xpos_new = readw(0x00e0);
+
+//mask upper bit
+  xpos_new &= 0x7fff;
+
+//get the current distance
+  dx = xpos_max - (xpos >> 16);
+  dy = ypos_max - (ypos >> 16);
+
+//quirk: clear and move in9
+  writew(0x00d2, 0xffff);
+  writew(0x00da, 0x0000);
+
+//grab the target angle
+  op_01(dy, dx, a1, b1, c1, (int16&)o1);
+
+//check for wrapping
+  if(abs(o1 - rot) > 0x8000) {
+    o1 += 0x8000;
+    rot += 0x8000;
+    wrap = true;
+  }
+
+uint16 old_speed = speed;
+
+//special case
+  if(abs(o1 - rot) == 0x8000) {
+    speed = 0x100;
+  }
+
+//slow down for sharp curves
+  else if(abs(o1 - rot) >= 0x1000) {
+  uint32 slow = abs(o1 - rot);
+    slow >>= 4; //scaling
+    speed -= slow;
+  }
+
+//otherwise accelerate
+  else {
+    speed += accel;
+    if(speed > speed_max) {
+      speed = speed_max; //clip speed
+    }
+  }
+
+//prevent negative/positive overflow
+  if(abs(old_speed - speed) > 0x8000) {
+    if(old_speed < speed) { speed = 0; }
+    else speed = 0xff00;
+  }
+
+//adjust direction by so many degrees
+//be careful of negative adjustments
+  if((o1 > rot && (o1 - rot) > 0x80) || (o1 < rot && (rot - o1) >= 0x80)) {
+    if(o1 < rot) { rot -= 0x280; }
+    else if(o1 > rot) { rot += 0x280; }
+  }
+
+//turn of wrapping
+  if(wrap) { rot -= 0x8000; }
+
+//now check the distances (store for later)
+  dx = (xpos_max << 16) - xpos;
+  dy = (ypos_max << 16) - ypos;
+  dx >>= 16;
+  dy >>= 16;
+
+//if we're in so many units of the target, signal it
+  if((system && (dy <= 6 && dy >= -8) && (dx <= 126 && dx >= -128)) || (!system && (dx <= 6 && dx >= -8) && (dy <= 126 && dy >= -128))) {
+  //announce our new destination and flag it
+    xpos_max = xpos_new & 0x7fff;
+    ypos_max = ypos_new;
+    flags |= 0x08;
+  }
+
+//update position
+  xpos -= (cos(rot) * 0x400 >> 15) * (speed >> 8) << 1;
+  ypos -= (sin(rot) * 0x400 >> 15) * (speed >> 8) << 1;
+
+//quirk: mask upper byte
+  xpos &= 0x1fffffff;
+  ypos &= 0x1fffffff;
+
+  writew(0x00c0, ypos_max);
+  writew(0x00c2, xpos_max);
+  writed(0x00c4, ypos);
+  writed(0x00c8, xpos);
+  writew(0x00cc, rot);
+  writew(0x00d4, speed);
+  writew(0x00dc, flags);
+}
+
+void ST010::op_06() {
+int16 multiplicand = readw(0x0000);
+int16 multiplier = readw(0x0002);
+int32 product;
+
+  product = multiplicand * multiplier << 1;
+
+  writed(0x0010, product);
+}
+
+void ST010::op_07() {
+int16 theta = readw(0x0000);
+
+int16 data;
+  for(int i = 0, offset = 0; i < 176; i++) {
+    data = mode7_scale[i] * cos(theta) >> 15;
+    writew(0x00f0 + offset, data);
+    writew(0x0510 + offset, data);
+
+    data = mode7_scale[i] * sin(theta) >> 15;
+    writew(0x0250 + offset, data);
+    if(data) { data = ~data; }
+    writew(0x03b0 + offset, data);
+
+    offset += 2;
+  }
+}
+
+void ST010::op_08() {
+int16 x0 = readw(0x0000);
+int16 y0 = readw(0x0002);
+int16 theta = readw(0x0004);
+int16 x1, y1;
+
+  x1 = (y0 * sin(theta) >> 15) + (x0 * cos(theta) >> 15);
+  y1 = (y0 * cos(theta) >> 15) - (x0 * sin(theta) >> 15);
+
+  writew(0x0010, x1);
+  writew(0x0012, y1);
+}

src/clean.bat

@@ -1 +1 @@
-@make PLATFORM=win-visualc-lui clean
+@make platform=win compiler=mingw32-gcc clean

src/clean.sh

@@ -1,2 +1 @@
-#!/bin/sh
-make PLATFORM=x-gcc-lui clean
+make platform=x compiler=gcc clean

src/config/config.cpp

@@ -1,7 +1,10 @@
-Config config_file;
-
 namespace config {
 
+configuration& config() {
+static configuration config;
+  return config;
+}
+
 string file_updatepath(const char *req_file, const char *req_path) {
 string file(req_file);
   replace(file, "\\", "/");
@@ -12,96 +15,115 @@ string path(req_path);
   if(!strend(path, "/")) { strcat(path, "/"); }
 
   if(strbegin(path, "./")) {
-    strltrim(path, "./");
+    ltrim(path(), "./");
   string temp;
     strcpy(temp, config::path.base);
     strcat(temp, path);
     strcpy(path, temp);
   }
 
-stringarray part;
+lstring part;
   split(part, "/", file);
   strcat(path, part[count(part) - 1]);
   return path;
 }
 
-StringSetting Path::base(0, "fs.base_path",
+string_setting Path::base("path.base",
   "Path that bsnes resides in", "");
-StringSetting Path::rom(&config_file, "path.rom",
+string_setting Path::rom(config(), "path.rom",
   "Default path to look for ROM files in (\"\" = use default directory)", "");
-StringSetting Path::save(&config_file, "path.save",
+string_setting Path::save(config(), "path.save",
   "Default path for all save RAM and cheat files (\"\" = use current directory)", "");
-StringSetting Path::bios(&config_file, "path.bios",
-  "Path where BIOS file(s) are located\n"
-  "Supported BIOS files:\n"
-  "stbios.bin - Bandai Sufami Turbo"
-  "", "./bios");
+string_setting Path::bsx(config(), "path.bsx", "", "");
+string_setting Path::st(config(), "path.st", "", "");
 
-StringSetting Path::save_ext(&config_file, "path.save_ext",
-  "Extension to be used for all save RAM files", "srm");
+integral_setting SNES::gamma_ramp(config(), "snes.colorfilter.gamma_ramp",
+  "Use precalculated TV-style gamma ramp", integral_setting::boolean, true);
+integral_setting SNES::sepia(config(), "snes.colorfilter.sepia",
+  "Convert color to sepia tone", integral_setting::boolean, false);
+integral_setting SNES::grayscale(config(), "snes.colorfilter.grayscale",
+  "Convert color to grayscale tone", integral_setting::boolean, false);
+integral_setting SNES::invert(config(), "snes.colorfilter.invert",
+  "Invert output image colors", integral_setting::boolean, false);
+integral_setting SNES::contrast(config(), "snes.colorfilter.contrast",
+  "Contrast", integral_setting::decimal, 0);
+integral_setting SNES::brightness(config(), "snes.colorfilter.brightness",
+  "Brightness", integral_setting::decimal, 0);
+integral_setting SNES::gamma(config(), "snes.colorfilter.gamma",
+  "Gamma", integral_setting::decimal, 80);
 
-IntegerSetting SNES::gamma_ramp(&config_file, "snes.colorfilter.gamma_ramp",
-  "Use precalculated TV-style gamma ramp", IntegerSetting::Boolean, true);
-IntegerSetting SNES::sepia(&config_file, "snes.colorfilter.sepia",
-  "Convert color to sepia tone", IntegerSetting::Boolean, false);
-IntegerSetting SNES::grayscale(&config_file, "snes.colorfilter.grayscale",
-  "Convert color to grayscale tone", IntegerSetting::Boolean, false);
-IntegerSetting SNES::invert(&config_file, "snes.colorfilter.invert",
-  "Invert output image colors", IntegerSetting::Boolean, false);
-IntegerSetting SNES::contrast(&config_file, "snes.colorfilter.contrast",
-  "Contrast", IntegerSetting::Decimal, 0);
-IntegerSetting SNES::brightness(&config_file, "snes.colorfilter.brightness",
-  "Brightness", IntegerSetting::Decimal, 0);
-IntegerSetting SNES::gamma(&config_file, "snes.colorfilter.gamma",
-  "Gamma", IntegerSetting::Decimal, 80);
-
-IntegerSetting SNES::ntsc_merge_fields(&config_file, "snes.ntsc_merge_fields",
+integral_setting SNES::ntsc_merge_fields(config(), "snes.ntsc_merge_fields",
   "Merge fields in NTSC video filter\n"
   "Set to true if using filter at any refresh rate other than 60hz\n"
-  "", IntegerSetting::Boolean, true);
+  "", integral_setting::boolean, true);
 
-IntegerSetting SNES::mute(&config_file, "snes.mute", "Mutes SNES audio output when enabled",
-  IntegerSetting::Boolean, false);
+integral_setting SNES::controller_port0(config(), "snes.controller_port_1",
+  "Controller attached to SNES port 1", integral_setting::decimal, ::SNES::DEVICEID_JOYPAD1);
+integral_setting SNES::controller_port1(config(), "snes.controller_port_2",
+  "Controller attached to SNES port 2", integral_setting::decimal, ::SNES::DEVICEID_JOYPAD2);
 
-IntegerSetting SNES::controller_port0(&config_file, "snes.controller_port_1",
-  "Controller attached to SNES port 1", IntegerSetting::Decimal, ::SNES::DEVICEID_JOYPAD1);
-IntegerSetting SNES::controller_port1(&config_file, "snes.controller_port_2",
-  "Controller attached to SNES port 2", IntegerSetting::Decimal, ::SNES::DEVICEID_JOYPAD2);
+integral_setting CPU::ntsc_clock_rate(config(), "cpu.ntsc_clock_rate",
+  "NTSC S-CPU clock rate (in hz)", integral_setting::decimal, 21477272);
+integral_setting CPU::pal_clock_rate(config(), "cpu.pal_clock_rate",
+  "PAL S-CPU clock rate (in hz)", integral_setting::decimal, 21281370);
+integral_setting CPU::wram_init_value(config(), "cpu.wram_init_value",
+  "Value to initialize 128k WRAM to upon power cycle.\n"
+  "Note that on real hardware, this value is undefined; meaning it can vary\n"
+  "per power-on, and per SNES unit. Such randomness is undesirable for an\n"
+  "emulator, so a static value is needed. There is also some form of pattern\n"
+  "to the randomness that has yet to be determined, which some games rely upon.\n"
+  "A value of 0x55 is safe for all known commercial software, and should be used.\n"
+  "However, some software written for SNES copiers, or backup units, relies on\n"
+  "WRAM being initialized to 0x00; which was a side-effect of the BIOS program\n"
+  "which executed on these copiers. Using 0x00 will therefore fix many homebrew\n"
+  "programs, but *will* break some poorly programmed commercial software titles,\n"
+  "which do not properly initialize WRAM upon power cycle.\n",
+  integral_setting::hex, 0x55);
 
-IntegerSetting CPU::ntsc_clock_rate(&config_file, "cpu.ntsc_clock_rate",
-  "NTSC S-CPU clock rate (in hz)", IntegerSetting::Decimal, 21477272);
-IntegerSetting CPU::pal_clock_rate(&config_file, "cpu.pal_clock_rate",
-  "PAL S-CPU clock rate (in hz)", IntegerSetting::Decimal, 21281370);
+integral_setting CPU::hdma_enable("cpu.hdma_enable",
+  "Enable HDMA effects", integral_setting::boolean, true);
 
-IntegerSetting CPU::hdma_enable(0, "cpu.hdma_enable",
-  "Enable HDMA effects", IntegerSetting::Boolean, true);
+integral_setting SMP::ntsc_clock_rate(config(), "smp.ntsc_clock_rate",
+  "NTSC S-SMP clock rate (in hz)", integral_setting::decimal, 24606720);
+integral_setting SMP::pal_clock_rate(config(), "smp.pal_clock_rate",
+  "PAL S-SMP clock rate (in hz)", integral_setting::decimal, 24606720);
 
-IntegerSetting SMP::ntsc_clock_rate(&config_file, "smp.ntsc_clock_rate",
-  "NTSC S-SMP clock rate (in hz)", IntegerSetting::Decimal, 24606720);
-IntegerSetting SMP::pal_clock_rate(&config_file, "smp.pal_clock_rate",
-  "PAL S-SMP clock rate (in hz)", IntegerSetting::Decimal, 24606720);
-
-IntegerSetting PPU::Hack::render_scanline_position(&config_file, "ppu.hack.render_scanline_position",
+integral_setting PPU::Hack::render_scanline_position(config(), "ppu.hack.render_scanline_position",
   "Approximate HCLOCK position to render at for scanline-based renderers",
-  IntegerSetting::Decimal, 512);
-IntegerSetting PPU::Hack::obj_cache(&config_file, "ppu.hack.obj_cache",
+  integral_setting::decimal, 512);
+integral_setting PPU::Hack::obj_cache(config(), "ppu.hack.obj_cache",
   "Cache OAM OBJ attributes one scanline before rendering\n"
   "This is technically closer to the actual operation of the SNES,\n"
   "but can cause problems in some games if enabled",
-  IntegerSetting::Boolean, false);
+  integral_setting::boolean, false);
+integral_setting PPU::Hack::oam_address_invalidation(config(), "ppu.hack.oam_address_invalidation",
+  "OAM access address changes during active display, as the S-PPU reads\n"
+  "data to render the display. Thusly, the address retrieved when accessing\n"
+  "OAM during active display is unpredictable. Unfortunately, the exact\n"
+  "algorithm for this is completely unknown at this time. It is more hardware\n"
+  "accurate to enable this setting, but one must *not* rely on the actual\n"
+  "address to match hardware under emulation.",
+  integral_setting::boolean, true);
+integral_setting PPU::Hack::cgram_address_invalidation(config(), "ppu.hack.cgram_address_invalidation",
+  "CGRAM access address changes during active display (excluding hblank), as\n"
+  "the S-PPU reads data to render the display. Thusly, as with OAM, the access\n"
+  "address is unpredictable. Again, enabling this setting is more hardware\n"
+  "accurate, but one must *not* rely on the actual address to match hardware\n"
+  "under emulation.",
+  integral_setting::boolean, true);
 
-IntegerSetting PPU::opt_enable(0, "ppu.opt_enable", "Enable offset-per-tile effects", IntegerSetting::Boolean, true);
-IntegerSetting PPU::bg1_pri0_enable(0, "ppu.bg1_pri0_enable", "Enable BG1 Priority 0", IntegerSetting::Boolean, true);
-IntegerSetting PPU::bg1_pri1_enable(0, "ppu.bg1_pri1_enable", "Enable BG1 Priority 1", IntegerSetting::Boolean, true);
-IntegerSetting PPU::bg2_pri0_enable(0, "ppu.bg2_pri0_enable", "Enable BG2 Priority 0", IntegerSetting::Boolean, true);
-IntegerSetting PPU::bg2_pri1_enable(0, "ppu.bg2_pri1_enable", "Enable BG2 Priority 1", IntegerSetting::Boolean, true);
-IntegerSetting PPU::bg3_pri0_enable(0, "ppu.bg3_pri0_enable", "Enable BG3 Priority 0", IntegerSetting::Boolean, true);
-IntegerSetting PPU::bg3_pri1_enable(0, "ppu.bg3_pri1_enable", "Enable BG3 Priority 1", IntegerSetting::Boolean, true);
-IntegerSetting PPU::bg4_pri0_enable(0, "ppu.bg4_pri0_enable", "Enable BG4 Priority 0", IntegerSetting::Boolean, true);
-IntegerSetting PPU::bg4_pri1_enable(0, "ppu.bg4_pri1_enable", "Enable BG4 Priority 1", IntegerSetting::Boolean, true);
-IntegerSetting PPU::oam_pri0_enable(0, "ppu.oam_pri0_enable", "Enable OAM Priority 0", IntegerSetting::Boolean, true);
-IntegerSetting PPU::oam_pri1_enable(0, "ppu.oam_pri1_enable", "Enable OAM Priority 1", IntegerSetting::Boolean, true);
-IntegerSetting PPU::oam_pri2_enable(0, "ppu.oam_pri2_enable", "Enable OAM Priority 2", IntegerSetting::Boolean, true);
-IntegerSetting PPU::oam_pri3_enable(0, "ppu.oam_pri3_enable", "Enable OAM Priority 3", IntegerSetting::Boolean, true);
+integral_setting PPU::opt_enable("ppu.opt_enable", "Enable offset-per-tile effects", integral_setting::boolean, true);
+integral_setting PPU::bg1_pri0_enable("ppu.bg1_pri0_enable", "Enable BG1 Priority 0", integral_setting::boolean, true);
+integral_setting PPU::bg1_pri1_enable("ppu.bg1_pri1_enable", "Enable BG1 Priority 1", integral_setting::boolean, true);
+integral_setting PPU::bg2_pri0_enable("ppu.bg2_pri0_enable", "Enable BG2 Priority 0", integral_setting::boolean, true);
+integral_setting PPU::bg2_pri1_enable("ppu.bg2_pri1_enable", "Enable BG2 Priority 1", integral_setting::boolean, true);
+integral_setting PPU::bg3_pri0_enable("ppu.bg3_pri0_enable", "Enable BG3 Priority 0", integral_setting::boolean, true);
+integral_setting PPU::bg3_pri1_enable("ppu.bg3_pri1_enable", "Enable BG3 Priority 1", integral_setting::boolean, true);
+integral_setting PPU::bg4_pri0_enable("ppu.bg4_pri0_enable", "Enable BG4 Priority 0", integral_setting::boolean, true);
+integral_setting PPU::bg4_pri1_enable("ppu.bg4_pri1_enable", "Enable BG4 Priority 1", integral_setting::boolean, true);
+integral_setting PPU::oam_pri0_enable("ppu.oam_pri0_enable", "Enable OAM Priority 0", integral_setting::boolean, true);
+integral_setting PPU::oam_pri1_enable("ppu.oam_pri1_enable", "Enable OAM Priority 1", integral_setting::boolean, true);
+integral_setting PPU::oam_pri2_enable("ppu.oam_pri2_enable", "Enable OAM Priority 2", integral_setting::boolean, true);
+integral_setting PPU::oam_pri3_enable("ppu.oam_pri3_enable", "Enable OAM Priority 3", integral_setting::boolean, true);
 
 };

src/config/config.h

@@ -1,44 +1,46 @@
-extern Config config_file;
-
 namespace config {
 
+extern configuration& config();
+
 string file_updatepath(const char *, const char *);
 
 extern struct Path {
-  static StringSetting base, rom, save, bios;
-  static StringSetting save_ext;
+  static string_setting base, rom, save;
+  static string_setting bsx, st;
 } path;
 
 extern struct SNES {
-  static IntegerSetting gamma_ramp, sepia, grayscale, invert, contrast, brightness, gamma;
-  static IntegerSetting ntsc_merge_fields;
-  static IntegerSetting mute;
-  static IntegerSetting controller_port0;
-  static IntegerSetting controller_port1;
+  static integral_setting gamma_ramp, sepia, grayscale, invert, contrast, brightness, gamma;
+  static integral_setting ntsc_merge_fields;
+  static integral_setting controller_port0;
+  static integral_setting controller_port1;
 } snes;
 
 extern struct CPU {
-  static IntegerSetting ntsc_clock_rate, pal_clock_rate;
-  static IntegerSetting hdma_enable;
+  static integral_setting ntsc_clock_rate, pal_clock_rate;
+  static integral_setting wram_init_value;
+  static integral_setting hdma_enable;
 } cpu;
 
 extern struct SMP {
-  static IntegerSetting ntsc_clock_rate, pal_clock_rate;
+  static integral_setting ntsc_clock_rate, pal_clock_rate;
 } smp;
 
 extern struct PPU {
   struct Hack {
-    static IntegerSetting render_scanline_position;
-    static IntegerSetting obj_cache;
+    static integral_setting render_scanline_position;
+    static integral_setting obj_cache;
+    static integral_setting oam_address_invalidation;
+    static integral_setting cgram_address_invalidation;
   } hack;
 
-  static IntegerSetting opt_enable;
-  static IntegerSetting bg1_pri0_enable, bg1_pri1_enable;
-  static IntegerSetting bg2_pri0_enable, bg2_pri1_enable;
-  static IntegerSetting bg3_pri0_enable, bg3_pri1_enable;
-  static IntegerSetting bg4_pri0_enable, bg4_pri1_enable;
-  static IntegerSetting oam_pri0_enable, oam_pri1_enable;
-  static IntegerSetting oam_pri2_enable, oam_pri3_enable;
+  static integral_setting opt_enable;
+  static integral_setting bg1_pri0_enable, bg1_pri1_enable;
+  static integral_setting bg2_pri0_enable, bg2_pri1_enable;
+  static integral_setting bg3_pri0_enable, bg3_pri1_enable;
+  static integral_setting bg4_pri0_enable, bg4_pri1_enable;
+  static integral_setting oam_pri0_enable, oam_pri1_enable;
+  static integral_setting oam_pri2_enable, oam_pri3_enable;
 } ppu;
 
 };

src/cpu/dcpu.cpp

@@ -4,7 +4,7 @@ uint8  CPU::dreadb(uint32 addr) {
   //do not read MMIO registers within debugger
     return 0x00;
   }
-  return r_mem->read(addr);
+  return bus.read(addr);
 }
 
 uint16 CPU::dreadw(uint32 addr) {

src/cpu/scpu/dma/dma.cpp

@@ -19,19 +19,19 @@ uint8 r;
        (abus & 0x40ffff) == 0x420b || (abus & 0x40ffff) == 0x420c) {
       r = regs.mdr;
     } else {
-      r = r_mem->read(abus);
+      r = bus.read(abus);
     }
-    r_mem->write(0x2100 | bbus, r);
+    bus.write(0x2100 | bbus, r);
   } else { //b->a
     if(bbus == 0x80 && ((abus & 0x7e0000) == 0x7e0000 || (abus & 0x40e000) == 0x0000)) {
     //prevent WRAM->WRAM transfers
       r = regs.mdr;
     } else {
-      r = r_mem->read(0x2100 | bbus);
+      r = bus.read(0x2100 | bbus);
     }
     if((abus & 0x40ff00) == 0x2100 || (abus & 0x40ff80) == 0x4300 ||
        (abus & 0x40ffff) == 0x420b || (abus & 0x40ffff) == 0x420c)return;
-    r_mem->write(abus, r);
+    bus.write(abus, r);
   }
 
   dma_add_clocks(8);
@@ -83,8 +83,8 @@ inline uint32 sCPU::hdma_iaddr(uint8 i) {
  *****/
 
 void sCPU::dma_transfertobusb(uint8 i, uint8 bbus) {
-  if(cartridge.info.sdd1 == true && sdd1->dma_active() == true) {
-    r_mem->write(0x2100 | bbus, sdd1->dma_read());
+  if(cartridge.info.sdd1 == true && sdd1.dma_active() == true) {
+    bus.write(0x2100 | bbus, sdd1.dma_read());
   } else {
     dma_transfer(0, bbus, dma_addr(i));
   }
@@ -111,8 +111,7 @@ void sCPU::dma_run() {
     dma_add_clocks(8);
 
     if(cartridge.info.sdd1 == true) {
-      sdd1->dma_begin(i, (channel[i].srcbank << 16) | (channel[i].srcaddr),
-        channel[i].xfersize);
+      sdd1.dma_begin(i, (channel[i].srcbank << 16) | (channel[i].srcaddr), channel[i].xfersize);
     }
 
     if(tracer.enabled() == true && tracer.cpudma_enabled() == true) {
@@ -168,19 +167,19 @@ uint8 r = 0;
 }
 
 void sCPU::hdma_update(uint8 i) {
-  channel[i].hdma_line_counter = r_mem->read(hdma_addr(i));
+  channel[i].hdma_line_counter = bus.read(hdma_addr(i));
   dma_add_clocks(8);
 
   channel[i].hdma_completed   = (channel[i].hdma_line_counter == 0);
   channel[i].hdma_do_transfer = !channel[i].hdma_completed;
 
   if(channel[i].hdma_indirect) {
-    channel[i].hdma_iaddr = r_mem->read(hdma_addr(i)) << 8;
+    channel[i].hdma_iaddr = bus.read(hdma_addr(i)) << 8;
     dma_add_clocks(8);
 
     if(!channel[i].hdma_completed || hdma_active_after(i)) {
       channel[i].hdma_iaddr >>= 8;
-      channel[i].hdma_iaddr  |= r_mem->read(hdma_addr(i)) << 8;
+      channel[i].hdma_iaddr  |= bus.read(hdma_addr(i)) << 8;
       dma_add_clocks(8);
     }
   }

src/cpu/scpu/memory/memory.cpp

@@ -14,21 +14,21 @@ void sCPU::op_io() {
 }
 
 uint8 sCPU::op_read(uint32 addr) {
-  status.clock_count = r_mem->speed(addr);
+  status.clock_count = bus.speed(addr);
   precycle_edge();
   add_clocks(status.clock_count - 4);
-  regs.mdr = r_mem->read(addr);
+  regs.mdr = bus.read(addr);
   add_clocks(4);
   cycle_edge();
   return regs.mdr;
 }
 
 void sCPU::op_write(uint32 addr, uint8 data) {
-  status.clock_count = r_mem->speed(addr);
+  status.clock_count = bus.speed(addr);
   precycle_edge();
   add_clocks(status.clock_count);
   regs.mdr = data;
-  r_mem->write(addr, regs.mdr);
+  bus.write(addr, regs.mdr);
   cycle_edge();
 }
 

src/cpu/scpu/mmio/mmio.cpp

@@ -4,14 +4,14 @@ uint8 sCPU::pio_status() {
 
 //WMDATA
 uint8 sCPU::mmio_r2180() {
-uint8 r = r_mem->read(0x7e0000 | status.wram_addr);
+uint8 r = bus.read(0x7e0000 | status.wram_addr);
   status.wram_addr = (status.wram_addr + 1) & 0x01ffff;
   return r;
 }
 
 //WMDATA
 void sCPU::mmio_w2180(uint8 data) {
-  r_mem->write(0x7e0000 | status.wram_addr, data);
+  bus.write(0x7e0000 | status.wram_addr, data);
   status.wram_addr = (status.wram_addr + 1) & 0x01ffff;
 }
 
@@ -76,7 +76,7 @@ void sCPU::mmio_w4200(uint8 data) {
 //WRIO
 void sCPU::mmio_w4201(uint8 data) {
   if((status.pio & 0x80) && !(data & 0x80)) {
-    r_ppu->latch_counters();
+    ppu.latch_counters();
   }
   status.pio = data;
 }
@@ -159,7 +159,7 @@ void sCPU::mmio_w420c(uint8 data) {
 
 //MEMSEL
 void sCPU::mmio_w420d(uint8 data) {
-  r_mem->set_speed(data & 1);
+  bus.set_speed(data & 1);
 }
 
 //RDNMI
@@ -419,11 +419,13 @@ void sCPU::mmio_reset() {
   status.joy4h = 0x00;
 }
 
-uint8 sCPU::mmio_read(uint16 addr) {
+uint8 sCPU::mmio_read(uint addr) {
+  addr &= 0xffff;
+
 //APU
   if((addr & 0xffc0) == 0x2140) { //$2140-$217f
     scheduler.sync_cpusmp();
-    return r_smp->port_read(addr & 3);
+    return smp.port_read(addr & 3);
   }
 
 //DMA
@@ -474,7 +476,9 @@ uint8 sCPU::mmio_read(uint16 addr) {
   return regs.mdr;
 }
 
-void sCPU::mmio_write(uint16 addr, uint8 data) {
+void sCPU::mmio_write(uint addr, uint8 data) {
+  addr &= 0xffff;
+
 //APU
   if((addr & 0xffc0) == 0x2140) { //$2140-$217f
     scheduler.sync_cpusmp();

src/cpu/scpu/mmio/mmio.h

@@ -1,7 +1,7 @@
   void   mmio_power();
   void   mmio_reset();
-  uint8  mmio_read (uint16 addr);
-  void   mmio_write(uint16 addr, uint8 data);
+  uint8  mmio_read (uint addr);
+  void   mmio_write(uint addr, uint8 data);
 
   uint8  pio_status();
 

src/cpu/scpu/scpu.cpp

@@ -21,8 +21,8 @@ void sCPU::power() {
 
 void sCPU::reset() {
   regs.pc.d = 0x000000;
-  regs.pc.l = r_mem->read(0xfffc);
-  regs.pc.h = r_mem->read(0xfffd);
+  regs.pc.l = bus.read(0xfffc);
+  regs.pc.h = bus.read(0xfffd);
 
 //note: some registers are not fully reset by SNES
   regs.x.h  = 0x00;

src/cpu/scpu/scpu.h

@@ -1,8 +1,6 @@
-class sCPU : public CPU {
-public:
+class sCPU : public CPU { public:
   void enter();
 
-public:
 #include "core/core.h"
 #include "dma/dma.h"
 #include "memory/memory.h"

src/cpu/scpu/timing/timing.cpp

@@ -90,7 +90,7 @@ void sCPU::scanline() {
   status.line_rendered  = false;
   status.hdma_triggered = (status.vcounter <= (!overscan() ? 224 : 239)) ? false : true;
 
-  r_ppu->scanline();
+  ppu.scanline();
   snes.scanline();
 
   update_interrupts();
@@ -117,7 +117,7 @@ void sCPU::frame() {
     status.hdmainit_trigger_position = 12 + dma_counter();
   }
 
-  r_ppu->frame();
+  ppu.frame();
   snes.frame();
 }
 
@@ -143,7 +143,7 @@ void sCPU::cycle_edge() {
   if(status.line_rendered == false) {
     if(status.hclock >= status.line_render_position) {
       status.line_rendered = true;
-      r_ppu->render_scanline();
+      ppu.render_scanline();
     }
   }
 
@@ -250,7 +250,7 @@ void sCPU::timing_reset() {
   status.prev_line_clocks = 1364;
 
   status.line_rendered        = false;
-  status.line_render_position = min(1112, (uint16)config::ppu.hack.render_scanline_position);
+  status.line_render_position = min(1112U, (uint)config::ppu.hack.render_scanline_position);
 
   status.dram_refreshed        = false;
   status.dram_refresh_position = (cpu_version == 1) ? 530 : 538;

src/dsp/bdsp/bdsp.cpp

@@ -660,9 +660,11 @@ static uint8 const initial_regs [bDSP::register_count] =
 
 void bDSP::power()
 {
-	ram = (uint8*) r_smp->get_spcram_handle();
+	ram = (uint8*) smp.get_spcram_handle();
 	memset( &m, 0, sizeof m );
-	memcpy( m.regs, initial_regs, sizeof m.regs );
+	//memcpy( m.regs, initial_regs, sizeof m.regs );
+	memset(m.regs, 0, sizeof m.regs);
+	REG(flg) = 0xe0;
 	
 	// Internal state
 	for ( int i = voice_count; --i >= 0; )

src/dsp/bdsp/bdsp.h

@@ -10,7 +10,12 @@ public:
 	
 	bDSP();
 	~bDSP();
-	
+
+	template<int n, typename T> inline T asr(const T x) {
+	enum { bits = (sizeof(T) << 3) - n };
+		return sclip<bits>(x >> n);
+	}
+
 public:
 
 	enum { echo_hist_size = 8 };

src/interface.h

@@ -1,75 +1,36 @@
-#ifdef POLYMORPHISM
-  #define ref(x) x
-#else
-  #define ref(x) (&x)
-#endif
-#define deref(x) __##x
-
-#define r_mem ref(deref(mem))
-#define r_cpu ref(deref(cpu))
-#define r_smp ref(deref(smp))
-#define r_dsp ref(deref(dsp))
-#define r_ppu ref(deref(ppu))
-
-#include "reader/reader.h"
-#include "cart/cart.h"
-#include "cheat/cheat.h"
-
-#include "memory/memory.h"
-#include "memory/bmemory/bmemory.h"
-
-#include "cpu/cpu.h"
-#include "cpu/scpu/scpu.h"
-
-#include "smp/smp.h"
-#include "smp/ssmp/ssmp.h"
-
-#include "dsp/dsp.h"
-//#include "dsp/adsp/adsp.h"
-#include "dsp/bdsp/bdsp.h"
-
-#include "ppu/ppu.h"
-#include "ppu/bppu/bppu.h"
-
-#include "snes/snes.h"
-
-#include "chip/srtc/srtc.h"
-#include "chip/sdd1/sdd1.h"
-#include "chip/c4/c4.h"
-#include "chip/dsp1/dsp1.h"
-#include "chip/dsp2/dsp2.h"
-#include "chip/obc1/obc1.h"
-
-extern MMIO mmio_unmapped;
-#ifdef POLYMORPHISM
-  extern MemBus *deref(mem);
-  extern CPU    *deref(cpu);
-  extern SMP    *deref(smp);
-  extern DSP    *deref(dsp);
-  extern PPU    *deref(ppu);
-#else
-  extern MEMCORE deref(mem);
-  extern CPUCORE deref(cpu);
-  extern SMPCORE deref(smp);
-  extern DSPCORE deref(dsp);
-  extern PPUCORE deref(ppu);
-#endif
-
-#include "config/config.h"
-
-#ifdef INTERFACE_MAIN
-  #include "config/config.cpp"
-  #ifdef POLYMORPHISM
-    MemBus *deref(mem);
-    CPU    *deref(cpu);
-    APU    *deref(smp);
-    DSP    *deref(dsp);
-    PPU    *deref(ppu);
-  #else
-    MEMCORE deref(mem);
-    CPUCORE deref(cpu);
-    SMPCORE deref(smp);
-    DSPCORE deref(dsp);
-    PPUCORE deref(ppu);
-  #endif
-#endif
+#include "reader/reader.h"
+#include "cheat/cheat.h"
+#include "config/config.h"
+
+#include "memory/memory.h"
+#include "memory/smemory/smemory.h"
+
+#include "cart/cart.h"
+
+#include "cpu/cpu.h"
+#include "cpu/scpu/scpu.h"
+
+#include "smp/smp.h"
+#include "smp/ssmp/ssmp.h"
+
+#include "dsp/dsp.h"
+#include "dsp/bdsp/bdsp.h"
+
+#include "ppu/ppu.h"
+#include "ppu/bppu/bppu.h"
+
+#include "snes/snes.h"
+#include "chip/chip.h"
+
+#ifdef INTERFACE_MAIN
+  #include "config/config.cpp"
+  #define extern
+#endif
+
+extern BUSCORE bus;
+extern CPUCORE cpu;
+extern SMPCORE smp;
+extern DSPCORE dsp;
+extern PPUCORE ppu;
+
+#undef extern

src/lib/bbase.h

@@ -1,14 +1,28 @@
 /*
-  libbase : version 0.10 ~byuu (2007-05-27)
+  bbase : version 0.12 ~byuu (2007-12-12)
   license: public domain
 */
 
-#ifndef LIBBASE_H
-#define LIBBASE_H
+#ifndef BBASE_H
+#define BBASE_H
+
+#include <nall/stdint.hpp>
+typedef int8_t   int8;
+typedef int16_t  int16;
+typedef int32_t  int32;
+typedef int64_t  int64;
+typedef uint8_t  uint8;
+typedef uint16_t uint16;
+typedef uint32_t uint32;
+typedef uint64_t uint64;
+typedef unsigned int uint;
+
+#include <algorithm>
+using std::min;
+using std::max;
 
 #include <assert.h>
 #include <limits.h>
-#include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdarg.h>
@@ -16,7 +30,7 @@
 #include <time.h>
 #include <math.h>
 
-#if defined(_MSC_VER)
+#if defined(_MSC_VER) || defined(__MINGW32__)
   #include <io.h>
   #include <direct.h>
   #include <shlobj.h>
@@ -32,6 +46,10 @@
 
   #define NOMINMAX
   #define PATH_MAX  _MAX_PATH
+  #define va_copy(dst, src) ((dst) = (src))
+#endif
+
+#if defined(_MSC_VER) || defined(__MINGW32__)
   #define getcwd    _getcwd
   #define ftruncate _chsize
   #define mkdir     _mkdir
@@ -39,11 +57,10 @@
   #define rmdir     _rmdir
   #define vsnprintf _vsnprintf
 
-  #define va_copy(dst, src) ((dst) = (src))
   static char *realpath(const char *file_name, char *resolved_name) {
     return _fullpath(resolved_name, file_name, PATH_MAX);
   }
-#elif defined(__GNUC__)
+#else
   #define mkdir(path) (mkdir)(path, 0755);
 #endif
 
@@ -55,35 +72,16 @@
   #define noinline      __declspec(noinline)
   #define inline        inline
   #define alwaysinline  __forceinline
-  #define fastcall      __fastcall
 #elif defined(__GNUC__)
   #define noinline      __attribute__((noinline))
   #define inline        inline
   #define alwaysinline  __attribute__((always_inline))
-  #define fastcall      __attribute__((fastcall))
 #else
   #define noinline
   #define inline        inline
   #define alwaysinline  inline
-  #define fastcall
 #endif
 
-/*****
- * typedefs
- *****/
-
-typedef unsigned int uint;
-
-typedef uint8_t  uint8;
-typedef uint16_t uint16;
-typedef uint32_t uint32;
-typedef uint64_t uint64;
-
-typedef int8_t   int8;
-typedef int16_t  int16;
-typedef int32_t  int32;
-typedef int64_t  int64;
-
 /*****
  * OS localization
  *****/
@@ -91,13 +89,13 @@ typedef int64_t  int64;
 //userpath(output) retrieves path to user's home folder
 //output must be at least as large as PATH_MAX
 
-#if defined(_MSC_VER)
+#if defined(_MSC_VER) || defined(__MINGW32__)
 static char *userpath(char *output) {
   strcpy(output, "."); //failsafe
   SHGetFolderPath(0, CSIDL_APPDATA | CSIDL_FLAG_CREATE, 0, 0, output);
   return output;
 }
-#elif defined(__GNUC__)
+#else
 static char *userpath(char *output) {
   strcpy(output, "."); //failsafe
 struct passwd *userinfo = getpwuid(getuid());
@@ -107,7 +105,7 @@ struct passwd *userinfo = getpwuid(getuid());
 #endif
 
 /*****
- * templates
+ * template functions
  *****/
 
 template<typename T> inline void safe_free(T &handle) {
@@ -131,115 +129,57 @@ template<typename T> inline void safe_release(T &handle) {
   }
 }
 
-template<typename T> inline void swap(T &x, T &y) {
-T z = x;
-  x = y;
-  y = z;
-}
-
-#ifdef min
-#undef min
-#endif
-#define min(x, y) (((x) < (y)) ? (x) : (y))
-
-#ifdef max
-#undef max
-#endif
-#define max(x, y) (((x) > (y)) ? (x) : (y))
-
 template<int min, int max, typename T> inline T minmax(const T x) {
   return (x < (T)min) ? (T)min : (x > (T)max) ? (T)max : x;
 }
 
-template<int bits> inline unsigned uclamp(const unsigned x) {
-enum { y = (1U << bits) - 1 };
-  return y + ((x - y) & -(x < y)); //min(x, y);
-}
-
-template<int bits> inline unsigned uclip(const unsigned x) {
-enum { m = (1U << bits) - 1 };
-  return (x & m);
-}
-
-template<int bits> inline signed sclamp(const signed x) {
-enum { b = 1U << (bits - 1), m = (1U << (bits - 1)) - 1 };
-  return (x > m) ? m : (x < -b) ? -b : x;
-}
-
-template<int bits> inline signed sclip(const signed x) {
-enum { b = 1U << (bits - 1), m = (1U << bits) - 1 };
-  return ((x & m) ^ b) - b;
-}
-
-template<int n, typename T> inline T rol(const T x) {
-enum { s = (sizeof(T) << 3) - n };
-  return (x << n) | (x >> s);
-}
-
-template<int n, typename T> inline T ror(const T x) {
-enum { s = (sizeof(T) << 3) - n };
-  return (x >> n) | (x << s);
-}
-
-template<int n, typename T> inline T asl(const T x) {
-  return (x << n);
-}
-
-template<int n, typename T> inline T asr(const T x) {
-enum { bits = (sizeof(T) << 3) - n };
-  return sclip<bits>(x >> n);
-}
-
-template<int n, typename T> inline T lsl(const T x) {
-  return (x << n);
-}
-
-template<int n, typename T> inline T lsr(const T x) {
-enum { bits = (sizeof(T) << 3) - n };
-  return uclip<bits>(x >> n);
-}
-
 /*****
  * endian wrappers
  *****/
 
-#ifndef ARCH_MSB
-//little-endian: uint8[] { 0x01, 0x02, 0x03, 0x04 } = 0x04030201
-#define order_lsb2(a,b)             a,b
-#define order_lsb3(a,b,c)           a,b,c
-#define order_lsb4(a,b,c,d)         a,b,c,d
-#define order_lsb5(a,b,c,d,e)       a,b,c,d,e
-#define order_lsb6(a,b,c,d,e,f)     a,b,c,d,e,f
-#define order_lsb7(a,b,c,d,e,f,g)   a,b,c,d,e,f,g
-#define order_lsb8(a,b,c,d,e,f,g,h) a,b,c,d,e,f,g,h
-#define order_msb2(a,b)             b,a
-#define order_msb3(a,b,c)           c,b,a
-#define order_msb4(a,b,c,d)         d,c,b,a
-#define order_msb5(a,b,c,d,e)       e,d,c,b,a
-#define order_msb6(a,b,c,d,e,f)     f,e,d,c,b,a
-#define order_msb7(a,b,c,d,e,f,g)   g,f,e,d,c,b,a
-#define order_msb8(a,b,c,d,e,f,g,h) h,g,f,e,d,c,b,a
-#else
-//big-endian:    uint8[] { 0x01, 0x02, 0x03, 0x04 } = 0x01020304
-#define order_lsb2(a,b)             b,a
-#define order_lsb3(a,b,c)           c,b,a
-#define order_lsb4(a,b,c,d)         d,c,b,a
-#define order_lsb5(a,b,c,d,e)       e,d,c,b,a
-#define order_lsb6(a,b,c,d,e,f)     f,e,d,c,b,a
-#define order_lsb7(a,b,c,d,e,f,g)   g,f,e,d,c,b,a
-#define order_lsb8(a,b,c,d,e,f,g,h) h,g,f,e,d,c,b,a
-#define order_msb2(a,b)             a,b
-#define order_msb3(a,b,c)           a,b,c
-#define order_msb4(a,b,c,d)         a,b,c,d
-#define order_msb5(a,b,c,d,e)       a,b,c,d,e
-#define order_msb6(a,b,c,d,e,f)     a,b,c,d,e,f
-#define order_msb7(a,b,c,d,e,f,g)   a,b,c,d,e,f,g
-#define order_msb8(a,b,c,d,e,f,g,h) a,b,c,d,e,f,g,h
+#ifndef ARCH_MSB
+//little-endian: uint8[] { 0x01, 0x02, 0x03, 0x04 } == 0x04030201
+  #define order_lsb2(a,b)             a,b
+  #define order_lsb3(a,b,c)           a,b,c
+  #define order_lsb4(a,b,c,d)         a,b,c,d
+  #define order_lsb5(a,b,c,d,e)       a,b,c,d,e
+  #define order_lsb6(a,b,c,d,e,f)     a,b,c,d,e,f
+  #define order_lsb7(a,b,c,d,e,f,g)   a,b,c,d,e,f,g
+  #define order_lsb8(a,b,c,d,e,f,g,h) a,b,c,d,e,f,g,h
+  #define order_msb2(a,b)             b,a
+  #define order_msb3(a,b,c)           c,b,a
+  #define order_msb4(a,b,c,d)         d,c,b,a
+  #define order_msb5(a,b,c,d,e)       e,d,c,b,a
+  #define order_msb6(a,b,c,d,e,f)     f,e,d,c,b,a
+  #define order_msb7(a,b,c,d,e,f,g)   g,f,e,d,c,b,a
+  #define order_msb8(a,b,c,d,e,f,g,h) h,g,f,e,d,c,b,a
+#else
+//big-endian:    uint8[] { 0x01, 0x02, 0x03, 0x04 } == 0x01020304
+  #define order_lsb2(a,b)             b,a
+  #define order_lsb3(a,b,c)           c,b,a
+  #define order_lsb4(a,b,c,d)         d,c,b,a
+  #define order_lsb5(a,b,c,d,e)       e,d,c,b,a
+  #define order_lsb6(a,b,c,d,e,f)     f,e,d,c,b,a
+  #define order_lsb7(a,b,c,d,e,f,g)   g,f,e,d,c,b,a
+  #define order_lsb8(a,b,c,d,e,f,g,h) h,g,f,e,d,c,b,a
+  #define order_msb2(a,b)             a,b
+  #define order_msb3(a,b,c)           a,b,c
+  #define order_msb4(a,b,c,d)         a,b,c,d
+  #define order_msb5(a,b,c,d,e)       a,b,c,d,e
+  #define order_msb6(a,b,c,d,e,f)     a,b,c,d,e,f
+  #define order_msb7(a,b,c,d,e,f,g)   a,b,c,d,e,f,g
+  #define order_msb8(a,b,c,d,e,f,g,h) a,b,c,d,e,f,g,h
 #endif
 
 /*****
  * libc extensions
  *****/
+
+//pseudo-random number generator
+static uint prng() {
+static uint n = 0;
+  return n = (n >> 1) ^ (((n & 1) - 1) & 0xedb88320);
+}
 
 static uint64 fget(FILE *fp, uint length = 1) {
 uint64 data = 0;
@@ -288,7 +228,6 @@ static int fresize(FILE *fp, long size) {
 
 /*****
  * crc32 calculation
- * TODO: create libhash and move this code there
  *****/
 
 const uint32 crc32_table[256] = {
@@ -349,4 +288,4 @@ uint32 crc32 = ~0;
   return ~crc32;
 }
 
-#endif
+#endif //ifndef BBASE_H

src/lib/hiro.cpp

@@ -0,0 +1,269 @@
+#include <hiro.h>
+using namespace nall;
+
+#if defined(_WIN32)
+  #include <hiro_win/hiro.cpp>
+#else
+  #include <hiro_gtk/hiro.cpp>
+#endif
+
+namespace libhiro {
+
+/* Hiro (singleton) */
+
+void Hiro::init() { p.init(); }
+void Hiro::term() { p.term(); }
+bool Hiro::run() { return p.run(); }
+bool Hiro::pending() { return p.pending(); }
+bool Hiro::file_load(Window *focus, char *filename, const char *filter, const char *path) { return p.file_load(focus, filename, filter, path); }
+bool Hiro::file_save(Window *focus, char *filename, const char *filter, const char *path) { return p.file_save(focus, filename, filter, path); }
+uint Hiro::screen_width() { return p.screen_width(); }
+uint Hiro::screen_height() { return p.screen_height(); }
+Hiro& Hiro::handle() { static Hiro hiro; return hiro; }
+Hiro::Hiro() : p(*new pHiro(*this)) {}
+Hiro::~Hiro() { delete &p; }
+Hiro& hiro() { return Hiro::handle(); }
+
+/* Widget */
+
+void Widget::show(bool state) { p.show(state); }
+void Widget::hide() { p.hide(); }
+bool Widget::visible() { return p.visible(); }
+uintptr_t Widget::handle() { return p.handle(); }
+Widget::Widget() : p(*new pWidget(*this)) { type = WidgetType; }
+Widget::Widget(pWidget &p_) : p(p_) { type = WidgetType; }
+Widget::~Widget() { delete &p; }
+
+/* Widget -> Window */
+
+void Window::create(uint style, uint width, uint height, const char *text) { p.create(style, width, height, text); }
+void Window::close() { p.close(); }
+void Window::move(uint x, uint y) { p.move(x, y); }
+void Window::resize(uint width, uint height) { p.resize(width, height); }
+void Window::focus() { p.focus(); }
+bool Window::focused() { return p.focused(); }
+void Window::fullscreen() { p.fullscreen(); }
+void Window::unfullscreen() { p.unfullscreen(); }
+uint Window::get_width() { return p.get_width(); }
+uint Window::get_height() { return p.get_height(); }
+void Window::set_background_color(uint8_t r, uint8_t g, uint8_t b) { p.set_background_color(r, g, b); }
+void Window::set_text(const char *text) { p.set_text(text); }
+void Window::attach(Window &window, uint x, uint y) { p.attach(window, x, y); }
+void Window::attach(MenuGroup &menugroup) { p.attach(menugroup); }
+void Window::attach(FormControl &formcontrol, uint x, uint y) { p.attach(formcontrol, x, y); }
+void Window::move(Window &window, uint x, uint y) { p.move(window, x, y); }
+void Window::move(FormControl &formcontrol, uint x, uint y) { p.move(formcontrol, x, y); }
+
+void Window::Menubar::show(bool state) { p.menu.show(state); }
+void Window::Menubar::hide() { p.menu.hide(); }
+bool Window::Menubar::visible() { return p.menu.visible(); }
+Window::Menubar::Menubar(pWindow &p_) : p(p_) {}
+
+void Window::Statusbar::set_text(const char *text) { p.status.set_text(text); }
+void Window::Statusbar::show(bool state) { p.status.show(state); }
+void Window::Statusbar::hide() { p.status.hide(); }
+bool Window::Statusbar::visible() { return p.status.visible(); }
+Window::Statusbar::Statusbar(pWindow &p_) : p(p_) {}
+
+Window::Window() :
+  base_from_member<pWindow&>(*new pWindow(*this)),
+  Widget(base_from_member<pWindow&>::value),
+  p(base_from_member<pWindow&>::value),
+  menu(base_from_member<pWindow&>::value),
+  status(base_from_member<pWindow&>::value) { type = WindowType; }
+
+/* Widget -> MenuControl */
+
+void MenuControl::enable(bool state) { p.enable(state); }
+void MenuControl::disable() { p.disable(); }
+bool MenuControl::enabled() { return p.enabled(); }
+MenuControl::MenuControl() :
+  base_from_member<pMenuControl&>(*new pMenuControl(*this)),
+  Widget(base_from_member<pMenuControl&>::value),
+  p(base_from_member<pMenuControl&>::value) { type = MenuControlType; }
+MenuControl::MenuControl(pMenuControl &p_) :
+  base_from_member<pMenuControl&>(p_),
+  Widget(base_from_member<pMenuControl&>::value),
+  p(base_from_member<pMenuControl&>::value) { type = MenuControlType; }
+
+/* Widget -> MenuControl -> MenuGroup */
+
+MenuGroup& MenuGroup::create(const char *text) { p.create(text); return *this; }
+void MenuGroup::attach(MenuControl &menucontrol) { p.attach(menucontrol); }
+MenuGroup::MenuGroup() :
+  base_from_member<pMenuGroup&>(*new pMenuGroup(*this)),
+  MenuControl(base_from_member<pMenuGroup&>::value),
+  p(base_from_member<pMenuGroup&>::value) { type = MenuGroupType; }
+
+/* Widget -> MenuControl -> MenuItem */
+
+MenuItem& MenuItem::create(const char *text) { p.create(text); return *this; }
+MenuItem::MenuItem() :
+  base_from_member<pMenuItem&>(*new pMenuItem(*this)),
+  MenuControl(base_from_member<pMenuItem&>::value),
+  p(base_from_member<pMenuItem&>::value) { type = MenuItemType; }
+
+/* Widget -> MenuControl -> MenuCheckItem */
+
+MenuCheckItem& MenuCheckItem::create(const char *text) { p.create(text); return *this; }
+void MenuCheckItem::check(bool state) { state ? p.check() : p.uncheck(); }
+void MenuCheckItem::uncheck() { p.uncheck(); }
+bool MenuCheckItem::checked() { return p.checked(); }
+MenuCheckItem::MenuCheckItem() :
+  base_from_member<pMenuCheckItem&>(*new pMenuCheckItem(*this)),
+  MenuControl(base_from_member<pMenuCheckItem&>::value),
+  p(base_from_member<pMenuCheckItem&>::value) { type = MenuCheckItemType; }
+
+/* Widget -> MenuControl -> MenuRadioItem */
+
+MenuRadioItem& MenuRadioItem::create(MenuRadioItemGroup &group, const char *text) { p.create(group, text); return *this; }
+void MenuRadioItem::check() { p.check(); }
+bool MenuRadioItem::checked() { return p.checked(); }
+MenuRadioItem::MenuRadioItem() :
+  base_from_member<pMenuRadioItem&>(*new pMenuRadioItem(*this)),
+  MenuControl(base_from_member<pMenuRadioItem&>::value),
+  p(base_from_member<pMenuRadioItem&>::value) { type = MenuRadioItemType; }
+
+/* Widget -> MenuControl -> MenuSeparator */
+
+MenuSeparator& MenuSeparator::create() { p.create(); return *this; }
+MenuSeparator::MenuSeparator() :
+  base_from_member<pMenuSeparator&>(*new pMenuSeparator(*this)),
+  MenuControl(base_from_member<pMenuSeparator&>::value),
+  p(base_from_member<pMenuSeparator&>::value) { type = MenuSeparatorType; }
+
+/* Widget -> FormControl */
+
+void FormControl::resize(uint width, uint height) { p.resize(width, height); }
+void FormControl::focus() { p.focus(); }
+bool FormControl::focused() { return p.focused(); }
+void FormControl::enable(bool state) { p.enable(state); }
+void FormControl::disable() { p.disable(); }
+bool FormControl::enabled() { return p.enabled(); }
+FormControl::FormControl() :
+  base_from_member<pFormControl&>(*new pFormControl(*this)),
+  Widget(base_from_member<pFormControl&>::value),
+  p(base_from_member<pFormControl&>::value) { type = FormControlType; }
+FormControl::FormControl(pFormControl &p_) :
+  base_from_member<pFormControl&>(p_),
+  Widget(base_from_member<pFormControl&>::value),
+  p(base_from_member<pFormControl&>::value) { type = FormControlType; }
+
+/* Widget -> FormControl -> Frame */
+
+void Frame::create(uint style, uint width, uint height, const char *text) { p.create(style, width, height, text); }
+void Frame::set_text(const char *text) { p.set_text(text); }
+Frame::Frame() :
+  base_from_member<pFrame&>(*new pFrame(*this)),
+  FormControl(base_from_member<pFrame&>::value),
+  p(base_from_member<pFrame&>::value) { type = FrameType; }
+
+/* Widget -> FormControl -> Canvas */
+
+void Canvas::create(uint style, uint width, uint height) { p.create(style, width, height); }
+void Canvas::redraw() { p.redraw(); }
+uint32_t* Canvas::buffer() { return p.buffer(); }
+Canvas::Canvas() :
+  base_from_member<pCanvas&>(*new pCanvas(*this)),
+  FormControl(base_from_member<pCanvas&>::value),
+  p(base_from_member<pCanvas&>::value) { type = CanvasType; }
+
+/* Widget -> FormControl -> Label */
+
+void Label::create(uint style, uint width, uint height, const char *text) { p.create(style, width, height, text); }
+void Label::set_text(const char *text) { p.set_text(text); }
+Label::Label() :
+  base_from_member<pLabel&>(*new pLabel(*this)),
+  FormControl(base_from_member<pLabel&>::value),
+  p(base_from_member<pLabel&>::value) { type = LabelType; }
+
+/* Widget -> FormControl -> Button */
+
+void Button::create(uint style, uint width, uint height, const char *text) { p.create(style, width, height, text); }
+void Button::set_text(const char *text) { p.set_text(text); }
+Button::Button() :
+  base_from_member<pButton&>(*new pButton(*this)),
+  FormControl(base_from_member<pButton&>::value),
+  p(base_from_member<pButton&>::value) { type = ButtonType; }
+
+/* Widget -> FormControl -> Checkbox */
+
+void Checkbox::create(uint style, uint width, uint height, const char *text) { p.create(style, width, height, text); }
+void Checkbox::set_text(const char *text) { p.set_text(text); }
+void Checkbox::check(bool state) { state ? p.check() : p.uncheck(); }
+void Checkbox::uncheck() { p.uncheck(); }
+bool Checkbox::checked() { return p.checked(); }
+Checkbox::Checkbox() :
+  base_from_member<pCheckbox&>(*new pCheckbox(*this)),
+  FormControl(base_from_member<pCheckbox&>::value),
+  p(base_from_member<pCheckbox&>::value) { type = CheckboxType; }
+
+/* Widget -> FormControl -> Radiobox */
+
+void Radiobox::create(RadioboxGroup &group, uint style, uint width, uint height, const char *text) { p.create(group, style, width, height, text); }
+void Radiobox::set_text(const char *text) { p.set_text(text); }
+void Radiobox::check() { p.check(); }
+bool Radiobox::checked() { return p.checked(); }
+Radiobox::Radiobox() :
+  base_from_member<pRadiobox&>(*new pRadiobox(*this)),
+  FormControl(base_from_member<pRadiobox&>::value),
+  p(base_from_member<pRadiobox&>::value) { type = RadioboxType; }
+
+/* Widget -> FormControl -> Editbox */
+
+void Editbox::create(uint style, uint width, uint height, const char *text) { p.create(style, width, height, text); }
+uint Editbox::get_text(char *text, uint length) { return p.get_text(text, length); }
+void Editbox::set_text(const char *text) { p.set_text(text); }
+Editbox::Editbox() :
+  base_from_member<pEditbox&>(*new pEditbox(*this)),
+  FormControl(base_from_member<pEditbox&>::value),
+  p(base_from_member<pEditbox&>::value) { type = EditboxType; }
+
+/* Widget -> FormControl -> Listbox */
+
+void Listbox::create(uint style, uint width, uint height, const char *columns, const char *text) { p.create(style, width, height, columns, text); }
+void Listbox::autosize_columns() { p.autosize_columns(); }
+void Listbox::set_column_width(uint column, uint width) { p.set_column_width(column, width); }
+void Listbox::add_item(const char *text) { p.add_item(text); }
+void Listbox::set_item(uint index, const char *text) { p.set_item(index, text); }
+int  Listbox::get_selection() { return p.get_selection(); }
+void Listbox::set_selection(int index) { p.set_selection(index); }
+void Listbox::reset() { p.reset(); }
+Listbox::Listbox() :
+  base_from_member<pListbox&>(*new pListbox(*this)),
+  FormControl(base_from_member<pListbox&>::value),
+  p(base_from_member<pListbox&>::value) { type = ListboxType; }
+
+/* Widget -> FormControl -> Combobox */
+
+void Combobox::create(uint style, uint width, uint height, const char *text) { p.create(style, width, height, text); }
+void Combobox::add_item(const char *text) { p.add_item(text); }
+int  Combobox::get_selection() { return p.get_selection(); }
+void Combobox::set_selection(int index) { p.set_selection(index); }
+void Combobox::reset() { p.reset(); }
+Combobox::Combobox() :
+  base_from_member<pCombobox&>(*new pCombobox(*this)),
+  FormControl(base_from_member<pCombobox&>::value),
+  p(base_from_member<pCombobox&>::value) { type = ComboboxType; }
+
+/* Widget -> FormControl -> Progressbar */
+
+void Progressbar::create(uint style, uint width, uint height) { p.create(style, width, height); }
+uint Progressbar::get_progress() { return p.get_progress(); }
+void Progressbar::set_progress(uint progress) { p.set_progress(progress); }
+Progressbar::Progressbar() :
+  base_from_member<pProgressbar&>(*new pProgressbar(*this)),
+  FormControl(base_from_member<pProgressbar&>::value),
+  p(base_from_member<pProgressbar&>::value) { type = ProgressbarType; }
+
+/* Widget -> FormControl -> Slider */
+
+void Slider::create(uint style, uint width, uint height, uint length) { p.create(style, width, height, length); }
+uint Slider::get_position() { return p.get_position(); }
+void Slider::set_position(uint position) { p.set_position(position); }
+Slider::Slider() :
+  base_from_member<pSlider&>(*new pSlider(*this)),
+  FormControl(base_from_member<pSlider&>::value),
+  p(base_from_member<pSlider&>::value) { type = SliderType; }
+
+} //namespace libhiro

src/lib/hiro.h

@@ -0,0 +1,526 @@
+/*
+  hiro
+  version: 0.001 (2008-02-03)
+  author: byuu
+  license: public domain
+*/
+
+#ifndef HIRO_H
+#define HIRO_H
+
+#include <nall/array.hpp>
+#include <nall/function.hpp>
+#include <nall/input.hpp>
+#include <nall/stdint.hpp>
+#include <nall/string.hpp>
+#include <nall/utility.hpp>
+typedef unsigned int uint;
+
+namespace libhiro {
+
+class pHiro;
+class pWidget;
+  class pWindow;
+  class pMenuControl;
+    class pMenuGroup;
+    class pMenuItem;
+    class pMenuCheckItem;
+    class pMenuRadioItem;
+    class pMenuSeparator;
+  class pFormControl;
+    class pFrame;
+    class pCanvas;
+    class pLabel;
+    class pButton;
+    class pCheckbox;
+    class pRadiobox;
+    class pEditbox;
+    class pListbox;
+    class pCombobox;
+    class pProgressbar;
+    class pSlider;
+
+#define pFriends \
+  friend class pHiro; \
+  friend class pWidget; \
+    friend class pWindow; \
+    friend class pMenuControl; \
+      friend class pMenuGroup; \
+      friend class pMenuItem; \
+      friend class pMenuCheckItem; \
+      friend class pMenuRadioItem; \
+      friend class pMenuSeparator; \
+    friend class pFormControl; \
+      friend class pFrame; \
+      friend class pCanvas; \
+      friend class pLabel; \
+      friend class pButton; \
+      friend class pCheckbox; \
+      friend class pRadiobox; \
+      friend class pEditbox; \
+      friend class pListbox; \
+      friend class pCombobox; \
+      friend class pProgressbar; \
+      friend class pSlider
+
+class Hiro;
+class Widget;
+  class Window;
+  class MenuControl;
+    class MenuGroup;
+    class MenuItem;
+    class MenuCheckItem;
+    class MenuRadioItem;
+    class MenuSeparator;
+  class FormControl;
+    class Frame;
+    class Canvas;
+    class Label;
+    class Button;
+    class Checkbox;
+    class Radiobox;
+    class Editbox;
+    class Listbox;
+    class Combobox;
+    class Progressbar;
+    class Slider;
+
+typedef nall::array<MenuRadioItem*> MenuRadioItemGroup;
+typedef nall::array<Radiobox*> RadioboxGroup;
+
+struct Event {
+  enum Type {
+    Close,
+    Block,
+    KeyDown,
+    KeyUp,
+    Change,
+    Tick,
+    Activate,
+  } type;
+  uintptr_t param;
+  Widget *widget;
+
+  Event(Type type_, uintptr_t param_ = 0, Widget *widget_ = 0) :
+    type(type_), param(param_), widget(widget_) {}
+};
+
+class Hiro : nall::noncopyable {
+public:
+  void init();
+  void term();
+  bool run();
+  bool pending();
+
+  bool file_load(Window *focus, char *filename, const char *filter, const char *path);
+  bool file_save(Window *focus, char *filename, const char *filter, const char *path);
+
+  uint screen_width();
+  uint screen_height();
+
+  static Hiro& handle();
+  Hiro();
+  ~Hiro();
+
+private:
+  pFriends;
+  pHiro &p;
+};
+
+Hiro& hiro();
+
+class Widget : nall::noncopyable {
+public:
+  enum Type {
+    WidgetType,
+      WindowType,
+      MenuControlType,
+        MenuGroupType,
+        MenuItemType,
+        MenuCheckItemType,
+        MenuRadioItemType,
+        MenuSeparatorType,
+      FormControlType,
+        FrameType,
+        CanvasType,
+        LabelType,
+        ButtonType,
+        CheckboxType,
+        RadioboxType,
+        EditboxType,
+        ListboxType,
+        ComboboxType,
+        ProgressbarType,
+        SliderType,
+  } type;
+
+  void show(bool = true);
+  void hide();
+  bool visible();
+
+  uintptr_t handle();
+
+  Widget();
+  ~Widget();
+
+protected:
+  Widget(pWidget&);
+
+private:
+  pFriends;
+  pWidget &p;
+};
+
+class Window : private nall::base_from_member<pWindow&>, public Widget {
+public:
+  enum Style {
+    AutoCenter = 1 << 1,
+  };
+
+  void create(uint style, uint width, uint height, const char *text = "");
+  void close();
+  void move(uint x, uint y);
+  void resize(uint width, uint height);
+  void focus();
+  bool focused();
+  void fullscreen();
+  void unfullscreen();
+  uint get_width();
+  uint get_height();
+  void set_background_color(uint8_t r, uint8_t g, uint8_t b);
+  void set_status_text(const char *text = "");
+  void set_text(const char *text = "");
+  void attach(Window &window, uint x, uint y);
+  void attach(MenuGroup &menugroup);
+  void attach(FormControl &formcontrol, uint x, uint y);
+  void move(Window &window, uint x, uint y);
+  void move(FormControl &formcontrol, uint x, uint y);
+
+  class Menubar {
+  public:
+    void show(bool = true);
+    void hide();
+    bool visible();
+
+    pWindow &p;
+    Menubar(pWindow&);
+  } menu;
+
+  class Statusbar {
+  public:
+    void set_text(const char *text = "");
+    void show(bool = true);
+    void hide();
+    bool visible();
+
+    pWindow &p;
+    Statusbar(pWindow&);
+  } status;
+
+  nall::function<uintptr_t (Event)> on_close;
+  nall::function<uintptr_t (Event)> on_block;
+  nall::function<uintptr_t (Event)> on_keydown;
+  nall::function<uintptr_t (Event)> on_keyup;
+
+  Window();
+
+private:
+  pFriends;
+  pWindow &p;
+};
+
+class MenuControl : public nall::base_from_member<pMenuControl&>, public Widget {
+public:
+  void enable(bool = true);
+  void disable();
+  bool enabled();
+
+  MenuControl();
+
+protected:
+  MenuControl(pMenuControl&);
+
+private:
+  pFriends;
+  pMenuControl &p;
+};
+
+class MenuGroup : public nall::base_from_member<pMenuGroup&>, public MenuControl {
+public:
+  MenuGroup& create(const char *text);
+  void attach(MenuControl &menucontrol);
+  MenuGroup();
+
+private:
+  pFriends;
+  pMenuGroup &p;
+};
+
+class MenuItem : public nall::base_from_member<pMenuItem&>, public MenuControl {
+public:
+  MenuItem& create(const char *text);
+  MenuItem();
+
+  nall::function<uintptr_t (Event)> on_tick;
+
+private:
+  pFriends;
+  pMenuItem &p;
+};
+
+class MenuCheckItem : public nall::base_from_member<pMenuCheckItem&>, public MenuControl {
+public:
+  MenuCheckItem& create(const char *text);
+  void check(bool = true);
+  void uncheck();
+  bool checked();
+  MenuCheckItem();
+
+  nall::function<uintptr_t (Event)> on_tick;
+
+private:
+  pFriends;
+  pMenuCheckItem &p;
+};
+
+class MenuRadioItem : public nall::base_from_member<pMenuRadioItem&>, public MenuControl {
+public:
+  MenuRadioItem& create(MenuRadioItemGroup &group, const char *text);
+  void check();
+  bool checked();
+  MenuRadioItem();
+
+  nall::function<uintptr_t (Event)> on_tick;
+
+private:
+  pFriends;
+  pMenuRadioItem &p;
+};
+
+class MenuSeparator : public nall::base_from_member<pMenuSeparator&>, public MenuControl {
+public:
+  MenuSeparator& create();
+  MenuSeparator();
+
+private:
+  pFriends;
+  pMenuSeparator &p;
+};
+
+class FormControl : private nall::base_from_member<pFormControl&>, public Widget {
+public:
+  void resize(uint width, uint height);
+  void focus();
+  bool focused();
+  void enable(bool = true);
+  void disable();
+  bool enabled();
+
+  FormControl();
+
+protected:
+  FormControl(pFormControl&);
+
+private:
+  pFriends;
+  pFormControl &p;
+};
+
+class Frame : private nall::base_from_member<pFrame&>, public FormControl {
+public:
+  void create(uint style, uint width, uint height, const char *text = "");
+  void set_text(const char *text = "");
+
+  Frame();
+
+private:
+  pFriends;
+  pFrame &p;
+};
+
+class Canvas : private nall::base_from_member<pCanvas&>, public FormControl {
+public:
+  void create(uint style, uint width, uint height);
+  void redraw();
+  uint32_t* buffer();
+
+  Canvas();
+
+private:
+  pFriends;
+  pCanvas &p;
+};
+
+class Label : private nall::base_from_member<pLabel&>, public FormControl {
+public:
+  void create(uint style, uint width, uint height, const char *text = "");
+  void set_text(const char *text = "");
+
+  Label();
+
+private:
+  pFriends;
+  pLabel &p;
+};
+
+class Button : private nall::base_from_member<pButton&>, public FormControl {
+public:
+  void create(uint style, uint width, uint height, const char *text = "");
+  void set_text(const char *text = "");
+
+  nall::function<uintptr_t (Event)> on_tick;
+
+  Button();
+
+private:
+  pFriends;
+  pButton &p;
+};
+
+class Checkbox : private nall::base_from_member<pCheckbox&>, public FormControl {
+public:
+  void create(uint style, uint width, uint height, const char *text = "");
+  void set_text(const char *text = "");
+  void check(bool = true);
+  void uncheck();
+  bool checked();
+
+  nall::function<uintptr_t (Event)> on_tick;
+
+  Checkbox();
+
+private:
+  pFriends;
+  pCheckbox &p;
+};
+
+class Radiobox : private nall::base_from_member<pRadiobox&>, public FormControl {
+public:
+  void create(RadioboxGroup &group, uint style, uint width, uint height, const char *text = "");
+  void set_text(const char *text = "");
+  void check();
+  bool checked();
+
+  nall::function<uintptr_t (Event)> on_tick;
+
+  Radiobox();
+
+private:
+  pFriends;
+  pRadiobox &p;
+};
+
+class Editbox : private nall::base_from_member<pEditbox&>, public FormControl {
+public:
+  enum Style {
+    Multiline = 1 << 1,
+    Readonly  = 1 << 2,
+
+    HorizontalScrollAuto   = 0,
+    HorizontalScrollAlways = 1 << 3,
+    HorizontalScrollNever  = 1 << 4,
+
+    VerticalScrollAuto   = 0,
+    VerticalScrollAlways = 1 << 5,
+    VerticalScrollNever  = 1 << 6,
+  };
+
+  void create(uint style, uint width, uint height, const char *text = "");
+  uint get_text(char *text, uint length = -1U);
+  void set_text(const char *text = "");
+
+  Editbox();
+
+private:
+  pFriends;
+  pEditbox &p;
+};
+
+class Listbox : private nall::base_from_member<pListbox&>, public FormControl {
+public:
+  enum Style {
+    Header = 1 << 1,
+
+    HorizontalScrollAuto   = 0,
+    HorizontalScrollAlways = 1 << 2,
+    HorizontalScrollNever  = 1 << 3,
+
+    VerticalScrollAuto   = 0,
+    VerticalScrollAlways = 1 << 4,
+    VerticalScrollNever  = 1 << 5,
+  };
+
+  void create(uint style, uint width, uint height, const char *columns = "", const char *text = "");
+  void autosize_columns();
+  void set_column_width(uint column, uint width);
+  void add_item(const char *text);
+  void set_item(uint index, const char *text);
+  int  get_selection();
+  void set_selection(int index);
+  void reset();
+
+  nall::function<uintptr_t (Event)> on_change;
+  nall::function<uintptr_t (Event)> on_activate;
+
+  Listbox();
+
+private:
+  pFriends;
+  pListbox &p;
+};
+
+class Combobox : private nall::base_from_member<pCombobox&>, public FormControl {
+public:
+  void create(uint style, uint width, uint height, const char *text = "");
+  void add_item(const char *text);
+  int  get_selection();
+  void set_selection(int index);
+  void reset();
+
+  nall::function<uintptr_t (Event)> on_change;
+
+  Combobox();
+
+private:
+  pFriends;
+  pCombobox &p;
+};
+
+class Progressbar : private nall::base_from_member<pProgressbar&>, public FormControl {
+public:
+  void create(uint style, uint width, uint height);
+  uint get_progress();
+  void set_progress(uint progress);
+
+  Progressbar();
+
+private:
+  pFriends;
+  pProgressbar &p;
+};
+
+class Slider : private nall::base_from_member<pSlider&>, public FormControl {
+public:
+  enum Style {
+    Horizontal = 0,
+    Vertical = 1 << 1,
+  };
+
+  void create(uint style, uint width, uint height, uint length);
+  uint get_position();
+  void set_position(uint position);
+
+  nall::function<uintptr_t (Event)> on_change;
+
+  Slider();
+
+private:
+  pFriends;
+  pSlider &p;
+};
+
+#undef pFriends
+
+} //namespace libhiro
+
+#endif //ifndef HIRO_H

src/lib/hiro_gtk/button.cpp

@@ -0,0 +1,25 @@
+void hiro_pbutton_tick(pButton *p) {
+  if(p->self.on_tick) p->self.on_tick(Event(Event::Tick, 0, &p->self));
+}
+
+void pButton::create(uint style, uint width, uint height, const char *text) {
+  button = gtk_button_new_with_label(text ? text : "");
+  gtk_widget_set_size_request(button, width, height);
+  gtk_widget_show(button);
+  g_signal_connect_swapped(G_OBJECT(button), "clicked", G_CALLBACK(hiro_pbutton_tick), (gpointer)this);
+}
+
+void pButton::set_text(const char *text) {
+  if(!button) return;
+  gtk_button_set_label(GTK_BUTTON(button), text ? text : "");
+}
+
+pButton::pButton(Button &self_) : pFormControl(self_), self(self_) {
+  button = 0;
+}
+
+/* internal */
+
+GtkWidget* pButton::gtk_handle() {
+  return button;
+}

src/lib/hiro_gtk/button.h

@@ -0,0 +1,12 @@
+class pButton : public pFormControl {
+public:
+  Button &self;
+  void create(uint style, uint width, uint height, const char *text = "");
+  void set_text(const char *text = "");
+
+  pButton(Button&);
+
+  /* internal */
+  GtkWidget *button;
+  GtkWidget* gtk_handle();
+};

src/lib/hiro_gtk/canvas.cpp

@@ -0,0 +1,72 @@
+void hiro_pcanvas_expose(pCanvas *p) {
+uint32_t *f = p->fbuffer;
+uint32_t *r = p->rbuffer;
+  for(uint y = p->canvas->allocation.height; y; y--) {
+    for(uint x = p->canvas->allocation.width; x; x--) {
+    uint32_t p = *f++;
+      *r++ = ((p << 16) & 0xff0000) + (p & 0x00ff00) + ((p >> 16) & 0x0000ff);
+    }
+  }
+
+  gdk_draw_rgb_32_image(p->canvas->window,
+    p->canvas->style->fg_gc[GTK_WIDGET_STATE(p->canvas)],
+    0, 0, p->canvas->allocation.width, p->canvas->allocation.height,
+    GDK_RGB_DITHER_NONE, (guchar*)p->rbuffer, p->bpitch);
+}
+
+void pCanvas::create(uint style, uint width, uint height) {
+  canvas = gtk_drawing_area_new();
+  resize(width, height);
+  GdkColor color;
+  color.pixel = color.red = color.green = color.blue = 0;
+  gtk_widget_modify_bg(canvas, GTK_STATE_NORMAL, &color);
+  gtk_widget_set_double_buffered(canvas, false);
+  gtk_widget_show(canvas);
+  g_signal_connect_swapped(G_OBJECT(canvas), "expose_event", G_CALLBACK(hiro_pcanvas_expose), (gpointer)this);
+}
+
+void pCanvas::redraw() {
+  if(!canvas || !canvas->window) return;
+
+GdkRectangle rect;
+  rect.x = 0;
+  rect.y = 0;
+  rect.width = canvas->allocation.width;
+  rect.height = canvas->allocation.height;
+  gdk_window_invalidate_rect(canvas->window, &rect, true);
+}
+
+uint32_t* pCanvas::buffer() {
+  return fbuffer;
+}
+
+pCanvas::pCanvas(Canvas &self_) : pFormControl(self_), self(self_) {
+  canvas = 0;
+  fbuffer = 0;
+  rbuffer = 0;
+  bpitch = 0;
+}
+
+pCanvas::~pCanvas() {
+  if(fbuffer) free(fbuffer);
+  if(rbuffer) free(rbuffer);
+}
+
+/* internal */
+
+void pCanvas::resize(uint width, uint height) {
+  if(fbuffer) free(fbuffer);
+  if(rbuffer) free(rbuffer);
+
+  bpitch = width * sizeof(uint32_t);
+  fbuffer = (uint32_t*)malloc(bpitch * height);
+  rbuffer = (uint32_t*)malloc(bpitch * height);
+  memset(fbuffer, 0, bpitch * height);
+  memset(rbuffer, 0, bpitch * height);
+
+  pFormControl::resize(width, height);
+}
+
+GtkWidget* pCanvas::gtk_handle() {
+  return canvas;
+}

src/lib/hiro_gtk/canvas.h

@@ -0,0 +1,19 @@
+class pCanvas : public pFormControl {
+public:
+  void create(uint style, uint width, uint height);
+  void redraw();
+  uint32_t* buffer();
+
+  Canvas &self;
+  pCanvas(Canvas&);
+  ~pCanvas();
+
+  /* internal */
+  GtkWidget *canvas;
+  //GTK+ RGB drawing function draws in xBGR format, so two buffers are needed ...
+  uint32_t *fbuffer; //one for the xRGB image
+  uint32_t *rbuffer; //one for the xBGR image
+  uint bpitch;
+  void resize(uint width, uint height);
+  GtkWidget* gtk_handle();
+};

src/lib/hiro_gtk/checkbox.cpp

@@ -0,0 +1,37 @@
+void hiro_pcheckbox_tick(pCheckbox *p) {
+  if(p->self.on_tick) p->self.on_tick(Event(Event::Tick, p->checked(), &p->self));
+}
+
+void pCheckbox::create(uint style, uint width, uint height, const char *text) {
+  checkbox = gtk_check_button_new_with_label(text ? text : "");
+  gtk_widget_set_size_request(checkbox, width, height);
+  gtk_widget_show(checkbox);
+  g_signal_connect_swapped(G_OBJECT(checkbox), "toggled", G_CALLBACK(hiro_pcheckbox_tick), (gpointer)this);
+}
+
+void pCheckbox::set_text(const char *text) {
+  if(!checkbox) return;
+  gtk_button_set_label(GTK_BUTTON(checkbox), text ? text : "");
+}
+
+void pCheckbox::check(bool state) {
+  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbox), state ? TRUE : FALSE);
+}
+
+void pCheckbox::uncheck() {
+  check(false);
+}
+
+bool pCheckbox::checked() {
+  return gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(checkbox));
+}
+
+pCheckbox::pCheckbox(Checkbox &self_) : pFormControl(self_), self(self_) {
+  checkbox = 0;
+}
+
+/* internal */
+
+GtkWidget* pCheckbox::gtk_handle() {
+  return checkbox;
+}

src/lib/hiro_gtk/checkbox.h

@@ -0,0 +1,15 @@
+class pCheckbox : public pFormControl {
+public:
+  void create(uint style, uint width, uint height, const char *text = "");
+  void set_text(const char *text = "");
+  void check(bool state = true);
+  void uncheck();
+  bool checked();
+
+  Checkbox &self;
+  pCheckbox(Checkbox&);
+
+  /* internal */
+  GtkWidget *checkbox;
+  GtkWidget* gtk_handle();
+};

src/lib/hiro_gtk/combobox.cpp

@@ -0,0 +1,44 @@
+void hiro_pcombobox_change(pCombobox *p) {
+  if(p->self.on_change) p->self.on_change(Event(Event::Change, p->get_selection(), &p->self));
+}
+
+void pCombobox::create(uint style, uint width, uint height, const char *text) {
+  combobox = gtk_combo_box_new_text();
+  gtk_widget_set_size_request(combobox, width, height);
+  gtk_widget_show(combobox);
+
+  g_signal_connect_swapped(G_OBJECT(combobox), "changed", G_CALLBACK(hiro_pcombobox_change), (gpointer)this);
+}
+
+void pCombobox::add_item(const char *text) {
+  if(!combobox) return;
+  gtk_combo_box_append_text(GTK_COMBO_BOX(combobox), text ? text : "?");
+  if(counter++ == 0) set_selection(0);
+}
+
+int pCombobox::get_selection() {
+  return gtk_combo_box_get_active(GTK_COMBO_BOX(combobox));
+}
+
+void pCombobox::set_selection(int index) {
+  gtk_combo_box_set_active(GTK_COMBO_BOX(combobox), index);
+}
+
+void pCombobox::reset() {
+  if(counter == 0) return;
+  for(int i = counter - 1; i >= 0; i--) {
+    gtk_combo_box_remove_text(GTK_COMBO_BOX(combobox), i);
+  }
+  counter = 0;
+}
+
+pCombobox::pCombobox(Combobox &self_) : pFormControl(self_), self(self_) {
+  combobox = 0;
+  counter = 0;
+}
+
+/* internal */
+
+GtkWidget* pCombobox::gtk_handle() {
+  return combobox;
+}

src/lib/hiro_gtk/combobox.h

@@ -0,0 +1,16 @@
+class pCombobox : public pFormControl {
+public:
+  void create(uint style, uint width, uint height, const char *text = "");
+  void add_item(const char *text);
+  int  get_selection();
+  void set_selection(int index);
+  void reset();
+
+  Combobox &self;
+  pCombobox(Combobox&);
+
+  /* internal */
+  GtkWidget *combobox;
+  uint counter;
+  GtkWidget* gtk_handle();
+};

src/lib/hiro_gtk/editbox.cpp

@@ -0,0 +1,62 @@
+void pEditbox::create(uint style, uint width, uint height, const char *text) {
+  multiline = bool(style & Editbox::Multiline);
+
+  if(multiline == false) {
+    editbox = gtk_entry_new();
+    if(style & Editbox::Readonly) { gtk_entry_set_editable(GTK_ENTRY(editbox), false); }
+    gtk_entry_set_text(GTK_ENTRY(editbox), text ? text : "");
+    gtk_widget_set_size_request(editbox, width, height);
+    gtk_widget_show(editbox);
+  } else {
+  GtkPolicyType hscroll = (style & Editbox::HorizontalScrollAlways) ? GTK_POLICY_ALWAYS :
+                          (style & Editbox::HorizontalScrollNever)  ? GTK_POLICY_NEVER  :
+                          GTK_POLICY_AUTOMATIC;
+  GtkPolicyType vscroll = (style & Editbox::VerticalScrollAlways) ? GTK_POLICY_ALWAYS :
+                          (style & Editbox::VerticalScrollNever)  ? GTK_POLICY_NEVER  :
+                          GTK_POLICY_AUTOMATIC;
+    scrollbox = gtk_scrolled_window_new(0, 0);
+    gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollbox), hscroll, vscroll);
+    gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrollbox), GTK_SHADOW_ETCHED_IN);
+    gtk_widget_set_size_request(scrollbox, width, height);
+    editbox = gtk_text_view_new();
+    gtk_container_add(GTK_CONTAINER(scrollbox), editbox);
+    buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(editbox));
+    if(style & Editbox::Readonly) { gtk_text_view_set_editable(GTK_TEXT_VIEW(editbox), false); }
+    gtk_text_buffer_set_text(buffer, text ? text : "", -1);
+    gtk_widget_show(editbox);
+    gtk_widget_show(scrollbox);
+  }
+}
+
+void pEditbox::set_text(const char *text) {
+  if(multiline == false) {
+    gtk_entry_set_text(GTK_ENTRY(editbox), text);
+  } else {
+    gtk_text_buffer_set_text(buffer, text, -1);
+  }
+}
+
+uint pEditbox::get_text(char *text, uint length) {
+  if(multiline == false) {
+  const char *temp = gtk_entry_get_text(GTK_ENTRY(editbox));
+    return strlcpy(text, temp ? temp : "", length);
+  } else {
+  GtkTextIter start, end;
+    gtk_text_buffer_get_start_iter(buffer, &start);
+    gtk_text_buffer_get_end_iter(buffer, &end);
+    return strlcpy(text, gtk_text_buffer_get_text(buffer, &start, &end, true), length);
+  }
+}
+
+pEditbox::pEditbox(Editbox &self_) : pFormControl(self_), self(self_) {
+  scrollbox = 0;
+  editbox = 0;
+  buffer = 0;
+  multiline = false;
+}
+
+/* internal */
+
+GtkWidget* pEditbox::gtk_handle() {
+  return multiline ? scrollbox : editbox;
+}

src/lib/hiro_gtk/editbox.h

@@ -0,0 +1,16 @@
+class pEditbox : public pFormControl {
+public:
+  Editbox &self;
+  void create(uint style, uint width, uint height, const char *text = "");
+  uint get_text(char *text, uint length = -1U);
+  void set_text(const char *text = "");
+
+  pEditbox(Editbox&);
+
+  /* internal */
+  GtkWidget *scrollbox;
+  GtkWidget *editbox;
+  GtkTextBuffer *buffer;
+  bool multiline;
+  GtkWidget* gtk_handle();
+};

src/lib/hiro_gtk/formcontrol.cpp

@@ -0,0 +1,32 @@
+void pFormControl::resize(uint width, uint height) {
+  gtk_widget_set_size_request(gtk_handle(), width, height);
+}
+
+void pFormControl::focus() {
+  gtk_widget_grab_focus(gtk_handle());
+}
+
+bool pFormControl::focused() {
+  return GTK_WIDGET_HAS_FOCUS(gtk_handle());
+}
+
+void pFormControl::enable(bool state) {
+  gtk_widget_set_sensitive(gtk_handle(), state);
+}
+
+void pFormControl::disable() {
+  enable(false);
+}
+
+bool pFormControl::enabled() {
+  return GTK_WIDGET_SENSITIVE(gtk_handle());
+}
+
+pFormControl::pFormControl(FormControl &self_) : pWidget(self_), self(self_) {
+}
+
+/* internal */
+
+GtkWidget* pFormControl::gtk_handle() {
+  return 0;
+}

src/lib/hiro_gtk/formcontrol.h

@@ -0,0 +1,15 @@
+class pFormControl : public pWidget {
+public:
+  virtual void resize(uint width, uint height);
+  void focus();
+  bool focused();
+  void enable(bool = true);
+  void disable();
+  bool enabled();
+
+  FormControl &self;
+  pFormControl(FormControl&);
+
+  /* internal */
+  virtual GtkWidget* gtk_handle();
+};

src/lib/hiro_gtk/frame.cpp

@@ -0,0 +1,19 @@
+void pFrame::create(uint style, uint width, uint height, const char *text) {
+  frame = gtk_frame_new(text ? text : "");
+  gtk_widget_set_size_request(frame, width, height);
+  gtk_widget_show(frame);
+}
+
+void pFrame::set_text(const char *text) {
+  gtk_frame_set_label(GTK_FRAME(frame), text ? text : "");
+}
+
+pFrame::pFrame(Frame &self_) : pFormControl(self_), self(self_) {
+  frame = 0;
+}
+
+/* internal */
+
+GtkWidget* pFrame::gtk_handle() {
+  return frame;
+}

src/lib/hiro_gtk/frame.h

@@ -0,0 +1,12 @@
+class pFrame : public pFormControl {
+public:
+  Frame &self;
+  void create(uint style, uint width, uint height, const char *text = "");
+  void set_text(const char *text = "");
+
+  pFrame(Frame&);
+
+  /* internal */
+  GtkWidget *frame;
+  GtkWidget* gtk_handle();
+};

src/lib/hiro_gtk/hiro.cpp

@@ -0,0 +1,121 @@
+#include "hiro.h"
+
+#include <nall/algorithm.hpp>
+using nall::min;
+using nall::max;
+
+namespace libhiro {
+
+#include "keymap.cpp"
+#include "widget.cpp"
+  #include "window.cpp"
+  #include "menucontrol.cpp"
+    #include "menugroup.cpp"
+    #include "menuitem.cpp"
+    #include "menucheckitem.cpp"
+    #include "menuradioitem.cpp"
+    #include "menuseparator.cpp"
+  #include "formcontrol.cpp"
+    #include "frame.cpp"
+    #include "canvas.cpp"
+    #include "label.cpp"
+    #include "button.cpp"
+    #include "checkbox.cpp"
+    #include "radiobox.cpp"
+    #include "editbox.cpp"
+    #include "listbox.cpp"
+    #include "combobox.cpp"
+    #include "progressbar.cpp"
+    #include "slider.cpp"
+
+void pHiro::init() {
+  //simulate passing argc, argv to gtk_init()
+  int argc = 1;
+  char **argv;
+  argv = (char**)malloc(1 * sizeof(char*));
+  argv[0] = (char*)malloc(64 * sizeof(char));
+  strcpy(argv[0], "./hiro");
+  gtk_init(&argc, &argv);
+  free(argv[0]);
+  free(argv);
+}
+
+void pHiro::term() {
+}
+
+bool pHiro::run() {
+  gtk_main_iteration_do(false);
+  return pending();
+}
+
+bool pHiro::pending() {
+  return gtk_events_pending();
+}
+
+bool pHiro::file_load(Window *focus, char *filename, const char *filter, const char *path) {
+  if(!filename) return false;
+  strcpy(filename, "");
+
+  GtkWidget *dialog = gtk_file_chooser_dialog_new("Load File",
+    focus ? GTK_WINDOW(focus->p.gtk_handle()) : (GtkWindow*)0,
+    GTK_FILE_CHOOSER_ACTION_OPEN,
+    GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
+    GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
+    (const gchar*)0);
+
+  if(path && *path) gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), path);
+
+  if(gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
+    char *fn = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
+    strcpy(filename, fn);
+    g_free(fn);
+  }
+
+  gtk_widget_destroy(dialog);
+  return strcmp(filename, ""); //return true if filename exists
+}
+
+bool pHiro::file_save(Window *focus, char *filename, const char *filter, const char *path) {
+  if(!filename) return false;
+  strcpy(filename, "");
+
+  GtkWidget *dialog = gtk_file_chooser_dialog_new("Save File",
+    focus ? GTK_WINDOW(focus->p.gtk_handle()) : (GtkWindow*)0,
+    GTK_FILE_CHOOSER_ACTION_SAVE,
+    GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
+    GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
+    (const gchar*)0);
+
+  if(path && *path) gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), path);
+  gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(dialog), TRUE);
+
+  if(gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
+    char *fn = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
+    strcpy(filename, fn);
+    g_free(fn);
+  }
+
+  gtk_widget_destroy(dialog);
+  return strcmp(filename, ""); //return true if filename exists
+}
+
+uint pHiro::screen_width() {
+  return gdk_screen_width();
+}
+
+uint pHiro::screen_height() {
+  return gdk_screen_height();
+}
+
+pHiro& pHiro::handle() {
+  return hiro().p;
+}
+
+pHiro::pHiro(Hiro &self_) : self(self_) {
+}
+
+pHiro& phiro() {
+  return pHiro::handle();
+}
+
+} //namespace libhiro

src/lib/hiro_gtk/hiro.h

@@ -0,0 +1,56 @@
+#ifndef HIRO_GTK_H
+#define HIRO_GTK_H
+
+#include <gtk/gtk.h>
+#include <gdk/gdkx.h>
+#include <gdk/gdkkeysyms.h>
+
+namespace libhiro {
+
+#include "widget.h"
+  #include "window.h"
+  #include "menucontrol.h"
+    #include "menugroup.h"
+    #include "menuitem.h"
+    #include "menucheckitem.h"
+    #include "menuradioitem.h"
+    #include "menuseparator.h"
+  #include "formcontrol.h"
+    #include "frame.h"
+    #include "canvas.h"
+    #include "label.h"
+    #include "button.h"
+    #include "checkbox.h"
+    #include "radiobox.h"
+    #include "editbox.h"
+    #include "listbox.h"
+    #include "combobox.h"
+    #include "progressbar.h"
+    #include "slider.h"
+
+class pHiro {
+public:
+  Hiro &self;
+  void init();
+  void term();
+  bool run();
+  bool pending();
+
+  bool file_load(Window *focus, char *filename, const char *filter, const char *path);
+  bool file_save(Window *focus, char *filename, const char *filter, const char *path);
+
+  uint screen_width();
+  uint screen_height();
+
+  static pHiro& handle();
+  pHiro(Hiro&);
+
+  /* internal */
+  uint16_t translate_key(uint key);
+};
+
+pHiro& phiro();
+
+} //namespace libhiro
+
+#endif //ifndef HIRO_GTK_H

src/lib/hiro_gtk/keymap.cpp

@@ -0,0 +1,188 @@
+uint16_t pHiro::translate_key(uint key) {
+  switch(key) {
+    case GDK_Escape: return keyboard::escape;
+
+    case GDK_F1:  return keyboard::f1;
+    case GDK_F2:  return keyboard::f2;
+    case GDK_F3:  return keyboard::f3;
+    case GDK_F4:  return keyboard::f4;
+    case GDK_F5:  return keyboard::f5;
+    case GDK_F6:  return keyboard::f6;
+    case GDK_F7:  return keyboard::f7;
+    case GDK_F8:  return keyboard::f8;
+    case GDK_F9:  return keyboard::f9;
+    case GDK_F10: return keyboard::f10;
+    case GDK_F11: return keyboard::f11;
+    case GDK_F12: return keyboard::f12;
+
+    case GDK_Print:       return keyboard::print_screen;
+    case GDK_Sys_Req:     return keyboard::print_screen;
+    case GDK_Scroll_Lock: return keyboard::scroll_lock;
+    case GDK_Pause:       return keyboard::pause;
+    case GDK_Break:       return keyboard::pause;
+
+    case GDK_grave:      return keyboard::tilde;
+    case GDK_asciitilde: return keyboard::tilde;
+
+    case GDK_1: return keyboard::num_1;
+    case GDK_2: return keyboard::num_2;
+    case GDK_3: return keyboard::num_3;
+    case GDK_4: return keyboard::num_4;
+    case GDK_5: return keyboard::num_5;
+    case GDK_6: return keyboard::num_6;
+    case GDK_7: return keyboard::num_7;
+    case GDK_8: return keyboard::num_8;
+    case GDK_9: return keyboard::num_9;
+    case GDK_0: return keyboard::num_0;
+
+    case GDK_exclam:      return keyboard::num_1;
+    case GDK_at:          return keyboard::num_2;
+    case GDK_numbersign:  return keyboard::num_3;
+    case GDK_dollar:      return keyboard::num_4;
+    case GDK_percent:     return keyboard::num_5;
+    case GDK_asciicircum: return keyboard::num_6;
+    case GDK_ampersand:   return keyboard::num_7;
+    case GDK_asterisk:    return keyboard::num_8;
+    case GDK_parenleft:   return keyboard::num_9;
+    case GDK_parenright:  return keyboard::num_0;
+
+    case GDK_minus:      return keyboard::dash;
+    case GDK_underscore: return keyboard::dash;
+    case GDK_equal:      return keyboard::equal;
+    case GDK_plus:       return keyboard::equal;
+    case GDK_BackSpace:  return keyboard::backspace;
+
+    case GDK_Insert:    return keyboard::insert;
+    case GDK_Delete:    return keyboard::delete_;
+    case GDK_Home:      return keyboard::home;
+    case GDK_End:       return keyboard::end;
+    case GDK_Page_Up:   return keyboard::page_up;
+    case GDK_Page_Down: return keyboard::page_down;
+
+    case GDK_a: return keyboard::a;
+    case GDK_b: return keyboard::b;
+    case GDK_c: return keyboard::c;
+    case GDK_d: return keyboard::d;
+    case GDK_e: return keyboard::e;
+    case GDK_f: return keyboard::f;
+    case GDK_g: return keyboard::g;
+    case GDK_h: return keyboard::h;
+    case GDK_i: return keyboard::i;
+    case GDK_j: return keyboard::j;
+    case GDK_k: return keyboard::k;
+    case GDK_l: return keyboard::l;
+    case GDK_m: return keyboard::m;
+    case GDK_n: return keyboard::n;
+    case GDK_o: return keyboard::o;
+    case GDK_p: return keyboard::p;
+    case GDK_q: return keyboard::q;
+    case GDK_r: return keyboard::r;
+    case GDK_s: return keyboard::s;
+    case GDK_t: return keyboard::t;
+    case GDK_u: return keyboard::u;
+    case GDK_v: return keyboard::v;
+    case GDK_w: return keyboard::w;
+    case GDK_x: return keyboard::x;
+    case GDK_y: return keyboard::y;
+    case GDK_z: return keyboard::z;
+
+    case GDK_A: return keyboard::a;
+    case GDK_B: return keyboard::b;
+    case GDK_C: return keyboard::c;
+    case GDK_D: return keyboard::d;
+    case GDK_E: return keyboard::e;
+    case GDK_F: return keyboard::f;
+    case GDK_G: return keyboard::g;
+    case GDK_H: return keyboard::h;
+    case GDK_I: return keyboard::i;
+    case GDK_J: return keyboard::j;
+    case GDK_K: return keyboard::k;
+    case GDK_L: return keyboard::l;
+    case GDK_M: return keyboard::m;
+    case GDK_N: return keyboard::n;
+    case GDK_O: return keyboard::o;
+    case GDK_P: return keyboard::p;
+    case GDK_Q: return keyboard::q;
+    case GDK_R: return keyboard::r;
+    case GDK_S: return keyboard::s;
+    case GDK_T: return keyboard::t;
+    case GDK_U: return keyboard::u;
+    case GDK_V: return keyboard::v;
+    case GDK_W: return keyboard::w;
+    case GDK_X: return keyboard::x;
+    case GDK_Y: return keyboard::y;
+    case GDK_Z: return keyboard::z;
+
+    case GDK_bracketleft:  return keyboard::lbracket;
+    case GDK_bracketright: return keyboard::rbracket;
+    case GDK_backslash:    return keyboard::backslash;
+    case GDK_semicolon:    return keyboard::semicolon;
+    case GDK_apostrophe:   return keyboard::apostrophe;
+    case GDK_comma:        return keyboard::comma;
+    case GDK_period:       return keyboard::period;
+    case GDK_slash:        return keyboard::slash;
+
+    case GDK_braceleft:  return keyboard::lbracket;
+    case GDK_braceright: return keyboard::rbracket;
+    case GDK_bar:        return keyboard::backslash;
+    case GDK_colon:      return keyboard::semicolon;
+    case GDK_quotedbl:   return keyboard::apostrophe;
+    case GDK_less:       return keyboard::comma;
+    case GDK_greater:    return keyboard::period;
+    case GDK_question:   return keyboard::slash;
+
+    case GDK_KP_1:       return keyboard::pad_1;
+    case GDK_KP_2:       return keyboard::pad_2;
+    case GDK_KP_3:       return keyboard::pad_3;
+    case GDK_KP_4:       return keyboard::pad_4;
+    case GDK_KP_5:       return keyboard::pad_5;
+    case GDK_KP_6:       return keyboard::pad_6;
+    case GDK_KP_7:       return keyboard::pad_7;
+    case GDK_KP_8:       return keyboard::pad_8;
+    case GDK_KP_9:       return keyboard::pad_9;
+    case GDK_KP_0:       return keyboard::pad_0;
+    case GDK_KP_Decimal: return keyboard::point;
+
+    case GDK_KP_End:       return keyboard::pad_1;
+    case GDK_KP_Down:      return keyboard::pad_2;
+    case GDK_KP_Page_Down: return keyboard::pad_3;
+    case GDK_KP_Left:      return keyboard::pad_4;
+    case GDK_KP_Begin:     return keyboard::pad_5;
+    case GDK_KP_Right:     return keyboard::pad_6;
+    case GDK_KP_Home:      return keyboard::pad_7;
+    case GDK_KP_Up:        return keyboard::pad_8;
+    case GDK_KP_Page_Up:   return keyboard::pad_9;
+    case GDK_KP_Insert:    return keyboard::pad_0;
+    case GDK_KP_Delete:    return keyboard::point;
+
+    case GDK_KP_Add:      return keyboard::add;
+    case GDK_KP_Subtract: return keyboard::subtract;
+    case GDK_KP_Multiply: return keyboard::multiply;
+    case GDK_KP_Divide:   return keyboard::divide;
+    case GDK_KP_Enter:    return keyboard::enter;
+
+    case GDK_Num_Lock:    return keyboard::num_lock;
+    case GDK_Caps_Lock:   return keyboard::caps_lock;
+
+    case GDK_Up:          return keyboard::up;
+    case GDK_Down:        return keyboard::down;
+    case GDK_Left:        return keyboard::left;
+    case GDK_Right:       return keyboard::right;
+
+    case GDK_Tab:         return keyboard::tab;
+    case GDK_Return:      return keyboard::return_;
+    case GDK_space:       return keyboard::spacebar;
+
+    case GDK_Control_L:   return keyboard::lctrl;
+    case GDK_Control_R:   return keyboard::rctrl;
+    case GDK_Alt_L:       return keyboard::lalt;
+    case GDK_Alt_R:       return keyboard::ralt;
+    case GDK_Shift_L:     return keyboard::lshift;
+    case GDK_Shift_R:     return keyboard::rshift;
+    case GDK_Super_L:     return keyboard::lsuper;
+    case GDK_Super_R:     return keyboard::rsuper;
+    case GDK_Menu:        return keyboard::menu;
+  }
+
+  return keyboard::none;
+}

src/lib/hiro_gtk/label.cpp

@@ -0,0 +1,21 @@
+void pLabel::create(uint style, uint width, uint height, const char *text) {
+  label = gtk_label_new(text ? text : "");
+  gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.0);
+  gtk_widget_set_size_request(label, width, height);
+  gtk_widget_show(label);
+}
+
+void pLabel::set_text(const char *text) {
+  if(!label) return;
+  gtk_label_set_label(GTK_LABEL(label), text ? text : "");
+}
+
+pLabel::pLabel(Label &self_) : pFormControl(self_), self(self_) {
+  label = 0;
+}
+
+/* internal */
+
+GtkWidget* pLabel::gtk_handle() {
+  return label;
+}

src/lib/hiro_gtk/label.h

@@ -0,0 +1,12 @@
+class pLabel : public pFormControl {
+public:
+  Label &self;
+  void create(uint style, uint width, uint height, const char *text = "");
+  void set_text(const char *text = "");
+
+  pLabel(Label&);
+
+  /* internal */
+  GtkWidget *label;
+  GtkWidget* gtk_handle();
+};