nudge 0.0.2 → 0.1.0

data/lib/instructions/code/code_execute_then_pop.rb

@@ -0,0 +1,20 @@
+class CodeExecuteThenPopInstruction < Instruction
+  def preconditions?
+    needs CodePopInstruction
+    needs :code, 1
+  end
+  def setup
+    @arg = @context.peek_value(:code) # does not pop the stack initially!
+  end
+  def derive
+    that_becomes = NudgeProgram.new(@arg)
+    if that_becomes.parses?
+      @result = CodeblockPoint.new([NudgeProgram.new(@arg).linked_code,InstructionPoint.new("code_pop")])
+    else
+      @result = CodeblockPoint.new([InstructionPoint.new("code_pop")])
+    end
+  end
+  def cleanup
+    pushes :exec, @result
+  end
+end

data/lib/instructions/code/code_flush.rb

@@ -0,0 +1,6 @@
+class CodeFlushInstruction < Instruction
+  include FlushInstruction
+  def initialize(context)
+    super(context, :code)
+  end
+end

data/lib/instructions/code/code_gsub.rb

@@ -0,0 +1,35 @@
+# ORIGINAL PUSH3 DESCRIPTION: Pushes the result of substituting the third item on the code stack for the second item in the first item. As of this writing this is implemented only in the Lisp implementation, within which it relies on the Lisp "subst" function. As such, there are several problematic possibilities; for example "dotted-lists" can result in certain cases with empty-list arguments. If any of these problematic possibilities occurs the stack is left unchanged.
+
+# Here, we will pop three :code items, find all occurrences of the appropriate point in the changed codeblock, and then replace them in last-to-first order (so the point counts discovered initially don't change during substitution)
+
+class CodeGsubInstruction < Instruction # was CODE.SUBST in Push3
+  def preconditions?
+    needs :code, 3
+  end
+  def setup
+    @host_tree = @context.pop_value(:code)
+    @old_subtree = @context.pop_value(:code)
+    @new_subtree = @context.pop_value(:code)
+  end
+  def derive
+    new_tree = NudgeProgram.new(@new_subtree)
+    raise InstructionMethodError,
+      "#{self.class.to_nudgecode} cannot work with unparseable code" unless new_tree.parses?
+    old_tree = NudgeProgram.new(@old_subtree)
+    raise InstructionMethodError,
+      "#{self.class.to_nudgecode} cannot work with unparseable code" unless old_tree.parses?
+    host = NudgeProgram.new(@host_tree)
+    raise InstructionMethodError,
+      "#{self.class.to_nudgecode} cannot work with unparseable code" unless host.parses?
+    
+    found_at = [] # need to iterate through the tree the slow way to capture the indices (I think)
+    host.linked_code.each_with_index do |point, index|
+      found_at << (index+1) if point.blueprint == old_tree.blueprint
+    end
+    found_at.reverse.each {|index| host = host.replace_point(index, new_tree.linked_code)}
+    @result = ValuePoint.new("code", host.blueprint)
+  end
+  def cleanup
+    pushes :code, @result
+  end
+end

data/lib/instructions/code/code_if.rb

@@ -0,0 +1,22 @@
+class CodeIfInstruction < Instruction
+  
+  def preconditions?
+    needs :code, 2
+    needs :bool, 1
+  end
+  
+  def setup
+    @stay = @context.pop_value(:bool)
+    @ifFalse = @context.pop_value(:code)
+    @ifTrue = @context.pop_value(:code)
+  end
+  
+  def derive
+    which = @stay ? @ifTrue : @ifFalse
+    @result = NudgeProgram.new(which).linked_code
+  end
+  
+  def cleanup
+    pushes :exec, @result
+  end
+end

data/lib/instructions/code/code_instructions.rb

@@ -0,0 +1,15 @@
+class CodeInstructionsInstruction < Instruction
+  def preconditions?
+    true
+  end
+  def setup
+  end
+  def derive
+    all_instructions = @context.instructions
+    list_as_block = all_instructions.inject("block {") {|b,i| b + " do #{i.to_nudgecode}"} + "}"
+    @result = ValuePoint.new("code", list_as_block)
+  end
+  def cleanup
+    pushes :code, @result
+  end
+end

data/lib/instructions/code/code_list.rb

