tp_plus 0.0.73

data/lib/tp_plus/nodes/expression_node.rb

@@ -0,0 +1,65 @@
+module TPPlus
+  module Nodes
+    class ExpressionNode
+      attr_reader :left_op, :op, :right_op
+      attr_accessor :grouped
+      def initialize(left_op, op_string, right_op)
+        @left_op  = left_op
+        @op       = OperatorNode.new(op_string)
+        @right_op = right_op
+      end
+
+      def requires_mixed_logic?(context)
+        contains_expression? ||
+          @grouped ||
+          [@op, @left_op, @right_op].map { |op|
+            next if op.nil?
+            op.requires_mixed_logic?(context)
+          }.any?
+      end
+
+      def contains_expression?
+        [@left_op, @right_op].map {|op| op.is_a? ExpressionNode }.any?
+      end
+
+      def boolean_result?
+        case @op.string
+        when "&&","||","!","==","<>",">",">=","<","<="
+          true
+        else
+          false
+        end
+      end
+
+      def with_parens(string, context, options={})
+        return string unless options[:force_parens] || options[:as_condition] && requires_mixed_logic?(context)
+
+        "(#{string})"
+      end
+
+      def string_val(context, options={})
+        if @op.bang?
+          # this is for skip conditions, which do not
+          # support mixed logic
+          if options[:disable_mixed_logic]
+            "#{@left_op.eval(context)}=OFF"
+          else
+            "#{@op.eval(context,options)}#{@left_op.eval(context)}"
+          end
+        else
+          if @op.boolean? && options[:opposite]
+            "!#{@left_op.eval(context)}#{@op.eval(context,options)}!#{@right_op.eval(context)}"
+          else
+            "#{@left_op.eval(context)}#{@op.eval(context,options)}#{@right_op.eval(context)}"
+          end
+        end
+      end
+
+      def eval(context,options={})
+        options[:force_parens] = true if @grouped
+
+        with_parens(string_val(context, options), context, options)
+      end
+    end
+  end
+end

data/lib/tp_plus/nodes/for_node.rb

@@ -0,0 +1,20 @@
+module TPPlus
+  module Nodes
+    class ForNode
+      def initialize(var_node, initial_value_node, final_value_node, block)
+        @var_node           = var_node
+        @initial_value_node = initial_value_node
+        @final_value_node   = final_value_node
+        @block              = block.flatten.reject {|n| n.is_a?(TerminatorNode) }
+      end
+
+      def block(context)
+        @s ||= @block.inject("") {|s,n| s << "#{n.eval(context)} ;\n" }
+      end
+
+      def eval(context)
+        "FOR #{@var_node.eval(context)}=#{@initial_value_node.eval(context)} TO #{@final_value_node.eval(context)} ;\n#{block(context)}ENDFOR"
+      end
+    end
+  end
+end

data/lib/tp_plus/nodes/header_node.rb

@@ -0,0 +1,27 @@
+module TPPlus
+  module Nodes
+    class HeaderNode
+      def initialize(type, value)
+        @type  = type
+        @value = value
+      end
+
+      def eval(context, options={})
+        case @type
+        when "TP_IGNORE_PAUSE"
+          context.header_data[:ignore_pause] = @value
+        when "TP_COMMENT"
+          context.header_data[:comment] = @value
+        when "TP_GROUPMASK"
+          context.header_data[:group_mask] = @value
+        when "TP_SUBTYPE"
+          context.header_data[:subtype] = @value.to_sym
+        else
+          raise "Unsupported TP Header value (#{@type})"
+        end
+
+        nil
+      end
+    end
+  end
+end

data/lib/tp_plus/nodes/indirect_node.rb

@@ -0,0 +1,49 @@
+module TPPlus
+  module Nodes
+    class IndirectNode
+      def initialize(type, target)
+        @type = type
+        @target = target
+      end
+
+      def string
+        case @type
+        when :position
+          "P"
+        when :position_register
+          "PR"
+        when :flag
+          "F"
+        when :timer
+          "TIMER"
+        when :register
+          "R"
+        when :user_alarm
+          "UALM"
+        else
+          raise "Invalid indirect type"
+        end
+      end
+
+      def requires_mixed_logic?(context)
+        case @type
+        when :flag#, :timer
+          true
+        else
+          false
+        end
+      end
+
+      def eval(context,options={})
+        s = "#{string}[#{@target.eval(context)}]"
+        if options[:opposite]
+          s = "!#{s}"
+        end
+        if options[:as_condition]
+          s = "(#{s})"
+        end
+        s
+      end
+    end
+  end
+end

