tp_plus 0.0.87 → 0.0.88

data/lib/tp_plus/nodes/wait_for_node.rb

@@ -1,50 +1,57 @@
-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
+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)
+        case @time
+        when DigitNode, RealNode
+          case @units
+          when "s"
+            return ("%.2f(sec)" % @time.eval(context)).sub(/^0+/, "")
+          when "ms"
+            return ("%.2f(sec)" % (@time.eval(context).to_f / 1000)).sub(/^0+/, "")
+          end
+        when VarNode
+          case @units
+          when "s"
+            if @time.constant?
+              return ("%.2f(sec)" % @time.eval(context)).sub(/^0+/, "")
+            else
+              return @time.eval(context)
+            end
+          else
+            raise "Indirect values can only use seconds ('s') as the units argument"
+          end
+        else
+          raise "PANIC"
+        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,61 +1,61 @@
-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
+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,40 +1,40 @@
-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
+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