tp_plus 0.0.77 → 0.0.87

data/lib/tp_plus/nodes/unary_expression_node.rb

@@ -0,0 +1,39 @@
+module TPPlus
+  module Nodes
+    class UnaryExpressionNode < BaseNode
+      attr_reader :op, :x
+      def initialize(op, x)
+        @op = OperatorNode.new(op)
+        @x = x
+      end
+
+      def grouped?
+        false
+      end
+
+      def requires_mixed_logic?(context)
+        true
+      end
+
+      def contains_expression?
+        false
+      end
+
+      def boolean_result?
+        false
+      end
+
+      def eval(context,options={})
+        if options[:opposite]
+          options[:opposite] = false #VarNode.eval() with options[:opposite] will add a !
+          @x.eval(context, options)
+        elsif options[:disable_mixed_logic]
+          options[:disable_mixed_logic] = false
+          "#{@x.eval(context, options)}=OFF"
+        else
+          "#{@op.eval(context, options)}#{@x.eval(context, options)}"
+        end
+      end
+    end
+  end
+end

data/lib/tp_plus/nodes/units_node.rb

@@ -1,20 +1,20 @@
-module TPPlus
-  module Nodes
-    class UnitsNode
-      def initialize(s)
-        @s = s
-      end
-
-      def eval(context)
-        case @s
-        when "mm/s"
-          "mm/sec"
-        when "%"
-          "%"
-        else
-          raise "Unknown unit: #{@s}"
-        end
-      end
-    end
-  end
-end
+module TPPlus
+  module Nodes
+    class UnitsNode < BaseNode
+      def initialize(s)
+        @s = s
+      end
+
+      def eval(context)
+        case @s
+        when "mm/s"
+          "mm/sec"
+        when "%"
+          "%"
+        else
+          raise "Unknown unit: #{@s}"
+        end
+      end
+    end
+  end
+end

data/lib/tp_plus/nodes/use_node.rb

@@ -1,21 +1,21 @@
-module TPPlus
-  module Nodes
-    class UseNode
-      def initialize(type, value)
-        @type = type
-        @value = value
-      end
-
-      def eval(context)
-        case @type
-        when "use_uframe"
-          "UFRAME_NUM=#{@value.eval(context)}"
-        when "use_utool"
-          "UTOOL_NUM=#{@value.eval(context)}"
-        when "use_payload"
-          "PAYLOAD[#{@value.eval(context)}]"
-        end
-      end
-    end
-  end
-end
+module TPPlus
+  module Nodes
+    class UseNode < BaseNode
+      def initialize(type, value)
+        @type = type
+        @value = value
+      end
+
+      def eval(context)
+        case @type
+        when "use_uframe"
+          "UFRAME_NUM=#{@value.eval(context)}"
+        when "use_utool"
+          "UTOOL_NUM=#{@value.eval(context)}"
+        when "use_payload"
+          "PAYLOAD[#{@value.eval(context)}]"
+        end
+      end
+    end
+  end
+end

data/lib/tp_plus/nodes/user_alarm_node.rb

@@ -1,16 +1,16 @@
-module TPPlus
-  module Nodes
-    class UserAlarmNode
-      attr_accessor :comment
-      attr_reader :id
-      def initialize(id)
-        @id = id
-        @comment = ""
-      end
-
-      def eval(context, options={})
-        "UALM[#{@id}]"
-      end
-    end
-  end
-end
+module TPPlus
+  module Nodes
+    class UserAlarmNode < BaseNode
+      attr_accessor :comment
+      attr_reader :id
+      def initialize(id)
+        @id = id
+        @comment = ""
+      end
+
+      def eval(context, options={})
+        "UALM[#{@id}]"
+      end
+    end
+  end
+end

data/lib/tp_plus/nodes/var_method_node.rb

