zemu 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 31940c64874b7aaeb203199df84fc7cdb7cedc8736728e147e2fda5557675d83
-  data.tar.gz: 7a236b15b5075d866aaedaa2793b535e5c1bf7e3fb279c4a7b3702f93ec6e719
+  metadata.gz: 8e57309f08bc232fd44db53f5961029283fdffaaf0e01c9e8e2ea36807987b33
+  data.tar.gz: 493c60567914e637c50244dc16f9d4ba47d8eea7ed1b3c8abce442fa142264bf
 SHA512:
-  metadata.gz: bd05cbd8eb7a42df7afa9f4c62957e138dcdef1b02c4c458ffdecf8156f64972664eaf2d54d48741d198dc9ee8b0a5f97352c1fcd7c8a4fa6736da50626a60fd
-  data.tar.gz: ac3fdb4305fc84ae7766db21351321c9c4e7c3041c3a6549e9c416be03666ac4f56d8275248ae707429941f34a2077596aadf8e9fee45290300f20f7fe4baf7f
+  metadata.gz: 4746e81b7cc05441d12fe45c284955a4aae66a8877be77168a110bb08aada6f0bd6e1cf7ca5d1085e0a059d1d4e1d0ed8288f1aae72d159b0cb699342f021005
+  data.tar.gz: 667278d74f889f7d555807d548715fa110d6a8b9d0dd0aacd77c37806517218e7058b42c61bc6d744c063fd7869c490a12674308fbc401face274209320d6b91

data/lib/zemu/config.rb

@@ -1,3 +1,5 @@
+require 'ostruct'
+
 module Zemu
     # Abstract configuration object.
     # All configuration objects should inherit from this.
@@ -89,10 +91,17 @@ module Zemu
                 end
 
                 @nmi = false
+                @interrupt = false
 
                 super
             end
 
+            # Parameters used for generating C code to
+            # implement this bus device.
+            def memory
+                nil
+            end
+
             # Setup to be performed on initialising the emulator
             # instance.
             def when_setup
@@ -147,7 +156,7 @@ module Zemu
             # Deriving objects can use the nmi function
             # to set the state of the non-maskable interrupt
             # at each clock cycle.
-            def clock
+            def clock(cycles)
             end
 
             # FFI functions provided by this device.
@@ -165,6 +174,16 @@ module Zemu
                 @nmi
             end
 
+            # Sets state of INT for this device.
+            def interrupt(state)
+                @interrupt = state
+            end
+
+            # Gets state of INT for this device.
+            def interrupt?
+                @interrupt
+            end
+
             # Parameters for a bus device.
             def params
                 %w(name)
@@ -208,6 +227,32 @@ module Zemu
                 false
             end
 
+            # Parameters used for generating C code to
+            # implement this memory block.
+            def memory
+                contents_initializer = ""
+                @contents.each_slice(32) do |c|
+                    contents_initializer += c.map { |b| b.to_s }.join(", ")
+                    contents_initializer += ",\n"
+                end
+
+                m = OpenStruct.new
+
+                m.setup = <<eos
+zuint8 memory_#{name}[#{size}] =
+{
+    #{contents_initializer}
+};
+eos
+
+                m.address = address
+                m.size = size
+                m.access_read = "memory_#{name}"
+                m.access_write = "memory_#{name}"
+
+                m
+            end
+
             # Memory bus read handler.
             #
             # Handles read access via the memory bus to this device.
@@ -217,15 +262,6 @@ module Zemu
             # Returns the value read, or nil if no value
             # (e.g. if address falls outside range for this device).
             def mem_read(addr)
-                # Return value in memory's contents if the address
-                # falls within range.
-                if (addr >= address) && (addr < (address + size))
-                    offset = addr - address
-                    return @contents[offset]
-                end
-
-                # Otherwise return nil - address does not correspond
-                # to this memory block.
                 nil
             end
 
@@ -236,12 +272,6 @@ module Zemu
             # @param addr The address being accessed.
             # @param value The value being written.
             def mem_write(addr, value)
-                # If address falls within range, set value in
-                # memory contents.
-                if (addr >= address) && (addr < (address + size))
-                    offset = addr - address
-                    @contents[offset] = value
-                end
             end
 
             # Valid parameters for this object.
@@ -673,10 +703,10 @@ module Zemu
             #
             # Handles a clock cycle for this device.
             # Sets NMI active if the count reaches 0.
-            def clock
+            def clock(cycles)
                 if @running == RUNNING
                     if @count > 0
-                        @count -= 1
+                        @count -= cycles
                     else
                         nmi(true)
                     end

data/lib/zemu/instance.rb

@@ -2,6 +2,17 @@ require 'ffi'
 require 'ostruct'
 
 module Zemu
