zemu 0.2.2 → 0.3.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 79900374a7a271fbfc1333290b4078e8e587ebbec09034c9cde520623459fcd4
-  data.tar.gz: 6282f2f1d04cf8188d84a058100d7db55d9305c3c577104455ead68195d17adb
+  metadata.gz: 3278a3fa602a14489f1bfe77bee8d51781be503fac50dba4334dd400f492b5ca
+  data.tar.gz: 0dc3644e09613e7449bbc2dd3167f4823fca647cd0b5df94b35a0d39768a8b26
 SHA512:
-  metadata.gz: 30dcdd1f3b79b767816a23a28c34107fb91ea48a8bbff445fa90228d4c2fe83276ba4f5ffb727f881e1864edeb40cbbefe1f637cb2e07a2793c0bbbab3ecf7fb
-  data.tar.gz: cf6f4519a152b2f1372c581222a35bcd33a32934607bdeae878330216551a26f712a7837ddf5a9935389c4c6a1b2aeba600c2e0c178fc083bb5dce616542cf19
+  metadata.gz: bb87eef723a62c64742f06ec85bf7f5c976103c6e5b8678b5efec665b49ea3242efe59238f1ea28808c7ef3e597471ec050cda5f0152f3c74fa900f88df294ea
+  data.tar.gz: 29de4f2e78acae5a24a443595e3b683acb3fd3a6d00ec84991c1126e3e7b07ce35078de8721347ec84926ee99fd2bd21912b1ef768fa868c0d1cc75ae966db02

data/lib/zemu.rb

@@ -128,7 +128,7 @@ module Zemu
 
         includes_str += " -I" + autogen
 
-        command = "#{compiler} -Werror -Wno-unknown-warning-option -fPIC -shared -Wl,-undefined -Wl,dynamic_lookup #{includes_str} #{defines_str} -o #{output} #{inputs_str}"
+        command = "#{compiler} -O2 -Werror -Wno-unknown-warning-option -fPIC -shared -Wl,-undefined -Wl,dynamic_lookup #{includes_str} #{defines_str} -o #{output} #{inputs_str}"
         
         # Run the compiler and generate a library.
         return system(command)

data/lib/zemu/config.rb

@@ -228,6 +228,10 @@ module Zemu
                 end
 
                 @ports = []
+                @setup_block = nil
+                @read_block = nil
+                @write_block = nil
+                @clock_block = nil
 
                 super
             end
@@ -269,28 +273,46 @@ module Zemu
                 @write_block = block
             end
 
+            # Defines the per-cycle behaviour of this IO device.
+            #
+            # Expects a block, the return value of which is a string
+            # defining the behaviour of the IO device on each system clock cycle.
+            # Care must be taken to ensure that this functionality does not conflict with that of
+            # any other IO devices.
+            #
+            # The block will be instance-evaluated at build-time, so it is possible to use
+            # instance variables of the IO device.
+            def when_clock(&block)
+                @clock_block = block
+            end
+
             # Evaluates the when_setup block of this IO device and returns the resulting string.
             def setup
-                instance_eval(&@setup_block)
+                return instance_eval(&@setup_block) unless @setup_block.nil?
+                return ""
             end
 
             # Evaluates the when_read block of this IO device and returns the resulting string.
             def read
-                instance_eval(&@read_block)
+                return instance_eval(&@read_block) unless @read_block.nil?
+                return ""
             end
 
             # Evaluates the when_write block of this IO device and returns the resulting string.
             def write
-                instance_eval(&@write_block)
+                return instance_eval(&@write_block) unless @write_block.nil?
+                return ""
+            end
+
+            # Evaluates the when_clock block of this IO device and returns the resulting string.
+            def clock
+                return instance_eval(&@clock_block) unless @clock_block.nil?
+                return ""
             end
 
             # Defines FFI API which will be available to the instance wrapper if this IO device is used.
             def functions
-                [
-                    {"name" => "zemu_io_#{name}_master_puts".to_sym, "args" => [:uint8], "return" => :void},
-                    {"name" => "zemu_io_#{name}_master_gets".to_sym, "args" => [], "return" => :uint8},
-                    {"name" => "zemu_io_#{name}_buffer_size".to_sym, "args" => [], "return" => :uint64}
-                ]
+                []
             end
 
             # Valid parameters for this object.