@@ -1,23 +1,23 @@
-module TPPlus
-  module Nodes
-    class VarMethodNode
-      attr_reader :identifier
-      def initialize(identifier, method)
-        @identifier = identifier
-        @method = method || {}
-      end
-
-      def requires_mixed_logic?(context)
-        node(context).requires_mixed_logic?(context)
-      end
-
-      def node(context)
-        context.get_var(@identifier)
-      end
-
-      def eval(context,options={})
-        node(context).eval(context,options.merge(@method))
-      end
-    end
-  end
-end
+module TPPlus
+  module Nodes
+    class VarMethodNode < BaseNode
+      attr_reader :identifier
+      def initialize(identifier, method)
+        @identifier = identifier
+        @method = method || {}
+      end
+
+      def requires_mixed_logic?(context)
+        node(context).requires_mixed_logic?(context)
+      end
+
+      def node(context)
+        context.get_var(@identifier)
+      end
+
+      def eval(context,options={})
+        node(context).eval(context,options.merge(@method))
+      end
+    end
+  end
+end

data/lib/tp_plus/nodes/var_node.rb

@@ -1,39 +1,39 @@
-module TPPlus
-  module Nodes
-    class VarNode
-      attr_reader :identifier
-      def initialize(identifier)
-        @identifier = identifier
-      end
-
-      def target_node(context)
-        constant? ? context.get_constant(@identifier) : context.get_var(@identifier)
-      end
-
-      def constant?
-        @identifier.upcase == @identifier
-      end
-
-      def requires_mixed_logic?(context)
-        target_node(context).requires_mixed_logic?(context)
-      end
-
-      def with_parens(s, options)
-        return s unless options[:as_condition]
-
-        "(#{s})"
-      end
-
-      def eval(context,options={})
-        return target_node(context).eval(context) if constant?
-
-        s = ""
-        if options[:opposite]
-          s += "!"
-        end
-
-        with_parens(s + target_node(context).eval(context, options), options)
-      end
-    end
-  end
-end
+module TPPlus
+  module Nodes
+    class VarNode < BaseNode
+      attr_reader :identifier
+      def initialize(identifier)
+        @identifier = identifier
+      end
+
+      def target_node(context)
+        constant? ? context.get_constant(@identifier) : context.get_var(@identifier)
+      end
+
+      def constant?
+        @identifier.upcase == @identifier
+      end
+
+      def requires_mixed_logic?(context)
+        target_node(context).requires_mixed_logic?(context)
+      end
+
+      def with_parens(s, options)
+        return s unless options[:as_condition]
+
+        "(#{s})"
+      end
+
+      def eval(context,options={})
+        return target_node(context).eval(context) if constant?
+
+        s = ""
+        if options[:opposite]
+          s += "!"
+        end
+
+        with_parens(s + target_node(context).eval(context, options), options)
+      end
+    end
+  end
+end

data/lib/tp_plus/nodes/vision_register_node.rb

@@ -1,22 +1,22 @@
-module TPPlus
-  module Nodes
-    class VisionRegisterNode
-      attr_accessor :comment
-      attr_reader :id
-      def initialize(id)
-        @id = id
-        @comment = ""
-      end
-
-      def comment_string
-        return "" if @comment == ""
-
-        ":#{@comment}"
-      end
-
-      def eval(context,options={})
-        "VR[#{@id}#{comment_string}]"
-      end
-    end
-  end
-end
+module TPPlus
+  module Nodes
+    class VisionRegisterNode < BaseNode
+      attr_accessor :comment
+      attr_reader :id
+      def initialize(id)
+        @id = id
+        @comment = ""
+      end
+
+      def comment_string
+        return "" if @comment == ""
+
+        ":#{@comment}"
+      end
+
+      def eval(context,options={})
+        "VR[#{@id}#{comment_string}]"
+      end
+    end
+  end
+end

data/lib/tp_plus/nodes/wait_for_node.rb

