gasm 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: bd06be7e5047c313deeb459a869c00cbf56ff8efd4d3d4190cd825ba09353eb3
+  data.tar.gz: da6ddd558a76a47819abe388c3cd57564c89530ec762f6493c793d6a81225a2b
+SHA512:
+  metadata.gz: 68e594afb0d28eb6b22bf9e8fb126881157f2e447edbeac877cf86e0320665534b451ce96bb239cfa976389acebe669d0d05b1c3c440cb3c348e246749e9b26d
+  data.tar.gz: 57f58715abe134ed443389ab2d432b454f4239b6dcf6ebd3703f80fed67da13533d9ad2fcad05930d8055a11be814b1d241c6ffa0e6659eb3b1f129954f44dd3

data/Gemfile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in gasm.gemspec
+gemspec

data/data/gasm/cpus/6502.gasm.rb

@@ -0,0 +1,162 @@
+# 6502 instructions
+# refs:
+# https://llx.com/Neil/a2/opcodes.html
+# http://www.6502.org/tutorials/6502opcodes.html
+# https://www.cs.otago.ac.nz/cosc243/pdf/6502Poster.pdf
+
+asm do
+  instructions do
+    def impl_type_a_instr(opcodes, addrmodes, c)
+      opcodes.each_with_index do |opcode, oi|
+        addrmodes.each_with_index do |(pattern, zeropage, operands), ai|
+          next if pattern.nil?
+          next if pattern == '___'
+
+          a = oi.to_s(2).rjust(3, '0')
+          b = ai.to_s(2).rjust(3, '0')
+          
+          condition = Proc.new do true end
+          condition = Proc.new do |x|
+            x[:n] < 256
+          end if zeropage
+  
+          op "#{opcode} #{pattern}", "#{a} #{b} #{c} #{'nnnn nnnn' * operands}", &condition
+        end
+      end
+    end
+
+    def hexop(name, hex, parambytes = 0)
+      op name, hex.to_s(2).rjust(8, '0') + "nnnn nnnn" * parambytes
+    end
+
+    # addressing modes:
+    
+    ADDR_ZERO_IN_X = ['(<n>,X)', true , 1] # (zero page, X)
+    ADDR_ZERO_PAGE = ['<n>',     true , 1] # zero page absolute
+    ADDR_IMMEDIATE = ['#<n>',    false, 1] # #immediate
+    ADDR_ABSOLUTE  = ['<n>',     false, 2] # absolute
+    ADDR_ZERO_IN_Y = ['(<n>),Y', true , 1] # (zero page), Y
+    ADDR_ZERO_X    = ['<n>,X',   true , 1] # zero page absolute, X
+    ADDR_ZERO_Y    = ['<n>,Y',   true , 1] # zero page absolute, Y
+    ADDR_ABS_Y     = ['<n>,Y',   false, 2] # absolute, Y
+    ADDR_ABS_X     = ['<n>,X',   false, 2] # absolute, X
+    ADDR_ACCUMULAT = ['A',       false, 0] # accumulator
+    ADDR_INVALID   = []                    # invalid addressing mode
+
+    # single byte instructions
+    hexop 'brk', 0x00
+    hexop 'nop', 0xea
+    hexop 'rti', 0x40
+    hexop 'rts', 0x60
+
+    hexop 'php', 0x08
+    hexop 'plp', 0x28
+    hexop 'pha', 0x48
+    hexop 'pla', 0x68
+
+    hexop 'txs', 0x9a
+    hexop 'tsx', 0xba
+
+    hexop 'tay', 0xa8
+    hexop 'tax', 0xaa
+
+    hexop 'dex', 0xca
+    hexop 'dey', 0x88
+
+    hexop 'iny', 0xc8
+    hexop 'inx', 0xe8
+
+    hexop 'txa', 0x8a
+    hexop 'tya', 0x98
+
+    hexop 'clc', 0x18
+    hexop 'cli', 0x58
+    hexop 'clv', 0xb8
+    hexop 'cld', 0xd8
+
+    hexop 'sec', 0x38
+    hexop 'sei', 0x78
+    hexop 'sed', 0xf8
+    
+    # type aaabbbcc instructions (01)
+    # I left sta #n in but its a nop anyway. it will generate the code without complaining
+    opcodes = %w[ora and eor adc sta lda cmp sbc]
+
+    addrmodes = [
+      ADDR_ZERO_IN_X,
+      ADDR_ZERO_PAGE,
+      ADDR_IMMEDIATE,
+      ADDR_ABSOLUTE,
+      ADDR_ZERO_IN_Y,
+      ADDR_ZERO_X,
+      ADDR_ABS_Y,
+      ADDR_ABS_X
+    ]
+
+    impl_type_a_instr(opcodes, addrmodes, '01')
+
+    # type aaabbbcc instructions (10)
+    # %w[asl rol lsr ror stx ldx dec inc]
+
+    common = [
+      ADDR_ZERO_PAGE,
+      ADDR_ACCUMULAT,
+      ADDR_ABSOLUTE,
+      ADDR_INVALID,
+    ]
+
+    no_a = [
+      ADDR_ZERO_PAGE,
+      ADDR_INVALID,
+      ADDR_ABSOLUTE,
+      ADDR_INVALID,
+    ]
+
+    # zero page statements
+    zerox = [ADDR_ZERO_X, ADDR_INVALID]
+    zeroy = [ADDR_ZERO_Y, ADDR_INVALID]
+
+    # absolute statements (only available in load)
+    absx = [ADDR_ABS_X]
+    absy = [ADDR_ABS_Y]
+
+    # note: stx a and ldx a are basically txa and tax, so we allow it
+    # note: stx abs,Y could actually exist but doesnt because it maps to an illegal instruction that is undefined.
+    impl_type_a_instr(%w[___ ___ ___ ___ ___ ldx ___ ___], [ADDR_IMMEDIATE] + common + zeroy + absy, '10')
+    impl_type_a_instr(%w[___ ___ ___ ___ stx ___ ___ ___], [ADDR_INVALID]   + common + zeroy       , '10')
+
+    # note: dec a is the same as dex. so we allow it
+    impl_type_a_instr(%w[asl rol lsr ror ___ ___ dec ___], [ADDR_INVALID]   + common + zerox + absx, '10')
+
+    # inc cannot access the accumulator. that opcode is nop
+    impl_type_a_instr(%w[___ ___ ___ ___ ___ ___ ___ inc], [ADDR_INVALID]   + no_a   + zerox + absx, '10')
+
+    # type aaabbbcc instructions (00)
+    # %w[___ bit ___ ___ sty ldy cpy cpx]
+
+    # note: ldy a is the same as tay so we allow it. sty a if we use the normal accumulator
+    #       pattern unfortunately leads to dey. we put in a special entry to map it to tya
+    impl_type_a_instr(%w[___ ___ ___ ___ ___ ldy ___ ___], [ADDR_IMMEDIATE] + common + zerox + absx, '00')
+    impl_type_a_instr(%w[___ ___ ___ ___ sty ___ ___ ___], [ADDR_INVALID]   + no_a   + zerox       , '00')
+    hexop 'sty A', 0x98
+
+    impl_type_a_instr(%w[___ ___ ___ ___ ___ ___ cpy cpx], [ADDR_IMMEDIATE] + no_a                 , '00')
+
+    impl_type_a_instr(%w[___ bit ___ ___ ___ ___ ___ ___], [ADDR_INVALID]   + no_a                 , '00')
+
+    # control flow instructions
+    hexop 'jmp <n>',   0x4c, 2
+    hexop 'jmp (<n>)', 0x6c, 2
+    hexop 'jsr <n>',   0x20, 2
+
+    hexop 'bpl <n>',   0x10, 1
+    hexop 'bmi <n>',   0x30, 1
+    hexop 'bvc <n>',   0x50, 1
+    hexop 'bvs <n>',   0x70, 1
+
+    hexop 'bcc <n>',   0x90, 1
+    hexop 'bcs <n>',   0xb0, 1
+    hexop 'bne <n>',   0xd0, 1
+    hexop 'beq <n>',   0xf0, 1
+  end
+end

