zemu 0.4.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: caa59294431c1faadda8328bc7fbefa504526ae43a5531e2cf1d6c2bc7dd5c87
-  data.tar.gz: 72ced5e284f94e586862e80e97f5d95f55a9a3dbc931dc889fdc73352cef3a82
+  metadata.gz: 62fdf5d376fa7ea32170f7f2ae62af17f3e96f8714313af513aabf86ef56fc71
+  data.tar.gz: 3adcc264bc22f519fff6bb0604051058b198ef3a200c3c5b118f1de1796d84ce
 SHA512:
-  metadata.gz: dbb449fa4a076320a3073391f98687098e4e0f8b484099a7ca2c67325f857e8923397267dc01c5bee521cf66e9457149a8845e15f4a8b74ae7962e1f84623ae1
-  data.tar.gz: 846f7d09837e09fdb5711ba7d3ee09ca734cf0454c10efaff77a2d92de742e88332cc2c3e008db7026c528460368e410c9c9ebaacf29694e513880255085d579
+  metadata.gz: 4bd2cbaf5099cd0874a5d59b519aaf7371e0c3b537fc7c57d70cb82f9003c751362dbed28aa1d5187736932f8d498746d95d1a404f1b43ff3cee571a1248c23a
+  data.tar.gz: 9a320b4fbaddf08a24ba5ef58452ab0750d9fec1476bc8b389d43fc2b623364ab82cd037e61560828740a3e01adfa7647093eefad14d72ee5f6ec0152beb11fe

data/lib/zemu/config.rb

@@ -75,10 +75,83 @@ module Zemu
     # @param [String] compiler The path to the compiler to be used for compiling the emulator executable.
     #
     class Config < ConfigObject
+        # Bus Device.
+        #
+        # Represents a device connected to the I/O
+        # or memory buses, or both.
+        class BusDevice < ConfigObject
+            # Constructor.
+            #
+            # This object should not be constructed directly.
+            def initialize
+                if self.class == Zemu::Config::BusDevice
+                    raise NotImplementedError, "Cannot construct an instance of the abstract class Zemu::Config::BusDevice."
+                end
+
+                super
+            end
+
+            # Setup to be performed on initialising the emulator
+            # instance.
+            def when_setup
+                ""
+            end
+
+            # Memory bus write handler.
+            #
+            # Defines C code generated for handling memory
+            # writes for this device.
+            def when_mem_write
+                ""
+            end
+
+            # Memory bus read handler.
+            #
+            # Defines C code generated for handling memory
+            # reads for this device.
+            def when_mem_read
+                ""
+            end
+
+            # IO bus write handler.
+            #
+            # Defines C code generated for handling IO
+            # writes for this device.
+            def when_io_write
+                ""
+            end
+
+            # IO bus read handler.
+            #
+            # Defines C code generated for handling IO
+            # reads for this device.
+            def when_io_read
+                ""
+            end
+
+            # Clock handler.
+            #
+            # Defines C code which executes for every
+            # clock cycle.
+            def when_clock
+                ""
+            end
+
+            # FFI functions provided by this device.
+            def functions
+                []
+            end
+
+            # Parameters for a bus device.
+            def params
+                %w(name)
+            end
+        end
+
         # Memory object.
         #
         # This is an abstract class from which all other memory objects inherit.
-        class Memory < ConfigObject
+        class Memory < BusDevice
             # Constructor.
             #
             # Do not use, as this is an abstract class. Use one of the subclasses instead.
@@ -107,15 +180,50 @@ module Zemu
                 end
             end
 
-            # @return [Boolean] true if this memory section is readonly, false otherwise.
+            # Is this memory read-only?
             def readonly?
