snes_utils 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 10a0fc18707cb4e615a13c7ed398cd65eb5b8f87a58ef96ad354b7448fb6ee8c
-  data.tar.gz: 6d99ea9bfb1d5a96e4d4fbb9a9389d05999ee834cd236d9ae8ac1e9d05b65f46
+  metadata.gz: 7f246381ab8ed69066585483ece562451ceca114af637eae26480ae617560738
+  data.tar.gz: f63b5921657411c56261f4130e943c0e9cb01d6c0bd9a81ffeb32b588ee0796d
 SHA512:
-  metadata.gz: b6b26360469e26d8af4e90abb38935a25ec1be30788331f5b051566b3a02fd834e32bf5bc14c06760cdf43a694e454215f5f6d6d0fdc6e999ba56b313d120d21
-  data.tar.gz: b53fd68058fa91144cf7123154fa4ab1cdbdde1d7d10d5a48600b8b16d17510924e45696dabf1ab21cf92babd6e4422ced446ac8f6f0950b656e5da8dbf3e90f
+  metadata.gz: 133a82e1e257c37cf735b74fc9d727567b3d61d907bb51b7db5eb1f575d6bc579170dabae4abc9d9aaae9e5a2198a03c6ea65a5a504311f1750699f541b68aae
+  data.tar.gz: 3ffb2de928787bdd9f56ff87b1cd6b3dd45ab5c4737e54800c00d4c417a44d34d397de025d27fdfb4116ff9c0a3eac58238683b5c9431394b9dc98cfe16b67a4

data/bin/png2snes

@@ -6,10 +6,18 @@ require 'snes_utils'
 options = {}
 OptionParser.new do |opts|
   opts.on('-f', '--file FILENAME', 'PNG source file') { |o| options[:filename] = o }
+  opts.on('-b', '--bpp BPP', 'BPP') { |o| options[:bpp] = o }
+  opts.on('-a', '--alpha ALPHA', 'ALPHA') { |o| options[:alpha] = o }
 end.parse!
 
 raise OptionParser::MissingArgument, 'Must specify PNG source file' if options[:filename].nil?
 
-c = SnesUtils::Png2Snes.new options[:filename]
+if options[:alpha]
+  alpha = options[:alpha].to_i(16)
+else
+  alpha = nil
+end
+
+c = SnesUtils::Png2Snes.new options[:filename], bpp: options[:bpp].to_i, alpha: alpha
 c.write_palette
 c.write_image

data/bin/tmx2snes

@@ -7,11 +7,12 @@ options = {}
 OptionParser.new do |opts|
   opts.on('-f', '--file FILENAME', 'TMX source file') { |o| options[:filename] = o }
   opts.on('-s', '--tile-size TILESIZE', '8 or 16') { |o| options[:tile_size] = o.to_i }
+  opts.on('-p', '--palette PALETTE', 'palette no. (0..7)') { |o| options[:palette] = o.to_i }
 end.parse!
 
 raise OptionParser::MissingArgument, 'Must specify TMX source file' if options[:filename].nil?
 raise 'Wrong size : must either be 8 or 16' unless [8, 16].include? options[:tile_size]
 
-t = SnesUtils::Tmx2Snes.new options[:filename], big_char: options[:tile_size] == 16
+t = SnesUtils::Tmx2Snes.new options[:filename], big_char: options[:tile_size] == 16, palette: options[:palette]
 
 t.write

data/bin/vas

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'snes_utils'
+
+options = {}
+OptionParser.new do |opts|
+  opts.on("-h", "--help", "Prints this help") do
+    puts opts
+    exit
+  end
+
+  opts.on('-f', '--file FILENAME', 'ASM file') { |o| options[:filename] = o }
+end.parse!
+
+SnesUtils::Vas.new(options[:filename]).assemble

data/lib/mini_assembler/definitions.rb

@@ -1,15 +1,22 @@
+# frozen_string_literal: true
+
 module SnesUtils
   class Definitions
     HEX_DIGIT = '[0-9a-f]'
 