@@ -1,54 +1,50 @@
-module TPPlus
-  module Nodes
-    class WaitForNode
-      def initialize(time, units)
-        @time = time
-        @units = units
-      end
-
-      def units_valid?
-        ["s","ms"].include?(@units)
-      end
-
-      # 2 decimal places and remove leading 0s
-      def time(context)
-        if @time.eval(context).is_a?(String)
-          case @units
-          when "s"
-            @time.eval(context)
-          else
-            raise "Invalid units"
-          end
-        else
-          ("%.2f" % case @units
-          when "s"
-            @time.eval(context)
-          when "ms"
-            @time.eval(context).to_f / 1000
-          end).sub(/^0+/, "") + "(sec)"
-        end
-      end
-
-      def can_be_inlined?
-        false
-      end
-
-      def expression
-        case @units
-        when "s"
-          @time
-        when "ms"
-          e = ExpressionNode.new(@time,"/",DigitNode.new(1000))
-          e.grouped = true
-          e
-        end
-      end
-
-      def eval(context)
-        raise "Invalid units" unless units_valid?
-
-        "WAIT #{time(context)}"
-      end
-    end
-  end
-end
+module TPPlus
+  module Nodes
+    class WaitForNode < BaseNode
+      def initialize(time, units)
+        @time = time
+        @units = units
+      end
+
+      def units_valid?
+        ["s","ms"].include?(@units)
+      end
+
+      # 2 decimal places and remove leading 0s
+      def time(context)
+        if @time.eval(context).is_a?(String)
+          case @units
+          when "s"
+            @time.eval(context)
+          else
+            raise "Indirect values can only use seconds ('s') as the units argument"
+          end
+        else
+          ("%.2f" % case @units
+          when "s"
+            @time.eval(context)
+          when "ms"
+            @time.eval(context).to_f / 1000
+          end).sub(/^0+/, "") + "(sec)"
+        end
+      end
+
+      def expression
+        case @units
+        when "s"
+          @time
+        when "ms"
+          e = ExpressionNode.new(@time,"/",DigitNode.new(1000))
+          e.grouped = true
+          e
+        end
+      end
+
+      def eval(context)
+        raise "Invalid units" unless units_valid?
+
+        "WAIT #{time(context)}"
+      end
+    end
+  end
+end

data/lib/tp_plus/nodes/wait_until_node.rb

@@ -1,65 +1,61 @@
-module TPPlus
-  module Nodes
-    class WaitUntilNode
-      def initialize(expression, timeout_options)
-        @expression = expression
-        @timeout_options = timeout_options || {}
-      end
-
-      def timeout(context)
-        return "" if @timeout_options[:label].nil?
-
-        " TIMEOUT,LBL[#{context.labels[@timeout_options[:label].to_sym]}]"
-      end
-
-      def val(context)
-        value_node = @timeout_options[:timeout][0]
-        units = @timeout_options[:timeout][1]
-
-        if value_node.is_a?(VarNode)
-          value = value_node.eval(context)
-
-          case units
-          when "s"
-            value = "#{value}*100"
-          when "ms"
-            value = "#{value}*.1"
-          else
-            raise "invalid units"
-          end
-        else
-          value = value_node.eval(context).to_i
-
-          case units
-          when "s"
-            value = (value * 100).to_i
-          when "ms"
-            value = (value * 0.1).to_i
-          else
-            raise "invalid units"
-          end
-        end
-
-        value
-      end
-
-      def can_be_inlined?
-        false
-      end
-
-      def wait_timeout(context)
-        return "" if @timeout_options[:timeout].nil?
-
-        "$WAITTMOUT=(#{val(context)}) ;\n"
-      end
-
-      def string_value(context)
-        "(#{@expression.eval(context)})"
-      end
-
-      def eval(context)
-        "#{wait_timeout(context)}WAIT #{string_value(context)}#{timeout(context)}"
-      end
-    end
-  end
-end
+module TPPlus
+  module Nodes
+    class WaitUntilNode < BaseNode
+      def initialize(expression, timeout_options)
+        @expression = expression
+        @timeout_options = timeout_options || {}
+      end
+
+      def timeout(context)
+        return "" if @timeout_options[:label].nil?
+
+        " TIMEOUT,LBL[#{context.labels[@timeout_options[:label].to_sym]}]"
+      end
+
+      def val(context)
+        value_node = @timeout_options[:timeout][0]
+        units = @timeout_options[:timeout][1]
+
+        if value_node.is_a?(VarNode)
+          value = value_node.eval(context)
+
+          case units
+          when "s"
+            value = "#{value}*100"
+          when "ms"
+            value = "#{value}*.1"
+          else
+            raise "invalid units"
+          end
+        else
+          value = value_node.eval(context).to_i
+
+          case units
+          when "s"
+            value = (value * 100).to_i
+          when "ms"
+            value = (value * 0.1).to_i
+          else
+            raise "invalid units"
+          end
+        end
+
+        value
+      end
+
+      def wait_timeout(context)
+        return "" if @timeout_options[:timeout].nil?
+
+        "$WAITTMOUT=(#{val(context)}) ;\n"
+      end
+
+      def string_value(context)
+        "(#{@expression.eval(context)})"
+      end
+
+      def eval(context)
+        "#{wait_timeout(context)}WAIT #{string_value(context)}#{timeout(context)}"
+      end
+    end
+  end
+end