data/data/gasm/cpus/chip8.gasm.rb

@@ -0,0 +1,66 @@
+asm do
+  instructions do
+    # Generate matchers for hex values for register
+    def vp(pattern, bits)
+      if pattern.include?('V<x>')
+        hex_letters = %w[a b c d e f A B C D E F]
+        hex_letters.each do |register_x|
+            pattern_a = pattern.gsub('V<x>', "V#{register_x}")
+            bits_a = bits.gsub('xxxx', "#{register_x.to_i(16).to_s(2)}")
+
+            if pattern_a.include?('V<y>')
+                hex_letters.each do |register_y|
+                    pattern_b = pattern_a.gsub('V<y>', "V#{register_y}")
+                    bits_b = bits_a.gsub('yyyy', "#{register_y.to_i(16).to_s(2)}")
+                    op pattern_b, bits_b 
+                end
+            end
+            op pattern_a, bits_a
+        end
+      end
+
+      op pattern, bits
+    end
+
+    vp "ld V<x>, [I]"        , "1111 xxxx 0110 0101" # LD Vx, [I]
+    vp "ld [I], V<x>"        , "1111 xxxx 0101 0101" # LD [I], Vx
+    vp "ld B, V<x>"          , "1111 xxxx 0011 0011" # LD B, Vx
+    vp "ld F, V<x>"          , "1111 xxxx 0010 1001" # LD F, Vx
+    vp "add I, V<x>"         , "1111 xxxx 0001 1110" # ADD I, Vx
+    vp "ld ST, V<x>"         , "1111 xxxx 0001 1000" # LD ST, Vx
+    vp "ld DT, V<x>"         , "1111 xxxx 0001 0101" # LD DT, Vx
+    vp "ld V<x>, K"          , "1111 xxxx 0000 1010" # LD Vx, K
+    vp "ld V<x>, DT"         , "1111 xxxx 0000 0111" # LD Vx, DT
+    
+    vp "sknp V<x>"           , "1110 xxxx 1010 0001" # SKNP Vx
+    vp "skp V<x>"            , "1110 xxxx 1001 1110" # SKP Vx
+    vp "drw V<x>, V<y>, <n>" , "1101 xxxx yyyy nnnn" # DRW Vx, Vy, n
+    vp "rnd V<x>, <k>"       , "1100 xxxx kkkk kkkk" # RND Vx, k; rnd Vx & k
+    op "jp V0, <n>"          , "1011 nnnn nnnn nnnn" # JP V0, n; jump n + V0
+    op "ld I, <n>"           , "1010 nnnn nnnn nnnn" # LD I, n
+    vp "sne V<x>, V<y>"      , "1001 xxxx yyyy 0000" # SNE Vx, Vy
+
+    vp "shl V<x>"            , "1000 xxxx yyyy 1110" # SHL Vx
+    vp "subn V<x>, V<y>"     , "1000 xxxx yyyy 0111" # SUBN Vx, Vy
+    vp "shr V<x>"            , "1000 xxxx yyyy 0110" # SHR Vx
+    vp "sub V<x>, V<y>"      , "1000 xxxx yyyy 0101" # SUB Vx, Vy
+    vp "add V<x>, V<y>"      , "1000 xxxx yyyy 0100" # ADD Vx, Vy
+    vp "xor V<x>, V<y>"      , "1000 xxxx yyyy 0011" # XOR Vx, Vy
+    vp "and V<x>, V<y>"      , "1000 xxxx yyyy 0010" # AND Vx, Vy
+    vp "or V<x>, V<y>"       , "1000 xxxx yyyy 0001" # OR Vx, Vy
+    vp "ld V<x>, V<y>"       , "1000 xxxx yyyy 0000" # LD Vx, Vy
+
+    vp "add V<x>, <k>"       , "0111 xxxx kkkk kkkk" # ADD Vx, k
+    vp "ld V<x>, <k>"        , "0110 xxxx kkkk kkkk" # LD Vx, k
+    vp "se V<x>, V<y>"       , "0101 xxxx yyyy 0000" # SE Vx, Vy
+    vp "sne V<x>, <k>"       , "0100 xxxx kkkk kkkk" # SNE Vx, k
+    vp "se V<x>, <k>"        , "0011 xxxx kkkk kkkk" # SE Vx, k
+    
+    op "call <n>"            , "0010 nnnn nnnn nnnn"
+    op "jp <n>"              , "0001 nnnn nnnn nnnn"
+    op "ret"                 , "0000 0000 1110 1110"
+    op "cls"                 , "0000 0000 1110 0000"
+
+    op "nop"                 , "1000 0000 0000 0000" # made up. basically LD V0, V0
+  end
+end

