zemu 0.3.3 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0be58ea6333733b1c2b6467ecc9e0ec1ebebc16cd1e3ba5f6b34454d22941313
-  data.tar.gz: 373889194e89aec21f878ef44dfe28b5432b9893d311532e83c460904bd1e292
+  metadata.gz: 0542a6b70d68a1ea2de55fb02802f487ec2ff06f00d824d8113dd8d0b40da40b
+  data.tar.gz: d806954f2a981777e57b2dcd3d8e1ba4946ce62c6ef440d63ceb2993ab1cd82c
 SHA512:
-  metadata.gz: ccb11a107eb8aa7f39634ecdfd0d1765583655c1c33c0d87c3ae01f9b6634ffc965e2234b8fe3460b2f8de3b8848a0387488bd401d588a47e69967b87afda864
-  data.tar.gz: 6d727da2887d8bf9d3e94f376d8659b29f03d3bb32865a2b66f3c61772bbeb300a347994c4341b494ed50649f0fe8cddf51d6c4b991c34b0955313d67907e932
+  metadata.gz: 45a3ca398596119e345dd6b146c571c7f635f5067b2ea58ecc9a2ebb6808ea3c60db327dbb0027c7d75ee1a73a79f41dc334cc9eea0e4bd7b3d634752c5047af
+  data.tar.gz: b580177e4823c0ecb5b54268c3820f32345560a8199054dc8754f855554ef74d38f15895d337a43fc3b7d6363e5e5ed148d479b6106db9673904765736693611

data/lib/zemu/config.rb

@@ -439,6 +439,218 @@ module Zemu
             end
         end
 
