zemu 0.3.9 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3278a3fa602a14489f1bfe77bee8d51781be503fac50dba4334dd400f492b5ca
-  data.tar.gz: 0dc3644e09613e7449bbc2dd3167f4823fca647cd0b5df94b35a0d39768a8b26
+  metadata.gz: caa59294431c1faadda8328bc7fbefa504526ae43a5531e2cf1d6c2bc7dd5c87
+  data.tar.gz: 72ced5e284f94e586862e80e97f5d95f55a9a3dbc931dc889fdc73352cef3a82
 SHA512:
-  metadata.gz: bb87eef723a62c64742f06ec85bf7f5c976103c6e5b8678b5efec665b49ea3242efe59238f1ea28808c7ef3e597471ec050cda5f0152f3c74fa900f88df294ea
-  data.tar.gz: 29de4f2e78acae5a24a443595e3b683acb3fd3a6d00ec84991c1126e3e7b07ce35078de8721347ec84926ee99fd2bd21912b1ef768fa868c0d1cc75ae966db02
+  metadata.gz: dbb449fa4a076320a3073391f98687098e4e0f8b484099a7ca2c67325f857e8923397267dc01c5bee521cf66e9457149a8845e15f4a8b74ae7962e1f84623ae1
+  data.tar.gz: 846f7d09837e09fdb5711ba7d3ee09ca734cf0454c10efaff77a2d92de742e88332cc2c3e008db7026c528460368e410c9c9ebaacf29694e513880255085d579

data/lib/zemu/config.rb

@@ -439,6 +439,215 @@ 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
+                @blocks = []
+                @initialize_from = nil
+
+                super
+
+                num_sectors.times do
+                    sector = []
+                    sector_size.times do
+                        sector << 0
+                    end
+                    @blocks << sector
+                end
+                
+                # 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
+
+                    File.open(@initialize_from, "rb") do |f|
+                        num_sectors.times do |s|
+                            sector_size.times do |b|
+                                @blocks[s][b] = f.getbyte()
+                            end
+                        end
+                    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
+                @blocks
+            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,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

@@ -142,6 +142,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
@@ -238,7 +248,7 @@ module Zemu
 
             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"])
                 end
             end
 

data/lib/zemu/interactive.rb

@@ -8,6 +8,8 @@ module Zemu
         def initialize(instance)
             @instance = instance
 
+            @symbol_table = {}
+
             @master, @slave = PTY.open
             log "Opened PTY at #{@slave.path}"
         end
@@ -59,6 +61,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 +71,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 +85,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 +144,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 +162,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 +172,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 +233,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.

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.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: zemu
 version: !ruby/object:Gem::Version
-  version: 0.3.9
+  version: 0.4.0
 platform: ruby
 authors:
 - Jay Valentine
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-08-26 00:00:00.000000000 Z
+date: 2021-10-23 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.