lignite 0.5.0 → 0.6.0

data/lib/lignite/condition.rb

@@ -0,0 +1,116 @@
+module Lignite
+  # Compile a conditional jump forward or backward
+  class Condition
+    # Call that instruction of the compiler
+    # that jumps by *offset* according to the condition that we implement
+    def cond_jump(_compiler, _offset)
+      raise ScriptError, "subclasses must override this"
+    end
+
+    # Negation of this condition.
+    # An `if(cond){ body }` becomes roughly `cond.not.jump_forward(body.size); body`
+    def not
+      raise ScriptError, "subclasses must override this"
+    end
+
+    def jump_forward(compiler, body_size)
+      cond_jump(compiler, body_size)
+    end
+
+    def jump_back(compiler, body_size, self_size = nil)
+      if self_size.nil?
+        fake = compiler.clone_context
+        jump_back(fake, body_size, 0)
+        self_size = fake.bytes.bytesize
+      end
+
+      cond_jump(compiler, - (body_size + self_size))
+    end
+  end
+
+  # A condition that is always true
+  class Always < Condition
+    def not
+      Never.new
+    end
+
+    def cond_jump(compiler, offset)
+      compiler.jr(JumpOffset.new(offset))
+    end
+  end
+
+  # A condition that is never true
+  class Never < Condition
+    def not
+      Always.new
+    end
+
+    def cond_jump(compiler, _offset)
+      # Never jump: do a jump of size 0
+      # but it must be a jump because code size calculations need that
+      compiler.jr(JumpOffset.new(0))
+    end
+  end
+
+  # Less-than (32 bit)
+  class Lt32 < Condition
+    def initialize(a, b)
+      @a = a
+      @b = b
+    end
+
+    def not
+      Gteq32.new(@a, @b)
+    end
+
+    def cond_jump(compiler, offset)
+      compiler.jr_lt32(@a, @b, JumpOffset.new(offset))
+    end
+  end
+
+  # Greater-than-or-equal (32 bit)
+  class Gteq32 < Condition
+    def initialize(a, b)
+      @a = a
+      @b = b
+    end
+
+    def not
+      Lt32.new(@a, @b)
+    end
+
+    def cond_jump(compiler, offset)
+      compiler.jr_gteq32(@a, @b, JumpOffset.new(offset))
+    end
+  end
+
+  # Test a boolean flag
+  class Flag < Condition
+    def initialize(f)
+      @f = f
+    end
+
+    def not
+      NotFlag.new(@f)
+    end
+
+    def cond_jump(compiler, offset)
+      compiler.jr_true(@f, JumpOffset.new(offset))
+    end
+  end
+
+  # Test a negated boolean flag
+  class NotFlag < Condition
+    def initialize(f)
+      @f = f
+    end
+
+    def not
+      Flag.new(@f)
+    end
+
+    def cond_jump(compiler, offset)
+      compiler.jr_false(@f, JumpOffset.new(offset))
+    end
+  end
+end

data/lib/lignite/connection.rb

@@ -5,18 +5,22 @@ module Lignite
   class Connection
     include Bytes
     include Logger
+    extend Logger
 
     # @return [Connection] Try a {Usb} connection first, then a {Bluetooth} one.
     def self.create
       @c ||= Replay.new(ENV["LIGNITE_REPLAY"]) if ENV["LIGNITE_REPLAY"]
 
       @c ||= begin
+               logger.debug "Connection: trying USB"
                Usb.new
              rescue NoUsbDevice
+               logger.debug "Connection: trying BT"
                Bluetooth.new
              end
 
       @c = Tap.new(@c, ENV["LIGNITE_TAP"]) if ENV["LIGNITE_TAP"]
+      logger.debug "Connection: #{@c.inspect}"
       @c
     end
 

data/lib/lignite/ev3_ops.rb

@@ -140,7 +140,7 @@ module Lignite
 
       bytes = u8(0x09)
       bytes += param_simple(objid)
-      bytes += param_multiple(*parameters)
+      bytes += param_n_multiple(*parameters)
       logger.debug "returning bytecode: #{bytes.inspect}"
       bytes
     end
@@ -862,7 +862,23 @@ module Lignite
       bytes
     end
 