data/data/gasm/cpus/chip8.gasm.yml

@@ -0,0 +1,47 @@
+# CHIP8 instruction set
+# Every instruction is 16 bits long
+asm:
+  instructions:
+    # This is a made-up instruction NOP, that basically does LD V0, V0
+    # it just wastes a cycle and does not do anything
+    nop                 : 1000 0000 0000 0000
+
+    ld V<x>, [I]        : 1111 xxxx 0110 0101 # LD Vx, [I]
+    ld [I], V<x>        : 1111 xxxx 0101 0101 # LD [I], Vx
+    ld B, V<x>          : 1111 xxxx 0011 0011 # LD B, Vx
+    ld F, V<x>          : 1111 xxxx 0010 1001 # LD F, Vx
+    add I, V<x>         : 1111 xxxx 0001 1110 # ADD I, Vx
+    ld ST, V<x>         : 1111 xxxx 0001 1000 # LD ST, Vx
+    ld DT, V<x>         : 1111 xxxx 0001 0101 # LD DT, Vx
+    ld V<x>, K          : 1111 xxxx 0000 1010 # LD Vx, K
+    ld V<x>, DT         : 1111 xxxx 0000 0111 # LD Vx, DT
+    
+    sknp V<x>           : 1110 xxxx 1010 0001 # SKNP Vx
+    skp V<x>            : 1110 xxxx 1001 1110 # SKP Vx
+
+    drw V<x>, V<y>, <n> : 1101 xxxx yyyy nnnn # DRW Vx, Vy, n
+    rnd V<x>, <k>       : 1100 xxxx kkkk kkkk # RND Vx, k; rnd Vx & k
+    jp V0, <n>          : 1011 nnnn nnnn nnnn # JP V0, n; jump n + V0
+    ld I, <n>           : 1010 nnnn nnnn nnnn # LD I, n
+
+    sne V<x>, V<y>      : 1001 xxxx yyyy 0000 # SNE Vx, Vy
+
+    shl V<x>            : 1000 xxxx yyyy 1110 # SHL Vx
+    subn V<x>, V<y>     : 1000 xxxx yyyy 0111 # SUBN Vx, Vy
+    shr V<x>            : 1000 xxxx yyyy 0110 # SHR Vx
+    sub V<x>, V<y>      : 1000 xxxx yyyy 0101 # SUB Vx, Vy
+    add V<x>, V<y>      : 1000 xxxx yyyy 0100 # ADD Vx, Vy
+    xor V<x>, V<y>      : 1000 xxxx yyyy 0011 # XOR Vx, Vy
+    and V<x>, V<y>      : 1000 xxxx yyyy 0010 # AND Vx, Vy
+    or V<x>, V<y>       : 1000 xxxx yyyy 0001 # OR Vx, Vy
+    ld V<x>, V<y>       : 1000 xxxx yyyy 0000 # LD Vx, Vy
+
+    add V<x>, <k>       : 0111 xxxx kkkk kkkk # ADD Vx, k
+    ld V<x>, <k>        : 0110 xxxx kkkk kkkk # LD Vx, k
+    se V<x>, V<y>       : 0101 xxxx yyyy 0000 # SE Vx, Vy
+    sne V<x>, <k>       : 0100 xxxx kkkk kkkk # SNE Vx, k
+    se V<x>, <k>        : 0011 xxxx kkkk kkkk # SE Vx, k
+    call <n>            : 0010 nnnn nnnn nnnn
+    jp <n>              : 0001 nnnn nnnn nnnn
+    ret                 : 0000 0000 1110 1110
+    cls                 : 0000 0000 1110 0000

