nudge 0.0.2 → 0.1.0

data/lib/instructions/int/int_yankdup.rb

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

data/lib/instructions/name/name_depth.rb

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

data/lib/instructions/name/name_disable_lookup.rb

@@ -0,0 +1,12 @@
+class NameDisableLookupInstruction < Instruction
+  def preconditions?
+    true
+  end
+  def setup
+  end
+  def derive
+  end
+  def cleanup
+    @context.evaluate_references = false
+  end
+end

data/lib/instructions/name/name_duplicate.rb

@@ -0,0 +1,6 @@
+class NameDuplicateInstruction < Instruction
+  include DuplicateInstruction
+  def initialize(context)
+    super(context, :name)
+  end
+end

data/lib/instructions/name/name_equal_q.rb

@@ -0,0 +1,15 @@
+class NameEqualQInstruction < Instruction
+  def preconditions?
+    needs :name, 2
+  end
+  def setup
+    @arg2 = @context.pop_value(:name)
+    @arg1 = @context.pop_value(:name)
+  end
+  def derive
+    @result = ValuePoint.new("bool", @arg1 == @arg2)
+  end
+  def cleanup
+    pushes :bool, @result
+  end
+end

data/lib/instructions/name/name_flush.rb

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

data/lib/instructions/name/name_next.rb

@@ -0,0 +1,14 @@
+class NameNextInstruction < Instruction
+  def preconditions?
+    true
+  end
+  def setup
+    @new_name = @context.next_name
+  end
+  def derive
+    @result = ReferencePoint.new(@new_name)
+  end
+  def cleanup
+    pushes :exec, @result
+  end
+end

data/lib/instructions/name/name_pop.rb

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

data/lib/instructions/name/name_random_bound.rb

@@ -0,0 +1,14 @@
+class NameRandomBoundInstruction < Instruction
+  def preconditions?
+    @context.references.length > 0
+  end
+  def setup
+  end
+  def derive
+    @result = ReferencePoint.new("placeholder")
+    @result.randomize(@context)
+  end
+  def cleanup
+    pushes :exec, @result
+  end
+end

data/lib/instructions/name/name_rotate.rb

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

data/lib/instructions/name/name_shove.rb

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

data/lib/instructions/name/name_swap.rb

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

data/lib/instructions/name/name_unbind.rb

@@ -0,0 +1,17 @@
+class NameUnbindInstruction < Instruction
+  def preconditions?
+    needs :name,1
+  end
+  
+  def setup
+    @arg1 = @context.pop(:name)
+  end
+  
+  def derive
+    @lost_name = @arg1.name
+  end
+  
+  def cleanup
+    @context.unbind_name(@lost_name)
+  end
+end

data/lib/instructions/name/name_yank.rb

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

data/lib/instructions/name/name_yankdup.rb

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

data/lib/interpreter/grammars/nudge_codeblock.treetop

@@ -0,0 +1,17 @@
+require 'nudge'
+
+
+grammar NudgeCodeblock
+  include NudgeCommon
+  include NudgeReference
+  include NudgeInstruction
+  include NudgeValue
+  
+  rule codesection
+    value / instruction / reference / (block_statement <CodeblockParseNode>)
+  end
+  
+  rule block_statement
+    'block' spcs? '{' spcs? block_contents:(codesection spcs?)* '}' 
+  end
+end

data/lib/interpreter/grammars/nudge_codeblock_helpers.rb

@@ -0,0 +1,19 @@
+# coding: utf-8
+module CodeblockParseNode
+  def contents
+    block_contents.elements.collect {|e| e.elements[0]}
+  end
+  
+  def tidy(level=1)
+    tt = "block {"
+    indent = level*2
+    contents.each {|item| tt += ("\n" + (" "*indent) + item.tidy(level+1))}
+    tt += "}"
+    return tt
+  end
+  
+  def to_point
+    c = CodeblockPoint.new(contents.collect {|e| e.to_point})
+  end
+end
+

data/lib/interpreter/grammars/nudge_common.treetop

@@ -0,0 +1,15 @@
+# encoding: utf-8
+grammar NudgeCommon
+  rule common
+    spcs / alphas_and_underscores
+  end
+  
+  rule spcs
+    [\s\t\n]+
+  end
+  
+  rule alphas_and_underscores
+    [\p{Alpha}] [_\p{Alnum}/u]*
+  end
+  
+end

data/lib/interpreter/grammars/nudge_instruction.treetop

@@ -0,0 +1,14 @@
+#encoding: utf-8
+require 'interpreter/grammars/nudge_common'
+
+grammar NudgeInstruction
+  include NudgeCommon
+  
+  rule instruction
+    'do' spcs opcode <InstructionParseNode>
+  end
+  
+  rule opcode
+    alphas_and_underscores
+  end
+end

