zemu 0.2.1 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2155a9588f54ef36a46f88d07f6ef7a1cb01a27ef8f8b104a2e1118cddbbdfb6
-  data.tar.gz: fd698260726fc03616d6f42c72039e9a04e4a34f77f04e2d3832a604e7c1ec64
+  metadata.gz: 79900374a7a271fbfc1333290b4078e8e587ebbec09034c9cde520623459fcd4
+  data.tar.gz: 6282f2f1d04cf8188d84a058100d7db55d9305c3c577104455ead68195d17adb
 SHA512:
-  metadata.gz: da88a0cc1dbbd30c9849b400c2fbfea989ff81f500fb51dd0c2fffd8af81a65fca231ddb1937e51205a4b9a7ac0a72ffa435ad0aa8941d9350b4edd42aca9027
-  data.tar.gz: 4a430f4fa54f8514d4c41a561e0ca92957d361025ce69ffb77a797a2d12b858b2462543ad5cc0eb8b87cd6d1688fa2c826179bd0255085f9d328de8e8629ab0d
+  metadata.gz: 30dcdd1f3b79b767816a23a28c34107fb91ea48a8bbff445fa90228d4c2fe83276ba4f5ffb727f881e1864edeb40cbbefe1f637cb2e07a2793c0bbbab3ecf7fb
+  data.tar.gz: cf6f4519a152b2f1372c581222a35bcd33a32934607bdeae878330216551a26f712a7837ddf5a9935389c4c6a1b2aeba600c2e0c178fc083bb5dce616542cf19

data/lib/zemu/config.rb

@@ -169,6 +169,53 @@ module Zemu
         # 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
 
@@ -185,6 +232,67 @@ module Zemu
                 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
+
+            # Evaluates the when_setup block of this IO device and returns the resulting string.
+            def setup
+                instance_eval(&@setup_block)
+            end
+
+            # Evaluates the when_read block of this IO device and returns the resulting string.
+            def read
+                instance_eval(&@read_block)
+            end
+
+            # Evaluates the when_write block of this IO device and returns the resulting string.
+            def write
+                instance_eval(&@write_block)
+            end
+
+            # Defines FFI API which will be available to the instance wrapper if this IO device is used.
+            def functions
+                [
+                    {"name" => "zemu_io_#{name}_master_puts".to_sym, "args" => [:uint8], "return" => :void},
+                    {"name" => "zemu_io_#{name}_master_gets".to_sym, "args" => [], "return" => :uint8},
+                    {"name" => "zemu_io_#{name}_buffer_size".to_sym, "args" => [], "return" => :uint64}
+                ]
+            end
+
             # Valid parameters for this object.
             # Should be extended by subclasses but NOT REPLACED.
             def params
@@ -217,8 +325,80 @@ module Zemu
             #
             def initialize
                 super
-            
-                @io_type = :serial
+
+                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
             end
 
             # Valid parameters for a SerialPort, along with those

data/lib/zemu/instance.rb

@@ -179,9 +179,11 @@ module Zemu
 
             wrapper.attach_function :zemu_debug_get_memory, [:uint16], :uint8
 
-            wrapper.attach_function :zemu_io_serial_master_puts, [:uint8], :void
-            wrapper.attach_function :zemu_io_serial_master_gets, [], :uint8
-            wrapper.attach_function :zemu_io_serial_buffer_size, [], :uint64
+            configuration.io.each do |device|
+                device.functions.each do |f|
+                    wrapper.attach_function(f["name"], f["args"], f["return"])
+                end
+            end
 
             return wrapper
         end

data/src/io.c.erb

@@ -1,83 +1,8 @@
 #include "io.h"
 
 <% io.each do |device| %>
