zemu 0.1.0

data/src/debug.c

@@ -0,0 +1,118 @@
+#include "debug.h"
+
+RunState zemu_debug_state = UNDEFINED;
+
+/* Currently, the number of breakpoints is defined statically.
+ * Perhaps in future there will be an unlimited number.
+ */
+zuint16 breakpoints[ZEMU_DEBUG_MAX_BREAKPOINTS];
+unsigned int breakpoint_count = 0;
+
+zusize zemu_debug_continue(Z80 * instance)
+{
+    /* Return if we've halted. */
+    if (zemu_debug_state == HALTED) return 0;
+ 
+    zusize cycles = 0;
+
+    zemu_debug_state = RUNNING;
+
+    while (zemu_debug_state == RUNNING)
+    {
+        cycles += zemu_debug_step(instance);
+
+        /* See if the Program Counter now matches any address
+         * in the breakpoint array.
+         */
+        for (unsigned int b = 0; b < breakpoint_count; b++)
+        {
+            if (instance->state.pc == breakpoints[b])
+            {
+                zemu_debug_state = BREAK;
+            }
+        }
+    }
+
+    return cycles;
+}
+
+zusize zemu_debug_step(Z80 * instance)
+{
+    /* Will run for at least one cycle. */
+    zusize cycles = z80_run(instance, 1);
+
+    return cycles;
+}
+
+void zemu_debug_halt(void * context, zboolean state)
+{
+    if (state)
+    {
+        zemu_debug_state = HALTED;
+    }
+    else
+    {
+        zemu_debug_state = RUNNING;
+    }
+}
+
+void zemu_debug_set_breakpoint(zuint16 address)
+{
+    breakpoints[breakpoint_count] = address;
+    breakpoint_count++;
+}
+
+zuint16 zemu_debug_register(Z80 * instance, zuint16 r)
+{
+    switch (r)
+    {
+        /* Special purpose registers. */
+        case 0:     return instance->state.pc;
+        case 1:     return instance->state.sp;
+        case 2:     return instance->state.iy.value_uint16;
+        case 3:     return instance->state.ix.value_uint16;
+
+        /* Main register set, 8-bit format. */
+        case 4:     return instance->state.af.values_uint8.index1;
+        case 5:     return instance->state.af.values_uint8.index0;
+
+        case 6:     return instance->state.bc.values_uint8.index1;
+        case 7:     return instance->state.bc.values_uint8.index0;
+
+        case 8:     return instance->state.de.values_uint8.index1;
+        case 9:     return instance->state.de.values_uint8.index0;
+
+        case 10:    return instance->state.hl.values_uint8.index1;
+        case 11:    return instance->state.hl.values_uint8.index0;
+
+        /* Alternate register set, 8-bit format. */
+        case 12:    return instance->state.af_.values_uint8.index1;
+        case 13:    return instance->state.af_.values_uint8.index0;
+
+        case 14:    return instance->state.bc_.values_uint8.index1;
+        case 15:    return instance->state.bc_.values_uint8.index0;
+
+        case 16:    return instance->state.de_.values_uint8.index1;
+        case 17:    return instance->state.de_.values_uint8.index0;
+
+        case 18:    return instance->state.hl_.values_uint8.index1;
+        case 19:    return instance->state.hl_.values_uint8.index0;
+
+        default:    return 0xFFFF;
+    }
+}
+
+zboolean zemu_debug_halted(void)
+{
+    return (zemu_debug_state == HALTED);
+}
+
+zboolean zemu_debug_break(void)
+{
+    return (zemu_debug_state == BREAK);
+}
+
+zuint8 zemu_debug_get_memory(zuint16 address)
+{
+    return zemu_memory_peek(address);
+}

data/src/debug.h

