lignite 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ce4cca8022a372bfd1ee229725d3a538376c6d54
-  data.tar.gz: 7957e5d6aa35cf8551752d3a324f2cef141bd466
+  metadata.gz: b479941700df01dc46fa526001f014920e528ad3
+  data.tar.gz: 00d321b86f44d215261ad1bfbe1d88158c62f3e5
 SHA512:
-  metadata.gz: fdf692daad988853107d65e5ebf31da38e0c6bd5d4bf6819e9b0e8e8ca5a140fe95bdf51d32db8c556f1e07298f3671aa389e8c994ff2293f087ae1c237cf1a7
-  data.tar.gz: c5a98aedfde6259e69cdadbed737ee7fa1eed93d505a42489ee99a2a64ff8dcadabbdd8c1f4d7bca0a7cb004fc18caaa4cc33f61275153789a63386404896d18
+  metadata.gz: 1c9836db38d2bc17c096e3e73e1e26f54d6701f8be6cec34d0450dd79a6752afabd9db1b20087c7839df612799b5e3c02a5450740576759eaa75e651fc0b6aa4
+  data.tar.gz: fb64659ace34de87e7b133e704eb7577b07aadcd20e80868cc02871c7e5f4725d69b197d319821152b20ef42cf721fab9ef471832384e6a776e228cc504f0634

data/.rubocop.yml

@@ -20,6 +20,11 @@ Performance/RedundantBlockCall:
 Style/SymbolArray:
   Enabled: false
 
