avruby 0.5.1

data/lib/avr/memory.rb

@@ -0,0 +1,163 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'avr/memory/memory_byte'
+require 'intel_hex'
+
+module AVR
+  class Memory
+    extend T::Sig
+    extend T::Helpers
+    abstract!
+
+    class Watch
+      extend T::Sig
+
+      sig do
+        params(
+          proc: T.nilable(
+            T.proc.params(
+              memory_byte: MemoryByte,
+              old_value: Integer,
+              new_value: Integer,
+            ).void
+          ),
+          block: T.nilable(
+            T.proc.params(
+              memory_byte: MemoryByte,
+              old_value: Integer,
+              new_value: Integer,
+            ).void
+          )
+        ).void
+      end
+      def initialize(proc = nil, &block)
+        @watch_proc = T.let(proc || T.must(block).to_proc, Proc)
+      end
+
+      sig { params(memory_byte: MemoryByte, old_value: Integer, new_value: Integer).void }
+      def notify(memory_byte, old_value, new_value)
+        @watch_proc.call(memory_byte, old_value, new_value)
+      end
+    end
+
+    class WatchBinding
+      extend T::Sig
+
+      sig { returns(Watch) }
+      attr_reader :watch
+
+      sig { returns(T.nilable(T::Array[Integer])) }
+      attr_reader :filter
+
+      sig { params(watch: Watch, filter: T.nilable(T::Array[Integer])).void }
+      def initialize(watch, filter = nil)
+        @watch = watch
+        @filter = filter
+      end
+
+      sig { params(address: Integer).returns(T::Boolean) }
+      def include?(address)
+        if filter
+          return true if filter&.include?(address)
+          false
+        end
+        true
+      end
+    end
+
+    sig { returns(String) }
+    attr_reader :name
+
+    sig { returns(Integer) }
+    attr_reader :size
+
+    sig { returns(T::Array[MemoryByte]) }
+    attr_reader :memory
+
+    sig { returns(T::Array[WatchBinding]) }
+    attr_reader :watches
+
+    sig { params(name: String, size: Integer, value: Integer).void }
+    def initialize(name, size, value = 0)
+      @name = name
+      @size = size
+      @memory = T.let(
+        size.times.map { |address| MemoryByte.new(self, address, value) },
+        T::Array[MemoryByte]
+      )
+      @watches = T.let([], T::Array[WatchBinding])
+    end
+
+    sig { returns(String) }
+    def inspect
+      "#<#{self.class.name} size=#{size}>"
+    end
+
+    sig { void }
+    def reset
+      memory.each do |byte|
+        byte.value = 0
+      end
+    end
+
+    sig { params(memory_byte: MemoryByte, old_value: Integer, new_value: Integer).void }
+    def notify(memory_byte, old_value, new_value)
+      watches.each do |watch|
+        if watch.include?(memory_byte.address)
+          watch.watch.notify(memory_byte, old_value, new_value)
+        end
+      end
+    end
+
+    sig { params(watch: Watch, filter: T.nilable(T::Array[Integer])).void }
+    def unshift_watch(watch, filter = nil)
+      watches.unshift(WatchBinding.new(watch, filter))
+    end
+
+    sig { params(watch: Watch, filter: T.nilable(T::Array[Integer])).void }
+    def push_watch(watch, filter = nil)
+      watches.push(WatchBinding.new(watch, filter))
+    end
+
+    sig do
+      params(
+        filter: T.untyped,
+        block: T.proc.params(
+          memory_byte: MemoryByte,
+          old_value: Integer,
+          new_value: Integer,
+        ).void
+      ).returns(Watch)
+    end
+    def watch(filter = nil, &block)
+      watch = Watch.new(block.to_proc)
+      push_watch(watch, filter.is_a?(Integer) ? [filter] : filter)
+      watch
+    end
+
+    sig { params(address: Integer).returns(Integer) }
+    def word(address)
+      byte_address = address << 1
+      (T.must(memory[byte_address + 1]).value << 8) | T.must(memory[byte_address]).value
+    end
+
+    sig { params(address: Integer, value: Integer).void }
+    def set_word(address, value)
+      byte_address = address << 1
+      T.must(memory[byte_address + 1]).value = (value & 0xff00) >> 8
+      T.must(memory[byte_address]).value = value & 0x00ff
+    end
+
+    sig { params(filename: String).returns(Integer) }
+    def load_from_intel_hex(filename)
+      ihex = IntelHex::FileReader.new(filename)
+      sum = 0
+      ihex.each_byte_with_address do |byte, address|
+        T.must(memory[address]).value = byte
+        sum += 1
+      end
+      sum
+    end
+  end
+end

data/lib/avr/memory/eeprom.rb