@@ -401,6 +423,15 @@ module Zemu
                 end
             end
 
+            # Defines FFI API which will be available to the instance wrapper if this IO device is used.
+            def functions
+                [
+                    {"name" => "zemu_io_#{name}_master_puts".to_sym, "args" => [:uint8], "return" => :void},
+                    {"name" => "zemu_io_#{name}_master_gets".to_sym, "args" => [], "return" => :uint8},
+                    {"name" => "zemu_io_#{name}_buffer_size".to_sym, "args" => [], "return" => :uint64}
+                ]
+            end
+
             # Valid parameters for a SerialPort, along with those
             # defined in [Zemu::Config::IOPort].
             def params
@@ -408,6 +439,44 @@ module Zemu
             end
         end
 
+        # Non-Maskable Interrupt Timer
+        #
+        # Represents a timer device, the period of which can be controlled
+        # by the CPU through an IO port. The timer generates an NMI once this
+        # period has expired. The timer can be reset via a control port.
+        class Timer < IOPort
+            def initialize
+                super
+
+                when_setup do
+                    "zuint8 io_#{name}_count;\n" +
+                    "zuint8 io_#{name}_running = 0;\n"
+                end
+
+                when_read do
+                end
+
+                when_write do
+                    "if (port == #{count_port}) io_#{name}_count = value;\n" +
+                    "else if (port == #{control_port}) io_#{name}_running = value;\n"
+                end
+
+                when_clock do
+                    "if (io_#{name}_running)\n" +
+                    "{\n" +
+                    "    if (io_#{name}_count > 0) io_#{name}_count--;\n" +
+                    "    else zemu_io_nmi(instance);\n" +
+                    "}\n"
+                end
+            end
+
+            # Valid parameters for a Timer, along with those defined in
+            # [Zemu::Config::IOPort].
+            def params
+                super + %w(count_port control_port)
+            end
+        end
+
         # Gets a binding for this object.
         def get_binding
             return binding
@@ -421,7 +490,7 @@ module Zemu
 
         # Parameters accessible by this configuration object.
         def params
-            return %w(name compiler output_directory clock_speed)
+            return %w(name compiler output_directory clock_speed serial_delay)
         end
 
         # Initial value for parameters of this configuration object.
@@ -429,7 +498,8 @@ module Zemu
             return {
                 "compiler" => "clang",
                 "output_directory" => "bin",
-                "clock_speed" => 0
+                "clock_speed" => 0,
+                "serial_delay" => 0
             }
         end
 

data/lib/zemu/instance.rb

@@ -37,8 +37,24 @@ module Zemu
             "L'" => 19
         }
 
+        # States that the emulated machine can be in.
+        class RunState
+            # Currently executing an instruction.
+            RUNNING = 0
+
+            # Executed a HALT instruction in the previous cycle.
+            HALTED = 1
+
+            # Hit a breakpoint in the previous cycle.
+            BREAK = 2
+
+            # Undefined. Emulated machine has not yet reached a well-defined state.
+            UNDEFINED = -1
+        end
+
         def initialize(configuration)
             @clock = configuration.clock_speed
+            @serial_delay = configuration.serial_delay
 
             @wrapper = make_wrapper(configuration)
 
@@ -47,6 +63,10 @@ module Zemu
             @instance = @wrapper.zemu_init
             @wrapper.zemu_power_on(@instance)
             @wrapper.zemu_reset(@instance)
+
+            @state = RunState::UNDEFINED
+
+            @breakpoints = {}
         end
 
         # Returns the clock speed of this instance in Hz.
@@ -54,6 +74,11 @@ module Zemu
             return @clock
         end
 
+        # Returns the delay between characters on the serial port for this instance in seconds.
+        def serial_delay
+            return @serial_delay
+        end
+
         # Returns a hash containing current values of the emulated
         # machine's registers. All names are as those given in the Z80
         # reference manual.
@@ -124,7 +149,32 @@ module Zemu
         #
         # Returns the number of cycles executed.
         def continue(run_cycles=-1)