+    # Exception raised when an error occurs in a Zemu::Instance.
+    class InstanceError < StandardError
+        # Constructor.
+        #
+        # @param msg    The exception message
+        #
+        def initialize(msg="An error occurred with the Zemu::Instance")
+            super
+        end
+    end
+
     # Represents an instance of a Zemu emulator.
     #
     # Provides methods by which the state of the emulator can be observed
@@ -60,8 +71,6 @@ module Zemu
             UNDEFINED = -1
         end
 
-        
-
         def initialize(configuration)
             @devices = configuration.devices
 
@@ -93,6 +102,7 @@ module Zemu
                     v = d.mem_read(addr)
                     unless v.nil?
                         r = v
+                        break
                     end
                 end
 
@@ -113,6 +123,7 @@ module Zemu
                     v = d.io_read(port)
                     unless v.nil?
                         r = v
+                        break
                     end
                 end
 
@@ -120,9 +131,9 @@ module Zemu
             end
 
             # IO read handler.
-            @io_clock = Proc.new do
+            @io_clock = Proc.new do |cycles|
                 @devices.each do |d|
-                    d.clock()
+                    d.clock(cycles)
                 end
 
                 bus_state = 0
@@ -131,6 +142,10 @@ module Zemu
                     bus_state |= 1
                 end
 
+                if @devices.any? { |d| d.interrupt? }
+                    bus_state |= 2
+                end
+
                 bus_state
             end
 
@@ -147,6 +162,7 @@ module Zemu
             @state = RunState::UNDEFINED
 
             @breakpoints = {}
+            @tracepoints = {}
         end
 
         # Returns the device with the given name, or nil
@@ -221,7 +237,7 @@ module Zemu
         # emulated machine.
         def serial_puts(string)
             string.each_char do |c|
-                @wrapper.zemu_io_serial_master_puts(c.ord)
+                device('serial').put_byte(c.ord)
             end
         end
 
@@ -237,14 +253,14 @@ module Zemu
         def serial_gets(count=nil)
             return_string = ""
 
-            actual_count = @wrapper.zemu_io_serial_buffer_size()
+            actual_count = device('serial').transmitted_count()
 
             if count.nil? || actual_count < count
                 count = actual_count
             end
 
             count.to_i.times do
-                return_string += @wrapper.zemu_io_serial_master_gets().chr
+                return_string += device('serial').get_byte().chr
             end
 
             return return_string
@@ -283,6 +299,12 @@ module Zemu
 
                 pc = @wrapper.zemu_debug_pc(@instance)
 
+                # If there's a tracepoint at this address,
+                # execute the associated proc.
+                unless @tracepoints[pc].nil?
+                    @tracepoints[pc].call(self)
+                end
+
                 # If the PC is now pointing to one of our breakpoints,
                 # we're in the BREAK state.
                 if @breakpoints[pc]
@@ -304,6 +326,26 @@ module Zemu
             @breakpoints[address] = true
         end
 
+        # Set a tracepoint to execute the given block at an address.
+        #
+        # @param address The address of the tracepoint
+        # @param block   The block to execute at the tracepoint.
+        #                The block takes the instance as a parameter.
+        #
+        # @example
+        #     instance.trace(0x1234) do |i|
+        #         puts "HL value: 04x" % i.registers["HL"]
+        #     end
+        #
+        def trace(address, &block)
+            if block.arity != 1
+                raise InstanceError,
+                      "Wrong arity for tracepoint - expected 1, got #{block.arity}"
+            end
+            
+            @tracepoints[address] = block
+        end
+
         # Remove a breakpoint of the given type at the given address.
         # Does nothing if no breakpoint previously existed at that address.
         #
@@ -343,7 +385,7 @@ module Zemu
 
             wrapper.callback :io_write_handler, [:uint8, :uint8], :void
             wrapper.callback :io_read_handler, [:uint8], :uint8
-            wrapper.callback :io_clock_handler, [:void], :uint8
+            wrapper.callback :io_clock_handler, [:uint64], :uint8
 
             wrapper.attach_function :zemu_set_mem_write_handler, [:mem_write_handler], :void
             wrapper.attach_function :zemu_set_mem_read_handler, [:mem_read_handler], :void

data/lib/zemu/interactive.rb

@@ -183,9 +183,6 @@ module Zemu
             serial_count = @instance.serial_delay.to_f
 
             while ((cycles == -1) || (cycles_left > 0))
-                # Get time before execution.
-                start = Time.now
-
                 old_pc = r16("PC")
 
                 if (serial_count >= @instance.serial_delay)