@@ -0,0 +1,19 @@
+class CodeListInstruction < Instruction
+  def preconditions?
+    needs :code, 2
+  end
+  def setup
+    @arg2 = @context.pop_value(:code)
+    @arg1 = @context.pop_value(:code)
+  end
+  def derive
+    listed = []
+    listed << NudgeProgram.new(@arg1).linked_code unless @arg1 == ""
+    listed << NudgeProgram.new(@arg2).linked_code unless @arg2 == ""
+    combined = CodeblockPoint.new(listed).blueprint
+    @result = ValuePoint.new("code", combined)
+  end
+  def cleanup
+    pushes :code, @result
+  end
+end

data/lib/instructions/code/code_member_q.rb

@@ -0,0 +1,26 @@
+class CodeMemberQInstruction < Instruction
+  def preconditions?
+    needs :code, 2
+  end
+  def setup
+    @arg2 = @context.pop_value(:code)
+    @arg1 = @context.pop_value(:code)
+  end
+  def derive
+    looking_for_this = NudgeProgram.new(@arg1)
+    tree = NudgeProgram.new(@arg2)
+    if tree.parses? && looking_for_this.parses?
+      if tree.linked_code.kind_of?(CodeblockPoint)
+        found = tree[1].contents.any? {|branch| branch.blueprint == looking_for_this.blueprint}
+      else
+        found = (tree.blueprint == looking_for_this.blueprint)
+      end
+    else
+      found = false
+    end
+    @result = ValuePoint.new("bool", found)
+  end
+  def cleanup
+    pushes :bool, @result
+  end
+end

data/lib/instructions/code/code_name_lookup.rb

@@ -0,0 +1,19 @@
+class CodeNameLookupInstruction < Instruction  # was Push3 CODE.DEFINITION
+  def preconditions?
+    needs :name, 1
+  end
+  def setup
+    @the_reference = @context.pop_value(:name)
+  end
+  def derive
+    bound_value = @context.variables[@the_reference] || @context.names[@the_reference] || nil
+    if bound_value != nil
+      @result = ValuePoint.new("code", bound_value.blueprint)
+    else
+      @result = ValuePoint.new("code", "")
+    end
+  end
+  def cleanup
+    pushes :code, @result
+  end
+end

data/lib/instructions/code/code_nth.rb

@@ -0,0 +1,24 @@
+class CodeNthInstruction < Instruction 
+  def preconditions?
+    needs :int, 1
+    needs :code, 1
+  end
+  def setup
+    @arg1 = @context.pop_value(:int)
+    @arg2 = @context.pop_value(:code)
+  end
+  def derive
+    tree = NudgeProgram.new(@arg2)
+    if tree.linked_code.kind_of?(CodeblockPoint)
+      pts = tree[1].contents.length
+      raise InstructionMethodError, "#{self.class} can't work on empty blocks" if pts < 1
+      val = tree[1].contents[@arg1 % pts]
+    else
+      val = tree
+    end
+    @result = ValuePoint.new("code", val.blueprint)
+  end
+  def cleanup
+    pushes :code, @result
+  end
+end

data/lib/instructions/code/code_nth_cdr.rb

@@ -0,0 +1,30 @@
+class CodeNthCdrInstruction < Instruction
+  def preconditions?
+    needs :int, 1
+    needs :code, 1
+  end
+  def setup
+    @arg1 = @context.pop_value(:int)
+    @arg2 = @context.pop_value(:code)
+  end
+  def derive
+    tree = NudgeProgram.new(@arg2)
+    raise InstructionMethodError,
+      "#{self.class.to_nudgecode} cannot parse the argument" unless tree.parses?
+    backbone = tree.linked_code
+    if backbone.kind_of?(CodeblockPoint)
+      b_len = backbone.contents.length
+      if b_len > 0
+        new_tree = CodeblockPoint.new(backbone.contents.slice(@arg1 % b_len, b_len))
+      else
+        new_tree = CodeblockPoint.new([])
+      end
+    else
+      new_tree = @arg1 > 0 ? CodeblockPoint.new([tree.linked_code]) : CodeblockPoint.new([])
+    end
+    @result = ValuePoint.new("code", new_tree.blueprint)
+  end
+  def cleanup
+    pushes :code, @result
+  end
+end

data/lib/instructions/code/code_nth_point.rb

