tp_plus 0.0.73

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 67da7b5806591383225c3d09717b6df2951a3c39
+  data.tar.gz: d11d8ac4716e5cccfc17b9913d587b2209a3438f
+SHA512:
+  metadata.gz: 82ef1ac3fbfa26321b17e679613c69b7bb43ccb5997f927fe2c8a87677600996a93e3f42708b2f997aaab7e83caefbc6e8ddbc82ef786c1a6209d928387fc9ef
+  data.tar.gz: fc6b978abb2f2952d3622f165549b0c7e700c0e60b78ebc2b6496201216f7a666cf62835be5ca9605692a5e7fb98488a957382ac5fdf9fe6086bf7592d62bd02

data/README.md

@@ -0,0 +1,65 @@
+TP+
+===
+
+TP+ is a higher-level language abstraction that translates into FANUC
+TP. It features many useful utilities that makes creating TP programs
+easier:
+
+* Identifiers for registers, position registers, IO, etc.
+* Re-usable methods
+* If-else blocks
+* Readable motion statements
+* Automatic label numbering
+
+Of course adding another layer of abstraction takes you a step further
+away from the code the robot is running. However, it's hoped that the
+increased productivity and rigid syntax requirements will actually
+improve your TP code.
+
+Examples
+--------
+
+example_1.tpp
+
+    foo  := R[1]
+
+    bar  := DO[1]
+    baz  := DO[2]
+
+    home := PR[1]
+
+
+    foo = 1
+
+    @loop
+      foo += 1
+
+      jump_to @foo if foo < 10
+
+    turn_on bar if foo == 5
+    toggle baz
+
+    linear_move.to(home).at(2000mm/s).term(0)
+
+
+example_1.ls
+
+    /PROG example_1
+    /MN
+      1:  R[1:foo] = 1 ;
+      1:   ;
+      1:  LBL[1:loop] ;
+      1:  R[1:foo]=R[1:foo]+1 ;
+      1:  IF R[1:foo]<10,JMP LBL[1] ;
+      1:   ;
+      1:  IF (R[1:foo]=5),DO[1:bar]=(ON) ;
+      1:  DO[2:baz]=(!DO[2:baz]) ;
+      1:   ;
+      1:  L PR[1:home] 2000mm/sec CNT0 ;
+    /END
+
+
+License
+-------
+
+TP+ is released under the [MIT License](http://www.opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,21 @@
+namespace :compile do
+  task :parser do
+    sh "racc -l -o lib/tp_plus/parser.rb generators/parser.y"
+  end
+
+  task :scanner do
+    sh "rex generators/scanner.rex -o lib/tp_plus/scanner.rb --stub"
+  end
+end
+
+task compile: ["compile:parser","compile:scanner"]
+
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/**/test_*.rb']
+  t.verbose = true
+end
+
+task default: :test

data/bin/tpp

@@ -0,0 +1,73 @@
+#!/usr/bin/env ruby
+require 'tp_plus'
+require 'optparse'
+
+options = {}
+OptionParser.new do |opts|
+  opts.banner = "Usage: tpp [options] filename"
+
+  opts.on("-e", "--environment env_file.tpp", "Require an environment file before parsing files") do |e|
+    options[:environment] = e
+  end
+
+  opts.on_tail("-h", "--help", "Show this message") do
+    puts opts
+    exit
+  end
+end.parse!
+
+def contents(filename)
+  if !File.exist?(filename)
+    puts "File (#{filename}) does not exist"
+    exit
+  end
+  f = File.open(filename,'rb')
+  src = f.read
+  f.close
+  return src
+end
+
+scanner = TPPlus::Scanner.new
+parser = TPPlus::Parser.new(scanner)
+interpreter = parser.interpreter
+if options[:environment]
+  interpreter.load_environment(contents(options[:environment]))
+end
+
+if ARGV.length != 1
+  puts "Must provide filename argument. See tpp --help for details"
+  exit
+end
+
+src = contents(ARGV[0])
+
+scanner.scan_setup(src)
+parser.parse
+
+lines = interpreter.eval
+
+tpp_filename = File.basename(ARGV[0],".*")
+output = %(/PROG #{tpp_filename.upcase}
+/ATTR
+COMMENT = "#{interpreter.header_data[:comment] || tpp_filename.upcase}";
+TCD:  STACK_SIZE	= 0,
+      TASK_PRIORITY	= 50,
+      TIME_SLICE	= 0,
+      BUSY_LAMP_OFF	= 0,
+      ABORT_REQUEST	= 0,
+      PAUSE_REQUEST	= #{interpreter.header_data[:ignore_pause] ? "7" : "0"};
+DEFAULT_GROUP = #{interpreter.header_data[:group_mask] || "1,*,*,*,*"};
+/MN\n)
+
+lines.each_line do |line|
+  output += " : " + line
+end
+
+if interpreter.pos_section != ""
+  output += "/POS\n"
+  output += interpreter.pos_section
+end
+
+output += %(/END\n)
+
+print output

data/lib/tp_plus/interpreter.rb

@@ -0,0 +1,129 @@
+require 'tp_plus/parser'
+
+module TPPlus
+  class Interpreter
+    attr_accessor :line_count, :nodes, :position_data, :header_data
+    attr_reader :labels, :variables, :constants, :namespaces, :source_line_count
+    def initialize
+      @line_count    = 0
+      @nodes         = []
+      @labels        = {}
+      @namespaces    = {}
+      @variables     = {}
+      @constants     = {}
+      @position_data = {}
+      @header_data   = {}
+      @current_label = 99
+    end
+
+    def load_environment(string)
+      scanner = TPPlus::Scanner.new
+      parser = TPPlus::Parser.new(scanner, self)
+      scanner.scan_setup(string)
+      parser.parse
+      eval
+    rescue RuntimeError => e
+      raise "Runtime error in environment on line #{@source_line_count}:\n#{e}"
+    end
+
+    def next_label
+      @current_label += 1
+    end
+
+    def add_namespace(name, block)
+      if @namespaces[name.to_sym].nil?
+        @namespaces[name.to_sym] = TPPlus::Namespace.new(name, block)
+      else
+        @namespaces[name.to_sym].reopen!(block)
+      end
+    end
+
+    def add_label(identifier)
+      raise "Label @#{identifier} already defined" if @labels[identifier.to_sym]
+      @labels[identifier.to_sym] = next_label
+    end
+
+    def add_var(identifier, node)
+      raise "Variable #{identifier} already defined" if @variables[identifier.to_sym]
+
+      @variables[identifier.to_sym] = node
+      node.comment = identifier
+    end
+
+    def add_constant(identifier, node)
+      raise "Constant #{identifier} already defined" if @constants[identifier.to_sym]
+
+      @constants[identifier.to_sym] = node
+    end
+
+    def get_namespace(identifier)
+      if ns = @namespaces[identifier.to_sym]
+        return ns
+      end
+
+      false
+    end
+
+    def get_var(identifier)
+      raise "Variable (#{identifier}) not defined" if @variables[identifier.to_sym].nil?
+
+      @variables[identifier.to_sym]
+    end
+
+    def get_constant(identifier)
+      raise "Constant (#{identifier}) not defined" if @constants[identifier.to_sym].nil?
+
+      @constants[identifier.to_sym]
+    end
+
+    def define_labels
+      @nodes.select {|n| n.is_a? Nodes::LabelDefinitionNode}.each do |n|
+        add_label(n.identifier)
+      end
+    end
+
+    def pos_section
+      return "" if @position_data.empty?
+      return "" if @position_data[:positions].empty?
+
+      @position_data[:positions].inject("") do |s,p|
+        s << %(P[#{p[:id]}:"#{p[:comment]}"]{
+   GP#{p[:group]}:
+  UF : #{p[:uframe]}, UT : #{p[:utool]},  CONFIG : '#{p[:config][:flip] ? 'F' : 'N'} #{p[:config][:up] ? 'U' : 'D'} #{p[:config][:top] ? 'T' : 'B'}, #{p[:config][:turn_counts].join(', ')}',
+  X = #{p[:components][:x]} mm, Y = #{p[:components][:y]} mm, Z = #{p[:components][:z]} mm,
+  W = #{p[:components][:w]} deg, P = #{p[:components][:p]} deg, R = #{p[:components][:r]} deg
+};\n)
+      end
+    end
+
+    def eval
+      s = ""
+      last_node = nil
+
+      define_labels
+
+      @source_line_count = 0
+
+      @nodes.each do |n|
+        @source_line_count += 1 unless n.is_a?(Nodes::TerminatorNode) && !last_node.is_a?(Nodes::TerminatorNode)
+        raise if n.is_a?(String)
+
+        res = n.eval(self)
+
+        # preserve whitespace
+        if n.is_a?(Nodes::TerminatorNode) && last_node.is_a?(Nodes::TerminatorNode)
+          s += " ;\n"
+        end
+        last_node = n
+        # end preserve whitespace
+
+        next if res.nil?
+
+        s += "#{res} ;\n"
+      end
+      s
+    rescue RuntimeError => e
+      raise "Runtime error on line #{@source_line_count}:\n#{e}"
+    end
+  end
+end

data/lib/tp_plus/namespace.rb

@@ -0,0 +1,66 @@
+module TPPlus
+  class Namespace
+    def initialize(name, block)
+      @name       = name
+      @block      = block
+      @namespaces = {}
+      @variables  = {}
+      @constants  = {}
+
+      define!
+    end
+
+    def define!
+      @block.flatten.select {|n| [TPPlus::Nodes::DefinitionNode, TPPlus::Nodes::NamespaceNode].include? n.class }.each do |node|
+        node.eval(self)
+      end
+    end
+
+    def reopen!(block)
+      @block = block
+      define!
+    end
+
+    def add_constant(identifier, node)
+      raise "Constant (#{identifier}) already defined within namespace #{@name}" unless @constants[identifier.to_sym].nil?
+
+      @constants[identifier.to_sym] = node
+    end
+
+    def add_namespace(identifier, block)
+      if @namespaces[identifier.to_sym].nil?
+        @namespaces[identifier.to_sym] = TPPlus::Namespace.new("#{@name} #{identifier}", block)
+      else
+        @namespaces[identifier.to_sym].reopen!(block)
+      end
+    end
+
+    def add_var(identifier, node)
+      raise "Variable (#{identifier}) already defined within namespace #{@name}" unless @variables[identifier.to_sym].nil?
+
+      @variables[identifier.to_sym] = node
+      node.comment = "#{@name} #{identifier}"
+    end
+
+    def get_constant(identifier)
+      raise "Constant (#{identifier}) not defined within namespace #{@name}" if @constants[identifier.to_sym].nil?
+
+      @constants[identifier.to_sym]
+    end
+
+    def get_var(identifier)
+      return get_constant(identifier) if identifier.upcase == identifier
+      raise "Variable (#{identifier}) not defined within namespace #{@name}" if @variables[identifier.to_sym].nil?
+
+      @variables[identifier.to_sym]
+    end
+
+    def get_namespace(identifier)
+      if ns = @namespaces[identifier.to_sym]
+        return ns
+      end
+
+      false
+    end
+  end
+end

data/lib/tp_plus/nodes/abort_node.rb

@@ -0,0 +1,9 @@
+module TPPlus
+  module Nodes
+    class AbortNode
+      def eval(context)
+        "ABORT"
+      end
+    end
+  end
+end

data/lib/tp_plus/nodes/argument_node.rb

@@ -0,0 +1,19 @@
+module TPPlus
+  module Nodes
+    class ArgumentNode
+      attr_accessor :comment
+      def initialize(id)
+        @id = id
+        @comment = comment
+      end
+
+      def requires_mixed_logic?(context)
+        true
+      end
+
+      def eval(context,options={})
+        "AR[#{@id}]"
+      end
+    end
+  end
+end

data/lib/tp_plus/nodes/assignment_node.rb

@@ -0,0 +1,45 @@
+module TPPlus
+  module Nodes
+    class AssignmentNode
+      attr_reader :identifier, :assignable
+      def initialize(identifier,assignable)
+        @identifier = identifier
+        @assignable = assignable
+      end
+
+      def assignable_string(context,options={})
+        if @assignable.is_a?(ExpressionNode)
+          options[:mixed_logic] = true if @assignable.contains_expression?
+          options[:mixed_logic] = true if @assignable.op.requires_mixed_logic?(context)
+          options[:mixed_logic] = true if @assignable.op.boolean?
+          options[:mixed_logic] = true if @assignable.boolean_result?
+        else
+          options[:mixed_logic] = true if @assignable.requires_mixed_logic?(context)
+          options[:mixed_logic] = true if @identifier.requires_mixed_logic?(context)
+        end
+
+        if options[:mixed_logic]
+          "(#{@assignable.eval(context)})"
+        else
+          @assignable.eval(context)
+        end
+      end
+
+      def requires_mixed_logic?(context)
+        true
+      end
+
+      def can_be_inlined?
+        true
+      end
+
+      def identifier_string(context)
+        @identifier.eval(context)
+      end
+
+      def eval(context,options={})
+        "#{identifier_string(context)}=#{assignable_string(context,options)}"
+      end
+    end
+  end
+end

data/lib/tp_plus/nodes/call_node.rb

@@ -0,0 +1,34 @@
+module TPPlus
+  module Nodes
+    class CallNode
+      attr_reader :args
+      def initialize(program_name, args, options={})
+        @program_name = program_name
+        @args = args
+        @async = options[:async]
+      end
+
+      def requires_mixed_logic?(context)
+        false
+      end
+
+      def async?
+        @async
+      end
+
+      def args_string(context)
+        return "" unless @args.any?
+
+        "(" + @args.map {|a| a.eval(context) }.join(",") + ")"
+      end
+
+      def can_be_inlined?
+        true
+      end
+
+      def eval(context,options={})
+        "#{async? ? "RUN" : "CALL"} #{@program_name.upcase}#{args_string(context)}"
+      end
+    end
+  end
+end

data/lib/tp_plus/nodes/case_condition_node.rb

@@ -0,0 +1,26 @@
+module TPPlus
+  module Nodes
+    class CaseConditionNode
+      def initialize(condition, block)
+        @condition = condition
+        @block = block
+      end
+
+      def eval(context, options={})
+        options[:no_indent] ||= false
+
+        s = ""
+        if !options[:no_indent]
+          s += "       "
+        end
+
+        if @condition
+          s += "=#{@condition.eval(context)},#{@block.eval(context)}"
+        else
+          s += "ELSE,#{@block.eval(context)}"
+        end
+        s
+      end
+    end
+  end
+end

data/lib/tp_plus/nodes/case_node.rb

@@ -0,0 +1,33 @@
+module TPPlus
+  module Nodes
+    class CaseNode
+      def initialize(var, conditions, else_condition)
+        @var = var
+        @conditions = conditions
+        @else_condition = else_condition
+      end
+
+      def else_condition(context)
+        return "" if @else_condition.nil?
+
+        " ;\n#{@else_condition.eval(context)}"
+      end
+
+      def other_conditions(context)
+        return "" if @conditions.empty?
+
+        s = " ;\n"
+        @conditions.reject! {|c| c.nil? }.each do |c|
+          s += c.eval(context)
+          s += " ;\n" unless c == @conditions.last
+        end
+
+        s
+      end
+
+      def eval(context)
+        "SELECT #{@var.eval(context)}#{@conditions.shift.eval(context, no_indent: true)}#{other_conditions(context)}#{else_condition(context)}"
+      end
+    end
+  end
+end

data/lib/tp_plus/nodes/comment_node.rb

@@ -0,0 +1,22 @@
+module TPPlus
+  module Nodes
+    class CommentNode
+      def initialize(text)
+        @text = text[1,text.length]
+      end
+
+      def can_be_inlined?
+        false
+      end
+
+      def eval(context)
+        s = ""
+        width = 29
+        @text.scan(/\S.{0,#{width}}\S(?=\s|$)|\S+/).each do |piece|
+          s += "! #{piece} ;\n"
+        end
+        s[0,s.length-3]
+      end
+    end
+  end
+end

data/lib/tp_plus/nodes/conditional_node.rb

@@ -0,0 +1,54 @@
+module TPPlus
+  module Nodes
+    class ConditionalNode
+      def initialize(type,condition,true_block,false_block)
+        @type        = type
+        @condition   = condition
+        @true_block  = true_block.flatten.reject  {|n| n.is_a? TerminatorNode }
+        @false_block = false_block.flatten.reject {|n| n.is_a? TerminatorNode }
+      end
+
+      def true_label(context)
+        @true_label ||= context.next_label
+      end
+
+      def end_label(context)
+        @end_label ||= context.next_label
+      end
+
+      def true_block(context)
+        @t ||= string_for(@true_block,context)
+      end
+
+      def false_block(context)
+        @f ||= string_for(@false_block,context)
+      end
+
+      def string_for(block,context)
+        block.inject("") {|s,n| s << "#{n.eval(context)} ;\n" }
+      end
+
+      def can_be_inlined?
+        return false unless @false_block.empty?
+        return false unless @true_block.length == 1
+
+        @true_block.first.can_be_inlined?
+      end
+
+      def opposite?
+        @type == "if"
+      end
+
+      def eval(context, options={})
+        return InlineConditionalNode.new(@type,@condition,@true_block.first).eval(context) if can_be_inlined?
+
+        if @false_block.empty?
+          "IF #{@condition.eval(context,opposite: opposite?, as_condition: true)},JMP LBL[#{true_label(context)}] ;\n#{true_block(context)}LBL[#{true_label(context)}]"
+        else
+          # could be if-else or unless-else
+          "IF #{@condition.eval(context,opposite: opposite?, as_condition: true)},JMP LBL[#{true_label(context)}] ;\n#{true_block(context)}JMP LBL[#{end_label(context)}] ;\nLBL[#{true_label(context)}] ;\n#{false_block(context)}LBL[#{end_label(context)}]"
+        end
+      end
+    end
+  end
+end

data/lib/tp_plus/nodes/definition_node.rb

@@ -0,0 +1,22 @@
+module TPPlus
+  module Nodes
+    class DefinitionNode
+      attr_reader :identifier, :assignable
+      def initialize(identifier,assignable)
+        @identifier = identifier
+        @assignable = assignable
+      end
+
+      def eval(context)
+        if @assignable.is_a?(DigitNode) || @assignable.is_a?(RealNode)
+          raise "Constants must be defined with all CAPS" unless @identifier.upcase == @identifier
+
+          context.add_constant(@identifier, @assignable)
+        else
+          context.add_var(@identifier, @assignable)
+        end
+        nil
+      end
+    end
+  end
+end

data/lib/tp_plus/nodes/digit_node.rb

@@ -0,0 +1,21 @@
+module TPPlus
+  module Nodes
+    class DigitNode
+      def initialize(value)
+        @value = value
+      end
+
+      def requires_mixed_logic?(context)
+        false
+      end
+
+      def eval(context, options={})
+        if @value < 0
+          "(#{@value})"
+        else
+          @value
+        end
+      end
+    end
+  end
+end

data/lib/tp_plus/nodes/eval_node.rb

@@ -0,0 +1,13 @@
+module TPPlus
+  module Nodes
+    class EvalNode
+      def initialize(string)
+        @string = string
+      end
+
+      def eval(context)
+        @string
+      end
+    end
+  end
+end