nudge 0.0.1

data/lib/interpreter/grammars/nudge_language.treetop

@@ -0,0 +1,83 @@
+grammar NudgeLanguage
+  
+  rule any_point
+    nonblock_point / block_point
+  end
+
+  rule block_point
+    spc? "block" spc* open_block innards:(any_point)* spc* close_block <BlockNode>
+  end
+  
+  rule nonblock_point
+    instruction_statement /
+    channel_statement /
+    literal_statement /
+    erc_statement
+  end
+  
+  rule instruction_statement
+    spc? "do" spc opcode:alpha_or_underscore spc* <InstructionNode>
+  end
+  
+  rule channel_statement
+    spc? "ref" spc chan_name:alpha_or_underscore spc* <ChannelNode>
+  end
+  
+  rule literal_statement
+    code_literal_statement / noncode_literal_statement
+  end
+  
+  rule noncode_literal_statement
+    spc? "literal" spc where:alpha_or_underscore spc* open_leaf assigned_value:most_anything close_leaf <LiteralNode>
+  end
+  
+  rule code_literal_statement
+    spc? "literal" spc where:"code" spc* open_leaf assigned_value:most_anything close_leaf <LiteralNode>
+  end
+  
+  rule erc_statement
+    code_literal_statement / noncode_erc_statement
+  end
+  
+  rule noncode_erc_statement
+    spc? "sample" spc where:alpha_or_underscore spc* open_leaf assigned_value:most_anything close_leaf <ERCNode>
+  end
+  
+  rule code_erc_statement
+    spc? "sample" spc where:"code" spc* open_leaf assigned_value:most_anything close_leaf <ERCNode>
+  end
+  
+  
+  rule comma
+    spc? "," spc?
+  end
+  
+  rule most_anything
+    (!')' . )*
+  end
+  
+  rule alpha_or_underscore
+    [a-zA-Z_] [a-zA-Z0-9_]*
+  end
+  
+  rule spc
+    [\s\t\n]+
+  end
+  
+  rule open_block
+    "{" spc?
+  end
+  
+  rule open_leaf
+    "(" spc?
+  end
+  
+  rule close_leaf
+    spc? ")" spc?
+  end
+  
+  rule close_block
+    spc? "}" spc?
+  end
+  
+end

data/lib/interpreter/grammars/nudge_language_helpers.rb

@@ -0,0 +1,64 @@
+# coding: utf-8
+module BlockNode
+  def to_points
+    newBlob = CodeBlock.new(text_value)
+    newBlob.contents = innards.elements.collect {|item| item.to_points}
+    newBlob.listing = newBlob.tidy
+    return newBlob
+  end
+end
+
+module InstructionNode
+  def instruction_name
+    return opcode.text_value
+  end
+  
+  def to_points
+    newBlob = InstructionPoint.new(opcode.text_value)
+    return newBlob
+  end
+end
+
+module ChannelNode
+  def channel_name
+    return chan_name.text_value
+  end
+  
+  def to_points
+    newBlob = ChannelPoint.new(channel_name)
+    return newBlob
+  end
+  
+end
+
+module LiteralNode
+  def stack_name
+    return where.text_value
+  end
+  
+  def value
+    # this depends on existence of class {stack_name}Literal with #build that returns
+    "#{stack_name.capitalize}Type".constantize.from_s(assigned_value.text_value)
+  end
+  
+  def to_points
+    newBlob = LiteralPoint.new(stack_name,value)
+    return newBlob
+  end
+end
+
+module ERCNode
+  def stack_name
+    return where.text_value
+  end
+  
+  def value
+    # this depends on existence of class {stack_name}Erc with #build that returns the value
+    "#{stack_name.capitalize}Type".constantize.from_s(assigned_value.text_value)
+  end
+  
+  def to_points
+    newBlob = Erc.new(stack_name,value)
+    return newBlob
+  end
+end

data/lib/interpreter/interpreter.rb