@@ -0,0 +1,21 @@
+class CodeNthPointInstruction < Instruction # was CODE.EXTRACT in Push3
+  def preconditions?
+    needs :int, 1
+    needs :code, 1
+  end
+  def setup
+    @arg1 = @context.pop_value(:int)
+    @arg2 = @context.pop_value(:code)
+  end
+  def derive
+    tree = NudgeProgram.new(@arg2)
+    tree_size = tree.points
+    raise InstructionMethodError, "#{self.class} divied by zero" if tree_size < 1
+    which = (@arg1-1) % tree_size + 1
+    pt = tree[which]
+    @result = ValuePoint.new("code", pt.blueprint)
+  end
+  def cleanup
+    pushes :code, @result
+  end
+end

data/lib/instructions/code/code_null_q.rb

@@ -0,0 +1,15 @@
+class CodeNullQInstruction < Instruction
+  def preconditions?
+    needs :code, 1
+  end
+  def setup
+    arg_blueprint = @context.pop_value(:code)
+    @arg1 = NudgeProgram.new(arg_blueprint).blueprint
+  end
+  def derive
+    @result = ValuePoint.new("bool", @arg1 == "block {}")
+  end
+  def cleanup
+    pushes :bool, @result
+  end
+end

data/lib/instructions/code/code_parses_q.rb

@@ -0,0 +1,15 @@
+class CodeParsesQInstruction < Instruction
+  def preconditions?
+    needs :code, 1
+  end
+  def setup
+    @arg1 = @context.pop_value(:code)
+  end
+  def derive
+    answer = NudgeProgram.new(@arg1).parses? ? true : false
+    @result = ValuePoint.new("bool", answer)
+  end
+  def cleanup
+    pushes :bool, @result
+  end
+end

data/lib/instructions/code/code_points.rb

@@ -0,0 +1,19 @@
+class CodePointsInstruction < Instruction
+  
+  def preconditions?
+    needs :code, 1
+  end
+  
+  def setup
+    arg_blueprint = @context.pop_value(:code)
+    @parsed = NudgeProgram.new(arg_blueprint)
+  end
+  
+  def derive
+    @result = ValuePoint.new("int",@parsed.points)
+  end
+  
+  def cleanup
+    pushes :int, @result
+  end
+end

data/lib/instructions/code/code_pop.rb

@@ -0,0 +1,6 @@
+class CodePopInstruction < Instruction
+  include PopInstruction
+  def initialize(context)
+    super(context, :code)
+  end
+end

data/lib/instructions/code/code_position.rb

@@ -0,0 +1,22 @@
+class CodePositionInstruction < Instruction
+  def preconditions?
+    needs :code, 2
+  end
+  def setup
+    @arg2 = @context.pop_value(:code)
+    @arg1 = @context.pop_value(:code)
+  end
+  def derive
+    looking_for_this = NudgeProgram.new(@arg1).linked_code
+    inside_this = NudgeProgram.new(@arg2).linked_code
+    if inside_this && looking_for_this
+      index = inside_this.find_index {|point| point.blueprint == looking_for_this.blueprint} || -2
+    else
+      index = -2
+    end
+    @result = ValuePoint.new("int", index+1)
+  end
+  def cleanup
+    pushes :int, @result
+  end
+end

data/lib/instructions/code/code_quote.rb

@@ -0,0 +1,14 @@
+class CodeQuoteInstruction < Instruction
+  def preconditions?
+    needs :exec, 1
+  end
+  def setup
+    @arg = @context.pop(:exec).blueprint
+  end
+  def derive
+    @result = ValuePoint.new("code", @arg)
+  end
+  def cleanup
+    pushes :code, @result
+  end
+end

data/lib/instructions/code/code_replace_nth_point.rb

@@ -0,0 +1,30 @@
+class CodeReplaceNthPointInstruction < Instruction # was CODE.INSERT in Push3
+  def preconditions?
+    needs :int, 1
+    needs :code, 2
+  end
+  def setup
+    @where = @context.pop_value(:int)
+    @accept = @context.pop_value(:code)
+    @insert = @context.pop_value(:code)
+  end
+  def derive
+    acceptor = NudgeProgram.new(@accept)
+    raise InstructionMethodError,
+      "#{self.class.to_nudgecode} cannot work with unparseable code" unless acceptor.parses?
+    insertion = NudgeProgram.new(@insert)
+    raise InstructionMethodError,
+      "#{self.class.to_nudgecode} cannot work with unparseable code" unless insertion.parses?
+    scale = acceptor.points
+    which_pt = if @where < 1 || @where > scale
+      (@where % acceptor.points) + 1
+    else
+      @where
+    end
+    new_tree = acceptor.replace_point(which_pt, insertion.linked_code).blueprint
+    @result = ValuePoint.new("code", new_tree)
+  end
+  def cleanup
+    pushes :code, @result
+  end
+end

