zemu 0.4.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: caa59294431c1faadda8328bc7fbefa504526ae43a5531e2cf1d6c2bc7dd5c87
-  data.tar.gz: 72ced5e284f94e586862e80e97f5d95f55a9a3dbc931dc889fdc73352cef3a82
+  metadata.gz: 99d9e825251363ade2a565f28d7545f81b3dc93221951980a12bed3d3b8ab82c
+  data.tar.gz: c93e03bccdf934341909811d4a2d07fb58d31121cd25983b0659495a2d9b176c
 SHA512:
-  metadata.gz: dbb449fa4a076320a3073391f98687098e4e0f8b484099a7ca2c67325f857e8923397267dc01c5bee521cf66e9457149a8845e15f4a8b74ae7962e1f84623ae1
-  data.tar.gz: 846f7d09837e09fdb5711ba7d3ee09ca734cf0454c10efaff77a2d92de742e88332cc2c3e008db7026c528460368e410c9c9ebaacf29694e513880255085d579
+  metadata.gz: 0c4024d10bfd6521b25f98f8172e40163cd635d354961554406532c48f58b2063a3ac945a0378907c472db3287dff3f8643f7bfbbf256684b81a9511a15dd3e1
+  data.tar.gz: c826fa009c55c9890faa7d9ef5f172c3ec123a1912e55ff75dca57c51e377cac7014b9d07f8ea9ab682e9ae1ea718c0fae70fda42b0eb0a471fe24c2f494ef96

data/lib/zemu/config.rb

@@ -466,18 +466,9 @@ module Zemu
             #
             #
             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?
@@ -486,14 +477,6 @@ module Zemu
                     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
@@ -626,7 +609,27 @@ eos
 
             # Array of sectors of this drive.
             def blocks
-                @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.

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.
@@ -91,6 +99,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 +119,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.
@@ -245,6 +269,7 @@ 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|

data/lib/zemu/interactive.rb

@@ -5,7 +5,13 @@ 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 = {}
@@ -275,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

@@ -73,10 +73,10 @@ 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
 

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.4.0
+  version: 0.4.1
 platform: ruby
 authors:
 - Jay Valentine
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-10-23 00:00:00.000000000 Z
+date: 2021-11-18 00:00:00.000000000 Z
 dependencies: []
 description: |2
       Zemu is a gem which allows the user to configure a Z80-based system