@@ -0,0 +1,176 @@
+module Nudge
+  
+  # The Interpreter class executes the Push3 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), ...
+  #       * ... 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
+  
+  class Interpreter
+    attr_accessor :parser, :stepLimit, :steps
+    attr_accessor :stacks, :instructions_library, :variables, :names, :types
+    attr_accessor :last_name, :evaluate_channels
+    
+    # A program to be interpreted can be passed in as an optional parameter
+    def initialize(params = {})
+      initialProgram = params[:program] || ""
+      @types = params[:types] || NudgeType.all_types
+      @stepLimit = params[:step_limit] || 3000
+      
+      instructions = params[:instructions] || []
+      @instructions_library = Hash.new
+      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
+      @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,
+    #    * parses the program
+    #    * 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="")
+      self.clear_stacks
+      @steps = 0
+      parsed = @parser.parse(program)
+      newCode = parsed.to_points if parsed
+      @stacks[:exec].push(newCode)
+      @evaluate_channels = true
+    end
+    
+    
+    def clear_stacks
+      @stacks = Hash.new {|hash, key| hash[key] = Stack.new(key) }
+    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?
+    def notDone?
+      @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>
+    # 3. call its go() method
+    # 4. increment the step counter self#steps
+    def step
+      if notDone?
+        nextPoint = @stacks[:exec].pop
+        nextPoint.go(self)
+        @steps += 1
+      end
+    end
+    
+    def instructions
+      @instructions_library.keys
+    end
+    
+    # invoke self.step() until a termination condition is true
+    def run
+      while notDone?
+        self.step
+      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)
+      elsif item.superclass == NudgeType
+        @types |= [item]
+      end
+    end
+    
+    def active?(item)
+      if item.superclass == Instruction
+        @instructions_library.include?(item)
+      elsif item.superclass == 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)
+      @variables[name] = value
+    end
+    
+    def bind_name(name, value)
+      raise(ArgumentError, "Names can only be bound to Literals") unless value.kind_of?(LiteralPoint)
+      @names[name] = value
+    end
+    
+    def next_name
+      @last_name = @last_name.next
+    end
+    
+    
+    def unbind_variable(name)
+      @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
+    
+    
+    def disable(item)
+      if item.superclass == Instruction
+        @instructions_library.delete(item)
+      elsif item.superclass == NudgeType
+        @types.delete(item)
+      end
+    end
+    
+    def disable_all_instructions
+      @instructions_library = Hash.new
+    end
+    
+    def disable_all_types
+      @types = []
+    end
+  end
+end

data/lib/interpreter/programPoints.rb