data/lib/instructions/code/code_rotate.rb

@@ -0,0 +1,6 @@
+class CodeRotateInstruction < Instruction
+  include RotateInstruction
+  def initialize(context)
+    super(context, :code)
+  end
+end

data/lib/instructions/code/code_shove.rb

@@ -0,0 +1,6 @@
+class CodeShoveInstruction < Instruction
+  include ShoveInstruction
+  def initialize(context)
+    super(context, :code)
+  end
+end

data/lib/instructions/code/code_swap.rb

@@ -0,0 +1,6 @@
+class CodeSwapInstruction < Instruction
+  include SwapInstruction
+  def initialize(context)
+    super(context, :code)
+  end
+end

data/lib/instructions/code/code_yank.rb

@@ -0,0 +1,6 @@
+class CodeYankInstruction < Instruction
+  include YankInstruction
+  def initialize(context)
+    super(context, :code)
+  end
+end

data/lib/instructions/code/code_yankdup.rb

@@ -0,0 +1,6 @@
+class CodeYankdupInstruction < Instruction
+  include YankdupInstruction
+  def initialize(context)
+    super(context, :code)
+  end
+end

data/lib/instructions/conversion/bool_from_float.rb

@@ -0,0 +1,14 @@
+class BoolFromFloatInstruction < Instruction
+  def preconditions?
+    needs :float, 1
+  end
+  def setup
+    @arg = @context.pop_value(:float)
+  end
+  def derive
+    @result = ValuePoint.new("bool", @arg != 0.0)
+  end
+  def cleanup
+    pushes :bool, @result
+  end
+end

data/lib/instructions/conversion/bool_from_int.rb

@@ -0,0 +1,14 @@
+class BoolFromIntInstruction < Instruction
+  def preconditions?
+    needs :int, 1
+  end
+  def setup
+    @arg = @context.pop_value(:int)
+  end
+  def derive
+    @result = ValuePoint.new("bool", @arg != 0)
+  end
+  def cleanup
+    pushes :bool, @result
+  end
+end

data/lib/instructions/conversion/code_from_bool.rb

@@ -0,0 +1,16 @@
+#encoding: utf-8
+
+class CodeFromBoolInstruction < Instruction
+  def preconditions?
+    needs :bool, 1
+  end
+  def setup
+    @arg = @context.pop_value(:bool)
+  end
+  def derive
+    @result = ValuePoint.new("code", "value «bool»\n«bool» #{@arg}")
+  end
+  def cleanup
+    pushes :code, @result
+  end
+end

data/lib/instructions/conversion/code_from_float.rb

@@ -0,0 +1,16 @@
+#encoding: utf-8
+
+class CodeFromFloatInstruction < Instruction
+  def preconditions?
+    needs :float, 1
+  end
+  def setup
+    @arg = @context.pop_value(:float)
+  end
+  def derive
+    @result = ValuePoint.new("code", "value «float»\n«float» #{@arg}")
+  end
+  def cleanup
+    pushes :code, @result
+  end
+end

data/lib/instructions/conversion/code_from_int.rb

@@ -0,0 +1,17 @@
+#encoding: utf-8
+
+
+class CodeFromIntInstruction < Instruction
+  def preconditions?
+    needs :int, 1
+  end
+  def setup
+    @arg = @context.pop_value(:int)
+  end
+  def derive
+    @result = ValuePoint.new("code", "value «int»\n«int» #{@arg}")
+  end
+  def cleanup
+    pushes :code, @result
+  end
+end

data/lib/instructions/conversion/code_from_name.rb

@@ -0,0 +1,16 @@
+#encoding: utf-8
+
+class CodeFromNameInstruction < Instruction
+  def preconditions?
+    needs :name, 1
+  end
+  def setup
+    @arg = @context.pop(:name).name
+  end
+  def derive
+    @result = ValuePoint.new("code", "ref #{@arg}")
+  end
+  def cleanup
+    pushes :code, @result
+  end
+end