data/lib/interpreter/grammars/nudge_instruction_helpers.rb

@@ -0,0 +1,14 @@
+# coding: utf-8
+class InstructionParseNode < Treetop::Runtime::SyntaxNode
+  def instruction_name
+    opcode.text_value
+  end
+  
+  def tidy(level=1)
+    "do #{instruction_name}"
+  end
+  
+  def to_point
+    InstructionPoint.new(instruction_name)
+  end
+end

data/lib/interpreter/grammars/nudge_reference.treetop

@@ -0,0 +1,9 @@
+require 'interpreter/grammars/nudge_common'
+
+grammar NudgeReference
+  include NudgeCommon
+
+  rule reference
+    'ref' spcs vname:alphas_and_underscores <ReferenceParseNode>
+  end
+end

data/lib/interpreter/grammars/nudge_reference_helpers.rb

@@ -0,0 +1,14 @@
+# coding: utf-8
+class ReferenceParseNode < Treetop::Runtime::SyntaxNode
+  def variable_name
+    vname.text_value
+  end
+  
+  def tidy(level=1)
+    "ref #{variable_name}"
+  end
+  
+  def to_point
+    ReferencePoint.new(variable_name)
+  end
+end

data/lib/interpreter/grammars/nudge_value.treetop

@@ -0,0 +1,14 @@
+# encoding: utf-8
+require 'interpreter/grammars/nudge_common'
+
+grammar NudgeValue
+  include NudgeCommon
+  
+  rule value
+    'value' spcs? '«' footnote_type '»' <ValueParseNode>
+  end
+  
+  rule footnote_type
+    alphas_and_underscores
+  end
+end

data/lib/interpreter/grammars/nudge_value_helpers.rb

@@ -0,0 +1,19 @@
+# coding: utf-8
+class ValueParseNode < Treetop::Runtime::SyntaxNode
+  def type=(new_type)
+    @type = new_type
+  end
+  
+  def type
+    @type ||= footnote_type.text_value
+  end
+  
+  def tidy(level=1)
+    "value «#{type}»"
+  end
+  
+  def to_point
+    return ValuePoint.new(type)
+  end
+  
+end

data/lib/interpreter/interpreter.rb

@@ -1,43 +1,48 @@
+#encoding: utf-8
 module Nudge
   
-  # The Interpreter class executes the Push3 language loop:
+  # The Interpreter class executes the Push3-like language loop:
   # 1. Pop the top item off the <b>:exec</b> Stack
   # 2. If it is a(n)...
-  #    * ... Instruction, execute its go() method;
-  #    * ... Literal or Sample, push its value to the Stack it names;
-  #    * ... Reference (Variable or Name), ...
+  #    * ... InstructionPoint, execute that instruction's go() method;
+  #    * ... ValuePoint, push its value to the Stack it names;
+  #    * ... ReferencePoint (Variable or Name), ...
   #       * ... if it's bound to a value, push the bound value onto the <b>:exec</b> Stack;
   #       * ... if it's not bound, push the name itself onto the <b>:name</b> Stack;
-  #    * ... CodeBlock, push its #contents (in the same order) back onto the <b>:exec</b> Stack
+  #    * ... CodeblockPoint, push its #contents (in the same order) back onto the <b>:exec</b> Stack
+  #    * ... NilPoint, do nothing
   
   class Interpreter
-    attr_accessor :parser, :stepLimit, :steps
+    attr_accessor :program, :stepLimit, :steps
     attr_accessor :stacks, :instructions_library, :variables, :names, :types
-    attr_accessor :last_name, :evaluate_channels
+    attr_accessor :last_name, :evaluate_references
+    
     
     # A program to be interpreted can be passed in as an optional parameter
     def initialize(params = {})
-      initialProgram = params[:program] || ""
+      initialProgram = params[:program] || nil
+      @program = initialProgram
       @types = params[:types] || NudgeType.all_types
       @stepLimit = params[:step_limit] || 3000
       
-      instructions = params[:instructions] || []
-      @instructions_library = Hash.new
+      instructions = params[:instructions] || Instruction.all_instructions
+      @instructions_library = Hash.new {|hash, key| raise InstructionPoint::InstructionNotFoundError,
+        "#{key} is not an active instruction in this context"}
       instructions.each {|i| self.enable(i)}
       
       # private parts
-      @parser = NudgeLanguageParser.new()
       @names = Hash.new
       @variables = Hash.new
       @steps = 0
       @last_name = "refAAAAA"