@@ -0,0 +1,236 @@
+module Nudge
+  
+  class ProgramPoint
+    def points
+      1
+    end
+  end
+  
+  
+  class CodeBlock < ProgramPoint
+    @@parser = NudgeLanguageParser.new
+    
+    def initialize(code = "block {}")
+      @listing = code
+    end
+    
+    def listing=(rawCode)
+      @listing = rawCode
+    end
+    
+    def listing
+      @listing ||= "block {}"
+    end
+    
+    def value
+      @listing
+    end
+    
+    def contents=(newArray)
+      @contents = newArray
+    end
+    
+    def contents
+      @contents ||= self.reparse
+    end
+    
+    def reparse
+      clone = @@parser.parse(@listing).to_points
+      @listing = clone.listing
+      return clone.contents
+    end
+    
+    def points
+      if @contents
+        @listing.split(/\n/).length
+      else
+        self.reparse
+        @listing.split(/\n/).length
+      end
+    end
+    
+    def go(context)
+      @contents.reverse.each {|item| context.stacks[:exec].push(item)} 
+    end
+    
+    def tidy(level=1)
+      tt = "block {"
+      indent = level*2
+      @contents.each {|item| tt += ("\n" + (" "*indent) + item.tidy(level+1))}
+      tt += "}"
+      return tt
+    end
+  end
+  
+  
+  class LiteralPoint < ProgramPoint
+    attr_accessor :type, :value
+    
+    def initialize(type,value)
+      @type = type.to_sym
+      @value = value
+    end
+    
+    def go(context)
+      context.stacks[self.type].push(self)
+    end
+    
+    def tidy(level=1)
+      "literal " + @type.to_s + " (" + @value.to_s + ")"
+    end
+    
+    def randomize(context)
+      raise(ArgumentError,"Random code cannot be created") if context.types == [CodeType]
+      newType = context.types.sample
+      @type = newType.to_s.slice(0..-5).downcase
+      if newType != CodeType
+        @value = newType.any_value
+      else
+        @value = newType.any_value(context)
+      end
+    end
+    
+    def self.any(context)
+      tmp = LiteralPoint.new("int", 1)
+      tmp.randomize(context)
+      return tmp
+    end
+    
+    def listing
+      self.tidy
+    end
+  end
+  
+  
+  class Erc < ProgramPoint
+    attr_accessor :type, :value
+    def initialize(type, value)
+      @type = type.to_sym
+      @value = value
+    end
+    
+    def to_literal()
+      LiteralPoint.new(@type,@value)
+    end
+    
+    def go(context)
+      self.to_literal.go(context)
+    end
+    
+    def tidy(level=1)
+      "sample " + @type.to_s + " (" + @value.to_s + ")"
+    end
+    
+    def randomize(context)
+      newType = context.types.sample
+      @type = newType.to_s.slice(0..-5).downcase
+      if newType != CodeType
+        @value = newType.any_value
+      else
+        @value = newType.any_value(context)
+      end
+    end
+    
+    def resample
+      @value = "#{@type.to_s.capitalize}Type".constantize.any_value
+    end
+    
+    def self.any(context)
+      tmp = Erc.new(context.types[0].to_s.slice(0..-5).downcase,0)
+      tmp.randomize(context)
+      return tmp
+    end
+    
+    def listing
+      self.tidy
+    end
+  end
+  
+  
+  class ChannelPoint < ProgramPoint
+    
+    def self.any(context)
+      tmp = ChannelPoint.new("e")
+      tmp.randomize(context)
+      return tmp
+    end
+    
+    attr_accessor :name
+    alias value name
+    
+    def initialize(var_name)
+      @name = var_name
+    end
+    
+    def go(context)
+      lookedUp = context.lookup(@name) if context.evaluate_channels
+      if lookedUp
+        context.stacks[:exec].push(lookedUp)
+      else
+        context.stacks[:name].push(self)
+        context.evaluate_channels = true
+      end
+    end
+    
+    def tidy(level=1)
+      "ref " + @name
+    end
+    
+    def randomize(context)
+      which = context.references.sample
+      @name = which
+    end
+    
+    def listing
+      self.tidy
+    end
+  end
+  
+  
+  class InstructionPoint < ProgramPoint
+    attr_accessor :name, :requirements, :effects
+    def initialize(name)
+      @name = name
+    end
+    
+    def className
+      "#{@name.camelize}Instruction"
+    end
+    
+    def classLookup
+      self.className.constantize
+    rescue NameError
+      raise InstructionNotFoundError, "#{self.className} not found"
+    end
+    
+    def tidy(level=1)
+      "do " + @name
+    end
+    
+    class InstructionNotFoundError < NameError
+    end
+    
+    def go(context)
+      className = self.classLookup
+      context.instructions_library[className].go
+    rescue InstructionNotFoundError
+      return
+    end
+    
+    def randomize(context)
+      instructionName = context.instructions.sample.to_s
+      @name = instructionName.slice(0..-12).underscore
+    end
+    
+    def self.any(context)
+      tmp = InstructionPoint.new("int_add")
+      tmp.randomize(context)
+      return tmp
+    end
+    
+    def listing
+      self.tidy
+    end
+  end
+  
+end

data/lib/interpreter/stack.rb