-    # Could not define init_bytes: Unhandled param type PARVALUES
+    # Move LENGTH number of DATA8 from BYTE STREAM to memory DESTINATION START
+    # @param destination [PAR8] (out) First element in DATA8 array to be initiated
+    # @param length [PAR32] (in) Number of elements to initiate
+    # @param source [PARVALUES] (in) First element to initiate DATA8 array with
+    def init_bytes(destination, length, *source)
+      logger.debug do
+        args = [destination, length, *source]
+        "called init_bytes with #{args.inspect}"
+      end
+
+      bytes = u8(0x2F)
+      bytes += param_simple(destination)
+      bytes += param_simple(length)
+      bytes += param_multiple(*source)
+      logger.debug "returning bytecode: #{bytes.inspect}"
+      bytes
+    end
 
     # Move 8 bit value from SOURCE to DESTINATION
     # @param source [PAR8] (in)
@@ -6045,7 +6061,7 @@ module Lignite
       bytes += param_simple(no)
       bytes += param_simple(type)
       bytes += param_simple(mode)
-      bytes += param_multiple(*values)
+      bytes += param_n_multiple(*values)
       logger.debug "returning bytecode: #{bytes.inspect}"
       bytes
     end
@@ -6070,7 +6086,7 @@ module Lignite
       bytes += param_simple(no)
       bytes += param_simple(type)
       bytes += param_simple(mode)
-      bytes += param_multiple(*values)
+      bytes += param_n_multiple(*values)
       logger.debug "returning bytecode: #{bytes.inspect}"
       bytes
     end
@@ -6095,7 +6111,7 @@ module Lignite
       bytes += param_simple(no)
       bytes += param_simple(type)
       bytes += param_simple(mode)
-      bytes += param_multiple(*values)
+      bytes += param_n_multiple(*values)
       logger.debug "returning bytecode: #{bytes.inspect}"
       bytes
     end
@@ -6277,7 +6293,7 @@ module Lignite
       bytes += param_simple(type)
       bytes += param_simple(mode)
       bytes += param_simple(format)
-      bytes += param_multiple(*values)
+      bytes += param_n_multiple(*values)
       logger.debug "returning bytecode: #{bytes.inspect}"
       bytes
     end
@@ -7559,19 +7575,95 @@ module Lignite
     #
     Lignite::INIT8 = 8
 
-    # Could not define array_init8: Unhandled param type PARVALUES
+    #
+    # @param handle [PAR16] (in) Array handle
+    # @param index [PAR32] (in) Index to element to write
+    # @param elements [PAR32] (in) Number of elements to write
+    # @param values [PARVALUES] (in)
+    def array_init8(handle, index, elements, *values)
+      logger.debug do
+        args = [handle, index, elements, *values]
+        "called array_init8 with #{args.inspect}"
+      end
+
+      bytes = u8(0xC1)
+      bytes += param_simple(8)
+      bytes += param_simple(handle)
+      bytes += param_simple(index)
+      bytes += param_simple(elements)
+      bytes += param_multiple(*values)
+      logger.debug "returning bytecode: #{bytes.inspect}"
+      bytes
+    end
     #
     Lignite::INIT16 = 9
 
-    # Could not define array_init16: Unhandled param type PARVALUES
+    #
+    # @param handle [PAR16] (in) Array handle
+    # @param index [PAR32] (in) Index to element to write
+    # @param elements [PAR32] (in) Number of elements to write
+    # @param values [PARVALUES] (in)
+    def array_init16(handle, index, elements, *values)
+      logger.debug do
+        args = [handle, index, elements, *values]
+        "called array_init16 with #{args.inspect}"
+      end
+
+      bytes = u8(0xC1)
+      bytes += param_simple(9)
+      bytes += param_simple(handle)
+      bytes += param_simple(index)
+      bytes += param_simple(elements)
+      bytes += param_multiple(*values)
+      logger.debug "returning bytecode: #{bytes.inspect}"
+      bytes
+    end
     #
     Lignite::INIT32 = 10
 
-    # Could not define array_init32: Unhandled param type PARVALUES
+    #
+    # @param handle [PAR16] (in) Array handle
+    # @param index [PAR32] (in) Index to element to write
+    # @param elements [PAR32] (in) Number of elements to write
+    # @param values [PARVALUES] (in)
+    def array_init32(handle, index, elements, *values)
+      logger.debug do
+        args = [handle, index, elements, *values]
+        "called array_init32 with #{args.inspect}"
+      end
+
+      bytes = u8(0xC1)
+      bytes += param_simple(10)
+      bytes += param_simple(handle)
+      bytes += param_simple(index)
+      bytes += param_simple(elements)
+      bytes += param_multiple(*values)
+      logger.debug "returning bytecode: #{bytes.inspect}"
+      bytes
+    end
     #
     Lignite::INITF = 11
 