-    BYTE_LOC_REGEX = /^#{HEX_DIGIT}{1,4}$/i
-    BYTE_RANGE_REGEX = /^(#{HEX_DIGIT}{1,4})\.+(#{HEX_DIGIT}{1,4})$/i
-    BYTE_SEQUENCE_REGEX = /^(#{HEX_DIGIT}{1,4}):\s*([0-9a-f ]+)$/i
-    DISASSEMBLE_REGEX = /^(#{HEX_DIGIT}{,4})l/i
-    SWITCH_BANK_REGEX = /^(#{HEX_DIGIT}{1,2})\/$/i
-    FLIP_MX_REG_REGEX = /^([01])=([xm])$/i
-    WRITE_REGEX = /^\.write\s*(.*)$/i
-    INCBIN_REGEX = /^(#{HEX_DIGIT}{1,4}):\s*\.incbin\s+(.*)$/i
-    READ_REGEX = /^((#{HEX_DIGIT}{1,4}):\s*)*\.read\s+(.*)$/i
+    BYTE_LOC_REGEX = /^#{HEX_DIGIT}{1,4}$/i.freeze
+    BYTE_RANGE_REGEX = /^(#{HEX_DIGIT}{1,4})\.+(#{HEX_DIGIT}{1,4})$/i.freeze
+    BYTE_SEQUENCE_REGEX = /^(#{HEX_DIGIT}{1,4}):\s*([0-9a-f ]+)$/i.freeze
+    READ_BYTE_SEQUENCE_REGEX = /^(.*):\s*\.db\s+([0-9a-f ]+)$/i.freeze
+    DISASSEMBLE_REGEX = /^(#{HEX_DIGIT}{,4})l/i.freeze
+    SWITCH_BANK_REGEX = %r{^(#{HEX_DIGIT}{1,2})/$}i.freeze
+    FLIP_MX_REG_REGEX = /^([01])=([xm])$/i.freeze
+    WRITE_REGEX = /^\.write\s*(.*)$/i.freeze
+    INCBIN_REGEX = /^(#{HEX_DIGIT}{1,4}):\s*\.incbin\s+(.*)$/i.freeze
+    READ_INCBIN_REGEX = /^(.*):\s*\.incbin\s+(.*)$/i.freeze
+    READ_INCSRC_REGEX = /^\s*\.incsrc\s+(.*)$/i.freeze
+    READ_REGEX = /^((#{HEX_DIGIT}{1,4}):\s*)*\.read\s+(.*)$/i.freeze
+    READ_BANK_SWITCH = /^\.bank\s+(#{HEX_DIGIT}{1,2})$/i.freeze
+    READ_ADDR_SWITCH = /^\.addr\s+(#{HEX_DIGIT}{1,4})$/i.freeze
   end
 end

data/lib/mini_assembler/mini_assembler.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 module SnesUtils
   Readline.completion_proc = proc do |input|
     Wdc65816::Definitions::OPCODES_DATA.map { |row| row[:mnemonic] }
-                               .select { |mnemonic| mnemonic.upcase.start_with?(input.upcase) }
+                                       .select { |mnemonic| mnemonic.upcase.start_with?(input.upcase) }
   end
 
   class MiniAssembler
@@ -13,7 +15,8 @@ module SnesUtils
         @memory = []
       end
 
-      @cpu = :wdc65816
+      @cpu = :wdc65816 # :spc700
+      @mem_map = :lorom # :hirom
 
       @normal_mode = true
 
@@ -21,10 +24,9 @@ module SnesUtils
       @current_bank_no = 0
       @accumulator_flag = 1
       @index_flag = 1
+      @label_registry = {}
 
       @next_addr_to_list = 0
-
-      @label_registry = {}
     end
 
     def run
@@ -44,7 +46,7 @@ module SnesUtils
       filename = filename.empty? ? 'out.smc' : filename
 
       File.open(filename, 'w+b') do |file|
-        file.write([@memory.map { |i| i ? i : '00' }.join].pack('H*'))
+        file.write([@memory.map { |i| i || '00' }.join].pack('H*'))
       end
 
       filename
@@ -67,15 +69,14 @@ module SnesUtils
       res = read(filename)
       write(outfile)
 
-      return res
+      res
     end
 
     def read(filename, start_addr = nil)
       return 0 unless File.file?(filename)
 
-      @label_registry = {}
-
       current_addr = start_addr || @current_addr
+      current_bank_no = @current_bank_no
       instructions = []
       raw_bytes = []
       incbin_files = []
@@ -84,6 +85,8 @@ module SnesUtils
 
       2.times do |i|
         @current_addr = current_addr
+        @current_bank_no = current_bank_no
+
         instructions = []
         File.open(filename).each_with_index do |raw_line, line_no|
           line = raw_line.split(';').first.strip.chomp
@@ -95,42 +98,81 @@ module SnesUtils
           elsif line == '.65816'
             @cpu = :wdc65816
             next
+          elsif line == '.lorom'
+            @mem_map = :lorom
+            next
+          elsif line == '.hirom'
+            @mem_map = :hirom
+            next
           end
 
-          if matches = Definitions::BYTE_SEQUENCE_REGEX.match(line)
-            if i == 1
-              addr = matches[1].to_i(16)
-              bytes = matches[2].delete(' ').scan(/.{1,2}/).map { |b| hex(b.to_i(16)) }
-              raw_bytes << [addr, bytes]
-            end
+          if matches = Definitions::READ_BYTE_SEQUENCE_REGEX.match(line)
+            raw_addr = matches[1]
+            addr = if raw_addr.start_with?('%')
+                     parse_address(line, true)
+                   else
+                     full_address(matches[1].to_i(16))
+                   end
+            bytes = matches[2].delete(' ').scan(/.{1,2}/).map { |b| hex(b.to_i(16)) }
 
+            raw_bytes << [addr, bytes] if i == 1
+
+            inc_addr(@current_addr, bytes.size)
+            next
+          elsif matches = Definitions::READ_INCBIN_REGEX.match(line)
+            raw_addr = matches[1]
+            addr = if raw_addr.start_with?('%')
+                     parse_address(line, true)
+                   else
+                     full_address(matches[1].to_i(16))
+                   end
+            target_filename = matches[2].strip.chomp
+            incbin_files << [addr, target_filename] if i == 1
+
+            inc_addr(@current_addr, File.size(target_filename))
             next
-          elsif matches = Definitions::INCBIN_REGEX.match(line)
-            if i == 1
-              addr = matches[1].to_i(16)
-              filename = matches[2].strip.chomp
+          elsif matches = Definitions::READ_INCSRC_REGEX.match(line)
+            target_filename = matches[1].strip.chomp
+            incsrc_res = read(target_filename)
+            puts "incsrc: #{target_filename}, #{incsrc_res}" if i == 1
+            next
+          elsif matches = Definitions::READ_BANK_SWITCH.match(line)
+            new_bank_no = matches[1].to_i(16)
+            max_bank_no = @mem_map == :hirom ? 0x3f : 0x7f
+            return "Error at line #{line_no + 1}" if new_bank_no > max_bank_no
 
-              incbin_files << [addr, filename]
-            end
+            @current_bank_no = new_bank_no
+            @current_addr = 0
+
+            next
+          elsif matches = Definitions::READ_ADDR_SWITCH.match(line)
+            new_addr = matches[1].to_i(16)
+            return "Error at line #{line_no + 1}" if new_addr > 0xffff
+
+            @current_addr = new_addr
 
             next
           end
 
-          instruction, length, address = parse_instruction(line, register_label=(i == 0), resolve_label=(i==1))
+          instruction, length, address = parse_instruction(line, register_label = (i == 0), resolve_label = (i == 1))
           return "Error at line #{line_no + 1}" unless instruction
 
-          instructions << [instruction, length, address]
-          @current_addr = address + length
+          instructions << [instruction, length, full_address(address)]
+          bank_wrap = inc_addr(address, length)
+          if bank_wrap && (i == 0)
+            puts "Warning: bank wrap at line #{line_no + 1}"
+          end
         end
       end
 
       @cpu = cpu
 
       total_bytes_read = 0
+      @current_bank_no = current_bank_no
 
       instructions.map do |instruction_arr|
         instruction, length, address = instruction_arr
-        total_bytes_read += replace_memory_range(address, address+length-1, instruction)
+        total_bytes_read += replace_memory_range(address, address + length - 1, instruction)
       end
 
       raw_bytes.each do |raw_byte|
@@ -143,7 +185,22 @@ module SnesUtils
         total_bytes_read += incbin(filename, addr)
       end
 
-      return "Read #{total_bytes_read} bytes"
+      dump_label_registry
+
+      "Read #{total_bytes_read} bytes"
+    end
+
+    def dump_label_registry
+      dump = ['label,snes addr,rom addr']
+      @label_registry.each do |k, v|
+        next if k.start_with?('@')
+
+        dump << "#{k},#{address_human(v[:mapped_addr], v[:mapped_bank])},#{hex(v[:rom_address], 6)}"
+      end
+
+      open('labels.csv', 'w') do |f|
+        f << dump.join("\n")
+      end
     end
 
     def detect_opcode_data_from_mnemonic(mnemonic, operand)
@@ -172,14 +229,26 @@ module SnesUtils
       end
     end
 
-    def full_address(address)
-      (@current_bank_no << 16) | address
+    def full_address(address, bank_no = @current_bank_no)
+      (bank_no << 16) | address
+    end
+
+    def inc_addr(address, length)
+      @current_addr = address + length
+      initial_bank_no = @current_bank_no
+
+      while @current_addr > 0xffff
+        @current_addr -= 0x10000
+        @current_bank_no += 1
+      end
+
+      @current_bank_no != initial_bank_no
     end
 
-    def address_human(addr=nil)
-      address = full_address(addr || @current_addr)
+    def address_human(addr = nil, cur_bank = @current_bank_no)
+      address = full_address(addr || @current_addr, cur_bank)
       bank = address >> 16
-      addr = (((address>>8)&0xFF) << 8) | (address&0xFF)
+      addr = (((address >> 8) & 0xFF) << 8) | (address & 0xFF)
       "#{hex(bank)}/#{hex(addr, 4)}"
     end
 
@@ -191,7 +260,9 @@ module SnesUtils
       start_full_addr = full_address(start_addr)
       end_full_addr = full_address(end_addr)
 
-      return [] if start_full_addr > end_full_addr || start_full_addr >= @memory.length
+      if start_full_addr > end_full_addr || start_full_addr >= @memory.length
+        return []
+      end
 
       @memory[start_full_addr..end_full_addr]
     end
@@ -214,62 +285,62 @@ module SnesUtils
       if @normal_mode
         if line == '!'
           @normal_mode = false
-          return
+          nil
         elsif line == '.spc700'
           @cpu = :spc700
-          return 'spc700'
+          'spc700'
         elsif line == '.65816'
           @cpu = :wdc65816
-          return '65816'
+          '65816'
         elsif matches = Definitions::WRITE_REGEX.match(line)
           filename = matches[1].strip.chomp
           out_filename = write(filename)
-          return "Written #{@memory.size} bytes to file #{out_filename}"
+          "Written #{@memory.size} bytes to file #{out_filename}"
         elsif matches = Definitions::READ_REGEX.match(line)
           start_addr = matches[2]&.to_i(16)
           filename = matches[3].strip.chomp
 
-          return read(filename, start_addr)
+          read(filename, start_addr)
         elsif matches = Definitions::INCBIN_REGEX.match(line)
           start_addr = matches[1].to_i(16)
           filename = matches[2].strip.chomp
           nb_bytes = incbin(filename, start_addr)
 
-          return "Inserted #{nb_bytes} bytes at #{address_human(start_addr)}"
+          "Inserted #{nb_bytes} bytes at #{address_human(start_addr)}"
         elsif Definitions::BYTE_LOC_REGEX =~ line
-          return memory_loc(line.to_i(16))
+          memory_loc(line.to_i(16))
         elsif matches = Definitions::BYTE_RANGE_REGEX.match(line)
           start_addr = matches[1].to_i(16)
           end_addr = matches[2].to_i(16)
 
           padding_count = start_addr % 8
-          padding = (1..padding_count).map { |b| '  ' }
+          padding = (1..padding_count).map { |_b| '  ' }
           arr = memory_range(start_addr, end_addr)
           return if arr.empty?
 
-          padded_arr = arr.insert(8-padding_count, *padding).each_slice(8).to_a
-          return padded_arr.each_with_index.map do |row, idx|
-            if idx == 0
-              line_addr = start_addr
-            else
-              line_addr = start_addr - padding_count + idx * 8
-            end
+          padded_arr = arr.insert(8 - padding_count, *padding).each_slice(8).to_a
+          padded_arr.each_with_index.map do |row, idx|
+            line_addr = if idx == 0
+                          start_addr
+                        else
+                          start_addr - padding_count + idx * 8
+                        end
             ["#{address_human(line_addr)}-", *row].join(' ')
           end.join("\n")
         elsif matches = Definitions::BYTE_SEQUENCE_REGEX.match(line)
           addr = matches[1].to_i(16)
           bytes = matches[2].delete(' ').scan(/.{1,2}/).map { |b| hex(b.to_i(16)) }
           replace_memory_range(addr, addr + bytes.length - 1, bytes)
-          return
+          nil
         elsif matches = Definitions::DISASSEMBLE_REGEX.match(line)
           start = matches[1].empty? ? @next_addr_to_list : matches[1].to_i(16)
-          return disassemble_range(start, 20).join("\n")
+          disassemble_range(start, 20).join("\n")
         elsif matches = Definitions::SWITCH_BANK_REGEX.match(line)
           target_bank_no = matches[1].to_i(16)
           @current_bank_no = target_bank_no
           @current_addr = @current_bank_no << 16
           @next_addr_to_list = 0
-          return
+          nil
         elsif matches = Definitions::FLIP_MX_REG_REGEX.match(line)
           val = matches[1]
           reg = matches[2]
@@ -280,59 +351,132 @@ module SnesUtils
             @index_flag = val.to_i
           end
 
-          return
+          nil
         end
       else
         if line == ''
           @normal_mode = true
-          return
+          nil
         else
           instruction, length, address = parse_instruction(line)
           return 'error' unless instruction
 
-          replace_memory_range(address, address+length-1, instruction)
-          @current_addr = address + length
-          return disassemble_range(address, 1, length > 2).join
+          replace_memory_range(address, address + length - 1, instruction)
+          inc_addr(address, length)
+          disassemble_range(address, 1, length > 2).join
         end
       end
     end
 
-    def parse_address(line, register_label = false)
+    def mapped_address(address, absolute = false)
+      return hex(address, 4) unless absolute
+
+      if @mem_map == :lorom
+        bank_offset = address / 0x8000
+        mapped_addr = address - (bank_offset * 0x8000)
+        mapped_addr += 0x8000 if mapped_addr < 0x8000
+        mapped_bank = @current_bank_no * 2
+        mapped_bank += bank_offset
+        mapped_bank += 0x80 if mapped_bank < 0x7f
+
+        { mapped_bank: mapped_bank, mapped_addr: mapped_addr, rom_address: full_address(address) }
+      elsif @mem_map == :hirom
+        mapped_bank = @current_bank_no + 0xc0 if @current_bank_no < 0x3f
+        { mapped_bank: mapped_bank, mapped_addr: address, rom_address: full_address(address) }
+      else
+        {}
+      end
+    end
+
+    def detect_label_type(address)
+      address = address[1..-1] if address.start_with?('#')
+      if address.start_with?('@')
+        :relative
+      elsif address.start_with?('%')
+        :absolute16
+      elsif address.start_with?('&')
+        :absolute24
+      end
+    end
+
+    def contains_label?(op)
+      op.include?('@') | op.include?('%') | op.include?('&')
+    end
+
+    def parse_address(line, _register_label = false)
       return @current_addr if line.index(':').nil?
 
       address = line.split(':').first.strip.chomp
-      return address.to_i(16) unless address.start_with?('@')
+      return -1 if address.to_i(16) > 0xffff
+      return address.to_i(16) if detect_label_type(address).nil?
+
+      label_type = detect_label_type(address)
+      case label_type
+      when :relative
+        @label_registry[address] = mapped_address(@current_addr)
+      when :absolute16
+        @label_registry[address[1..-1]] = mapped_address(@current_addr, true)
+      when :absolute24
+        @label_registry[address[1..-1]] = mapped_address(@current_addr, true)
+      else
+        op
+      end
 
-      @label_registry[address] = hex(@current_addr, 4)
-      return @current_addr
+      @current_addr
     end
 
     def parse_instruction(line, register_label = false, resolve_label = false)
       current_address = parse_address(line, register_label)
+      return if current_address < 0 || current_address > 0xffff
+
       instruction = line.split(':').last.split(' ')
       mnemonic = instruction[0].upcase
       raw_operand = instruction[1].to_s
 
-      if register_label and raw_operand.include?('@')
-        raw_operands = raw_operand.split(',')
-        raw_operands.each_with_index do |op, idx|
-          if op.start_with?('@')
-            raw_operands[idx] = hex(@current_addr, 4)
+      if register_label && contains_label?(raw_operand)
+        raw_operand = raw_operand.split(',').map do |op|
+          label_type = detect_label_type(op)
+          case label_type
+          when :relative
+            mapped_address(@current_addr)
+          when :absolute16
+            dummy = mapped_address(@current_addr, true)
+            dummy[:mapped_addr].to_s(16)
+          when :absolute24
+            dummy = mapped_address(@current_addr, true)
+            full_address(dummy[:mapped_addr], dummy[:mapped_bank]).to_s(16)
+          else
+            op
           end
-        end
-
-        raw_operand = raw_operands.join(',')
+        end.join(',')
       end
 
-      if resolve_label and raw_operand.include?('@')
-        raw_operands = raw_operand.split(',')
-        raw_operands.each_with_index do |op, idx|
-          if op.start_with?('@')
-            raw_operands[idx] = @label_registry[op]
+      if resolve_label && contains_label?(raw_operand)
+        raw_operand = raw_operand.split(',').map do |op|
+          label_type = detect_label_type(op)
+          case label_type
+          when :relative
+            if op.start_with?('#')
+              @label_registry[op[1..-1]]
+            else
+              @label_registry[op]
+            end
+          when :absolute16
+            if op.start_with?('#')
+              "##{@label_registry[op[2..-1]][:mapped_addr].to_s(16)}"
+            else
+              @label_registry[op[1..-1]][:mapped_addr].to_s(16)
+            end
+          when :absolute24
+            if op.start_with?('#')
+              "##{full_address(@label_registry[op[2..-1]][:mapped_addr], @label_registry[op[1..-1]][:mapped_bank]).to_s(16)}"
+            else
+              full_address(@label_registry[op[1..-1]][:mapped_addr], @label_registry[op[1..-1]][:mapped_bank]).to_s(16)
+            end
+          else
+            op
           end
-        end
-
-        raw_operand = raw_operands.join(',')
+        end.join(',')
       end
 
       opcode_data = detect_opcode_data_from_mnemonic(mnemonic, raw_operand)
@@ -349,10 +493,11 @@ module SnesUtils
         if SnesUtils.const_get(@cpu.capitalize)::Definitions::BIT_INSTRUCTIONS.include?(mode)
           m = operand_matches[1].to_i(16)
           return if m > 0x1fff
+
           b = operand_matches[2].to_i(16)
           return if b > 7
 
-          operand = m << 3 | 5
+          operand = m << 3 | b
         else
           if SnesUtils.const_get(@cpu.capitalize)::Definitions::REL_INSTRUCTIONS.include?(mode)
             operand = [operand_matches[1], operand_matches[2]].map { |o| o.to_i(16) }
@@ -369,7 +514,7 @@ module SnesUtils
           if SnesUtils.const_get(@cpu.capitalize)::Definitions::DOUBLE_OPERAND_INSTRUCTIONS.include?(mode)
             relative_addr = operand[1] - current_address - length
 
-            return if (relative_addr < -128 || relative_addr > 127)
+            return if relative_addr < -128 || relative_addr > 127
 
             relative_addr = 0x100 + relative_addr if relative_addr < 0
             param_bytes = "#{hex(operand[0])}#{hex(relative_addr)}"
@@ -377,29 +522,31 @@ module SnesUtils
             relative_addr = operand - current_address - length
 
             if @cpu == :wdc65816 && mode == :rell
-              return if (relative_addr < -32768 || relative_addr > 32767)
+              return if relative_addr < -32_768 || relative_addr > 32_767
             else
-              return if (relative_addr < -128 || relative_addr > 127)
+              return if relative_addr < -128 || relative_addr > 127
             end
 
-            relative_addr = (2**(8*(length-1))) + relative_addr if relative_addr < 0
-            param_bytes = hex(relative_addr, 2*(length-1)).scan(/.{2}/).reverse.join
+            if relative_addr < 0
+              relative_addr = (2**(8 * (length - 1))) + relative_addr
+            end
+            param_bytes = hex(relative_addr, 2 * (length - 1)).scan(/.{2}/).reverse.join
           end
         else
-          param_bytes = hex(operand, 2*(length-1)).scan(/.{2}/).reverse.join
+          param_bytes = hex(operand, 2 * (length - 1)).scan(/.{2}/).reverse.join
         end
       end
 
       encoded_result = "#{opcode}#{param_bytes}"
 
-      return [encoded_result.scan(/.{2}/), length, current_address]
+      [encoded_result.scan(/.{2}/), length, current_address]
     end
 
     def auto_update_flags(opcode, operand)
-      if 0xc2 == opcode
+      if opcode == 0xc2
         @index_flag = 0 if (operand & 0x10) == 0x10
         @accumulator_flag = 0 if (operand & 0x20) == 0x20
-      elsif 0xe2 == opcode
+      elsif opcode == 0xe2
         @index_flag = 1 if (operand & 0x10) == 0x10
         @accumulator_flag = 1 if (operand & 0x20) == 0x20
       end
@@ -411,6 +558,7 @@ module SnesUtils
       count.times do
         byte = memory_loc(next_idx)
         break unless byte
+
         opcode = byte.to_i(16)
 
         opcode_data = detect_opcode_data_from_opcode(opcode, force_length)
@@ -421,9 +569,9 @@ module SnesUtils
 
         format = SnesUtils.const_get(@cpu.capitalize)::Definitions::MODES_FORMATS[mode]
 
-        operand = memory_range(next_idx+1, next_idx+length-1).reverse.join.to_i(16)
+        operand = memory_range(next_idx + 1, next_idx + length - 1).reverse.join.to_i(16)
 
-        hex_encoded_instruction = memory_range(next_idx, next_idx+length-1)
+        hex_encoded_instruction = memory_range(next_idx, next_idx + length - 1)
         prefix = ["#{address_human(next_idx)}:", *hex_encoded_instruction].join(' ')
 
         auto_update_flags(opcode, operand) if @cpu == :wdc65816
@@ -455,12 +603,12 @@ module SnesUtils
           end
         end
 
-        instructions << "#{prefix.ljust(30)} #{format % [mnemonic, *operand]}"
+        instructions << "#{prefix.ljust(30)} #{format(format, mnemonic, *operand)}"
         next_idx += length
       end
 
       @next_addr_to_list = next_idx
-      return instructions
+      instructions
     end
 
     def relative_operand(operand, next_idx, limit = 0x7f, offset = 0x100, rjust_len = 2)