@@ -0,0 +1,65 @@
+# typed: false
+# frozen_string_literal: true
+
+module AVR
+  class EEPROM < Memory
+    extend T::Sig
+
+    ERASED_VALUE = 0xff
+
+    sig { returns(CPU) }
+    attr_reader :cpu
+
+    sig { params(size: Integer, cpu: CPU).void }
+    def initialize(size, cpu)
+      super('EEPROM', size, ERASED_VALUE)
+      attach(cpu)
+    end
+
+    sig { params(cpu: CPU).void }
+    def attach(cpu)
+      @cpu = cpu
+      @watched_memory_bytes = {
+        cpu.EEARL.memory_byte => :EEARL,
+        cpu.EEARH.memory_byte => :EEARH,
+        cpu.EECR.memory_byte => :EECR,
+        cpu.EEDR.memory_byte => :EEDR,
+      }
+
+      @cpu.sram.watch(@watched_memory_bytes.keys.map(&:address)) do |memory_byte, old_value, new_value|
+        case @watched_memory_bytes[memory_byte]
+        when :EECR
+          handle_eecr(old_value, new_value)
+        end
+      end
+    end
+
+    sig { params(old_value: Integer, new_value: Integer).void }
+    def handle_eecr(old_value, new_value)
+      old_eecr = cpu.EECR.hash_for_value(old_value)
+      new_eecr = cpu.EECR.hash_for_value(new_value)
+
+      if !old_eecr[:EEMPE] && new_eecr[:EEMPE]
+        cpu.notify_at_tick(cpu.clock.ticks + 4) do
+          cpu.EECR.EEMPE = false
+        end
+      end
+
+      if !old_eecr[:EEPE] && new_eecr[:EEPE] && new_eecr[:EEMPE]
+        if (!new_eecr[:EEPM0] && !new_eecr[:EEPM1]) || new_eecr[:EEPM1]
+          T.must(memory[(cpu.EEARH.value << 8) | cpu.EEARL.value]).value = cpu.EEDR.value
+        elsif new_eecr[:EEPM0]
+          T.must(memory[(cpu.EEARH.value << 8) | cpu.EEARL.value]).value = ERASED_VALUE
+        end
+        cpu.EECR.from_h({ EEMPE: false, EEPE: false })
+      end
+
+      if !old_eecr[:EERE] && new_eecr[:EERE]
+        cpu.EEDR.value = T.must(memory[(cpu.EEARH.value << 8) | cpu.EEARL.value]).value
+        cpu.EECR.EERE = false
+      end
+
+      cpu.interrupt(:EE_READY) if cpu.sreg.I && new_eecr[:EERIE]
+    end
+  end
+end

data/lib/avr/memory/flash.rb

@@ -0,0 +1,13 @@
+# typed: strict
+# frozen_string_literal: true
+
+module AVR
+  class Flash < Memory
+    extend T::Sig
+
+    sig { params(size: Integer).void }
+    def initialize(size)
+      super('Flash', size, 0xff)
+    end
+  end
+end

data/lib/avr/memory/memory_byte.rb

@@ -0,0 +1,54 @@
+# typed: strict
+# frozen_string_literal: true
+
+module AVR
+  class MemoryByte
+    extend T::Sig
+
+    sig { returns(Memory) }
+    attr_reader :memory
+
+    sig { returns(Integer) }
+    attr_reader :address
+
+    sig { returns(Integer) }
+    attr_reader :value
+
+    sig { params(memory: Memory, address: Integer, value: Integer).void }
+    def initialize(memory, address, value)
+      @memory = memory
+      @address = address
+      @value = value
+    end
+
+    sig { returns(String) }
+    def format
+      '%02x'
+    end
+
+    sig { returns(Integer) }
+    def to_i
+      value.to_i
+    end
+
+    sig { returns(String) }
+    def to_s
+      value.to_s
+    end
+
+    sig { returns(String) }
+    def chr
+      value.chr
+    end
+
+    sig { params(new_value: Integer).void }
+    def value=(new_value)
+      return if new_value == value
+      raise "Value #{new_value} out of range" unless (0..255).include?(new_value)
+
+      old_value = value
+      @value = new_value
+      memory.notify(self, old_value, new_value)
+    end
+  end
+end

data/lib/avr/memory/sram.rb

@@ -0,0 +1,13 @@
+# typed: strict
+# frozen_string_literal: true
+
+module AVR
+  class SRAM < Memory
+    extend T::Sig
+
+    sig { params(size: Integer).void }
+    def initialize(size)
+      super('SRAM', size, 0)
+    end
+  end
+end

data/lib/avr/opcode.rb