-<% if device.io_type == :serial %>
-/* Buffer to which the master pushes data, slave pulls. */
-SerialBuffer io_serial_buffer_master = { .head = 0, .tail = 0 };
-
-/* Buffer to which the slave pushes data, master pulls. */
-SerialBuffer io_serial_buffer_slave = { .head = 0, .tail = 0 };
-<% end %>
-<% end %>
-
-zusize zemu_io_serial_buffer_size(void)
-{
-<% unless io.empty? %>
-    zusize start = io_serial_buffer_slave.head;
-    zusize end = io_serial_buffer_slave.tail;
-
-    if (end < start)
-    {
-        end += ZEMU_IO_SERIAL_BUFFER_SIZE;
-    }
-
-    return end - start;
-<% else %>
-    return 0;
-<% end %>
-}
-
-void zemu_io_serial_slave_puts(zuint8 val)
-{
-<% unless io.empty? %>
-    io_serial_buffer_slave.buffer[io_serial_buffer_slave.tail] = val;
-    io_serial_buffer_slave.tail++;
-
-    if (io_serial_buffer_slave.tail >= ZEMU_IO_SERIAL_BUFFER_SIZE)
-        io_serial_buffer_slave.tail = 0;
-<% end %>
-}
-
-zuint8 zemu_io_serial_slave_gets(void)
-{
-<% unless io.empty? %>
-    zuint8 val = io_serial_buffer_master.buffer[io_serial_buffer_master.head];
-    io_serial_buffer_master.head++;
-
-    if (io_serial_buffer_master.head >= ZEMU_IO_SERIAL_BUFFER_SIZE)
-        io_serial_buffer_master.head = 0;
-
-    return val;
-<% else %>
-    return 0;
-<% end %>
-}
-
-void zemu_io_serial_master_puts(zuint8 val)
-{
-<% unless io.empty? %>
-    io_serial_buffer_master.buffer[io_serial_buffer_master.tail] = val;
-    io_serial_buffer_master.tail++;
-
-    if (io_serial_buffer_master.tail >= ZEMU_IO_SERIAL_BUFFER_SIZE)
-        io_serial_buffer_master.tail = 0;
-<% end %>
-}
-
-zuint8 zemu_io_serial_master_gets(void)
-{
-<% unless io.empty? %>
-    zuint8 val = io_serial_buffer_slave.buffer[io_serial_buffer_slave.head];
-    io_serial_buffer_slave.head++;
-
-    if (io_serial_buffer_slave.head >= ZEMU_IO_SERIAL_BUFFER_SIZE)
-        io_serial_buffer_slave.head = 0;
-
-    return val;
-<% else %>
-    return 0;
+<%= device.setup %>
 <% end %>
-}
 
 zuint8 zemu_io_in(void * context, zuint16 port)
 {
@@ -87,24 +12,7 @@ zuint8 zemu_io_in(void * context, zuint16 port)
     port &= 0x00FF;
 
 <% io.each do |device| %>
-<% if device.io_type == :serial %>
-    if (port == <%= device.in_port %>)
-    {
-        return zemu_io_serial_slave_gets();
-    }
-
-    else if (port == <%= device.ready_port %>)
-    {
-        if (io_serial_buffer_master.head == io_serial_buffer_master.tail)
-        {
-            return 0;
-        }
-        else
-        {
-            return 1;
-        }
-    }
-<% end %>
+<%= device.read %>
 <% end %>
     return 0;
 }
@@ -117,11 +25,6 @@ void zemu_io_out(void * context, zuint16 port, zuint8 value)
     port &= 0x00FF;
 
 <% io.each do |device| %>
-<% if device.io_type == :serial %>
-    if (port == <%= device.out_port %>)
-    {
-        zemu_io_serial_slave_puts(value);
-    }
-<% end %>
+<%= device.write %>
 <% end %>
 }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: zemu
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.2
 platform: ruby
 authors:
 - Jay Valentine
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-02-22 00:00:00.000000000 Z
+date: 2020-02-29 00:00:00.000000000 Z
 dependencies: []
 description: |2
       Zemu is a gem which allows the user to configure a Z80-based system