data/data/gasm/cpus/gameboy.gasm.rb

@@ -0,0 +1,136 @@
+# gameboy cpu instructions
+# refs:
+# http://marc.rawer.de/Gameboy/Docs/GBCPUman.pdf
+# https://meganesulli.com/generate-gb-opcodes/
+
+TARGETS = %w[B C D E H L (HL) A]
+CB = "1100 1011"
+
+asm do
+  instructions do
+
+    def tbit(i)
+      i.to_s(2).rjust(3,'0')
+    end
+
+    def dbit(i)
+      i.to_s(2).rjust(2,'0')
+    end
+
+    def hexop(name, hex)
+      op name, hex.to_s(2).rjust(8, '0')
+    end
+
+    # reset to position
+    %w[00 08 10 18 20 28 30 38].each do |pos|
+      op "rst $#{pos}", "11 #{(pos.to_i(16)+7).to_s(2)}"
+    end
+
+    # conditional jumps
+    %w[NZ Z NC C].each_with_index do |cond, i|
+      op "jp #{cond}, <n>",   "110 #{dbit(i)} 010 nnnn nnnn nnnn nnnn"
+      op "jr #{cond}, <n>",   "001 #{dbit(i)} 000 nnnn nnnn"
+      op "call #{cond}, <n>", "110 #{dbit(i)} 100 nnnn nnnn nnnn nnnn"
+      op "ret #{cond}",       "110 #{dbit(i)} 000"
+    end
+
+    # jumps
+    op "jp (HL)",  "1110 1001"
+    op "jp <n>",   "1100 0011 nnnn nnnn nnnn nnnn"
+    op "jr <n>",   "0001 1000 nnnn nnnn"
+    op "call <n>", "1100 1101 nnnn nnnn nnnn nnnn"
+  
+    # shift and rotates
+    %w[rlc rrc rl rr sla sra swap srl].each_with_index do |oper, opidx|
+      TARGETS.each_with_index do |reg, i|
+        op "#{oper} #{reg}"          , "#{CB} 00 #{tbit(opidx)} #{tbit(i)}"
+      end
+    end
+
+    # bit twiddling
+    TARGETS.each_with_index do |reg, i|
+      op "bit <b>, #{reg}"          , "#{CB} 01 bbb #{tbit(i)}"
+      op "res <b>, #{reg}"          , "#{CB} 10 bbb #{tbit(i)}"
+      op "set <b>, #{reg}"          , "#{CB} 11 bbb #{tbit(i)}"
+    end
+
+    op "stop", "0001 0000 0000 0000"
+
+    # misc instructions
+    hexop "daa", 0x27
+    hexop "cpl", 0x2f
+    hexop "ccf", 0x3f
+    hexop "scf", 0x37
+
+    hexop "reti", 0xd9
+    hexop "ret", 0xc9
+
+    hexop "nop", 0x00
+    hexop "halt", 0x76
+
+    hexop "di", 0xf3
+    hexop "ei", 0xfb
+    
+    hexop "rlca", 0x07
+    hexop "rla", 0x17
+    hexop "rrca", 0x0f
+    hexop "rra", 0x1f
+
+    # 16-bit arithmetic
+    %w[BC DE HL SP].each_with_index do |reg, i|
+      op "add HL, #{reg}"       , "00 #{dbit(i)} 1001"
+      op "inc #{reg}", "00 #{dbit(i)} 0011"
+      op "dec #{reg}", "00 #{dbit(i)} 1011"
+    end
+    
+    # 8-bit arithmetic
+    %w[add adc sub sbc and xor or cp].each_with_index do |oper, operidx|
+      TARGETS.each_with_index do |reg, i|
+        op "#{oper} A, #{reg}"         , "10 #{tbit(operidx)} #{tbit(i)}"
+      end
+  
+      op "#{oper} A, <n>"            , "11 #{tbit(operidx)} 110 nnnn nnnn"
+    end
+    
+    TARGETS.each_with_index do |reg, i|
+      op "inc #{reg}"         , "00 #{tbit(i)} 100"
+      op "dec #{reg}"         , "00 #{tbit(i)} 101"
+    end
+
+    op "add SP, <n>", "1110 1000 nnnn nnnn"
+    
+    # stack
+    %w[BC DE HL AF].each_with_index do |reg, i|
+      op "pop #{reg}"           , "11 #{dbit(i)} 0001"
+    end
+    
+    %w[BC DE HL AF].each_with_index do |reg, i|
+      op "push #{reg}"           , "11 #{dbit(i)} 0101"
+    end
+    
+    op "ld (<n>), SP", "0000 1000  nnnn nnnn nnnn nnnn"
+    
+    op "ld HL, SP + <n>", "1111 1000  nnnn nnnn nnnn nnnn"
+
+    # hl -> sp
+    op "ld SP, HL", "1111 1001"
+
+    # immediate 16-bit loads
+    %w[BC DE HL SP].each_with_index do |reg, i|
+      op "ld #{reg}, <n>"           , "00 #{dbit(i)} 0001 nnnn nnnn nnnn nnnn"
+    end
+
+    # register-register 8-bit loads
+    TARGETS.each_with_index do |dreg, di|
+      TARGETS.each_with_index do |sreg, si|
+        op "ld #{dreg}, #{sreg}"           , "01 #{tbit(di)} #{tbit(si)}"
+      end
+    end
+
+    # immediate 8-bit loads
+    TARGETS.each_with_index do |reg, i|
+      op "ld #{reg}, <n>"           , "00 #{tbit(i)} 110 nnnn nnnn"
+    end
+  
+  end
+end

