snes_utils 0.1.1 → 0.2.0

data/lib/mini_assembler/wdc65816/definitions.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SnesUtils
   module Wdc65816
     class Definitions
@@ -6,70 +8,70 @@ module SnesUtils
       HEX16 = "\\$?(#{HEX_DIGIT}{3,4})"
       HEX24 = "\\$?(#{HEX_DIGIT}{5,6})"
 
-      SINGLE_OPERAND_INSTRUCTIONS = [:imm, :iml, :imm8, :imm16, :sr, :dp, :dpx, :dpy, :idp, :idx, :idy, :idl, :idly, :isy, :abs, :abx, :aby, :abl, :alx, :ind, :iax, :ial, :rel, :rell]
-      DOUBLE_OPERAND_INSTRUCTIONS = [:bm]
-      REL_INSTRUCTIONS = [:rel, :rell]
-      BIT_INSTRUCTIONS = []
+      SINGLE_OPERAND_INSTRUCTIONS = %i[imm iml imm8 imm16 sr dp dpx dpy idp idx idy idl idly isy abs abx aby abl alx ind iax ial rel rell].freeze
+      DOUBLE_OPERAND_INSTRUCTIONS = [:bm].freeze
+      REL_INSTRUCTIONS = %i[rel rell].freeze
+      BIT_INSTRUCTIONS = [].freeze
 
       MODES_REGEXES = {
-        acc:   /^$/,
-        imp:   /^$/,
-        imm:   /^#{HEX8}$/i,
-        iml:   /^#{HEX16}$/i,
-        imm8:  /^##{HEX8}$/i,
+        acc: /^$/,
+        imp: /^$/,
+        imm: /^#{HEX8}$/i,
+        iml: /^#{HEX16}$/i,
+        imm8: /^##{HEX8}$/i,
         imm16: /^##{HEX16}$/i,
-        sr:    /^#{HEX8},S$/i,
-        dp:    /^#{HEX8}$/i,
-        dpx:   /^#{HEX8},X$/i,
-        dpy:   /^#{HEX8},Y$/i,
-        idp:   /^\(#{HEX8}\)$/i,
-        idx:   /^\(#{HEX8},X\)$/i,
-        idy:   /^\(#{HEX8}\),Y$/i,
-        idl:   /^\[#{HEX8}\]$/i,
-        idly:  /^\[#{HEX8}\],Y$/i,
-        isy:   /^\(#{HEX8},S\),Y$/i,
-        abs:   /^#{HEX16}$/i,
-        abx:   /^#{HEX16},X$/i,
-        aby:   /^#{HEX16},Y$/i,
-        abl:   /^#{HEX24}$/i,
-        alx:   /^#{HEX24},X$/i,
-        ind:   /^\(#{HEX16}\)$/i,
-        iax:   /^\(#{HEX16},X\)$/i,
-        ial:   /^\[#{HEX16}\]$/i,
-        rel:   /^#{HEX16}$/i,
-        rell:  /^#{HEX16}$/i,
-        bm:    /^#{HEX8},#{HEX8}$/i
-      }
+        sr: /^#{HEX8},S$/i,
+        dp: /^#{HEX8}$/i,
+        dpx: /^#{HEX8},X$/i,
+        dpy: /^#{HEX8},Y$/i,
+        idp: /^\(#{HEX8}\)$/i,
+        idx: /^\(#{HEX8},X\)$/i,
+        idy: /^\(#{HEX8}\),Y$/i,
+        idl: /^\[#{HEX8}\]$/i,
+        idly: /^\[#{HEX8}\],Y$/i,
+        isy: /^\(#{HEX8},S\),Y$/i,
+        abs: /^#{HEX16}$/i,
+        abx: /^#{HEX16},X$/i,
+        aby: /^#{HEX16},Y$/i,
+        abl: /^#{HEX24}$/i,
+        alx: /^#{HEX24},X$/i,
+        ind: /^\(#{HEX16}\)$/i,
+        iax: /^\(#{HEX16},X\)$/i,
+        ial: /^\[#{HEX16}\]$/i,
+        rel: /^#{HEX16}$/i,
+        rell: /^#{HEX16}$/i,
+        bm: /^#{HEX8},#{HEX8}$/i
+      }.freeze
 
       MODES_FORMATS = {
-        acc:   "%s",
-        imp:   "%s",
-        imm:   "%s %02X",
-        iml:   "%s %02X",
-        imm8:  "%s #%02X",
-        imm16: "%s #%04X",
-        sr:    "%s %02X,S",
-        dp:    "%s %02X",
-        dpx:   "%s %02X,X",
-        dpy:   "%s %02X,Y",
-        idp:   "%s (%02X)",
-        idx:   "%s (%02X,X)",
-        idy:   "%s (%02X),Y",
-        idl:   "%s [%02X]",
-        idly:  "%s [%02X],Y",
-        isy:   "%s (%02X,S),Y",
-        abs:   "%s %04X",
-        abx:   "%s %04X,X",
-        aby:   "%s %04X,Y",
-        abl:   "%s %06X",
-        alx:   "%s %06X,X",
-        ind:   "%s (%04X)",
-        iax:   "%s (%04X,X)",
-        ial:   "%s [%04X]",
-        rel:   "%s %04X {%s}",
-        rell:  "%s %04X {%s}",
-        bm:    "%s %02X,%02X"
-      }
+        acc: '%s',
+        imp: '%s',
+        imm: '%s %02X',
+        iml: '%s %02X',
+        imm8: '%s #%02X',
+        imm16: '%s #%04X',
+        sr: '%s %02X,S',
+        dp: '%s %02X',
+        dpx: '%s %02X,X',
+        dpy: '%s %02X,Y',
+        idp: '%s (%02X)',
+        idx: '%s (%02X,X)',
+        idy: '%s (%02X),Y',
+        idl: '%s [%02X]',
+        idly: '%s [%02X],Y',
+        isy: '%s (%02X,S),Y',
+        abs: '%s %04X',
+        abx: '%s %04X,X',
+        aby: '%s %04X,Y',
+        abl: '%s %06X',
+        alx: '%s %06X,X',
+        ind: '%s (%04X)',
+        iax: '%s (%04X,X)',
+        ial: '%s [%04X]',
+        rel: '%s %04X {%s}',
+        rell: '%s %04X {%s}',
+        bm: '%s %02X,%02X'
+      }.freeze
 
       OPCODES_DATA = [{ opcode: 0x61, mnemonic: 'ADC', mode: :idx, length: 2 },
                       { opcode: 0x63, mnemonic: 'ADC', mode: :sr, length: 2 },

data/lib/png2snes/png2snes.rb

@@ -15,7 +15,7 @@ module SnesUtils
 
       raise ArgumentError, 'Image width and height must be a multiple of sprite size' if (@image.width % @char_size != 0) or (@image.height % @char_size != 0)
 
-      alpha_first if alpha
+      unshift_alpha(alpha) if alpha
       fill_palette
     end
 
@@ -29,7 +29,8 @@ module SnesUtils
       end
     end
 
-    def alpha_first
+    def unshift_alpha(alpha)
+      @palette.unshift(alpha)
     end
 
     def fill_palette

data/lib/snes_utils.rb

@@ -1,8 +1,7 @@
 require 'readline'
 require 'chunky_png'
 require 'matrix'
-require 'nokogiri'
-
+require 'csv'
 require 'byebug'
 
 require 'mini_assembler/mini_assembler'
@@ -12,5 +11,7 @@ require 'mini_assembler/spc700/definitions'
 require 'png2snes/png2snes'
 require 'tmx2snes/tmx2snes'
 
+require 'vas/vas'
+
 module SnesUtils
 end

data/lib/tmx2snes/tmx2snes.rb

@@ -14,14 +14,9 @@ module SnesUtils
       tnm = big_char ? 2 : 1 # big_char : 16x16 tiles. otherwise, 8x8 tiles
       row_offset = 16 * (tnm - 1) # Skip a row in case of 16x16 tiles ( tile #9 starts at index 32)
 
-      doc = Nokogiri::XML(File.open(@file_path))
-      csv_node = doc.xpath('//data').children.first.to_s
-
-      csv = csv_node.split("\n").compact.reject { |e| e.empty? }.map { |row| row.split(',') }
-
-      csv.each do |row|
+      CSV.foreach(@file_path) do |row|
         raise if row.length != 32
-        @tilemap += row.map { |r| (r.to_i - 1)*tnm + row_offset * ((r.to_i - 1)/8).to_i }
+        @tilemap += row.map { |r| (r.to_i)*tnm + row_offset * ((r.to_i)/8).to_i }
       end
 
       raise if @tilemap.length != 32*32

data/lib/vas/vas.rb

@@ -0,0 +1,407 @@
+require 'securerandom'
+
+module SnesUtils
+  class Vas
+    WDC65816 = :wdc65816
+    SPC700 = :spc700
+
+    DIRECTIVE = [
+      '.65816', '.spc700', '.org', '.base', '.db', '.rb', '.incbin', '.incsrc', '.define'
+    ]
+
+    LABEL_OPERATORS = ['@', '!', '<', '>', '\^']
+
+    def initialize(filename)
+      raise "File not found: #{filename}" unless File.file?(filename)
+
+      @filename = filename
+      @file = {}
+      @label_registry = []
+      @define_registry = {}
+      @incbin_list = []
+      @byte_sequence_list = []
+      @memory = []
+    end
+
+    def assemble
+      construct_file
+
+      2.times do |pass|
+        @program_counter = 0
+        @origin = 0
+        @base = 0
+        @cpu = WDC65816
+
+        assemble_file(pass)
+      end
+
+      write_label_registry
+      insert_bytes
+      incbin
+      write
+    end
+
+    def construct_file(filename = @filename)
+      File.open(filename).each_with_index do |raw_line, line_no|
+        line = raw_line.split(';').first.strip.chomp
+        next if line.empty?
+
+        if line.start_with?('.include')
+          directive = line.split(' ')
+          inc_filename = directive[1].to_s.strip.chomp
+
+          construct_file(inc_filename)
+        elsif line.start_with?('.define')
+          args = line.split(' ')
+          key = "#{args[1]}"
+          val = args[2..-1].join(' ').split(';').first.strip.chomp
+
+          raise "Already defined: #{key}" unless @define_registry[key].nil?
+          @define_registry[key] = val
+        else
+          new_line = replace_define(line)
+
+          @file[SecureRandom.uuid] = { line: new_line, orig_line: line, line_no: line_no + 1, filename: filename }
+        end
+      end
+
+    end
+
+    def replace_define(line)
+      found = nil
+
+      @define_registry.keys.each do |key|
+        if line.match(/\b#{key}\b/)
+          found = key
+          break
+        end
+      end
+
+
+      return line if found.nil?
+
+      val = @define_registry[found]
+
+      line.gsub(/\b#{found}/, val)
+    end
+
+    def assemble_file(pass)
+      @file.each do |key, val|
+        @line = val[:line]
+
+        if @line.include?(':')
+          arr = @line.split(':')
+          label = arr[0].strip.chomp
+          unless /^\w+$/ =~ label
+            raise "Invalid label: #{label}"
+          end
+          register_label(label) if pass == 0
+          next unless arr[1]
+          instruction = arr[1].strip.chomp
+        else
+          instruction = @line
+        end
+
+        next if instruction.empty?
+
+        if instruction.start_with?(*DIRECTIVE)
+          process_directive(instruction, pass)
+          next
+        end
+
+        begin
+          bytes = LineAssembler.new(instruction, **options).assemble
+        rescue => e
+          puts "Error at line #{val[:filename]}##{val[:line_no]} - (#{val[:orig_line]}) : #{e}"
+          exit(1)
+        end
+
+        insert(bytes) if pass == 1
+        @program_counter += bytes.size
+      end
+    end
+
+    def register_label(label)
+      raise "Label already defined: #{label}" if @label_registry.detect { |l| l[0] == label }
+      @label_registry << [label, @program_counter + @origin]
+    end
+
+    def insert(bytes, insert_at = insert_index)
+      @memory[insert_at..insert_at + bytes.size - 1] = bytes
+    end
+
+    def insert_index
+      @program_counter + @base
+    end
+
+    def write(filename = 'out.smc')
+      File.open(filename, 'w+b') do |file|
+        file.write([@memory.map { |i| Vas::hex(i) }.join].pack('H*'))
+      end
+
+      filename
+    end
+
+    def self.hex(num, rjust_len = 2)
+      (num || 0).to_s(16).rjust(rjust_len, '0').upcase
+    end
+
+    def options
+      {
+        program_counter: @program_counter,
+        origin: @origin,
+        cpu: @cpu,
+        label_registry: @label_registry
+      }
+    end
+
+    def process_directive(instruction, pass)
+      directive = instruction.split(' ')
+
+      case directive[0]
+      when '.65816'
+        @cpu = WDC65816
+      when '.spc700'
+        @cpu = SPC700
+      when '.org'
+        update_origin(directive[1].to_i(16))
+      when '.base'
+        @base = directive[1].to_i(16)
+      when '.incbin'
+        @program_counter += prepare_incbin(directive[1].to_s.strip.chomp, pass)
+      when '.db'
+        raw_line = directive[1..-1].join.to_s.strip.chomp
+        line = LineAssembler.new(raw_line, **options).replace_labels(raw_line)
+
+        @program_counter += define_bytes(line, pass)
+      when '.rb'
+        @program_counter += directive[1].to_i(16)
+      when '.define'
+        # TODO
+      end
+    end
+
+    def update_origin(param)
+      @origin = param
+      @program_counter = 0
+
+      update_base_from_origin
+    end
+
+    def update_base_from_origin
+      # TODO: automatically update base
+      # lorom/hirom scheme
+      # spc700 scheme
+    end
+
+    def prepare_incbin(filename, pass)
+      raise "Incbin: file not found: #{filename}" unless File.file?(filename)
+
+      @incbin_list << [filename, insert_index] if pass == 0
+      File.size(filename) || 0
+    end
+
+    def incbin
+      @incbin_list.each do |filename, index|
+        file = File.open(filename)
+        bytes = file.each_byte.to_a
+        @line = filename
+        insert(bytes, index)
+      end
+    end
+
+    def define_bytes(raw_bytes, pass)
+      bytes = raw_bytes.split(',').map { |rb| rb.scan(/.{2}/).reverse }.flatten.map do |b|
+        bv = b.to_i(16)
+        raise "Invalid byte: #{b} : #{@line}" if bv < 0 || bv > 0xff
+        bv
+      end
+
+      @byte_sequence_list << [bytes, insert_index] if pass == 0
+      bytes.size
+    end
+
+    def insert_bytes
+      @byte_sequence_list.each do |bytes, index|
+        insert(bytes, index)
+      end
+    end
+
+    def write_label_registry
+      longest = @label_registry.map{|r| r[0] }.max_by(&:length)
+
+      File.open('labels.txt', 'w+b') do |file|
+        @label_registry.each do |label|
+          adjusted_label = label[0].ljust(longest.length, ' ')
+          raw_address = Vas::hex(label[1], 6)
+          address = "#{raw_address[0..1]}/#{raw_address[2..-1]}"
+          file.write "#{adjusted_label} #{address}\n"
+        end
+      end
+    end
+  end
+
+  class LineAssembler
+    def initialize(raw_line, **options)
+      @line = raw_line.split(';').first.strip.chomp
+      @current_address = (options[:program_counter] + options[:origin])
+      @cpu = options[:cpu]
+      @label_registry = options[:label_registry]
+    end
+
+    def assemble
+      instruction = @line.split(' ')
+      mnemonic = instruction[0].upcase
+      raw_operand = instruction[1].to_s
+
+      raw_operand = replace_label(raw_operand)
+
+      opcode_data = detect_opcode(mnemonic, raw_operand)
+      raise "Invalid syntax" unless opcode_data
+
+      opcode = opcode_data[:opcode]
+      @mode = opcode_data[:mode]
+      @length = opcode_data[:length]
+
+      operand_data = detect_operand(raw_operand)
+
+      operand = process_operand(operand_data)
+
+      return [opcode, *operand]
+    end
+
+    def contains_label?(operand)
+      Vas::LABEL_OPERATORS.any? { |s| operand.include?(s[-1,1]) }
+    end
+
+    def replace_labels(operand)
+      while contains_label?(operand)
+        operand = replace_label(operand)
+      end
+
+      operand
+    end
+
+    def replace_label(operand)
+      return operand unless contains_label?(operand)
+
+      unless matches = /(#{Vas::LABEL_OPERATORS.join('|')})(\w+)(\+(\d+))?/.match(operand)
+          raise "Invalid label syntax: #{operand}"
+      end
+
+      mode = matches[1]
+      label = matches[2]
+      offset = matches[4].to_i
+
+      label_data = @label_registry.detect { |l| l[0] == label }
+
+      value = label_data ? label_data[1] : @current_address
+
+      value += offset
+
+      case mode
+      when '@'
+        value = value & 0x00ffff
+        new_value = Vas::hex(value, 4)
+      when '!'
+        value = value | (((@current_address >> 16) & 0xff) << 16)
+        new_value = Vas::hex(value, 6)
+      when '<'
+        value = value & 0x0000ff
+        new_value = Vas::hex(value)
+      when '>'
+        value = (value & 0x00ff00) >> 8
+        new_value = Vas::hex(value)
+      when '^'
+        mode = '\^'
+        value = (value & 0xff0000) >> 16
+        new_value = Vas::hex(value)
+      else
+        raise "Mode error: #{mode}"
+      end
+
+      operand.gsub(/(#{mode})\w+(\+(\d+))?/, new_value)
+    end
+
+    def detect_opcode(mnemonic, operand)
+      SnesUtils.const_get(@cpu.capitalize)::Definitions::OPCODES_DATA.detect do |row|
+        mode = row[:mode]
+        regex = SnesUtils.const_get(@cpu.capitalize)::Definitions::MODES_REGEXES[mode]
+        row[:mnemonic] == mnemonic && regex =~ operand
+      end
+    end
+
+    def detect_operand(raw_operand)
+      SnesUtils.const_get(@cpu.capitalize)::Definitions::MODES_REGEXES[@mode].match(raw_operand)
+    end
+
+    def process_operand(operand_data)
+      if double_operand_instruction?
+        process_double_operand_instruction(operand_data)
+      else
+        operand = operand_data[1]&.to_i(16)
+        rel_instruction? ? process_rel_operand(operand) : little_endian(operand, @length - 1)
+      end
+    end
+
+    def process_double_operand_instruction(operand_data)
+      if bit_instruction?
+        process_bit_operand(operand_data)
+      else
+        operands = [operand_data[1], operand_data[2]].map { |o| o.to_i(16) }
+        operand_2 = rel_instruction? ? process_rel_operand(operands[1]) : operands[1]
+
+        rel_instruction? ? [operands[0], operand_2] : [operand_2, operands[0]]
+      end
+    end
+
+    def process_bit_operand(operand_data)
+      m = operand_data[1].to_i(16)
+      raise "Out of range: m > 0x1fff: #{m}" if m > 0x1fff
+
+      b = operand_data[2].to_i(16)
+      raise "Out of range: b > 7: #{b}" if b > 7
+
+      little_endian(m << 3 | b, 2)
+    end
+
+    def process_rel_operand(operand)
+      relative_addr = operand - (@current_address & 0x00ffff) - @length
+
+      if @cpu == Vas::WDC65816 && @mode == :rell
+        raise "Relative address out of range: #{relative_addr}" if relative_addr < -32_768 || relative_addr > 32_767
+
+        relative_addr += 0x10000 if relative_addr < 0
+        little_endian(relative_addr, 2)
+      else
+        raise "Relative address out of range: #{relative_addr}" if relative_addr < -128 || relative_addr > 127
+
+        relative_addr += 0x100 if relative_addr < 0
+        relative_addr
+      end
+
+    end
+
+    def little_endian(operand, length)
+      if length > 2
+        [((operand >> 0) & 0xff), ((operand >> 8) & 0xff), ((operand >> 16) & 0xff)]
+      elsif length > 1
+        [((operand >> 0) & 0xff), ((operand >> 8) & 0xff)]
+      else
+        operand
+      end
+    end
+
+    def double_operand_instruction?
+      SnesUtils.const_get(@cpu.capitalize)::Definitions::DOUBLE_OPERAND_INSTRUCTIONS.include?(@mode)
+    end
+
+    def bit_instruction?
+      SnesUtils.const_get(@cpu.capitalize)::Definitions::BIT_INSTRUCTIONS.include?(@mode)
+    end
+
+    def rel_instruction?
+      SnesUtils.const_get(@cpu.capitalize)::Definitions::REL_INSTRUCTIONS.include?(@mode)
+    end
+  end
+end