data/lib/instructions/conversion/float_from_bool.rb

@@ -0,0 +1,14 @@
+class FloatFromBoolInstruction < Instruction
+  def preconditions?
+    needs :bool, 1
+  end
+  def setup
+    @arg = @context.pop_value(:bool)
+  end
+  def derive
+    @result = ValuePoint.new("float", @arg ? 1.0 : 0.0)
+  end
+  def cleanup
+    pushes :float, @result
+  end
+end

data/lib/instructions/conversion/float_from_int.rb

@@ -0,0 +1,14 @@
+class FloatFromIntInstruction < Instruction
+  def preconditions?
+    needs :int, 1
+  end
+  def setup
+    @arg = @context.pop_value(:int)
+  end
+  def derive
+    @result = ValuePoint.new("float", @arg.to_f)
+  end
+  def cleanup
+    pushes :float, @result
+  end
+end

data/lib/instructions/conversion/int_from_bool.rb

@@ -0,0 +1,14 @@
+class IntFromBoolInstruction < Instruction
+  def preconditions?
+    needs :bool, 1
+  end
+  def setup
+    @arg = @context.pop_value(:bool)
+  end
+  def derive
+    @result = ValuePoint.new("int", @arg ? 1 : 0)
+  end
+  def cleanup
+    pushes :int, @result
+  end
+end

data/lib/instructions/conversion/int_from_float.rb

@@ -0,0 +1,14 @@
+class IntFromFloatInstruction < Instruction
+  def preconditions?
+    needs :float, 1
+  end
+  def setup
+    @arg = @context.pop_value(:float)
+  end
+  def derive
+    @result = ValuePoint.new("int", @arg.to_i)
+  end
+  def cleanup
+    pushes :int, @result
+  end
+end

data/lib/instructions/exec/exec_define.rb

@@ -0,0 +1,6 @@
+class ExecDefineInstruction < Instruction
+  include DefineInstruction
+  def initialize(context)
+    super(context, :exec)
+  end
+end

data/lib/instructions/exec/exec_depth.rb

@@ -0,0 +1,6 @@
+class ExecDepthInstruction < Instruction
+  include DepthInstruction
+  def initialize(context)
+    super(context, :exec)
+  end
+end

data/lib/instructions/exec/exec_do_count.rb

@@ -0,0 +1,23 @@
+class ExecDoCountInstruction < Instruction
+  def preconditions?
+    needs ExecDoRangeInstruction
+    needs :exec, 1
+    needs :int, 1
+  end
+  
+  def setup
+    @destination = @context.pop(:int)
+    @code = @context.pop(:exec)
+  end
+  
+  def derive
+    raise InstructionMethodError, "#{self.class} needs a positive argument" if @destination.value < 1
+    @one_less = ValuePoint.new("int",@destination.value-1)
+  end
+  
+  def cleanup
+    recursor = CodeblockPoint.new([ValuePoint.new("int",0), @one_less,
+      InstructionPoint.new("exec_do_range"),@code])
+    pushes :exec, recursor
+  end
+end

data/lib/instructions/exec/exec_do_range.rb

@@ -0,0 +1,36 @@
+class ExecDoRangeInstruction < Instruction
+  def preconditions?
+    needs :exec, 1
+    needs :int, 2
+  end
+  
+  def setup
+    @destination = @context.pop(:int)
+    @counter = @context.pop(:int)
+    @code = @context.pop(:exec)
+  end
+  
+  def derive
+    @finished = false
+    if @counter.value == @destination.value
+      @finished = true
+    elsif @counter.value < @destination.value
+      @new_counter = ValuePoint.new("int", @counter.value + 1)
+    else
+      @new_counter = ValuePoint.new("int", @counter.value - 1)
+    end
+  end
+  
+  def cleanup
+    if @finished
+      pushes :int, @counter
+      pushes :exec, @code
+    else
+      recursor = CodeblockPoint.new([@new_counter, @destination,
+        InstructionPoint.new("exec_do_range"),@code])
+      pushes :int, @counter
+      pushes :exec, recursor
+      pushes :exec, @code
+    end
+  end
+end