data/exe/gasm

@@ -0,0 +1,77 @@
+#!/usr/bin/env ruby
+
+require 'gasm'
+
+include Gasm
+
+asm_desc = ARGV[0]
+asm_file = ARGV[1]
+
+basedir = File.join(
+  Gem.loaded_specs['gasm'].full_gem_path,
+  'data', 'gasm', 'cpus')
+
+if asm_desc == 'lscpu'
+  a = Dir[File.join(basedir, "*.gasm.rb")].map do |x|
+    x.sub!(basedir + '/', '')
+    x.sub!('.gasm.rb', '')
+    x
+  end
+
+  puts a.to_a
+
+  exit(0)
+end
+
+if asm_desc.nil? || asm_file.nil?
+  puts "USAGE: gasm <GASMFILE> <ASMFILE or ->"
+  puts "GASMFILE can be a YML or Ruby file that is a GASM description."
+  puts "ASMFILE is any text file that contains a series of assembly instructions separated"
+  puts "  by newlines. You can also just write a dash and it will attempt to read from STDIN"
+
+  puts "USAGE: gasm lscpu"
+  puts "Lists known CPUs. See below."
+
+  puts "USAGE: gasm -<CPUNAME> <ASMFILE or ->"
+  puts "Assembles a known CPU."
+  puts "Valid values of CPUNAME can be found using 'gasm lscpu'"
+  exit(1)
+end
+
+if asm_desc.start_with?('-')
+  descfile = File.join(basedir, "#{asm_desc[1..-1]}.gasm.rb")
+
+  if !File.exist?(descfile)
+    STDERR.puts "'#{descfile}' is not a known CPU."
+    exit(1)
+  end
+
+  asm_desc = descfile
+end
+
+if !File.exist?(asm_desc)
+  STDERR.puts "'#{asm_desc}' GASM file does not exist"
+  exit(1)
+end
+
+begin
+  matcher = Gasm::GasmMatcher.new(GasmLoader.new(asm_desc).desc)
+rescue => e
+  STDERR.puts "Maybe invalid GASM file: #{e.message}"
+  exit(1)
+end
+
+
+asm = if asm_file == '-'
+  Asm.new(STDIN.read, matcher)
+  
+else
+  if !File.exist?(asm_file)
+    STDERR.puts "'#{asm_file}' asm does not exist"
+    exit(1)
+  end
+  
+  Asm.new(File.read(asm_file), matcher)
+end
+
+puts asm.compiled

