scasm 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in scasm.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Rich Lane
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,69 @@
+SCASM
+=====
+
+Introduction
+------------
+
+SCASM is an assembler for the DCPU-16 architecture used in the game 0x10c.
+See the game's [official website](http://0x10c.com/) for details on the
+instruction set. This assembler is different and powerful because the
+code you write is actually Ruby, meaning you can use all the capabilities
+of a high-level programming language to help generate the final machine code.
+
+Installation
+------------
+
+    gem install scasm
+
+Example
+-------
+
+    foo = A
+    bar = B
+    offset = 42
+    add [foo, offset], bar
+
+See the examples directory for more sample code.
+
+Syntax
+------
+
+SCASM input is Ruby code, but you won't need a deep understanding of Ruby to
+get started. Simple statements like `add A, 1` work just like you expect. This
+section will cover the SCASM-specific syntax.
+
+### Registers
+
+Ruby variables named `A`, `B`, `C`, `X`, `Y`, `Z`, `I`, and `J` are provided to refer to the
+processor registers.
+
+### Memory
+
+Memory references are of the form `[register, offset]`. Either `register` or
+`offset` can be omitted.
+
+Examples:
+
+* `[A]`
+* `[0x100]`
+* `[A, 2]`
+
+### Literals
+
+Literal values are just given as integers. Example: `42` or `0x200`.
+
+### Miscellaneous
+
+These values have the same meaning as in the spec:
+
+* `pop`
+* `peek`
+* `push`
+* `sp`
+* `pc`
+* `o`
+
+Contributing
+------------
+
+Fork the project on GitHub and send me a pull request.

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/bin/scasm

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+require 'trollop'
+require 'scasm/assembler'
+
+opts = Trollop.options do
+  banner <<-EOS
+scasm - the Ship Computer Assembler
+
+SCASM is an assembler for the DCPU-16 computer used in the game 0x10c.
+CPU specs: http://0x10c.com/doc/dcpu-16.txt
+
+Usage:
+       scasm [options] [file]
+
+where [options] are:
+EOS
+
+  opt :output, "Output filename", :short => 'o', :type => :string
+  opt :help, "Show this message", :short => 'h'
+
+  text <<-EOS
+
+If no input file is given input is read from stdin. If no output file is given
+the output will be written to filename.bin or stdout.
+  EOS
+end
+
+if ARGV[0]
+  input_io = File.open(ARGV[0])
+else
+  input_io = $stdin
+end
+
+if opts[:output]
+  output_io = File.open(opts[:output], 'w')
+elsif input_io != $stdin
+  filename = File.join(File.dirname(input_io.path), File.basename(input_io.path, '.scasm') + '.bin')
+  output_io = File.open(filename, 'w')
+else
+  output_io = $stdout
+end
+
+as = SCASM::Assembler.new
+as.eval input_io.read
+output_io.write as.assemble

data/bin/scasm-disassemble

