adds plocks (Proc Block) as descibed in posts. Usage also described, but not coded yet

lib/vm/plock.rb

@@ -0,0 +1,64 @@
+module Vm
+  #Plock (Proc-Block) is mostly a Block but also somewhat Proc-ish: A Block that carries data.
+  #
+  # Data in a Block is usefull in the same way data in objects is. Plocks being otherwise just code.
+  #
+  # But the concept is not quite straigtforwrd: If one think of an Plock enbedded in a normal function,
+  # the a data in the Plock would be static data. In OO terms this comes quite close to a Proc, if the data is the local
+  # variables. Quite possibly they shall be used to implement procs, but that is not the direction now.
+  #
+  # For now we use Plocks behaind the scenes as it were. In the code that you never see, method invocation mainly.
+  # 
+  # In terms of implementation the Plock is a Block with data (Not too much data, mainly a couple of references).
+  # The block writes it's instructions as normal, but a jump is inserted as the last instruction. The jump is to the 
+  # next block, over the data that is inserted after the block code (and so before the next)
+  #
+  # It follows that Plocks should be linear blocks.
+  class Plock < Block
+    
+    def initialize(name , function , next_block )
+      super
+      @data = []
+      @branch_code = RegisterMachine.instance.b next_block
+    end
+
+    def set_next next_b
+      super
+      @branch_code = RegisterMachine.instance.b next_block
+    end
+
+    # Data gets assembled after functions
+    def add_data o
+      return if @objects.include? o
+      raise "must be derived from Code #{o.inspect}" unless o.is_a? Vm::Code
+      @data << o # TODO check type , no basic values allowed (must be wrapped)
+    end
+
+    # Code interface follows. Note position is inheitted as is from Code
+
+    # length of the Plock is the length of the block, plus the branch, plus data.
+    def length
+      len = @data.inject(super) {| sum  , item | sum + item.length}
+      len + @branch_code.length
+    end
+
+    # again, super +  branch plus data
+    def link_at pos , context
+      super(pos , context)
+      @branch_code.link_at pos , context
+      @data.each do |code|
+        code.link_at(pos , context)
+        pos += code.length
+      end
+    end
+
+    # again, super +  branch plus data
+    def assemble(io)
+      super
+      @branch_code.assemble(io)
+      @data.each do |obj|
+        obj.assemble io
+      end
+    end
+  end
+end