data/gasm.gemspec

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'gasm/version'
+
+Gem::Specification.new do |spec|
+  unless spec.respond_to?(:metadata)
+    # Prevent pushing this gem to RubyGems.org by setting 'allowed_push_host',
+    # or delete this section to allow pushing this gem to any host.
+    raise <<-ERR
+      RubyGems 2.0 or newer is required to protect against public gem pushes.
+    ERR
+  end
+
+  spec.name          = 'gasm'
+  spec.version       = Gasm::VERSION
+  spec.authors       = ['David Siaw']
+  spec.email         = ['davidsiaw@gmail.com']
+
+  spec.summary       = 'General ASsembler Maker'
+  spec.description   = 'Generates an assembler based on an assembly description'
+  spec.homepage      = 'https://github.com/davidsiaw/gasm'
+  spec.license       = 'MIT'
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = 'https://github.com/davidsiaw/gasm'
+  spec.metadata['changelog_uri'] = 'https://github.com/davidsiaw/gasm'
+
+  spec.files = Dir['{data,exe,lib,bin}/**/*'] +
+               %w[Gemfile gasm.gemspec]
+  spec.test_files    = Dir['{spec,features}/**/*']
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'rspec'
+
+  spec.metadata['allowed_push_host'] = 'https://rubygems.org'
+end

data/lib/gasm/asm.rb

@@ -0,0 +1,31 @@
+module Gasm
+  class Asm
+    def initialize(contents, gasm)
+      @gasm = gasm
+      @contents = contents
+    end
+
+    def compiled
+      lines = @contents.split("\n")
+      offset = 0
+
+      result = []
+
+      lines.each do |line|
+        line.strip!
+        next if line.length.zero? # Skip empty lines
+
+        if line.start_with?('//') # Skip over comments
+          result << line
+          next
+        end
+
+        parsed = @gasm.parse(line)
+        result << line
+        result << "#{parsed}\n" if parsed
+      end
+
+      result.join("\n")
+    end
+  end
+end

data/lib/gasm/gasm_loader.rb