-            return @wrapper.zemu_debug_continue(@instance, run_cycles)
+            # Return immediately if we're HALTED.
+            return if @state == RunState::HALTED
+
+            cycles_executed = 0
+
+            @state = RunState::RUNNING
+
+            # Run as long as:
+            #   We haven't hit a breakpoint
+            #   We haven't halted
+            #   We haven't hit the number of cycles we've been told to execute for.
+            while (run_cycles == -1 || cycles_executed < run_cycles) && (@state == RunState::RUNNING)
+                cycles_executed += @wrapper.zemu_debug_step(@instance)
+
+                pc = @wrapper.zemu_debug_pc(@instance)
+
+                # If the PC is now pointing to one of our breakpoints,
+                # we're in the BREAK state.
+                if @breakpoints[pc]
+                    @state = RunState::BREAK
+                elsif @wrapper.zemu_debug_halted()
+                    @state = RunState::HALTED
+                end
+            end
+
+            return cycles_executed
         end
 
         # Set a breakpoint of the given type at the given address.
@@ -133,17 +183,26 @@ module Zemu
         # @param type The type of breakpoint:
         #   * :program => Break when the program counter hits the address given. 
         def break(address, type)
-            @wrapper.zemu_debug_set_breakpoint(address)
+            @breakpoints[address] = true
+        end
+
+        # Remove a breakpoint of the given type at the given address.
+        # Does nothing if no breakpoint previously existed at that address.
+        #
+        # @param address The address of the breakpoint to be removed.
+        # @param type The type of breakpoint. See Instance#break.
+        def remove_break(address, type)
+            @breakpoints[address] = false
         end
 
         # Returns true if the CPU has halted, false otherwise.
         def halted?
-            return @wrapper.zemu_debug_halted
+            return @state == RunState::HALTED
         end
 
         # Returns true if a breakpoint has been hit, false otherwise.
         def break?
-            return @wrapper.zemu_debug_break
+            return @state == RunState::BREAK
         end
 
         # Powers off the emulated CPU and destroys this instance.
@@ -168,14 +227,12 @@ module Zemu
 
             wrapper.attach_function :zemu_reset, [:pointer], :void
 
-            wrapper.attach_function :zemu_debug_continue, [:pointer, :int64], :uint64
+            wrapper.attach_function :zemu_debug_step, [:pointer], :uint64
 
             wrapper.attach_function :zemu_debug_halted, [], :bool
-            wrapper.attach_function :zemu_debug_break, [], :bool
-
-            wrapper.attach_function :zemu_debug_set_breakpoint, [:uint16], :void
 
             wrapper.attach_function :zemu_debug_register, [:pointer, :uint16], :uint16
+            wrapper.attach_function :zemu_debug_pc, [:pointer], :uint16
 
             wrapper.attach_function :zemu_debug_get_memory, [:uint16], :uint8
 

data/lib/zemu/interactive.rb

@@ -114,13 +114,19 @@ module Zemu
             cycles_left = cycles
             actual_cycles = 0
 
+            serial_count = @instance.serial_delay
+
             while ((cycles == -1) || (cycles_left > 0))
                 # Get time before execution.
                 start = Time.now
 
                 old_pc = r16("PC")
 
-                process_serial
+                if (serial_count >= @instance.serial_delay)
+                    process_serial
+                    serial_count = 0
+                end
+
                 cycles_done = @instance.continue(1)
                 cycles_left -= cycles_done
                 actual_cycles += cycles_done
@@ -132,7 +138,9 @@ module Zemu
                 if @instance.clock_speed > 0
                     elapsed = ending - start
 
-                    execution_time = actual_cycles * (1/@instance.clock_speed)
+                    execution_time = cycles_done * (1.0/@instance.clock_speed)
+                    serial_count += execution_time
+                    
                     padding = execution_time - elapsed
                     sleep(padding) unless padding < 0
                 end
@@ -169,7 +177,7 @@ module Zemu
             
             (address.to_i(16)...address.to_i(16) + size.to_i(16)).each do |a|
                 m = @instance.memory(a)