@@ -0,0 +1,112 @@
+#!/usr/bin/env ruby
+require 'trollop'
+require 'scasm/isa'
+require 'scasm/statement'
+require 'scasm/value'
+
+include SCASM
+
+opts = Trollop.options do
+  banner <<-EOS
+scasm-disassembler - Disassemble DCPU-16 binaries.
+
+Usage:
+       scasm-disassembler [options] [file]
+
+where [options] are:
+EOS
+end
+
+mem = ARGF.read.unpack("v*")
+addr = 0
+basic_opcode_map = SCASM::BASIC_OPCODES.invert
+extended_opcode_map = SCASM::EXTENDED_OPCODES.invert
+register_map = SCASM::REGISTERS.invert
+
+next_word = lambda do
+  word = mem[addr]
+  addr += 1
+  word
+end
+
+decode_value = lambda do |value|
+  if value <= 0x07
+    Register.new register_map[value]
+  elsif value <= 0x0f
+    RegisterMemory.new register_map[value-0x08]
+  elsif value <= 0x17
+    OffsetRegisterMemory.new register_map[value-0x10], next_word[]
+  elsif value == 0x18
+    Pop.new
+  elsif value == 0x19
+    Peek.new
+  elsif value == 0x1a
+    Push.new
+  elsif value == 0x1b
+    SP.new
+  elsif value == 0x1c
+    PC.new
+  elsif value == 0x1d
+    O.new
+  elsif value == 0x1e
+    ImmediateMemory.new next_word[]
+  elsif value == 0x1f
+    Immediate.new next_word[]
+  elsif value < 0x3f
+    Immediate.new(value-0x20)
+  end
+end
+
+# Create statements for each instruction
+stmts = []
+jumps = Hash.new { |h,k| h[k] = [] }
+while addr < mem.size
+  start_addr = addr
+  word = next_word[]
+  opcode = word & 0xf
+  code_a = (word >> 4) & 0x3f
+  code_b = (word >> 10) & 0x3f
+
+  if opcode != 0 then
+    opsym = basic_opcode_map[opcode] or fail "unknown opcode #{opcode} at #{start_addr}"
+    a = decode_value[code_a]
+    b = decode_value[code_b]
+  else
+    opsym = extended_opcode_map[code_a] or fail "unknown extended opcode #{code_a} at #{start_addr}"
+    a = decode_value[code_b]
+    b = nil
+  end
+
+  if opsym == :set and a.is_a? PC and b.is_a? Immediate
+    imm = b.value
+    b = ImmediateLabel.new "L#{b.value}"
+    b.resolve imm
+    jumps[imm] << b
+  elsif opsym == :jsr and a.is_a? Immediate
+    imm = a.value
+    a = ImmediateLabel.new "L#{a.value}"
+    a.resolve imm
+    jumps[imm] << a
+  end
+
+  inst = Instruction.new(opsym, a, b)
+  inst.addr = start_addr
+  stmts << inst
+end
+
+# Create labels and fixup jumpers
+labelled_stmts = []
+stmts.each do |stmt|
+  if jumps.member? stmt.addr
+    jumpers = jumps[stmt.addr]
+    lbl = Label.new("L#{stmt.addr}")
+    lbl.addr = stmt.addr
+    labelled_stmts << lbl
+  end
+  labelled_stmts << stmt
+end
+
+# Output each statement
+labelled_stmts.each do |stmt|
+  printf "%-40s # pc=%d\n" % [stmt, stmt.addr]
+end

data/examples/spec.scasm

@@ -0,0 +1,29 @@
+# Translation of the example code from the DPU-16 spec.
+
+# Try some basic stuff
+set A, 48
+set [4096], 32
+sub A, [4096]
+ifn A, 16
+  set pc, "crash"
+
+# Do a loopy thing
+set I, 10
+set A, 8192
+label "loop"
+set [I, 8192], [A]
+sub I, 1
+ifn I, 0
+  set pc, "loop"
+
+# Call a subroutine
+set X, 4
+jsr "testsub"
+set pc, "crash"
+label "testsub"
+shl X, 4
+set pc, pop
+
+# Hang forever. X should now be 0x40 if everything went right.
+label "crash"
+set pc, "crash"

data/lib/scasm/assembler.rb