@@ -0,0 +1,37 @@
+require 'yaml'
+require 'gasm/ruby_desc'
+
+module Gasm
+  class GasmLoader
+    def initialize(filename)
+      @filename = filename
+    end
+  
+    def rubydesc
+      rbdesc = RubyDesc.new
+      rbdesc.instance_eval(File.read(@filename), @filename)
+      rbdesc.desc
+    end
+  
+    def desc
+      return yamldesc if @filename.end_with?('.yml')
+  
+      rubydesc
+    end
+  
+    def yamldesc
+      v = YAML.load_file(@filename)
+  
+      newhash = {}
+      v['asm']['instructions'].each do |k, v|
+        newhash[k] = {
+          bits: v,
+          condition: Proc.new {|x| true}
+        }
+      end
+  
+      v['asm']['instructions'] = newhash
+      v
+    end
+  end
+end

data/lib/gasm/gasm_matcher.rb

@@ -0,0 +1,192 @@
+module Gasm
+  class GasmMatcher
+    def initialize(desc)
+      @desc = desc
+    end
+    
+    def strip_spaces(line)
+      line.sub(/([^%\$a-z0-9]) +/, '\1')
+    end
+    
+    def strip_comment(line)
+      line.split('//')[0]
+    end
+    
+    NUMCHARS = %[0 1 2 3 4 5 6 7 8 9 a b c d e f o x b $ %]
+    def parse(line)
+      line = strip_comment(line)
+      line = strip_spaces(line)
+      line = line.strip
+      
+      result = ''
+      values = {}
+      idx = 0
+      
+      @desc['asm']['instructions'].each do |k, info|
+        result = info[:bits]
+        idx = 0
+        
+        state = 'CHR'
+        varname = ''
+        
+        values = {}
+        k.split('').each do |chr|
+          #p chr
+          if state == 'VAR'
+            if chr.ord >= 'a'.ord && chr.ord <= 'z'.ord
+              varname = chr
+              state = 'FIN'
+            else
+              throw "expected a-z but got #{chr}"
+            end
+            
+          elsif state == 'FIN' && 
+            if chr == '>'
+              state = 'CHR'
+              value = ''
+              loop do
+                break if line[idx].nil? || !NUMCHARS.include?(line[idx])
+                value += line[idx]
+                idx += 1
+              end
+              values[varname] = value
+              
+            else
+              throw "expected > but got #{chr}"
+            end
+            
+          elsif state == 'CHR'
+            if chr == '<'
+              state = 'VAR'
+            elsif chr != line[idx]
+              result = nil
+              break
+            else
+              idx += 1
+            end
+            
+          else
+            throw "unknown state #{state} #{chr}"
+            
+          end
+        end
+        
+        # parsing was not complete, so its not this one
+        if line[idx] != nil
+          result = nil
+        end
+        
+        #p result, values, line, k
+        # convert values to ints
+        values = values.map do |k, v|
+          int = 0
+          if v.start_with?('0x')
+            int = v[2..-1].to_i(16).to_s(2)
+          elsif v.start_with?('$')
+            int = v[1..-1].to_i(16).to_s(2)
+          elsif v.start_with?('0b')
+            int = v[2..-1].to_i(2).to_s(2)
+          elsif v.start_with?('%')
+            int = v[1..-1].to_i(2).to_s(2)
+          elsif v.to_i.to_s == v
+            int = v.to_i.to_s(2)
+          else
+            # we encounter a non-number or some symbol that makes no sense
+            # this might not be the instruction we want.
+            result = nil
+            break
+          end
+          [k, int]
+        end.to_h
+        
+        next if result.nil?
+        
+        # check the custom condition tagged on the opcode
+        unless info[:condition].call(values.map{|k,v| [k.to_sym, v.to_i(2)]}.to_h)
+          result = nil
+        end
+        
+        break unless result.nil?
+      end
+      
+      if result.nil?
+        throw "unknown instruction '#{line}'"
+      end
+      
+      # fill in result
+      result = result.to_s.gsub(/\s+/, '')
+      idx = result.length - 1
+      varidx = 0
+      
+      lastvar = ' '
+      output = ''
+      
+      evalues = endiannize(values)
+      loop do
+        
+        if result[idx] == lastvar
+          varidx += 1
+        else
+          varidx = 0
+        end
+        
+        if evalues.key? result[idx]
+          output = (evalues[result[idx]][-1 - varidx] || '.') + output
+          lastvar = result[idx]
+        else
+          lastvar = ' '
+          varidx = 0
+          output = result[idx] + output
+        end
+        
+        #puts "#{evalues}, #{lastvar} #{varidx}"
+        
+        idx -= 1
+        break if idx < 0
+      end
+      
+      # split array into groups of 8 bits
+      toks = output.split('').each_slice(8)
+      
+      # rejoin the 8 bits in bsm format, and pad the end with zeros
+      toks = toks.map do |x|
+        "#{x.join('').ljust(8, '.')}"
+      end
+      
+      # write down a byte breakdown in both dec and hex
+      comment_line = toks.map{|x| x.tr('.', '0').to_i(2).to_s.ljust(11)}.join('')
+      comment_line2 = toks.map{|x| ("0x" + x.tr('.', '0').to_i(2).to_s(16).rjust(2, '0')).ljust(11)}.join('')
+      comment_line3 = toks.map{|x| ("0o" + x.tr('.', '0').to_i(2).to_s(8).rjust(3, '0')).ljust(11)}.join('')
+      
+      # generate the line that actually creates the bits
+      command_line = toks.map{|x| "<#{x}>"}.join(' ')
+      
+      [
+        "--",
+        " d " + comment_line,
+        " h " + comment_line2,
+        " o " + comment_line3,
+        "; " + command_line
+      ].join("\n")
+    end
+    
+    def littleendian(bitstr)
+      # flips a bit string around to blocks of 8 little endian bytes
+      # 1. reverse the string
+      # 2. cut it into blocks of 8
+      # 3. reverse each block of 8
+      # 4. et voila
+      bitstr.split('').reverse.each_slice(8).map{|x| x.reverse}.flatten.join('')
+    end
+    
+    def endiannize(values)
+      # transforms the values array into big and small endian versions
+      result = {}
+      values.each do |k,v|
+        result[k] = littleendian(v)
+        result[k.upcase] = v
+      end
+      result
+    end
+  end
+end

