@@ -2,11 +2,6 @@ #!/bin/sh
 if [ $TRAVIS_OS_NAME = "osx" ]; then
 	brew update
 	brew install qt5 ffmpeg imagemagick sdl2 libzip libpng
-	if [ "$CC" == "gcc" ]; then
-		brew install gcc@5
-		export CC=gcc-5
-		export CXX=g++-5
-	fi
 else
 	sudo apt-get clean
 	sudo add-apt-repository -y ppa:george-edison55/cmake-3.x

@@ -7,8 +7,6 @@ dist: trusty
       compiler: gcc
     - os: osx
       compiler: clang
-    - os: osx
-      compiler: gcc
 
 before_install:
   - source ./.travis-deps.sh

@@ -28,6 +28,13 @@ - Super Game Boy support
  - Customizable autofire speed
  - Ability to set default Game Boy model
  - Map viewer
+ - Automatic cheat loading and saving
+ - GameShark and Action Replay button support
+ - AGBPrint support
+ - Debugger: Conditional breakpoints and watchpoints
+ - Ability to select GB/GBC/SGB BIOS on console ports
+ - Optional automatic state saving/loading
+ - Access to ur0 and uma0 partitions on the Vita
 Bugfixes:
  - GB Audio: Make audio unsigned with bias (fixes mgba.io/i/749)
  - GB Serialize: Fix audio state loading
@@ -36,6 +43,28 @@ - Qt: Fix GL display when loading a game from CLI (fixes mgba.io/i/843)
  - ARM: Fix MSR when T bit is set
  - GB Serialize: Fix game title check
  - GB: Revamp IRQ handling based on new information
+ - GBA Video: Don't mask out high bits of BLDY (fixes mgba.io/i/899)
+ - GBA Video: Force align 256-color tiles
+ - GBA DMA: ROM reads are forced to increment
+ - GB Video: Fix loading states while in mode 3
+ - GB Video: Only trigger STAT write IRQs when screen is on (fixes mgba.io/i/912)
+ - GBA Cheats: Fix PARv3 slide codes (fixes mgba.io/i/919)
+ - GBA Video: OBJWIN can change blend params after OBJ is drawn (fixes mgba.io/i/921)
+ - GBA DMA: Fix invalid DMA reads (fixes mgba.io/i/142)
+ - GBA Savedata: Fix crash when resizing flash
+ - GBA Video: Add delay when enabling BGs (fixes mgba.io/i/744, mgba.io/i/752)
+ - GB Memory: HDMAs should not start when LCD is off (fixes mgba.io/i/310)
+ - GBA Cheats: Fix slide codes not initializing properly
+ - Qt: Fix locale being set to English on settings save (fixes mgba.io/i/906)
+ - LR35902: Fix watchpoints not reporting new value
+ - GBA Audio: Increase PSG volume (fixes mgba.io/i/932)
+ - 3DS: Fix opening files in directory names with trailing slashes
+ - GB MBC: Fix MBC2 saves (fixes mgba.io/i/954)
+ - GBA Memory: Fix copy-on-write memory leak
+ - Core: Fix ROM patches not being unloaded when disabled (fixes mgba.io/i/962)
+ - GBA I/O: Fix writing to DISPCNT CGB flag (fixes mgba.io/i/902)
+ - GBA Memory: Partially revert prefetch changes (fixes mgba.io/i/840)
+ - PSP2: Fix issues causing poor audio
 Misc:
  - GBA Timer: Use global cycles for timers
  - GBA: Extend oddly-sized ROMs to full address space (fixes mgba.io/i/722)
@@ -44,6 +73,18 @@ - Qt: Redo GameController into multiple classes
  - Test: Restructure test suite into multiple executables
  - Python: Integrate tests from cinema test suite
  - Util: Don't build crc32 if the function already exists
+ - GBA: Implement display start DMAs
+ - Qt: Prevent window from being created off-screen
+ - Qt: Add option to disable FPS display
+ - GBA: Improve multiboot image detection
+ - GB MBC: Remove erroneous bank 0 wrapping
+ - GBA Cheats: Allow multiple ROM patches in the same slot
+ - GB: Skip BIOS option now works
+ - Libretro: Add frameskip option
+ - GBA Memory: 64 MiB GBA Video cartridge support
+ - 3DS: Scale font based on glyph heights (fixes mgba.io/i/961)
+ - PSP2: Use system enter key by default
+ - 3DS: Remove deprecated CSND interface
 
 0.6.1: (2017-10-01)
 Bugfixes:

@@ -2,7 +2,11 @@ cmake_minimum_required(VERSION 3.1)
 project(medusa)
 set(BINARY_NAME medusa-emu CACHE INTERNAL "Name of output binaries")
 if(NOT MSVC)
-	set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wextra -Wno-missing-field-initializers -std=c99")
+	set(GCC_STD "c99")
+	if(CMAKE_C_COMPILER_ID STREQUAL "GNU" AND CMAKE_COMPILER_VERSION VERSION_LESS "4.3")
+		set(GCC_STD "gnu99")
+	endif()
+	set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wextra -Wno-missing-field-initializers -std=${GCC_STD}")
 else()
 	set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D_CRT_SECURE_NO_WARNINGS /wd4003 /wd4244 /wd4146")
 endif()
@@ -40,6 +44,10 @@ set(BUILD_GL ON CACHE STRING "Build with OpenGL")
 set(BUILD_GLES2 OFF CACHE STRING "Build with OpenGL|ES 2")
 set(USE_EPOXY ON CACHE STRING "Build with libepoxy")
 set(DISABLE_DEPS OFF CACHE BOOL "Build without dependencies")