@@ -0,0 +1,30 @@
+#include "emulation/CPU/Z80.h"
+
+#include <stdio.h>
+
+#include "memory.h"
+
+/* Define number of breakpoints, if not done so already. */
+#ifndef ZEMU_DEBUG_MAX_BREAKPOINTS
+#define ZEMU_DEBUG_MAX_BREAKPOINTS 256
+#endif
+
+typedef enum RunState
+{
+    RUNNING,
+    HALTED,
+    BREAK,
+    UNDEFINED
+} RunState;
+
+zusize zemu_debug_continue(Z80 * instance);
+
+zusize zemu_debug_step(Z80 * instance);
+
+void zemu_debug_halt(void * context, zboolean state);
+
+zboolean zemu_debug_halted(void);
+
+void zemu_debug_set_breakpoint(zuint16 address);
+
+zuint16 zemu_debug_register(Z80 * instance, zuint16 r);

data/src/external/Z/API/Z/ABIs/generic/allocator.h

@@ -0,0 +1,36 @@
+/* Z Kit - ABIs/generic/allocator.h
+ _____  _______________
+/_   /_/  -_/_   _/  _ |
+ /____/\___/ /__//___/_| Kit
+Copyright (C) 2006-2018 Manuel Sainz de Baranda y Goñi.
+Released under the terms of the GNU Lesser General Public License v3. */
+
+#ifndef _Z_ABIs_generic_allocator_H_
+#define _Z_ABIs_generic_allocator_H_
+
+#include <Z/types/base.h>
+
+typedef void* (* ZAllocate)	(void*	context,
+				 zusize size,
+				 zusize alignment);
+
+typedef void* (* ZAllocateClean)(void*	context,
+				 zusize size,
+				 zusize alignment);
+
+typedef void* (* ZReallocate)	(void*	context,
+				 void*	block,
+				 zusize new_size,
+				 zusize alignment);
+
+typedef void  (* ZDeallocate)	(void*	context,
+				 void*	block);
+
+typedef struct {
+	ZAllocate      allocate;
+	ZAllocateClean allocate_clean;
+	ZReallocate    reallocate;
+	ZDeallocate    deallocate;
+} ZAllocatorABI;
+
+#endif /* _Z_ABIs_generic_allocator_H_ */

data/src/external/Z/API/Z/ABIs/generic/cipher.h

@@ -0,0 +1,47 @@
+/* Z Kit - ABIs/generic/cipher.h
+ _____  _______________
+/_   /_/  -_/_   _/  _ |
+ /____/\___/ /__//___/_| Kit
+Copyright (C) 2006-2018 Manuel Sainz de Baranda y Goñi.
+Released under the terms of the GNU Lesser General Public License v3. */
+
+#ifndef _Z_ABIs_generic_cipher_H_
+#define _Z_ABIs_generic_cipher_H_
+
+#include <Z/types/base.h>
+
+#define Z_CIPHER_FEATURE_SEQUENTIAL 1
+
+typedef ZStatus (* ZCipherTestKey)   (void const* key,
+				      zusize	  key_size);
+
+typedef void	(* ZCipherSetKey)    (void*	  context,
+				      void const* key,
+				      zusize	  key_size);
+
+typedef void	(* ZCipherProcess)   (void*	  context,
+				      void const* block,
+				      zusize	  block_size,
+				      void*	  output);
+
+typedef zusize	(* ZCipherOutputSize)(void*	  context,
+				      void const* block,
+				      zusize	  block_size);
+
+typedef struct {
+	ZCipherTestKey	  test_key;
+	ZCipherSetKey	  set_key;
+	ZCipherProcess	  encipher;
+	ZCipherProcess	  decipher;
+	ZCipherOutputSize enciphering_size;
+	ZCipherOutputSize deciphering_size;
+	zusize		  instance_size;
+	zusize		  key_minimum_size;
+	zusize		  key_maximum_size;
+	zusize		  key_word_size;
+	zusize		  enciphering_word_size;
+	zusize		  deciphering_word_size;
+	zuint8		  features;
+} ZCipherABI;
+
+#endif /* _Z_ABIs_generic_cipher_H_ */

data/src/external/Z/API/Z/ABIs/generic/data codec.h