-    # Could not define array_initf: Unhandled param type PARVALUES
+    #
+    # @param handle [PAR16] (in) Array handle
+    # @param index [PAR32] (in) Index to element to write
+    # @param elements [PAR32] (in) Number of elements to write
+    # @param values [PARVALUES] (in)
+    def array_initf(handle, index, elements, *values)
+      logger.debug do
+        args = [handle, index, elements, *values]
+        "called array_initf with #{args.inspect}"
+      end
+
+      bytes = u8(0xC1)
+      bytes += param_simple(11)
+      bytes += param_simple(handle)
+      bytes += param_simple(index)
+      bytes += param_simple(elements)
+      bytes += param_multiple(*values)
+      logger.debug "returning bytecode: #{bytes.inspect}"
+      bytes
+    end
     #
     Lignite::SIZE = 12
 
@@ -8924,7 +9016,7 @@ module Lignite
       bytes += param_simple(hardware)
       bytes += param_simple(boxname)
       bytes += param_simple(type)
-      bytes += param_multiple(*values)
+      bytes += param_n_multiple(*values)
       logger.debug "returning bytecode: #{bytes.inspect}"
       bytes
     end
@@ -8942,7 +9034,7 @@ module Lignite
       bytes = u8(0xDA)
       bytes += param_simple(no)
       bytes += param_simple(length)
-      bytes += param_multiple(*values)
+      bytes += param_n_multiple(*values)
       logger.debug "returning bytecode: #{bytes.inspect}"
       bytes
     end

data/lib/lignite/ev3_tool.rb

@@ -32,14 +32,15 @@ module Lignite
     desc "download BRICK_FILENAME [LOCAL_FILENAME]", "download a file"
     map "dl" => "download"
     def download(brick_filename, local_filename = nil)
+      chunk_size = 1000 # 2000 stalls, 4096 goes out of sync in our code
       local_filename ||= File.basename(brick_filename)
-      fsize, handle, data = sc.begin_upload(4096, brick_filename)
+      fsize, handle, data = sc.begin_upload(chunk_size, brick_filename)
       File.open(local_filename, "w") do |f|
         loop do
           f.write(data)
           fsize -= data.bytesize
           break if fsize.zero?
-          handle, data = sc.continue_upload(handle, 4096)
+          handle, data = sc.continue_upload(handle, chunk_size)
         end
       end
     end
@@ -55,6 +56,12 @@ module Lignite
       puts raw_ls(name)
     end
 
+    desc "asm RUBYFILE RBFFILE", "assemble RUBYFILE to RBFFILE"
+    def asm(ruby_fn, rbf_fn)
+      a = Assembler.new
+      a.assemble(ruby_fn, rbf_fn)
+    end
+
     no_commands do
       def raw_list_files(name)
         name ||= EV3TOOL_HOME

data/lib/lignite/jump_offset.rb

@@ -0,0 +1,18 @@
+module Lignite
+  # A specialized Integer.
+  # When compiling jumps, the jump instruction itself must have a constant size
+  # so this class is special-cased in {OpCompiler#param_simple}.
+  class JumpOffset
+    # @return [Integer]
+    attr_reader :value
+
+    def size
+      2
+    end
+
+    def initialize(v)
+      raise "Jumping too far: #{value}" if v.abs > 32767
+      @value = v
+    end
+  end
+end

data/lib/lignite/motors.rb

@@ -13,9 +13,18 @@ module Lignite
 
     # 0x02 | 0x04 | 0x08 -> [1, 2, 3]
     def nos_as_indices
-      [0, 1, 2, 3].find_all do |n|
+      r = [0, 1, 2, 3].find_all do |n|
         (nos & (1 << n)) != 0
       end
+      r
+    end
+
+    # 0x02 | 0x04 | 0x08 -> [0x02, 0x04, 0x08]
+    def nos_as_bits
+      r = [1, 2, 4, 8].find_all do |n|
+        (nos & n) != 0
+      end
+      r
     end
 
     def initialize(layer, nos, dc = Lignite::DirectCommands.new)
@@ -85,17 +94,17 @@ module Lignite
     end
 
     # ATTR running?
+    # @return [Boolean] true if busy/running
     def test
       layer = @layer
-      nos_as_indices.map do |no|
-        busy = dc.with_reply do
-          data8 :busy
-          block do
-            output_test(layer, no, :busy)
-          end
+      nos = @nos
+      busy = dc.with_reply do
+        data8 :busy
+        block do
+          output_test(layer, nos, :busy)
         end
-        busy
       end
+      busy != 0
     end
 
     # which commands are affected? not output_start they say

data/lib/lignite/op_compiler.rb