@@ -0,0 +1,237 @@
+# typed: strict
+# frozen_string_literal: true
+
+module AVR
+  extend T::Sig
+
+  class Opcode
+    extend T::Sig
+
+    class OpcodeException < RuntimeError; end
+    class IncorrectArgumentCount < OpcodeException; end
+    class RegisterExpected < OpcodeException; end
+    class UpperRegisterExpected < OpcodeException; end
+    class WordRegisterExpected < OpcodeException; end
+    class ByteConstantExpected < OpcodeException; end
+    class WordConstantExpected < OpcodeException; end
+    class IoAddressExpected < OpcodeException; end
+    class LowerIoAddressExpected < OpcodeException; end
+    class AbsolutePcExpected < OpcodeException; end
+    class NearRelativePcExpected < OpcodeException; end
+    class FarRelativePcExpected < OpcodeException; end
+    class BitNumberExpected < OpcodeException; end
+    class StatusRegisterBitExpected < OpcodeException; end
+    class ConstantOutOfRange < OpcodeException; end
+
+    # rubocop:disable Layout/HashAlignment
+    OPCODE_ARGUMENT_TYPES = T.let(
+      {
+        sreg_flag:          '%s',
+        near_relative_pc:   proc { |arg| '.%+d' % [2 * arg] },
+        far_relative_pc:    proc { |arg| '.%+d' % [2 * arg] },
+        absolute_pc:        proc { |arg| '0x%04x' % [2 * arg] },
+        byte:               '0x%02x',
+        word:               '0x%04x',
+        register:           '%s',
+        register_pair:      proc { |arg| '%s:%s' % [arg[0], arg[1]] },
+        word_register:      '%s',
+        modifying_word_register: proc { |arg|
+          if arg.is_a?(RegisterPair)
+            '%s' % arg
+          else
+            '%s%s%s' % [
+              arg[1] == :pre_decrement ? '-' : '',
+              arg[0].to_s,
+              arg[1] == :post_increment ? '+' : '',
+            ]
+          end
+        },
+        displaced_word_register: proc { |arg|
+          '%s%+d' % [arg.register.name, arg.displacement]
+        },
+        register_with_bit_number: '%s',
+        io_address:         '0x%02x',
+        lower_io_address:   '0x%02x',
+        bit_number:         '%d',
+      }.freeze,
+      T::Hash[Symbol, T.any(String, T.proc.params(arg: T::Array[Integer]).returns(String))]
+    )
+    # rubocop:enable Layout/HashAlignment
+
+    sig { returns(Symbol) }
+    attr_reader :mnemonic
+
+    sig { returns(T::Array[Symbol]) }
+    attr_reader :arg_types
+
+    sig { returns(T::Array[Symbol]) }
+    attr_reader :sreg_flags
+
+    ProcType = T.type_alias do
+      T.proc.params(
+        cpu: CPU,
+        memory: T.nilable(Memory),
+        args: Argument::ArrayType
+      ).void
+    end
+
+    sig { returns(Opcode::ProcType) }
+    attr_reader :opcode_proc
+
+    ExtractedOperandHashType = T.type_alias { T::Hash[Symbol, Integer] }
+    OperandValueHashType = T.type_alias { T::Hash[Symbol, Argument::ValueType] }
+
+    sig do
+      params(
+        mnemonic: Symbol,
+        arg_types: T::Array[Symbol],
+        sreg_flags: T::Array[Symbol],
+        opcode_proc: Opcode::ProcType
+      ).void
+    end
+    def initialize(mnemonic, arg_types, sreg_flags, opcode_proc)
+      @mnemonic = mnemonic
+      @arg_types = arg_types
+      @sreg_flags = sreg_flags
+      @opcode_proc = opcode_proc
+      arg_types.each do |arg_type|
+        raise "Unknown Opcode argument type: #{arg_type}" unless OPCODE_ARGUMENT_TYPES[arg_type]
+      end
+    end
+
+    sig { params(arg: T.untyped, arg_number: Integer).returns(T.nilable(T.class_of(OpcodeException))) }
+    def validate_arg(arg, arg_number)
+      case arg_types[arg_number]
+      when :register
+        return RegisterExpected unless arg.is_a?(Register)
+      when :word_register
+        return WordRegisterExpected unless arg.is_a?(RegisterPair)
+      when :byte
+        return ByteConstantExpected unless arg.is_a?(Value)
+        return ConstantOutOfRange unless arg.value >= 0x00 && arg.value <= 0xff
+      when :word
+        return WordConstantExpected unless arg.is_a?(Value)
+        return ConstantOutOfRange unless arg.value >= 0x0000 && arg.value <= 0xffff
+      when :absolute_pc
+        return AbsolutePcExpected unless arg.is_a?(Value)
+        return ConstantOutOfRange unless arg.value >= 0 && arg.value <= (2**22).to_i - 1
+      when :near_relative_pc
+        return NearRelativePcExpected unless arg.is_a?(Value)
+        return ConstantOutOfRange unless arg.value >= -64 && arg.value <= 63
+      when :far_relative_pc
+        return FarRelativePcExpected unless arg.is_a?(Value)
+        return ConstantOutOfRange unless arg.value >= -2048 && arg.value <= 2047
+      when :io_address
+        return IoAddressExpected unless arg.is_a?(Value)
+        return ConstantOutOfRange unless arg.value >= 0 && arg.value <= 63
+      when :lower_io_address
+        return IoAddressExpected unless arg.is_a?(Value)
+        return ConstantOutOfRange unless arg.value >= 0 && arg.value <= 31
+      when :register_with_bit_number
+        return RegisterExpected unless arg.register.is_a?(Register)
+        return BitNumberExpected unless arg.bit_number.is_a?(Integer)
+        return ConstantOutOfRange unless arg.bit_number >= 0 && arg.bit_number <= 7
+      when :sreg_flag
+        return StatusRegisterBitExpected unless arg.is_a?(Value)
+        return StatusRegisterBitExpected unless arg.value == 0 || arg.value == 1
+      end
+    end
+
+    sig { params(args: T::Array[T.untyped]).returns(T::Boolean) }
+    def validate(args)
+      raise IncorrectArgumentCount unless args.size == arg_types.size
+
+      args.each_with_index do |arg, i|
+        arg_exception = validate_arg(arg, i)
+
+        raise arg_exception, "Argument #{i} (#{arg}) invalid for #{arg_types[i]}" if arg_exception
+      end
+
+      true
+    end
+
+    sig { params(args: T::Array[T.untyped]).returns(T::Array[String]) }
+    def format_args(args)
+      formatted_args = []
+      args.each_with_index do |arg, i|
+        arg_formatter = OPCODE_ARGUMENT_TYPES[T.must(arg_types[i])]
+        case arg_formatter
+        when String
+          formatted_args << (arg_formatter % arg)
+        when Proc
+          formatted_args << arg_formatter.call(arg)
+        else
+          raise "Unknown argument formatter (#{arg_formatter.class}) for #{arg}"
+        end
+      end
+      formatted_args
+    end
+
+    sig { returns(String) }
+    def inspect
+      "#<#{self.class.name} #{mnemonic} #{arg_types}>"
+    end
+
+    sig { params(cpu: CPU, memory: T.nilable(Memory), args: T::Array[T.untyped]).void }
+    def execute(cpu, memory, args)
+      opcode_proc.call(cpu, memory, args)
+    end
+
+    @opcodes = T.let({}, T::Hash[Symbol, Opcode])
+
+    class << self
+      extend T::Sig
+      sig { returns(T::Hash[Symbol, Opcode]) }
+      attr_reader :opcodes
+    end
+
+    sig { params(cpu: CPU, byte: Integer).returns(Integer) }
+    def self.stack_push(cpu, byte)
+      cpu.sram.memory.fetch(cpu.sp.value).value = byte
+      cpu.sp.decrement
+    end
+
+    sig { params(cpu: CPU, word: Integer).returns(Integer) }
+    def self.stack_push_word(cpu, word)
+      stack_push(cpu, (word & 0xff00) >> 8)
+      stack_push(cpu, (word & 0x00ff))
+    end
+
+    sig { params(cpu: CPU).returns(Integer) }
+    def self.stack_pop(cpu)
+      cpu.sp.increment
+      cpu.sram.memory.fetch(cpu.sp.value).value
+    end
+
+    sig { params(cpu: CPU).returns(Integer) }
+    def self.stack_pop_word(cpu)
+      stack_pop(cpu) | (stack_pop(cpu) << 8)
+    end
+
+    sig do
+      params(
+        mnemonic: Symbol,
+        arg_types: T::Array[Symbol],
+        sreg_flags: T::Array[Symbol],
+        block: T.nilable(Opcode::ProcType)
+      ).returns(Opcode)
+    end
+    def self.opcode(mnemonic, arg_types = [], sreg_flags = [], &block)
+      raise 'No block given' unless block_given?
+
+      opcodes[mnemonic] = Opcode.new(mnemonic, arg_types, sreg_flags, block.to_proc)
+    end
+
+    sig { params(pattern: String, mnemonic: Symbol, block: OpcodeDecoder::OpcodeDefinition::ProcType).void }
+    def self.decode(pattern, mnemonic, &block)
+      OpcodeDecoder.add_opcode_definition(
+        OpcodeDecoder::OpcodeDefinition.new(pattern, mnemonic, block.to_proc)
+      )
+    end
+
+    sig { params(pattern: String, block: T.untyped).void }
+    def self.parse_operands(pattern, &block)
+      OpcodeDecoder.add_operand_parser(OpcodeDecoder::OperandParser.new(pattern, block.to_proc))
+    end
+  end
+end