-                return false
+                false
+            end
+
+            # Defines generated C to declare this memory block.
+            def when_setup
+                init_array = []
+                contents.each_with_index do |b, i|
+                    init_array << ((i % 16 == 0) ? "\n    " : "") + ("0x%02x, " % b)
+                end
+
+<<-eos
+/* Initialization memory block "#{name}" */
+#{if self.readonly? then "const" else "" end} zuint8 zemu_memory_block_#{name}[0x#{size.to_s(16)}] =
+{#{init_array.join("")}
+};
+eos
+            end
+
+            # Defines generated C to handle reading this memory block.
+            def when_mem_read
+<<-eos
+if (address_32 >= 0x#{address.to_s(16)} && address_32 < 0x#{(address + size).to_s(16)})
+{
+    return zemu_memory_block_#{name}[address_32 - 0x#{address.to_s(16)}];
+}
+eos
+            end
+
+            # Defines generated C to handle writing to this memory block.
+            def when_mem_write
+<<-eos
+if (address_32 >= 0x#{address.to_s(16)} && address_32 < 0x#{(address + size).to_s(16)})
+{
+    zemu_memory_block_#{name}[address_32 - 0x#{address.to_s(16)}] = value;
+}
+eos
             end
 
             # Valid parameters for this object.
             # Should be extended by subclasses but NOT REPLACED.
             def params
-                return %w(name address size)
+                super + %w(address size)
             end
 
             # Reads the contents of a file in binary format and
@@ -155,8 +263,17 @@ module Zemu
                 super
             end
 
+            # Is this memory block readonly?
             def readonly?
-                return true
+                true
+            end
+
+            # Defines generated C to handle writing to this
+            # memory block. Because this block is read-only,
+            # no code is generated to handle writes.
+            def when_mem_write
+                # Cannot write to read-only memory.
+                ""
             end
         end
 
@@ -165,169 +282,13 @@ module Zemu
         # Represents a block of memory which can be read and written.
         class RAM < Memory
         end
-
-        # Input/Output Port object
-        #
-        # Represents an input/output device assigned to one or more ports.
-        #
-        # This is an abstract class and cannot be instantiated directly.
-        # The when_setup, when_read, and when_write methods can be used to define
-        # the behaviour of a subclass.
-        #
-        # @example
-        #    class MyIODevice < IOPort
-        #        # Extend the parameters of the object so we can define a port.
-        #        def params
-        #            super + "port"
-        #        end
-        #
-        #        def initialize
-        #            super
-        # 
-        #            # Define the setup for the IO device.
-        #            # This is some global C code that ends up in "io.c".
-        #            # Parameters can be used here, as the block is instance-evaluated.
-        #            when_setup do
-        #                %Q(zuint8 #{name}_value = 42;)
-        #            end
-        #
-        #            # Define the logic when reading from an IO port.
-        #            # The C variable "port" takes the value of the 8-bit port
-        #            # address being read from, and should be used to identify
-        #            # if this IO device is the one being used.
-        #            when_read do
-        #                %Q(if (port == #{port}) return #{name}_value;)
-        #            end
-        #
-        #            # Define the logic when writing to the IO port.
-        #            # Similar to #when_read, but we have access to an extra
-        #            # C variable, "value". This is the value being written
-        #            # to the IO port.
-        #            when_write do
-        #                %Q(if (port == #{port}) #{name}_value = value;)
-        #            end
-        #        end
-        #    end
-        #
-        #    # The subclass can now be declared as below:
-        #    device = MyIODevice.new do
-        #        name "myDevice"
-        #        port 11
-        #    end
-        #
-        #
-        class IOPort < ConfigObject
-            attr_reader :io_type
-
-            # Constructor.
-            #
-            # Do not use, as this is an abstract class. Use one of the subclasses instead.
-            def initialize
-                if self.class == Zemu::Config::IOPort
-                    raise NotImplementedError, "Cannot construct an instance of the abstract class Zemu::Config::IOPort."
-                end
-
-                @ports = []
-                @setup_block = nil
-                @read_block = nil
-                @write_block = nil
-                @clock_block = nil
-
-                super
-            end
-
-            # Defines the setup behaviour of this IO device.
-            #
-            # Expects a block, the return value of which is a string
-            # containing all data and function declarations required by this IO device.
-            #
-            # The block will be instance-evaluated at build-time, so it is possible to use
-            # instance variables of the IO device.
-            def when_setup(&block)
-                @setup_block = block
-            end
-
-            # Defines the read behaviour of this IO device.
-            #
-            # Expects a block, the return value of which is a string
-            # containing the behaviour of this IO device when a value is read from the IO bus.
-            # Care must be taken to ensure that this functionality does not conflict with that of
-            # any other IO devices.
-            #
-            # The block will be instance-evaluated at build-time, so it is possible to use
-            # instance variables of the IO device.
-            def when_read(&block)
-                @read_block = block
-            end
-
-            # Defines the write behaviour of this IO device.
-            #
-            # Expects a block, the return value of which is a string
-            # containing the behaviour of this IO device when a value is written to the IO bus.
-            # Care must be taken to ensure that this functionality does not conflict with that of
-            # any other IO devices.
-            #
-            # The block will be instance-evaluated at build-time, so it is possible to use
-            # instance variables of the IO device.
-            def when_write(&block)
-                @write_block = block
-            end
-
-            # Defines the per-cycle behaviour of this IO device.
-            #
-            # Expects a block, the return value of which is a string
-            # defining the behaviour of the IO device on each system clock cycle.
-            # Care must be taken to ensure that this functionality does not conflict with that of
-            # any other IO devices.
-            #
-            # The block will be instance-evaluated at build-time, so it is possible to use
-            # instance variables of the IO device.
-            def when_clock(&block)
-                @clock_block = block
-            end
-
-            # Evaluates the when_setup block of this IO device and returns the resulting string.
-            def setup
-                return instance_eval(&@setup_block) unless @setup_block.nil?
-                return ""
-            end
-
-            # Evaluates the when_read block of this IO device and returns the resulting string.
-            def read
-                return instance_eval(&@read_block) unless @read_block.nil?
-                return ""
-            end
-
-            # Evaluates the when_write block of this IO device and returns the resulting string.
-            def write
-                return instance_eval(&@write_block) unless @write_block.nil?
-                return ""
-            end
-
-            # Evaluates the when_clock block of this IO device and returns the resulting string.
-            def clock
-                return instance_eval(&@clock_block) unless @clock_block.nil?
-                return ""
-            end
-
-            # Defines FFI API which will be available to the instance wrapper if this IO device is used.
-            def functions
-                []
-            end
-
-            # Valid parameters for this object.
-            # Should be extended by subclasses but NOT REPLACED.
-            def params
-                %w(name)
-            end
-        end
         
         # Serial Input/Output object
         #
         # Represents a serial connection between the emulated CPU
         # and the host machine, with input and output mapped to Z80 I/O
         # ports.
-        class SerialPort < IOPort
+        class SerialPort < BusDevice
             # Constructor.
             #
             # Takes a block in which the parameters of the serial port
@@ -347,80 +308,84 @@ module Zemu
             #
             def initialize
                 super
+            end
 
-                when_setup do
-                    "SerialBuffer io_#{name}_buffer_master = { .head = 0, .tail = 0 };\n" +
-                    "SerialBuffer io_#{name}_buffer_slave = { .head = 0, .tail = 0 };\n" +
-                    "\n" +
-                    "zusize zemu_io_#{name}_buffer_size(void)\n" +
-                    "{\n" +
-                    "    zusize start = io_#{name}_buffer_slave.head;\n" +
-                    "    zusize end = io_#{name}_buffer_slave.tail\n;" +
-                    "    if (end < start) end += ZEMU_IO_SERIAL_BUFFER_SIZE;\n" +
-                    "    return end - start;\n" +
-                    "}\n" +
-                    "\n" +
-                    "void zemu_io_#{name}_slave_puts(zuint8 val)\n" +
-                    "{\n" +
-                    "    io_#{name}_buffer_slave.buffer[io_#{name}_buffer_slave.tail] = val;\n" +
-                    "    io_#{name}_buffer_slave.tail++;\n" +
-                    "    if (io_#{name}_buffer_slave.tail >= ZEMU_IO_SERIAL_BUFFER_SIZE)\n" +
-                    "        io_#{name}_buffer_slave.tail = 0;\n" +
-                    "}\n" +
-                    "\n" +
-                    "zuint8 zemu_io_#{name}_slave_gets(void)\n" +
-                    "{\n" +
-                    "    zuint8 val = io_#{name}_buffer_master.buffer[io_#{name}_buffer_master.head];\n" +
-                    "    io_#{name}_buffer_master.head++;\n" +
-                    "    if (io_#{name}_buffer_master.head >= ZEMU_IO_SERIAL_BUFFER_SIZE)\n" +
-                    "        io_#{name}_buffer_master.head = 0;\n" +
-                    "\n" +
-                    "    return val;\n" +
-                    "}\n" +
-                    "\n" +
-                    "void zemu_io_#{name}_master_puts(zuint8 val)\n" +
-                    "{\n" +
-                    "    io_#{name}_buffer_master.buffer[io_#{name}_buffer_master.tail] = val;\n" +
-                    "    io_#{name}_buffer_master.tail++;\n" +
-                    "    if (io_#{name}_buffer_master.tail >= ZEMU_IO_SERIAL_BUFFER_SIZE)\n" +
-                    "        io_#{name}_buffer_master.tail = 0;\n" +
-                    "}\n" +
-                    "\n" +
-                    "zuint8 zemu_io_#{name}_master_gets(void)\n" +
-                    "{\n" +
-                    "    zuint8 val = io_#{name}_buffer_slave.buffer[io_#{name}_buffer_slave.head];\n" +
-                    "    io_#{name}_buffer_slave.head++;\n" +
-                    "    if (io_#{name}_buffer_slave.head >= ZEMU_IO_SERIAL_BUFFER_SIZE)\n" +
-                    "        io_#{name}_buffer_slave.head = 0;\n" +
-                    "\n" +
-                    "    return val;\n" +
-                    "}\n"
-                end
-
-                when_read do
-                    "if (port == #{in_port})\n" +
-                    "{\n" +
-                    "    return zemu_io_#{name}_slave_gets();\n" +
-                    "}\n" +
-                    "else if (port == #{ready_port})\n" +
-                    "{\n" +
-                    "    if (io_#{name}_buffer_master.head == io_#{name}_buffer_master.tail)\n" +
-                    "    {\n" +
-                    "        return 0;\n" +
-                    "    }\n" +
-                    "    else\n" +
-                    "    {\n" +
-                    "        return 1;\n" +
-                    "    }\n" +
-                    "}\n"
-                end
-
-                when_write do
-                    "if (port == #{out_port})\n" +
-                    "{\n" +
-                    "    zemu_io_#{name}_slave_puts(value);\n" +
-                    "}\n"
-                end
+            # Defines generated C to declare the serial device.
+            def when_setup
+                "SerialBuffer io_#{name}_buffer_master = { .head = 0, .tail = 0 };\n" +
+                "SerialBuffer io_#{name}_buffer_slave = { .head = 0, .tail = 0 };\n" +
+                "\n" +
+                "zusize zemu_io_#{name}_buffer_size(void)\n" +
+                "{\n" +
+                "    zusize start = io_#{name}_buffer_slave.head;\n" +
+                "    zusize end = io_#{name}_buffer_slave.tail\n;" +
+                "    if (end < start) end += ZEMU_IO_SERIAL_BUFFER_SIZE;\n" +
+                "    return end - start;\n" +
+                "}\n" +
+                "\n" +
+                "void zemu_io_#{name}_slave_puts(zuint8 val)\n" +
+                "{\n" +
+                "    io_#{name}_buffer_slave.buffer[io_#{name}_buffer_slave.tail] = val;\n" +
+                "    io_#{name}_buffer_slave.tail++;\n" +
+                "    if (io_#{name}_buffer_slave.tail >= ZEMU_IO_SERIAL_BUFFER_SIZE)\n" +
+                "        io_#{name}_buffer_slave.tail = 0;\n" +
+                "}\n" +
+                "\n" +
+                "zuint8 zemu_io_#{name}_slave_gets(void)\n" +
+                "{\n" +
+                "    zuint8 val = io_#{name}_buffer_master.buffer[io_#{name}_buffer_master.head];\n" +
+                "    io_#{name}_buffer_master.head++;\n" +
+                "    if (io_#{name}_buffer_master.head >= ZEMU_IO_SERIAL_BUFFER_SIZE)\n" +
+                "        io_#{name}_buffer_master.head = 0;\n" +
+                "\n" +
+                "    return val;\n" +
+                "}\n" +
+                "\n" +
+                "void zemu_io_#{name}_master_puts(zuint8 val)\n" +
+                "{\n" +
+                "    io_#{name}_buffer_master.buffer[io_#{name}_buffer_master.tail] = val;\n" +
+                "    io_#{name}_buffer_master.tail++;\n" +
+                "    if (io_#{name}_buffer_master.tail >= ZEMU_IO_SERIAL_BUFFER_SIZE)\n" +
+                "        io_#{name}_buffer_master.tail = 0;\n" +
+                "}\n" +
+                "\n" +
+                "zuint8 zemu_io_#{name}_master_gets(void)\n" +
+                "{\n" +
+                "    zuint8 val = io_#{name}_buffer_slave.buffer[io_#{name}_buffer_slave.head];\n" +
+                "    io_#{name}_buffer_slave.head++;\n" +
+                "    if (io_#{name}_buffer_slave.head >= ZEMU_IO_SERIAL_BUFFER_SIZE)\n" +
+                "        io_#{name}_buffer_slave.head = 0;\n" +
+                "\n" +
+                "    return val;\n" +
+                "}\n"
+            end
+
+            # Defines generated C to handle reading from serial port's
+            # registers.
+            def when_io_read
+                "if (port == #{in_port})\n" +
+                "{\n" +
+                "    return zemu_io_#{name}_slave_gets();\n" +
+                "}\n" +
+                "else if (port == #{ready_port})\n" +
+                "{\n" +
+                "    if (io_#{name}_buffer_master.head == io_#{name}_buffer_master.tail)\n" +
+                "    {\n" +
+                "        return 0;\n" +
+                "    }\n" +
+                "    else\n" +
+                "    {\n" +
+                "        return 1;\n" +
+                "    }\n" +
+                "}\n"
+            end
+
+            # Defines generated C to handle writing to the serial port's registers.
+            def when_io_write
+                "if (port == #{out_port})\n" +
+                "{\n" +
+                "    zemu_io_#{name}_slave_puts(value);\n" +
+                "}\n"
             end
 
             # Defines FFI API which will be available to the instance wrapper if this IO device is used.
@@ -433,7 +398,7 @@ module Zemu
             end
 
             # Valid parameters for a SerialPort, along with those
-            # defined in [Zemu::Config::IOPort].
+            # defined in [Zemu::Config::BusDevice].
             def params
                 super + %w(in_port out_port ready_port)
             end
@@ -443,7 +408,7 @@ module Zemu
         #
         # 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
+        class BlockDrive < BusDevice
             # Constructor.
             #
             # Takes a block in which the parameters of the block drive
@@ -466,18 +431,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,17 +442,11 @@ 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
+            end
 
-                when_setup do
+            # Defines generated C to declare the block device.
+            def when_setup
 <<-eos
 #include <stdio.h>
 
@@ -537,9 +487,11 @@ zuint8 zemu_io_#{name}_readbyte(zuint32 sector, zuint32 offset)
     return sector_data_#{name}[offset];
 }
 eos
-                end
+            end
 
-                when_read do
+            # Defines generated C to handle reading the block drive's
+            # registers.
+            def when_io_read
 <<-eos
 if (port == #{base_port})
 {
@@ -556,9 +508,11 @@ else if (port == #{base_port+7})
     return drive_status_#{name};
 }
 eos
-                end
+            end
 
-                when_write do
+            # Defines generated C to handle writing to the block drive's
+            # registers.
+            def when_io_write
 <<-eos
 if (port == #{base_port})
 {
@@ -621,12 +575,31 @@ else if (port == #{base_port+7})
     }
 }
 eos
-                end
             end
 
             # 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.
@@ -642,7 +615,7 @@ eos
             end
 
             # Valid parameters for a BlockDrive, along with those
-            # defined in [Zemu::Config::IOPort].
+            # defined in [Zemu::Config::BusDevice].
             def params
                 super + %w(base_port sector_size num_sectors)
             end
@@ -653,30 +626,27 @@ eos
         # Represents a timer device, the period of which can be controlled
         # by the CPU through an IO port. The timer generates an NMI once this
         # period has expired. The timer can be reset via a control port.
-        class Timer < IOPort
-            def initialize
-                super
-
-                when_setup do
-                    "zuint8 io_#{name}_count;\n" +
-                    "zuint8 io_#{name}_running = 0;\n"
-                end
-
-                when_read do
-                end
+        class Timer < BusDevice
+            # Defines generated C that sets up the timer.
+            def when_setup
+                "zuint8 io_#{name}_count;\n" +
+                "zuint8 io_#{name}_running = 0;\n"
+            end
 
-                when_write do
-                    "if (port == #{count_port}) io_#{name}_count = value;\n" +
-                    "else if (port == #{control_port}) io_#{name}_running = value;\n"
-                end
+            # Defines generated C that handles writing to the timer's
+            # registers.
+            def when_io_write
+                "if (port == #{count_port}) io_#{name}_count = value;\n" +
+                "else if (port == #{control_port}) io_#{name}_running = value;\n"
+            end
 
-                when_clock do
-                    "if (io_#{name}_running)\n" +
-                    "{\n" +
-                    "    if (io_#{name}_count > 0) io_#{name}_count--;\n" +
-                    "    else zemu_io_nmi(instance);\n" +
-                    "}\n"
-                end
+            # Defines generated C that handles a clock tick for the timer.
+            def when_clock
+                "if (io_#{name}_running)\n" +
+                "{\n" +
+                "    if (io_#{name}_count > 0) io_#{name}_count--;\n" +
+                "    else zemu_io_nmi(instance);\n" +
+                "}\n"
             end
 
             # Valid parameters for a Timer, along with those defined in
@@ -691,11 +661,8 @@ eos
             return binding
         end
 
-        # The memory sections of this configuration object.
-        attr_reader :memory
-
-        # The IO devices of this configuration object.
-        attr_reader :io
+        # The bus devices of this configuration object.
+        attr_reader :devices
 
         # Parameters accessible by this configuration object.
         def params
@@ -734,8 +701,7 @@ eos
         #
         # @raise [Zemu::ConfigError] Raised if the +name+ parameter is not set, or contains whitespace.
         def initialize
-            @memory = []
-            @io = []
+            @devices = []
 
             super
 
@@ -750,16 +716,29 @@ eos
 
         # Adds a new memory section to this configuration.
         #
+        # Deprecated - retained only for backwards compatibility.
+        # Use add_device instead.
+        #
         # @param [Zemu::Config::Memory] mem The memory object to add.
         def add_memory(mem)
-            @memory << mem
+            @devices << mem
         end
 
         # Adds a new IO device to this configuration.
         #
-        # @param [Zemu::Config::IOPort] io The IO device to add.
+        # Deprecated - retained only for backwards compatibility.
+        # Use add_device instead.
+        #
+        # @param [Zemu::Config::BusDevice] io The IO device to add.
         def add_io(io)
-            @io << io
+            @devices << io
+        end
+
+        # Adds a new device to the bus for this configuration.
+        #
+        # @param [Zemu::Config::BusDevice] device The device to add.
+        def add_device(device)
+            @devices << device
         end
     end
 

data/lib/zemu/debug.rb

@@ -5,22 +5,55 @@ module Zemu
         # 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 = {}
+            symbols = []
 
             File.open(path, "r") do |f|
                 f.each_line do |l|
                     s = Symbol.parse(l)
 
-                    if symbols[s.address].nil?
-                        symbols[s.address] = []
+                    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
 
-                    symbols[s.address] << s
-                    symbols[s.address].sort_by!(&:label)
+            # 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
 
-            return symbols
+            # Get symbols as a hash.
+            def hash
+                return @syms
+            end
         end
         
         # Represents a symbol definition, of the form `label = address`.

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 bus devices that we make
+            # accessible to the user.
+            @device_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.
@@ -245,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|
+            configuration.devices.each do |device|
                 device.functions.each do |f|
                     wrapper.attach_function(f["name"].to_sym, f["args"], f["return"])
+                    @device_methods << f["name"].to_sym
                 end
             end
 
             return wrapper
         end
 
+        # Redirects calls to I/O FFI functions.
+        def method_missing(method, *args)
+            if @device_methods.include? method
+                return @wrapper.send(method)
+            end
+
+            super
+        end
+
         private :make_wrapper
     end
 end

data/lib/zemu/interactive.rb

@@ -5,7 +5,14 @@ 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]
+            @trace = []
+
             @instance = instance
 
             @symbol_table = {}
@@ -64,6 +71,9 @@ module Zemu
                 elsif cmd[0] == "map"
                     load_map(cmd[1])
 
+                elsif cmd[0] == "trace"
+                    trace()
+
                 elsif cmd[0] == "help"
                     log "Available commands:"
                     log "    continue [<n>]     - Continue execution for <n> cycles"
@@ -84,6 +94,14 @@ module Zemu
             close
         end
 
+        # Print trace for the emulator instance
+        # (last 200 addresses visited).
+        def trace
+            @trace.each do |t|
+                puts "%04x" % t
+            end
+        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.
@@ -179,6 +197,9 @@ 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
 
@@ -193,6 +214,11 @@ module Zemu
                     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?
                 if @instance.break?
                     log "Hit breakpoint at #{r16("PC")}."
@@ -252,7 +278,7 @@ module Zemu
 
             syms = {}
             begin
-                syms.merge! Debug.load_map(path.to_s)
+                syms.merge! Debug.load_map(path.to_s).hash
             rescue ArgumentError => e
                 log "Error loading map file: #{e.message}"
                 syms.clear
@@ -275,12 +301,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

@@ -62,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
@@ -73,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
@@ -109,13 +111,15 @@ module Zemu
 
         inputs_str = inputs.map { |i| File.join(SRC, i) }.join(" ")
 
-        inputs_str += " " + File.join(autogen, "memory.c") + " " + File.join(autogen, "io.c")
+        inputs_str += " " + File.join(autogen, "bus.c")
 
         defines = {
             "CPU_Z80_STATIC" => 1,
             "CPU_Z80_USE_LOCAL_HEADER" => 1
         }
 
+        defines.merge! user_defines
+
         defines_str = defines.map { |d, v| "-D#{d}=#{v}" }.join(" ")
 
         includes = [
@@ -139,32 +143,13 @@ module Zemu
     #
     # @param [Zemu::Config] configuration The configuration for which an emulator will be generated.
     def Zemu::generate(configuration)
-        generate_memory(configuration)
-        generate_io(configuration)
-    end
-
-    # Generates the memory.c and memory.h files for a given configuration.
-    def Zemu::generate_memory(configuration)
-        header_template = ERB.new File.read(File.join(SRC, "memory.h.erb"))
-        source_template = ERB.new File.read(File.join(SRC, "memory.c.erb"))
-
-        autogen = File.join(configuration.output_directory, "autogen_#{configuration.name}")
-
-        unless Dir.exist? autogen
-            Dir.mkdir autogen
-        end
-
-        File.write(File.join(autogen, "memory.h"),
-                   header_template.result(configuration.get_binding))
-
-        File.write(File.join(autogen, "memory.c"),
-                   source_template.result(configuration.get_binding))
+        generate_bus(configuration)
     end
 
-    # Generates the io.c and io.h files for a given configuration.
-    def Zemu::generate_io(configuration)
-        header_template = ERB.new File.read(File.join(SRC, "io.h.erb"))
-        source_template = ERB.new File.read(File.join(SRC, "io.c.erb"))
+    # Generates the bus.c and bus.h files for a given configuration.
+    def Zemu::generate_bus(configuration)
+        header_template = ERB.new File.read(File.join(SRC, "bus.h.erb"))
+        source_template = ERB.new File.read(File.join(SRC, "bus.c.erb"))
 
         autogen = File.join(configuration.output_directory, "autogen_#{configuration.name}")
 
@@ -172,10 +157,10 @@ module Zemu
             Dir.mkdir autogen
         end
 
-        File.write(File.join(autogen, "io.h"),
+        File.write(File.join(autogen, "bus.h"),
                    header_template.result(configuration.get_binding))
 
-        File.write(File.join(autogen, "io.c"),
+        File.write(File.join(autogen, "bus.c"),
                    source_template.result(configuration.get_binding))
     end
 end

data/src/bus.c.erb

@@ -0,0 +1,88 @@
+#include "bus.h"
+
+<% devices.each do |device| %>
+<%= device.when_setup %>
+<% end %>
+
+zuint8 zemu_memory_read(void * context, zuint16 address)
+{
+    zuint32 address_32 = address;
+<% devices.each do |mem| %>
+<%= mem.when_mem_read %>
+<% end %>
+    /* Unmapped memory has a value of 0. */
+    return 0;
+}
+
+void zemu_memory_write(void * context, zuint16 address, zuint8 value)
+{
+    zuint32 address_32 = address;
+<% devices.each do |mem| %>
+<%= mem.when_mem_write %>
+<% end %>
+}
+
+zuint8 zemu_memory_peek(zuint16 address)
+{
+    zuint32 address_32 = address;
+<% devices.each do |mem| %>
+<%= mem.when_mem_read %>
+<% end %>
+    /* Unmapped memory has a value of 0. */
+    return 0;
+}
+
+void zemu_memory_poke(zuint16 address, zuint8 value)
+{
+    zuint32 address_32 = address;
+<% devices.each do |mem| %>
+<%= mem.when_mem_write %>
+<% 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.
+     * We cannot assume that the top half is valid.
+     */
+    port &= 0x00FF;
+
+<% devices.each do |device| %>
+<%= device.when_io_read %>
+<% end %>
+    return 0;
+}
+
+void zemu_io_out(void * context, zuint16 port, zuint8 value)
+{
+    /* Z80 IO ports occupy the lower half of the address bus.
+     * We cannot assume that the top half is valid.
+     */
+    port &= 0x00FF;
+
+<% devices.each do |device| %>
+<%= device.when_io_write %>
+<% end %>
+}
+
+void zemu_io_clock(Z80 * instance)
+{
+<% devices.each do |device| %>
+<%= device.when_clock %>
+<% end %>
+}

data/src/{io.h.erb → bus.h.erb}

@@ -13,6 +13,13 @@ typedef struct {
     unsigned int tail;
 } SerialBuffer;
 
+
+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);
+
 void zemu_io_serial_master_puts(zuint8 val);
 zuint8 zemu_io_serial_master_gets(void);
 zusize zemu_io_serial_buffer_size(void);

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/debug.h

@@ -2,8 +2,7 @@
 
 #include <stdio.h>
 
-#include "memory.h"
-#include "io.h"
+#include "bus.h"
 
 zusize zemu_debug_step(Z80 * instance);
 

data/src/main.c

@@ -4,8 +4,7 @@
 
 #include "debug.h"
 
-#include "memory.h"
-#include "io.h"
+#include "bus.h"
 #include "interrupt.h"
 
 /* Allocate and initialize a Z80 instance.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: zemu
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Jay Valentine
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-10-23 00:00:00.000000000 Z
+date: 2021-12-30 00:00:00.000000000 Z
 dependencies: []
 description: |2
       Zemu is a gem which allows the user to configure a Z80-based system
@@ -32,6 +32,8 @@ files:
 - lib/zemu/debug.rb
 - lib/zemu/instance.rb
 - lib/zemu/interactive.rb
+- src/bus.c.erb
+- src/bus.h.erb
 - src/debug.c
 - src/debug.h
 - src/external/Z/API/Z/ABIs/generic/allocator.h
@@ -310,11 +312,7 @@ files:
 - src/external/z80/sources/Z80.c
 - src/interrupt.c
 - src/interrupt.h
-- src/io.c.erb
-- src/io.h.erb
 - src/main.c
-- src/memory.c.erb
-- src/memory.h.erb
 homepage: https://github.com/jayvalentine/zemu
 licenses:
 - GPL-3.0

data/src/io.c.erb

@@ -1,52 +0,0 @@
-#include "io.h"
-
-<% io.each do |device| %>
-<%= 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.
-     * We cannot assume that the top half is valid.
-     */
-    port &= 0x00FF;
-
-<% io.each do |device| %>
-<%= device.read %>
-<% end %>
-    return 0;
-}
-
-void zemu_io_out(void * context, zuint16 port, zuint8 value)
-{
-    /* Z80 IO ports occupy the lower half of the address bus.
-     * We cannot assume that the top half is valid.
-     */
-    port &= 0x00FF;
-
-<% io.each do |device| %>
-<%= device.write %>
-<% end %>
-}
-
-void zemu_io_clock(Z80 * instance)
-{
-<% io.each do |device| %>
-<%= device.clock %>
-<% end %>
-}

data/src/memory.c.erb

@@ -1,43 +0,0 @@
-#include "memory.h"
-
-<% memory.each do |mem| %>
-/* Initialization memory block "<%= mem.name %>" */
-<%= mem.readonly? ? "const " : "" %>zuint8 zemu_memory_block_<%= mem.name %>[0x<%= mem.size.to_s(16) %>] =
-{<% mem.contents.each_with_index do |b, i| %><%= (i % 16 == 0) ? "\n    " : "" %><%= ("0x%02x, " % b) %><% end %>
-};
-<% end %>
-
-zuint8 zemu_memory_read(void * context, zuint16 address)
-{
-<% memory.each do |mem| %>
-    if (address >= 0x<%= mem.address.to_s(16) %> && address < 0x<%= (mem.address + mem.size).to_s(16) %>)
-    {
-        return zemu_memory_block_<%= mem.name %>[address - 0x<%= mem.address.to_s(16) %>];
-    }
-<% end %>
-    /* Unmapped memory has a value of 0. */
-    return 0;
-}
-
-void zemu_memory_write(void * context, zuint16 address, zuint8 value)
-{
-<% 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) %>)
-    {
-        zemu_memory_block_<%= mem.name %>[address - 0x<%= mem.address.to_s(16) %>] = value;
-    }
-<% end %>
-}
-
-zuint8 zemu_memory_peek(zuint16 address)
-{
-<% memory.each do |mem| %>
-    if (address >= 0x<%= mem.address.to_s(16) %> && address < 0x<%= (mem.address + mem.size).to_s(16) %>)
-    {
-        return zemu_memory_block_<%= mem.name %>[address - 0x<%= mem.address.to_s(16) %>];
-    }
-<% end %>
-    /* Unmapped memory has a value of 0. */
-    return 0;
-}

data/src/memory.h.erb

@@ -1,9 +0,0 @@
-#include "emulation/CPU/Z80.h"
-
-#include <stdio.h>
-
-zuint8 zemu_memory_read(void * context, zuint16 address);
-
-void zemu_memory_write(void * context, zuint16 address, zuint8 value);
-
-zuint8 zemu_memory_peek(zuint16 address);