data/lib/tp_plus/nodes/inline_conditional_node.rb

@@ -0,0 +1,40 @@
+module TPPlus
+  module Nodes
+    class InlineConditionalNode
+      attr_reader :condition_node
+      def initialize(type, condition, block)
+        @type           = type
+        @condition_node = condition
+        @block          = block
+      end
+
+      def condition_requires_mixed_logic?(context)
+        @condition_node.is_a?(VarNode) ||
+          @condition_node.is_a?(NamespacedVarNode) ||
+          @condition_node.requires_mixed_logic?(context)
+      end
+
+      def block_requires_mixed_logic?(context)
+        @block.requires_mixed_logic?(context)
+      end
+
+      def can_be_inlined?
+        false
+      end
+
+      def condition(context,options={})
+        options[:opposite] ||= @type == "unless"
+
+        if condition_requires_mixed_logic?(context) || block_requires_mixed_logic?(context)
+          "(#{@condition_node.eval(context, options)})"
+        else
+          @condition_node.eval(context, options)
+        end
+      end
+
+      def eval(context)
+        "IF #{condition(context)},#{@block.eval(context,mixed_logic:true)}"
+      end
+    end
+  end
+end

data/lib/tp_plus/nodes/io_method_node.rb

@@ -0,0 +1,55 @@
+module TPPlus
+  module Nodes
+    class IOMethodNode
+      def initialize(method, target,options={})
+        @method = method
+        @target = target
+        @init_options = options
+      end
+
+      def requires_mixed_logic?(context)
+        true
+      end
+
+      def can_be_inlined?
+        true
+      end
+
+      def on_off(value,options={})
+        options[:mixed_logic] ? "(#{value})" : value
+      end
+
+      def pulse_time(context)
+        "%.1f" % case @init_options[:pulse_units]
+        when "s"
+          @init_options[:pulse_time].eval(context)
+        when "ms"
+          @init_options[:pulse_time].eval(context).to_f / 1000
+        else
+          raise "Invalid pulse units"
+        end
+      end
+
+      def pulse_extra(context)
+        return "" if @init_options[:pulse_time].nil?
+
+        ",#{pulse_time(context)}sec"
+      end
+
+      def eval(context,options={})
+        options[:mixed_logic] = true if @target.requires_mixed_logic?(context)
+
+        case @method
+        when "turn_on"
+          "#{@target.eval(context)}=#{on_off("ON",options)}"
+        when "turn_off"
+          "#{@target.eval(context)}=#{on_off("OFF",options)}"
+        when "toggle"
+          "#{@target.eval(context)}=(!#{@target.eval(context)})"
+        when "pulse"
+          "#{@target.eval(context)}=PULSE#{pulse_extra(context)}"
+        end
+      end
+    end
+  end
+end

data/lib/tp_plus/nodes/io_node.rb

@@ -0,0 +1,30 @@
+module TPPlus
+  module Nodes
+    class IONode
+      attr_accessor :comment
+      def initialize(type, id)
+        @type    = type
+        @id      = id.to_i
+        @comment = ""
+      end
+
+      def requires_mixed_logic?(context)
+        ["F","SO","SI","DI"].include?(@type) ? true : false
+      end
+
+      def result
+        "#{@type}[#{@id}:#{@comment}]"
+      end
+
+      def eval(context, options={})
+        s = result
+
+        if options[:disable_mixed_logic]
+          s = "#{s}=ON"
+        end
+
+        options[:force_parens] ? "(#{s})" : s
+      end
+    end
+  end
+end

data/lib/tp_plus/nodes/jump_node.rb

@@ -0,0 +1,23 @@
+module TPPlus
+  module Nodes
+    class JumpNode 
+      def initialize(identifier)
+        @identifier = identifier
+      end
+
+      def requires_mixed_logic?(context)
+        false
+      end
+
+      def can_be_inlined?
+        true
+      end
+
+      def eval(context,options={})
+        raise "Label (#{@identifier}) not found" if context.labels[@identifier.to_sym].nil?
+
+        "JMP LBL[#{context.labels[@identifier.to_sym]}]"
+      end
+    end
+  end
+end