@@ -197,26 +194,10 @@ module Zemu
                 cycles_left -= cycles_done
                 actual_cycles += cycles_done
 
-                @trace << r16("PC")
-                @trace = @trace[1..] if @trace.size > 200
-
-                # Get time after execution.
-                ending = Time.now
-
                 # Get elapsed time and calculate padding time to match clock speed.
                 if @instance.clock_speed > 0
-                    elapsed = ending - start
-
                     execution_time = cycles_done * (1.0/@instance.clock_speed)
                     serial_count += execution_time
-                    
-                    padding = execution_time - elapsed
-                    sleep(padding) unless padding < 0
-                end
-
-                if (@instance.memory(0x200) != 0xf3)
-                    log "Buffer overflow at #{r16("PC")}"
-                    break
                 end
 
                 # Have we hit a breakpoint or HALT instruction?

data/src/bus.c.erb

@@ -7,6 +7,11 @@ io_write_handler_t * io_write_handler;
 io_read_handler_t * io_read_handler;
 io_clock_handler_t * io_clock_handler;
 
+<% devices.each do |d| %>
+<% next if d.memory.nil? %>
+<%= d.memory.setup %>
+<% end %>
+
 void zemu_set_mem_write_handler(mem_write_handler_t * h)
 {
     mem_write_handler = h;
@@ -34,25 +39,37 @@ void zemu_set_io_clock_handler(io_clock_handler_t * h)
 
 zuint8 zemu_memory_read(void * context, zuint16 address)
 {
-    zuint32 address_32 = address;
-    return mem_read_handler(address_32);
+    return zemu_memory_peek(address);
 }
 
 void zemu_memory_write(void * context, zuint16 address, zuint8 value)
 {
-    zuint32 address_32 = address;
-    mem_write_handler(address_32, value);
+    zemu_memory_poke(address, value);
 }
 
 zuint8 zemu_memory_peek(zuint16 address)
 {
     zuint32 address_32 = address;
+
+    <% devices.each do |d| %>
+    <% next if d.memory.nil? %>
+    if ((address_32 >= <%= d.memory.address %>) && (address_32 < <%= d.memory.address + d.memory.size%>))
+        return <%= d.memory.access_read %>[address_32 - <%= d.memory.address %>];
+    <% end %>
+
     return mem_read_handler(address_32);
 }
 
 void zemu_memory_poke(zuint16 address, zuint8 value)
 {
     zuint32 address_32 = address;
+    
+    <% devices.each do |d| %>
+    <% next if d.memory.nil? %>
+    if ((address_32 >= <%= d.memory.address %>) && (address_32 < <%= d.memory.address + d.memory.size%>))
+        <%= d.memory.access_write %>[address_32 - <%= d.memory.address %>] = value;
+    <% end %>
+
     mem_write_handler(address_32, value);
 }
 
@@ -91,9 +108,12 @@ void zemu_io_out(void * context, zuint16 port, zuint8 value)
     io_write_handler((zuint8)port, value);
 }
 
-void zemu_io_clock(Z80 * instance)
+void zemu_io_clock(Z80 * instance, zusize cycles)
 {
-    zuint8 bus_state = io_clock_handler();
+    zuint8 bus_state = io_clock_handler(cycles);
 
     if (bus_state & 0x01) zemu_io_nmi(instance);
+    
+    if (bus_state & 0x02) zemu_io_int_on(instance);
+    else                  zemu_io_int_off(instance);
 }

data/src/bus.h.erb

@@ -26,7 +26,7 @@ typedef void io_write_handler_t(zuint8, zuint8);
 typedef zuint8 io_read_handler_t(zuint8);
 
 /* Type of a function to handle a clock cycle for a peripheral. */
-typedef zuint8 io_clock_handler_t(void);
+typedef zuint8 io_clock_handler_t(zusize);
 
 void zemu_set_mem_write_handler(mem_write_handler_t * h);
 void zemu_set_mem_read_handler(mem_read_handler_t * h);
@@ -48,6 +48,6 @@ 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);
+void zemu_io_clock(Z80 * instance, zusize cycles);
 
 #endif

data/src/debug.c

@@ -8,7 +8,7 @@ zusize zemu_debug_step(Z80 * instance)
     zusize cycles = z80_run(instance, 1);
 
     /* Execute the per-cycle behaviour of the peripheral devices. */
-    for (zusize i = 0; i < cycles; i++) zemu_io_clock(instance);
+    zemu_io_clock(instance, cycles);
 
     return cycles;
 }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: zemu
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Jay Valentine
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-12-30 00:00:00.000000000 Z
+date: 2022-01-30 00:00:00.000000000 Z
 dependencies: []
 description: |2
       Zemu is a gem which allows the user to configure a Z80-based system