data/lib/tp_plus/nodes/while_node.rb

@@ -1,42 +1,40 @@
-module TPPlus
-  module Nodes
-    class WhileNode
-      def initialize(condition_node, block)
-        @condition_node = condition_node
-        @block = block.flatten.reject {|n| n.is_a?(TerminatorNode) }
-      end
-
-      def top_label(context)
-        @top_label ||= context.next_label
-      end
-
-      def bottom_label(context)
-        @bottom_label ||= context.next_label
-      end
-
-      def parens(s, context)
-        return s unless @condition_node.requires_mixed_logic?(context)
-
-        "(#{s})"
-      end
-
-      def if_statement(context)
-        "IF #{parens(condition(context), context)},JMP LBL[#{bottom_label(context)}] ;\n"
-      end
-
-
-      def condition(context)
-        @condition_node.eval(context, opposite: true)
-      end
-
-
-      def block(context)
-        @block.inject("") {|s,n| s << "#{n.eval(context)} ;\n" }
-      end
-
-      def eval(context)
-        "LBL[#{top_label(context)}] ;\n#{if_statement(context)}#{block(context)}JMP LBL[#{top_label(context)}] ;\nLBL[#{bottom_label(context)}]"
-      end
-    end
-  end
-end
+module TPPlus
+  module Nodes
+    class WhileNode < BaseNode
+      def initialize(condition_node, block)
+        @condition_node = condition_node
+        @block = block.flatten.reject {|n| n.is_a?(TerminatorNode) }
+      end
+
+      def top_label(context)
+        @top_label ||= context.next_label
+      end
+
+      def bottom_label(context)
+        @bottom_label ||= context.next_label
+      end
+
+      def parens(s, context)
+        return s unless @condition_node.requires_mixed_logic?(context)
+
+        "(#{s})"
+      end
+
+      def if_statement(context)
+        "IF #{parens(condition(context), context)},JMP LBL[#{bottom_label(context)}] ;\n"
+      end
+
+      def condition(context)
+        @condition_node.eval(context, opposite: true)
+      end
+
+      def block(context)
+        @block.inject("") {|s,n| s << "#{n.eval(context)} ;\n" }
+      end
+
+      def eval(context)
+        "LBL[#{top_label(context)}] ;\n#{if_statement(context)}#{block(context)}JMP LBL[#{top_label(context)}] ;\nLBL[#{bottom_label(context)}]"
+      end
+    end
+  end
+end