@@ -0,0 +1,33 @@
+/* Z Kit - ABIs/generic/data codec.h
+ _____  _______________
+/_   /_/  -_/_   _/  _ |
+ /____/\___/ /__//___/_| Kit
+Copyright (C) 2006-2018 Manuel Sainz de Baranda y Goñi.
+Released under the terms of the GNU Lesser General Public License v3. */
+
+#ifndef _Z_ABIs_generic_data_codec_H_
+#define _Z_ABIs_generic_data_codec_H_
+
+#include <Z/types/base.h>
+
+typedef zusize	(* ZDataCodecProcess)	(void const* block,
+					 zusize	     block_size,
+					 void*	     output);
+
+typedef zusize	(* ZDataCodecOutputSize)(void const* block,
+					 zusize	     block_size);
+
+typedef ZStatus (* ZDataCodecValidate)	(void const* block,
+					 zusize	     block_size,
+					 zusize*     error_offset);
+
+typedef struct {
+	ZDataCodecProcess    encode;
+	ZDataCodecProcess    decode;
+	ZDataCodecOutputSize encoding_size;
+	ZDataCodecOutputSize decoding_size;
+	ZDataCodecValidate   validate_encoding;
+	zboolean	     sequential;
+} ZDataCodecABI;
+
+#endif /* _Z_ABIs_generic_data_codec_H_ */

data/src/external/Z/API/Z/ABIs/generic/emulation.h

@@ -0,0 +1,103 @@
+/* Z Kit - ABIs/generic/emulation.h
+ _____  _______________
+/_   /_/  -_/_   _/  _ |
+ /____/\___/ /__//___/_| Kit
+Copyright (C) 2006-2018 Manuel Sainz de Baranda y Goñi.
+Released under the terms of the GNU Lesser General Public License v3. */
+
+#ifndef _Z_ABIs_generic_emulation_H_
+#define _Z_ABIs_generic_emulation_H_
+
+#include <Z/types/base.h>
+#include <Z/macros/key.h>
+
+#define Z_EMULATOR_FUNCTION_POWER		0
+#define Z_EMULATOR_FUNCTION_RESET		1
+#define Z_EMULATOR_FUNCTION_RUN			2
+#define Z_EMULATOR_FUNCTION_RUN_ONE_SCANLINE
+#define Z_EMULATOR_FUNCTION_RUN_ONE_FRAME
+#define Z_EMULATOR_FUNCTION_WILL_READ_STATE	3
+#define Z_EMULATOR_FUNCTION_DID_WRITE_STATE	4
+#define Z_EMULATOR_FUNCTION_HALT		8
+#define Z_EMULATOR_FUNCTION_NMI			4
+#define Z_EMULATOR_FUNCTION_IRQ			5
+#define Z_EMULATOR_FUNCTION_IRQ_DATA		9
+#define Z_EMULATOR_FUNCTION_READ_8BIT		6
+#define Z_EMULATOR_FUNCTION_READ_16BIT
+#define Z_EMULATOR_FUNCTION_READ_32BIT
+#define Z_EMULATOR_FUNCTION_READ_64BIT
+#define Z_EMULATOR_FUNCTION_READ_128BIT
+#define Z_EMULATOR_FUNCTION_READ_256BIT
+#define Z_EMULATOR_FUNCTION_READ_512BIT
+#define Z_EMULATOR_FUNCTION_READ_1024BIT
+#define Z_EMULATOR_FUNCTION_WRITE_8BIT		20
+#define Z_EMULATOR_FUNCTION_WRITE_16BIT
+#define Z_EMULATOR_FUNCTION_WRITE_32BIT
+#define Z_EMULATOR_FUNCTION_WRITE_64BIT
+#define Z_EMULATOR_FUNCTION_WRITE_128BIT
+#define Z_EMULATOR_FUNCTION_WRITE_256BIT
+#define Z_EMULATOR_FUNCTION_WRITE_512BIT
+#define Z_EMULATOR_FUNCTION_WRITE_1024BIT
+#define Z_EMULATOR_FUNCTION_IN_8BIT		30
+#define Z_EMULATOR_FUNCTION_IN_16BIT
+#define Z_EMULATOR_FUNCTION_IN_32BIT
+#define Z_EMULATOR_FUNCTION_IN_64BIT
+#define Z_EMULATOR_FUNCTION_IN_128BIT
+#define Z_EMULATOR_FUNCTION_IN_256BIT
+#define Z_EMULATOR_FUNCTION_IN_512BIT
+#define Z_EMULATOR_FUNCTION_IN_1024BIT
+#define Z_EMULATOR_FUNCTION_OUT_8BIT		40
+#define Z_EMULATOR_FUNCTION_OUT_16BIT
+#define Z_EMULATOR_FUNCTION_OUT_32BIT
+#define Z_EMULATOR_FUNCTION_OUT_64BIT
+#define Z_EMULATOR_FUNCTION_OUT_128BIT
+#define Z_EMULATOR_FUNCTION_OUT_256BIT
+#define Z_EMULATOR_FUNCTION_OUT_512BIT
+#define Z_EMULATOR_FUNCTION_OUT_1024BIT
+
+#define Z_KEY_BITS_EMULATOR_FUNCTION 8
+
+typedef void   (* ZEmulatorPower	)(void* object, zboolean state );
+typedef zusize (* ZEmulatorRun		)(void* object, zusize   cycles);
+typedef void   (* ZEmulatorWillReadState)(void* object);
+typedef void   (* ZEmulatorDidWriteState)(void* object);
+
+typedef struct {
+	zuintptr id;
+
+	struct {zusize cycles;
+		/* ... */
+	} context;
+} ZEmulatorComponent;
+
+Z_DEFINE_STRICT_STRUCTURE (
+	zchar const* domain_identifier;
+	zchar const* unit_identifier;
+) ZEmulatorDependency;
+
+Z_DEFINE_STRICT_STRUCTURE (
+	ZKey(EMULATOR_FUNCTION) key;
+	ZPointer		component;
+) ZEmulatorExport;
+
+Z_DEFINE_STRICT_STRUCTURE (
+	ZKey(EMULATOR_FUNCTION) key;
+	zusize			offset;
+) ZEmulatorInstanceImport;
+
+typedef ZEmulatorExport		ZCPUEmulatorExport;
+typedef ZEmulatorInstanceImport ZCPUEmulatorInstanceImport;
+
+Z_DEFINE_STRICT_STRUCTURE (
+	zusize			       dependency_count;
+	ZEmulatorDependency const*     dependencies;
+	zusize			       export_count;
+	ZEmulatorExport const*	       exports;
+	zusize			       instance_size;
+	zusize			       instance_state_offset;
+	zusize			       instance_state_size;
+	zusize			       instance_import_count;
+	ZEmulatorInstanceImport const* instance_imports;
+) ZCPUEmulatorABI;
+
+#endif /* _Z_ABIs_generic_emulation_H_ */