-      @evaluate_channels = true
+      @evaluate_references = true
       @stacks =  Hash.new {|hash, key| hash[key] = Stack.new(key) }
       
       # set it all up here
       self.reset(initialProgram)
     end
     
+    
     # Resets the Interpreter state:
     # * clears all the Stacks (including the <b>:exec</b> Stack)
     # * loads a new program,
@@ -45,13 +50,15 @@ module Nudge
     #    * if it parses, pushes it onto the <b>:exec</b> Stack
     #    * (and if it doesn't parse, leaves all stacks empty)
     # * resets the @step counter.
-    def reset(program="")
+    def reset(program=nil)
+      @program = program
       self.clear_stacks
+      self.reset_names
+      if program
+        @stacks[:exec].push(NudgeProgram.new(program).linked_code)
+      end
       @steps = 0
-      parsed = @parser.parse(program)
-      newCode = parsed.to_points if parsed
-      @stacks[:exec].push(newCode)
-      @evaluate_channels = true
+      @evaluate_references = true
     end
     
     
@@ -59,6 +66,35 @@ module Nudge
       @stacks = Hash.new {|hash, key| hash[key] = Stack.new(key) }
     end
     
+    
+    def peek(stackname)
+      @stacks[stackname].peek
+    end
+    
+    
+    def peek_value(stackname)
+      item = @stacks[stackname].peek
+      item.nil? ? nil : item.value
+    end
+    
+    
+    def pop(stackname)
+      @stacks[stackname].pop
+    end
+    
+    
+    def pop_value(stackname)
+      item = @stacks[stackname].pop
+      item.nil? ? nil : item.value
+    end
+    
+    
+    def push(stackname, value="")
+      @stacks[stackname].push(ValuePoint.new(stackname, value))
+    end
+    
+    
+    
     # Checks to see if either stopping condition applies:
     # 1. Is the <b>:exec</b> stack empty?
     # 2. Are the number of steps greater than self.stepLimit?
@@ -66,6 +102,7 @@ module Nudge
       @stacks[:exec].depth > 0 && @steps < @stepLimit
     end
     
+    
     # Execute one cycle of the Push3 interpreter rule:
     # 1. check termination conditions with self.notDone()?
     # 2. pop one item from <b>:exec</b>
@@ -79,10 +116,12 @@ module Nudge
       end
     end
     
+    
     def instructions
       @instructions_library.keys
     end
     
+    
     # invoke self.step() until a termination condition is true
     def run
       while notDone?
@@ -90,14 +129,17 @@ module Nudge
       end
     end
     
+    
     def lookup(name)
       @variables[name] || @names[name]
     end
     
+    
     def references
       @names.merge(@variables).keys
     end
     
+    
     def enable(item)
       if item.superclass == Instruction
         @instructions_library[item] = item.new(self)
@@ -106,28 +148,30 @@ module Nudge
       end
     end
     
+    
     def active?(item)
-      puts "#{item.inspect} is the item"
       if item.superclass == Instruction
         @instructions_library.include?(item)
-      elsif item.include? NudgeType
-        puts "#{@types} is the type list"
-        
+      elsif item.include? NudgeType        
         @types.include?(item)
       end
     end
     
     
     def bind_variable(name, value)
-      raise(ArgumentError, "Variables can only be bound to Literals") unless value.kind_of?(LiteralPoint)
+      raise(ArgumentError, "Variables can only be bound to ProgramPoints") unless
+        value.kind_of?(ProgramPoint)
       @variables[name] = value
     end
     
+    
     def bind_name(name, value)
-      raise(ArgumentError, "Names can only be bound to Literals") unless value.kind_of?(LiteralPoint)
+      raise(ArgumentError, "Names can only be bound to ProgramPoints") unless
+        value.kind_of?(ProgramPoint)
       @names[name] = value
     end
     
+    
     def next_name
       @last_name = @last_name.next
     end
@@ -137,24 +181,29 @@ module Nudge
       @variables.delete(name)
     end
     
+    
     def unbind_name(name)
       @names.delete(name)
     end
     
+    
     def reset_variables
       @variables = Hash.new
     end
     
+    
     def reset_names
       @names = Hash.new
     end
     
+    
     def enable_all_instructions
       Instruction.all_instructions.each do |i|
         @instructions_library[i] = i.new(self)
       end
     end
     
+    
     def enable_all_types
       @types = NudgeType.all_types
     end
@@ -168,10 +217,12 @@ module Nudge
       end
     end
     
+    
     def disable_all_instructions
       @instructions_library = Hash.new
     end
     
+    
     def disable_all_types
       @types = []
     end