zemu 0.3.9 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3278a3fa602a14489f1bfe77bee8d51781be503fac50dba4334dd400f492b5ca
-  data.tar.gz: 0dc3644e09613e7449bbc2dd3167f4823fca647cd0b5df94b35a0d39768a8b26
+  metadata.gz: b7ab3a65fd7f45896cac4297f3715d138a1753def97266f78dd1af1b30e0f012
+  data.tar.gz: 6d33e40e95a4add449616e6793b2817d2a9c5113f7fcc6fe0f7bf075d0d9dec2
 SHA512:
-  metadata.gz: bb87eef723a62c64742f06ec85bf7f5c976103c6e5b8678b5efec665b49ea3242efe59238f1ea28808c7ef3e597471ec050cda5f0152f3c74fa900f88df294ea
-  data.tar.gz: 29de4f2e78acae5a24a443595e3b683acb3fd3a6d00ec84991c1126e3e7b07ce35078de8721347ec84926ee99fd2bd21912b1ef768fa868c0d1cc75ae966db02
+  metadata.gz: 4551b92671a66d326ec426cbfd240427d93d181ef000c47bda8505185f9ac865b51411bfc35222d097f79e810af9cb9337a50473c7ef80c5b0a63c7d98fa550f
+  data.tar.gz: aeb983650f57cbb5a7e76b6caffbf81a0ccef919133754fae2608d1a8b04708b329ae5d75e2f5606e8409808b8b456d26b776c28c0ee9a7c39f6f4c1b1ddf038

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

data/lib/zemu/debug.rb

@@ -0,0 +1,96 @@
+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)
+
+                    symbols << s
+                end
+            end
+
+            return Symbols.new(symbols)
+        end
+
+        # Contains a set of symbols.
+        # Allows for various lookup operations.
+        class Symbols
+            # Constructor.
+            def initialize(syms)
+                @syms = []
+                syms.each do |s|
+                    @syms << s
+                end
+            end
+
+            # Access all symbols with a given address.
+            def [](address)
+                at_address = []
+                @syms.each do |s|
+                    if s.address == address
+                        at_address << s
+                    end
+                end
+
+                return at_address.sort_by(&:label)
+            end
+
+            # Find a symbol with a given name.
+            def find_by_name(name)
+                @syms.each do |s|
+                    return s if s.label == name
+                end
+
+                return nil
+            end
+        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,6 +61,10 @@ 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
 
@@ -91,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
@@ -105,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.
@@ -142,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
@@ -235,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,7 +168,7 @@ module Zemu
             cycles_left = cycles
             actual_cycles = 0
 
-            serial_count = @instance.serial_delay
+            serial_count = @instance.serial_delay.to_f
 
             while ((cycles == -1) || (cycles_left > 0))
                 # Get time before execution.
@@ -124,7 +178,7 @@ module Zemu
 
                 if (serial_count >= @instance.serial_delay)
                     process_serial
-                    serial_count = 0
+                    serial_count = 0.0
                 end
 
                 cycles_done = @instance.continue(1)
@@ -185,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.
@@ -199,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/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.9
+  version: 0.5.0
 platform: ruby
 authors:
 - Jay Valentine
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-08-26 00:00:00.000000000 Z
+date: 2021-11-26 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.