-                if (m < 32)
+                if (m < 32 || m > 126)
                     log "%04x: %02x    ." % [a, m]
                 else
                     log ("%04x: %02x    " % [a, m]) + m.chr("UTF-8")

data/src/debug.c

@@ -1,69 +1,16 @@
 #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, zinteger run_cycles)
-{
-    /* Return if we've halted. */
-    if (zemu_debug_state == HALTED) return 0;
- 
-    zusize cycles = 0;
-
-    zemu_debug_state = RUNNING;
-
-    /* Run as long as:
-     * We don't hit a breakpoint
-     * We haven't run for more than the number of cycles given
-     */
-    while (zemu_debug_state == RUNNING && (run_cycles < 0 || cycles < run_cycles))
-    {
-        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;
-}
+zboolean halted = FALSE;
 
 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;
-    }
-}
+    /* Execute the per-cycle behaviour of the peripheral devices. */
+    for (zusize i = 0; i < cycles; i++) zemu_io_clock(instance);
 
-void zemu_debug_set_breakpoint(zuint16 address)
-{
-    breakpoints[breakpoint_count] = address;
-    breakpoint_count++;
+    return cycles;
 }
 
 zuint16 zemu_debug_register(Z80 * instance, zuint16 r)
@@ -106,14 +53,19 @@ zuint16 zemu_debug_register(Z80 * instance, zuint16 r)
     }
 }
 
-zboolean zemu_debug_halted(void)
+zuint16 zemu_debug_pc(Z80 * instance)
+{
+    return instance->state.pc;
+}
+
+void zemu_debug_halt(void * context, zboolean state)
 {
-    return (zemu_debug_state == HALTED);
+    halted = state;
 }
 
-zboolean zemu_debug_break(void)
+zboolean zemu_debug_halted(void)
 {
-    return (zemu_debug_state == BREAK);
+    return (halted);
 }
 
 zuint8 zemu_debug_get_memory(zuint16 address)

data/src/debug.h

@@ -3,28 +3,16 @@
 #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, zinteger run_cycles);
+#include "io.h"
 
 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);
+zboolean zemu_debug_break(void);
+zboolean zemu_debug_running(void);
 
 zuint16 zemu_debug_register(Z80 * instance, zuint16 r);
+
+zuint16 zemu_debug_pc(Z80 * instance);

data/src/io.c.erb

@@ -4,6 +4,21 @@
 <%= device.setup %>
 <% end %>
 
+void zemu_io_nmi(Z80 * instance)
+{
+    z80_nmi(instance);
+}
+
+void zemu_io_int_on(Z80 * instance)
+{
+    z80_int(instance, TRUE);
+}
+
+void zemu_io_int_off(Z80 * instance)
+{
+    z80_int(instance, FALSE);
+}
+
 zuint8 zemu_io_in(void * context, zuint16 port)
 {
     /* Z80 IO ports occupy the lower half of the address bus.
@@ -28,3 +43,10 @@ void zemu_io_out(void * context, zuint16 port, zuint8 value)
 <%= device.write %>
 <% end %>
 }
+
+void zemu_io_clock(Z80 * instance)
+{
+<% io.each do |device| %>
+<%= device.clock %>
+<% end %>
+}

data/src/io.h.erb

@@ -1,3 +1,6 @@
+#ifndef _ZEMU_IO_H
+#define _ZEMU_IO_H
+
 #include "emulation/CPU/Z80.h"
 
 #ifndef ZEMU_IO_SERIAL_BUFFER_SIZE
@@ -16,3 +19,7 @@ zusize zemu_io_serial_buffer_size(void);
 
 zuint8 zemu_io_in(void * context, zuint16 port);
 void zemu_io_out(void * context, zuint16 port, zuint8 value);
+void zemu_io_nmi(Z80 * instance);
+void zemu_io_clock(Z80 * instance);
+
+#endif

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: zemu
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.3.9
 platform: ruby
 authors:
 - Jay Valentine
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-02-29 00:00:00.000000000 Z
+date: 2020-08-26 00:00:00.000000000 Z
 dependencies: []
 description: |2
       Zemu is a gem which allows the user to configure a Z80-based system