@@ -0,0 +1,39 @@
+module Nudge
+  
+  # Nudge Stacks are Arrays with some added convenience functions.
+  class Stack
+    delegate :clear, :to => :entries
+    
+    attr_accessor :entries
+    attr_reader :name
+    
+    # Stack name must be a symbol
+    def initialize(name)
+      raise(ArgumentError,"Stack name must be a Symbol") if !name.kind_of?(Symbol)
+      @name = name
+      @entries = []
+    end
+    
+    # Only non-nil objects can be pushed; there is no type checking or validation beyond that.
+    def push(item)
+      @entries.push(item) unless item == nil
+    end
+    
+    # Removes the last item pushed to the Stack and returns it
+    def pop
+      return @entries.pop
+    end
+    
+    # Reference to the last item pushed to the Stack. Doesn't remove it
+    def peek
+      return @entries.last
+    end
+    
+    # Stack#depth returns the number of items
+    def depth
+      @entries.length
+    end
+    
+  end
+  
+end

data/lib/interpreter/types/codeType.rb

@@ -0,0 +1,108 @@
+# coding: utf-8
+
+class CodeType < NudgeType
+  @@defaultPoints = 20
+  
+  def self.random_skeleton(points=@@defaultPoints, blocks=points/10)
+    blocks = [0,[points,blocks].min].max
+    
+    if points > 1
+      skel = ["block {"]
+      (points-2).times {skel << "*"}
+      skel << "*}"
+      front = 0
+      (blocks-1).times do
+        until skel[front].include?("*") do
+          a,b = rand(points), rand(points)
+          front,back = [a,b].min, [a,b].max
+        end
+        skel[front] = skel[front].sub(/\*/," block {")
+        skel[back] = skel[back] + "}"
+      end
+      skel = skel.join
+    else
+      if blocks>0
+        skel = "block {}"
+      else
+        skel = "*"
+      end
+    end
+    return skel
+  end
+  
+  
+  def self.any_type(types)
+    raise(ArgumentError,"no available NudgeTypes") if types.empty?
+    return types.sample
+  end
+  
+  
+  def self.any_instruction(instructions)
+    raise(ArgumentError,"no available Instructions") if instructions.empty?
+    return instructions.sample
+  end
+  
+  
+  def self.any_reference(references)
+    raise(ArgumentError,"no available references") if references.empty?
+    return references.sample
+  end
+  
+  
+  def self.roulette_wheel(references, instructions, types)
+    basis = Hash["reference", references.length,
+      "instruction", instructions.length,
+      "sample", types.length]
+    sum = basis.values.inject(:+)
+    spin = rand(sum)
+    basis.each do |result,weight|
+      return result if spin <= weight && weight > 0
+      spin -= weight
+    end
+    raise "A problem occurred when executing CodeType#roulette_wheel"
+  end
+  
+  
+  def self.random_value(context, params = {})
+    points = params[:points] || @@defaultPoints
+    blocks = params[:blocks] || points/10
+    skeleton = params[:skeleton] || self.random_skeleton(points, blocks)
+    instructions = params[:instructions] || context.instructions
+    references = params[:references] || context.references
+    types = params[:types] || context.types
+    
+    while skeleton.include?("*") do
+      case self.roulette_wheel(references,instructions,types)
+      when "instruction"
+        newPoint = " do " + self.any_instruction(instructions).to_nudgecode
+      when "reference"
+        newPoint = " ref " + self.any_reference(references)
+      when "sample"
+        theType = any_type(types)
+        if theType == CodeType
+          if types != [CodeType]
+            theType = self.any_type(types - [CodeType])
+          else
+            raise ArgumentError, "Random code cannot be created"
+          end
+        end
+        newPoint = " sample " + theType.to_nudgecode + " (" + theType.any_value.to_s + ")"
+      else
+        raise ArgumentError, "Nothing to make random code from"
+      end
+      skeleton = skeleton.sub(/\*/, newPoint)
+      skeleton = skeleton.sub(/\n/,'')
+    end
+    skeleton
+  end
+  
+  
+  
+  def self.from_s(string_value)
+    return string_value.sub(/\(/,"«").sub(/\)/,"»")
+  end
+  
+  def self.any_value(context)
+    self.random_value(context)
+  end
+end