data/lib/gasm/instruction_section.rb

@@ -0,0 +1,20 @@
+require 'gasm/op_section'
+
+module Gasm
+  class InstructionsSection
+    def initialize
+      @ops = []
+    end
+    
+    def inst
+      {
+        'instructions' => @ops
+      }
+    end
+    
+    def instructions(&block)
+      op = OpSection.new(@ops)
+      op.instance_eval(&block)
+    end
+  end
+end

data/lib/gasm/op_section.rb

@@ -0,0 +1,19 @@
+module Gasm
+  class OpSection
+    attr_reader :pattern, :bits
+    
+    def initialize(ops)
+      @ops = ops
+    end
+    
+    def op(pattern, bits, &block)
+      info = {
+        bits: bits,
+        condition: lambda { |x| true }
+      }
+      info[:condition] = lambda { |x| block.call(x) } if block
+      
+      @ops << [pattern, info]
+    end
+  end
+end

data/lib/gasm/ruby_desc.rb

@@ -0,0 +1,17 @@
+require 'gasm/instruction_section'
+
+module Gasm
+  class RubyDesc
+    attr_reader :desc
+
+    def initialize
+      @desc = {}
+    end
+
+    def asm(&block)
+      insts = InstructionsSection.new
+      insts.instance_eval(&block)
+      @desc['asm'] = insts.inst
+    end
+  end
+end

data/lib/gasm/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Gasm
+  VERSION = '0.1.0'
+end

data/lib/gasm.rb

@@ -0,0 +1,4 @@
+require 'gasm/gasm_loader'
+require 'gasm/ruby_desc'
+require 'gasm/asm'
+require 'gasm/gasm_matcher'

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification
+name: gasm
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- David Siaw
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2022-07-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Generates an assembler based on an assembly description
+email:
+- davidsiaw@gmail.com
+executables:
+- gasm
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- data/gasm/cpus/6502.gasm.rb
+- data/gasm/cpus/chip8.gasm.rb
+- data/gasm/cpus/chip8.gasm.yml
+- data/gasm/cpus/gameboy.gasm.rb
+- exe/gasm
+- gasm.gemspec
+- lib/gasm.rb
+- lib/gasm/asm.rb
+- lib/gasm/gasm_loader.rb
+- lib/gasm/gasm_matcher.rb
+- lib/gasm/instruction_section.rb
+- lib/gasm/op_section.rb
+- lib/gasm/ruby_desc.rb
+- lib/gasm/version.rb
+homepage: https://github.com/davidsiaw/gasm
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/davidsiaw/gasm
+  source_code_uri: https://github.com/davidsiaw/gasm
+  changelog_uri: https://github.com/davidsiaw/gasm
+  allowed_push_host: https://rubygems.org
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.4
+signing_key: 
+specification_version: 4
+summary: General ASsembler Maker
+test_files: []