+        # Block drive object
+        #
+        # Represents a device with a sequence of sectors of a fixed size,
+        # which can be accessed via IO instructions as an IDE drive.
+        class BlockDrive < IOPort
+            # Constructor.
+            #
+            # Takes a block in which the parameters of the block drive
+            # can be initialized.
+            #
+            # All parameters can be set within this block.
+            # They become readonly as soon as the block completes.
+            #
+            # Constructor raises RangeError if a file is provided for initialization
+            # and it is of the wrong size.
+            #
+            # @example
+            #   
+            #   Zemu::Config::BlockDrive.new do
+            #       name "drive"
+            #       base_port 0x0c
+            #       sector_size 512
+            #       num_sectors 64
+            #   end
+            #
+            #
+            def initialize
+                @initialize_from = nil
+
+                super
+                
+                # Initialize from provided file if applicable.
+                unless @initialize_from.nil?
+                    # Check file size.
+                    file_size = File.size(@initialize_from)
+                    if (file_size != num_sectors * sector_size)
+                        raise RangeError, "Initialization file for Zemu::Config::BlockDrive '#{name}' is of wrong size."
+                    end
+                end
+
+                when_setup do
+<<-eos
+#include <stdio.h>
+
+zuint8 sector_data_#{name}[#{sector_size}];
+zuint32 sector_data_#{name}_offset;
+zuint32 loaded_sector_#{name} = Z_UINT32_MAXIMUM;
+zuint8 drive_mode_#{name};
+zuint8 drive_status_#{name} = 0b01000000;
+
+zuint8 lba_#{name}_0;
+zuint8 lba_#{name}_1;
+zuint8 lba_#{name}_2;
+zuint8 lba_#{name}_3;
+
+void internal_#{name}_load_sector(zuint32 sector)
+{
+    if (loaded_sector_#{name} == sector) return;
+
+    FILE * fptr = fopen("#{@initialize_from}", "rb");
+    fseek(fptr, sector * #{sector_size}, SEEK_SET);
+    fread(sector_data_#{name}, #{sector_size}, 1, fptr);
+    fclose(fptr);
+
+    loaded_sector_#{name} = sector;
+}
+
+void internal_#{name}_write_current_sector()
+{
+    FILE * fptr = fopen("#{@initialize_from}", "r+b");
+    fseek(fptr, loaded_sector_#{name} * #{sector_size}, SEEK_SET);
+    fwrite(sector_data_#{name}, 1, #{sector_size}, fptr);
+    fclose(fptr);
+}
+
+zuint8 zemu_io_#{name}_readbyte(zuint32 sector, zuint32 offset)
+{
+    internal_#{name}_load_sector(sector);
+    return sector_data_#{name}[offset];
+}
+eos
+                end
+
+                when_read do
+<<-eos
+if (port == #{base_port})
+{
+    zuint8 b = sector_data_#{name}[sector_data_#{name}_offset];
+    sector_data_#{name}_offset++;
+    if (sector_data_#{name}_offset >= #{sector_size})
+    {
+        drive_status_#{name} = 0b01000000;
+    }
+    return b;
+}
+else if (port == #{base_port+7})
+{
+    return drive_status_#{name};
+}
+eos
+                end
+
+                when_write do
+<<-eos
+if (port == #{base_port})
+{
+    if (drive_mode_#{name} == 0x01)
+    {
+        sector_data_#{name}[sector_data_#{name}_offset] = value;
+        sector_data_#{name}_offset++;
+        if (sector_data_#{name}_offset >= #{sector_size})
+        {
+            internal_#{name}_write_current_sector();
+            drive_status_#{name} = 0b01000000;
+        }
+    }
+}
+else if (port == #{base_port+3})
+{
+    lba_#{name}_0 = value;
+}
+else if (port == #{base_port+4})
+{
+    lba_#{name}_1 = value;
+}
+else if (port == #{base_port+5})
+{
+    lba_#{name}_2 = value;
+}
+else if (port == #{base_port+6})
+{
+    lba_#{name}_3 = value & 0b00011111;
+}
+else if (port == #{base_port+7})
+{
+    if (value == 0x20)
+    {
+        zuint32 sector = 0;
+        sector |= (zuint32)lba_#{name}_3 << 24;
+        sector |= (zuint32)lba_#{name}_2 << 16;
+        sector |= (zuint32)lba_#{name}_1 << 8;
+        sector |= (zuint32)lba_#{name}_0;
+
+        internal_#{name}_load_sector(sector);
+        sector_data_#{name}_offset = 0;
+
+        drive_mode_#{name} = 0x00;
+        drive_status_#{name} = 0b00001000;
+    }
+    else if (value == 0x30)
+    {
+        zuint32 sector = 0;
+        sector |= (zuint32)lba_#{name}_3 << 24;
+        sector |= (zuint32)lba_#{name}_2 << 16;
+        sector |= (zuint32)lba_#{name}_1 << 8;
+        sector |= (zuint32)lba_#{name}_0;
+
+        internal_#{name}_load_sector(sector);
+        sector_data_#{name}_offset = 0;
+
+        drive_mode_#{name} = 0x01;
+        drive_status_#{name} = 0b00001000;
+    }
+}
+eos
+                end
+            end
+
+            # Array of sectors of this drive.
+            def blocks
+                b = []
+                
+                if @initialize_from.nil?
+                    num_sectors.times do
+                        this_block = []
+                        sector_size.times do
+                            this_block << 0
+                        end
+                        b << this_block
+                    end
+                    return b
+                end
+                
+                File.open(@initialize_from, "rb") do |f|
+                    num_sectors.times do
+                        this_block = f.read(sector_size)
+                        b << this_block.unpack("C" * sector_size)
+                    end
+                end
+
+                b
+            end
+
+            # Set file to initialize from.
+            def initialize_from(file)
+                @initialize_from = file
+            end
+
+            # Defines FFI API which will be available to the instance wrapper if this IO device is used.
+            def functions
+                [
+                    {"name" => "zemu_io_#{name}_readbyte", "args" => [:uint32, :uint32], "return" => :uint8},
+                ]
+            end
+
+            # Valid parameters for a BlockDrive, along with those
+            # defined in [Zemu::Config::IOPort].
+            def params
+                super + %w(base_port sector_size num_sectors)
+            end
+        end
+
         # Non-Maskable Interrupt Timer
         #
         # Represents a timer device, the period of which can be controlled
@@ -490,7 +702,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.
@@ -498,7 +710,8 @@ module Zemu
             return {
                 "compiler" => "clang",
                 "output_directory" => "bin",
-                "clock_speed" => 0
+                "clock_speed" => 0,
+                "serial_delay" => 0
             }
         end
 

data/lib/zemu/debug.rb

@@ -0,0 +1,68 @@
+module Zemu
+    # Handles debugging functionality, like mapping of symbols to addresses,
+    # disassembling of instructions, etc.
+    module Debug
+        # Loads a map file at the given path, and returns a hash of address => Symbol
+        # for the symbols defined within.
+        def self.load_map(path)
+            symbols = {}
+
+            File.open(path, "r") do |f|
+                f.each_line do |l|
+                    s = Symbol.parse(l)
+
+                    if symbols[s.address].nil?
+                        symbols[s.address] = []
+                    end
+
+                    symbols[s.address] << s
+                    symbols[s.address].sort_by!(&:label)
+                end
+            end
+
+            return symbols
+        end
+        
+        # Represents a symbol definition, of the form `label = address`.
+        class Symbol
+            # Parse a symbol definition, returning a Symbol instance.
+            def self.parse(s)
+                # Split on whitespace.
+                tokens = s.to_s.split(' ')
+
+                if tokens.size < 3
+                    raise ArgumentError, "Invalid symbol definition: '#{s}'"
+                end
+
+                label = tokens[0]
+
+                address = nil
+
+                if /0x[0-9a-fA-F]+/ =~ tokens[2]
+                    address = tokens[2][2..-1].to_i(16)
+                elsif /\$[0-9a-fA-F]+/ =~ tokens[2]
+                    address = tokens[2][1..-1].to_i(16)
+                elsif /\d+/ =~ tokens[2]
+                    address = tokens[2].to_i
+                end
+
+                if address.nil?
+                    raise ArgumentError, "Invalid symbol address: '#{tokens[2]}'"
+                end
+
+                return self.new(label, address)
+            end
+
+            # Textual label for this symbol.
+            attr_reader :label
+
+            # Address of this symbol in the binary.
+            attr_reader :address
+
+            def initialize(label, address)
+                @label = label
+                @address = address
+            end
+        end
+    end
+end

data/lib/zemu/instance.rb

@@ -37,6 +37,14 @@ module Zemu
             "L'" => 19
         }
 
+        # Mapping of extended registers
+        # to the registers that comprise them.
+        REGISTERS_EXTENDED = {
+            "HL" => ["H", "L"],
+            "BC" => ["B", "C"],
+            "DE" => ["D", "E"]
+        }
+
         # States that the emulated machine can be in.
         class RunState
             # Currently executing an instruction.
@@ -53,7 +61,12 @@ module Zemu
         end
 
         def initialize(configuration)
+            # Methods defined by IO devices that we make
+            # accessible to the user.
+            @io_methods = []
+
             @clock = configuration.clock_speed
+            @serial_delay = configuration.serial_delay
 
             @wrapper = make_wrapper(configuration)
 
@@ -73,6 +86,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.
@@ -85,6 +103,12 @@ module Zemu
             REGISTERS.each do |reg, num|
                 r[reg] = @wrapper.zemu_debug_register(@instance, num)
             end
+
+            REGISTERS_EXTENDED.each do |reg, components|
+                hi = components[0]
+                lo = components[1]
+                r[reg] = (r[hi] << 8) | r[lo]
+            end
             
             return r
         end
@@ -99,6 +123,16 @@ module Zemu
             return @wrapper.zemu_debug_get_memory(address)
         end
 
+        # Set the value in memory at a given address.
+        #
+        # @param address The address in memory to be set.
+        # @param value The value to set to.
+        #
+        # Returns nothing.
+        def set_memory(address, value)
+            @wrapper.zemu_debug_set_memory(address, value)
+        end
+
         # Write a string to the serial line of the emulated CPU.
         #
         # @param string The string to be sent.
@@ -136,6 +170,16 @@ module Zemu
             return return_string
         end
 
+        # Get a byte from the attached disk drive.
+        #
+        # @param sector The sector to read
+        # @param offset The offset in sector to read
+        #
+        # Gets a byte at the given offset in the given sector.
+        def drive_readbyte(sector, offset)
+            return @wrapper.zemu_io_block_drive_readbyte(sector, offset)
+        end
+
         # Continue running this instance until either:
         # * A HALT instruction is executed
         # * A breakpoint is hit
@@ -229,16 +273,27 @@ module Zemu
             wrapper.attach_function :zemu_debug_pc, [:pointer], :uint16
 
             wrapper.attach_function :zemu_debug_get_memory, [:uint16], :uint8
+            wrapper.attach_function :zemu_debug_set_memory, [:uint16, :uint8], :void
 
             configuration.io.each do |device|
                 device.functions.each do |f|
-                    wrapper.attach_function(f["name"], f["args"], f["return"])
+                    wrapper.attach_function(f["name"].to_sym, f["args"], f["return"])
+                    @io_methods << f["name"].to_sym
                 end
             end
 
             return wrapper
         end
 
+        # Redirects calls to I/O FFI functions.
+        def method_missing(method, *args)
+            if @io_methods.include? method
+                return @wrapper.send(method)
+            end
+
+            super
+        end
+
         private :make_wrapper
     end
 end

data/lib/zemu/interactive.rb

@@ -5,9 +5,17 @@ module Zemu
         # Constructor.
         #
         # Create a new interactive wrapper for the given instance.
-        def initialize(instance)
+        # The options hash allows the user to configure the behaviour
+        # of the interactive instance:
+        #     :print_serial => true if serial input/output should be logged
+        #                      to the emulator window.
+        def initialize(instance, options = {})
+            @print_serial = options[:print_serial]
+
             @instance = instance
 
+            @symbol_table = {}
+
             @master, @slave = PTY.open
             log "Opened PTY at #{@slave.path}"
         end
@@ -59,6 +67,9 @@ module Zemu
                         memory(cmd[1], cmd[2])
                     end
 
+                elsif cmd[0] == "map"
+                    load_map(cmd[1])
+
                 elsif cmd[0] == "help"
                     log "Available commands:"
                     log "    continue [<n>]     - Continue execution for <n> cycles"
@@ -66,6 +77,7 @@ module Zemu
                     log "    registers          - View register contents"
                     log "    memory <a> [<n>]   - View <n> bytes of memory, starting at address <a>."
                     log "                         <n> defaults to 1 if omitted."
+                    log "    map <path>         - Load symbols from map file at <path>"
                     log "    break  <a>         - Set a breakpoint at the given address <a>."
                     log "    quit               - End this emulator instance."
 
@@ -79,16 +91,53 @@ module Zemu
         end
 
         # Outputs a table giving the current values of the instance's registers.
+        # For the 16-bit registers (BC, DE, HL, IX, IY, SP, PC), attempts to identify the symbol
+        # to which they point.
         def registers
             log "A:  #{r("A")} F: #{r("F")}"
-            log "B:  #{r("B")} C: #{r("C")}"
-            log "D:  #{r("D")} E: #{r("E")}"
-            log "H:  #{r("H")} L: #{r("L")}"
+
+            registers_gp('B', 'C')
+            registers_gp('D', 'E')
+            registers_gp('H', 'L')
+
             log ""
-            log "IX: #{r16("IX")}"
-            log "IY: #{r16("IY")}"
-            log "SP: #{r16("SP")}"
-            log "PC: #{r16("PC")}"
+
+            register_16("IX")
+            register_16("IY")
+            register_16("SP")
+            register_16("PC")
+        end
+
+        # Displays the value of a 16-bit register.
+        def register_16(r)
+            value = @instance.registers[r]
+
+            log "#{r}: #{r16(r)} (#{get_symbol(value)})"
+        end
+
+        # Displays the value of a general-purpose 16-bit register pair.
+        def registers_gp(hi, lo)
+            value = hilo(@instance.registers[hi], @instance.registers[lo])
+
+            log "#{hi}:  #{r(hi)} #{lo}: #{r(lo)} (#{get_symbol(value)})"
+        end
+
+        # Gets the symbol associated with the given value.
+        # If no matching symbol, gives offset from previous symbol.
+        def get_symbol(value)
+            syms = nil
+            addr = value
+            while addr > 0 do
+                syms = @symbol_table[addr]
+                break unless syms.nil?
+                addr -= 1
+            end
+
+            sym = if syms.nil? then nil else syms[0] end
+
+            sym_str = "<#{if sym.nil? then 'undefined' else sym.label end}#{if addr == value then '' else "+#{value-addr}" end}>"
+
+            return sym_str
         end
 
         # Returns a particular 8-bit register value.
@@ -101,6 +150,11 @@ module Zemu
             return "0x%04x" % @instance.registers[reg]
         end
 
+        # Concatenates two 8-bit values, in big-endian format.
+        def hilo(hi, lo)
+            return (hi << 8) | lo
+        end
+
         # Continue for *up to* the given number of cycles.
         # Fewer cycles may be executed, depending on the behaviour of the processor.
         def continue(cycles=-1)
@@ -114,13 +168,19 @@ module Zemu
             cycles_left = cycles
             actual_cycles = 0
 
+            serial_count = @instance.serial_delay.to_f
+
             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.0
+                end
+
                 cycles_done = @instance.continue(1)
                 cycles_left -= cycles_done
                 actual_cycles += cycles_done
@@ -132,7 +192,9 @@ module Zemu
                 if @instance.clock_speed > 0
                     elapsed = ending - start
 
-                    execution_time = cycles_done * (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
@@ -177,6 +239,34 @@ module Zemu
             end
         end
 
+        # Loads a MAP file from the given path.
+        def load_map(path)
+            if path.nil?
+                log "No path specified."
+                return
+            end
+
+            unless File.exist?(path.to_s)
+                log "Map file '#{path}' does not exist."
+                return
+            end
+
+            if File.directory?(path.to_s)
+                log "Cannot open '#{path}': it is a directory."
+                return
+            end
+
+            syms = {}
+            begin
+                syms.merge! Debug.load_map(path.to_s)
+            rescue ArgumentError => e
+                log "Error loading map file: #{e.message}"
+                syms.clear
+            end
+
+            @symbol_table.merge! syms
+        end
+
         # Process serial input/output via the TTY.
         def process_serial
             # Read/write serial.
@@ -191,12 +281,12 @@ module Zemu
 
             unless input.empty?
                 @instance.serial_puts input
-                log "Serial in: #{input}"
+                log "Serial in: #{input} ($#{input.ord.to_s(16)})" if @print_serial
             end
 
             unless output.empty?
                 @master.write output
-                log "Serial out: #{output}"
+                log "Serial out: #{output} ($#{output.ord.to_s(16)})" if @print_serial
             end
         end
     end

data/lib/zemu.rb

@@ -5,6 +5,7 @@ require 'pty'
 require_relative 'zemu/config'
 require_relative 'zemu/instance'
 require_relative 'zemu/interactive'
+require_relative 'zemu/debug'
 
 # Zemu is a module providing an interface to build and interact with
 # configurable Z80 emulators.
@@ -61,10 +62,12 @@ module Zemu
     SRC = File.join(__dir__, "..", "src")
 
     # Build and start an emulator according to the given configuration.
+    # Returns the emulator instance.
     #
     # @param [Zemu::Config] configuration The configuration for which an emulator will be generated.
-    def Zemu::start(configuration)
-        build(configuration)
+    # @param user_defines Any user-defined preprocessor macros.
+    def Zemu::start(configuration, user_defines={})
+        build(configuration, user_defines)
 
         return Instance.new(configuration)
     end
@@ -72,19 +75,19 @@ module Zemu
     # Starts an interactive instance of an emulator, according to the given configuration.
     #
     # @param [Zemu::Config] configuration The configuration for which an emulator will be generated.
-    def Zemu::start_interactive(configuration)
+    def Zemu::start_interactive(configuration, options = {})
         instance = start(configuration)
 
-        interactive = InteractiveInstance.new(instance)
+        interactive = InteractiveInstance.new(instance, options)
         interactive.run
     end
 
     # Builds a library according to the given configuration.
+    # Returns true if the build is a success, false (build failed) or nil (compiler not found) otherwise.
     #
     # @param [Zemu::Config] configuration The configuration for which an emulator will be generated.
-    #
-    # @returns true if the build is a success, false (build failed) or nil (compiler not found) otherwise.
-    def Zemu::build(configuration)
+    # @param user_defines Any user-defined preprocessor macros.
+    def Zemu::build(configuration, user_defines={})
         # Create the output directory unless it already exists.
         unless Dir.exist? configuration.output_directory
             Dir.mkdir configuration.output_directory
@@ -115,6 +118,8 @@ module Zemu
             "CPU_Z80_USE_LOCAL_HEADER" => 1
         }
 
+        defines.merge! user_defines
+
         defines_str = defines.map { |d, v| "-D#{d}=#{v}" }.join(" ")
 
         includes = [

data/src/debug.c

@@ -72,3 +72,8 @@ zuint8 zemu_debug_get_memory(zuint16 address)
 {
     return zemu_memory_peek(address);
 }
+
+void zemu_debug_set_memory(zuint16 address, zuint8 value)
+{
+    zemu_memory_poke(address, value);
+}

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.
@@ -29,11 +44,6 @@ void zemu_io_out(void * context, zuint16 port, zuint8 value)
 <% end %>
 }
 
-void zemu_io_nmi(Z80 * instance)
-{
-    z80_nmi(instance);
-}
-
 void zemu_io_clock(Z80 * instance)
 {
 <% io.each do |device| %>

data/src/memory.c.erb

@@ -9,10 +9,11 @@
 
 zuint8 zemu_memory_read(void * context, zuint16 address)
 {
+    zuint32 address_32 = address;
 <% memory.each do |mem| %>
-    if (address >= 0x<%= mem.address.to_s(16) %> && address < 0x<%= (mem.address + mem.size).to_s(16) %>)
+    if (address_32 >= 0x<%= mem.address.to_s(16) %> && address_32 < 0x<%= (mem.address + mem.size).to_s(16) %>)
     {
-        return zemu_memory_block_<%= mem.name %>[address - 0x<%= mem.address.to_s(16) %>];
+        return zemu_memory_block_<%= mem.name %>[address_32 - 0x<%= mem.address.to_s(16) %>];
     }
 <% end %>
     /* Unmapped memory has a value of 0. */
@@ -21,23 +22,38 @@ zuint8 zemu_memory_read(void * context, zuint16 address)
 
 void zemu_memory_write(void * context, zuint16 address, zuint8 value)
 {
+    zuint32 address_32 = address;
 <% memory.each do |mem| %>
     <% next if mem.readonly? %>
-    if (address >= 0x<%= mem.address.to_s(16) %> && address < 0x<%= (mem.address + mem.size).to_s(16) %>)
+    if (address_32 >= 0x<%= mem.address.to_s(16) %> && address_32 < 0x<%= (mem.address + mem.size).to_s(16) %>)
     {
-        zemu_memory_block_<%= mem.name %>[address - 0x<%= mem.address.to_s(16) %>] = value;
+        zemu_memory_block_<%= mem.name %>[address_32 - 0x<%= mem.address.to_s(16) %>] = value;
     }
 <% end %>
 }
 
 zuint8 zemu_memory_peek(zuint16 address)
 {
+    zuint32 address_32 = address;
 <% memory.each do |mem| %>
-    if (address >= 0x<%= mem.address.to_s(16) %> && address < 0x<%= (mem.address + mem.size).to_s(16) %>)
+    if (address_32 >= 0x<%= mem.address.to_s(16) %> && address_32 < 0x<%= (mem.address + mem.size).to_s(16) %>)
     {
-        return zemu_memory_block_<%= mem.name %>[address - 0x<%= mem.address.to_s(16) %>];
+        return zemu_memory_block_<%= mem.name %>[address_32 - 0x<%= mem.address.to_s(16) %>];
     }
 <% end %>
     /* Unmapped memory has a value of 0. */
     return 0;
 }
+
+void zemu_memory_poke(zuint16 address, zuint8 value)
+{
+    zuint32 address_32 = address;
+<% memory.each do |mem| %>
+    <% next if mem.readonly? %>
+    if (address_32 >= 0x<%= mem.address.to_s(16) %> && address_32 < 0x<%= (mem.address + mem.size).to_s(16) %>)
+    {
+        zemu_memory_block_<%= mem.name %>[address_32 - 0x<%= mem.address.to_s(16) %>] = value;
+        return;
+    }
+<% end %>
+}

data/src/memory.h.erb

@@ -7,3 +7,5 @@ zuint8 zemu_memory_read(void * context, zuint16 address);
 void zemu_memory_write(void * context, zuint16 address, zuint8 value);
 
 zuint8 zemu_memory_peek(zuint16 address);
+
+void zemu_memory_poke(zuint16 address, zuint8 value);

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: zemu
 version: !ruby/object:Gem::Version
-  version: 0.3.3
+  version: 0.4.2
 platform: ruby
 authors:
 - Jay Valentine
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-03-30 00:00:00.000000000 Z
+date: 2021-11-19 00:00:00.000000000 Z
 dependencies: []
 description: |2
       Zemu is a gem which allows the user to configure a Z80-based system
@@ -29,6 +29,7 @@ extra_rdoc_files: []
 files:
 - lib/zemu.rb
 - lib/zemu/config.rb
+- lib/zemu/debug.rb
 - lib/zemu/instance.rb
 - lib/zemu/interactive.rb
 - src/debug.c
@@ -333,8 +334,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: A configurable Z80 emulator.