@@ -43,22 +43,29 @@ module Lignite
 
     PRIMPAR_LABEL      = 0x20
 
-    def make_lcn(n, bytes)
-      case bytes
-      when 0
-        [n & PRIMPAR_VALUE]
-      when 1
-        [PRIMPAR_LONG | PRIMPAR_1_BYTE, n & 0xff]
-      when 2
-        [PRIMPAR_LONG | PRIMPAR_2_BYTES, n & 0xff, (n >> 8) & 0xff]
-      else
-        [PRIMPAR_LONG | PRIMPAR_4_BYTES,
-         n & 0xff, (n >> 8) & 0xff, (n >> 16) & 0xff, (n >> 24) & 0xff]
+    # @param n [Integer] value to encode
+    # @param next_size [Integer] how many bytes follow the initial opcode
+    # @return [ByteString]
+    def numeric_literal_with_size(n, next_size)
+      bytes = case next_size
+              when 0
+                [n & PRIMPAR_VALUE]
+              when 1
+                [PRIMPAR_LONG | PRIMPAR_1_BYTE, n & 0xff]
+              when 2
+                [PRIMPAR_LONG | PRIMPAR_2_BYTES, n & 0xff, (n >> 8) & 0xff]
+              else
+                [PRIMPAR_LONG | PRIMPAR_4_BYTES,
+                 n & 0xff, (n >> 8) & 0xff, (n >> 16) & 0xff, (n >> 24) & 0xff]
       end
+      bytes.map(&:chr).join("")
     end
 
-    def make_lc(n, bytes = nil)
-      bytes ||= if (-31..31).cover? n
+    # @param n [Integer] value to encode
+    # @param next_size [Integer] how many bytes follow the initial opcode
+    # @return [ByteString]
+    def numeric_literal(n, next_size = nil)
+      next_size ||= if (-31..31).cover? n
         0
       elsif (-127..127).cover? n
         1
@@ -67,12 +74,13 @@ module Lignite
       else
         4
       end
-      make_lcn(n, bytes)
+      numeric_literal_with_size(n, next_size)
     end
 
+    # @return [ByteString]
     def make_v(n, local_or_global)
       vartag = PRIMPAR_VARIABEL | local_or_global
-      if (0..31).cover? n
+      bytes = if (0..31).cover? n
         [vartag | (n & PRIMPAR_VALUE)]
       elsif (0..255).cover? n
         [vartag | PRIMPAR_LONG | PRIMPAR_1_BYTE, n & 0xff]
@@ -82,10 +90,12 @@ module Lignite
         [vartag | PRIMPAR_LONG | PRIMPAR_4_BYTES,
          n & 0xff, (n >> 8) & 0xff, (n >> 16) & 0xff, (n >> 24) & 0xff]
       end
+      bytes.map(&:chr).join("")
     end
 
     # Reference a variable.
     # (For declaring, see {VariableDeclarer}.)
+    # @return [ByteString]
     def make_var(sym)
       raise "No variables declared, cannot process symbols" if @locals.nil? && @globals.nil?
       if @locals.key?(sym)
@@ -99,27 +109,43 @@ module Lignite
       end
     end
 
+    # @return [ByteString]
+    def param_n_multiple(*args)
+      u8(args.size) + param_multiple(*args)
+    end
+
     # @return [ByteString]
     def param_multiple(*args)
-      u8(args.size) + args.map { |a| param_simple(a) }.join("")
+      args.map { |a| param_simple(a) }.join("")
     end
 
     # @return [ByteString]
-    def param_simple(x)
+    def param_simple_numeric(x)
       case x
       when Integer
-        make_lc(x).map(&:chr).join("")
-      when Complex
-        # a Complex number:
-        #   #real: just like an Integer above, but
-        #   #imag tells how many bytes to use for it
-        make_lc(x.real, x.imag).map(&:chr).join("")
-      when String
-        u8(0x80) + x + u8(0x00)
+        numeric_literal(x)
       when Float
         u8(0x83) + f32(x)
+      else
+        raise ArgumentError, "Unexpected type: #{x.class}"
+      end
+    end
+
+    # @return [ByteString]
+    def param_simple(x)
+      case x
+      when Numeric
+        param_simple_numeric(x)
+      when JumpOffset
+        numeric_literal(x.value, x.size)
+      when String
+        u8(0x80) + x + u8(0x00)
+      when true
+        param_simple(1)
+      when false
+        param_simple(0)
       when Symbol
-        make_var(x).map(&:chr).join("")
+        make_var(x)
       else
         raise ArgumentError, "Unexpected type: #{x.class}"
       end