@@ -0,0 +1,152 @@
+require 'stringio'
+require 'scasm/isa'
+require 'scasm/statement'
+require 'scasm/value'
+
+module SCASM
+
+class Assembler < BasicObject
+  def initialize
+    @stmts = []
+    @relocations = []
+  end
+
+  def eval code
+    instance_eval code
+  end
+
+  def assemble
+    resolve_labels
+    io = ::StringIO.new
+    @stmts.each { |stmt| stmt.assemble io }
+    io.string
+  end
+
+  def inst opsym, a, b
+    a = parse_value a
+    b = parse_value b
+    @stmts << Instruction.new(opsym, a, b)
+  end
+
+  def label name
+    ::Kernel.raise "label names must be strings" unless name.is_a? ::String
+    @stmts << Label.new(name)
+  end
+
+  def reg regsym
+    Register.new regsym
+  end
+
+  def regmem regsym
+    RegisterMemory.new regsym
+  end
+
+  def iregmem regsym, imm
+    OffsetRegisterMemory.new regsym, imm
+  end
+
+  def pop
+    Pop.new
+  end
+
+  def peek
+    Peek.new
+  end
+
+  def push
+    Push.new
+  end
+
+  def sp
+    SP.new
+  end
+
+  def pc
+    PC.new
+  end
+
+  def o
+    O.new
+  end
+
+  def imem imm
+    ImmediateMemory.new imm
+  end
+
+  def imm imm
+    Immediate.new imm
+  end
+
+  def l name
+    ::Kernel.raise "label names must be strings" unless name.is_a? ::String
+    ImmediateLabel.new(name).tap { |x| @relocations << x }
+  end
+
+  # Add a method for each instruction
+  BASIC_OPCODES.each do |opsym,opcode|
+    define_method(opsym) { |a,b| inst opsym, a, b }
+  end
+
+  EXTENDED_OPCODES.each do |opsym,opcode|
+    define_method(opsym) { |a| inst opsym, a, nil }
+  end
+
+  # Add a constant for each register
+  REGISTERS.each do |regsym,regnum|
+    const_set regsym, regsym
+  end
+
+private
+  
+  def resolve_labels
+    label_addrs = {}
+
+    addr = 0
+    @stmts.each do |stmt|
+      if stmt.is_a? Label
+        label_addrs[stmt.name] = addr
+      end
+      addr += stmt.length
+    end
+
+    @relocations.each do |x|
+      addr = label_addrs[x.name] or ::Kernel.raise "undefined label #{x.name.inspect}"
+      x.resolve addr
+    end
+  end
+
+  # Shorter notation for values
+  def parse_value x
+    case x
+    when Value, ::NilClass
+      x
+    when ::Array
+      x1, x2, = x
+      if x1.is_a? ::Symbol and x2 == nil
+        # [reg]
+        regmem x1
+      elsif x1.is_a? ::Symbol and x2.is_a? ::Integer
+        # [reg, imm]
+        iregmem x1, x2
+      elsif x1.is_a? ::Integer
+        # [imm]
+        imem x1
+      else
+        ::Kernel.fail "invalid memory access syntax"
+      end
+    when ::Symbol
+      # register
+      reg x
+    when ::String
+      # label
+      l x
+    when ::Integer
+      # immediate
+      imm x
+    else
+      ::Kernel.raise "unexpected value class #{x.class}"
+    end
+  end
+end
+
+end

data/lib/scasm/isa.rb

@@ -0,0 +1,37 @@
+module SCASM
+
+BASIC_OPCODES = {
+  :ext => 0x0,
+  :set => 0x1,
+  :add => 0x2,
+  :sub => 0x3,
+  :mul => 0x4,
+  :div => 0x5,
+  :mod => 0x6,
+  :shl => 0x7,
+  :shr => 0x8,
+  :and_ => 0x9, # "and" is a reserved word
+  :bor => 0xa,
+  :xor => 0xb,
+  :ife => 0xc,
+  :ifn => 0xd,
+  :ifg => 0xe,
+  :ifb => 0xf,
+}
+
+EXTENDED_OPCODES = {
+  :jsr => 0x01,
+}
+
+REGISTERS = {
+  :A => 0,
+  :B => 1,
+  :C => 2,
+  :X => 3,
+  :Y => 4,
+  :Z => 5,
+  :I => 6,
+  :J => 7,
+}
+
+end

data/lib/scasm/statement.rb

@@ -0,0 +1,74 @@
+require 'stringio'
+
+module SCASM
+
+class Statement
+  attr_accessor :addr
+
+  def assemble io
+    fail 'unimplemented'
+  end
+
+  def to_s
+    fail 'unimplemented'
+  end
+
+  # XXX HACK
+  def length
+    io = StringIO.new
+    assemble io
+    io.length/2
+  end
+end
+
+class Instruction < Statement
+  attr_reader :opsym, :a, :b
+  attr_writer :b # for disassembler
+
+  def initialize opsym, a, b
+    @opsym = opsym
+    @a = a
+    @b = b
+  end
+
+  def assemble io
+    if opcode = BASIC_OPCODES[@opsym]
+      code_a, imm_a = @a.assemble
+      code_b, imm_b = @b.assemble
+      code = opcode | (code_a<<4) | (code_b<<10)
+      io.write [code, imm_a, imm_b].compact.pack('v*')
+    elsif opcode = EXTENDED_OPCODES[@opsym]
+      code_a, imm_a = @a.assemble
+      fail unless @b == nil
+      code = (opcode<<4) | (code_a<<10)
+      io.write [code, imm_a].compact.pack('v*')
+    else
+      fail "unknown opsym #{@opsym.inspect}"
+    end
+  end
+
+  def to_s
+    "%s %s, %s" % [@opsym, @a, @b]
+  end
+end
+
+class Data < Statement
+end
+
+class Label < Statement
+  attr_reader :name
+
+  def initialize name
+    @name = name
+  end
+
+  def assemble io
+    # nop
+  end
+
+  def to_s
+    "label #{@name.inspect}"
+  end
+end
+
+end