data/src/external/Z/API/Z/ABIs/generic/hash function.h

@@ -0,0 +1,33 @@
+/* Z Kit - ABIs/generic/hash function.h
+ _____  _______________
+/_   /_/  -_/_   _/  _ |
+ /____/\___/ /__//___/_| Kit
+Copyright (C) 2006-2018 Manuel Sainz de Baranda y Goñi.
+Released under the terms of the GNU Lesser General Public License v3. */
+
+#ifndef _Z_ABIs_generic_hash_function_H_
+#define _Z_ABIs_generic_hash_function_H_
+
+#include <Z/types/base.h>
+
+void  (* ZHashFunctionInitialize)(void*	      context);
+
+void  (* ZHashFunctionUpdate)	 (void*	      context,
+				  void*	      block,
+				  zusize      block_size);
+
+void  (* ZHashFunctionFinalize)	 (void*	      context);
+
+void* (* ZHashFunctionResult)	 (void const* context,
+				  zusize*     result_size);
+
+typedef struct {
+	ZHashFunctionInitialize initialize;
+	ZHashFunctionUpdate	update;
+	ZHashFunctionFinalize	finalize;
+	ZHashFunctionResult	result;
+	zusize			context_size;
+	zusize			result_size;
+} ZHashFunctionABI;
+
+#endif /* _Z_ABIs_generic_hash_function_H_ */

data/src/external/Z/API/Z/ABIs/generic/module.h