data/lib/tp_plus/nodes/label_definition_node.rb

@@ -0,0 +1,21 @@
+module TPPlus
+  module Nodes
+    class LabelDefinitionNode
+      attr_reader :identifier
+      def initialize(identifier)
+        @identifier = identifier
+      end
+
+      def long_identifier_comment(context)
+        return "" unless @identifier.length > 16
+
+        " ;\n! #{@identifier}"
+      end
+
+      def eval(context)
+        #context.add_label(@identifier)
+        "LBL[#{context.labels[@identifier.to_sym]}:#{@identifier[0,16]}]#{long_identifier_comment(context)}"
+      end
+    end
+  end
+end

data/lib/tp_plus/nodes/motion_node.rb

@@ -0,0 +1,62 @@
+module TPPlus
+  module Nodes
+    class MotionNode
+      def initialize(type, destination, modifiers)
+        @type = type
+        @destination = destination
+        @modifiers = modifiers
+      end
+
+      def prefix
+        case @type
+        when "linear_move"
+          "L"
+        when "joint_move"
+          "J"
+        when "circular_move"
+          "C"
+        else
+          raise "Unsupported motion"
+        end
+      end
+
+      def speed_node
+        @speed_node ||= @modifiers.select {|m| m.is_a? SpeedNode }.first
+      end
+
+      def termination_node
+        @termination_node ||= @modifiers.select {|m| m.is_a? TerminationNode }.first
+      end
+
+      def actual_modifiers
+        @actual_modifiers ||= @modifiers.reject {|m| m.is_a? SpeedNode}.reject {|m| m.is_a? TerminationNode }
+      end
+
+      def modifiers_string(context)
+        return "" unless actual_modifiers.any?
+
+        strings_array = [""] << actual_modifiers.map { |m| m.eval(context) }
+        @modifiers_string = strings_array.join(" ")
+      end
+
+      def speed_valid?(context)
+        case @type
+        when "linear_move"
+          return true if speed_node.eval(context) == "max_speed"
+
+          ["mm/sec"].include? speed_node.units
+        when "joint_move"
+          return false if speed_node.eval(context) == "max_speed"
+
+          ["%"].include? speed_node.units
+        end
+      end
+
+      def eval(context)
+        raise "Speed is invalid for motion type" unless speed_valid?(context)
+
+        "#{prefix} #{@destination.eval(context)} #{speed_node.eval(context)} #{termination_node.eval(context)}#{modifiers_string(context)}"
+      end
+    end
+  end
+end

data/lib/tp_plus/nodes/namespace_node.rb

@@ -0,0 +1,16 @@
+module TPPlus
+  module Nodes
+    class NamespaceNode
+      attr_reader :block
+      def initialize(name, block)
+        @name = name
+        @block = block
+      end
+
+      def eval(context)
+        context.add_namespace(@name, @block)
+        nil
+      end
+    end
+  end
+end

data/lib/tp_plus/nodes/namespaced_var_node.rb

@@ -0,0 +1,38 @@
+module TPPlus
+  module Nodes
+    class NamespacedVarNode
+      attr_reader :namespaces
+      def initialize(namespaces, var_node)
+        @namespaces = namespaces
+        @var_node   = var_node
+      end
+
+      def namespace(context)
+        @context = context
+        @namespaces.each do |ns|
+          if @context.get_namespace(ns)
+            @context = @context.get_namespace(ns)
+          end
+        end
+
+        @context
+      end
+
+      def identifier
+        @var_node.identifier
+      end
+
+      def target_node(context)
+        @var_node.target_node(namespace(context))
+      end
+
+      def requires_mixed_logic?(context)
+        @var_node.requires_mixed_logic?(namespace(context))
+      end
+
+      def eval(context,options={})
+        @var_node.eval(namespace(context), options)
+      end
+    end
+  end
+end

data/lib/tp_plus/nodes/numreg_node.rb

@@ -0,0 +1,25 @@
+module TPPlus
+  module Nodes
+    class NumregNode
+      attr_accessor :comment
+      def initialize(id)
+        @id = id
+        @comment = ""
+      end
+
+      def requires_mixed_logic?(context)
+        false
+      end
+
+      def comment_string
+        return "" if @comment == ""
+
+        ":#{@comment}"
+      end
+
+      def eval(context,options={})
+        "R[#{@id}#{comment_string}]"
+      end
+    end
+  end
+end