data/lib/scasm/value.rb

@@ -0,0 +1,178 @@
+module SCASM
+
+class Value
+  def assemble
+    fail "not implemented"
+  end
+
+  def to_s
+    fail "not implemented"
+  end
+end
+
+class Register < Value
+  def initialize regsym
+    fail "invalid register #{regsym.inspect}" unless REGISTERS.member? regsym
+    @regsym = regsym
+  end
+
+  def assemble
+    return REGISTERS[@regsym]
+  end
+
+  def to_s
+    "reg(#@regsym)"
+  end
+end
+
+class RegisterMemory < Value
+  def initialize regsym
+    fail "invalid register #{regsym.inspect}" unless REGISTERS.member? regsym
+    @regsym = regsym
+  end
+
+  def assemble
+    return 0x08 + REGISTERS[@regsym]
+  end
+
+  def to_s
+    "regmem(#@regsym)"
+  end
+end
+
+class OffsetRegisterMemory < Value
+  def initialize regsym, imm
+    fail "invalid register #{regsym.inspect}" unless REGISTERS.member? regsym
+    @regsym = regsym
+    @imm = imm
+  end
+
+  def assemble
+    return (0x10 + REGISTERS[@regsym]), @imm
+  end
+
+  def to_s
+    "iregmem(#@regsym, #@imm)"
+  end
+end
+
+class Pop < Value
+  def assemble
+    return 0x18
+  end
+
+  def to_s
+    'pop'
+  end
+end
+
+class Peek < Value
+  def assemble
+    return 0x19
+  end
+
+  def to_s
+    'peek'
+  end
+end
+
+class Push < Value
+  def assemble
+    return 0x1a
+  end
+
+  def to_s
+    'push'
+  end
+end
+
+class SP < Value
+  def assemble
+    return 0x1b
+  end
+
+  def to_s
+    'sp'
+  end
+end
+
+class PC < Value
+  def assemble
+    return 0x1c
+  end
+
+  def to_s
+    'pc'
+  end
+end
+
+class O < Value
+  def assemble
+    return 0x1d
+  end
+
+  def to_s
+    'o'
+  end
+end
+
+class ImmediateMemory < Value
+  def initialize imm
+    @imm = imm
+  end
+
+  def assemble
+    return 0x1e, @imm
+  end
+
+  def to_s
+    "imem(#@imm)"
+  end
+end
+
+class Immediate < Value
+  def initialize imm
+    @imm = imm
+  end
+
+  def assemble
+    if @imm <= 0x1f
+      return 0x20 + @imm
+    else
+      return 0x1f, @imm
+    end
+  end
+
+  def to_s
+    "imm(#@imm)"
+  end
+
+  def value
+    @imm
+  end
+end
+
+class ImmediateLabel < Value
+  attr_reader :name
+
+  def initialize name
+    @name = name
+    @imm = nil
+  end
+
+  def resolve imm
+    fail if @imm
+    @imm = imm
+  end
+
+  def assemble
+    #fail unless @imm
+    return 0x1f, (@imm||0) # HACK
+  end
+
+  def to_s
+    "l(#{@name.inspect})"
+  end
+end
+
+end

data/lib/scasm/version.rb

@@ -0,0 +1,3 @@
+module Scasm
+  VERSION = "0.0.1"
+end

data/scasm.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/scasm/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Rich Lane"]
+  gem.email         = ["rlane@club.cc.cmu.edu"]
+  gem.description   = %q{}
+  gem.summary       = %q{A Ruby DSL for DCPU-16 assembly code}
+  gem.homepage      = "https://github.com/rlane/scasm"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "scasm"
+  gem.require_paths = ["lib"]
+  gem.version       = Scasm::VERSION
+
+  gem.add_dependency 'trollop'
+end

data/test/foo.scasm