@@ -0,0 +1,33 @@
+/* Z Kit - ABIs/generic/module.h
+ _____  _______________
+/_   /_/  -_/_   _/  _ |
+ /____/\___/ /__//___/_| Kit
+Copyright (C) 2006-2018 Manuel Sainz de Baranda y Goñi.
+Released under the terms of the GNU Lesser General Public License v3. */
+
+#ifndef _Z_ABIs_generic_module_H_
+#define _Z_ABIs_generic_module_H_
+
+#include <Z/types/base.h>
+#include <Z/macros/version.h>
+
+typedef struct {
+	zchar const* identifier;
+	zchar const* name;
+	zuint64	     version;
+	void const*  abi;
+} ZModuleUnit;
+
+typedef struct {
+	zchar const*	   identifier;
+	zuint64		   abi_version;
+	zusize		   unit_count;
+	ZModuleUnit const* units;
+} ZModuleDomain;
+
+typedef struct {
+	zusize		     domain_count;
+	ZModuleDomain const* domains;
+} ZModuleABI;
+
+#endif /* _Z_ABIs_generic_module_H_ */

data/src/external/Z/API/Z/ABIs/generic/wave codec.h

@@ -0,0 +1,40 @@
+/* Z Kit - ABIs/generic/wave codec.h
+ _____  _______________
+/_   /_/  -_/_   _/  _ |
+ /____/\___/ /__//___/_| Kit
+Copyright (C) 2006-2018 Manuel Sainz de Baranda y Goñi.
+Released under the terms of the GNU Lesser General Public License v3. */
+
+#ifndef _Z_ABIs_generic_wave_codec_H_
+#define _Z_ABIs_generic_wave_codec_H_
+
+#include <Z/types/base.h>
+#include <Z/macros/key.h>
+#include <Z/keys/value.h>
+
+#define Z_WAVE_CODEC_STATE_CAN_DISCARD_INPUT
+#define Z_WAVE_CODEC_STATE_CAN_DISCARD_OUTPUT
+
+#define Z_KEY_BITS_WAVE_CODEC_STATE 8
+#define Z_KEY_LAST_WAVE_CODEC_STATE Z_WAVE_CODEC_STATE_CAN_DISCARD_OUTPUT
+
+typedef struct {
+	void*		       input;
+	void*		       output;
+	zuint32		       resolution;
+	zuint16		       channel_count;
+	ZKey(VALUE_TYPE)       sample_fixed_type;
+	ZKey(WAVE_CODEC_STATE) state;
+	ZStatus		       status;
+} ZWaveCodecSC;
+
+typedef zusize (* ZWaveCodecProcess)(ZWaveCodecSC *sc, zusize sample_count);
+
+typedef struct {
+	ZWaveCodecProcess encode;
+	ZWaveCodecProcess decode;
+	zusize		  encoding_context_size;
+	zusize		  decoding_context_size;
+} ZWaveCodecABI;
+
+#endif /* _Z_ABIs_generic_wave_codec_H_ */

data/src/external/Z/API/Z/classes/base/InitializerList.hpp

@@ -0,0 +1,34 @@
+/* Z Kit - classes/base/InitializerList.hpp
+ _____  _______________
+/_   /_/  -_/_   _/  _ |
+ /____/\___/ /__//___/_| Kit
+Copyright (C) 2006-2018 Manuel Sainz de Baranda y Goñi.
+Released under the terms of the GNU Lesser General Public License v3. */
+
+#ifndef _Z_classes_base_InitializerList_HPP_
+#define _Z_classes_base_InitializerList_HPP_
+
+#include <Z/types/base.hpp>
+
+
+namespace Zeta {template <class T> class InitializerList {
+
+	private:
+	const T* _begin;
+	USize	 _size;
+
+	public:
+
+	Z_INLINE InitializerList()
+	: _begin(NULL), _size(0) {}
+
+	Z_INLINE InitializerList(const T *begin, USize size)
+	: _begin(begin), _size(size) {}
+
+	Z_INLINE USize	  size () const {return _size;}
+	Z_INLINE const T *begin() const {return _begin;}
+	Z_INLINE const T *end  () const {return _begin + _size;}
+};}
+
+
+#endif // _Z_classes_base_InitializerList_HPP_