+# self.sleep is Ev3Ops#sleep, sleep is Kernel#sleep
+Style/RedundantSelf:
+  Exclude:
+    - spec/data/*.rb
+
 Metrics/BlockLength:
   Exclude:
     - lignite.gemspec

data/NEWS.md

@@ -2,6 +2,14 @@
 
 ## unreleased
 
+## 0.5.0, 2018-03-05
+
+- Ev3Ops: added missing array_* ops (with PARV in the signature).
+- loop_while added, with a Condition prototype: Lt32.
+- Corrected the variable argument calling convention (PARNO).
+  Before, it was necessary to manually add a parameter specifying the number
+  of the remaining parameters. Now it is automatic.
+
 ## 0.4.0, 2018-03-04
 
 - Generate Ev3Ops ahead of time, enabling YARD docs for them,

data/VERSION

@@ -1 +1 @@
-0.4.0
+0.5.0

data/examples/light-sensor.rb

@@ -6,14 +6,13 @@ dc = Lignite::DirectCommands.new
 # see 28/31 of Comm dev kit, read light sensor value on port 3
 LAYER0 = 0
 MODE = 0
-count = 1
 pct = dc.with_reply do
   # global vars
   dataf :light
 
   # TODO: make the block optional if there are no locals. or #with_locals
   block do
-    input_device_ready_si(LAYER0, Lignite::PORT_3, Lignite::TYPE_KEEP, MODE, count, :light)
+    input_device_ready_si(LAYER0, Lignite::PORT_3, Lignite::TYPE_KEEP, MODE, :light)
   end
 end
 puts "Light sensor percentage: #{pct}"

data/lib/lignite/assembler.rb

@@ -1,11 +1,24 @@
+require "lignite/rbf_declarer"
 require "lignite/variables"
 
 module Lignite
   # Assemble a complete RBF program file.
+  #
+  # The compilation has two passes:
+  #
+  # 1. pass1, Declaration
+  # 2. pass2, Resolution
+  #
+  # After P1, the instruction sequence is iterated. If an item responds to
+  # :pass2, it is replaced by the result of that call.
+  # After pass2 we have a sequence of ByteStrings which are just concatenated
+  #
+  # No, pass1, gather names, pass2 do all the rest
   class Assembler
     include Bytes
     include Logger
 
+    HEADER_SIZE = 16
     SIGNATURE = "LEGO".freeze
     def image_header(image_size:, version:, object_count:, global_bytes:)
       SIGNATURE + u32(image_size) + u16(version) + u16(object_count) +
@@ -27,24 +40,34 @@ module Lignite
       @objects = []
       @globals = Variables.new
 
+      @declarer = RbfDeclarer.new
+      @declarer.instance_eval(rb_text, rb_filename, 1) # 1 is the line number
       instance_eval(rb_text, rb_filename, 1) # 1 is the line number
 
+      write(rbf_filename, version)
+    end
+
+    def write(rbf_filename, version)
+      image_size = HEADER_SIZE + @objects.map(&:size).reduce(0, :+)
+
       File.open(rbf_filename, "w") do |f|
-        dummy_header = image_header(image_size: 0, version: 0, object_count: 0, global_bytes: 0)
-        f.write(dummy_header)
+        header = image_header(image_size:   image_size,
+                              version:      version,
+                              object_count: @objects.size,
+                              global_bytes: @globals.bytesize)
+        f.write(header)
+
+        object_instruction_offset = HEADER_SIZE + @objects.count * RbfObject::HEADER_SIZE
         @objects.each do |obj|
-          h = obj.header(f.tell)
+          h = obj.header(object_instruction_offset)
           f.write(h)
+          object_instruction_offset += obj.body.bytesize
+        end
+
+        @objects.each do |obj|
           f.write(obj.body)
           # align??
         end
-        size = f.tell
-        f.pos = 0
-        header = image_header(image_size:   size,
-                              version:      version,
-                              object_count: @objects.size,
-                              global_bytes: @globals.bytesize)
-        f.write(header)
       end
     end
 
@@ -53,16 +76,27 @@ module Lignite
     end
     include VariableDeclarer
 
-    def vmthread(id, &body)
+    def vmthread(name, &body)
       @locals = Variables.new
-      bodyc = BodyCompiler.new(@globals, @locals)
+      bodyc = BodyCompiler.new(@globals, @locals, @declarer)
       bodyc.instance_exec(&body)
       bodyc.instance_exec { object_end }
-      # FIXME: id is not written?!
-      logger.debug "VMTHREAD #{id}"
+      logger.debug "VMTHREAD #{name}"
       logger.debug "  size #{bodyc.bytes.bytesize}"
       logger.debug "  " + bin_to_hex(bodyc.bytes)
       @objects << RbfObject.vmthread(body: bodyc.bytes, local_bytes: @locals.bytesize)
     end
+
+    def sub(_name, &body)
+      @locals = Variables.new
+      bodyc = BodyCompiler.new(@globals, @locals, @declarer)
+      bodyc.instance_exec(&body)
+      bodyc.instance_exec do
+        self.return
+        object_end
+      end
+      @objects << RbfObject.subcall(body:        bodyc.param_decl_header + bodyc.bytes,
+                                    local_bytes: @locals.bytesize)
+    end
   end
 end

data/lib/lignite/body_compiler.rb

@@ -1,4 +1,30 @@
 module Lignite
+  # Less-than (32 bit)
+  class Lt32 # < Condition
+    def initialize(a, b)
+      @a = a
+      @b = b
+    end
+
+    def not
+      Ge32.new(@a, @b)
+    end
+
+    def jump_forward(compiler, body_size)
+      compiler.jr_lt32(@a, @b, Complex(body_size, 2))
+    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
+
+      compiler.jr_lt32(@a, @b, Complex(- (body_size + self_size), 2))
+    end
+  end
+
   # Extends {OpCompiler} by
   # - variable declarations: {VariableDeclarer}
   # - high level flow control: {#loop}
@@ -8,20 +34,36 @@ module Lignite
     # @return [Variables]
     attr_reader :locals
 
+    attr_reader :declared_objects
+
     def variables
       locals
     end
     include VariableDeclarer
 
-    def initialize(globals, locals)
+    def parameters
+      locals
+    end
+    include ParameterDeclarer
+
+    def param_decl_header
+      parameters.param_decl_header
+    end
+
+    def initialize(globals, locals, declared_objects)
       @bytes = ""
       @globals = globals
       @locals = locals
+      @declared_objects = declared_objects
       @op_compiler = OpCompiler.new(@globals, @locals)
     end
 
+    def clone_context
+      BodyCompiler.new(@globals, @locals, @declared_objects)
+    end
+
     def if(flag8, &body)
-      subc = BodyCompiler.new(@globals, @locals)
+      subc = BodyCompiler.new(@globals, @locals, @declared_objects)
       subc.instance_exec(&body)
 
       jr_false(flag8, Complex(subc.bytes.bytesize, 2))
@@ -29,7 +71,7 @@ module Lignite
     end
 
     def loop(&body)
-      subc = BodyCompiler.new(@globals, @locals)
+      subc = BodyCompiler.new(@globals, @locals, @declared_objects)
       subc.instance_exec(&body)
       @bytes << subc.bytes
       # the jump takes up 4 bytes: JR, LC2, LO, HI
@@ -37,13 +79,37 @@ module Lignite
     end
 
     def loop_while_postcond(flag8, &body)
-      subc = BodyCompiler.new(@globals, @locals)
+      subc = BodyCompiler.new(@globals, @locals, @declared_objects)
       subc.instance_exec(&body)
       @bytes << subc.bytes
-      # the jump takes up 4 bytes: JR_TRUE, LV0(flag8), LC2, LO, HI
+      # the jump takes up 5 bytes: JR_TRUE, LV0(flag8), LC2, LO, HI
       jr_true(flag8, Complex(- (subc.bytes.bytesize + 5), 2))
     end
 
+    def loop_while(a, b)
+      if a.respond_to? :call
+        loop_while_post(b, &a)
+      else
+        loop_while_pre(a, &b)
+      end
+    end
+
+    def loop_while_post(condition, &body)
+      subc = BodyCompiler.new(@globals, @locals, @declared_objects)
+      subc.instance_exec(&body)
+      @bytes << subc.bytes
+      body_size = subc.bytes.bytesize
+      condition.jump_back(self, body_size)
+    end
+
+    def call(name, *args)
+      obj_id = declared_objects.index_of(name)
+      raise "Name #{name} not found" if obj_id.nil?
+
+      # TODO: check that args match their declaration
+      super(obj_id, *args) # Ev3Ops::call
+    end
+
     # Delegate the ops to the {OpCompiler},
     # but also aggregate the result in @bytes.
     def method_missing(name, *args)

data/lib/lignite/direct_commands.rb

@@ -1,3 +1,5 @@
+require "lignite/rbf_declarer"
+
 module Lignite
   # This enables sending commands without wrapping them in a .rbf program
   class DirectCommands
@@ -35,7 +37,7 @@ module Lignite
 
     def block(&body)
       locals = Variables.new
-      bodyc = BodyCompiler.new(@globals, locals)
+      bodyc = BodyCompiler.new(@globals, locals, RbfDeclarer::Dummy.new)
       bodyc.instance_exec(&body)
 
       bs = bodyc.bytes

data/lib/lignite/ev3_ops.rb

@@ -7521,7 +7521,22 @@ module Lignite
     #
     Lignite::FILL = 6
 
-    # Could not define array_fill: Unhandled param type PARV
+    #
+    # @param handle [PAR16] (in) Array handle
+    # @param value [PARV] (in) Value to write - type depends on type of array
+    def array_fill(handle, value)
+      logger.debug do
+        args = [handle, value]
+        "called array_fill with #{args.inspect}"
+      end
+
+      bytes = u8(0xC1)
+      bytes += param_simple(6)
+      bytes += param_simple(handle)
+      bytes += param_simple(value)
+      logger.debug "returning bytecode: #{bytes.inspect}"
+      bytes
+    end
     #
     Lignite::COPY = 7
 
@@ -7693,11 +7708,57 @@ module Lignite
       __send__("array_#{csym}", *args)
     end
 
-    # Could not define array_write: Unhandled param type PARV
+    # Array element write
+    # @param handle [PAR16] (in) Array handle
+    # @param index [PAR32] (in) Index to first byte to write
+    # @param value [PARV] (in) Value to write - type depends on type of array
+    def array_write(handle, index, value)
+      logger.debug do
+        args = [handle, index, value]
+        "called array_write with #{args.inspect}"
+      end
 
-    # Could not define array_read: Unhandled param type PARV
+      bytes = u8(0xC2)
+      bytes += param_simple(handle)
+      bytes += param_simple(index)
+      bytes += param_simple(value)
+      logger.debug "returning bytecode: #{bytes.inspect}"
+      bytes
+    end
 
-    # Could not define array_append: Unhandled param type PARV
+    # Array element read
+    # @param handle [PAR16] (in) Array handle
+    # @param index [PAR32] (in) Index to first byte to write
+    # @param value [PARV] (out) Value to read - type depends on type of array
+    def array_read(handle, index, value)
+      logger.debug do
+        args = [handle, index, value]
+        "called array_read with #{args.inspect}"
+      end
+
+      bytes = u8(0xC3)
+      bytes += param_simple(handle)
+      bytes += param_simple(index)
+      bytes += param_simple(value)
+      logger.debug "returning bytecode: #{bytes.inspect}"
+      bytes
+    end
+
+    # Array element append
+    # @param handle [PAR16] (in) Array handle
+    # @param value [PARV] (in) Value (new element) to append - type depends on type of array
+    def array_append(handle, value)
+      logger.debug do
+        args = [handle, value]
+        "called array_append with #{args.inspect}"
+      end
+
+      bytes = u8(0xC4)
+      bytes += param_simple(handle)
+      bytes += param_simple(value)
+      logger.debug "returning bytecode: #{bytes.inspect}"
+      bytes
+    end
 
     # Get memory usage
     # @param total [PAR32] (out) Total memory [KB]
@@ -9092,25 +9153,205 @@ module Lignite
       bytes
     end
 
-    # Could not define dynload_entry_0: Unhandled param type PARV
+    # Execute Entry Point function 0 in Third Party VM
+    # @param cmd [PAR8] (in) Sub command to be executed
+    # @param length_in [PAR8] (in) Amount of data passed to this opcode
+    # @param length_out [PAR16] (out) Amount of data returned
+    # @param value [PARV] (out) Data from opcode
+    def dynload_entry_0(cmd, length_in, length_out, value)
+      logger.debug do
+        args = [cmd, length_in, length_out, value]
+        "called dynload_entry_0 with #{args.inspect}"
+      end
 
-    # Could not define dynload_entry_1: Unhandled param type PARV
+      bytes = u8(0xF2)
+      bytes += param_simple(cmd)
+      bytes += param_simple(length_in)
+      bytes += param_simple(length_out)
+      bytes += param_simple(value)
+      logger.debug "returning bytecode: #{bytes.inspect}"
+      bytes
+    end
 
-    # Could not define dynload_entry_2: Unhandled param type PARV
+    # Execute Entry Point function 1 in Third Party VM
+    # @param cmd [PAR8] (in) Sub command to be executed
+    # @param length_in [PAR8] (in) Amount of data passed to this opcode
+    # @param length_out [PAR16] (out) Amount of data returned
+    # @param value [PARV] (out) Data from opcode
+    def dynload_entry_1(cmd, length_in, length_out, value)
+      logger.debug do
+        args = [cmd, length_in, length_out, value]
+        "called dynload_entry_1 with #{args.inspect}"
+      end
 
-    # Could not define dynload_entry_3: Unhandled param type PARV
+      bytes = u8(0xF3)
+      bytes += param_simple(cmd)
+      bytes += param_simple(length_in)
+      bytes += param_simple(length_out)
+      bytes += param_simple(value)
+      logger.debug "returning bytecode: #{bytes.inspect}"
+      bytes
+    end
 
-    # Could not define dynload_entry_4: Unhandled param type PARV
+    # Execute Entry Point function 2 in Third Party VM
+    # @param cmd [PAR8] (in) Sub command to be executed
+    # @param length_in [PAR8] (in) Amount of data passed to this opcode
+    # @param length_out [PAR16] (out) Amount of data returned
+    # @param value [PARV] (out) Data from opcode
+    def dynload_entry_2(cmd, length_in, length_out, value)
+      logger.debug do
+        args = [cmd, length_in, length_out, value]
+        "called dynload_entry_2 with #{args.inspect}"
+      end
 
-    # Could not define dynload_entry_5: Unhandled param type PARV
+      bytes = u8(0xF4)
+      bytes += param_simple(cmd)
+      bytes += param_simple(length_in)
+      bytes += param_simple(length_out)
+      bytes += param_simple(value)
+      logger.debug "returning bytecode: #{bytes.inspect}"
+      bytes
+    end
+
+    # Execute Entry Point function 3 in Third Party VM
+    # @param cmd [PAR8] (in) Sub command to be executed
+    # @param length_in [PAR8] (in) Amount of data passed to this opcode
+    # @param length_out [PAR16] (out) Amount of data returned
+    # @param value [PARV] (out) Data from opcode
+    def dynload_entry_3(cmd, length_in, length_out, value)
+      logger.debug do
+        args = [cmd, length_in, length_out, value]
+        "called dynload_entry_3 with #{args.inspect}"
+      end
+
+      bytes = u8(0xF5)
+      bytes += param_simple(cmd)
+      bytes += param_simple(length_in)
+      bytes += param_simple(length_out)
+      bytes += param_simple(value)
+      logger.debug "returning bytecode: #{bytes.inspect}"
+      bytes
+    end
+
+    # Execute Entry Point function 4 in Third Party VM
+    # @param cmd [PAR8] (in) Sub command to be executed
+    # @param length_in [PAR8] (in) Amount of data passed to this opcode
+    # @param length_out [PAR16] (out) Amount of data returned
+    # @param value [PARV] (out) Data from opcode
+    def dynload_entry_4(cmd, length_in, length_out, value)
+      logger.debug do
+        args = [cmd, length_in, length_out, value]
+        "called dynload_entry_4 with #{args.inspect}"
+      end
+
+      bytes = u8(0xF6)
+      bytes += param_simple(cmd)
+      bytes += param_simple(length_in)
+      bytes += param_simple(length_out)
+      bytes += param_simple(value)
+      logger.debug "returning bytecode: #{bytes.inspect}"
+      bytes
+    end
+
+    # Execute Entry Point function 5 in Third Party VM
+    # @param cmd [PAR8] (in) Sub command to be executed
+    # @param length_in [PAR8] (in) Amount of data passed to this opcode
+    # @param length_out [PAR16] (out) Amount of data returned
+    # @param value [PARV] (out) Data from opcode
+    def dynload_entry_5(cmd, length_in, length_out, value)
+      logger.debug do
+        args = [cmd, length_in, length_out, value]
+        "called dynload_entry_5 with #{args.inspect}"
+      end
+
+      bytes = u8(0xF7)
+      bytes += param_simple(cmd)
+      bytes += param_simple(length_in)
+      bytes += param_simple(length_out)
+      bytes += param_simple(value)
+      logger.debug "returning bytecode: #{bytes.inspect}"
+      bytes
+    end
 
-    # Could not define dynload_entry_6: Unhandled param type PARV
+    # Execute Entry Point function 6 in Third Party VM
+    # @param cmd [PAR8] (in) Sub command to be executed
+    # @param length_in [PAR8] (in) Amount of data passed to this opcode
+    # @param length_out [PAR16] (out) Amount of data returned
+    # @param value [PARV] (out) Data from opcode
+    def dynload_entry_6(cmd, length_in, length_out, value)
+      logger.debug do
+        args = [cmd, length_in, length_out, value]
+        "called dynload_entry_6 with #{args.inspect}"
+      end
+
+      bytes = u8(0xF8)
+      bytes += param_simple(cmd)
+      bytes += param_simple(length_in)
+      bytes += param_simple(length_out)
+      bytes += param_simple(value)
+      logger.debug "returning bytecode: #{bytes.inspect}"
+      bytes
+    end
+
+    # Execute Entry Point function 7 in Third Party VM
+    # @param cmd [PAR8] (in) Sub command to be executed
+    # @param length_in [PAR8] (in) Amount of data passed to this opcode
+    # @param length_out [PAR16] (out) Amount of data returned
+    # @param value [PARV] (out) Data from opcode
+    def dynload_entry_7(cmd, length_in, length_out, value)
+      logger.debug do
+        args = [cmd, length_in, length_out, value]
+        "called dynload_entry_7 with #{args.inspect}"
+      end
+
+      bytes = u8(0xF9)
+      bytes += param_simple(cmd)
+      bytes += param_simple(length_in)
+      bytes += param_simple(length_out)
+      bytes += param_simple(value)
+      logger.debug "returning bytecode: #{bytes.inspect}"
+      bytes
+    end
+
+    # Execute Entry Point function 8 in Third Party VM
+    # @param cmd [PAR8] (in) Sub command to be executed
+    # @param length_in [PAR8] (in) Amount of data passed to this opcode
+    # @param length_out [PAR16] (out) Amount of data returned
+    # @param value [PARV] (out) Data from opcode
+    def dynload_entry_8(cmd, length_in, length_out, value)
+      logger.debug do
+        args = [cmd, length_in, length_out, value]
+        "called dynload_entry_8 with #{args.inspect}"
+      end
 
-    # Could not define dynload_entry_7: Unhandled param type PARV
+      bytes = u8(0xFA)
+      bytes += param_simple(cmd)
+      bytes += param_simple(length_in)
+      bytes += param_simple(length_out)
+      bytes += param_simple(value)
+      logger.debug "returning bytecode: #{bytes.inspect}"
+      bytes
+    end
 
-    # Could not define dynload_entry_8: Unhandled param type PARV
+    # Execute Entry Point function 9 in Third Party VM
+    # @param cmd [PAR8] (in) Sub command to be executed
+    # @param length_in [PAR8] (in) Amount of data passed to this opcode
+    # @param length_out [PAR16] (out) Amount of data returned
+    # @param value [PARV] (out) Data from opcode
+    def dynload_entry_9(cmd, length_in, length_out, value)
+      logger.debug do
+        args = [cmd, length_in, length_out, value]
+        "called dynload_entry_9 with #{args.inspect}"
+      end
 
-    # Could not define dynload_entry_9: Unhandled param type PARV
+      bytes = u8(0xFB)
+      bytes += param_simple(cmd)
+      bytes += param_simple(length_in)
+      bytes += param_simple(length_out)
+      bytes += param_simple(value)
+      logger.debug "returning bytecode: #{bytes.inspect}"
+      bytes
+    end
 
     # Get the index of the currently loaded VM
     # @param result [PAR8] (out) VM Index, Robotc = 0, Labview = 1, -1 for no loaded VM