data/lib/tp_plus/nodes/offset_node.rb

@@ -0,0 +1,27 @@
+module TPPlus
+  module Nodes
+    class OffsetNode
+      def initialize(type, var)
+        @type = type
+        @var = var
+      end
+
+      def name
+        case @type.downcase
+        when "offset"
+          "Offset"
+        when "tool_offset"
+          "Tool_Offset"
+        when "vision_offset"
+          "VOFFSET"
+        else
+          raise "Invalid type"
+        end
+      end
+
+      def eval(context)
+        "#{name},#{@var.eval(context)}"
+      end
+    end
+  end
+end

data/lib/tp_plus/nodes/operator_node.rb

@@ -0,0 +1,72 @@
+module TPPlus
+  module Nodes
+    class OperatorNode
+      attr_reader :string
+      def initialize(string)
+        @string = string
+      end
+
+      def bang?
+        @string == "!"
+      end
+
+      def requires_mixed_logic?(context)
+        case @string
+        when "&&", "||", "!"
+          true
+        else
+          false
+        end
+      end
+
+      def boolean?
+        case @string
+        when "&&", "||", "!"#, "==", "<>", ">", ">=", "<", "<="
+          true
+        else
+          false
+        end
+      end
+
+      def eval(context,options={})
+        if options[:opposite]
+          case @string
+          when "=="
+            "<>"
+          when "!=", "<>"
+            "="
+          when ">"
+            "<="
+          when "<"
+            ">="
+          when ">="
+            "<"
+          when "<="
+            ">"
+          when "!"
+            ""
+          when "||"
+            " AND "
+          when "&&"
+            " OR "
+          end
+        else
+          case @string
+          when "=="
+            "="
+          when "!="
+            "<>"
+          when "&&"
+            " AND "
+          when "||"
+            " OR "
+          when "%"
+            " MOD "
+          else
+            "#{@string}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tp_plus/nodes/pause_node.rb

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

data/lib/tp_plus/nodes/position_data_node.rb

@@ -0,0 +1,50 @@
+module TPPlus
+  module Nodes
+    class PositionDataNode
+      attr_reader :hash
+      def initialize(hash)
+        @hash = hash
+        @ids  = []
+      end
+
+      def valid?
+        return false unless @hash[:positions].is_a?(Array)
+        return false if @hash[:positions].map {|p| position_valid?(p) == false }.any?
+
+        true
+      end
+
+      def position_valid?(position_hash)
+        return false if @ids.include?(position_hash[:id])
+        @ids.push(position_hash[:id])
+
+        return false unless position_hash[:group].is_a?(Fixnum)
+        return false unless position_hash[:uframe].is_a?(Fixnum)
+        return false unless position_hash[:utool].is_a?(Fixnum)
+        return false unless position_hash[:config].is_a?(Hash)
+        return false unless boolean?(position_hash[:config][:flip])
+        return false unless boolean?(position_hash[:config][:up])
+        return false unless boolean?(position_hash[:config][:top])
+        return false unless position_hash[:config][:turn_counts].is_a?(Array)
+        return false unless position_hash[:config][:turn_counts].length == 3
+        return false if position_hash[:config][:turn_counts].map {|tc| tc.is_a?(Fixnum) == false }.any?
+        return false unless position_hash[:components].is_a?(Hash)
+        [:x,:y,:z,:w,:p,:r].each do |component|
+          return false unless position_hash[:components][component].is_a?(Float)
+        end
+
+        true
+      end
+
+      def boolean?(thing)
+        thing.is_a?(TrueClass) || thing.is_a?(FalseClass)
+      end
+
+      def eval(context, options={})
+        raise "Invalid position data" unless valid?
+        context.position_data = @hash
+        nil
+      end
+    end
+  end
+end

data/lib/tp_plus/nodes/position_node.rb

@@ -0,0 +1,25 @@
+module TPPlus
+  module Nodes
+    class PositionNode
+      attr_accessor :comment
+      def initialize(id)
+        @id = id
+        @comment = ""
+      end
+
+      def requires_mixed_logic?(context)
+        false
+      end
+
+      def comment_string
+        return "" if @comment == ""
+
+        ":#{@comment}"
+      end
+
+      def eval(context,options={})
+        "P[#{@id}#{comment_string}]"
+      end
+    end
+  end
+end