@@ -0,0 +1,14 @@
+set reg(A), reg(B)
+add reg(A), regmem(C)
+sub reg(A), iregmem(X, 1)
+div reg(A), pop
+mod reg(A), peek
+shl reg(A), push
+shr reg(A), sp
+and_ reg(A), pc
+bor reg(A), o
+xor reg(A), imem(5)
+ife reg(A), imm(1)
+ifn reg(A), imm(32)
+ifg reg(I), reg(Y)
+ifb reg(J), reg(Z)

data/test/test_assembler.rb

@@ -0,0 +1,133 @@
+require 'test/unit'
+require 'scasm/assembler'
+
+class AssemblerTest < Test::Unit::TestCase
+  def setup
+    @expected = nil
+  end
+
+  def teardown
+  end
+
+  def expect words
+    @expected = words
+  end
+
+  def check code
+    as = SCASM::Assembler.new
+    as.eval code
+    result = as.assemble
+    result_words = result.unpack('v*')
+    assert_equal @expected, result_words
+  end
+
+  def test_empty
+    expect []
+    check ''
+  end
+
+  def test_reg
+    expect [
+      0x0401,
+      0x0c21,
+      0x1441,
+      0x1c61,
+    ]
+
+    check <<-EOS
+      set reg(A), reg(B)
+      set reg(C), reg(X)
+      set reg(Y), reg(Z)
+      set reg(I), reg(J)
+    EOS
+
+    check <<-EOS
+      set A, B
+      set C, X
+      set Y, Z
+      set I, J
+    EOS
+  end
+
+  def test_regmem
+    expect [0x0cb1]
+    check "set regmem(X), reg(X)"
+    check "set [X], X"
+  end
+
+  def test_iregmem
+    expect [0x0d31, 0x002a]
+    check 'set iregmem(X, 42), reg(X)'
+    check 'set [X,42], X'
+  end
+
+  def test_misc
+    expect [0x6181]
+    check 'set pop, pop'
+
+    expect [0x6591]
+    check 'set peek, peek'
+
+    expect [0x69a1]
+    check 'set push, push'
+
+    expect [0x6db1]
+    check 'set sp, sp'
+
+    expect [0x71c1]
+    check 'set pc, pc'
+
+    expect [0x75d1]
+    check 'set o, o'
+  end
+
+  def test_imem
+    expect [0x7801, 0x1000]
+    check 'set reg(A), imem(0x1000)'
+    check 'set A, [0x1000]'
+  end
+
+  def test_imm
+    expect [0xfc01]
+    check "set reg(A), imm(31)"
+    check "set A, 31"
+
+    expect [0x7c01, 0x0020]
+    check "set reg(A), imm(32)"
+    check "set A, 32"
+
+    expect [0x7df1, 0xffff, 0x0020]
+    check "set imm(65535), imm(32)"
+    check "set 65535, 32"
+  end
+
+  def test_label
+    expect [
+      0xb401,
+      0x8402,
+      0x7dc1, 0x0001,
+    ]
+
+    check <<-EOS
+      set reg(A), imm(13)
+      label 'loop'
+      add reg(A), imm(1)
+      set pc, l('loop')
+    EOS
+
+    check <<-EOS
+      set A, 13
+      label 'loop'
+      add A, 1
+      set pc, 'loop'
+    EOS
+  end
+
+  def test_ext_insts
+    expect [0x0010]
+    check 'jsr A'
+    
+    expect [0x7c10, 0x0020]
+    check 'jsr 32'
+  end
+end

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification
+name: scasm
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Rich Lane
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: trollop
+  requirement: &15992680 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *15992680
+description: ''
+email:
+- rlane@club.cc.cmu.edu
+executables:
+- scasm
+- scasm-disassemble
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/scasm
+- bin/scasm-disassemble
+- examples/spec.scasm
+- lib/scasm/assembler.rb
+- lib/scasm/isa.rb
+- lib/scasm/statement.rb
+- lib/scasm/value.rb
+- lib/scasm/version.rb
+- scasm.gemspec
+- test/foo.scasm
+- test/test_assembler.rb
+homepage: https://github.com/rlane/scasm
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.17
+signing_key: 
+specification_version: 3
+summary: A Ruby DSL for DCPU-16 assembly code
+test_files:
+- test/foo.scasm
+- test/test_assembler.rb