microruby 0.0.1

data/bin/microruby

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+require 'microruby'
+
+cmd = ARGV.shift
+abort "Missing command" if cmd.nil?
+
+case cmd.downcase.to_sym
+  when :compile
+    path = ARGV.shift
+    abort "Missing file path" if path.nil?
+    MicroRuby.compile_file(path)
+  else
+    abort "Unknown command: #{cmd}"
+end
+
+
+

data/lib/microruby.rb

@@ -0,0 +1,26 @@
+require_relative "microruby/bytecode"
+
+class MicroRuby
+
+  def self.compile_file(path)
+    raise "File not found: #{path}" unless File.file?(path)
+
+    dir = File.dirname(path)
+    filename = File.basename(path, ".rb")
+
+    bc = compile File.read(path)
+
+    target_path = "#{dir}/#{filename}.mrbc"
+    File.open(target_path, "w") do |f|
+      f.write(bc)
+      puts "Compiled to #{target_path}"
+    end
+
+  end
+
+  def self.compile(code)
+    seq = RubyVM::InstructionSequence.compile(code).to_a
+    Bytecode.encode(seq).to_bin
+  end
+
+end

data/lib/microruby/bytecode.rb

@@ -0,0 +1,156 @@
+
+require_relative "instruction_set"
+
+class Bytecode
+
+  TYPES = {
+      :null     => 0,
+      :int8     => 1,
+      :int16    => 2,
+      :int32    => 3,
+      :uint8    => 4,
+      :uint16   => 5,
+      :uint32   => 6,
+      :float    => 7,
+      :double   => 8,
+      :bool     => 9,
+      :string   => 10,
+      :array    => 11
+  }
+
+  attr_accessor :arg_size
+  attr_accessor :local_size
+  attr_accessor :stack_max
+  attr_accessor :inst_seq
+  attr_accessor :bytes
+
+
+  def initialize
+    @bytes = []
+  end
+
+
+  def self.encode(sequence)
+    bc = Bytecode.new
+    bc.arg_size = sequence[4][:arg_size]
+    bc.local_size = sequence[4][:local_size]
+    bc.stack_max = sequence[4][:stack_max]
+    # TODO: preserve line numbers (optionally)
+    instructions = sequence[13].find_all {|i| i.is_a?(Array)}
+    instructions.each do |i|
+      bc.bytes += encode_instruction(i)
+    end
+    bc
+  end
+
+
+  def to_bin
+    self.bytes.pack("C*")
+  end
+
+
+  private
+
+
+  def self.encode_instruction(instruction)
+
+    inst_bytes = []
+    opcode = instruction[0]
+
+    inst_def = INSTRUCTIONS[opcode]
+
+    if inst_def
+
+      inst_bytes << inst_def[0]
+
+      if [:putobject, :putstring].include?(opcode)
+        # literal object - requires special encoding
+        val = instruction[1]
+        inst_bytes += encode_object(val)
+      elsif [:trace, :setlocal, :getlocal, :opt_plus, :opt_minus, :opt_mult, :opt_div].include?(opcode)
+        # simple operand opcodes
+        inst_bytes += instruction[1..-1]
+      elsif [:nop, :dup, :leave].include?(opcode)
+        # zero operand opcodes
+      end
+
+    else
+      raise "Unexpected opcode (#{opcode})"
+    end
+
+    inst_bytes
+
+  end
+
+
+  def self.encode_object(val)
+    val_bytes = []
+
+    case val
+      when NilClass
+        val_bytes << TYPES[:null]
+        # empty value
+
+      when FalseClass
+        val_bytes << TYPES[:bool]
+        val_bytes << 0
+      when TrueClass
+        val_bytes << TYPES[:bool]
+        val_bytes << 1
+
+      when Fixnum
+        if val >= 0
+          # unsigned
+          if val < 2**8
+            val_bytes << TYPES[:uint8]
+            val_bytes += [val].pack("C").unpack("C*")
+          elsif val < 2**16
+            val_bytes << TYPES[:uint16]
+            val_bytes += [val].pack("S>").unpack("C*")
+          elsif val < 2**32
+            val_bytes << TYPES[:uint32]
+            val_bytes += [val].pack("L>").unpack("C*")
+          else
+            raise "64 bit integers not supported... yet."
+          end
+        else
+          # signed
+          if val.abs < 2**7
+            val_bytes << TYPES[:int8]
+            val_bytes += [val].pack("c").unpack("C*")
+          elsif val.abs < 2**15
+            val_bytes << TYPES[:int16]
+            val_bytes += [val].pack("s>").unpack("C*")
+          elsif val.abs < 2**31
+            val_bytes << TYPES[:int32]
+            val_bytes += [val].pack("l>").unpack("C*")
+          else
+            raise "64 bit integers not supported... yet."
+          end
+        end
+
+      when Float
+        # TODO: add single-precision support
+        val_bytes << TYPES[:double]
+        val_bytes += [val].pack("G").unpack("C*")
+
+      when String
+        # TODO: support for strings larger than 255 bytes
+        val_bytes << TYPES[:string]
+        val_bytes << val.length
+        val_bytes += val.bytes.to_a
+
+      when Array
+        # TODO: support for arrays larger than 255 bytes
+        val_bytes << TYPES[:array]
+        val_bytes << val.length
+        val.each do |v|
+          val_bytes += encode_object(v)
+        end
+    end
+
+    val_bytes
+  end
+
+
+end

data/lib/microruby/instruction_set.rb

@@ -0,0 +1,22 @@
+
+class Bytecode
+
+  INSTRUCTIONS = {
+      # opcode key => [opcode value, operand count]
+      :nop          => [0, 0],
+      :getlocal     => [1, 1],
+      :setlocal     => [2, 1],
+      :putobject    => [17, 1],
+      :putstring    => [18, 1],
+      :dup          => [31, 0],
+      :trace        => [43, 1],
+      :leave        => [48, 0],
+      :opt_plus     => [59, 1],
+      :opt_minus    => [60, 1],
+      :opt_mult     => [61, 1],
+      :opt_div      => [62, 1],
+      :newarray     => [22, 1],
+      :expandarray  => [24, 1]
+  }
+
+end

metadata

@@ -0,0 +1,57 @@
+--- !ruby/object:Gem::Specification 
+name: microruby
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Mark Lyons
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-12-03 00:00:00 Z
+dependencies: []
+
+description: MicroRuby compiles Ruby to compact bytecode for execution on embedded microcontrollers.
+email: mark@microruby.com
+executables: 
+- microruby
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/microruby/bytecode.rb
+- lib/microruby/instruction_set.rb
+- lib/microruby.rb
+- bin/microruby
+homepage: http://microruby.com
+licenses: []
+
+post_install_message: "Warning: This is an alpha release! Opcode support is limited."
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: MicroRuby compiler
+test_files: []
+