+if(WIN32)
+	set(WIN32_UNIX_PATHS OFF CACHE BOOL "Use Unix-like paths")
+	mark_as_advanced(WIN32_UNIX_PATHS)
+endif()
 file(GLOB ARM_SRC ${CMAKE_CURRENT_SOURCE_DIR}/src/arm/*.c)
 file(GLOB ARM_TEST_SRC ${CMAKE_CURRENT_SOURCE_DIR}/src/arm/test/*.c)
 file(GLOB LR35902_SRC ${CMAKE_CURRENT_SOURCE_DIR}/src/lr35902/*.c)
@@ -57,7 +65,7 @@ file(GLOB UTIL_SRC ${CMAKE_CURRENT_SOURCE_DIR}/src/util/*.[cSs])
 file(GLOB UTIL_TEST_SRC ${CMAKE_CURRENT_SOURCE_DIR}/src/util/test/*.c)
 file(GLOB GUI_SRC ${CMAKE_CURRENT_SOURCE_DIR}/src/util/gui/*.c ${CMAKE_CURRENT_SOURCE_DIR}/src/feature/gui/*.c)
 file(GLOB GBA_RENDERER_SRC ${CMAKE_CURRENT_SOURCE_DIR}/src/gba/renderers/*.c)
-file(GLOB GBA_SIO_SRC ${CMAKE_CURRENT_SOURCE_DIR}/src/gba/sio/lockstep.c)
+file(GLOB GBA_SIO_SRC ${CMAKE_CURRENT_SOURCE_DIR}/src/gba/sio/*.c)
 file(GLOB GBA_EXTRA_SRC ${CMAKE_CURRENT_SOURCE_DIR}/src/gba/extra/*.c)
 file(GLOB GB_SIO_SRC ${CMAKE_CURRENT_SOURCE_DIR}/src/gb/sio/*.c)
 file(GLOB GB_RENDERER_SRC ${CMAKE_CURRENT_SOURCE_DIR}/src/gb/renderers/*.c)
@@ -80,8 +88,16 @@ if(NOT CMAKE_BUILD_TYPE)
 	set(CMAKE_BUILD_TYPE Release CACHE STRING "Build type (e.g. Release or Debug)" FORCE)
 endif()
 
-include(GNUInstallDirs)
-string(REPLACE "${PROJECT_NAME}" "${BINARY_NAME}" CMAKE_INSTALL_DOCDIR "${CMAKE_INSTALL_DOCDIR}")
+if(NOT WIN32 OR WIN32_UNIX_PATHS)
+	include(GNUInstallDirs)
+	string(REPLACE "${PROJECT_NAME}" "${BINARY_NAME}" CMAKE_INSTALL_DOCDIR "${CMAKE_INSTALL_DOCDIR}")
+else()
+	set(CMAKE_INSTALL_LIBDIR ".")
+	set(CMAKE_INSTALL_BINDIR ".")
+	set(CMAKE_INSTALL_DATADIR ".")
+	set(CMAKE_INSTALL_DOCDIR ".")
+	set(CMAKE_INSTALL_INCLUDEDIR "include")
+endif()
 
 set(LIBDIR "${CMAKE_INSTALL_LIBDIR}" CACHE PATH "Installed library directory")
 mark_as_advanced(LIBDIR)
@@ -168,7 +184,7 @@ list(APPEND UTIL_SRC ${CMAKE_CURRENT_BINARY_DIR}/version.c)
 source_group("Generated sources" FILES ${CMAKE_CURRENT_BINARY_DIR}/version.c)
 
 # Advanced settings
-if(NOT DEFINED 3DS)
+if(NOT DEFINED 3DS AND NOT (CMAKE_C_COMPILER_ID STREQUAL "GNU" AND CMAKE_COMPILER_VERSION VERSION_LESS "4.5"))
 	# LTO appears to make 3DS binary slower
 	set(DEFAULT_LTO ON)
 else()
@@ -214,6 +230,7 @@ add_definitions(-D_GNU_SOURCE)
 	endif()
 	if(NOT APPLE AND NOT HAIKU)
 		set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -pthread")
+		set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pthread")
 	endif()
 
 	list(APPEND CORE_VFS_SRC ${CMAKE_CURRENT_SOURCE_DIR}/src/util/vfs/vfs-fd.c ${CMAKE_CURRENT_SOURCE_DIR}/src/util/vfs/vfs-dirent.c)
@@ -223,7 +240,9 @@ endif()
 
 if(APPLE)
 	add_definitions(-D_DARWIN_C_SOURCE)
-	set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -mmacosx-version-min=10.6")
+	if(CMAKE_SYSTEM_VERSION VERSION_GREATER "10.5.8")
+		set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -mmacosx-version-min=10.6")
+	endif()
 endif()
 
 if(NOT HAIKU AND NOT MSVC AND NOT PSP2)
@@ -414,6 +433,8 @@ ${CMAKE_CURRENT_SOURCE_DIR}/src/debugger/parser.c
 	${CMAKE_CURRENT_SOURCE_DIR}/src/debugger/symbols.c
 	${CMAKE_CURRENT_SOURCE_DIR}/src/debugger/cli-debugger.c)
 
+file(GLOB DEBUGGER_TEST_SRC ${CMAKE_CURRENT_SOURCE_DIR}/src/debugger/test/*.c)
+
 set(FEATURE_SRC)
 set(CPACK_DEBIAN_PACKAGE_DEPENDS "libc6")
 
@@ -520,6 +541,7 @@ include_directories(AFTER ${ZLIB_INCLUDE_DIRS})
 	list(APPEND DEPENDENCY_LIB ${ZLIB_LIBRARIES})
 	set(CPACK_DEBIAN_PACKAGE_DEPENDS "${CPACK_DEBIAN_PACKAGE_DEPENDS},zlib1g")
 	set(HAVE_CRC32 ON)
+	list(APPEND OS_LIB ${ZLIB_LIBRARIES})
 else()
 	# zlib pulls in crc32
 	check_function_exists(crc32 HAVE_CRC32)
@@ -596,7 +618,7 @@ endif()
 endif()
 
 if (USE_LZMA)
-	include_directories(AFTER ${CMAKE_CURRENT_SOURCE_DIR}/third-party/lzma)
+	include_directories(AFTER ${CMAKE_CURRENT_SOURCE_DIR}/src/third-party/lzma)
 	add_definitions(-D_7ZIP_PPMD_SUPPPORT)
 	list(APPEND VFS_SRC ${CMAKE_CURRENT_SOURCE_DIR}/src/util/vfs/vfs-lzma.c)
 	set(LZMA_SRC
@@ -710,6 +732,7 @@ endif()
 
 if(USE_DEBUGGERS)
 	list(APPEND FEATURE_SRC ${DEBUGGER_SRC})
+	list(APPEND TEST_SRC ${DEBUGGER_TEST_SRC})
 	list(APPEND FEATURES DEBUGGERS)
 endif()
 
@@ -850,7 +873,7 @@ if(BUILD_OPENEMU)
 	find_library(FOUNDATION Foundation)
 	find_library(OPENEMUBASE OpenEmuBase)
 	file(GLOB OE_SRC ${CMAKE_CURRENT_SOURCE_DIR}/src/platform/openemu/*.m)
-	add_library(${BINARY_NAME}-openemu MODULE ${CORE_SRC} ${OE_SRC})
+	add_library(${BINARY_NAME}-openemu MODULE ${CORE_SRC} ${OS_SRC})
 	set_target_properties(${BINARY_NAME}-openemu PROPERTIES
 		MACOSX_BUNDLE_INFO_PLIST ${CMAKE_CURRENT_SOURCE_DIR}/src/platform/openemu/Info.plist.in
 		BUNDLE TRUE
@@ -951,7 +974,8 @@ SET(CPACK_DEB_COMPONENT_INSTALL ON)
 
 set(CPACK_STRIP_FILES ${BINARY_NAME})
 
-install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/README.md ${CMAKE_CURRENT_SOURCE_DIR}/CHANGES DESTINATION ${CMAKE_INSTALL_DOCDIR} COMPONENT lib${BINARY_NAME})
+file(GLOB READMES ${CMAKE_CURRENT_SOURCE_DIR}/README*.md)
+install(FILES ${READMES} ${CMAKE_CURRENT_SOURCE_DIR}/CHANGES DESTINATION ${CMAKE_INSTALL_DOCDIR} COMPONENT lib${BINARY_NAME})
 
 include(CPack)
 

@@ -128,11 +128,11 @@ To build on Windows for development, using MSYS2 is recommended. Follow the installation steps found on their [website](https://msys2.github.io). Make sure you're running the 32-bit version ("MSYS2 MinGW 32-bit") (or the 64-bit version "MSYS2 MinGW 64-bit" if you want to build for x86_64) and run this additional command (including the braces) to install the needed dependencies (please note that this involves downloading over 500MiB of packages, so it will take a long time):
 
 For x86 (32 bit) builds:
 
-	pacman -Sy mingw-w64-i686-{cmake,ffmpeg,gcc,gdb,imagemagick,libzip,pkg-config,qt5,SDL2}
+	pacman -Sy mingw-w64-i686-{cmake,ffmpeg,gcc,gdb,imagemagick,libzip,pkg-config,qt5,SDL2,ntldd-git}
 
 For x86_64 (64 bit) builds:
 
-	pacman -Sy mingw-w64-x86_64-{cmake,ffmpeg,gcc,gdb,imagemagick,libzip,pkg-config,qt5,SDL2}
+	pacman -Sy mingw-w64-x86_64-{cmake,ffmpeg,gcc,gdb,imagemagick,libzip,pkg-config,qt5,SDL2,ntldd-git}
 
 Check out the source code by running this command:
 
@@ -146,7 +146,7 @@ cd build
 	cmake .. -G "MSYS Makefiles"
 	make
 
-Please note that this build of medusa for Windows is not suitable for distribution, due to the scattering of DLLs it needs to run, but is perfect for development. However, if distributing such a build is desired (e.g. for testing on machines that don't have the MSYS2 environment installed), a tool called "[Dependency Walker](http://dependencywalker.com)" can be used to see which additional DLL files need to be shipped with the medusa executable.
+Please note that this build of medusa for Windows is not suitable for distribution, due to the scattering of DLLs it needs to run, but is perfect for development. However, if distributing such a build is desired (e.g. for testing on machines that don't have the MSYS2 environment installed), running `cpack -G ZIP` will prepare a zip file with all of the necessary DLLs.
 
 ### Dependencies
 

@@ -0,0 +1,178 @@
+mGBA
+====
+
+mGBA ist ein Emulator für Game Boy Advance-Spiele. Das Ziel von mGBA ist, schneller und genauer als viele existierende Game Boy Advance-Emulatoren zu sein. Außerdem verfügt mGBA über Funktionen, die anderen Emulatoren fehlen. Zusätzlich werden auch Game Boy- und Game Boy Color-Spiele unterstützt.
+
+Aktuelle Neuigkeiten und Downloads findest Du auf [mgba.io](https://mgba.io).
+
+[![Build-Status](https://travis-ci.org/mgba-emu/mgba.svg?branch=master)](https://travis-ci.org/mgba-emu/mgba)
+
+Features
+--------
+
+- Nahzu vollständige Unterstützung der Game Boy Advance-Hardware[<sup>[1]</sup>](#missing).
+- Unterstützung der Game Boy-/Game Boy Color-Hardware.
+- Schnelle Emulation. mGBA ist dafür bekannt, auch auf schwacher Hardware wie Netbooks mit voller Geschwindigkeit zu laufen.
+- Qt- und SDL-Portierungen für eine vollwertige und eine "leichtgewichtige" Benutzeroberfläche.
+- Lokale (gleicher Computer) Unterstützung für Link-Kabel.
+- Erkennung des Speichertypes, einschließlich der Größe des Flash-Speichers[<sup>[2]</sup>](#flashdetect).
+- Unterstützung für Spielmodule mit Bewegungssensoren und Rüttel-Effekten (nur verwendbar mit Spiele-Controllern).
+- Unterstützung für Echtzeituhren, selbst ohne Konfiguration.
+- Unterstützung für Game Boy Printer und Game Boy Camera.
+- Eingebaute BIOS-Implementierung mit der Möglichkeit, externe BIOS-Dateien zu laden.
+- Turbo/Vorlauf-Unterstützung durch drücken der Tab-Taste.
+- Rücklauf-Unterstützung durch drücken der Akzent-Taste.
+- Frameskip von bis zu 10 Bildern.
+- Unterstützung für Screenshots.
+- Unterstützung für Cheat-Codes.
+- 9 Speicherstände für Savestates/Spielzustände. Savestates können auch als Screenshots dargestellt werden.
+- Video- und GIF-Aufzeichnung.
+- Frei wählbare Tastenbelegungen für Tastaturen und Controller.
+- Unterstützung für ZIP- und 7z-Archive.
+- Unterstützung für Patches im IPS-, UPS- und BPS-Format.
+- Spiele-Debugging über ein Kommandozeilen-Interface und IDA Pro-kompatible GDB-Unterstützung.
+- Einstellbare Rücklauf-Funktion.
+- Unterstützung für das Laden und Exportieren von GameShark- und Action Replay-Abbildern.
+- Verfügbare Cores für RetroArch/Libretro und OpenEmu.
+- Viele, viele kleinere Dinge.
+
+### Geplante Features
+
+- Unterstützung für Link-Kabel-Multiplayer über ein Netzwerk.
+- Unterstützung für Link-Kabel über Dolphin/JOY-Bus.
+- M4A-Audio-Abmischung für höhere Audio-Qualität.
+- Unterstützung für Tool-Assisted Speedruns.
+- Lua-Unterstützung für Scripting.
+- Eine umfangreiche Debugging-Suite.
+- e-Reader-Unterstützung.
+- Unterstützung für Drahtlosadapter.
+
+Unterstützte Plattformen
+------------------------
+
+- Windows Vista oder neuer
+- OS X 10.7 (Lion)[<sup>[3]</sup>](#osxver) oder neuer
+- Linux
+- FreeBSD
+- Nintendo 3DS
+- Wii
+- PlayStation Vita
+
+Andere Unix-ähnliche Plattformen wie OpenBSD sind ebenfalls dafür bekannt, mit mGBA kompatibel zu sein. Sie sind jedoch nicht getestet und werden nicht voll unterstützt.
+
+### Systemvoraussetzungen
+
+Die Systemvoraussetzungen sind minimal. Jeder Computer, der mit Windows Vista oder neuer läuft, sollte in der Lage sein, die Emulation zu bewältigen. Unterstützung für OpenGL 1.1 oder neuer ist ebenfalls voraussgesetzt.
+
+Downloads
+---------
+
+Download-Links befinden sich in der [Downloads][downloads]-Sektion auf der offizielle Website. Der Quellcode befindet sich auf [GitHub][source].
+
+Steuerung
+---------
+
+Die Steuerung kann im Einstellungs-Menü konfiguriert werden. Viele Spiele-Controller werden automatisch erkannt und entsprechend belegt. Für Tastaturen wird standardmäßig folgende Belegung verwendet:
+
+- **A**: X
+- **B**: Z
+- **L**: A
+- **R**: S
+- **Start**: Enter
+- **Select**: Rücktaste
+
+Kompilieren
+-----------
+
+Um mGBA kompilieren zu können, wird CMake 2.8.11 oder neuer benötigt. GCC und Clang sind beide dafür bekannt, mGBA kompilieren zu können. Visual Studio 2013 und älter funktionieren nicht. Unterstützung für Visual Studio 2015 und neuer wird bald hinzugefügt. Um CMake auf einem Unix-basierten System zu verwenden, werden folgende Kommandos empfohlen:
+
+	mkdir build
+	cd build
+	cmake -DCMAKE_INSTALL_PREFIX:PATH=/usr ..
+	make
+	sudo make install
+
+Damit wird mGBA gebaut und in `/usr/bin` und `/usr/lib` installiert. Installierte Abhängigkeiten werden automatisch erkannt. Features, die aufgrund fehlender Abhängigkeiten deaktiviert werden, werden nach dem `cmake`-Kommando aufgelistet.
+
+Wenn Du macOS verwendest, sind die einzelnen Schritte etwas anders. Angenommen, dass Du eine Homebrew-Paketverwaltung verwendest, werden folgende Schritte zum installieren der Abhängigkeiten und anschließenden bauen von mGBA empfohlen:
+
+	brew install cmake ffmpeg imagemagick libzip qt5 sdl2 libedit
+	mkdir build
+	cd build
+	cmake -DCMAKE_PREFIX_PATH='brew --prefix qt5' ..
+	make
+
+Bitte beachte, dass Du unter macOS nicht 'make install' verwenden solltest, da dies nicht korrekt funktionieren wird.
+
+### Für Entwickler: Kompilieren unter Windows
+
+Um mGBA auf Windows zu kompilieren, wird MSYS2 empfohlen. Befolge die Installationsschritte auf der [MSYS2-Website](https://msys2.github.io). Stelle sicher, dass Du die 32-Bit-Version ("MSYS2 MinGW 32-bit") (oder die 64-Bit-Version "MSYS2 MinGW 64-bit", wenn Du mGBA für x86_64 kompilieren willst) verwendest und führe folgendes Kommando (einschließlich der Klammern) aus, um alle benötigten Abhängigkeiten zu installieren. Bitte beachte, dass dafür über 500MiB an Paketen heruntergeladen werden, was eine Weile dauern kann):
+
+Für x86 (32 Bit):
+
+	pacman -Sy mingw-w64-i686-{cmake,ffmpeg,gcc,gdb,imagemagick,libzip,pkg-config,qt5,SDL2,ntldd-git}
+
+Für x86_64 (64 Bit):
+
+	pacman -Sy mingw-w64-x86_64-{cmake,ffmpeg,gcc,gdb,imagemagick,libzip,pkg-config,qt5,SDL2,ntldd-git}
+
+Lade den aktuellen mGBA-Quellcode mithilfe des folgenden Kommandos herunter:
+
+	git clone https://github.com/mgba-emu/mgba.git
+
+Abschließend wird mGBA über folgende Kommandos kompiliert:
+
+	cd mgba
+	mkdir build
+	cd build
+	cmake .. -G "MSYS Makefiles"
+	make
+
+Bitte beachte, dass mGBA für Windows aufgrund der Vielzahl an benötigten DLLs nicht für die weitere Verteilung geeignet ist, wenn es auf diese Weise gebaut wurde. Es ist jedoch perfekt für Entwickler geeignet. Soll mGBA dennoch weiter verteilt werden (beispielsweise zu Testzwecken auf Systemen, auf denen keine MSYS2-Umgebung installiert ist), kann mithilfe des Befehls 'cpack -G ZIP' ein ZIP-Archiv mit allen benötigten DLLs erstellt werden.
+
+### Abhängigkeiten
+
+mGBA hat keine "harten" Abhängigkeiten. Dennoch werden die folgenden optionalen Abhängigkeiten für einige Features benötigt. Diese Features werden automatisch deaktiviert, wenn die benötigten Abhängigkeiten nicht gefunden werden.
+
+- Qt 5: Für die Benutzeroberfläche. Qt Multimedia oder SDL werden für Audio-Ausgabe benötigt.
+- SDL: Für eine einfachere Benutzeroberfläche und Spiele-Controller-Unterstützung in der Qt-Oberfläche. SDL 2 ist empfohlen, SDL 1.2 wird jedoch auch unterstützt.
+- zlib und libpng: Für die Unterstützung von Bildschirmfotos und Savestates-in-PNG-Unterstützung.
+- libedit: Für die Unterstützung des Kommandozeilen-Debuggers.
+- ffmpeg oder libav: Für Videoaufzeichnungen.
+- libzip oder zlib: Um ROMs aus ZIP-Dateien zu laden.
+- ImageMagick: Für GIF-Aufzeichnungen.
+- SQLite3: Für Spiele-Datenbanken.
+- libelf: Für das Laden von ELF-Dateien.
+
+SQLite3, libpng und zlib werden mit dem Emulator mitgeliefert, sodass sie nicht zuerst kompiliert werden müssen.
+
+Fußnoten
+--------
+
+<a name="missing">[1]</a> Zurzeit fehlende Features sind
+
+- OBJ-Fenster für die Modi 3, 4 und 5 ([Bug #5](http://mgba.io/b/5))
+- Mosaik-Effekt für umgewandelte OBJs ([Bug #9](http://mgba.io/b/9))
+
+<a name="flashdetect">[2]</a> In manchen Fällen ist es nicht möglich, die Größe des Flash-Speichers automatisch zu ermitteln. Diese kann dann zur Laufzeit konfiguriert werden, es wird jedoch empfohlen, den Fehler zu melden.
+
+<a name="osxver">[3]</a> 10.7 wird nur für die Qt-Portierung benötigt. Die SDL-Portierung ist dafür bekannt, mit 10.5 und möglicherweise auf älteren Versionen zu funktionieren.
+
+[downloads]: http://mgba.io/downloads.html
+[source]: https://github.com/mgba-emu/mgba/
+
+Copyright
+---------
+
+Copyright für mGBA © 2013 – 2017 Jeffrey Pfau. mGBA wird unter der [Mozilla Public License version 2.0](https://www.mozilla.org/MPL/2.0/) veröffentlicht. Eine Kopie der Lizenz ist in der mitgelieferten Datei LICENSE verfügbar.
+
+mGBA beinhaltet die folgenden Bibliotheken von Drittanbietern:
+
+- [inih](https://github.com/benhoyt/inih), Copyright © 2009 Ben Hoyt, verwendet unter einer BSD 3-clause-Lizenz.
+- [blip-buf](https://code.google.com/archive/b/blip-buf), Copyright © 2003 - 2009 Shay Green, verwendet unter einer Lesser GNU Public License.
+- [LZMA SDK](http://www.7-zip.org/sdk.html), Public Domain.
+- [MurmurHash3](https://github.com/aappleby/smhasher), Implementierung von Austin Appleby, Public Domain.
+- [getopt fot MSVC](https://github.com/skandhurkat/Getopt-for-Visual-Studio/), Public Domain.
+- [SQLite3](https://www.sqlite.org), Public Domain.
+
+Wenn Du ein Spiele-Publisher bist und mGBA für kommerzielle Verwendung lizenzieren möchtest, schreibe bitte eine e-Mail an [licensing@mgba.io](mailto:licensing@mgba.io) für weitere Informationen.

@@ -0,0 +1,2 @@
+config:
+  gb.model: CGB

@@ -73,7 +73,7 @@ #ifndef M_PI
 #define M_PI 3.141592654f
 #endif
 
-#ifndef _MSC_VER
+#if !defined(_MSC_VER) && (defined(__llvm__) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7))
 #define ATOMIC_STORE(DST, SRC) __atomic_store_n(&DST, SRC, __ATOMIC_RELEASE)
 #define ATOMIC_LOAD(DST, SRC) DST = __atomic_load_n(&SRC, __ATOMIC_ACQUIRE)
 #define ATOMIC_ADD(DST, OP) __atomic_add_fetch(&DST, OP, __ATOMIC_RELEASE)
@@ -101,6 +101,8 @@ #else
 #define PRIz "z"
 #endif
 
+#if defined __BIG_ENDIAN__
+#define LOAD_32BE(DEST, ADDR, ARR) DEST = *(uint32_t*) ((uintptr_t) (ARR) + (size_t) (ADDR))
 #if defined(__PPC__) || defined(__POWERPC__)
 #define LOAD_32LE(DEST, ADDR, ARR) { \
 	uint32_t _addr = (ADDR); \
@@ -126,10 +128,39 @@ void* _ptr = (ARR); \
 	__asm__("sthbrx %0, %1, %2" : : "r"(SRC), "b"(_ptr), "r"(_addr)); \
 }
 
-#define LOAD_64LE(DEST, ADDR, ARR) DEST = __builtin_bswap64(((uint64_t*) ARR)[(ADDR) >> 3])
-#define STORE_64LE(SRC, ADDR, ARR) ((uint64_t*) ARR)[(ADDR) >> 3] = __builtin_bswap64(SRC)
-#elif defined __BIG_ENDIAN__
-#if defined(__llvm__) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)
+#define LOAD_64LE(DEST, ADDR, ARR) { \
+	uint32_t _addr = (ADDR); \
+	union { \
+		struct { \
+			uint32_t hi; \
+			uint32_t lo; \
+		}; \
+		uint64_t b64; \
+	} *bswap = (void*) &DEST; \
+	const void* _ptr = (ARR); \
+	__asm__( \
+		"lwbrx %0, %2, %3 \n" \
+		"lwbrx %1, %2, %4 \n" \
+		: "=r"(bswap->lo), "=r"(bswap->hi) : "b"(_ptr), "r"(_addr), "r"(_addr + 4)); \
+}
+
+#define STORE_64LE(SRC, ADDR, ARR) { \
+	uint32_t _addr = (ADDR); \
+	union { \
+		struct { \
+			uint32_t hi; \
+			uint32_t lo; \
+		}; \
+		uint64_t b64; \
+	} *bswap = (void*) &SRC; \
+	const void* _ptr = (ARR); \
+	__asm__( \
+		"stwbrx %0, %2, %3 \n" \
+		"stwbrx %1, %2, %4 \n" \
+		: : "r"(bswap->hi), "r"(bswap->lo), "b"(_ptr), "r"(_addr), "r"(_addr + 4)); \
+}
+
+#elif defined(__llvm__) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)
 #define LOAD_64LE(DEST, ADDR, ARR) DEST = __builtin_bswap64(((uint64_t*) ARR)[(ADDR) >> 3])
 #define LOAD_32LE(DEST, ADDR, ARR) DEST = __builtin_bswap32(((uint32_t*) ARR)[(ADDR) >> 2])
 #define LOAD_16LE(DEST, ADDR, ARR) DEST = __builtin_bswap16(((uint16_t*) ARR)[(ADDR) >> 1])
@@ -146,6 +177,7 @@ #define LOAD_16LE(DEST, ADDR, ARR) DEST = *(uint16_t*) ((uintptr_t) (ARR) + (size_t) (ADDR))
 #define STORE_64LE(SRC, ADDR, ARR) *(uint64_t*) ((uintptr_t) (ARR) + (size_t) (ADDR)) = SRC
 #define STORE_32LE(SRC, ADDR, ARR) *(uint32_t*) ((uintptr_t) (ARR) + (size_t) (ADDR)) = SRC
 #define STORE_16LE(SRC, ADDR, ARR) *(uint16_t*) ((uintptr_t) (ARR) + (size_t) (ADDR)) = SRC
+#define LOAD_32BE(DEST, ADDR, ARR) DEST = __builtin_bswap32(((uint32_t*) ARR)[(ADDR) >> 2])
 #endif
 
 #define MAKE_MASK(START, END) (((1 << ((END) - (START))) - 1) << (START))

@@ -11,18 +11,9 @@
 #include <3ds.h>
 #include <malloc.h>
 
-#ifdef _3DS
-// ctrulib already has a type called Thread
-#define Thread CustomThread
-#endif
-
 #define THREAD_ENTRY void
 typedef ThreadFunc ThreadEntry;
 
-typedef struct {
-	Handle handle;
-	u8* stack;
-} Thread;
 typedef LightLock Mutex;
 typedef struct {
 	Mutex mutex;
@@ -103,22 +94,12 @@ static inline int ThreadCreate(Thread* thread, ThreadEntry entry, void* context) {
 	if (!entry || !thread) {
 		return 1;
 	}
-	thread->stack = memalign(8, 0x8000);
-	if (!thread->stack) {
-		return 1;
-	}
-	bool isNew3DS;
-	APT_CheckNew3DS(&isNew3DS);
-	if (isNew3DS && svcCreateThread(&thread->handle, entry, (u32) context, (u32*) &thread->stack[0x8000], 0x18, 2) == 0) {
-		return 0;
-	}
-	return svcCreateThread(&thread->handle, entry, (u32) context, (u32*) &thread->stack[0x8000], 0x18, -1);
+	*thread = threadCreate(entry, context, 0x8000, 0x18, 2, true);
+	return !*thread;
 }
 
 static inline int ThreadJoin(Thread thread) {
-	svcWaitSynchronization(thread.handle, U64_MAX);
-	free(thread.stack);
-	return 0;
+	return threadJoin(thread, U64_MAX);
 }
 
 static inline void ThreadSetName(const char* name) {

@@ -86,7 +86,12 @@ }
 
 static inline int ThreadSetName(const char* name) {
 #ifdef __APPLE__
+#if __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 1060
 	return pthread_setname_np(name);
+#else
+	UNUSED(name);
+	return 0;
+#endif
 #elif defined(__FreeBSD__) || defined(__OpenBSD__)
 	pthread_set_name_np(pthread_self(), name);
 	return 0;

@@ -10,6 +10,10 @@ #include <mgba-util/common.h>
 
 CXX_GUARD_START
 
+#ifdef vector
+#undef vector
+#endif
+
 #define DECLARE_VECTOR(NAME, TYPE) \
 	struct NAME { \
 		TYPE* vector; \

@@ -87,7 +87,7 @@ #ifdef USE_LZMA
 struct VDir* VDirOpen7z(const char* path, int flags);
 #endif
 
-#if defined(__wii__) || defined(_3DS)
+#if defined(__wii__) || defined(_3DS) || defined(PSP2)
 struct VDir* VDeviceList(void);
 #endif
 

@@ -14,8 +14,6 @@ #include <mgba/core/cpu.h>
 #include <mgba/core/log.h>
 #include <mgba-util/vector.h>
 
-#define MAX_ROM_PATCHES 4
-
 enum mCheatType {
 	CHEAT_ASSIGN,
 	CHEAT_ASSIGN_INDIRECT,
@@ -30,7 +28,8 @@ CHEAT_IF_ULT,
 	CHEAT_IF_UGT,
 	CHEAT_IF_AND,
 	CHEAT_IF_LAND,
-	CHEAT_IF_NAND
+	CHEAT_IF_NAND,
+	CHEAT_IF_BUTTON,
 };
 
 struct mCheat {
@@ -79,6 +78,8 @@
 	struct mCheatSet* (*createSet)(struct mCheatDevice*, const char* name);
 
 	struct mCheatSets cheats;
+	bool autosave;
+	bool buttonDown;
 };
 
 struct VFile;
@@ -99,7 +100,12 @@
 bool mCheatParseFile(struct mCheatDevice*, struct VFile*);
 bool mCheatSaveFile(struct mCheatDevice*, struct VFile*);
 
+#if !defined(MINIMAL_CORE) || MINIMAL_CORE < 2
+void mCheatAutosave(struct mCheatDevice*);
+#endif
+
 void mCheatRefresh(struct mCheatDevice*, struct mCheatSet*);
+void mCheatPressButton(struct mCheatDevice*, bool down);
 
 CXX_GUARD_END
 

@@ -51,6 +51,7 @@ char* savegamePath;
 	char* savestatePath;
 	char* screenshotPath;
 	char* patchPath;
+	char* cheatsPath;
 
 	int volume;
 	bool mute;

@@ -148,6 +148,7 @@ void (*attachDebugger)(struct mCore*, struct mDebugger*);
 	void (*detachDebugger)(struct mCore*);
 
 	void (*loadSymbols)(struct mCore*, struct VFile*);
+	bool (*lookupIdentifier)(struct mCore*, const char* name, int32_t* value, int* segment);
 #endif
 
 	struct mCheatDevice* (*cheatDevice)(struct mCore*);
@@ -175,6 +176,7 @@ bool mCorePreloadFile(struct mCore* core, const char* path);
 
 bool mCoreAutoloadSave(struct mCore* core);
 bool mCoreAutoloadPatch(struct mCore* core);
+bool mCoreAutoloadCheats(struct mCore* core);
 
 bool mCoreSaveState(struct mCore* core, int slot, int flags);
 bool mCoreLoadState(struct mCore* core, int slot, int flags);

@@ -21,6 +21,7 @@ struct VDir* save;
 	struct VDir* patch;
 	struct VDir* state;
 	struct VDir* screenshot;
+	struct VDir* cheats;
 };
 
 void mDirectorySetInit(struct mDirectorySet* dirs);

@@ -13,29 +13,38 @@
 #include <mgba-util/vector.h>
 
 enum mCoreMemorySearchType {
-	mCORE_MEMORY_SEARCH_32,
-	mCORE_MEMORY_SEARCH_16,
-	mCORE_MEMORY_SEARCH_8,
+	mCORE_MEMORY_SEARCH_INT,
 	mCORE_MEMORY_SEARCH_STRING,
 	mCORE_MEMORY_SEARCH_GUESS,
 };
 
+enum mCoreMemorySearchOp {
+	mCORE_MEMORY_SEARCH_EQUAL,
+	mCORE_MEMORY_SEARCH_GREATER,
+	mCORE_MEMORY_SEARCH_LESS,
+	mCORE_MEMORY_SEARCH_DELTA,
+};
+
 struct mCoreMemorySearchParams {
 	int memoryFlags;
 	enum mCoreMemorySearchType type;
+	enum mCoreMemorySearchOp op;
+	int align;
+	int width;
 	union {
 		const char* valueStr;
-		uint32_t value32;
-		uint32_t value16;
-		uint32_t value8;
+		int32_t valueInt;
 	};
 };
 
 struct mCoreMemorySearchResult {
 	uint32_t address;
 	int segment;
-	uint64_t guessDivisor;
+	uint32_t guessDivisor;
+	uint32_t guessMultiplier;
 	enum mCoreMemorySearchType type;
+	int width;
+	int32_t oldValue;
 };
 
 DECLARE_VECTOR(mCoreMemorySearchResults, struct mCoreMemorySearchResult);

@@ -60,16 +60,17 @@ uint32_t oldValue;
 			uint32_t newValue;
 			enum mWatchpointType watchType;
 			enum mWatchpointType accessType;
-		};
+		} wp;
 
 		struct {
 			uint32_t opcode;
 			enum mBreakpointType breakType;
-		};
-	};
+		} bp;
+	} type;
 };
 
 struct mDebugger;
+struct ParseTree;
 struct mDebuggerPlatform {
 	struct mDebugger* p;
 
@@ -79,14 +80,19 @@ void (*entered)(struct mDebuggerPlatform*, enum mDebuggerEntryReason, struct mDebuggerEntryInfo*);
 
 	bool (*hasBreakpoints)(struct mDebuggerPlatform*);
 	void (*setBreakpoint)(struct mDebuggerPlatform*, uint32_t address, int segment);
+	void (*setConditionalBreakpoint)(struct mDebuggerPlatform*, uint32_t address, int segment, struct ParseTree* condition);
 	void (*clearBreakpoint)(struct mDebuggerPlatform*, uint32_t address, int segment);
 	void (*setWatchpoint)(struct mDebuggerPlatform*, uint32_t address, int segment, enum mWatchpointType type);
+	void (*setConditionalWatchpoint)(struct mDebuggerPlatform*, uint32_t address, int segment, enum mWatchpointType type, struct ParseTree* condition);
 	void (*clearWatchpoint)(struct mDebuggerPlatform*, uint32_t address, int segment);
 	void (*checkBreakpoints)(struct mDebuggerPlatform*);
 	void (*trace)(struct mDebuggerPlatform*, char* out, size_t* length);
+
+	bool (*getRegister)(struct mDebuggerPlatform*, const char* name, int32_t* value);
+	bool (*setRegister)(struct mDebuggerPlatform*, const char* name, int32_t value);
+	bool (*lookupIdentifier)(struct mDebuggerPlatform*, const char* name, int32_t* value, int* segment);
 };
 
-struct mDebuggerSymbols;
 struct mDebugger {
 	struct mCPUComponent d;
 	struct mDebuggerPlatform* platform;
@@ -108,6 +114,8 @@ void mDebuggerAttach(struct mDebugger*, struct mCore*);
 void mDebuggerRun(struct mDebugger*);
 void mDebuggerRunFrame(struct mDebugger*);
 void mDebuggerEnter(struct mDebugger*, enum mDebuggerEntryReason, struct mDebuggerEntryInfo*);
+
+bool mDebuggerLookupIdentifier(struct mDebugger* debugger, const char* name, int32_t* value, int* segment);
 
 CXX_GUARD_END
 

@@ -21,6 +21,13 @@ SIO_GPIO = 8,
 	SIO_JOYBUS = 12
 };
 
+enum GBASIOJOYCommand {
+	JOY_RESET = 0xFF,
+	JOY_POLL = 0x00,
+	JOY_TRANS = 0x14,
+	JOY_RECV = 0x15
+};
+
 struct GBA;
 struct GBAAudio;
 struct GBASIO;
@@ -47,6 +54,10 @@ bool (*load)(struct GBASIODriver* driver);
 	bool (*unload)(struct GBASIODriver* driver);
 	uint16_t (*writeRegister)(struct GBASIODriver* driver, uint32_t address, uint16_t value);
 };
+
+void GBASIOJOYCreate(struct GBASIODriver* sio);
+int GBASIOJOYSendCommand(struct GBASIODriver* sio, enum GBASIOJOYCommand command, uint8_t* data);
+
 
 CXX_GUARD_END
 

@@ -15,8 +15,10 @@
 #include <mgba/internal/arm/arm.h>
 #include <mgba-util/vector.h>
 
+struct ParseTree;
 struct ARMDebugBreakpoint {
 	uint32_t address;
+	struct ParseTree* condition;
 	bool isSw;
 	struct {
 		uint32_t opcode;
@@ -27,6 +29,7 @@
 struct ARMDebugWatchpoint {
 	uint32_t address;
 	enum mWatchpointType type;
+	struct ParseTree* condition;
 };
 
 DECLARE_VECTOR(ARMDebugBreakpointList, struct ARMDebugBreakpoint);

@@ -14,6 +14,7 @@ #include <mgba/debugger/debugger.h>
 
 extern const char* ERROR_MISSING_ARGS;
 extern const char* ERROR_OVERFLOW;
+extern const char* ERROR_INVALID_ARGS;
 
 struct CLIDebugger;
 
@@ -24,22 +25,17 @@ CLIDV_ERROR_TYPE,
 		CLIDV_INT_TYPE,
 		CLIDV_CHAR_TYPE,
 	} type;
-	union {
-		char* charValue;
-		struct {
-			int32_t intValue;
-			int segmentValue;
-		};
-	};
+	char* charValue;
+	int32_t intValue;
+	int segmentValue;
 };
 
 typedef void (*CLIDebuggerCommand)(struct CLIDebugger*, struct CLIDebugVector*);
-typedef struct CLIDebugVector* (*CLIDVParser)(struct CLIDebugger* debugger, const char* string, size_t length);
 
 struct CLIDebuggerCommandSummary {
 	const char* name;
 	CLIDebuggerCommand command;
-	CLIDVParser parser;
+	const char* format;
 	const char* summary;
 };
 
@@ -51,8 +47,6 @@ void (*deinit)(struct CLIDebuggerSystem*);
 	bool (*custom)(struct CLIDebuggerSystem*);
 
 	void (*disassemble)(struct CLIDebuggerSystem*, struct CLIDebugVector* dv);
-	uint32_t (*lookupIdentifier)(struct CLIDebuggerSystem*, const char* name, struct CLIDebugVector* dv);
-	uint32_t (*lookupPlatformIdentifier)(struct CLIDebuggerSystem*, const char* name, struct CLIDebugVector* dv);
 	void (*printStatus)(struct CLIDebuggerSystem*);
 
 	struct CLIDebuggerCommandSummary* commands;
@@ -81,9 +75,6 @@
 	struct CLIDebuggerSystem* system;
 	struct CLIDebuggerBackend* backend;
 };
-
-struct CLIDebugVector* CLIDVParse(struct CLIDebugger* debugger, const char* string, size_t length);
-struct CLIDebugVector* CLIDVStringParse(struct CLIDebugger* debugger, const char* string, size_t length);
 
 void CLIDebuggerCreate(struct CLIDebugger*);
 void CLIDebuggerAttachSystem(struct CLIDebugger*, struct CLIDebuggerSystem*);

@@ -8,27 +8,36 @@ #define PARSER_H
 
 #include <mgba-util/common.h>
 
+#include <mgba-util/vector.h>
+
 CXX_GUARD_START
 
-#include <mgba/debugger/debugger.h>
-
-enum LexState {
-	LEX_ERROR = -1,
-	LEX_ROOT = 0,
-	LEX_EXPECT_IDENTIFIER,
-	LEX_EXPECT_BINARY,
-	LEX_EXPECT_DECIMAL,
-	LEX_EXPECT_HEX,
-	LEX_EXPECT_PREFIX,
-	LEX_EXPECT_OPERATOR
-};
+struct Token;
+DECLARE_VECTOR(LexVector, struct Token);
 
 enum Operation {
 	OP_ASSIGN,
 	OP_ADD,
 	OP_SUBTRACT,
 	OP_MULTIPLY,
-	OP_DIVIDE
+	OP_DIVIDE,
+	OP_MODULO,
+	OP_AND,
+	OP_OR,
+	OP_XOR,
+	OP_LESS,
+	OP_GREATER,
+	OP_EQUAL,
+	OP_NOT_EQUAL,
+	OP_LOGICAL_AND,
+	OP_LOGICAL_OR,
+	OP_LE,
+	OP_GE,
+	OP_NEGATE,
+	OP_FLIP,
+	OP_NOT,
+	OP_SHIFT_L,
+	OP_SHIFT_R,
 };
 
 struct Token {
@@ -48,22 +57,20 @@ enum Operation operatorValue;
 	};
 };
 
-struct LexVector {
-	struct LexVector* next;
-	struct Token token;
-};
-
 struct ParseTree {
 	struct Token token;
 	struct ParseTree* lhs;
 	struct ParseTree* rhs;
 };
 
-size_t lexExpression(struct LexVector* lv, const char* string, size_t length);
+size_t lexExpression(struct LexVector* lv, const char* string, size_t length, const char* eol);
 void parseLexedExpression(struct ParseTree* tree, struct LexVector* lv);
 
 void lexFree(struct LexVector* lv);
 void parseFree(struct ParseTree* tree);
+
+struct mDebugger;
+bool mDebuggerEvaluateParseTree(struct mDebugger* debugger, struct ParseTree* tree, int32_t* value, int* segment);
 
 CXX_GUARD_END
 

@@ -145,6 +145,8 @@ void GBCreate(struct GB* gb);
 void GBDestroy(struct GB* gb);
 
 void GBReset(struct LR35902Core* cpu);
+void GBSkipBIOS(struct GB* gb);
+void GBUnmapBIOS(struct GB* gb);
 void GBDetectModel(struct GB* gb);
 
 void GBUpdateIRQs(struct GB* gb);

@@ -84,6 +84,7 @@ REG_WY = 0x4A,
 	REG_WX = 0x4B,
 
 	// CGB
+	REG_UNK4C = 0x4C,
 	REG_KEY1 = 0x4D,
 	REG_VBK = 0x4F,
 	REG_HDMA1 = 0x51,
@@ -101,8 +102,8 @@ REG_SVBK = 0x70,
 	REG_UNK72 = 0x72,
 	REG_UNK73 = 0x73,
 	REG_UNK74 = 0x74,
-	REG_UNK75 = 0x75,
-	REG_UNK76 = 0x76,
+	REG_PCM12 = 0x75,
+	REG_PCM34 = 0x76,
 	REG_UNK77 = 0x77,
 	REG_MAX = 0x100
 };

@@ -207,7 +207,7 @@
 uint8_t GBView8(struct LR35902Core* cpu, uint16_t address, int segment);
 
 void GBMemoryDMA(struct GB* gb, uint16_t base);
-void GBMemoryWriteHDMA5(struct GB* gb, uint8_t value);
+uint8_t GBMemoryWriteHDMA5(struct GB* gb, uint8_t value);
 
 void GBPatch8(struct LR35902Core* cpu, uint16_t address, int8_t value, int8_t* old, int segment);
 

@@ -32,6 +32,8 @@ uint8_t scx;
 	uint8_t wy;
 	uint8_t wx;
 	uint8_t currentWy;
+	int lastY;
+	bool hasWindow;
 
 	GBRegisterLCDC lcdc;
 	enum GBModel model;
@@ -43,6 +45,9 @@ int sgbPacketId;
 	int sgbDataSets;
 	uint8_t sgbPartialDataSet[15];
 	bool sgbBorders;
+	int sgbAttrX;
+	int sgbAttrY;
+	int sgbAttrDirection;
 };
 
 void GBVideoSoftwareRendererCreate(struct GBVideoSoftwareRenderer*);

@@ -169,7 +169,9 @@ * | 0x0C7DB: Current bit count
  * | 0x0C7DC - 0x0C7DF: Flags
  *   | bits 0 - 1: Current P1 bits
  *   | bits 2 - 3: Current render mode
- *   | bits 4 - 31: Reserved (leave 0)
+ *   | bit 4: Is a mode event not scheduled?
+ *   | bit 5: Is a frame event not scheduled?
+ *   | bits 6 - 31: Reserved (leave 0)
  * | 0x0C7E0 - 0x0C7EF: Current packet
  * | 0x0C7F0 - 0x0C7FF: Reserved
  * | 0x0C800 - 0x0E7FF: Character VRAM

@@ -159,7 +159,7 @@ void GBVideoInit(struct GBVideo* video);
 void GBVideoReset(struct GBVideo* video);
 void GBVideoDeinit(struct GBVideo* video);
 void GBVideoAssociateRenderer(struct GBVideo* video, struct GBVideoRenderer* renderer);
-void GBVideoProcessDots(struct GBVideo* video);
+void GBVideoProcessDots(struct GBVideo* video, uint32_t cyclesLate);
 
 void GBVideoWriteLCDC(struct GBVideo* video, GBRegisterLCDC value);
 void GBVideoWriteSTAT(struct GBVideo* video, GBRegisterSTAT value);

@@ -13,7 +13,7 @@
 #include <mgba/internal/arm/arm.h>
 #include <mgba/core/cheats.h>
 
-#define MAX_ROM_PATCHES 4
+#define MAX_ROM_PATCHES 10
 #define COMPLETE ((size_t) -1)
 
 enum GBACheatType {
@@ -63,7 +63,7 @@ PAR3_COND_LT = 0x18000000,
 	PAR3_COND_GT = 0x20000000,
 	PAR3_COND_ULT = 0x28000000,
 	PAR3_COND_UGT = 0x30000000,
-	PAR3_COND_LAND = 0x38000000,
+	PAR3_COND_AND = 0x38000000,
 };
 
 enum GBAActionReplay3Width {

@@ -10,18 +10,18 @@ #include <mgba-util/common.h>
 
 CXX_GUARD_START
 
-enum DMAControl {
-	DMA_INCREMENT = 0,
-	DMA_DECREMENT = 1,
-	DMA_FIXED = 2,
-	DMA_INCREMENT_RELOAD = 3
+enum GBADMAControl {
+	GBA_DMA_INCREMENT = 0,
+	GBA_DMA_DECREMENT = 1,
+	GBA_DMA_FIXED = 2,
+	GBA_DMA_INCREMENT_RELOAD = 3
 };
 
-enum DMATiming {
-	DMA_TIMING_NOW = 0,
-	DMA_TIMING_VBLANK = 1,
-	DMA_TIMING_HBLANK = 2,
-	DMA_TIMING_CUSTOM = 3
+enum GBADMATiming {
+	GBA_DMA_TIMING_NOW = 0,
+	GBA_DMA_TIMING_VBLANK = 1,
+	GBA_DMA_TIMING_HBLANK = 2,
+	GBA_DMA_TIMING_CUSTOM = 3
 };
 
 DECL_BITFIELD(GBADMARegister, uint16_t);
@@ -59,6 +59,7 @@ struct GBADMA;
 void GBADMASchedule(struct GBA* gba, int number, struct GBADMA* info);
 void GBADMARunHblank(struct GBA* gba, int32_t cycles);
 void GBADMARunVblank(struct GBA* gba, int32_t cycles);
+void GBADMARunDisplayStart(struct GBA* gba, int32_t cycles);
 void GBADMAUpdate(struct GBA* gba);
 
 CXX_GUARD_END

@@ -0,0 +1,28 @@
+/* Copyright (c) 2013-2018 Jeffrey Pfau
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+#ifndef GBA_MATRIX_H
+#define GBA_MATRIX_H
+
+#include <mgba-util/common.h>
+
+CXX_GUARD_START
+
+struct GBAMatrix {
+	uint32_t cmd;
+	uint32_t paddr;
+	uint32_t vaddr;
+	uint32_t size;
+};
+
+struct GBA;
+struct GBAMemory;
+void GBAMatrixReset(struct GBA*);
+void GBAMatrixWrite(struct GBA*, uint32_t address, uint32_t value);
+void GBAMatrixWrite16(struct GBA*, uint32_t address, uint16_t value);
+
+CXX_GUARD_END
+
+#endif

@@ -17,6 +17,7 @@ #include <mgba/internal/gba/dma.h>
 #include <mgba/internal/gba/hardware.h>
 #include <mgba/internal/gba/savedata.h>
 #include <mgba/internal/gba/vfame.h>
+#include <mgba/internal/gba/matrix.h>
 
 mLOG_DECLARE_CATEGORY(GBA_MEM);
 
@@ -71,7 +72,9 @@ SIZE_CART_SRAM = 0x00008000,
 	SIZE_CART_FLASH512 = 0x00010000,
 	SIZE_CART_FLASH1M = 0x00020000,
 	SIZE_CART_EEPROM = 0x00002000,
-	SIZE_CART_EEPROM512 = 0x00000200
+	SIZE_CART_EEPROM512 = 0x00000200,
+
+	SIZE_AGB_PRINT = 0x10000
 };
 
 enum {
@@ -79,6 +82,21 @@ OFFSET_MASK = 0x00FFFFFF,
 	BASE_OFFSET = 24
 };
 
+enum {
+	AGB_PRINT_BASE = 0x00FD0000,
+	AGB_PRINT_TOP = 0x00FE0000,
+	AGB_PRINT_PROTECT = 0x00FE2FFE,
+	AGB_PRINT_STRUCT = 0x01FE20F8,
+	AGB_PRINT_FLUSH_ADDR = 0x01FE209C,
+};
+
+struct GBAPrintContext {
+	uint16_t request;
+	uint16_t bank;
+	uint16_t get;
+	uint16_t put;
+};
+
 struct GBAMemory {
 	uint32_t* bios;
 	uint32_t* wram;
@@ -89,6 +107,7 @@
 	struct GBACartridgeHardware hw;
 	struct GBASavedata savedata;
 	struct GBAVFameCart vfame;
+	struct GBAMatrix matrix;
 	size_t romSize;
 	uint32_t romMask;
 	uint16_t romID;
@@ -106,6 +125,11 @@
 	struct GBADMA dma[4];
 	struct mTimingEvent dmaEvent;
 	int activeDMA;
+	uint32_t dmaTransferRegister;
+
+	uint16_t agbPrint;
+	struct GBAPrintContext agbPrintCtx;
+	uint16_t* agbPrintBuffer;
 
 	bool mirroring;
 };
@@ -144,6 +168,8 @@
 struct GBASerializedState;
 void GBAMemorySerialize(const struct GBAMemory* memory, struct GBASerializedState* state);
 void GBAMemoryDeserialize(struct GBAMemory* memory, const struct GBASerializedState* state);
+
+void GBAPrintFlush(struct GBA* gba);
 
 CXX_GUARD_END
 

@@ -43,6 +43,8 @@ int16_t dy;
 	int16_t dmy;
 	int32_t sx;
 	int32_t sy;
+	int yCache;
+	uint16_t mapCache[64];
 	color_t* extPalette;
 	color_t* variantPalette;
 };

@@ -169,7 +169,8 @@ *   | bits 2 - 3: GB Player inputs posted
  *   | bits 4 - 8: GB Player transmit position
  *   | bits 9 - 23: Reserved
  * 0x002C4 - 0x002C7: Game Boy Player next event
- * 0x002C8 - 0x002DF: Reserved (leave zero)
+ * 0x002C8 - 0x002CB: Current DMA transfer word
+ * 0x002CC - 0x002DF: Reserved (leave zero)
  * 0x002E0 - 0x002EF: Savedata state
  * | 0x002E0 - 0x002E0: Savedata type
  * | 0x002E1 - 0x002E1: Savedata command (see savedata.h)
@@ -293,7 +294,9 @@ GBASerializedHWFlags3 flags3;
 		uint32_t gbpNextEvent;
 	} hw;
 
-	uint32_t reservedHardware[6];
+	uint32_t dmaTransferRegister;
+
+	uint32_t reservedHardware[5];
 
 	struct {
 		uint8_t type;

@@ -15,16 +15,18 @@
 #include <mgba/internal/lr35902/lr35902.h>
 #include <mgba-util/vector.h>
 
-
+struct ParseTree;
 struct LR35902DebugBreakpoint {
 	uint16_t address;
 	int segment;
+	struct ParseTree* condition;
 };
 
 struct LR35902DebugWatchpoint {
 	uint16_t address;
 	int segment;
 	enum mWatchpointType type;
+	struct ParseTree* condition;
 };
 
 struct LR35902Segment {

@@ -17,23 +17,21 @@ static void _disassembleArm(struct CLIDebugger*, struct CLIDebugVector*);
 static void _disassembleThumb(struct CLIDebugger*, struct CLIDebugVector*);
 static void _setBreakpointARM(struct CLIDebugger*, struct CLIDebugVector*);
 static void _setBreakpointThumb(struct CLIDebugger*, struct CLIDebugVector*);
-static void _writeRegister(struct CLIDebugger*, struct CLIDebugVector*);
 
 static void _disassembleMode(struct CLIDebugger*, struct CLIDebugVector*, enum ExecutionMode mode);
 static uint32_t _printLine(struct CLIDebugger* debugger, uint32_t address, enum ExecutionMode mode);
 
 static struct CLIDebuggerCommandSummary _armCommands[] = {
-	{ "b/a", _setBreakpointARM, CLIDVParse, "Set a software breakpoint as ARM" },
-	{ "b/t", _setBreakpointThumb, CLIDVParse, "Set a software breakpoint as Thumb" },
-	{ "break/a", _setBreakpointARM, CLIDVParse, "Set a software breakpoint as ARM" },
-	{ "break/t", _setBreakpointThumb, CLIDVParse, "Set a software breakpoint as Thumb" },
-	{ "dis/a", _disassembleArm, CLIDVParse, "Disassemble instructions as ARM" },
-	{ "dis/t", _disassembleThumb, CLIDVParse, "Disassemble instructions as Thumb" },
-	{ "disasm/a", _disassembleArm, CLIDVParse, "Disassemble instructions as ARM" },
-	{ "disasm/t", _disassembleThumb, CLIDVParse, "Disassemble instructions as Thumb" },
-	{ "disassemble/a", _disassembleArm, CLIDVParse, "Disassemble instructions as ARM" },
-	{ "disassemble/t", _disassembleThumb, CLIDVParse, "Disassemble instructions as Thumb" },
-	{ "w/r", _writeRegister, CLIDVParse, "Write a register" },
+	{ "b/a", _setBreakpointARM, "I", "Set a software breakpoint as ARM" },
+	{ "b/t", _setBreakpointThumb, "I", "Set a software breakpoint as Thumb" },
+	{ "break/a", _setBreakpointARM, "I", "Set a software breakpoint as ARM" },
+	{ "break/t", _setBreakpointThumb, "I", "Set a software breakpoint as Thumb" },
+	{ "dis/a", _disassembleArm, "Ii", "Disassemble instructions as ARM" },
+	{ "dis/t", _disassembleThumb, "Ii", "Disassemble instructions as Thumb" },
+	{ "disasm/a", _disassembleArm, "Ii", "Disassemble instructions as ARM" },
+	{ "disasm/t", _disassembleThumb, "Ii", "Disassemble instructions as Thumb" },
+	{ "disassemble/a", _disassembleArm, "Ii", "Disassemble instructions as ARM" },
+	{ "disassemble/t", _disassembleThumb, "Ii", "Disassemble instructions as Thumb" },
 	{ 0, 0, 0, 0 }
 };
 
@@ -145,25 +143,6 @@ }
 	_printLine(debugger->p, cpu->gprs[ARM_PC] - instructionLength, mode);
 }
 
-static void _writeRegister(struct CLIDebugger* debugger, struct CLIDebugVector* dv) {
-	struct CLIDebuggerBackend* be = debugger->backend;
-	struct ARMCore* cpu = debugger->d.core->cpu;
-	if (!dv || dv->type != CLIDV_INT_TYPE) {
-		be->printf(be, "%s\n", ERROR_MISSING_ARGS);
-		return;
-	}
-	if (!dv->next || dv->next->type != CLIDV_INT_TYPE) {
-		be->printf(be, "%s\n", ERROR_MISSING_ARGS);
-		return;
-	}
-	uint32_t regid = dv->intValue;
-	uint32_t value = dv->next->intValue;
-	if (regid >= ARM_PC) {
-		return;
-	}
-	cpu->gprs[regid] = value;
-}
-
 static void _setBreakpointARM(struct CLIDebugger* debugger, struct CLIDebugVector* dv) {
 	struct CLIDebuggerBackend* be = debugger->backend;
 	if (!dv || dv->type != CLIDV_INT_TYPE) {
@@ -184,38 +163,9 @@ uint32_t address = dv->intValue;
 	ARMDebuggerSetSoftwareBreakpoint(debugger->d.platform, address, MODE_THUMB);
 }
 
-static uint32_t _lookupPlatformIdentifier(struct CLIDebuggerSystem* debugger, const char* name, struct CLIDebugVector* dv) {
-	struct ARMCore* cpu = debugger->p->d.core->cpu;
-	if (strcmp(name, "sp") == 0) {
-		return cpu->gprs[ARM_SP];
-	}
-	if (strcmp(name, "lr") == 0) {
-		return cpu->gprs[ARM_LR];
-	}
-	if (strcmp(name, "pc") == 0) {
-		return cpu->gprs[ARM_PC];
-	}
-	if (strcmp(name, "cpsr") == 0) {
-		return cpu->cpsr.packed;
-	}
-	// TODO: test if mode has SPSR
-	if (strcmp(name, "spsr") == 0) {
-		return cpu->spsr.packed;
-	}
-	if (name[0] == 'r' && name[1] >= '0' && name[1] <= '9') {
-		int reg = atoi(&name[1]);
-		if (reg < 16) {
-			return cpu->gprs[reg];
-		}
-	}
-	dv->type = CLIDV_ERROR_TYPE;
-	return 0;
-}
-
 void ARMCLIDebuggerCreate(struct CLIDebuggerSystem* debugger) {
 	debugger->printStatus = _printStatus;
 	debugger->disassemble = _disassemble;
-	debugger->lookupPlatformIdentifier = _lookupPlatformIdentifier;
 	debugger->platformName = "ARM";
 	debugger->platformCommands = _armCommands;
 }

@@ -10,6 +10,7 @@ #include <mgba/internal/arm/arm.h>
 #include <mgba/internal/arm/decoder.h>
 #include <mgba/internal/arm/isa-inlines.h>
 #include <mgba/internal/arm/debugger/memory-debugger.h>
+#include <mgba/internal/debugger/parser.h>
 
 DEFINE_VECTOR(ARMDebugBreakpointList, struct ARMDebugBreakpoint);
 DEFINE_VECTOR(ARMDebugWatchpointList, struct ARMDebugWatchpoint);
@@ -24,6 +25,20 @@ }
 	return 0;
 }
 
+static void _destroyBreakpoint(struct ARMDebugBreakpoint* breakpoint) {
+	if (breakpoint->condition) {
+		parseFree(breakpoint->condition);
+		free(breakpoint->condition);
+	}
+}
+
+static void _destroyWatchpoint(struct ARMDebugWatchpoint* watchpoint) {
+	if (watchpoint->condition) {
+		parseFree(watchpoint->condition);
+		free(watchpoint->condition);
+	}
+}
+
 static void ARMDebuggerCheckBreakpoints(struct mDebuggerPlatform* d) {
 	struct ARMDebugger* debugger = (struct ARMDebugger*) d;
 	int instructionLength;
@@ -37,9 +52,16 @@ struct ARMDebugBreakpoint* breakpoint = _lookupBreakpoint(&debugger->breakpoints, debugger->cpu->gprs[ARM_PC] - instructionLength);
 	if (!breakpoint) {
 		return;
 	}
+	if (breakpoint->condition) {
+		int32_t value;
+		int segment;
+		if (!mDebuggerEvaluateParseTree(d->p, breakpoint->condition, &value, &segment) || !(value || segment >= 0)) {
+			return;
+		}
+	}
 	struct mDebuggerEntryInfo info = {
 		.address = breakpoint->address,
-		.breakType = BREAKPOINT_HARDWARE
+		.type.bp.breakType = BREAKPOINT_HARDWARE
 	};
 	mDebuggerEnter(d->p, DEBUGGER_ENTER_BREAKPOINT, &info);
 }
@@ -50,12 +72,16 @@
 static void ARMDebuggerEnter(struct mDebuggerPlatform* d, enum mDebuggerEntryReason reason, struct mDebuggerEntryInfo* info);
 
 static void ARMDebuggerSetBreakpoint(struct mDebuggerPlatform*, uint32_t address, int segment);
+static void ARMDebuggerSetConditionalBreakpoint(struct mDebuggerPlatform*, uint32_t address, int segment, struct ParseTree* condition);
 static void ARMDebuggerClearBreakpoint(struct mDebuggerPlatform*, uint32_t address, int segment);
 static void ARMDebuggerSetWatchpoint(struct mDebuggerPlatform*, uint32_t address, int segment, enum mWatchpointType type);
+static void ARMDebuggerSetConditionalWatchpoint(struct mDebuggerPlatform*, uint32_t address, int segment, enum mWatchpointType type, struct ParseTree* condition);
 static void ARMDebuggerClearWatchpoint(struct mDebuggerPlatform*, uint32_t address, int segment);
 static void ARMDebuggerCheckBreakpoints(struct mDebuggerPlatform*);
 static bool ARMDebuggerHasBreakpoints(struct mDebuggerPlatform*);
 static void ARMDebuggerTrace(struct mDebuggerPlatform*, char* out, size_t* length);
+static bool ARMDebuggerGetRegister(struct mDebuggerPlatform*, const char* name, int32_t* value);
+static bool ARMDebuggerSetRegister(struct mDebuggerPlatform*, const char* name, int32_t value);
 
 struct mDebuggerPlatform* ARMDebuggerPlatformCreate(void) {
 	struct mDebuggerPlatform* platform = (struct mDebuggerPlatform*) malloc(sizeof(struct ARMDebugger));
@@ -63,12 +89,16 @@ platform->entered = ARMDebuggerEnter;
 	platform->init = ARMDebuggerInit;
 	platform->deinit = ARMDebuggerDeinit;
 	platform->setBreakpoint = ARMDebuggerSetBreakpoint;
+	platform->setConditionalBreakpoint = ARMDebuggerSetConditionalBreakpoint;
 	platform->clearBreakpoint = ARMDebuggerClearBreakpoint;
 	platform->setWatchpoint = ARMDebuggerSetWatchpoint;
+	platform->setConditionalWatchpoint = ARMDebuggerSetConditionalWatchpoint;
 	platform->clearWatchpoint = ARMDebuggerClearWatchpoint;
 	platform->checkBreakpoints = ARMDebuggerCheckBreakpoints;
 	platform->hasBreakpoints = ARMDebuggerHasBreakpoints;
 	platform->trace = ARMDebuggerTrace;
+	platform->getRegister = ARMDebuggerGetRegister;
+	platform->setRegister = ARMDebuggerSetRegister;
 	return platform;
 }
 
@@ -93,7 +123,15 @@ }
 	}
 	ARMDebuggerRemoveMemoryShim(debugger);
 
+	size_t i;
+	for (i = 0; i < ARMDebugBreakpointListSize(&debugger->breakpoints); ++i) {
+		_destroyBreakpoint(ARMDebugBreakpointListGetPointer(&debugger->breakpoints, i));
+	}
 	ARMDebugBreakpointListDeinit(&debugger->breakpoints);
+
+	for (i = 0; i < ARMDebugWatchpointListSize(&debugger->watchpoints); ++i) {
+		_destroyWatchpoint(ARMDebugWatchpointListGetPointer(&debugger->watchpoints, i));
+	}
 	ARMDebugBreakpointListDeinit(&debugger->swBreakpoints);
 	ARMDebugWatchpointListDeinit(&debugger->watchpoints);
 }
@@ -161,9 +199,14 @@ }
 }
 
 static void ARMDebuggerSetBreakpoint(struct mDebuggerPlatform* d, uint32_t address, int segment) {
+	ARMDebuggerSetConditionalBreakpoint(d, address, segment, NULL);
+}
+
+static void ARMDebuggerSetConditionalBreakpoint(struct mDebuggerPlatform* d, uint32_t address, int segment, struct ParseTree* condition) {
 	UNUSED(segment);
 	struct ARMDebugger* debugger = (struct ARMDebugger*) d;
 	struct ARMDebugBreakpoint* breakpoint = ARMDebugBreakpointListAppend(&debugger->breakpoints);
+	breakpoint->condition = condition;
 	breakpoint->address = address;
 	breakpoint->isSw = false;
 }
@@ -175,6 +218,7 @@ struct ARMDebugBreakpointList* breakpoints = &debugger->breakpoints;
 	size_t i;
 	for (i = 0; i < ARMDebugBreakpointListSize(breakpoints); ++i) {
 		if (ARMDebugBreakpointListGetPointer(breakpoints, i)->address == address) {
+			_destroyBreakpoint(ARMDebugBreakpointListGetPointer(breakpoints, i));
 			ARMDebugBreakpointListShift(breakpoints, i, 1);
 		}
 	}
@@ -186,6 +230,10 @@ return ARMDebugBreakpointListSize(&debugger->breakpoints) || ARMDebugWatchpointListSize(&debugger->watchpoints);
 }
 
 static void ARMDebuggerSetWatchpoint(struct mDebuggerPlatform* d, uint32_t address, int segment, enum mWatchpointType type) {
+	ARMDebuggerSetConditionalWatchpoint(d, address, segment, type, NULL);
+}
+
+static void ARMDebuggerSetConditionalWatchpoint(struct mDebuggerPlatform* d, uint32_t address, int segment, enum mWatchpointType type, struct ParseTree* condition) {
 	UNUSED(segment);
 	struct ARMDebugger* debugger = (struct ARMDebugger*) d;
 	if (!ARMDebugWatchpointListSize(&debugger->watchpoints)) {
@@ -194,6 +242,7 @@ }
 	struct ARMDebugWatchpoint* watchpoint = ARMDebugWatchpointListAppend(&debugger->watchpoints);
 	watchpoint->address = address;
 	watchpoint->type = type;
+	watchpoint->condition = condition;
 }
 
 static void ARMDebuggerClearWatchpoint(struct mDebuggerPlatform* d, uint32_t address, int segment) {
@@ -203,6 +252,7 @@ struct ARMDebugWatchpointList* watchpoints = &debugger->watchpoints;
 	size_t i;
 	for (i = 0; i < ARMDebugWatchpointListSize(watchpoints); ++i) {
 		if (ARMDebugWatchpointListGetPointer(watchpoints, i)->address == address) {
+			_destroyWatchpoint(ARMDebugWatchpointListGetPointer(watchpoints, i));
 			ARMDebugWatchpointListShift(watchpoints, i, 1);
 		}
 	}
@@ -246,3 +296,81 @@ cpu->gprs[8],  cpu->gprs[9],  cpu->gprs[10], cpu->gprs[11],
 		               cpu->gprs[12], cpu->gprs[13], cpu->gprs[14], cpu->gprs[15],
 		               cpu->cpsr.packed, disassembly);
 }
+
+bool ARMDebuggerGetRegister(struct mDebuggerPlatform* d, const char* name, int32_t* value) {
+	struct ARMDebugger* debugger = (struct ARMDebugger*) d;
+	struct ARMCore* cpu = debugger->cpu;
+
+	if (strcmp(name, "sp") == 0) {
+		*value = cpu->gprs[ARM_SP];
+		return true;
+	}
+	if (strcmp(name, "lr") == 0) {
+		*value = cpu->gprs[ARM_LR];
+		return true;
+	}
+	if (strcmp(name, "pc") == 0) {
+		*value = cpu->gprs[ARM_PC];
+		return true;
+	}
+	if (strcmp(name, "cpsr") == 0) {
+		*value = cpu->cpsr.packed;
+		return true;
+	}
+	// TODO: test if mode has SPSR
+	if (strcmp(name, "spsr") == 0) {
+		*value = cpu->spsr.packed;
+		return true;
+	}
+	if (name[0] == 'r') {
+		char* end;
+		uint32_t reg = strtoul(&name[1], &end, 10);
+		if (reg <= ARM_PC) {
+			*value = cpu->gprs[reg];
+			return true;
+		}
+	}
+	return false;
+}
+
+bool ARMDebuggerSetRegister(struct mDebuggerPlatform* d, const char* name, int32_t value) {
+	struct ARMDebugger* debugger = (struct ARMDebugger*) d;
+	struct ARMCore* cpu = debugger->cpu;
+
+	if (strcmp(name, "sp") == 0) {
+		cpu->gprs[ARM_SP] = value;
+		return true;
+	}
+	if (strcmp(name, "lr") == 0) {
+		cpu->gprs[ARM_LR] = value;
+		return true;
+	}
+	if (strcmp(name, "pc") == 0) {
+		cpu->gprs[ARM_PC] = value;
+		int32_t currentCycles = 0;
+		if (cpu->executionMode == MODE_ARM) {
+			ARM_WRITE_PC;
+		} else {
+			THUMB_WRITE_PC;
+		}
+		return true;
+	}
+	if (name[0] == 'r') {
+		char* end;
+		uint32_t reg = strtoul(&name[1], &end, 10);
+		if (reg > ARM_PC) {
+			return false;
+		}
+		cpu->gprs[reg] = value;
+		if (reg == ARM_PC) {
+			int32_t currentCycles = 0;
+			if (cpu->executionMode == MODE_ARM) {
+				ARM_WRITE_PC;
+			} else {
+				THUMB_WRITE_PC;
+			}
+		}
+		return true;
+	}
+	return false;
+}

@@ -6,6 +6,7 @@ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 #include <mgba/internal/arm/debugger/memory-debugger.h>
 
 #include <mgba/internal/arm/debugger/debugger.h>
+#include <mgba/internal/debugger/parser.h>
 
 #include <mgba-util/math.h>
 
@@ -97,21 +98,29 @@ size_t i;
 	for (i = 0; i < ARMDebugWatchpointListSize(&debugger->watchpoints); ++i) {
 		watchpoint = ARMDebugWatchpointListGetPointer(&debugger->watchpoints, i);
 		if (!((watchpoint->address ^ address) & ~width) && watchpoint->type & type) {
+			if (watchpoint->condition) {
+				int32_t value;
+				int segment;
+				if (!mDebuggerEvaluateParseTree(debugger->d.p, watchpoint->condition, &value, &segment) || !(value || segment >= 0)) {
+					return false;
+				}
+			}
+
 			switch (width + 1) {
 			case 1:
-				info->oldValue = debugger->originalMemory.load8(debugger->cpu, address, 0);
+				info->type.wp.oldValue = debugger->originalMemory.load8(debugger->cpu, address, 0);
 				break;
 			case 2:
-				info->oldValue = debugger->originalMemory.load16(debugger->cpu, address, 0);
+				info->type.wp.oldValue = debugger->originalMemory.load16(debugger->cpu, address, 0);
 				break;
 			case 4:
-				info->oldValue = debugger->originalMemory.load32(debugger->cpu, address, 0);
+				info->type.wp.oldValue = debugger->originalMemory.load32(debugger->cpu, address, 0);
 				break;
 			}
-			info->newValue = newValue;
+			info->type.wp.newValue = newValue;
 			info->address = address;
-			info->watchType = watchpoint->type;
-			info->accessType = type;
+			info->type.wp.watchType = watchpoint->type;
+			info->type.wp.accessType = type;
 			return true;
 		}
 	}

@@ -51,6 +51,8 @@ void mCheatDeviceCreate(struct mCheatDevice* device) {
 	device->d.id = M_CHEAT_DEVICE_ID;
 	device->d.init = mCheatDeviceInit;
 	device->d.deinit = mCheatDeviceDeinit;
+	device->autosave = false;
+	device->buttonDown = false;
 	mCheatSetsInit(&device->cheats, 4);
 }
 
@@ -252,11 +254,25 @@ StringListDeinit(&directives);
 	return true;
 }
 
+#if !defined(MINIMAL_CORE) || MINIMAL_CORE < 2
+void mCheatAutosave(struct mCheatDevice* device) {
+	if (!device->autosave) {
+		return;
+	}
+	struct VFile* vf = mDirectorySetOpenSuffix(&device->p->dirs, device->p->dirs.cheats, ".cheats", O_WRONLY | O_CREAT | O_TRUNC);
+	if (!vf) {
+		return;
+	}
+	mCheatSaveFile(device, vf);
+	vf->close(vf);
+}
+#endif
+
 void mCheatRefresh(struct mCheatDevice* device, struct mCheatSet* cheats) {
+	cheats->refresh(cheats, device);
 	if (!cheats->enabled) {
 		return;
 	}
-	cheats->refresh(cheats, device);
 
 	size_t elseLoc = 0;
 	size_t endLoc = 0;
@@ -350,6 +366,12 @@ conditionRemaining = cheat->repeat;
 				negativeConditionRemaining = cheat->negativeRepeat;
 				operationsRemaining = 1;
 				break;
+			case CHEAT_IF_BUTTON:
+				condition = device->buttonDown;
+				conditionRemaining = cheat->repeat;
+				negativeConditionRemaining = cheat->negativeRepeat;
+				operationsRemaining = 1;
+				break;
 			}
 
 			if (performAssignment) {
@@ -372,6 +394,10 @@ elseLoc = i + conditionRemaining;
 			endLoc = elseLoc + negativeConditionRemaining;
 		}
 	}
+}
+
+void mCheatPressButton(struct mCheatDevice* device, bool down) {
+	device->buttonDown = down;
 }
 
 void mCheatDeviceInit(void* cpu, struct mCPUComponent* component) {

@@ -379,6 +379,7 @@ _lookupCharValue(config, "savegamePath", &opts->savegamePath);
 	_lookupCharValue(config, "savestatePath", &opts->savestatePath);
 	_lookupCharValue(config, "screenshotPath", &opts->screenshotPath);
 	_lookupCharValue(config, "patchPath", &opts->patchPath);
+	_lookupCharValue(config, "cheatsPath", &opts->cheatsPath);
 }
 
 void mCoreConfigLoadDefaults(struct mCoreConfig* config, const struct mCoreOptions* opts) {
@@ -443,10 +444,12 @@ free(opts->savegamePath);
 	free(opts->savestatePath);
 	free(opts->screenshotPath);
 	free(opts->patchPath);
+	free(opts->cheatsPath);
 	opts->bios = 0;
 	opts->shader = 0;
 	opts->savegamePath = 0;
 	opts->savestatePath = 0;
 	opts->screenshotPath = 0;
 	opts->patchPath = 0;
+	opts->cheatsPath = 0;
 }

@@ -5,6 +5,7 @@ * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 #include <mgba/core/core.h>
 
+#include <mgba/core/cheats.h>
 #include <mgba/core/log.h>
 #include <mgba/core/serialize.h>
 #include <mgba-util/vfs.h>
@@ -172,6 +173,30 @@ core->loadPatch(core, mDirectorySetOpenSuffix(&core->dirs, core->dirs.patch, ".ips", O_RDONLY)) ||
 	       core->loadPatch(core, mDirectorySetOpenSuffix(&core->dirs, core->dirs.patch, ".bps", O_RDONLY));
 }
 
+bool mCoreAutoloadCheats(struct mCore* core) {
+	bool success = true;
+	int cheatAuto;
+	if (!mCoreConfigGetIntValue(&core->config, "cheatAutoload", &cheatAuto) || cheatAuto) {
+		struct VFile* vf = mDirectorySetOpenSuffix(&core->dirs, core->dirs.cheats, ".cheats", O_RDONLY);
+		if (vf) {
+			struct mCheatDevice* device = core->cheatDevice(core);
+			if (!device) {
+				success = false;
+			} else {
+				success = mCheatParseFile(device, vf);
+			}
+			vf->close(vf);
+		}
+	}
+	if (!mCoreConfigGetIntValue(&core->config, "cheatAutosave", &cheatAuto) || cheatAuto) {
+		struct mCheatDevice* device = core->cheatDevice(core);
+		if (device) {
+			device->autosave = true;
+		}
+	}
+	return success;
+}
+
 bool mCoreSaveState(struct mCore* core, int slot, int flags) {
 	struct VFile* vf = mCoreGetState(core, slot, true);
 	if (!vf) {
@@ -264,7 +289,7 @@ mCoreConfigInit(&core->config, port);
 }
 
 void mCoreLoadConfig(struct mCore* core) {
-#ifndef MINIMAL_CORE
+#if !defined(MINIMAL_CORE) || MINIMAL_CORE < 2
 	mCoreConfigLoad(&core->config);
 #endif
 	mCoreLoadForeignConfig(core, &core->config);
@@ -272,12 +297,16 @@ }
 
 void mCoreLoadForeignConfig(struct mCore* core, const struct mCoreConfig* config) {
 	mCoreConfigMap(config, &core->opts);
-#ifndef MINIMAL_CORE
+#if !defined(MINIMAL_CORE) || MINIMAL_CORE < 2
 	mDirectorySetMapOptions(&core->dirs, &core->opts);
 #endif
 	if (core->opts.audioBuffers) {
 		core->setAudioBufferSize(core, core->opts.audioBuffers);
 	}
+
+	mCoreConfigCopyValue(&core->config, config, "cheatAutosave");
+	mCoreConfigCopyValue(&core->config, config, "cheatAutoload");
+
 	core->loadConfig(core, config);
 }
 

@@ -16,6 +16,7 @@ dirs->save = 0;
 	dirs->patch = 0;
 	dirs->state = 0;
 	dirs->screenshot = 0;
+	dirs->cheats = 0;
 }
 
 void mDirectorySetDeinit(struct mDirectorySet* dirs) {
@@ -34,6 +35,9 @@ }
 		if (dirs->archive == dirs->screenshot) {
 			dirs->screenshot = NULL;
 		}
+		if (dirs->archive == dirs->cheats) {
+			dirs->cheats = NULL;
+		}
 		dirs->archive->close(dirs->archive);
 		dirs->archive = NULL;
 	}
@@ -48,6 +52,9 @@ }
 		if (dirs->save == dirs->screenshot) {
 			dirs->screenshot = NULL;
 		}
+		if (dirs->save == dirs->cheats) {
+			dirs->cheats = NULL;
+		}
 		dirs->save->close(dirs->save);
 		dirs->save = NULL;
 	}
@@ -58,6 +65,9 @@ dirs->state = NULL;
 		}
 		if (dirs->patch == dirs->screenshot) {
 			dirs->screenshot = NULL;
+		}
+		if (dirs->patch == dirs->cheats) {
+			dirs->cheats = NULL;
 		}
 		dirs->patch->close(dirs->patch);
 		dirs->patch = NULL;
@@ -67,14 +77,25 @@ if (dirs->state) {
 		if (dirs->state == dirs->screenshot) {
 			dirs->state = NULL;
 		}
+		if (dirs->state == dirs->cheats) {
+			dirs->cheats = NULL;
+		}
 		dirs->state->close(dirs->state);
 		dirs->state = NULL;
 	}
 
 	if (dirs->screenshot) {
+		if (dirs->screenshot == dirs->cheats) {
+			dirs->cheats = NULL;
+		}
 		dirs->screenshot->close(dirs->screenshot);
 		dirs->screenshot = NULL;
 	}
+
+	if (dirs->cheats) {
+		dirs->cheats->close(dirs->cheats);
+		dirs->cheats = NULL;
+	}
 }
 
 void mDirectorySetAttachBase(struct mDirectorySet* dirs, struct VDir* base) {
@@ -91,6 +112,9 @@ }
 	if (!dirs->screenshot) {
 		dirs->screenshot = dirs->base;
 	}
+	if (!dirs->cheats) {
+		dirs->cheats = dirs->base;
+	}
 }
 
 void mDirectorySetDetachBase(struct mDirectorySet* dirs) {
@@ -105,6 +129,9 @@ dirs->state = NULL;
 	}
 	if (dirs->screenshot == dirs->base) {
 		dirs->screenshot = NULL;
+	}
+	if (dirs->cheats == dirs->base) {
+		dirs->cheats = NULL;
 	}
 
 	if (dirs->base) {
@@ -181,6 +208,16 @@ if (dirs->patch && dirs->patch != dirs->base) {
 				dirs->patch->close(dirs->patch);
 			}
 			dirs->patch = dir;
+		}
+	}
+
+	if (opts->cheatsPath) {
+		struct VDir* dir = VDirOpen(opts->cheatsPath);
+		if (dir) {
+			if (dirs->cheats && dirs->cheats != dirs->base) {
+				dirs->cheats->close(dirs->cheats);
+			}
+			dirs->cheats = dir;
 		}
 	}
 }

@@ -11,7 +11,7 @@ #include <mgba-util/vector.h>
 
 #include <inttypes.h>
 
-#define SECTION_NAME_MAX 50
+#define SECTION_NAME_MAX 128
 #define KEY_NAME_MAX 32
 #define KEY_VALUE_MAX 16
 #define AXIS_INFO_MAX 12

@@ -10,248 +10,112 @@ #include <mgba/core/interface.h>
 
 DEFINE_VECTOR(mCoreMemorySearchResults, struct mCoreMemorySearchResult);
 
-static size_t _search32(const void* mem, size_t size, const struct mCoreMemoryBlock* block, uint32_t value32, struct mCoreMemorySearchResults* out, size_t limit) {
+static bool _op(int32_t value, int32_t match, enum mCoreMemorySearchOp op) {
+	switch (op) {
+	case mCORE_MEMORY_SEARCH_GREATER:
+		return value > match;
+	case mCORE_MEMORY_SEARCH_LESS:
+		return value < match;
+	case mCORE_MEMORY_SEARCH_EQUAL:
+	case mCORE_MEMORY_SEARCH_DELTA:
+		return value == match;
+	}
+}
+
+static size_t _search32(const void* mem, size_t size, const struct mCoreMemoryBlock* block, uint32_t value32, enum mCoreMemorySearchOp op, struct mCoreMemorySearchResults* out, size_t limit) {
 	const uint32_t* mem32 = mem;
 	size_t found = 0;
 	uint32_t start = block->start;
 	uint32_t end = size; // TODO: Segments
 	size_t i;
 	// TODO: Big endian
-	for (i = 0; (!limit || found < limit) && i < end; i += 16) {
-		int mask = 0;
-		mask |= (mem32[(i >> 2) + 0] == value32) << 0;
-		mask |= (mem32[(i >> 2) + 1] == value32) << 1;
-		mask |= (mem32[(i >> 2) + 2] == value32) << 2;
-		mask |= (mem32[(i >> 2) + 3] == value32) << 3;
-		if (!mask) {
-			continue;
-		}
-		if ((mask & 1) && (!limit || found < limit)) {
+	for (i = 0; (!limit || found < limit) && i < end; i += 4) {
+		if (_op(mem32[i >> 2], value32, op)) {
 			struct mCoreMemorySearchResult* res = mCoreMemorySearchResultsAppend(out);
 			res->address = start + i;
-			res->type = mCORE_MEMORY_SEARCH_32;
-			res->segment = -1; // TODO
-			res->guessDivisor = 1;
-			++found;
-		}
-		if ((mask & 2) && (!limit || found < limit)) {
-			struct mCoreMemorySearchResult* res = mCoreMemorySearchResultsAppend(out);
-			res->address = start + i + 4;
-			res->type = mCORE_MEMORY_SEARCH_32;
-			res->segment = -1; // TODO
-			res->guessDivisor = 1;
-			++found;
-		}
-		if ((mask & 4) && (!limit || found < limit)) {
-			struct mCoreMemorySearchResult* res = mCoreMemorySearchResultsAppend(out);
-			res->address = start + i + 8;
-			res->type = mCORE_MEMORY_SEARCH_32;
-			res->segment = -1; // TODO
-			res->guessDivisor = 1;
-			++found;
-		}
-		if ((mask & 8) && (!limit || found < limit)) {
-			struct mCoreMemorySearchResult* res = mCoreMemorySearchResultsAppend(out);
-			res->address = start + i + 12;
-			res->type = mCORE_MEMORY_SEARCH_32;
+			res->type = mCORE_MEMORY_SEARCH_INT;
+			res->width = 4;
 			res->segment = -1; // TODO
 			res->guessDivisor = 1;
+			res->guessMultiplier = 1;
+			res->oldValue = value32;
 			++found;
 		}
 	}
-	// TODO: last 12 bytes
 	return found;
 }
 
-static size_t _search16(const void* mem, size_t size, const struct mCoreMemoryBlock* block, uint16_t value16, struct mCoreMemorySearchResults* out, size_t limit) {
+static size_t _search16(const void* mem, size_t size, const struct mCoreMemoryBlock* block, uint16_t value16, enum mCoreMemorySearchOp op, struct mCoreMemorySearchResults* out, size_t limit) {
 	const uint16_t* mem16 = mem;
 	size_t found = 0;
 	uint32_t start = block->start;
 	uint32_t end = size; // TODO: Segments
 	size_t i;
 	// TODO: Big endian
-	for (i = 0; (!limit || found < limit) && i < end; i += 16) {
-		int mask = 0;
-		mask |= (mem16[(i >> 1) + 0] == value16) << 0;
-		mask |= (mem16[(i >> 1) + 1] == value16) << 1;
-		mask |= (mem16[(i >> 1) + 2] == value16) << 2;
-		mask |= (mem16[(i >> 1) + 3] == value16) << 3;
-		mask |= (mem16[(i >> 1) + 4] == value16) << 4;
-		mask |= (mem16[(i >> 1) + 5] == value16) << 5;
-		mask |= (mem16[(i >> 1) + 6] == value16) << 6;
-		mask |= (mem16[(i >> 1) + 7] == value16) << 7;
-		if (!mask) {
-			continue;
-		}
-		if ((mask & 1) && (!limit || found < limit)) {
+	for (i = 0; (!limit || found < limit) && i < end; i += 2) {
+		if (_op(mem16[i >> 1], value16, op)) {
 			struct mCoreMemorySearchResult* res = mCoreMemorySearchResultsAppend(out);
 			res->address = start + i;
-			res->type = mCORE_MEMORY_SEARCH_16;
-			res->segment = -1; // TODO
-			res->guessDivisor = 1;
-			++found;
-		}
-		if ((mask & 2) && (!limit || found < limit)) {
-			struct mCoreMemorySearchResult* res = mCoreMemorySearchResultsAppend(out);
-			res->address = start + i + 2;
-			res->type = mCORE_MEMORY_SEARCH_16;
-			res->segment = -1; // TODO
-			res->guessDivisor = 1;
-			++found;
-		}
-		if ((mask & 4) && (!limit || found < limit)) {
-			struct mCoreMemorySearchResult* res = mCoreMemorySearchResultsAppend(out);
-			res->address = start + i + 4;
-			res->type = mCORE_MEMORY_SEARCH_16;
+			res->type = mCORE_MEMORY_SEARCH_INT;
+			res->width = 2;
 			res->segment = -1; // TODO
 			res->guessDivisor = 1;
-			++found;
-		}
-		if ((mask & 8) && (!limit || found < limit)) {
-			struct mCoreMemorySearchResult* res = mCoreMemorySearchResultsAppend(out);
-			res->address = start + i + 6;
-			res->type = mCORE_MEMORY_SEARCH_16;
-			res->segment = -1; // TODO
-			res->guessDivisor = 1;
-			++found;
-		}
-		if ((mask & 16) && (!limit || found < limit)) {
-			struct mCoreMemorySearchResult* res = mCoreMemorySearchResultsAppend(out);
-			res->address = start + i + 8;
-			res->type = mCORE_MEMORY_SEARCH_16;
-			res->segment = -1; // TODO
-			res->guessDivisor = 1;
-			++found;
-		}
-		if ((mask & 32) && (!limit || found < limit)) {
-			struct mCoreMemorySearchResult* res = mCoreMemorySearchResultsAppend(out);
-			res->address = start + i + 10;
-			res->type = mCORE_MEMORY_SEARCH_16;
-			res->segment = -1; // TODO
-			res->guessDivisor = 1;
-			++found;
-		}
-		if ((mask & 64) && (!limit || found < limit)) {
-			struct mCoreMemorySearchResult* res = mCoreMemorySearchResultsAppend(out);
-			res->address = start + i + 12;
-			res->type = mCORE_MEMORY_SEARCH_16;
-			res->segment = -1; // TODO
-			res->guessDivisor = 1;
-			++found;
-		}
-		if ((mask & 128) && (!limit || found < limit)) {
-			struct mCoreMemorySearchResult* res = mCoreMemorySearchResultsAppend(out);
-			res->address = start + i + 14;
-			res->type = mCORE_MEMORY_SEARCH_16;
-			res->segment = -1; // TODO
-			res->guessDivisor = 1;
+			res->guessMultiplier = 1;
+			res->oldValue = value16;
 			++found;
 		}
 	}
-	// TODO: last 14 bytes
 	return found;
 }
 
-static size_t _search8(const void* mem, size_t size, const struct mCoreMemoryBlock* block, uint8_t value8, struct mCoreMemorySearchResults* out, size_t limit) {
+static size_t _search8(const void* mem, size_t size, const struct mCoreMemoryBlock* block, uint8_t value8, enum mCoreMemorySearchOp op, struct mCoreMemorySearchResults* out, size_t limit) {
 	const uint8_t* mem8 = mem;
 	size_t found = 0;
 	uint32_t start = block->start;
 	uint32_t end = size; // TODO: Segments
 	size_t i;
-	for (i = 0; (!limit || found < limit) && i < end; i += 8) {
-		int mask = 0;
-		mask |= (mem8[i + 0] == value8) << 0;
-		mask |= (mem8[i + 1] == value8) << 1;
-		mask |= (mem8[i + 2] == value8) << 2;
-		mask |= (mem8[i + 3] == value8) << 3;
-		mask |= (mem8[i + 4] == value8) << 4;
-		mask |= (mem8[i + 5] == value8) << 5;
-		mask |= (mem8[i + 6] == value8) << 6;
-		mask |= (mem8[i + 7] == value8) << 7;
-		if (!mask) {
-			continue;
-		}
-		if ((mask & 1) && (!limit || found < limit)) {
+	for (i = 0; (!limit || found < limit) && i < end; ++i) {
+		if (_op(mem8[i], value8, op)) {
 			struct mCoreMemorySearchResult* res = mCoreMemorySearchResultsAppend(out);
 			res->address = start + i;
-			res->type = mCORE_MEMORY_SEARCH_8;
+			res->type = mCORE_MEMORY_SEARCH_INT;
+			res->width = 1;
 			res->segment = -1; // TODO
 			res->guessDivisor = 1;
+			res->guessMultiplier = 1;
+			res->oldValue = value8;
 			++found;
 		}
-		if ((mask & 2) && (!limit || found < limit)) {
-			struct mCoreMemorySearchResult* res = mCoreMemorySearchResultsAppend(out);
-			res->address = start + i + 1;
-			res->type = mCORE_MEMORY_SEARCH_8;
-			res->segment = -1; // TODO
-			res->guessDivisor = 1;
-			++found;
-		}
-		if ((mask & 4) && (!limit || found < limit)) {
-			struct mCoreMemorySearchResult* res = mCoreMemorySearchResultsAppend(out);
-			res->address = start + i + 2;
-			res->type = mCORE_MEMORY_SEARCH_8;
-			res->segment = -1; // TODO
-			res->guessDivisor = 1;
-			++found;
-		}
-		if ((mask & 8) && (!limit || found < limit)) {
-			struct mCoreMemorySearchResult* res = mCoreMemorySearchResultsAppend(out);
-			res->address = start + i + 3;
-			res->type = mCORE_MEMORY_SEARCH_8;
-			res->segment = -1; // TODO
-			res->guessDivisor = 1;
-			++found;
-		}
-		if ((mask & 16) && (!limit || found < limit)) {
-			struct mCoreMemorySearchResult* res = mCoreMemorySearchResultsAppend(out);
-			res->address = start + i + 4;
-			res->type = mCORE_MEMORY_SEARCH_8;
-			res->segment = -1; // TODO
-			res->guessDivisor = 1;
-			++found;
-		}
-		if ((mask & 32) && (!limit || found < limit)) {
-			struct mCoreMemorySearchResult* res = mCoreMemorySearchResultsAppend(out);
-			res->address = start + i + 5;
-			res->type = mCORE_MEMORY_SEARCH_8;
-			res->segment = -1; // TODO
-			res->guessDivisor = 1;
-			++found;
-		}
-		if ((mask & 64) && (!limit || found < limit)) {
-			struct mCoreMemorySearchResult* res = mCoreMemorySearchResultsAppend(out);
-			res->address = start + i + 6;
-			res->type = mCORE_MEMORY_SEARCH_8;
-			res->segment = -1; // TODO
-			res->guessDivisor = 1;
-			++found;
-		}
-		if ((mask & 128) && (!limit || found < limit)) {
-			struct mCoreMemorySearchResult* res = mCoreMemorySearchResultsAppend(out);
-			res->address = start + i + 7;
-			res->type = mCORE_MEMORY_SEARCH_8;
-			res->segment = -1; // TODO
-			res->guessDivisor = 1;
-			++found;
+	}
+	return found;
+}
+
+static size_t _searchInt(const void* mem, size_t size, const struct mCoreMemoryBlock* block, const struct mCoreMemorySearchParams* params, struct mCoreMemorySearchResults* out, size_t limit) {
+	if (params->align == params->width || params->align == -1) {
+		switch (params->width) {
+		case 4:
+			return _search32(mem, size, block, params->valueInt, params->op, out, limit);
+		case 2:
+			return _search16(mem, size, block, params->valueInt, params->op, out, limit);
+		case 1:
+			return _search8(mem, size, block, params->valueInt, params->op, out, limit);
 		}
 	}
-	// TODO: last 7 bytes
-	return found;
+	return 0;
 }
 
-static size_t _searchStr(const void* mem, size_t size, const struct mCoreMemoryBlock* block, const char* valueStr, struct mCoreMemorySearchResults* out, size_t limit) {
+static size_t _searchStr(const void* mem, size_t size, const struct mCoreMemoryBlock* block, const char* valueStr, int len, struct mCoreMemorySearchResults* out, size_t limit) {
 	const char* memStr = mem;
 	size_t found = 0;
-	size_t len = strlen(valueStr);
 	uint32_t start = block->start;
 	uint32_t end = size; // TODO: Segments
 	size_t i;
 	for (i = 0; (!limit || found < limit) && i < end - len; ++i) {
-		if (!strncmp(valueStr, &memStr[i], len)) {
+		if (!memcmp(valueStr, &memStr[i], len)) {
 			struct mCoreMemorySearchResult* res = mCoreMemorySearchResultsAppend(out);
 			res->address = start + i;
 			res->type = mCORE_MEMORY_SEARCH_STRING;
+			res->width = len;
 			res->segment = -1; // TODO
 			++found;
 		}
@@ -259,11 +123,11 @@ }
 	return found;
 }
 
-static size_t _searchGuess(const void* mem, size_t size, const struct mCoreMemoryBlock* block, const char* valueStr, struct mCoreMemorySearchResults* out, size_t limit) {
+static size_t _searchGuess(const void* mem, size_t size, const struct mCoreMemoryBlock* block, const struct mCoreMemorySearchParams* params, struct mCoreMemorySearchResults* out, size_t limit) {
 	// TODO: As str
 
 	char* end;
-	uint64_t value;
+	int64_t value;
 
 	size_t found = 0;
 
@@ -271,14 +135,14 @@ struct mCoreMemorySearchResults tmp;
 	mCoreMemorySearchResultsInit(&tmp, 0);
 
 	// Decimal:
-	value = strtoull(valueStr, &end, 10);
+	value = strtoll(params->valueStr, &end, 10);
 	if (end && !end[0]) {
-		if (value > 0x10000) {
-			found += _search32(mem, size, block, value, out, limit ? limit - found : 0);
-		} else if (value > 0x100) {
-			found += _search16(mem, size, block, value, out, limit ? limit - found : 0);
+		if ((params->width == -1 && value > 0x10000) || params->width == 4) {
+			found += _search32(mem, size, block, value, params->op, out, limit ? limit - found : 0);
+		} else if ((params->width == -1 && value > 0x100) || params->width == 2) {
+			found += _search16(mem, size, block, value, params->op, out, limit ? limit - found : 0);
 		} else {
-			found += _search8(mem, size, block, value, out, limit ? limit - found : 0);
+			found += _search8(mem, size, block, value, params->op, out, limit ? limit - found : 0);
 		}
 
 		uint32_t divisor = 1;
@@ -287,12 +151,12 @@ mCoreMemorySearchResultsClear(&tmp);
 			value /= 10;
 			divisor *= 10;
 
-			if (value > 0x10000) {
-				found += _search32(mem, size, block, value, &tmp, limit ? limit - found : 0);
-			} else if (value > 0x100) {
-				found += _search16(mem, size, block, value, &tmp, limit ? limit - found : 0);
+			if ((params->width == -1 && value > 0x10000) || params->width == 4) {
+				found += _search32(mem, size, block, value, params->op, &tmp, limit ? limit - found : 0);
+			} else if ((params->width == -1 && value > 0x100) || params->width == 2) {
+				found += _search16(mem, size, block, value, params->op, &tmp, limit ? limit - found : 0);
 			} else {
-				found += _search8(mem, size, block, value, &tmp, limit ? limit - found : 0);
+				found += _search8(mem, size, block, value, params->op, &tmp, limit ? limit - found : 0);
 			}
 			size_t i;
 			for (i = 0; i < mCoreMemorySearchResultsSize(&tmp); ++i) {
@@ -304,14 +168,14 @@ }
 	}
 
 	// Hex:
-	value = strtoull(valueStr, &end, 16);
+	value = strtoll(params->valueStr, &end, 16);
 	if (end && !end[0]) {
-		if (value > 0x10000) {
-			found += _search32(mem, size, block, value, out, limit ? limit - found : 0);
-		} else if (value > 0x100) {
-			found += _search16(mem, size, block, value, out, limit ? limit - found : 0);
+		if ((params->width == -1 && value > 0x10000) || params->width == 4) {
+			found += _search32(mem, size, block, value, params->op, out, limit ? limit - found : 0);
+		} else if ((params->width == -1 && value > 0x100) || params->width == 2) {
+			found += _search16(mem, size, block, value, params->op, out, limit ? limit - found : 0);
 		} else {
-			found += _search8(mem, size, block, value, out, limit ? limit - found : 0);
+			found += _search8(mem, size, block, value, params->op, out, limit ? limit - found : 0);
 		}
 
 		uint32_t divisor = 1;
@@ -320,12 +184,12 @@ mCoreMemorySearchResultsClear(&tmp);
 			value >>= 4;
 			divisor <<= 4;
 
-			if (value > 0x10000) {
-				found += _search32(mem, size, block, value, &tmp, limit ? limit - found : 0);
-			} else if (value > 0x100) {
-				found += _search16(mem, size, block, value, &tmp, limit ? limit - found : 0);
+			if ((params->width == -1 && value > 0x10000) || params->width == 4) {
+				found += _search32(mem, size, block, value, params->op, &tmp, limit ? limit - found : 0);
+			} else if ((params->width == -1 && value > 0x100) || params->width == 2) {
+				found += _search16(mem, size, block, value, params->op, &tmp, limit ? limit - found : 0);
 			} else {
-				found += _search8(mem, size, block, value, &tmp, limit ? limit - found : 0);
+				found += _search8(mem, size, block, value, params->op, &tmp, limit ? limit - found : 0);
 			}
 			size_t i;
 			for (i = 0; i < mCoreMemorySearchResultsSize(&tmp); ++i) {
@@ -342,16 +206,12 @@ }
 
 static size_t _search(const void* mem, size_t size, const struct mCoreMemoryBlock* block, const struct mCoreMemorySearchParams* params, struct mCoreMemorySearchResults* out, size_t limit) {
 	switch (params->type) {
-	case mCORE_MEMORY_SEARCH_32:
-		return _search32(mem, size, block, params->value32, out, limit);
-	case mCORE_MEMORY_SEARCH_16:
-		return _search16(mem, size, block, params->value16, out, limit);
-	case mCORE_MEMORY_SEARCH_8:
-		return _search8(mem, size, block, params->value8, out, limit);
+	case mCORE_MEMORY_SEARCH_INT:
+		return _searchInt(mem, size, block, params, out, limit);
 	case mCORE_MEMORY_SEARCH_STRING:
-		return _searchStr(mem, size, block, params->valueStr, out, limit);
+		return _searchStr(mem, size, block, params->valueStr, params->width, out, limit);
 	case mCORE_MEMORY_SEARCH_GUESS:
-		return _searchGuess(mem, size, block, params->valueStr, out, limit);
+		return _searchGuess(mem, size, block, params, out, limit);
 	}
 }
 
@@ -378,34 +238,42 @@ found += _search(mem, size, block, params, out, limit ? limit - found : 0);
 	}
 }
 
-bool _testGuess(struct mCore* core, const struct mCoreMemorySearchResult* res, const struct mCoreMemorySearchParams* params) {
-	uint64_t value;
+bool _testGuess(struct mCore* core, struct mCoreMemorySearchResult* res, const struct mCoreMemorySearchParams* params) {
+	int64_t value;
+	int32_t offset = 0;
 	char* end;
+	if (params->op == mCORE_MEMORY_SEARCH_DELTA) {
+		offset = res->oldValue;
+	}
 
-	value = strtoull(params->valueStr, &end, 10);
+	value = strtoll(params->valueStr, &end, 10);
 	if (end) {
-		if (core->rawRead8(core, res->address, res->segment) * res->guessDivisor == value) {
+		res->oldValue += value;
+		if (_op(core->rawRead8(core, res->address, res->segment) * res->guessDivisor / res->guessMultiplier, value + offset, params->op)) {
 			return true;
 		}
-		if (!(res->address & 1) && core->rawRead16(core, res->address, res->segment) * res->guessDivisor == value) {
+		if (!(res->address & 1) && (res->width >= 2 || res->width == -1) && _op(core->rawRead16(core, res->address, res->segment) * res->guessDivisor / res->guessMultiplier, value + offset, params->op)) {
 			return true;
 		}
-		if (!(res->address & 3) && core->rawRead32(core, res->address, res->segment) * res->guessDivisor == value) {
+		if (!(res->address & 3) && (res->width >= 4 || res->width == -1) && _op(core->rawRead32(core, res->address, res->segment) * res->guessDivisor / res->guessMultiplier, value + offset, params->op)) {
 			return true;
 		}
+		res->oldValue -= value;
 	}
 
-	value = strtoull(params->valueStr, &end, 16);
+	value = strtoll(params->valueStr, &end, 16);
 	if (end) {
-		if (core->rawRead8(core, res->address, res->segment) * res->guessDivisor == value) {
+		res->oldValue += value;
+		if (_op(core->rawRead8(core, res->address, res->segment) * res->guessDivisor / res->guessMultiplier, value + offset, params->op)) {
 			return true;
 		}
-		if (!(res->address & 1) && core->rawRead16(core, res->address, res->segment) * res->guessDivisor == value) {
+		if (!(res->address & 1) && (res->width >= 2 || res->width == -1) && _op(core->rawRead16(core, res->address, res->segment) * res->guessDivisor / res->guessMultiplier, value + offset, params->op)) {
 			return true;
 		}
-		if (!(res->address & 3) && core->rawRead32(core, res->address, res->segment) * res->guessDivisor == value) {
+		if (!(res->address & 3) && (res->width >= 4 || res->width == -1) && _op(core->rawRead32(core, res->address, res->segment) * res->guessDivisor / res->guessMultiplier, value + offset, params->op)) {
 			return true;
 		}
+		res->oldValue -= value;
 	}
 	return false;
 }
@@ -415,76 +283,39 @@ size_t i;
 	for (i = 0; i < mCoreMemorySearchResultsSize(inout); ++i) {
 		struct mCoreMemorySearchResult* res = mCoreMemorySearchResultsGetPointer(inout, i);
 		switch (res->type) {
-		case mCORE_MEMORY_SEARCH_8:
-			switch (params->type) {
-			case mCORE_MEMORY_SEARCH_8:
-				if (core->rawRead8(core, res->address, res->segment) != params->value8) {
-					mCoreMemorySearchResultsShift(inout, i, 1);
-					--i;
-				}
-				break;
-			case mCORE_MEMORY_SEARCH_16:
-				if (core->rawRead8(core, res->address, res->segment) != params->value16) {
-					mCoreMemorySearchResultsShift(inout, i, 1);
-					--i;
-				}
-				break;
-			case mCORE_MEMORY_SEARCH_32:
-				if (core->rawRead32(core, res->address, res->segment) != params->value32) {
-					mCoreMemorySearchResultsShift(inout, i, 1);
-					--i;
-				}
-				break;
-			case mCORE_MEMORY_SEARCH_GUESS:
+		case mCORE_MEMORY_SEARCH_INT:
+			if (params->type == mCORE_MEMORY_SEARCH_GUESS) {
 				if (!_testGuess(core, res, params)) {
-					mCoreMemorySearchResultsShift(inout, i, 1);
+					*res = *mCoreMemorySearchResultsGetPointer(inout, mCoreMemorySearchResultsSize(inout) - 1);
+					mCoreMemorySearchResultsResize(inout, -1);
 					--i;
 				}
-				break;
-			default:
-				break;
-			}
-			break;
-		case mCORE_MEMORY_SEARCH_16:
-			switch (params->type) {
-			case mCORE_MEMORY_SEARCH_16:
-				if (core->rawRead16(core, res->address, res->segment) != params->value16) {
-					mCoreMemorySearchResultsShift(inout, i, 1);
-					--i;
+			} else if (params->type == mCORE_MEMORY_SEARCH_INT) {
+				int32_t oldValue = params->valueInt;
+				if (params->op == mCORE_MEMORY_SEARCH_DELTA) {
+					oldValue += res->oldValue;
 				}
-				break;
-			case mCORE_MEMORY_SEARCH_32:
-				if (core->rawRead32(core, res->address, res->segment) != params->value32) {
-					mCoreMemorySearchResultsShift(inout, i, 1);
-					--i;
+				int32_t value = 0;
+				switch (params->width) {
+				case 1:
+					value = core->rawRead8(core, res->address, res->segment);
+					break;
+				case 2:
+					value = core->rawRead16(core, res->address, res->segment);
+					break;
+				case 4:
+					value = core->rawRead32(core, res->address, res->segment);
+					break;
+				default:
+					break;
 				}
-				break;
-			case mCORE_MEMORY_SEARCH_GUESS:
-				if (!_testGuess(core, res, params)) {
-					mCoreMemorySearchResultsShift(inout, i, 1);
+				if (!_op(value, oldValue, params->op)) {
+					*res = *mCoreMemorySearchResultsGetPointer(inout, mCoreMemorySearchResultsSize(inout) - 1);
+					mCoreMemorySearchResultsResize(inout, -1);
 					--i;
+				} else {
+					res->oldValue = value;
 				}
-				break;
-			default:
-				break;
-			}
-			break;
-		case mCORE_MEMORY_SEARCH_32:
-			switch (params->type) {
-			case mCORE_MEMORY_SEARCH_32:
-				if (core->rawRead32(core, res->address, res->segment) != params->value32) {
-					mCoreMemorySearchResultsShift(inout, i, 1);
-					--i;
-				}
-				break;
-			case mCORE_MEMORY_SEARCH_GUESS:
-				if (!_testGuess(core, res, params)) {
-					mCoreMemorySearchResultsShift(inout, i, 1);
-					--i;
-				}
-				break;
-			default:
-				break;
 			}
 			break;
 		case mCORE_MEMORY_SEARCH_STRING:

@@ -623,6 +623,12 @@ UNUSED(level);
 	printf("%s: ", mLogCategoryName(category));
 	vprintf(format, args);
 	printf("\n");
+	struct mCoreThread* thread = mCoreThreadGet();
+	if (thread && level == mLOG_FATAL) {
+#ifndef DISABLE_THREADING
+		mCoreThreadMarkCrashed(thread);
+#endif
+	}
 }
 
 struct mLogger* mCoreThreadLogger(void) {

@@ -26,6 +26,7 @@ #endif
 
 const char* ERROR_MISSING_ARGS = "Arguments missing"; // TODO: share
 const char* ERROR_OVERFLOW = "Arguments overflow";
+const char* ERROR_INVALID_ARGS = "Invalid arguments";
 
 #if !defined(NDEBUG) && !defined(_WIN32)
 static void _breakInto(struct CLIDebugger*, struct CLIDebugVector*);
@@ -51,6 +52,7 @@ static void _setWriteWatchpoint(struct CLIDebugger*, struct CLIDebugVector*);
 static void _trace(struct CLIDebugger*, struct CLIDebugVector*);
 static void _writeByte(struct CLIDebugger*, struct CLIDebugVector*);
 static void _writeHalfword(struct CLIDebugger*, struct CLIDebugVector*);
+static void _writeRegister(struct CLIDebugger*, struct CLIDebugVector*);
 static void _writeWord(struct CLIDebugger*, struct CLIDebugVector*);
 static void _dumpByte(struct CLIDebugger*, struct CLIDebugVector*);
 static void _dumpHalfword(struct CLIDebugger*, struct CLIDebugVector*);
@@ -60,50 +62,51 @@ static void _source(struct CLIDebugger*, struct CLIDebugVector*);
 #endif
 
 static struct CLIDebuggerCommandSummary _debuggerCommands[] = {
-	{ "b", _setBreakpoint, CLIDVParse, "Set a breakpoint" },
-	{ "break", _setBreakpoint, CLIDVParse, "Set a breakpoint" },
-	{ "c", _continue, 0, "Continue execution" },
-	{ "continue", _continue, 0, "Continue execution" },
-	{ "d", _clearBreakpoint, CLIDVParse, "Delete a breakpoint" },
-	{ "delete", _clearBreakpoint, CLIDVParse, "Delete a breakpoint" },
-	{ "dis", _disassemble, CLIDVParse, "Disassemble instructions" },
-	{ "disasm", _disassemble, CLIDVParse, "Disassemble instructions" },
-	{ "disassemble", _disassemble, CLIDVParse, "Disassemble instructions" },
-	{ "h", _printHelp, CLIDVStringParse, "Print help" },
-	{ "help", _printHelp, CLIDVStringParse, "Print help" },
-	{ "i", _printStatus, 0, "Print the current status" },
-	{ "info", _printStatus, 0, "Print the current status" },
-	{ "n", _next, 0, "Execute next instruction" },
-	{ "next", _next, 0, "Execute next instruction" },
-	{ "p", _print, CLIDVParse, "Print a value" },
-	{ "p/t", _printBin, CLIDVParse, "Print a value as binary" },
-	{ "p/x", _printHex, CLIDVParse, "Print a value as hexadecimal" },
-	{ "print", _print, CLIDVParse, "Print a value" },
-	{ "print/t", _printBin, CLIDVParse, "Print a value as binary" },
-	{ "print/x", _printHex, CLIDVParse, "Print a value as hexadecimal" },
-	{ "q", _quit, 0, "Quit the emulator" },
-	{ "quit", _quit, 0, "Quit the emulator" },
-	{ "reset", _reset, 0, "Reset the emulation" },
-	{ "r/1", _readByte, CLIDVParse, "Read a byte from a specified offset" },
-	{ "r/2", _readHalfword, CLIDVParse, "Read a halfword from a specified offset" },
-	{ "r/4", _readWord, CLIDVParse, "Read a word from a specified offset" },
-	{ "status", _printStatus, 0, "Print the current status" },
-	{ "trace", _trace, CLIDVParse, "Trace a fixed number of instructions" },
-	{ "w", _setWatchpoint, CLIDVParse, "Set a watchpoint" },
-	{ "w/1", _writeByte, CLIDVParse, "Write a byte at a specified offset" },
-	{ "w/2", _writeHalfword, CLIDVParse, "Write a halfword at a specified offset" },
-	{ "w/4", _writeWord, CLIDVParse, "Write a word at a specified offset" },
-	{ "watch", _setWatchpoint, CLIDVParse, "Set a watchpoint" },
-	{ "watch/r", _setReadWatchpoint, CLIDVParse, "Set a read watchpoint" },
-	{ "watch/w", _setWriteWatchpoint, CLIDVParse, "Set a write watchpoint" },
-	{ "x/1", _dumpByte, CLIDVParse, "Examine bytes at a specified offset" },
-	{ "x/2", _dumpHalfword, CLIDVParse, "Examine halfwords at a specified offset" },
-	{ "x/4", _dumpWord, CLIDVParse, "Examine words at a specified offset" },
+	{ "b", _setBreakpoint, "Is", "Set a breakpoint" },
+	{ "break", _setBreakpoint, "Is", "Set a breakpoint" },
+	{ "c", _continue, "", "Continue execution" },
+	{ "continue", _continue, "", "Continue execution" },
+	{ "d", _clearBreakpoint, "I", "Delete a breakpoint" },
+	{ "delete", _clearBreakpoint, "I", "Delete a breakpoint" },
+	{ "dis", _disassemble, "Ii", "Disassemble instructions" },
+	{ "disasm", _disassemble, "Ii", "Disassemble instructions" },
+	{ "disassemble", _disassemble, "Ii", "Disassemble instructions" },
+	{ "h", _printHelp, "S", "Print help" },
+	{ "help", _printHelp, "S", "Print help" },
+	{ "i", _printStatus, "", "Print the current status" },
+	{ "info", _printStatus, "", "Print the current status" },
+	{ "n", _next, "", "Execute next instruction" },
+	{ "next", _next, "", "Execute next instruction" },
+	{ "p", _print, "I", "Print a value" },
+	{ "p/t", _printBin, "I", "Print a value as binary" },
+	{ "p/x", _printHex, "I", "Print a value as hexadecimal" },
+	{ "print", _print, "I", "Print a value" },
+	{ "print/t", _printBin, "I", "Print a value as binary" },
+	{ "print/x", _printHex, "I", "Print a value as hexadecimal" },
+	{ "q", _quit, "", "Quit the emulator" },
+	{ "quit", _quit, "", "Quit the emulator" },
+	{ "reset", _reset, "", "Reset the emulation" },
+	{ "r/1", _readByte, "I", "Read a byte from a specified offset" },
+	{ "r/2", _readHalfword, "I", "Read a halfword from a specified offset" },
+	{ "r/4", _readWord, "I", "Read a word from a specified offset" },
+	{ "status", _printStatus, "", "Print the current status" },
+	{ "trace", _trace, "I", "Trace a fixed number of instructions" },
+	{ "w", _setWatchpoint, "Is", "Set a watchpoint" },
+	{ "w/1", _writeByte, "II", "Write a byte at a specified offset" },
+	{ "w/2", _writeHalfword, "II", "Write a halfword at a specified offset" },
+	{ "w/r", _writeRegister, "SI", "Write a register" },
+	{ "w/4", _writeWord, "II", "Write a word at a specified offset" },
+	{ "watch", _setWatchpoint, "Is", "Set a watchpoint" },
+	{ "watch/r", _setReadWatchpoint, "Is", "Set a read watchpoint" },
+	{ "watch/w", _setWriteWatchpoint, "Is", "Set a write watchpoint" },
+	{ "x/1", _dumpByte, "Ii", "Examine bytes at a specified offset" },
+	{ "x/2", _dumpHalfword, "Ii", "Examine halfwords at a specified offset" },
+	{ "x/4", _dumpWord, "Ii", "Examine words at a specified offset" },
 #ifdef ENABLE_SCRIPTING
-	{ "source", _source, CLIDVStringParse, "Load a script" },
+	{ "source", _source, "S", "Load a script" },
 #endif
 #if !defined(NDEBUG) && !defined(_WIN32)
-	{ "!", _breakInto, 0, "Break into attached debugger (for developers)" },
+	{ "!", _breakInto, "", "Break into attached debugger (for developers)" },
 #endif
 	{ 0, 0, 0, 0 }
 };
@@ -273,12 +276,12 @@ debugger->backend->printf(debugger->backend, " 0x%08X\n", value);
 }
 
 static void _writeByte(struct CLIDebugger* debugger, struct CLIDebugVector* dv) {
-	if (!dv || dv->type != CLIDV_INT_TYPE) {
+	if (!dv || !dv->next) {
 		debugger->backend->printf(debugger->backend, "%s\n", ERROR_MISSING_ARGS);
 		return;
 	}
-	if (!dv->next || dv->next->type != CLIDV_INT_TYPE) {
-		debugger->backend->printf(debugger->backend, "%s\n", ERROR_MISSING_ARGS);
+	if (dv->type != CLIDV_INT_TYPE || dv->next->type != CLIDV_INT_TYPE) {
+		debugger->backend->printf(debugger->backend, "%s\n", ERROR_INVALID_ARGS);
 		return;
 	}
 	uint32_t address = dv->intValue;
@@ -295,12 +298,12 @@ }
 }
 
 static void _writeHalfword(struct CLIDebugger* debugger, struct CLIDebugVector* dv) {
-	if (!dv || dv->type != CLIDV_INT_TYPE) {
+	if (!dv || !dv->next) {
 		debugger->backend->printf(debugger->backend, "%s\n", ERROR_MISSING_ARGS);
 		return;
 	}
-	if (!dv->next || dv->next->type != CLIDV_INT_TYPE) {
-		debugger->backend->printf(debugger->backend, "%s\n", ERROR_MISSING_ARGS);
+	if (dv->type != CLIDV_INT_TYPE || dv->next->type != CLIDV_INT_TYPE) {
+		debugger->backend->printf(debugger->backend, "%s\n", ERROR_INVALID_ARGS);
 		return;
 	}
 	uint32_t address = dv->intValue;
@@ -316,13 +319,27 @@ debugger->d.core->busWrite16(debugger->d.core, address, value);
 	}
 }
 
+static void _writeRegister(struct CLIDebugger* debugger, struct CLIDebugVector* dv) {
+	if (!dv || !dv->next) {
+		debugger->backend->printf(debugger->backend, "%s\n", ERROR_MISSING_ARGS);
+		return;
+	}
+	if (dv->type != CLIDV_CHAR_TYPE || dv->next->type != CLIDV_INT_TYPE) {
+		debugger->backend->printf(debugger->backend, "%s\n", ERROR_INVALID_ARGS);
+		return;
+	}
+	if (!debugger->d.platform->setRegister(debugger->d.platform, dv->charValue, dv->next->intValue)) {
+		debugger->backend->printf(debugger->backend, "%s\n", ERROR_INVALID_ARGS);
+	}
+}
+
 static void _writeWord(struct CLIDebugger* debugger, struct CLIDebugVector* dv) {
-	if (!dv || dv->type != CLIDV_INT_TYPE) {
+	if (!dv || !dv->next) {
 		debugger->backend->printf(debugger->backend, "%s\n", ERROR_MISSING_ARGS);
 		return;
 	}
-	if (!dv->next || dv->next->type != CLIDV_INT_TYPE) {
-		debugger->backend->printf(debugger->backend, "%s\n", ERROR_MISSING_ARGS);
+	if (dv->type != CLIDV_INT_TYPE || dv->next->type != CLIDV_INT_TYPE) {
+		debugger->backend->printf(debugger->backend, "%s\n", ERROR_INVALID_ARGS);
 		return;
 	}
 	uint32_t address = dv->intValue;
@@ -435,13 +452,53 @@ }
 }
 #endif
 
+static struct ParseTree* _parseTree(const char* string) {
+	struct LexVector lv;
+	bool error = false;
+	LexVectorInit(&lv, 0);
+	size_t length = strlen(string);
+	size_t adjusted = lexExpression(&lv, string, length, NULL);
+	struct ParseTree* tree = malloc(sizeof(*tree));
+	if (!adjusted) {
+		error = true;
+	} else {
+		parseLexedExpression(tree, &lv);
+
+		if (adjusted > length) {
+			error = true;
+		} else {
+			length -= adjusted;
+			string += adjusted;
+		}
+	}
+	lexFree(&lv);
+	LexVectorClear(&lv);
+	LexVectorDeinit(&lv);
+	if (error) {
+		parseFree(tree);
+		free(tree);
+		return NULL;
+	} else {
+		return tree;
+	}
+}
+
 static void _setBreakpoint(struct CLIDebugger* debugger, struct CLIDebugVector* dv) {
 	if (!dv || dv->type != CLIDV_INT_TYPE) {
 		debugger->backend->printf(debugger->backend, "%s\n", ERROR_MISSING_ARGS);
 		return;
 	}
 	uint32_t address = dv->intValue;
-	debugger->d.platform->setBreakpoint(debugger->d.platform, address, dv->segmentValue);
+	if (dv->next && dv->next->type == CLIDV_CHAR_TYPE) {
+		struct ParseTree* tree = _parseTree(dv->next->charValue);
+		if (tree) {
+			debugger->d.platform->setConditionalBreakpoint(debugger->d.platform, address, dv->segmentValue, tree);
+		} else {
+			debugger->backend->printf(debugger->backend, "%s\n", ERROR_INVALID_ARGS);
+		}
+	} else {
+		debugger->d.platform->setBreakpoint(debugger->d.platform, address, dv->segmentValue);
+	}
 }
 
 static void _setWatchpoint(struct CLIDebugger* debugger, struct CLIDebugVector* dv) {
@@ -454,7 +511,16 @@ debugger->backend->printf(debugger->backend, "Watchpoints are not supported by this platform.\n");
 		return;
 	}
 	uint32_t address = dv->intValue;
-	debugger->d.platform->setWatchpoint(debugger->d.platform, address, dv->segmentValue, WATCHPOINT_RW);
+	if (dv->next && dv->next->type == CLIDV_CHAR_TYPE) {
+		struct ParseTree* tree = _parseTree(dv->next->charValue);
+		if (tree) {
+			debugger->d.platform->setConditionalWatchpoint(debugger->d.platform, address, dv->segmentValue, WATCHPOINT_RW, tree);
+		} else {
+			debugger->backend->printf(debugger->backend, "%s\n", ERROR_INVALID_ARGS);
+		}
+	} else {
+		debugger->d.platform->setWatchpoint(debugger->d.platform, address, dv->segmentValue, WATCHPOINT_RW);
+	}
 }
 
 static void _setReadWatchpoint(struct CLIDebugger* debugger, struct CLIDebugVector* dv) {
@@ -467,7 +533,16 @@ debugger->backend->printf(debugger->backend, "Watchpoints are not supported by this platform.\n");
 		return;
 	}
 	uint32_t address = dv->intValue;
-	debugger->d.platform->setWatchpoint(debugger->d.platform, address, dv->segmentValue, WATCHPOINT_READ);
+	if (dv->next && dv->next->type == CLIDV_CHAR_TYPE) {
+		struct ParseTree* tree = _parseTree(dv->next->charValue);
+		if (tree) {
+			debugger->d.platform->setConditionalWatchpoint(debugger->d.platform, address, dv->segmentValue, WATCHPOINT_READ, tree);
+		} else {
+			debugger->backend->printf(debugger->backend, "%s\n", ERROR_INVALID_ARGS);
+		}
+	} else {
+		debugger->d.platform->setWatchpoint(debugger->d.platform, address, dv->segmentValue, WATCHPOINT_READ);
+	}
 }
 
 static void _setWriteWatchpoint(struct CLIDebugger* debugger, struct CLIDebugVector* dv) {
@@ -480,8 +555,16 @@ debugger->backend->printf(debugger->backend, "Watchpoints are not supported by this platform.\n");
 		return;
 	}
 	uint32_t address = dv->intValue;
-	debugger->d.platform->setWatchpoint(debugger->d.platform, address, dv->segmentValue, WATCHPOINT_WRITE);
-}
+	if (dv->next && dv->next->type == CLIDV_CHAR_TYPE) {
+		struct ParseTree* tree = _parseTree(dv->next->charValue);
+		if (tree) {
+			debugger->d.platform->setConditionalWatchpoint(debugger->d.platform, address, dv->segmentValue, WATCHPOINT_WRITE, tree);
+		} else {
+			debugger->backend->printf(debugger->backend, "%s\n", ERROR_INVALID_ARGS);
+		}
+	} else {
+		debugger->d.platform->setWatchpoint(debugger->d.platform, address, dv->segmentValue, WATCHPOINT_WRITE);
+	}}
 
 static void _clearBreakpoint(struct CLIDebugger* debugger, struct CLIDebugVector* dv) {
 	if (!dv || dv->type != CLIDV_INT_TYPE) {
@@ -521,86 +604,6 @@ UNUSED(dv);
 	debugger->system->printStatus(debugger->system);
 }
 
-static uint32_t _performOperation(enum Operation operation, uint32_t current, uint32_t next, struct CLIDebugVector* dv) {
-	switch (operation) {
-	case OP_ASSIGN:
-		current = next;
-		break;
-	case OP_ADD:
-		current += next;
-		break;
-	case OP_SUBTRACT:
-		current -= next;
-		break;
-	case OP_MULTIPLY:
-		current *= next;
-		break;
-	case OP_DIVIDE:
-		if (next != 0) {
-			current /= next;
-		} else {
-			dv->type = CLIDV_ERROR_TYPE;
-			return 0;
-		}
-		break;
-	}
-	return current;
-}
-
-static void _lookupIdentifier(struct mDebugger* debugger, const char* name, struct CLIDebugVector* dv) {
-	struct CLIDebugger* cliDebugger = (struct CLIDebugger*) debugger;
-	if (cliDebugger->system) {
-		uint32_t value;
-#ifdef ENABLE_SCRIPTING
-		if (debugger->bridge && mScriptBridgeLookupSymbol(debugger->bridge, name, &dv->intValue)) {
-			return;
-		}
-#endif
-		if (debugger->core->symbolTable && mDebuggerSymbolLookup(debugger->core->symbolTable, name, &dv->intValue, &dv->segmentValue)) {
-			return;
-		}
-		value = cliDebugger->system->lookupPlatformIdentifier(cliDebugger->system, name, dv);
-		if (dv->type != CLIDV_ERROR_TYPE) {
-			dv->intValue = value;
-			return;
-		}
-		dv->type = CLIDV_INT_TYPE;
-		value = cliDebugger->system->lookupIdentifier(cliDebugger->system, name, dv);
-		if (dv->type != CLIDV_ERROR_TYPE) {
-			dv->intValue = value;
-			return;
-		}
-	}
-	dv->type = CLIDV_ERROR_TYPE;
-}
-
-static void _evaluateParseTree(struct mDebugger* debugger, struct ParseTree* tree, struct CLIDebugVector* dv) {
-	int32_t lhs, rhs;
-	switch (tree->token.type) {
-	case TOKEN_UINT_TYPE:
-		dv->intValue = tree->token.uintValue;
-		break;
-	case TOKEN_SEGMENT_TYPE:
-		_evaluateParseTree(debugger, tree->lhs, dv);
-		dv->segmentValue = dv->intValue;
-		_evaluateParseTree(debugger, tree->rhs, dv);
-		break;
-	case TOKEN_OPERATOR_TYPE:
-		_evaluateParseTree(debugger, tree->lhs, dv);
-		lhs = dv->intValue;
-		_evaluateParseTree(debugger, tree->rhs, dv);
-		rhs = dv->intValue;
-		dv->intValue = _performOperation(tree->token.operatorValue, lhs, rhs, dv);
-		break;
-	case TOKEN_IDENTIFIER_TYPE:
-		_lookupIdentifier(debugger, tree->token.identifierValue, dv);
-		break;
-	case TOKEN_ERROR_TYPE:
-	default:
-		dv->type = CLIDV_ERROR_TYPE;
-	}
-}
-
 struct CLIDebugVector* CLIDVParse(struct CLIDebugger* debugger, const char* string, size_t length) {
 	if (!string || length < 1) {
 		return 0;
@@ -608,11 +611,11 @@ }
 
 	struct CLIDebugVector dvTemp = { .type = CLIDV_INT_TYPE, .segmentValue = -1 };
 
-	struct LexVector lv = { .next = 0 };
-	size_t adjusted = lexExpression(&lv, string, length);
+	struct LexVector lv;
+	LexVectorInit(&lv, 0);
+	size_t adjusted = lexExpression(&lv, string, length, " ");
 	if (adjusted > length) {
 		dvTemp.type = CLIDV_ERROR_TYPE;
-		lexFree(lv.next);
 	}
 
 	struct ParseTree tree;
@@ -620,14 +623,15 @@ parseLexedExpression(&tree, &lv);
 	if (tree.token.type == TOKEN_ERROR_TYPE) {
 		dvTemp.type = CLIDV_ERROR_TYPE;
 	} else {
-		_evaluateParseTree(&debugger->d, &tree, &dvTemp);
+		if (!mDebuggerEvaluateParseTree(&debugger->d, &tree, &dvTemp.intValue, &dvTemp.segmentValue)) {
+			dvTemp.type = CLIDV_ERROR_TYPE;
+		}
 	}
 
-	parseFree(tree.lhs);
-	parseFree(tree.rhs);
+	parseFree(&tree);
 
-	length -= adjusted;
-	string += adjusted;
+	lexFree(&lv);
+	LexVectorDeinit(&lv);
 
 	struct CLIDebugVector* dv = malloc(sizeof(struct CLIDebugVector));
 	if (dvTemp.type == CLIDV_ERROR_TYPE) {
@@ -635,43 +639,22 @@ dv->type = CLIDV_ERROR_TYPE;
 		dv->next = 0;
 	} else {
 		*dv = dvTemp;
-		if (string[0] == ' ') {
-			dv->next = CLIDVParse(debugger, string + 1, length - 1);
-			if (dv->next && dv->next->type == CLIDV_ERROR_TYPE) {
-				dv->type = CLIDV_ERROR_TYPE;
-			}
-		}
 	}
 	return dv;
 }
 
 struct CLIDebugVector* CLIDVStringParse(struct CLIDebugger* debugger, const char* string, size_t length) {
+	UNUSED(debugger);
 	if (!string || length < 1) {
 		return 0;
 	}
 
 	struct CLIDebugVector dvTemp = { .type = CLIDV_CHAR_TYPE };
 
-	size_t adjusted;
-	const char* next = strchr(string, ' ');
-	if (next) {
-		adjusted = next - string;
-	} else {
-		adjusted = length;
-	}
-	dvTemp.charValue = strndup(string, adjusted);
-
-	length -= adjusted;
-	string += adjusted;
+	dvTemp.charValue = strndup(string, length);
 
 	struct CLIDebugVector* dv = malloc(sizeof(struct CLIDebugVector));
 	*dv = dvTemp;
-	if (string[0] == ' ') {
-		dv->next = CLIDVStringParse(debugger, string + 1, length - 1);
-		if (dv->next && dv->next->type == CLIDV_ERROR_TYPE) {
-			dv->type = CLIDV_ERROR_TYPE;
-		}
-	}
 	return dv;
 }
 
@@ -687,8 +670,28 @@ dv = next;
 	}
 }
 
+static struct CLIDebugVector* _parseArg(struct CLIDebugger* debugger, const char* args, size_t argsLen, char type) {
+	struct CLIDebugVector* dv = NULL;
+	switch (type) {
+	case 'I':
+	case 'i':
+		return CLIDVParse(debugger, args, argsLen);
+	case 'S':
+	case 's':
+		return CLIDVStringParse(debugger, args, argsLen);
+	case '*':
+		dv = _parseArg(debugger, args, argsLen, 'I');
+		if (!dv) {
+			dv = _parseArg(debugger, args, argsLen, 'S');
+		}
+		break;
+	}
+	return dv;
+}
+
 static int _tryCommands(struct CLIDebugger* debugger, struct CLIDebuggerCommandSummary* commands, const char* command, size_t commandLen, const char* args, size_t argsLen) {
-	struct CLIDebugVector* dv = 0;
+	struct CLIDebugVector* dv = NULL;
+	struct CLIDebugVector* dvLast = NULL;
 	int i;
 	const char* name;
 	for (i = 0; (name = commands[i].name); ++i) {
@@ -696,22 +699,78 @@ if (strlen(name) != commandLen) {
 			continue;
 		}
 		if (strncasecmp(name, command, commandLen) == 0) {
-			if (commands[i].parser) {
-				if (args) {
-					dv = commands[i].parser(debugger, args, argsLen);
-					if (dv && dv->type == CLIDV_ERROR_TYPE) {
+			if (commands[i].format && args) {
+				char lastArg = '\0';
+				int arg;
+				for (arg = 0; commands[i].format[arg] && argsLen; ++arg) {
+					while (isspace(args[0]) && argsLen) {
+						++args;
+						--argsLen;
+					}
+					if (!args[0] || !argsLen) {
+						debugger->backend->printf(debugger->backend, "Wrong number of arguments\n");
+						_DVFree(dv);
+						return 0;
+					}
+
+					size_t adjusted;
+					const char* next = strchr(args, ' ');
+					if (next) {
+						adjusted = next - args;
+					} else {
+						adjusted = argsLen;
+					}
+
+					struct CLIDebugVector* dvNext = NULL;
+					bool nextArgMandatory = false;
+
+					if (commands[i].format[arg] == '+') {
+						dvNext = _parseArg(debugger, args, adjusted, lastArg);
+						--args;
+					} else {
+						nextArgMandatory = isupper(commands[i].format[arg]) || (commands[i].format[arg] == '*');
+						dvNext = _parseArg(debugger, args, adjusted, commands[i].format[arg]);
+					}
+
+					args += adjusted;
+					argsLen -= adjusted;
+
+					if (!dvNext) {
+						if (!nextArgMandatory) {
+							args = NULL;
+						}
+						break;
+					}
+					if (dvNext->type == CLIDV_ERROR_TYPE) {
 						debugger->backend->printf(debugger->backend, "Parse error\n");
 						_DVFree(dv);
-						return false;
+						return 0;
+					}
+
+					if (dvLast) {
+						dvLast->next = dvNext;
+						dvLast = dvNext;
+					} else {
+						dv = dvNext;
+						dvLast = dv;
 					}
 				}
-			} else if (args) {
+			}
+
+			if (args) {
+				while (isspace(args[0]) && argsLen) {
+					++args;
+					--argsLen;
+				}
+			}
+			if (args && argsLen) {
 				debugger->backend->printf(debugger->backend, "Wrong number of arguments\n");
-				return false;
+				_DVFree(dv);
+				return 0;
 			}
 			commands[i].command(debugger, dv);
 			_DVFree(dv);
-			return true;
+			return 1;
 		}
 	}
 	return -1;
@@ -781,10 +840,10 @@ }
 		break;
 	case DEBUGGER_ENTER_WATCHPOINT:
 		if (info) {
-			if (info->accessType & WATCHPOINT_WRITE) {
-				cliDebugger->backend->printf(cliDebugger->backend, "Hit watchpoint at 0x%08X: (new value = 0x%08x, old value = 0x%08X)\n", info->address, info->newValue, info->oldValue);
+			if (info->type.wp.accessType & WATCHPOINT_WRITE) {
+				cliDebugger->backend->printf(cliDebugger->backend, "Hit watchpoint at 0x%08X: (new value = 0x%08x, old value = 0x%08X)\n", info->address, info->type.wp.newValue, info->type.wp.oldValue);
 			} else {
-				cliDebugger->backend->printf(cliDebugger->backend, "Hit watchpoint at 0x%08X: (value = 0x%08x)\n", info->address, info->oldValue);
+				cliDebugger->backend->printf(cliDebugger->backend, "Hit watchpoint at 0x%08X: (value = 0x%08x)\n", info->address, info->type.wp.oldValue);
 			}
 		} else {
 			cliDebugger->backend->printf(cliDebugger->backend, "Hit watchpoint\n");
@@ -792,7 +851,7 @@ }
 		break;
 	case DEBUGGER_ENTER_ILLEGAL_OP:
 		if (info) {
-			cliDebugger->backend->printf(cliDebugger->backend, "Hit illegal opcode at 0x%08X: 0x%08X\n", info->address, info->opcode);
+			cliDebugger->backend->printf(cliDebugger->backend, "Hit illegal opcode at 0x%08X: 0x%08X\n", info->address, info->type.bp.opcode);
 		} else {
 			cliDebugger->backend->printf(cliDebugger->backend, "Hit illegal opcode\n");
 		}

@@ -8,6 +8,7 @@
 #include <mgba/core/core.h>
 
 #include <mgba/internal/debugger/cli-debugger.h>
+#include <mgba/internal/debugger/symbols.h>
 
 #ifdef USE_GDB_STUB
 #include <mgba/internal/debugger/gdb-stub.h>
@@ -137,3 +138,22 @@ debugger->deinit(debugger);
 	}
 	debugger->platform->deinit(debugger->platform);
 }
+
+bool mDebuggerLookupIdentifier(struct mDebugger* debugger, const char* name, int32_t* value, int* segment) {
+	*segment = -1;
+#ifdef ENABLE_SCRIPTING
+	if (debugger->bridge && mScriptBridgeLookupSymbol(debugger->bridge, name, value)) {
+		return true;
+	}
+#endif
+	if (debugger->core->symbolTable && mDebuggerSymbolLookup(debugger->core->symbolTable, name, value, segment)) {
+		return true;
+	}
+	if (debugger->core->lookupIdentifier(debugger->core, name, value, segment)) {
+		return true;
+	}
+	if (debugger->platform && debugger->platform->getRegister(debugger->platform, name, value)) {
+		return true;
+	}
+	return false;
+}

@@ -46,7 +46,7 @@ snprintf(stub->outgoing, GDB_STUB_MAX_LINE - 4, "S%02x", SIGINT);
 		break;
 	case DEBUGGER_ENTER_BREAKPOINT:
 		if (stub->supportsHwbreak && stub->supportsSwbreak && info) {
-			snprintf(stub->outgoing, GDB_STUB_MAX_LINE - 4, "T%02x%cwbreak:;", SIGTRAP, info->breakType == BREAKPOINT_SOFTWARE ? 's' : 'h');
+			snprintf(stub->outgoing, GDB_STUB_MAX_LINE - 4, "T%02x%cwbreak:;", SIGTRAP, info->type.bp.breakType == BREAKPOINT_SOFTWARE ? 's' : 'h');
 		} else {
 			snprintf(stub->outgoing, GDB_STUB_MAX_LINE - 4, "S%02xk", SIGTRAP);
 		}
@@ -54,9 +54,9 @@ break;
 	case DEBUGGER_ENTER_WATCHPOINT:
 		if (info) {
 			const char* type = 0;
-			switch (info->watchType) {
+			switch (info->type.wp.watchType) {
 			case WATCHPOINT_WRITE:
-				if (info->newValue == info->oldValue) {
+				if (info->type.wp.newValue == info->type.wp.oldValue) {
 					if (stub->d.state == DEBUGGER_PAUSED) {
 						stub->d.state = DEBUGGER_RUNNING;
 					}
@@ -363,7 +363,7 @@
 #ifdef _MSC_VER
 	value = _byteswap_ulong(value);
 #else
-	value = __builtin_bswap32(value);
+	LOAD_32BE(value, 0, &value);
 #endif
 
 	if (reg <= ARM_PC) {

@@ -5,39 +5,181 @@ * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 #include <mgba/internal/debugger/parser.h>
 
+#include <mgba/debugger/debugger.h>
 #include <mgba-util/string.h>
 
-static struct LexVector* _lexOperator(struct LexVector* lv, char operator) {
-	struct LexVector* lvNext = malloc(sizeof(struct LexVector));
-	lvNext->token.type = TOKEN_OPERATOR_TYPE;
+DEFINE_VECTOR(LexVector, struct Token);
+
+enum LexState {
+	LEX_ERROR = -1,
+	LEX_ROOT = 0,
+	LEX_EXPECT_IDENTIFIER,
+	LEX_EXPECT_BINARY_FIRST,
+	LEX_EXPECT_BINARY,
+	LEX_EXPECT_DECIMAL,
+	LEX_EXPECT_HEX_FIRST,
+	LEX_EXPECT_HEX,
+	LEX_EXPECT_PREFIX,
+	LEX_EXPECT_OPERATOR,
+	LEX_EXPECT_OPERATOR2,
+};
+
+static void _lexOperator(struct LexVector* lv, char operator, enum LexState* state) {
+	if (*state == LEX_EXPECT_OPERATOR2) {
+		struct Token* lvNext = LexVectorGetPointer(lv, LexVectorSize(lv) - 1);
+		if (lvNext->type != TOKEN_OPERATOR_TYPE) {
+			lvNext->type = TOKEN_ERROR_TYPE;
+			*state = LEX_ERROR;
+			return;
+		}
+		switch (lvNext->operatorValue) {
+		case OP_AND:
+			if (operator == '&') {
+				lvNext->operatorValue = OP_LOGICAL_AND;
+				*state = LEX_ROOT;
+				return;
+			}
+			break;
+		case OP_OR:
+			if (operator == '|') {
+				lvNext->operatorValue = OP_LOGICAL_OR;
+				*state = LEX_ROOT;
+				return;
+			}
+			break;
+		case OP_LESS:
+			if (operator == '=') {
+				lvNext->operatorValue = OP_LE;
+				*state = LEX_ROOT;
+				return;
+			}
+			if (operator == '<') {
+				lvNext->operatorValue = OP_SHIFT_L;
+				*state = LEX_ROOT;
+				return;
+			}
+			break;
+		case OP_GREATER:
+			if (operator == '=') {
+				lvNext->operatorValue = OP_GE;
+				*state = LEX_ROOT;
+				return;
+			}
+			if (operator == '>') {
+				lvNext->operatorValue = OP_SHIFT_R;
+				*state = LEX_ROOT;
+				return;
+			}
+			break;
+		case OP_ASSIGN:
+			if (operator == '=') {
+				lvNext->operatorValue = OP_EQUAL;
+				*state = LEX_ROOT;
+				return;
+			}
+			break;
+		case OP_NOT:
+			if (operator == '=') {
+				lvNext->operatorValue = OP_NOT_EQUAL;
+				*state = LEX_ROOT;
+				return;
+			}
+			break;
+		default:
+			break;
+		}
+		*state = LEX_ERROR;
+		return;
+	}
+	struct Token* lvNext = LexVectorAppend(lv);
+	lvNext->type = TOKEN_OPERATOR_TYPE;
+	*state = LEX_EXPECT_OPERATOR2;
 	switch (operator) {
+	case '=':
+		lvNext->operatorValue = OP_ASSIGN;
+		break;
 	case '+':
-		lvNext->token.operatorValue = OP_ADD;
+		lvNext->operatorValue = OP_ADD;
 		break;
 	case '-':
-		lvNext->token.operatorValue = OP_SUBTRACT;
+		lvNext->operatorValue = OP_SUBTRACT;
 		break;
 	case '*':
-		lvNext->token.operatorValue = OP_MULTIPLY;
+		lvNext->operatorValue = OP_MULTIPLY;
+		break;
+	case '/':
+		lvNext->operatorValue = OP_DIVIDE;
+		break;
+	case '%':
+		lvNext->operatorValue = OP_MODULO;
+		break;
+	case '&':
+		lvNext->operatorValue = OP_AND;
+		break;
+	case '|':
+		lvNext->operatorValue = OP_OR;
+		break;
+	case '^':
+		lvNext->operatorValue = OP_XOR;
+		break;
+	case '<':
+		lvNext->operatorValue = OP_LESS;
 		break;
+	case '>':
+		lvNext->operatorValue = OP_GREATER;
+		break;
+	case '!':
+		lvNext->operatorValue = OP_NOT;
+		break;
+	default:
+		lvNext->type = TOKEN_ERROR_TYPE;
+		break;
+	}
+}
+
+static void _lexValue(struct LexVector* lv, char token, uint32_t next, enum LexState* state) {
+	struct Token* lvNext;
+
+	switch (token) {
+	case '=':
+	case '+':
+	case '-':
+	case '*':
 	case '/':
-		lvNext->token.operatorValue = OP_DIVIDE;
+	case '%':
+	case '&':
+	case '|':
+	case '^':
+	case '<':
+	case '>':
+	case '!':
+		lvNext = LexVectorAppend(lv);
+		lvNext->type = TOKEN_UINT_TYPE;
+		lvNext->uintValue = next;
+		_lexOperator(lv, token, state);
+		break;
+	case ')':
+		lvNext = LexVectorAppend(lv);
+		lvNext->type = TOKEN_UINT_TYPE;
+		lvNext->uintValue = next;
+		lvNext = LexVectorAppend(lv);
+		lvNext->type = TOKEN_CLOSE_PAREN_TYPE;
+		*state = LEX_EXPECT_OPERATOR;
+		break;
+	case ' ':
+	case '\t':
+		lvNext = LexVectorAppend(lv);
+		lvNext->type = TOKEN_UINT_TYPE;
+		lvNext->uintValue = next;
+		*state = LEX_EXPECT_OPERATOR;
 		break;
 	default:
-		lvNext->token.type = TOKEN_ERROR_TYPE;
+		*state = LEX_ERROR;
 		break;
 	}
-	lvNext->next = lv->next;
-	lv->next = lvNext;
-	lv = lvNext;
-	lvNext = malloc(sizeof(struct LexVector));
-	lvNext->next = lv->next;
-	lvNext->token.type = TOKEN_ERROR_TYPE;
-	lv->next = lvNext;
-	return lvNext;
 }
 
-size_t lexExpression(struct LexVector* lv, const char* string, size_t length) {
+size_t lexExpression(struct LexVector* lv, const char* string, size_t length, const char* eol) {
 	if (!string || length < 1) {
 		return 0;
 	}
@@ -47,14 +189,32 @@ size_t adjusted = 0;
 
 	enum LexState state = LEX_ROOT;
 	const char* tokenStart = 0;
-	struct LexVector* lvNext;
+	struct Token* lvNext;
+
+	if (!eol) {
+		eol = " \r\n";
+	}
 
-	while (length > 0 && string[0] && string[0] != ' ' && state != LEX_ERROR) {
+	while (length > 0 && string[0] && !strchr(eol, string[0]) && state != LEX_ERROR) {
 		char token = string[0];
 		++string;
 		++adjusted;
 		--length;
 		switch (state) {
+		case LEX_EXPECT_OPERATOR2:
+			switch (token) {
+			case '&':
+			case '|':
+			case '=':
+			case '<':
+			case '>':
+				_lexOperator(lv, token, &state);
+				break;
+			}
+			if (state != LEX_EXPECT_OPERATOR2) {
+				break;
+			}
+			// Fall through
 		case LEX_ROOT:
 			tokenStart = string - 1;
 			switch (token) {
@@ -75,17 +235,20 @@ state = LEX_EXPECT_PREFIX;
 				next = 0;
 				break;
 			case '$':
-				state = LEX_EXPECT_HEX;
+				state = LEX_EXPECT_HEX_FIRST;
+				next = 0;
+				break;
+			case '%':
+				state = LEX_EXPECT_BINARY_FIRST;
 				next = 0;
 				break;
 			case '(':
 				state = LEX_ROOT;
-				lv->token.type = TOKEN_OPEN_PAREN_TYPE;
-				lvNext = malloc(sizeof(struct LexVector));
-				lvNext->next = lv->next;
-				lvNext->token.type = TOKEN_ERROR_TYPE;
-				lv->next = lvNext;
-				lv = lvNext;
+				lvNext = LexVectorAppend(lv);
+				lvNext->type = TOKEN_OPEN_PAREN_TYPE;
+				break;
+			case ' ':
+			case '\t':
 				break;
 			default:
 				if (tolower(token) >= 'a' && tolower(token <= 'z')) {
@@ -98,24 +261,45 @@ };
 			break;
 		case LEX_EXPECT_IDENTIFIER:
 			switch (token) {
+			case '=':
 			case '+':
 			case '-':
 			case '*':
 			case '/':
-				lv->token.type = TOKEN_IDENTIFIER_TYPE;
-				lv->token.identifierValue = strndup(tokenStart, string - tokenStart - 1);
-				lv = _lexOperator(lv, token);
-				state = LEX_ROOT;
+			case '%':
+			case '&':
+			case '|':
+			case '^':
+			case '<':
+			case '>':
+			case '!':
+				lvNext = LexVectorAppend(lv);
+				lvNext->type = TOKEN_IDENTIFIER_TYPE;
+				lvNext->identifierValue = strndup(tokenStart, string - tokenStart - 1);
+				_lexOperator(lv, token, &state);
 				break;
 			case ')':
-				lv->token.type = TOKEN_IDENTIFIER_TYPE;
-				lv->token.identifierValue = strndup(tokenStart, string - tokenStart - 1);
+				lvNext = LexVectorAppend(lv);
+				lvNext->type = TOKEN_IDENTIFIER_TYPE;
+				lvNext->identifierValue = strndup(tokenStart, string - tokenStart - 1);
+				lvNext = LexVectorAppend(lv);
+				lvNext->type = TOKEN_CLOSE_PAREN_TYPE;
+				state = LEX_EXPECT_OPERATOR;
+				break;
+			case ' ':
+			case '\t':
+				lvNext = LexVectorAppend(lv);
+				lvNext->type = TOKEN_IDENTIFIER_TYPE;
+				lvNext->identifierValue = strndup(tokenStart, string - tokenStart - 1);
 				state = LEX_EXPECT_OPERATOR;
 				break;
 			default:
 				break;
 			}
 			break;
+		case LEX_EXPECT_BINARY_FIRST:
+			state = LEX_EXPECT_BINARY;
+			// Fall through
 		case LEX_EXPECT_BINARY:
 			switch (token) {
 			case '0':
@@ -124,22 +308,8 @@ // TODO: handle overflow
 				next <<= 1;
 				next += token - '0';
 				break;
-			case '+':
-			case '-':
-			case '*':
-			case '/':
-				lv->token.type = TOKEN_UINT_TYPE;
-				lv->token.uintValue = next;
-				lv = _lexOperator(lv, token);
-				state = LEX_ROOT;
-				break;
-			case ')':
-				lv->token.type = TOKEN_UINT_TYPE;
-				lv->token.uintValue = next;
-				state = LEX_EXPECT_OPERATOR;
-				break;
 			default:
-				state = LEX_ERROR;
+				_lexValue(lv, token, next, &state);
 				break;
 			}
 			break;
@@ -159,24 +329,14 @@ // TODO: handle overflow
 				next *= 10;
 				next += token - '0';
 				break;
-			case '+':
-			case '-':
-			case '*':
-			case '/':
-				lv->token.type = TOKEN_UINT_TYPE;
-				lv->token.uintValue = next;
-				lv = _lexOperator(lv, token);
-				state = LEX_ROOT;
-				break;
-			case ')':
-				lv->token.type = TOKEN_UINT_TYPE;
-				lv->token.uintValue = next;
-				state = LEX_EXPECT_OPERATOR;
+			default:
+				_lexValue(lv, token, next, &state);
 				break;
-			default:
-				state = LEX_ERROR;
 			}
 			break;
+		case LEX_EXPECT_HEX_FIRST:
+			state = LEX_EXPECT_HEX;
+			// Fall through
 		case LEX_EXPECT_HEX:
 			switch (token) {
 			case '0':
@@ -213,33 +373,14 @@ // TODO: handle overflow
 				next *= 16;
 				next += token - 'a' + 10;
 				break;
-			case '+':
-			case '-':
-			case '*':
-			case '/':
-				lv->token.type = TOKEN_UINT_TYPE;
-				lv->token.uintValue = next;
-				lv = _lexOperator(lv, token);
-				state = LEX_ROOT;
-				break;
 			case ':':
-				lv->token.type = TOKEN_SEGMENT_TYPE;
-				lv->token.uintValue = next;
-				lvNext = malloc(sizeof(struct LexVector));
-				lvNext->next = lv->next;
-				lvNext->token.type = TOKEN_UINT_TYPE;
-				lv->next = lvNext;
-				lv = lvNext;
+				lvNext = LexVectorAppend(lv);
+				lvNext->type = TOKEN_SEGMENT_TYPE;
+				lvNext->uintValue = next;
 				next = 0;
-				state = LEX_EXPECT_HEX;
-				break;
-			case ')':
-				lv->token.type = TOKEN_UINT_TYPE;
-				lv->token.uintValue = next;
-				state = LEX_EXPECT_OPERATOR;
 				break;
 			default:
-				state = LEX_ERROR;
+				_lexValue(lv, token, next, &state);
 				break;
 			}
 			break;
@@ -248,26 +389,12 @@ switch (token) {
 			case 'X':
 			case 'x':
 				next = 0;
-				state = LEX_EXPECT_HEX;
+				state = LEX_EXPECT_HEX_FIRST;
 				break;
 			case 'B':
 			case 'b':
 				next = 0;
-				state = LEX_EXPECT_BINARY;
-				break;
-			case '+':
-			case '-':
-			case '*':
-			case '/':
-				lv->token.type = TOKEN_UINT_TYPE;
-				lv->token.uintValue = next;
-				lv = _lexOperator(lv, token);
-				state = LEX_ROOT;
-				break;
-			case ')':
-				lv->token.type = TOKEN_UINT_TYPE;
-				lv->token.uintValue = next;
-				state = LEX_EXPECT_OPERATOR;
+				state = LEX_EXPECT_BINARY_FIRST;
 				break;
 			case '0':
 			case '1':
@@ -283,21 +410,32 @@ next = token - '0';
 				state = LEX_EXPECT_DECIMAL;
 				break;
 			default:
-				state = LEX_ERROR;
+				_lexValue(lv, token, next, &state);
+				break;
 			}
 			break;
 		case LEX_EXPECT_OPERATOR:
 			switch (token) {
+			case '=':
 			case '+':
 			case '-':
 			case '*':
 			case '/':
-				lvNext = malloc(sizeof(struct LexVector));
-				lvNext->next = lv->next;
-				lvNext->token.type = TOKEN_CLOSE_PAREN_TYPE;
-				lv->next = lvNext;
-				lv = _lexOperator(lv->next, token);
-				state = LEX_ROOT;
+			case '%':
+			case '&':
+			case '|':
+			case '^':
+			case '<':
+			case '>':
+			case '!':
+				_lexOperator(lv, token, &state);
+				break;
+			case ')':
+				lvNext = LexVectorAppend(lv);
+				lvNext->type = TOKEN_CLOSE_PAREN_TYPE;
+				break;
+			case ' ':
+			case '\t':
 				break;
 			default:
 				state = LEX_ERROR;
@@ -314,33 +452,53 @@ case LEX_EXPECT_BINARY:
 	case LEX_EXPECT_DECIMAL:
 	case LEX_EXPECT_HEX:
 	case LEX_EXPECT_PREFIX:
-		lv->token.type = TOKEN_UINT_TYPE;
-		lv->token.uintValue = next;
+		lvNext = LexVectorAppend(lv);
+		lvNext->type = TOKEN_UINT_TYPE;
+		lvNext->uintValue = next;
 		break;
 	case LEX_EXPECT_IDENTIFIER:
-		lv->token.type = TOKEN_IDENTIFIER_TYPE;
-		lv->token.identifierValue = strndup(tokenStart, string - tokenStart);
+		lvNext = LexVectorAppend(lv);
+		lvNext->type = TOKEN_IDENTIFIER_TYPE;
+		lvNext->identifierValue = strndup(tokenStart, string - tokenStart);
 		break;
+	case LEX_ROOT:
 	case LEX_EXPECT_OPERATOR:
-		lvNext = malloc(sizeof(struct LexVector));
-		lvNext->next = lv->next;
-		lvNext->token.type = TOKEN_CLOSE_PAREN_TYPE;
-		lv->next = lvNext;
+	case LEX_EXPECT_OPERATOR2:
 		break;
+	case LEX_EXPECT_BINARY_FIRST:
+	case LEX_EXPECT_HEX_FIRST:
 	case LEX_ERROR:
 	default:
-		lv->token.type = TOKEN_ERROR_TYPE;
+		lvNext = LexVectorAppend(lv);
+		lvNext->type = TOKEN_ERROR_TYPE;
 		break;
 	}
 	return adjusted;
 }
 
 static const int _operatorPrecedence[] = {
-	2,
-	1,
-	1,
-	0,
-	0
+	[OP_ASSIGN] = 14,
+	[OP_ADD] = 4,
+	[OP_SUBTRACT] = 4,
+	[OP_MULTIPLY] = 3,
+	[OP_DIVIDE] = 3,
+	[OP_MODULO] = 3,
+	[OP_AND] = 8,
+	[OP_OR] = 10,
+	[OP_XOR] = 9,
+	[OP_LESS] = 6,
+	[OP_GREATER] = 6,
+	[OP_EQUAL] = 7,
+	[OP_NOT_EQUAL] = 7,
+	[OP_LE] = 6,
+	[OP_GE] = 6,
+	[OP_LOGICAL_AND] = 11,
+	[OP_LOGICAL_OR] = 12,
+	[OP_NEGATE] = 2,
+	[OP_FLIP] = 2,
+	[OP_NOT] = 2,
+	[OP_SHIFT_L] = 5,
+	[OP_SHIFT_R] = 5,
 };
 
 static struct ParseTree* _parseTreeCreate() {
@@ -351,65 +509,69 @@ tree->lhs = 0;
 	return tree;
 }
 
-static struct LexVector* _parseExpression(struct ParseTree* tree, struct LexVector* lv, int precedence, int openParens) {
+static size_t _parseExpression(struct ParseTree* tree, struct LexVector* lv, size_t i, int precedence, int* openParens) {
 	struct ParseTree* newTree = 0;
-	while (lv) {
+	while (i < LexVectorSize(lv)) {
+		struct Token* token = LexVectorGetPointer(lv, i);
 		int newPrecedence;
-		switch (lv->token.type) {
+		switch (token->type) {
 		case TOKEN_IDENTIFIER_TYPE:
 		case TOKEN_UINT_TYPE:
 			if (tree->token.type == TOKEN_ERROR_TYPE) {
-				tree->token = lv->token;
-				lv = lv->next;
+				tree->token = *token;
+				if (token->type == TOKEN_IDENTIFIER_TYPE) {
+					tree->token.identifierValue = strdup(token->identifierValue);
+				}
+				++i;
 			} else {
 				tree->token.type = TOKEN_ERROR_TYPE;
-				return 0;
+				return i + 1;
 			}
 			break;
 		case TOKEN_SEGMENT_TYPE:
 			tree->lhs = _parseTreeCreate();
 			tree->lhs->token.type = TOKEN_UINT_TYPE;
-			tree->lhs->token.uintValue = lv->token.uintValue;
+			tree->lhs->token.uintValue = token->uintValue;
 			tree->rhs = _parseTreeCreate();
 			tree->token.type = TOKEN_SEGMENT_TYPE;
-			lv = _parseExpression(tree->rhs, lv->next, precedence, openParens);
+			i = _parseExpression(tree->rhs, lv, i + 1, precedence, openParens);
 			if (tree->token.type == TOKEN_ERROR_TYPE) {
 				tree->token.type = TOKEN_ERROR_TYPE;
 			}
 			break;
 		case TOKEN_OPEN_PAREN_TYPE:
-			lv = _parseExpression(tree, lv->next, INT_MAX, openParens + 1);
+			++*openParens;
+			i = _parseExpression(tree, lv, i + 1, INT_MAX, openParens);
 			break;
 		case TOKEN_CLOSE_PAREN_TYPE:
-			if (openParens <= 0) {
+			if (*openParens <= 0) {
 				tree->token.type = TOKEN_ERROR_TYPE;
-				return 0;
 			}
-			return lv->next;
-			break;
+			--*openParens;
+			return i + 1;
 		case TOKEN_OPERATOR_TYPE:
-			newPrecedence = _operatorPrecedence[lv->token.operatorValue];
+			newPrecedence = _operatorPrecedence[token->operatorValue];
 			if (newPrecedence < precedence) {
 				newTree = _parseTreeCreate();
 				*newTree = *tree;
 				tree->lhs = newTree;
 				tree->rhs = _parseTreeCreate();
-				tree->token = lv->token;
-				lv = _parseExpression(tree->rhs, lv->next, newPrecedence, openParens);
+				tree->token = *token;
+				i = _parseExpression(tree->rhs, lv, i + 1, newPrecedence, openParens);
 				if (tree->token.type == TOKEN_ERROR_TYPE) {
 					tree->token.type = TOKEN_ERROR_TYPE;
 				}
 			} else {
-				return lv;
+				return i;
 			}
 			break;
 		case TOKEN_ERROR_TYPE:
 			tree->token.type = TOKEN_ERROR_TYPE;
-			return 0;
+			return i + 1;
 		}
 	}
 
-	return 0;
+	return i;
 }
 
 void parseLexedExpression(struct ParseTree* tree, struct LexVector* lv) {
@@ -421,14 +583,23 @@ tree->token.type = TOKEN_ERROR_TYPE;
 	tree->lhs = 0;
 	tree->rhs = 0;
 
-	_parseExpression(tree, lv, _operatorPrecedence[OP_ASSIGN], 0);
+	int openParens = 0;
+	_parseExpression(tree, lv, 0, INT_MAX, &openParens);
+	if (openParens) {
+		if (tree->token.type == TOKEN_IDENTIFIER_TYPE) {
+			free(tree->token.identifierValue);
+		}
+		tree->token.type = TOKEN_ERROR_TYPE;
+	}
 }
 
 void lexFree(struct LexVector* lv) {
-	while (lv) {
-		struct LexVector* lvNext = lv->next;
-		free(lv);
-		lv = lvNext;
+	size_t i;
+	for (i = 0; i < LexVectorSize(lv); ++i) {
+		struct Token* token = LexVectorGetPointer(lv, i);
+		if (token->type == TOKEN_IDENTIFIER_TYPE) {
+			free(token->identifierValue);
+		}
 	}
 }
 
@@ -437,11 +608,124 @@ if (!tree) {
 		return;
 	}
 
-	parseFree(tree->lhs);
-	parseFree(tree->rhs);
+	if (tree->lhs) {
+		parseFree(tree->lhs);
+		free(tree->lhs);
+	}
+	if (tree->rhs) {
+		parseFree(tree->rhs);
+		free(tree->rhs);
+	}
 
 	if (tree->token.type == TOKEN_IDENTIFIER_TYPE) {
 		free(tree->token.identifierValue);
 	}
-	free(tree);
+}
+
+static bool _performOperation(enum Operation operation, int32_t current, int32_t next, int32_t* value) {
+	switch (operation) {
+	case OP_ASSIGN:
+		current = next;
+		break;
+	case OP_ADD:
+		current += next;
+		break;
+	case OP_SUBTRACT:
+		current -= next;
+		break;
+	case OP_MULTIPLY:
+		current *= next;
+		break;
+	case OP_DIVIDE:
+		if (next != 0) {
+			current /= next;
+		} else {
+			return false;
+		}
+		break;
+	case OP_MODULO:
+		if (next != 0) {
+			current %= next;
+		} else {
+			return false;
+		}
+		break;
+	case OP_AND:
+		current &= next;
+		break;
+	case OP_OR:
+		current |= next;
+		break;
+	case OP_XOR:
+		current ^= next;
+		break;
+	case OP_LESS:
+		current = current < next;
+		break;
+	case OP_GREATER:
+		current = current > next;
+		break;
+	case OP_EQUAL:
+		current = current == next;
+		break;
+	case OP_NOT_EQUAL:
+		current = current != next;
+		break;
+	case OP_LOGICAL_AND:
+		current = current && next;
+		break;
+	case OP_LOGICAL_OR:
+		current = current || next;
+		break;
+	case OP_LE:
+		current = current <= next;
+		break;
+	case OP_GE:
+		current = current >= next;
+		break;
+	case OP_SHIFT_L:
+		current <<= next;
+		break;
+	case OP_SHIFT_R:
+		current >>= next;
+		break;
+	default:
+		return false;
+	}
+	*value = current;
+	return true;
+}
+
+bool mDebuggerEvaluateParseTree(struct mDebugger* debugger, struct ParseTree* tree, int32_t* value, int* segment) {
+	if (!value) {
+		return false;
+	}
+	int32_t lhs, rhs;
+	switch (tree->token.type) {
+	case TOKEN_UINT_TYPE:
+		if (segment) {
+			*segment = -1;
+		}
+		*value = tree->token.uintValue;
+		return true;
+	case TOKEN_SEGMENT_TYPE:
+		if (!mDebuggerEvaluateParseTree(debugger, tree->rhs, value, segment)) {
+			return false;
+		}
+		return mDebuggerEvaluateParseTree(debugger, tree->lhs, segment, NULL);
+	case TOKEN_OPERATOR_TYPE:
+		if (!mDebuggerEvaluateParseTree(debugger, tree->lhs, &lhs, segment)) {
+			return false;
+		}
+		if (!mDebuggerEvaluateParseTree(debugger, tree->rhs, &rhs, segment)) {
+			return false;
+		}
+		return _performOperation(tree->token.operatorValue, lhs, rhs, value);
+	case TOKEN_IDENTIFIER_TYPE:
+		return mDebuggerLookupIdentifier(debugger, tree->token.identifierValue, value, segment);
+	case TOKEN_ERROR_TYPE:
+	default:
+		break;
+	}
+	return false;
 }

@@ -0,0 +1,855 @@
+/* Copyright (c) 2013-2017 Jeffrey Pfau
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+#include "util/test/suite.h"
+
+#include <mgba/internal/debugger/parser.h>
+
+#define LEX(STR) \
+	struct LexVector* lv = *state; \
+	lexFree(lv); \
+	LexVectorClear(lv); \
+	size_t adjusted = lexExpression(lv, STR, strlen(STR), ""); \
+	assert_false(adjusted > strlen(STR))
+
+M_TEST_SUITE_SETUP(Lexer) {
+	struct LexVector* lv = malloc(sizeof(struct LexVector));
+	LexVectorInit(lv, 0);
+	*state = lv;
+	return 0;
+}
+
+M_TEST_SUITE_TEARDOWN(Lexer) {
+	struct LexVector* lv = *state;
+	lexFree(lv);
+	LexVectorDeinit(lv);
+	free(lv);
+	return 0;
+}
+
+M_TEST_DEFINE(lexEmpty) {
+	LEX("");
+
+	assert_int_equal(LexVectorSize(lv), 0);
+}
+
+M_TEST_DEFINE(lexInt) {
+	LEX("0");
+
+	assert_int_equal(LexVectorSize(lv), 1);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_UINT_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->uintValue, 0);
+}
+
+M_TEST_DEFINE(lexDecimal) {
+	LEX("10");
+
+	assert_int_equal(LexVectorSize(lv), 1);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_UINT_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->uintValue, 10);
+}
+
+M_TEST_DEFINE(lexBinary) {
+	LEX("0b10");
+
+	assert_int_equal(LexVectorSize(lv), 1);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_UINT_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->uintValue, 2);
+}
+
+M_TEST_DEFINE(lexSigilBinary) {
+	LEX("%10");
+
+	assert_int_equal(LexVectorSize(lv), 1);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_UINT_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->uintValue, 2);
+}
+
+M_TEST_DEFINE(lexHex) {
+	LEX("0x10");
+
+	assert_int_equal(LexVectorSize(lv), 1);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_UINT_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->uintValue, 0x10);
+}
+
+M_TEST_DEFINE(lexSigilHex) {
+	LEX("$10");
+
+	assert_int_equal(LexVectorSize(lv), 1);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_UINT_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->uintValue, 0x10);
+}
+
+M_TEST_DEFINE(lexInvalidDecimal) {
+	LEX("1a");
+
+	assert_int_equal(LexVectorSize(lv), 1);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_ERROR_TYPE);
+}
+
+M_TEST_DEFINE(lexInvalidBinary) {
+	LEX("0b12");
+
+	assert_int_equal(LexVectorSize(lv), 1);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_ERROR_TYPE);
+}
+
+M_TEST_DEFINE(lexInvalidHex) {
+	LEX("0x1g");
+
+	assert_int_equal(LexVectorSize(lv), 1);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_ERROR_TYPE);
+}
+
+M_TEST_DEFINE(lexTruncatedBinary) {
+	LEX("0b");
+
+	assert_int_equal(LexVectorSize(lv), 1);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_ERROR_TYPE);
+}
+
+M_TEST_DEFINE(lexTruncatedSigilBinary) {
+	LEX("%");
+
+	assert_int_equal(LexVectorSize(lv), 1);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_ERROR_TYPE);
+}
+
+M_TEST_DEFINE(lexTruncatedSigilHex) {
+	LEX("$");
+
+	assert_int_equal(LexVectorSize(lv), 1);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_ERROR_TYPE);
+}
+
+M_TEST_DEFINE(lexTruncatedHex) {
+	LEX("0x");
+
+	assert_int_equal(LexVectorSize(lv), 1);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_ERROR_TYPE);
+}
+
+M_TEST_DEFINE(lexSigilSegmentHex) {
+	LEX("$01:0010");
+
+	assert_int_equal(LexVectorSize(lv), 2);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_SEGMENT_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->uintValue, 1);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_UINT_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->uintValue, 0x10);
+}
+
+M_TEST_DEFINE(lexIdentifier) {
+	LEX("x");
+
+	assert_int_equal(LexVectorSize(lv), 1);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_IDENTIFIER_TYPE);
+	assert_string_equal(LexVectorGetPointer(lv, 0)->identifierValue, "x");
+}
+
+M_TEST_DEFINE(lexAddOperator) {
+	LEX("1+");
+
+	assert_int_equal(LexVectorSize(lv), 2);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_UINT_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->uintValue, 1);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_OPERATOR_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->operatorValue, OP_ADD);
+}
+
+M_TEST_DEFINE(lexIdentifierAddOperator) {
+	LEX("x+");
+
+	assert_int_equal(LexVectorSize(lv), 2);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_IDENTIFIER_TYPE);
+	assert_string_equal(LexVectorGetPointer(lv, 0)->identifierValue, "x");
+	assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_OPERATOR_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->operatorValue, OP_ADD);
+}
+
+M_TEST_DEFINE(lexSubOperator) {
+	LEX("1-");
+
+	assert_int_equal(LexVectorSize(lv), 2);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_UINT_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->uintValue, 1);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_OPERATOR_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->operatorValue, OP_SUBTRACT);
+}
+
+M_TEST_DEFINE(lexIdentifierSubOperator) {
+	LEX("x-");
+
+	assert_int_equal(LexVectorSize(lv), 2);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_IDENTIFIER_TYPE);
+	assert_string_equal(LexVectorGetPointer(lv, 0)->identifierValue, "x");
+	assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_OPERATOR_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->operatorValue, OP_SUBTRACT);
+}
+
+M_TEST_DEFINE(lexMulOperator) {
+	LEX("1*");
+
+	assert_int_equal(LexVectorSize(lv), 2);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_UINT_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->uintValue, 1);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_OPERATOR_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->operatorValue, OP_MULTIPLY);
+}
+
+M_TEST_DEFINE(lexIdentifierMulOperator) {
+	LEX("x*");
+
+	assert_int_equal(LexVectorSize(lv), 2);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_IDENTIFIER_TYPE);
+	assert_string_equal(LexVectorGetPointer(lv, 0)->identifierValue, "x");
+	assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_OPERATOR_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->operatorValue, OP_MULTIPLY);
+}
+
+M_TEST_DEFINE(lexDivOperator) {
+	LEX("1/");
+
+	assert_int_equal(LexVectorSize(lv), 2);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_UINT_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->uintValue, 1);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_OPERATOR_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->operatorValue, OP_DIVIDE);
+}
+
+M_TEST_DEFINE(lexIdentifierDivOperator) {
+	LEX("x/");
+
+	assert_int_equal(LexVectorSize(lv), 2);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_IDENTIFIER_TYPE);
+	assert_string_equal(LexVectorGetPointer(lv, 0)->identifierValue, "x");
+	assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_OPERATOR_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->operatorValue, OP_DIVIDE);
+}
+
+M_TEST_DEFINE(lexModOperator) {
+	LEX("1%");
+
+	assert_int_equal(LexVectorSize(lv), 2);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_UINT_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->uintValue, 1);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_OPERATOR_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->operatorValue, OP_MODULO);
+}
+
+M_TEST_DEFINE(lexIdentifierModOperator) {
+	LEX("x%");
+
+	assert_int_equal(LexVectorSize(lv), 2);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_IDENTIFIER_TYPE);
+	assert_string_equal(LexVectorGetPointer(lv, 0)->identifierValue, "x");
+	assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_OPERATOR_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->operatorValue, OP_MODULO);
+}
+
+M_TEST_DEFINE(lexAndOperator) {
+	LEX("1&");
+
+	assert_int_equal(LexVectorSize(lv), 2);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_UINT_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->uintValue, 1);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_OPERATOR_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->operatorValue, OP_AND);
+}
+
+M_TEST_DEFINE(lexIdentifierAndOperator) {
+	LEX("x&");
+
+	assert_int_equal(LexVectorSize(lv), 2);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_IDENTIFIER_TYPE);
+	assert_string_equal(LexVectorGetPointer(lv, 0)->identifierValue, "x");
+	assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_OPERATOR_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->operatorValue, OP_AND);
+}
+
+M_TEST_DEFINE(lexOrOperator) {
+	LEX("1|");
+
+	assert_int_equal(LexVectorSize(lv), 2);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_UINT_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->uintValue, 1);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_OPERATOR_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->operatorValue, OP_OR);
+}
+
+M_TEST_DEFINE(lexIdentifierOrOperator) {
+	LEX("x|");
+
+	assert_int_equal(LexVectorSize(lv), 2);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_IDENTIFIER_TYPE);
+	assert_string_equal(LexVectorGetPointer(lv, 0)->identifierValue, "x");
+	assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_OPERATOR_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->operatorValue, OP_OR);
+}
+
+M_TEST_DEFINE(lexXorOperator) {
+	LEX("1^");
+
+	assert_int_equal(LexVectorSize(lv), 2);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_UINT_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->uintValue, 1);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_OPERATOR_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->operatorValue, OP_XOR);
+}
+
+M_TEST_DEFINE(lexIdentifierXorOperator) {
+	LEX("x^");
+
+	assert_int_equal(LexVectorSize(lv), 2);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_IDENTIFIER_TYPE);
+	assert_string_equal(LexVectorGetPointer(lv, 0)->identifierValue, "x");
+	assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_OPERATOR_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->operatorValue, OP_XOR);
+}
+
+M_TEST_DEFINE(lexLessOperator) {
+	LEX("1<");
+
+	assert_int_equal(LexVectorSize(lv), 2);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_UINT_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->uintValue, 1);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_OPERATOR_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->operatorValue, OP_LESS);
+}
+
+M_TEST_DEFINE(lexIdentifierLessOperator) {
+	LEX("x<");
+
+	assert_int_equal(LexVectorSize(lv), 2);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_IDENTIFIER_TYPE);
+	assert_string_equal(LexVectorGetPointer(lv, 0)->identifierValue, "x");
+	assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_OPERATOR_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->operatorValue, OP_LESS);
+}
+
+M_TEST_DEFINE(lexGreaterOperator) {
+	LEX("1>");
+
+	assert_int_equal(LexVectorSize(lv), 2);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_UINT_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->uintValue, 1);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_OPERATOR_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->operatorValue, OP_GREATER);
+}
+
+M_TEST_DEFINE(lexIdentifierGreaterOperator) {
+	LEX("x>");
+
+	assert_int_equal(LexVectorSize(lv), 2);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_IDENTIFIER_TYPE);
+	assert_string_equal(LexVectorGetPointer(lv, 0)->identifierValue, "x");
+	assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_OPERATOR_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->operatorValue, OP_GREATER);
+}
+
+M_TEST_DEFINE(lexEqualsOperator) {
+	LEX("1==");
+
+	assert_int_equal(LexVectorSize(lv), 2);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_UINT_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->uintValue, 1);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_OPERATOR_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->operatorValue, OP_EQUAL);
+}
+
+M_TEST_DEFINE(lexIdentifierEqualsOperator) {
+	LEX("x==");
+
+	assert_int_equal(LexVectorSize(lv), 2);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_IDENTIFIER_TYPE);
+	assert_string_equal(LexVectorGetPointer(lv, 0)->identifierValue, "x");
+	assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_OPERATOR_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->operatorValue, OP_EQUAL);
+}
+
+M_TEST_DEFINE(lexNotEqualsOperator) {
+	LEX("1!=");
+
+	assert_int_equal(LexVectorSize(lv), 2);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_UINT_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->uintValue, 1);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_OPERATOR_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->operatorValue, OP_NOT_EQUAL);
+}
+
+M_TEST_DEFINE(lexIdentifierNotEqualsOperator) {
+	LEX("x!=");
+
+	assert_int_equal(LexVectorSize(lv), 2);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_IDENTIFIER_TYPE);
+	assert_string_equal(LexVectorGetPointer(lv, 0)->identifierValue, "x");
+	assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_OPERATOR_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->operatorValue, OP_NOT_EQUAL);
+}
+
+M_TEST_DEFINE(lexLEOperator) {
+	LEX("1<=");
+
+	assert_int_equal(LexVectorSize(lv), 2);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_UINT_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->uintValue, 1);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_OPERATOR_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->operatorValue, OP_LE);
+}
+
+M_TEST_DEFINE(lexIdentifierLEOperator) {
+	LEX("x<=");
+
+	assert_int_equal(LexVectorSize(lv), 2);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_IDENTIFIER_TYPE);
+	assert_string_equal(LexVectorGetPointer(lv, 0)->identifierValue, "x");
+	assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_OPERATOR_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->operatorValue, OP_LE);
+}
+
+M_TEST_DEFINE(lexGEOperator) {
+	LEX("1>=");
+
+	assert_int_equal(LexVectorSize(lv), 2);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_UINT_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->uintValue, 1);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_OPERATOR_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->operatorValue, OP_GE);
+}
+
+M_TEST_DEFINE(lexIdentifierGEOperator) {
+	LEX("x>=");
+
+	assert_int_equal(LexVectorSize(lv), 2);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_IDENTIFIER_TYPE);
+	assert_string_equal(LexVectorGetPointer(lv, 0)->identifierValue, "x");
+	assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_OPERATOR_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->operatorValue, OP_GE);
+}
+
+M_TEST_DEFINE(lexLAndOperator) {
+	LEX("1&&");
+
+	assert_int_equal(LexVectorSize(lv), 2);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_UINT_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->uintValue, 1);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_OPERATOR_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->operatorValue, OP_LOGICAL_AND);
+}
+
+M_TEST_DEFINE(lexIdentifierLAndOperator) {
+	LEX("x&&");
+
+	assert_int_equal(LexVectorSize(lv), 2);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_IDENTIFIER_TYPE);
+	assert_string_equal(LexVectorGetPointer(lv, 0)->identifierValue, "x");
+	assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_OPERATOR_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->operatorValue, OP_LOGICAL_AND);
+}
+
+M_TEST_DEFINE(lexLOrOperator) {
+	LEX("1||");
+
+	assert_int_equal(LexVectorSize(lv), 2);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_UINT_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->uintValue, 1);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_OPERATOR_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->operatorValue, OP_LOGICAL_OR);
+}
+
+M_TEST_DEFINE(lexIdentifierLOrOperator) {
+	LEX("x||");
+
+	assert_int_equal(LexVectorSize(lv), 2);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_IDENTIFIER_TYPE);
+	assert_string_equal(LexVectorGetPointer(lv, 0)->identifierValue, "x");
+	assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_OPERATOR_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->operatorValue, OP_LOGICAL_OR);
+}
+
+M_TEST_DEFINE(lexShiftLOperator) {
+	LEX("1<<");
+
+	assert_int_equal(LexVectorSize(lv), 2);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_UINT_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->uintValue, 1);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_OPERATOR_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->operatorValue, OP_SHIFT_L);
+}
+
+M_TEST_DEFINE(lexIdentifierShiftLOperator) {
+	LEX("x<<");
+
+	assert_int_equal(LexVectorSize(lv), 2);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_IDENTIFIER_TYPE);
+	assert_string_equal(LexVectorGetPointer(lv, 0)->identifierValue, "x");
+	assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_OPERATOR_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->operatorValue, OP_SHIFT_L);
+}
+
+M_TEST_DEFINE(lexShiftROperator) {
+	LEX("1>>");
+
+	assert_int_equal(LexVectorSize(lv), 2);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_UINT_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->uintValue, 1);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_OPERATOR_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->operatorValue, OP_SHIFT_R);
+}
+
+M_TEST_DEFINE(lexIdentifierShiftROperator) {
+	LEX("x>>");
+
+	assert_int_equal(LexVectorSize(lv), 2);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_IDENTIFIER_TYPE);
+	assert_string_equal(LexVectorGetPointer(lv, 0)->identifierValue, "x");
+	assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_OPERATOR_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->operatorValue, OP_SHIFT_R);
+}
+
+M_TEST_DEFINE(lexEqualsInvalidOperator) {
+	LEX("1=|");
+
+	assert_int_equal(LexVectorSize(lv), 3);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_UINT_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->uintValue, 1);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_OPERATOR_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->operatorValue, OP_ASSIGN);
+	assert_int_equal(LexVectorGetPointer(lv, 2)->type, TOKEN_ERROR_TYPE);
+}
+
+M_TEST_DEFINE(lexIdentifierEqualsInvalidOperator) {
+	LEX("x=|");
+
+	assert_int_equal(LexVectorSize(lv), 3);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_IDENTIFIER_TYPE);
+	assert_string_equal(LexVectorGetPointer(lv, 0)->identifierValue, "x");
+	assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_OPERATOR_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->operatorValue, OP_ASSIGN);
+	assert_int_equal(LexVectorGetPointer(lv, 2)->type, TOKEN_ERROR_TYPE);
+}
+
+M_TEST_DEFINE(lexNotInvalidOperator) {
+	LEX("1!|");
+
+	assert_int_equal(LexVectorSize(lv), 3);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_UINT_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->uintValue, 1);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_OPERATOR_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->operatorValue, OP_NOT);
+	assert_int_equal(LexVectorGetPointer(lv, 2)->type, TOKEN_ERROR_TYPE);
+}
+
+M_TEST_DEFINE(lexIdentifierNotInvalidOperator) {
+	LEX("x!|");
+
+	assert_int_equal(LexVectorSize(lv), 3);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_IDENTIFIER_TYPE);
+	assert_string_equal(LexVectorGetPointer(lv, 0)->identifierValue, "x");
+	assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_OPERATOR_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->operatorValue, OP_NOT);
+	assert_int_equal(LexVectorGetPointer(lv, 2)->type, TOKEN_ERROR_TYPE);
+}
+
+M_TEST_DEFINE(lexLessInvalidOperator) {
+	LEX("1<|");
+
+	assert_int_equal(LexVectorSize(lv), 3);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_UINT_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->uintValue, 1);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_OPERATOR_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->operatorValue, OP_LESS);
+	assert_int_equal(LexVectorGetPointer(lv, 2)->type, TOKEN_ERROR_TYPE);
+}
+
+M_TEST_DEFINE(lexIdentifierLessInvalidOperator) {
+	LEX("x<|");
+
+	assert_int_equal(LexVectorSize(lv), 3);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_IDENTIFIER_TYPE);
+	assert_string_equal(LexVectorGetPointer(lv, 0)->identifierValue, "x");
+	assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_OPERATOR_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->operatorValue, OP_LESS);
+	assert_int_equal(LexVectorGetPointer(lv, 2)->type, TOKEN_ERROR_TYPE);
+}
+
+M_TEST_DEFINE(lexGreaterInvalidOperator) {
+	LEX("1>|");
+
+	assert_int_equal(LexVectorSize(lv), 3);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_UINT_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->uintValue, 1);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_OPERATOR_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->operatorValue, OP_GREATER);
+	assert_int_equal(LexVectorGetPointer(lv, 2)->type, TOKEN_ERROR_TYPE);
+}
+
+M_TEST_DEFINE(lexIdentifierGreaterInvalidOperator) {
+	LEX("x>|");
+
+	assert_int_equal(LexVectorSize(lv), 3);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_IDENTIFIER_TYPE);
+	assert_string_equal(LexVectorGetPointer(lv, 0)->identifierValue, "x");
+	assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_OPERATOR_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->operatorValue, OP_GREATER);
+	assert_int_equal(LexVectorGetPointer(lv, 2)->type, TOKEN_ERROR_TYPE);
+}
+
+M_TEST_DEFINE(lexAndInvalidOperator) {
+	LEX("1&|");
+
+	assert_int_equal(LexVectorSize(lv), 3);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_UINT_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->uintValue, 1);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_OPERATOR_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->operatorValue, OP_AND);
+	assert_int_equal(LexVectorGetPointer(lv, 2)->type, TOKEN_ERROR_TYPE);
+}
+
+M_TEST_DEFINE(lexIdentifierAndInvalidOperator) {
+	LEX("x&|");
+
+	assert_int_equal(LexVectorSize(lv), 3);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_IDENTIFIER_TYPE);
+	assert_string_equal(LexVectorGetPointer(lv, 0)->identifierValue, "x");
+	assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_OPERATOR_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->operatorValue, OP_AND);
+	assert_int_equal(LexVectorGetPointer(lv, 2)->type, TOKEN_ERROR_TYPE);
+}
+
+M_TEST_DEFINE(lexOrInvalidOperator) {
+	LEX("1|>");
+
+	assert_int_equal(LexVectorSize(lv), 3);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_UINT_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->uintValue, 1);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_OPERATOR_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->operatorValue, OP_OR);
+	assert_int_equal(LexVectorGetPointer(lv, 2)->type, TOKEN_ERROR_TYPE);
+}
+
+M_TEST_DEFINE(lexIdentifierOrInvalidOperator) {
+	LEX("x|>");
+
+	assert_int_equal(LexVectorSize(lv), 3);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_IDENTIFIER_TYPE);
+	assert_string_equal(LexVectorGetPointer(lv, 0)->identifierValue, "x");
+	assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_OPERATOR_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->operatorValue, OP_OR);
+	assert_int_equal(LexVectorGetPointer(lv, 2)->type, TOKEN_ERROR_TYPE);
+}
+
+M_TEST_DEFINE(lexSimpleExpression) {
+	LEX("1+1");
+
+	assert_int_equal(LexVectorSize(lv), 3);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_UINT_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->uintValue, 1);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_OPERATOR_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->operatorValue, OP_ADD);
+	assert_int_equal(LexVectorGetPointer(lv, 2)->type, TOKEN_UINT_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 2)->uintValue, 1);
+}
+
+M_TEST_DEFINE(lexOpenParen) {
+	LEX("(");
+
+	assert_int_equal(LexVectorSize(lv), 1);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_OPEN_PAREN_TYPE);
+}
+
+M_TEST_DEFINE(lexCloseParen) {
+	LEX("(0)");
+
+	assert_int_equal(LexVectorSize(lv), 3);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_OPEN_PAREN_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_UINT_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->uintValue, 0);
+	assert_int_equal(LexVectorGetPointer(lv, 2)->type, TOKEN_CLOSE_PAREN_TYPE);
+}
+
+M_TEST_DEFINE(lexIdentifierCloseParen) {
+	LEX("(x)");
+
+	assert_int_equal(LexVectorSize(lv), 3);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_OPEN_PAREN_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_IDENTIFIER_TYPE);
+	assert_string_equal(LexVectorGetPointer(lv, 1)->identifierValue, "x");
+	assert_int_equal(LexVectorGetPointer(lv, 2)->type, TOKEN_CLOSE_PAREN_TYPE);
+}
+
+M_TEST_DEFINE(lexParentheticalExpression) {
+	LEX("(1+1)");
+
+	assert_int_equal(LexVectorSize(lv), 5);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_OPEN_PAREN_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_UINT_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->uintValue, 1);
+	assert_int_equal(LexVectorGetPointer(lv, 2)->type, TOKEN_OPERATOR_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 2)->operatorValue, OP_ADD);
+	assert_int_equal(LexVectorGetPointer(lv, 3)->type, TOKEN_UINT_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 3)->uintValue, 1);
+	assert_int_equal(LexVectorGetPointer(lv, 4)->type, TOKEN_CLOSE_PAREN_TYPE);
+}
+
+M_TEST_DEFINE(lexNestedParentheticalExpression) {
+	LEX("(1+(2+3))");
+
+	assert_int_equal(LexVectorSize(lv), 9);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_OPEN_PAREN_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_UINT_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->uintValue, 1);
+	assert_int_equal(LexVectorGetPointer(lv, 2)->type, TOKEN_OPERATOR_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 2)->operatorValue, OP_ADD);
+	assert_int_equal(LexVectorGetPointer(lv, 3)->type, TOKEN_OPEN_PAREN_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 4)->type, TOKEN_UINT_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 4)->uintValue, 2);
+	assert_int_equal(LexVectorGetPointer(lv, 5)->type, TOKEN_OPERATOR_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 5)->operatorValue, OP_ADD);
+	assert_int_equal(LexVectorGetPointer(lv, 6)->type, TOKEN_UINT_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 6)->uintValue, 3);
+	assert_int_equal(LexVectorGetPointer(lv, 7)->type, TOKEN_CLOSE_PAREN_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 8)->type, TOKEN_CLOSE_PAREN_TYPE);
+}
+
+M_TEST_DEFINE(lexSpaceSimple) {
+	LEX(" 1 ");
+
+	assert_int_equal(LexVectorSize(lv), 1);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_UINT_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->uintValue, 1);
+}
+
+M_TEST_DEFINE(lexSpaceIdentifier) {
+	LEX(" x ");
+
+	assert_int_equal(LexVectorSize(lv), 1);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_IDENTIFIER_TYPE);
+	assert_string_equal(LexVectorGetPointer(lv, 0)->identifierValue, "x");
+}
+
+M_TEST_DEFINE(lexSpaceOperator) {
+	LEX("1 + 2");
+
+	assert_int_equal(LexVectorSize(lv), 3);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_UINT_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->uintValue, 1);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_OPERATOR_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->operatorValue, OP_ADD);
+	assert_int_equal(LexVectorGetPointer(lv, 2)->type, TOKEN_UINT_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 2)->uintValue, 2);
+}
+
+M_TEST_DEFINE(lexSpaceParen) {
+	LEX(" ( 1 + 2 ) ");
+
+	assert_int_equal(LexVectorSize(lv), 5);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_OPEN_PAREN_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_UINT_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->uintValue, 1);
+	assert_int_equal(LexVectorGetPointer(lv, 2)->type, TOKEN_OPERATOR_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 2)->operatorValue, OP_ADD);
+	assert_int_equal(LexVectorGetPointer(lv, 3)->type, TOKEN_UINT_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 3)->uintValue, 2);
+	assert_int_equal(LexVectorGetPointer(lv, 4)->type, TOKEN_CLOSE_PAREN_TYPE);
+}
+
+M_TEST_DEFINE(lexSpaceParens) {
+	LEX(" ( 1 + ( 2 + 3 ) ) ");
+
+	assert_int_equal(LexVectorSize(lv), 9);
+	assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_OPEN_PAREN_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_UINT_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 1)->uintValue, 1);
+	assert_int_equal(LexVectorGetPointer(lv, 2)->type, TOKEN_OPERATOR_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 2)->operatorValue, OP_ADD);
+	assert_int_equal(LexVectorGetPointer(lv, 3)->type, TOKEN_OPEN_PAREN_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 4)->type, TOKEN_UINT_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 4)->uintValue, 2);
+	assert_int_equal(LexVectorGetPointer(lv, 5)->type, TOKEN_OPERATOR_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 5)->operatorValue, OP_ADD);
+	assert_int_equal(LexVectorGetPointer(lv, 6)->type, TOKEN_UINT_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 6)->uintValue, 3);
+	assert_int_equal(LexVectorGetPointer(lv, 7)->type, TOKEN_CLOSE_PAREN_TYPE);
+	assert_int_equal(LexVectorGetPointer(lv, 8)->type, TOKEN_CLOSE_PAREN_TYPE);
+}
+
+M_TEST_SUITE_DEFINE_SETUP_TEARDOWN(Lexer,
+	cmocka_unit_test(lexEmpty),
+	cmocka_unit_test(lexInt),
+	cmocka_unit_test(lexDecimal),
+	cmocka_unit_test(lexBinary),
+	cmocka_unit_test(lexSigilBinary),
+	cmocka_unit_test(lexHex),
+	cmocka_unit_test(lexSigilHex),
+	cmocka_unit_test(lexSigilSegmentHex),
+	cmocka_unit_test(lexInvalidDecimal),
+	cmocka_unit_test(lexInvalidHex),
+	cmocka_unit_test(lexInvalidBinary),
+	cmocka_unit_test(lexTruncatedHex),
+	cmocka_unit_test(lexTruncatedSigilHex),
+	cmocka_unit_test(lexTruncatedBinary),
+	cmocka_unit_test(lexTruncatedSigilBinary),
+	cmocka_unit_test(lexIdentifier),
+	cmocka_unit_test(lexAddOperator),
+	cmocka_unit_test(lexIdentifierAddOperator),
+	cmocka_unit_test(lexSubOperator),
+	cmocka_unit_test(lexIdentifierSubOperator),
+	cmocka_unit_test(lexMulOperator),
+	cmocka_unit_test(lexIdentifierMulOperator),
+	cmocka_unit_test(lexDivOperator),
+	cmocka_unit_test(lexIdentifierDivOperator),
+	cmocka_unit_test(lexModOperator),
+	cmocka_unit_test(lexIdentifierModOperator),
+	cmocka_unit_test(lexAndOperator),
+	cmocka_unit_test(lexIdentifierAndOperator),
+	cmocka_unit_test(lexOrOperator),
+	cmocka_unit_test(lexIdentifierOrOperator),
+	cmocka_unit_test(lexXorOperator),
+	cmocka_unit_test(lexIdentifierXorOperator),
+	cmocka_unit_test(lexLessOperator),
+	cmocka_unit_test(lexIdentifierLessOperator),
+	cmocka_unit_test(lexGreaterOperator),
+	cmocka_unit_test(lexIdentifierGreaterOperator),
+	cmocka_unit_test(lexEqualsOperator),
+	cmocka_unit_test(lexIdentifierEqualsOperator),
+	cmocka_unit_test(lexNotEqualsOperator),
+	cmocka_unit_test(lexIdentifierNotEqualsOperator),
+	cmocka_unit_test(lexLEOperator),
+	cmocka_unit_test(lexIdentifierLEOperator),
+	cmocka_unit_test(lexGEOperator),
+	cmocka_unit_test(lexIdentifierGEOperator),
+	cmocka_unit_test(lexLAndOperator),
+	cmocka_unit_test(lexIdentifierLAndOperator),
+	cmocka_unit_test(lexLOrOperator),
+	cmocka_unit_test(lexIdentifierLOrOperator),
+	cmocka_unit_test(lexShiftLOperator),
+	cmocka_unit_test(lexIdentifierShiftLOperator),
+	cmocka_unit_test(lexShiftROperator),
+	cmocka_unit_test(lexIdentifierShiftROperator),
+	cmocka_unit_test(lexEqualsInvalidOperator),
+	cmocka_unit_test(lexIdentifierEqualsInvalidOperator),
+	cmocka_unit_test(lexNotInvalidOperator),
+	cmocka_unit_test(lexIdentifierNotInvalidOperator),
+	cmocka_unit_test(lexLessInvalidOperator),
+	cmocka_unit_test(lexIdentifierLessInvalidOperator),
+	cmocka_unit_test(lexGreaterInvalidOperator),
+	cmocka_unit_test(lexIdentifierGreaterInvalidOperator),
+	cmocka_unit_test(lexAndInvalidOperator),
+	cmocka_unit_test(lexIdentifierAndInvalidOperator),
+	cmocka_unit_test(lexOrInvalidOperator),
+	cmocka_unit_test(lexIdentifierOrInvalidOperator),
+	cmocka_unit_test(lexSimpleExpression),
+	cmocka_unit_test(lexOpenParen),
+	cmocka_unit_test(lexCloseParen),
+	cmocka_unit_test(lexIdentifierCloseParen),
+	cmocka_unit_test(lexParentheticalExpression),
+	cmocka_unit_test(lexNestedParentheticalExpression),
+	cmocka_unit_test(lexSpaceSimple),
+	cmocka_unit_test(lexSpaceIdentifier),
+	cmocka_unit_test(lexSpaceOperator),
+	cmocka_unit_test(lexSpaceParen),
+	cmocka_unit_test(lexSpaceParens))

@@ -0,0 +1,118 @@
+/* Copyright (c) 2013-2017 Jeffrey Pfau
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+#include "util/test/suite.h"
+
+#include <mgba/internal/debugger/parser.h>
+
+struct LPTest {
+	struct LexVector lv;
+	struct ParseTree tree;
+};
+
+#define PARSE(STR) \
+	struct LPTest* lp = *state; \
+	lexFree(&lp->lv); \
+	LexVectorClear(&lp->lv); \
+	size_t adjusted = lexExpression(&lp->lv, STR, strlen(STR), ""); \
+	assert_false(adjusted > strlen(STR)); \
+	struct ParseTree* tree = &lp->tree; \
+	parseLexedExpression(tree, &lp->lv)
+
+M_TEST_SUITE_SETUP(Parser) {
+	struct LPTest* lp = malloc(sizeof(struct LPTest));
+	LexVectorInit(&lp->lv, 0);
+	*state = lp;
+	return 0;
+}
+
+M_TEST_SUITE_TEARDOWN(Parser) {
+	struct LPTest* lp = *state;
+	parseFree(&lp->tree); \
+	lexFree(&lp->lv);
+	LexVectorDeinit(&lp->lv);
+	free(lp);
+	return 0;
+}
+
+M_TEST_DEFINE(parseEmpty) {
+	PARSE("");
+
+	assert_int_equal(tree->token.type, TOKEN_ERROR_TYPE);
+}
+
+M_TEST_DEFINE(parseInt) {
+	PARSE("0");
+
+	assert_int_equal(tree->token.type, TOKEN_UINT_TYPE);
+	assert_int_equal(tree->token.uintValue, 0);
+}
+
+M_TEST_DEFINE(parseLexError) {
+	PARSE("@");
+
+	assert_int_equal(tree->token.type, TOKEN_ERROR_TYPE);
+}
+
+M_TEST_DEFINE(parseSimpleExpression) {
+	PARSE("1+2");
+
+	assert_int_equal(tree->token.type, TOKEN_OPERATOR_TYPE);
+	assert_int_equal(tree->token.operatorValue, OP_ADD);
+	assert_int_equal(tree->lhs->token.type, TOKEN_UINT_TYPE);
+	assert_int_equal(tree->lhs->token.uintValue, 1);
+	assert_int_equal(tree->rhs->token.type, TOKEN_UINT_TYPE);
+	assert_int_equal(tree->rhs->token.uintValue, 2);
+}
+
+M_TEST_DEFINE(parseAddMultplyExpression) {
+	PARSE("1+2*3");
+
+	assert_int_equal(tree->token.type, TOKEN_OPERATOR_TYPE);
+	assert_int_equal(tree->token.operatorValue, OP_ADD);
+	assert_int_equal(tree->lhs->token.type, TOKEN_UINT_TYPE);
+	assert_int_equal(tree->lhs->token.uintValue, 1);
+	assert_int_equal(tree->rhs->token.type, TOKEN_OPERATOR_TYPE);
+	assert_int_equal(tree->rhs->token.uintValue, OP_MULTIPLY);
+	assert_int_equal(tree->rhs->lhs->token.type, TOKEN_UINT_TYPE);
+	assert_int_equal(tree->rhs->lhs->token.uintValue, 2);
+	assert_int_equal(tree->rhs->rhs->token.type, TOKEN_UINT_TYPE);
+	assert_int_equal(tree->rhs->rhs->token.uintValue, 3);
+}
+
+M_TEST_DEFINE(parseParentheticalExpression) {
+	PARSE("(1+2)");
+
+	assert_int_equal(tree->token.type, TOKEN_OPERATOR_TYPE);
+	assert_int_equal(tree->token.operatorValue, OP_ADD);
+	assert_int_equal(tree->lhs->token.type, TOKEN_UINT_TYPE);
+	assert_int_equal(tree->lhs->token.uintValue, 1);
+	assert_int_equal(tree->rhs->token.type, TOKEN_UINT_TYPE);
+	assert_int_equal(tree->rhs->token.uintValue, 2);
+}
+
+M_TEST_DEFINE(parseParentheticalAddMultplyExpression) {
+	PARSE("(1+2)*3");
+
+	assert_int_equal(tree->token.type, TOKEN_OPERATOR_TYPE);
+	assert_int_equal(tree->token.operatorValue, OP_MULTIPLY);
+	assert_int_equal(tree->lhs->token.type, TOKEN_OPERATOR_TYPE);
+	assert_int_equal(tree->lhs->token.uintValue, OP_ADD);
+	assert_int_equal(tree->lhs->lhs->token.type, TOKEN_UINT_TYPE);
+	assert_int_equal(tree->lhs->lhs->token.uintValue, 1);
+	assert_int_equal(tree->lhs->lhs->token.type, TOKEN_UINT_TYPE);
+	assert_int_equal(tree->lhs->rhs->token.uintValue, 2);
+	assert_int_equal(tree->rhs->token.type, TOKEN_UINT_TYPE);
+	assert_int_equal(tree->rhs->token.uintValue, 3);
+}
+
+M_TEST_SUITE_DEFINE_SETUP_TEARDOWN(Parser,
+	cmocka_unit_test(parseEmpty),
+	cmocka_unit_test(parseInt),
+	cmocka_unit_test(parseLexError),
+	cmocka_unit_test(parseSimpleExpression),
+	cmocka_unit_test(parseAddMultplyExpression),
+	cmocka_unit_test(parseParentheticalExpression),
+	cmocka_unit_test(parseParentheticalAddMultplyExpression))

@@ -133,13 +133,13 @@ DSDMAService(dscore, dma);
 		}
 	} else {
 		dma->nextCount = 0;
-		if (!GBADMARegisterIsRepeat(dma->reg) || GBADMARegisterGetTiming(dma->reg) == DMA_TIMING_NOW) {
+		if (!GBADMARegisterIsRepeat(dma->reg) || GBADMARegisterGetTiming(dma->reg) == GBA_DMA_TIMING_NOW) {
 			dma->reg = GBADMARegisterClearEnable(dma->reg);
 
 			// Clear the enable bit in memory
 			memory->io[(DS_REG_DMA0CNT_HI + memory->activeDMA * (DS_REG_DMA1CNT_HI - DS_REG_DMA0CNT_HI)) >> 1] &= 0x7FFF;
 		}
-		if (GBADMARegisterGetDestControl(dma->reg) == DMA_INCREMENT_RELOAD) {
+		if (GBADMARegisterGetDestControl(dma->reg) == GBA_DMA_INCREMENT_RELOAD) {
 			dma->nextDest = dma->dest;
 		}
 		if (GBADMARegisterIsDoIRQ(dma->reg)) {

@@ -617,7 +617,7 @@ #ifdef USE_DEBUGGERS
 	if (ds->debugger) {
 		struct mDebuggerEntryInfo info = {
 			.address = _ARMPCAddress(cpu),
-			.opcode = opcode
+			.type.bp.opcode = opcode
 		};
 		mDebuggerEnter(ds->debugger->d.p, DEBUGGER_ENTER_ILLEGAL_OP, &info);
 	}
@@ -641,7 +641,7 @@ #ifdef USE_DEBUGGERS
 	} else if (ds->debugger) {
 		struct mDebuggerEntryInfo info = {
 			.address = _ARMPCAddress(cpu),
-			.opcode = opcode
+			.type.bp.opcode = opcode
 		};
 		mDebuggerEnter(ds->debugger->d.p, DEBUGGER_ENTER_ILLEGAL_OP, &info);
 #endif

@@ -12,7 +12,6 @@ #include <mgba/internal/ds/ds.h>
 
 static void _DSCLIDebuggerInit(struct CLIDebuggerSystem*);
 static bool _DSCLIDebuggerCustom(struct CLIDebuggerSystem*);
-static uint32_t _DSCLIDebuggerLookupIdentifier(struct CLIDebuggerSystem*, const char* name, struct CLIDebugVector* dv);
 
 static void _frame(struct CLIDebugger*, struct CLIDebugVector*);
 static void _switchCpu(struct CLIDebugger*, struct CLIDebugVector*);
@@ -29,7 +28,6 @@ ARMCLIDebuggerCreate(&debugger->d);
 	debugger->d.init = _DSCLIDebuggerInit;
 	debugger->d.deinit = NULL;
 	debugger->d.custom = _DSCLIDebuggerCustom;
-	debugger->d.lookupIdentifier = _DSCLIDebuggerLookupIdentifier;
 
 	debugger->d.name = "DS";
 	debugger->d.commands = _DSCLIDebuggerCommands;
@@ -47,12 +45,6 @@ }
 
 static bool _DSCLIDebuggerCustom(struct CLIDebuggerSystem* debugger) {
 	return false;
-}
-
-static uint32_t _DSCLIDebuggerLookupIdentifier(struct CLIDebuggerSystem* debugger, const char* name, struct CLIDebugVector* dv) {
-	UNUSED(debugger);
-	dv->type = CLIDV_ERROR_TYPE;
-	return 0;
 }
 
 static void _frame(struct CLIDebugger* debugger, struct CLIDebugVector* dv) {

@@ -235,7 +235,11 @@ encoder->audio->sample_fmt = encoder->sampleFormat;
 		AVDictionary* opts = 0;
 		av_dict_set(&opts, "strict", "-2", 0);
 		if (encoder->context->oformat->flags & AVFMT_GLOBALHEADER) {
+#ifdef AV_CODEC_FLAG_GLOBAL_HEADER
+			encoder->audio->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
+#else
 			encoder->audio->flags |= CODEC_FLAG_GLOBAL_HEADER;
+#endif
 		}
 		avcodec_open2(encoder->audio, acodec, &opts);
 		av_dict_free(&opts);
@@ -298,7 +302,11 @@ encoder->video->pix_fmt = encoder->pixFormat;
 	encoder->video->gop_size = 60;
 	encoder->video->max_b_frames = 3;
 	if (encoder->context->oformat->flags & AVFMT_GLOBALHEADER) {
+#ifdef AV_CODEC_FLAG_GLOBAL_HEADER
+		encoder->video->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
+#else
 		encoder->video->flags |= CODEC_FLAG_GLOBAL_HEADER;
+#endif
 	}
 	if (strcmp(vcodec->name, "libx264") == 0) {
 		// Try to adaptively figure out when you can use a slower encoder

@@ -10,6 +10,9 @@ #include <mgba/core/core.h>
 #include "feature/gui/gui-runner.h"
 #include "feature/gui/remap.h"
 #include <mgba/internal/gba/gba.h>
+#ifdef M_CORE_GB
+#include <mgba/internal/gb/gb.h>
+#endif
 #include <mgba-util/gui/file-select.h>
 #include <mgba-util/gui/menu.h>
 
@@ -39,6 +42,26 @@ .title = "Show framerate",
 		.data = "fpsCounter",
 		.submenu = 0,
 		.state = false,
+		.validStates = (const char*[]) {
+			"Off", "On"
+		},
+		.nStates = 2
+	};
+	*GUIMenuItemListAppend(&menu.items) = (struct GUIMenuItem) {
+		.title = "Autosave state",
+		.data = "autosave",
+		.submenu = 0,
+		.state = true,
+		.validStates = (const char*[]) {
+			"Off", "On"
+		},
+		.nStates = 2
+	};
+	*GUIMenuItemListAppend(&menu.items) = (struct GUIMenuItem) {
+		.title = "Autoload state",
+		.data = "autoload",
+		.submenu = 0,
+		.state = true,
 		.validStates = (const char*[]) {
 			"Off", "On"
 		},
@@ -55,9 +78,23 @@ },
 		.nStates = 2
 	};
 	*GUIMenuItemListAppend(&menu.items) = (struct GUIMenuItem) {
-		.title = "Select BIOS path",
-		.data = "bios",
+		.title = "Select GBA BIOS path",
+		.data = "gba.bios",
+	};
+#ifdef M_CORE_GB
+	*GUIMenuItemListAppend(&menu.items) = (struct GUIMenuItem) {
+		.title = "Select GB BIOS path",
+		.data = "gb.bios",
 	};
+	*GUIMenuItemListAppend(&menu.items) = (struct GUIMenuItem) {
+		.title = "Select GBC BIOS path",
+		.data = "gbc.bios",
+	};
+	*GUIMenuItemListAppend(&menu.items) = (struct GUIMenuItem) {
+		.title = "Select SGB BIOS path",
+		.data = "sgb.bios",
+	};
+#endif
 	size_t i;
 	const char* mapNames[GUI_MAX_INPUTS + 1];
 	if (runner->keySources) {
@@ -88,7 +125,12 @@ .title = "Cancel",
 		.data = 0,
 	};
 	enum GUIMenuExitReason reason;
-	char biosPath[256] = "";
+	char gbaBiosPath[256] = "";
+#ifdef M_CORE_GB
+	char gbBiosPath[256] = "";
+	char gbcBiosPath[256] = "";
+	char sgbBiosPath[256] = "";
+#endif
 
 	struct GUIMenuItem* item;
 	for (i = 0; i < GUIMenuItemListSize(&menu.items); ++i) {
@@ -105,8 +147,17 @@ if (reason != GUI_MENU_EXIT_ACCEPT || !item->data) {
 			break;
 		}
 		if (!strcmp(item->data, "*SAVE")) {
-			if (biosPath[0]) {
-				mCoreConfigSetValue(&runner->config, "bios", biosPath);
+			if (gbaBiosPath[0]) {
+				mCoreConfigSetValue(&runner->config, "gba.bios", gbaBiosPath);
+			}
+			if (gbBiosPath[0]) {
+				mCoreConfigSetValue(&runner->config, "gb.bios", gbBiosPath);
+			}
+			if (gbcBiosPath[0]) {
+				mCoreConfigSetValue(&runner->config, "gbc.bios", gbcBiosPath);
+			}
+			if (sgbBiosPath[0]) {
+				mCoreConfigSetValue(&runner->config, "sgb.bios", sgbBiosPath);
 			}
 			for (i = 0; i < GUIMenuItemListSize(&menu.items); ++i) {
 				item = GUIMenuItemListGetPointer(&menu.items, i);
@@ -130,13 +181,36 @@ if (!strcmp(item->data, "*REMAP")) {
 			mGUIRemapKeys(&runner->params, &runner->core->inputMap, &runner->keySources[item->state]);
 			continue;
 		}
-		if (!strcmp(item->data, "bios")) {
+		if (!strcmp(item->data, "gba.bios")) {
+			// TODO: show box if failed
+			if (!GUISelectFile(&runner->params, gbaBiosPath, sizeof(gbaBiosPath), GBAIsBIOS)) {
+				gbaBiosPath[0] = '\0';
+			}
+			continue;
+		}
+#ifdef M_CORE_GB
+		if (!strcmp(item->data, "gb.bios")) {
 			// TODO: show box if failed
-			if (!GUISelectFile(&runner->params, biosPath, sizeof(biosPath), GBAIsBIOS)) {
-				biosPath[0] = '\0';
+			if (!GUISelectFile(&runner->params, gbBiosPath, sizeof(gbBiosPath), GBIsBIOS)) {
+				gbBiosPath[0] = '\0';
 			}
 			continue;
 		}
+		if (!strcmp(item->data, "gbc.bios")) {
+			// TODO: show box if failed
+			if (!GUISelectFile(&runner->params, gbcBiosPath, sizeof(gbcBiosPath), GBIsBIOS)) {
+				gbcBiosPath[0] = '\0';
+			}
+			continue;
+		}
+		if (!strcmp(item->data, "sgb.bios")) {
+			// TODO: show box if failed
+			if (!GUISelectFile(&runner->params, sgbBiosPath, sizeof(sgbBiosPath), GBIsBIOS)) {
+				sgbBiosPath[0] = '\0';
+			}
+			continue;
+		}
+#endif
 		if (item->validStates) {
 			++item->state;
 			if (item->state >= item->nStates) {

@@ -18,15 +18,12 @@ #include <mgba-util/memory.h>
 #include <mgba-util/png-io.h>
 #include <mgba-util/vfs.h>
 
-#ifdef _3DS
-#include <3ds.h>
-#endif
-
 #include <sys/time.h>
 
 mLOG_DECLARE_CATEGORY(GUI_RUNNER);
 mLOG_DEFINE_CATEGORY(GUI_RUNNER, "GUI Runner", "gui.runner");
 
+#define AUTOSAVE_GRANULARITY 600
 #define FPS_GRANULARITY 120
 #define FPS_BUFFER_SIZE 3
 
@@ -38,18 +35,10 @@ RUNNER_LOAD_STATE,
 	RUNNER_SCREENSHOT,
 	RUNNER_CONFIG,
 	RUNNER_RESET,
-	RUNNER_COMMAND_MASK = 0xFFFF,
+	RUNNER_COMMAND_MASK = 0xFFFF
+};
 
-	RUNNER_STATE_1 = 0x10000,
-	RUNNER_STATE_2 = 0x20000,
-	RUNNER_STATE_3 = 0x30000,
-	RUNNER_STATE_4 = 0x40000,
-	RUNNER_STATE_5 = 0x50000,
-	RUNNER_STATE_6 = 0x60000,
-	RUNNER_STATE_7 = 0x70000,
-	RUNNER_STATE_8 = 0x80000,
-	RUNNER_STATE_9 = 0x90000,
-};
+#define RUNNER_STATE(X) ((X) << 16)
 
 static const struct mInputPlatformInfo _mGUIKeyInfo = {
 	.platformName = "gui",
@@ -145,6 +134,27 @@ }
 	return 0xFF - value;
 }
 
+static void _tryAutosave(struct mGUIRunner* runner) {
+	int autosave = false;
+	mCoreConfigGetIntValue(&runner->config, "autosave", &autosave);
+	if (!autosave) {
+		return;
+	}
+
+#ifdef DISABLE_THREADING
+	mCoreSaveState(runner->core, 0, SAVESTATE_SAVEDATA | SAVESTATE_RTC | SAVESTATE_METADATA);
+#else
+	if (!runner->autosave.buffer) {
+		runner->autosave.buffer = VFileMemChunk(NULL, 0);
+	}
+	MutexLock(&runner->autosave.mutex);
+	runner->autosave.core = runner->core;
+	mCoreSaveStateNamed(runner->core, runner->autosave.buffer, SAVESTATE_SAVEDATA | SAVESTATE_RTC | SAVESTATE_METADATA);
+	ConditionWake(&runner->autosave.cond);
+	MutexUnlock(&runner->autosave.mutex);
+#endif
+}
+
 void mGUIInit(struct mGUIRunner* runner, const char* port) {
 	GUIInit(&runner->params);
 	runner->port = port;
@@ -164,7 +174,14 @@ mCoreConfigInit(&runner->config, runner->port);
 	// TODO: Do we need to load more defaults?
 	mCoreConfigSetDefaultIntValue(&runner->config, "volume", 0x100);
 	mCoreConfigSetDefaultValue(&runner->config, "idleOptimization", "detect");
+	mCoreConfigSetDefaultIntValue(&runner->config, "autoload", true);
+#ifdef DISABLE_THREADING
+	mCoreConfigSetDefaultIntValue(&runner->config, "autosave", false);
+#else
+	mCoreConfigSetDefaultIntValue(&runner->config, "autosave", true);
+#endif
 	mCoreConfigLoad(&runner->config);
+	mCoreConfigGetIntValue(&runner->config, "logLevel", &logger.logLevel);
 
 	char path[PATH_MAX];
 	mCoreConfigDirectory(path, PATH_MAX);
@@ -177,9 +194,34 @@ if (lastPath) {
 		strncpy(runner->params.currentPath, lastPath, PATH_MAX - 1);
 		runner->params.currentPath[PATH_MAX - 1] = '\0';
 	}
+
+#ifndef DISABLE_THREADING
+	if (!runner->autosave.running) {
+		runner->autosave.running = true;
+		MutexInit(&runner->autosave.mutex);
+		ConditionInit(&runner->autosave.cond);
+		ThreadCreate(&runner->autosave.thread, mGUIAutosaveThread, &runner->autosave);
+	}
+#endif
 }
 
 void mGUIDeinit(struct mGUIRunner* runner) {
+#ifndef DISABLE_THREADING
+	MutexLock(&runner->autosave.mutex);
+	runner->autosave.running = false;
+	ConditionWake(&runner->autosave.cond);
+	MutexUnlock(&runner->autosave.mutex);
+
+	ThreadJoin(runner->autosave.thread);
+
+	ConditionDeinit(&runner->autosave.cond);
+	MutexDeinit(&runner->autosave.mutex);
+
+	if (runner->autosave.buffer) {
+		runner->autosave.buffer->close(runner->autosave.buffer);
+	}
+#endif
+
 	if (runner->teardown) {
 		runner->teardown(runner);
 	}
@@ -242,25 +284,26 @@ *GUIMenuItemListAppend(&pauseMenu.items) = (struct GUIMenuItem) { .title = "Unpause", .data = (void*) RUNNER_CONTINUE };
 	*GUIMenuItemListAppend(&pauseMenu.items) = (struct GUIMenuItem) { .title = "Save state", .submenu = &stateSaveMenu };
 	*GUIMenuItemListAppend(&pauseMenu.items) = (struct GUIMenuItem) { .title = "Load state", .submenu = &stateLoadMenu };
 
-	*GUIMenuItemListAppend(&stateSaveMenu.items) = (struct GUIMenuItem) { .title = "State 1", .data = (void*) (RUNNER_SAVE_STATE | RUNNER_STATE_1) };
-	*GUIMenuItemListAppend(&stateSaveMenu.items) = (struct GUIMenuItem) { .title = "State 2", .data = (void*) (RUNNER_SAVE_STATE | RUNNER_STATE_2) };
-	*GUIMenuItemListAppend(&stateSaveMenu.items) = (struct GUIMenuItem) { .title = "State 3", .data = (void*) (RUNNER_SAVE_STATE | RUNNER_STATE_3) };
-	*GUIMenuItemListAppend(&stateSaveMenu.items) = (struct GUIMenuItem) { .title = "State 4", .data = (void*) (RUNNER_SAVE_STATE | RUNNER_STATE_4) };
-	*GUIMenuItemListAppend(&stateSaveMenu.items) = (struct GUIMenuItem) { .title = "State 5", .data = (void*) (RUNNER_SAVE_STATE | RUNNER_STATE_5) };
-	*GUIMenuItemListAppend(&stateSaveMenu.items) = (struct GUIMenuItem) { .title = "State 6", .data = (void*) (RUNNER_SAVE_STATE | RUNNER_STATE_6) };
-	*GUIMenuItemListAppend(&stateSaveMenu.items) = (struct GUIMenuItem) { .title = "State 7", .data = (void*) (RUNNER_SAVE_STATE | RUNNER_STATE_7) };
-	*GUIMenuItemListAppend(&stateSaveMenu.items) = (struct GUIMenuItem) { .title = "State 8", .data = (void*) (RUNNER_SAVE_STATE | RUNNER_STATE_8) };
-	*GUIMenuItemListAppend(&stateSaveMenu.items) = (struct GUIMenuItem) { .title = "State 9", .data = (void*) (RUNNER_SAVE_STATE | RUNNER_STATE_9) };
+	*GUIMenuItemListAppend(&stateSaveMenu.items) = (struct GUIMenuItem) { .title = "State 1", .data = (void*) (RUNNER_SAVE_STATE | RUNNER_STATE(1)) };
+	*GUIMenuItemListAppend(&stateSaveMenu.items) = (struct GUIMenuItem) { .title = "State 2", .data = (void*) (RUNNER_SAVE_STATE | RUNNER_STATE(2)) };
+	*GUIMenuItemListAppend(&stateSaveMenu.items) = (struct GUIMenuItem) { .title = "State 3", .data = (void*) (RUNNER_SAVE_STATE | RUNNER_STATE(3)) };
+	*GUIMenuItemListAppend(&stateSaveMenu.items) = (struct GUIMenuItem) { .title = "State 4", .data = (void*) (RUNNER_SAVE_STATE | RUNNER_STATE(4)) };
+	*GUIMenuItemListAppend(&stateSaveMenu.items) = (struct GUIMenuItem) { .title = "State 5", .data = (void*) (RUNNER_SAVE_STATE | RUNNER_STATE(5)) };
+	*GUIMenuItemListAppend(&stateSaveMenu.items) = (struct GUIMenuItem) { .title = "State 6", .data = (void*) (RUNNER_SAVE_STATE | RUNNER_STATE(6)) };
+	*GUIMenuItemListAppend(&stateSaveMenu.items) = (struct GUIMenuItem) { .title = "State 7", .data = (void*) (RUNNER_SAVE_STATE | RUNNER_STATE(7)) };
+	*GUIMenuItemListAppend(&stateSaveMenu.items) = (struct GUIMenuItem) { .title = "State 8", .data = (void*) (RUNNER_SAVE_STATE | RUNNER_STATE(8)) };
+	*GUIMenuItemListAppend(&stateSaveMenu.items) = (struct GUIMenuItem) { .title = "State 9", .data = (void*) (RUNNER_SAVE_STATE | RUNNER_STATE(9)) };
 
-	*GUIMenuItemListAppend(&stateLoadMenu.items) = (struct GUIMenuItem) { .title = "State 1", .data = (void*) (RUNNER_LOAD_STATE | RUNNER_STATE_1) };
-	*GUIMenuItemListAppend(&stateLoadMenu.items) = (struct GUIMenuItem) { .title = "State 2", .data = (void*) (RUNNER_LOAD_STATE | RUNNER_STATE_2) };
-	*GUIMenuItemListAppend(&stateLoadMenu.items) = (struct GUIMenuItem) { .title = "State 3", .data = (void*) (RUNNER_LOAD_STATE | RUNNER_STATE_3) };
-	*GUIMenuItemListAppend(&stateLoadMenu.items) = (struct GUIMenuItem) { .title = "State 4", .data = (void*) (RUNNER_LOAD_STATE | RUNNER_STATE_4) };
-	*GUIMenuItemListAppend(&stateLoadMenu.items) = (struct GUIMenuItem) { .title = "State 5", .data = (void*) (RUNNER_LOAD_STATE | RUNNER_STATE_5) };
-	*GUIMenuItemListAppend(&stateLoadMenu.items) = (struct GUIMenuItem) { .title = "State 6", .data = (void*) (RUNNER_LOAD_STATE | RUNNER_STATE_6) };
-	*GUIMenuItemListAppend(&stateLoadMenu.items) = (struct GUIMenuItem) { .title = "State 7", .data = (void*) (RUNNER_LOAD_STATE | RUNNER_STATE_7) };
-	*GUIMenuItemListAppend(&stateLoadMenu.items) = (struct GUIMenuItem) { .title = "State 8", .data = (void*) (RUNNER_LOAD_STATE | RUNNER_STATE_8) };
-	*GUIMenuItemListAppend(&stateLoadMenu.items) = (struct GUIMenuItem) { .title = "State 9", .data = (void*) (RUNNER_LOAD_STATE | RUNNER_STATE_9) };
+	*GUIMenuItemListAppend(&stateLoadMenu.items) = (struct GUIMenuItem) { .title = "Autosave", .data = (void*) (RUNNER_LOAD_STATE | RUNNER_STATE(0)) };
+	*GUIMenuItemListAppend(&stateLoadMenu.items) = (struct GUIMenuItem) { .title = "State 1", .data = (void*) (RUNNER_LOAD_STATE | RUNNER_STATE(1)) };
+	*GUIMenuItemListAppend(&stateLoadMenu.items) = (struct GUIMenuItem) { .title = "State 2", .data = (void*) (RUNNER_LOAD_STATE | RUNNER_STATE(2)) };
+	*GUIMenuItemListAppend(&stateLoadMenu.items) = (struct GUIMenuItem) { .title = "State 3", .data = (void*) (RUNNER_LOAD_STATE | RUNNER_STATE(3)) };
+	*GUIMenuItemListAppend(&stateLoadMenu.items) = (struct GUIMenuItem) { .title = "State 4", .data = (void*) (RUNNER_LOAD_STATE | RUNNER_STATE(4)) };
+	*GUIMenuItemListAppend(&stateLoadMenu.items) = (struct GUIMenuItem) { .title = "State 5", .data = (void*) (RUNNER_LOAD_STATE | RUNNER_STATE(5)) };
+	*GUIMenuItemListAppend(&stateLoadMenu.items) = (struct GUIMenuItem) { .title = "State 6", .data = (void*) (RUNNER_LOAD_STATE | RUNNER_STATE(6)) };
+	*GUIMenuItemListAppend(&stateLoadMenu.items) = (struct GUIMenuItem) { .title = "State 7", .data = (void*) (RUNNER_LOAD_STATE | RUNNER_STATE(7)) };
+	*GUIMenuItemListAppend(&stateLoadMenu.items) = (struct GUIMenuItem) { .title = "State 8", .data = (void*) (RUNNER_LOAD_STATE | RUNNER_STATE(8)) };
+	*GUIMenuItemListAppend(&stateLoadMenu.items) = (struct GUIMenuItem) { .title = "State 9", .data = (void*) (RUNNER_LOAD_STATE | RUNNER_STATE(9)) };
 
 	*GUIMenuItemListAppend(&pauseMenu.items) = (struct GUIMenuItem) { .title = "Take screenshot", .data = (void*) RUNNER_SCREENSHOT };
 	*GUIMenuItemListAppend(&pauseMenu.items) = (struct GUIMenuItem) { .title = "Configure", .data = (void*) RUNNER_CONFIG };
@@ -283,7 +326,7 @@ runner->core = mCoreFind(path);
 	if (runner->core) {
 		mLOG(GUI_RUNNER, INFO, "Found core");
 		runner->core->init(runner->core);
-		mCoreConfigInit(&runner->core->config, runner->port);
+		mCoreInitConfig(runner->core, runner->port);
 		mInputMapInit(&runner->core->inputMap, &GBAInputInfo);
 		found = mCoreLoadFile(runner->core, path);
 		if (!found) {
@@ -302,10 +345,10 @@ runner->core->setPeripheral(runner->core, mPERIPH_GBA_LUMINANCE, &runner->luminanceSource.d);
 	}
 	mLOG(GUI_RUNNER, DEBUG, "Loading config...");
 	mCoreLoadForeignConfig(runner->core, &runner->config);
-	logger.logLevel = runner->core->opts.logLevel;
 
 	mLOG(GUI_RUNNER, DEBUG, "Loading save...");
 	mCoreAutoloadSave(runner->core);
+	mCoreAutoloadCheats(runner->core);
 	if (runner->setup) {
 		mLOG(GUI_RUNNER, DEBUG, "Setting up runner...");
 		runner->setup(runner);
@@ -320,7 +363,22 @@ }
 	mLOG(GUI_RUNNER, DEBUG, "Reseting...");
 	runner->core->reset(runner->core);
 	mLOG(GUI_RUNNER, DEBUG, "Reset!");
+
+
+	int autoload = false;
+	mCoreConfigGetIntValue(&runner->config, "autoload", &autoload);
+	if (autoload) {
+		mCoreLoadState(runner->core, 0, SAVESTATE_SCREENSHOT | SAVESTATE_RTC);
+	}
+
 	bool running = true;
+
+#ifndef DISABLE_THREADING
+	MutexLock(&runner->autosave.mutex);
+	runner->autosave.core = runner->core;
+	MutexUnlock(&runner->autosave.mutex);
+#endif
+
 	if (runner->gameLoaded) {
 		runner->gameLoaded(runner);
 	}
@@ -333,13 +391,14 @@ struct timeval tv;
 		gettimeofday(&tv, 0);
 		runner->lastFpsCheck = 1000000LL * tv.tv_sec + tv.tv_usec;
 
-		while (true) {
-#ifdef _3DS
-			running = aptMainLoop();
-			if (!running) {
-				break;
+		int frame = 0;
+		while (running) {
+			if (runner->running) {
+				running = runner->running(runner);
+				if (!running) {
+					break;
+				}
 			}
-#endif
 			uint32_t guiKeys;
 			uint32_t heldKeys;
 			GUIPollInput(&runner->params, &guiKeys, &heldKeys);
@@ -411,6 +470,11 @@ runner->totalDelta += delta;
 						runner->fps = (CircleBufferSize(&runner->fpsBuffer) * FPS_GRANULARITY * 1000000.0f) / (runner->totalDelta * sizeof(uint32_t));
 					}
 				}
+				if (frame == AUTOSAVE_GRANULARITY) {
+					frame = 0;
+					_tryAutosave(runner);
+				}
+				++frame;
 			}
 		}
 
@@ -463,6 +527,18 @@ mLOG(GUI_RUNNER, DEBUG, "Shutting down...");
 	if (runner->gameUnloaded) {
 		runner->gameUnloaded(runner);
 	}
+#ifndef DISABLE_THREADING
+	MutexLock(&runner->autosave.mutex);
+	runner->autosave.core = NULL;
+	MutexUnlock(&runner->autosave.mutex);
+#endif
+
+	int autosave = false;
+	mCoreConfigGetIntValue(&runner->config, "autosave", &autosave);
+	if (autosave) {
+		mCoreSaveState(runner->core, 0, SAVESTATE_SAVEDATA | SAVESTATE_RTC | SAVESTATE_METADATA);
+	}
+
 	mLOG(GUI_RUNNER, DEBUG, "Unloading game...");
 	runner->core->unloadROM(runner->core);
 	drawState.screenshotId = 0;
@@ -486,6 +562,7 @@ }
 	mInputMapDeinit(&runner->core->inputMap);
 	mLOG(GUI_RUNNER, DEBUG, "Deinitializing core...");
 	runner->core->deinit(runner->core);
+	runner->core = NULL;
 
 	GUIMenuItemListDeinit(&pauseMenu.items);
 	GUIMenuItemListDeinit(&stateSaveMenu.items);
@@ -511,3 +588,21 @@ mCoreConfigSave(&runner->config);
 		mGUIRun(runner, path);
 	}
 }
+
+#ifndef DISABLE_THREADING
+THREAD_ENTRY mGUIAutosaveThread(void* context) {
+	struct mGUIAutosaveContext* autosave = context;
+	MutexLock(&autosave->mutex);
+	while (autosave->running) {
+		ConditionWait(&autosave->cond, &autosave->mutex);
+		if (autosave->running && autosave->core) {
+			struct VFile* vf = mCoreGetState(autosave->core, 0, true);
+			void* mem = autosave->buffer->map(autosave->buffer, autosave->buffer->size(autosave->buffer), MAP_READ);
+			vf->write(vf, mem, autosave->buffer->size(autosave->buffer));
+			autosave->buffer->unmap(autosave->buffer, mem, autosave->buffer->size(autosave->buffer));
+			vf->close(vf);
+		}
+	}
+	MutexUnlock(&autosave->mutex);
+}
+#endif

@@ -15,6 +15,7 @@ #include "feature/gui/remap.h"
 #include <mgba/internal/gba/hardware.h>
 #include <mgba-util/circle-buffer.h>
 #include <mgba-util/gui.h>
+#include <mgba-util/threading.h>
 
 enum mGUIInput {
 	mGUI_INPUT_INCREASE_BRIGHTNESS = GUI_INPUT_USER_START,
@@ -38,12 +39,27 @@ struct GBALuminanceSource d;
 	int luxLevel;
 };
 
+#ifndef DISABLE_THREADING
+struct VFile;
+struct mGUIAutosaveContext {
+	struct VFile* buffer;
+	struct mCore* core;
+	Thread thread;
+	Mutex mutex;
+	Condition cond;
+	bool running;
+};
+#endif
+
 struct mGUIRunner {
 	struct mCore* core;
 	struct GUIParams params;
 
 	struct mGUIBackground background;
 	struct mGUIRunnerLux luminanceSource;
+#ifndef DISABLE_THREADING
+	struct mGUIAutosaveContext autosave;
+#endif
 
 	struct mInputMap guiKeys;
 	struct mCoreConfig config;
@@ -70,12 +86,17 @@ void (*unpaused)(struct mGUIRunner*);
 	void (*incrementScreenMode)(struct mGUIRunner*);
 	void (*setFrameLimiter)(struct mGUIRunner*, bool limit);
 	uint16_t (*pollGameInput)(struct mGUIRunner*);
+	bool (*running)(struct mGUIRunner*);
 };
 
 void mGUIInit(struct mGUIRunner*, const char* port);
 void mGUIDeinit(struct mGUIRunner*);
 void mGUIRun(struct mGUIRunner*, const char* path);
 void mGUIRunloop(struct mGUIRunner*);
+
+#ifndef DISABLE_THREADING
+THREAD_ENTRY mGUIAutosaveThread(void* context);
+#endif
 
 CXX_GUARD_END
 

@@ -244,7 +244,11 @@ }
 
 static void GBCheatRefresh(struct mCheatSet* cheats, struct mCheatDevice* device) {
 	struct GBCheatSet* gbset = (struct GBCheatSet*) cheats;
-	_patchROM(device, gbset);
+	if (cheats->enabled) {
+		_patchROM(device, gbset);
+	} else {
+		_unpatchROM(device, gbset);
+	}
 }
 
 static void GBCheatSetCopyProperties(struct mCheatSet* set, struct mCheatSet* oldSet) {

@@ -463,6 +463,10 @@ }
 #endif
 
 	LR35902Reset(core->cpu);
+
+	if (core->opts.skipBios) {
+		GBSkipBIOS(core->board);
+	}
 }
 
 static void _GBCoreRunFrame(struct mCore* core) {
@@ -746,6 +750,20 @@ return;
 	}
 	GBLoadSymbols(core->symbolTable, vf);
 }
+
+static bool _GBCoreLookupIdentifier(struct mCore* core, const char* name, int32_t* value, int* segment) {
+	UNUSED(core);
+	*segment = -1;
+	int i;
+	for (i = 0; i < REG_MAX; ++i) {
+		const char* reg = GBIORegisterNames[i];
+		if (reg && strcasecmp(reg, name) == 0) {
+			*value = GB_BASE_IO | i;
+			return true;
+		}
+	}
+	return false;
+}
 #endif
 
 static struct mCheatDevice* _GBCoreCheatDevice(struct mCore* core) {
@@ -835,6 +853,7 @@ break;
 	}
 }
 
+#ifndef MINIMAL_CORE
 static void _GBCoreStartVideoLog(struct mCore* core, struct mVideoLogContext* context) {
 	struct GBCore* gbcore = (struct GBCore*) core;
 	struct GB* gb = core->board;
@@ -857,6 +876,7 @@ GBVideoProxyRendererUnshim(&gb->video, &gbcore->proxyRenderer);
 	free(gbcore->proxyRenderer.logger);
 	gbcore->proxyRenderer.logger = NULL;
 }
+#endif
 
 struct mCore* GBCoreCreate(void) {
 	struct GBCore* gbcore = malloc(sizeof(*gbcore));
@@ -928,6 +948,7 @@ core->cliDebuggerSystem = _GBCoreCliDebuggerSystem;
 	core->attachDebugger = _GBCoreAttachDebugger;
 	core->detachDebugger = _GBCoreDetachDebugger;
 	core->loadSymbols = _GBCoreLoadSymbols;
+	core->lookupIdentifier = _GBCoreLookupIdentifier;
 #endif
 	core->cheatDevice = _GBCoreCheatDevice;
 	core->savedataClone = _GBCoreSavedataClone;

@@ -14,16 +14,15 @@ #include <mgba/internal/lr35902/debugger/cli-debugger.h>
 
 static void _GBCLIDebuggerInit(struct CLIDebuggerSystem*);
 static bool _GBCLIDebuggerCustom(struct CLIDebuggerSystem*);
-static uint32_t _GBCLIDebuggerLookupIdentifier(struct CLIDebuggerSystem*, const char* name, struct CLIDebugVector* dv);
 
 static void _frame(struct CLIDebugger*, struct CLIDebugVector*);
 static void _load(struct CLIDebugger*, struct CLIDebugVector*);
 static void _save(struct CLIDebugger*, struct CLIDebugVector*);
 
 struct CLIDebuggerCommandSummary _GBCLIDebuggerCommands[] = {
-	{ "frame", _frame, 0, "Frame advance" },
-	{ "load", _load, CLIDVParse, "Load a savestate" },
-	{ "save", _save, CLIDVParse, "Save a savestate" },
+	{ "frame", _frame, "", "Frame advance" },
+	{ "load", _load, "*", "Load a savestate" },
+	{ "save", _save, "*", "Save a savestate" },
 	{ 0, 0, 0, 0 }
 };
 
@@ -34,7 +33,6 @@ LR35902CLIDebuggerCreate(&debugger->d);
 	debugger->d.init = _GBCLIDebuggerInit;
 	debugger->d.deinit = NULL;
 	debugger->d.custom = _GBCLIDebuggerCustom;
-	debugger->d.lookupIdentifier = _GBCLIDebuggerLookupIdentifier;
 
 	debugger->d.name = "Game Boy";
 	debugger->d.commands = _GBCLIDebuggerCommands;
@@ -63,19 +61,6 @@ gbDebugger->inVblank = GBRegisterSTATGetMode(((struct GB*) gbDebugger->core->board)->memory.io[REG_STAT]) == 1;
 		return true;
 	}
 	return false;
-}
-
-static uint32_t _GBCLIDebuggerLookupIdentifier(struct CLIDebuggerSystem* debugger, const char* name, struct CLIDebugVector* dv) {
-	UNUSED(debugger);
-	int i;
-	for (i = 0; i < REG_MAX; ++i) {
-		const char* reg = GBIORegisterNames[i];
-		if (reg && strcasecmp(reg, name) == 0) {
-			return GB_BASE_IO | i;
-		}
-	}
-	dv->type = CLIDV_ERROR_TYPE;
-	return 0;
 }
 
 static void _frame(struct CLIDebugger* debugger, struct CLIDebugVector* dv) {

@@ -435,83 +435,10 @@ cpu->b = 0;
 	cpu->d = 0;
 
 	gb->timer.internalDiv = 0;
-	int nextDiv = 0;
-	if (!gb->biosVf) {
-		switch (gb->model) {
-		case GB_MODEL_AUTODETECT: // Silence warnings
-			gb->model = GB_MODEL_DMG;
-		case GB_MODEL_DMG:
-			cpu->a = 1;
-			cpu->f.packed = 0xB0;
-			cpu->c = 0x13;
-			cpu->e = 0xD8;
-			cpu->h = 1;
-			cpu->l = 0x4D;
-			gb->timer.internalDiv = 0xABC;
-			nextDiv = 4;
-			break;
-		case GB_MODEL_SGB:
-			cpu->a = 1;
-			cpu->f.packed = 0x00;
-			cpu->c = 0x14;
-			cpu->e = 0x00;
-			cpu->h = 0xC0;
-			cpu->l = 0x60;
-			gb->timer.internalDiv = 0xABC;
-			nextDiv = 4;
-			break;
-		case GB_MODEL_MGB:
-			cpu->a = 0xFF;
-			cpu->f.packed = 0xB0;
-			cpu->c = 0x13;
-			cpu->e = 0xD8;
-			cpu->h = 1;
-			cpu->l = 0x4D;
-			gb->timer.internalDiv = 0xABC;
-			nextDiv = 4;
-			break;
-		case GB_MODEL_SGB2:
-			cpu->a = 0xFF;
-			cpu->f.packed = 0x00;
-			cpu->c = 0x14;
-			cpu->e = 0x00;
-			cpu->h = 0xC0;
-			cpu->l = 0x60;
-			gb->timer.internalDiv = 0xABC;
-			nextDiv = 4;
-			break;
-		case GB_MODEL_AGB:
-			cpu->a = 0x11;
-			cpu->b = 1;
-			cpu->f.packed = 0x00;
-			cpu->c = 0;
-			cpu->e = 0x08;
-			cpu->h = 0;
-			cpu->l = 0x7C;
-			gb->timer.internalDiv = 0x1EA;
-			nextDiv = 0xC;
-			break;
-		case GB_MODEL_CGB:
-			cpu->a = 0x11;
-			cpu->f.packed = 0x80;
-			cpu->c = 0;
-			cpu->e = 0x08;
-			cpu->h = 0;
-			cpu->l = 0x7C;
-			gb->timer.internalDiv = 0x1EA;
-			nextDiv = 0xC;
-			break;
-		}
-
-		cpu->sp = 0xFFFE;
-		cpu->pc = 0x100;
-	}
 
 	gb->cpuBlocked = false;
 	gb->earlyExit = false;
 	gb->doubleSpeed = 0;
-
-	cpu->memory.setActiveRegion(cpu, cpu->pc);
 
 	if (gb->yankedRomSize) {
 		gb->memory.romSize = gb->yankedRomSize;
@@ -527,15 +454,109 @@
 	GBMemoryReset(gb);
 	GBVideoReset(&gb->video);
 	GBTimerReset(&gb->timer);
-	mTimingSchedule(&gb->timing, &gb->timer.event, nextDiv);
+	if (!gb->biosVf) {
+		GBSkipBIOS(gb);
+	} else {
+		mTimingSchedule(&gb->timing, &gb->timer.event, 0);
+	}
 
 	GBIOReset(gb);
 	GBAudioReset(&gb->audio);
 	GBSIOReset(&gb->sio);
+
+	cpu->memory.setActiveRegion(cpu, cpu->pc);
 
 	GBSavedataUnmask(gb);
 }
 
+void GBSkipBIOS(struct GB* gb) {
+	struct LR35902Core* cpu = gb->cpu;
+	int nextDiv = 0;
+
+	switch (gb->model) {
+	case GB_MODEL_AUTODETECT: // Silence warnings
+		gb->model = GB_MODEL_DMG;
+	case GB_MODEL_DMG:
+		cpu->a = 1;
+		cpu->f.packed = 0xB0;
+		cpu->c = 0x13;
+		cpu->e = 0xD8;
+		cpu->h = 1;
+		cpu->l = 0x4D;
+		gb->timer.internalDiv = 0xABC;
+		nextDiv = 4;
+		break;
+	case GB_MODEL_SGB:
+		cpu->a = 1;
+		cpu->f.packed = 0x00;
+		cpu->c = 0x14;
+		cpu->e = 0x00;
+		cpu->h = 0xC0;
+		cpu->l = 0x60;
+		gb->timer.internalDiv = 0xABC;
+		nextDiv = 4;
+		break;
+	case GB_MODEL_MGB:
+		cpu->a = 0xFF;
+		cpu->f.packed = 0xB0;
+		cpu->c = 0x13;
+		cpu->e = 0xD8;
+		cpu->h = 1;
+		cpu->l = 0x4D;
+		gb->timer.internalDiv = 0xABC;
+		nextDiv = 4;
+		break;
+	case GB_MODEL_SGB2:
+		cpu->a = 0xFF;
+		cpu->f.packed = 0x00;
+		cpu->c = 0x14;
+		cpu->e = 0x00;
+		cpu->h = 0xC0;
+		cpu->l = 0x60;
+		gb->timer.internalDiv = 0xABC;
+		nextDiv = 4;
+		break;
+	case GB_MODEL_AGB:
+		cpu->a = 0x11;
+		cpu->b = 1;
+		cpu->f.packed = 0x00;
+		cpu->c = 0;
+		cpu->e = 0x08;
+		cpu->h = 0;
+		cpu->l = 0x7C;
+		gb->timer.internalDiv = 0x1EA;
+		nextDiv = 0xC;
+		break;
+	case GB_MODEL_CGB:
+		cpu->a = 0x11;
+		cpu->f.packed = 0x80;
+		cpu->c = 0;
+		cpu->e = 0x08;
+		cpu->h = 0;
+		cpu->l = 0x7C;
+		gb->timer.internalDiv = 0x1EA;
+		nextDiv = 0xC;
+		break;
+	}
+
+	cpu->sp = 0xFFFE;
+	cpu->pc = 0x100;
+
+	mTimingDeschedule(&gb->timing, &gb->timer.event);
+	mTimingSchedule(&gb->timing, &gb->timer.event, 0);
+
+	if (gb->biosVf) {
+		GBUnmapBIOS(gb);
+	}
+}
+
+void GBUnmapBIOS(struct GB* gb) {
+	if (gb->memory.romBase < gb->memory.rom || gb->memory.romBase > &gb->memory.rom[gb->memory.romSize - 1]) {
+		free(gb->memory.romBase);
+		gb->memory.romBase = gb->memory.rom;
+	}
+}
+
 void GBDetectModel(struct GB* gb) {
 	if (gb->model != GB_MODEL_AUTODETECT) {
 		return;
@@ -677,9 +698,12 @@ GBUpdateIRQs(gb);
 }
 
 void GBHalt(struct LR35902Core* cpu) {
-	if (!cpu->irqPending) {
+	struct GB* gb = (struct GB*) cpu->master;
+	if (!(gb->memory.ie & gb->memory.io[REG_IF])) {
 		cpu->cycles = cpu->nextEvent;
 		cpu->halted = true;
+	} else if (gb->model < GB_MODEL_CGB) {
+		mLOG(GB, STUB, "Unimplemented HALT bug");
 	}
 }
 
@@ -698,7 +722,7 @@ #ifdef USE_DEBUGGERS
 		if (cpu->components && cpu->components[CPU_COMPONENT_DEBUGGER]) {
 			struct mDebuggerEntryInfo info = {
 				.address = cpu->pc - 1,
-				.opcode = 0x1000 | cpu->bus
+				.type.bp.opcode = 0x1000 | cpu->bus
 			};
 			mDebuggerEnter((struct mDebugger*) cpu->components[CPU_COMPONENT_DEBUGGER], DEBUGGER_ENTER_ILLEGAL_OP, &info);
 		}
@@ -717,7 +741,7 @@ #ifdef USE_DEBUGGERS
 	if (cpu->components && cpu->components[CPU_COMPONENT_DEBUGGER]) {
 		struct mDebuggerEntryInfo info = {
 			.address = cpu->pc,
-			.opcode = cpu->bus
+			.type.bp.opcode = cpu->bus
 		};
 		mDebuggerEnter((struct mDebugger*) cpu->components[CPU_COMPONENT_DEBUGGER], DEBUGGER_ENTER_ILLEGAL_OP, &info);
 	}