data/src/external/Z/API/Z/classes/base/OpaqueFunctionPointer.hpp

@@ -0,0 +1,26 @@
+/* Z Kit - classes/base/OpaqueFunctionPointer.hpp
+ _____  _______________
+/_   /_/  -_/_   _/  _ |
+ /____/\___/ /__//___/_| Kit
+Copyright (C) 2006-2018 Manuel Sainz de Baranda y Goñi.
+Released under the terms of the GNU Lesser General Public License v3. */
+
+#ifndef _Z_classes_base_OpaqueFunctionPointer_HPP_
+#define _Z_classes_base_OpaqueFunctionPointer_HPP_
+
+#include <Z/macros/language.hpp>
+
+
+namespace Zeta {struct OpaqueFunctionPointer {
+	void (* function)();
+
+	template <class T>
+	Z_INLINE OpaqueFunctionPointer(T function)
+	: function((void (*)())function) {}
+
+	template <class T>
+	Z_INLINE operator T() const {return (T)function;}
+};}
+
+
+#endif // _Z_classes_base_OpaqueFunctionPointer_HPP_

data/src/external/Z/API/Z/classes/base/OpaqueMemberFunctionPointer.hpp

@@ -0,0 +1,26 @@
+/* Z Kit - classes/base/OpaqueMemberFunctionPointer.hpp
+ _____  _______________
+/_   /_/  -_/_   _/  _ |
+ /____/\___/ /__//___/_| Kit
+Copyright (C) 2006-2018 Manuel Sainz de Baranda y Goñi.
+Released under the terms of the GNU Lesser General Public License v3. */
+
+#ifndef _Z_classes_base_OpaqueMemberFunctionPointer_HPP_
+#define _Z_classes_base_OpaqueMemberFunctionPointer_HPP_
+
+#include <Z/types/base.hpp>
+
+
+namespace Zeta {struct OpaqueMemberFunctionPointer {
+	void (NaT::* function)();
+
+	template <class M>
+	Z_INLINE OpaqueMemberFunctionPointer(M function)
+	: function((void (NaT::*)())function) {}
+
+	template <class M>
+	Z_INLINE operator M() const {return (M)function;}
+};}
+
+
+#endif // _Z_classes_base_OpaqueMemberFunctionPointer_HPP_

data/src/external/Z/API/Z/classes/base/Pair.hpp

@@ -0,0 +1,46 @@
+/* Z Kit - classes/base/Pair.hpp
+ _____  _______________
+/_   /_/  -_/_   _/  _ |
+ /____/\___/ /__//___/_| Kit
+Copyright (C) 2006-2018 Manuel Sainz de Baranda y Goñi.
+Released under the terms of the GNU Lesser General Public License v3. */
+
+#ifndef _Z_classes_base_Pair_HPP_
+#define _Z_classes_base_Pair_HPP_
+
+#include <Z/functions/base/value.hpp>
+
+
+namespace Zeta {template <class T1, class T2> struct Pair {
+	typedef T1 First;
+	typedef T2 Second;
+
+	T1 first;
+	T2 second;
+
+	Z_INLINE Pair() Z_DEFAULTED({})
+
+	Z_CT(CPP11) Pair(
+		typename Type<T1>::to_forwardable first,
+		typename Type<T2>::to_forwardable second
+	) : first(first), second(second) {}
+
+
+	Z_CT(CPP11) Boolean operator ==(const Pair &pair) const
+		{return first == pair.first && second == pair.second;}
+
+
+	Z_CT(CPP11) Boolean operator !=(const Pair &pair) const
+		{return first != pair.first || second != pair.second;}
+
+
+	Z_INLINE void swap(Pair &pair)
+		{
+		Zeta::swap<typename Type<Pair>::to_opaque>
+			((typename Type<Pair>::to_opaque *)this,
+			 (typename Type<Pair>::to_opaque *)&pair);
+		}
+};}
+
+
+#endif // _Z_classes_base_Pair_HPP_