RangeNodes.java

  1. /*
  2.  * Copyright (c) 2013, 2014 Oracle and/or its affiliates. All rights reserved. This
  3.  * code is released under a tri EPL/GPL/LGPL license. You can use it,
  4.  * redistribute it and/or modify it under the terms of the:
  5.  *
  6.  * Eclipse Public License version 1.0
  7.  * GNU General Public License version 2
  8.  * GNU Lesser General Public License version 2.1
  9.  */
  10. package org.jruby.truffle.nodes.core;

  12. import com.oracle.truffle.api.CompilerDirectives;
  13. import com.oracle.truffle.api.dsl.Specialization;
  14. import com.oracle.truffle.api.frame.VirtualFrame;
  15. import com.oracle.truffle.api.source.SourceSection;
  16. import com.oracle.truffle.api.utilities.BranchProfile;
  17. import org.jruby.truffle.nodes.RubyNode;
  18. import org.jruby.truffle.nodes.RubyRootNode;
  19. import org.jruby.truffle.nodes.dispatch.DispatchHeadNode;
  20. import org.jruby.truffle.nodes.dispatch.PredicateDispatchHeadNode;
  21. import org.jruby.truffle.runtime.RubyContext;
  22. import org.jruby.truffle.runtime.control.BreakException;
  23. import org.jruby.truffle.runtime.control.NextException;
  24. import org.jruby.truffle.runtime.control.RedoException;
  25. import org.jruby.truffle.runtime.core.RubyArray;
  26. import org.jruby.truffle.runtime.core.RubyProc;
  27. import org.jruby.truffle.runtime.core.RubyRange;
  28. import org.jruby.truffle.runtime.core.RubyString;

  30. @CoreClass(name = "Range")
  31. public abstract class RangeNodes {

  33.     @CoreMethod(names = "==", required = 1)
  34.     public abstract static class EqualNode extends CoreMethodNode {

  36.         @Child protected KernelNodes.SameOrEqualNode equalNode;

  38.         public EqualNode(RubyContext context, SourceSection sourceSection) {
  39.             super(context, sourceSection);
  40.         }

  42.         public EqualNode(EqualNode prev) {
  43.             super(prev);
  44.         }

  46.         protected boolean equal(VirtualFrame frame, Object a, Object b) {
  47.             if (equalNode == null) {
  48.                 CompilerDirectives.transferToInterpreterAndInvalidate();
  49.                 equalNode = insert(KernelNodesFactory.SameOrEqualNodeFactory.create(getContext(), getSourceSection(), new RubyNode[]{null, null}));
  50.             }
  51.             return equalNode.executeSameOrEqual(frame, a, b);

  53.         }

  55.         @Specialization
  56.         public boolean equal(RubyRange.IntegerFixnumRange a, RubyRange.IntegerFixnumRange b) {
  57.             notDesignedForCompilation();

  59.             return a.doesExcludeEnd() == b.doesExcludeEnd() && a.getBegin() == b.getBegin() && a.getEnd() == b.getEnd();
  60.         }

  62.         @Specialization
  63.         public boolean equal(RubyRange.IntegerFixnumRange a, RubyRange.LongFixnumRange b) {
  64.             notDesignedForCompilation();

  66.             return a.doesExcludeEnd() == b.doesExcludeEnd() && a.getBegin() == b.getBegin() && a.getEnd() == b.getEnd();
  67.         }

  69.         @Specialization
  70.         public boolean equal(RubyRange.LongFixnumRange a, RubyRange.LongFixnumRange b) {
  71.             notDesignedForCompilation();

  73.             return a.doesExcludeEnd() == b.doesExcludeEnd() && a.getBegin() == b.getBegin() && a.getEnd() == b.getEnd();
  74.         }

  76.         @Specialization
  77.         public boolean equal(RubyRange.LongFixnumRange a, RubyRange.IntegerFixnumRange b) {
  78.             notDesignedForCompilation();

  80.             return a.doesExcludeEnd() == b.doesExcludeEnd() && a.getBegin() == b.getBegin() && a.getEnd() == b.getEnd();
  81.         }

  83.         @Specialization
  84.         public boolean equal(VirtualFrame frame, RubyRange.ObjectRange a, RubyRange.ObjectRange b) {
  85.             notDesignedForCompilation();

  87.             return a.doesExcludeEnd() == b.doesExcludeEnd() &&
  88.                     equal(frame, a.getBegin(), b.getBegin()) &&
  89.                     equal(frame, a.getEnd(), b.getEnd());
  90.         }
  91.     }

  93.     @CoreMethod(names = {"collect", "map"}, needsBlock = true, lowerFixnumSelf = true)
  94.     public abstract static class CollectNode extends YieldingCoreMethodNode {

  96.         @Child protected ArrayBuilderNode arrayBuilder;

  98.         public CollectNode(RubyContext context, SourceSection sourceSection) {
  99.             super(context, sourceSection);
  100.             arrayBuilder = new ArrayBuilderNode.UninitializedArrayBuilderNode(context);
  101.         }

  103.         public CollectNode(CollectNode prev) {
  104.             super(prev);
  105.             arrayBuilder = prev.arrayBuilder;
  106.         }

  108.         @Specialization
  109.         public RubyArray collect(VirtualFrame frame, RubyRange.IntegerFixnumRange range, RubyProc block) {
  110.             final int begin = range.getBegin();
  111.             final int exclusiveEnd = range.getExclusiveEnd();
  112.             final int length = exclusiveEnd - begin;

  114.             Object store = arrayBuilder.start(length);

  116.             int count = 0;

  118.             try {
  119.                 for (int n = 0; n < length; n++) {
  120.                     if (CompilerDirectives.inInterpreter()) {
  121.                         count++;
  122.                     }

  124.                     store = arrayBuilder.append(store, n, yield(frame, block, n));
  125.                 }
  126.             } finally {
  127.                 if (CompilerDirectives.inInterpreter()) {
  128.                     ((RubyRootNode) getRootNode()).reportLoopCount(count);
  129.                 }
  130.             }

  132.             return new RubyArray(getContext().getCoreLibrary().getArrayClass(), arrayBuilder.finish(store, length), length);
  133.         }

  135.     }

  137.     @CoreMethod(names = "each", needsBlock = true, lowerFixnumSelf = true)
  138.     public abstract static class EachNode extends YieldingCoreMethodNode {

  140.         private final BranchProfile breakProfile = BranchProfile.create();
  141.         private final BranchProfile nextProfile = BranchProfile.create();
  142.         private final BranchProfile redoProfile = BranchProfile.create();

  144.         public EachNode(RubyContext context, SourceSection sourceSection) {
  145.             super(context, sourceSection);
  146.         }

  148.         public EachNode(EachNode prev) {
  149.             super(prev);
  150.         }

  152.         @Specialization
  153.         public Object each(VirtualFrame frame, RubyRange.IntegerFixnumRange range, RubyProc block) {
  154.             final int exclusiveEnd = range.getExclusiveEnd();

  156.             int count = 0;

  158.             try {
  159.                 outer:
  160.                 for (int n = range.getBegin(); n < exclusiveEnd; n++) {
  161.                     while (true) {
  162.                         if (CompilerDirectives.inInterpreter()) {
  163.                             count++;
  164.                         }

  166.                         try {
  167.                             yield(frame, block, n);
  168.                             continue outer;
  169.                         } catch (BreakException e) {
  170.                             breakProfile.enter();
  171.                             return e.getResult();
  172.                         } catch (NextException e) {
  173.                             nextProfile.enter();
  174.                             continue outer;
  175.                         } catch (RedoException e) {
  176.                             redoProfile.enter();
  177.                         }
  178.                     }
  179.                 }
  180.             } finally {
  181.                 if (CompilerDirectives.inInterpreter()) {
  182.                     ((RubyRootNode) getRootNode()).reportLoopCount(count);
  183.                 }
  184.             }

  186.             return range;
  187.         }

  189.     }

  191.     @CoreMethod(names = "exclude_end?")
  192.     public abstract static class ExcludeEndNode extends CoreMethodNode {

  194.         public ExcludeEndNode(RubyContext context, SourceSection sourceSection) {
  195.             super(context, sourceSection);
  196.         }

  198.         public ExcludeEndNode(ExcludeEndNode prev) {
  199.             super(prev);
  200.         }

  202.         @Specialization
  203.         public boolean excludeEnd(RubyRange range) {
  204.             return range.doesExcludeEnd();
  205.         }

  207.     }

  209.     @CoreMethod(names = {"first", "begin"})
  210.     public abstract static class FirstNode extends CoreMethodNode {

  212.         public FirstNode(RubyContext context, SourceSection sourceSection) {
  213.             super(context, sourceSection);
  214.         }

  216.         public FirstNode(FirstNode prev) {
  217.             super(prev);
  218.         }

  220.         @Specialization
  221.         public int each(RubyRange.IntegerFixnumRange range) {
  222.             return range.getBegin();
  223.         }

  225.         @Specialization
  226.         public Object each(RubyRange.ObjectRange range) {
  227.             return range.getBegin();
  228.         }

  230.     }

  232.     @CoreMethod(names = {"include?", "==="}, required = 1)
  233.     public abstract static class IncludeNode extends CoreMethodNode {

  235.         @Child protected PredicateDispatchHeadNode callLess;
  236.         @Child protected PredicateDispatchHeadNode callGreater;
  237.         @Child protected PredicateDispatchHeadNode callGreaterEqual;

  239.         public IncludeNode(RubyContext context, SourceSection sourceSection) {
  240.             super(context, sourceSection);
  241.             callLess = new PredicateDispatchHeadNode(context);
  242.             callGreater = new PredicateDispatchHeadNode(context);
  243.             callGreaterEqual = new PredicateDispatchHeadNode(context);
  244.         }

  246.         public IncludeNode(IncludeNode prev) {
  247.             super(prev);
  248.             callLess = prev.callLess;
  249.             callGreater = prev.callGreater;
  250.             callGreaterEqual = prev.callGreaterEqual;
  251.         }

  253.         @Specialization
  254.         public boolean include(RubyRange.IntegerFixnumRange range, int value) {
  255.             return value >= range.getBegin() && value < range.getExclusiveEnd();
  256.         }

  258.         @Specialization
  259.         public boolean include(VirtualFrame frame, RubyRange.ObjectRange range, Object value) {
  260.             notDesignedForCompilation();

  262.             if (callLess.call(frame, value, "<", null, range.getBegin())) {
  263.                 return false;
  264.             }

  266.             if (range.doesExcludeEnd()) {
  267.                 if (callGreaterEqual.call(frame, value, ">=", null, range.getEnd())) {
  268.                     return false;
  269.                 }
  270.             } else {
  271.                 if (callGreater.call(frame, value, ">", null, range.getEnd())) {
  272.                     return false;
  273.                 }
  274.             }

  276.             return true;
  277.         }
  278.     }

  280.     @CoreMethod(names = {"last", "end"})
  281.     public abstract static class LastNode extends CoreMethodNode {

  283.         public LastNode(RubyContext context, SourceSection sourceSection) {
  284.             super(context, sourceSection);
  285.         }

  287.         public LastNode(LastNode prev) {
  288.             super(prev);
  289.         }

  291.         @Specialization
  292.         public int last(RubyRange.IntegerFixnumRange range) {
  293.             return range.getEnd();
  294.         }

  296.         @Specialization
  297.         public Object last(RubyRange.ObjectRange range) {
  298.             return range.getEnd();
  299.         }

  301.     }

  303.     @CoreMethod(names = "step", needsBlock = true, required = 1)
  304.     public abstract static class StepNode extends YieldingCoreMethodNode {

  306.         private final BranchProfile breakProfile = BranchProfile.create();
  307.         private final BranchProfile nextProfile = BranchProfile.create();
  308.         private final BranchProfile redoProfile = BranchProfile.create();

  310.         public StepNode(RubyContext context, SourceSection sourceSection) {
  311.             super(context, sourceSection);
  312.         }

  314.         public StepNode(StepNode prev) {
  315.             super(prev);
  316.         }

  318.         @Specialization
  319.         public Object step(VirtualFrame frame, RubyRange.IntegerFixnumRange range, int step, RubyProc block) {
  320.             int count = 0;

  322.             try {
  323.                 outer:
  324.                 for (int n = range.getBegin(); n < range.getExclusiveEnd(); n += step) {
  325.                     while (true) {
  326.                         if (CompilerDirectives.inInterpreter()) {
  327.                             count++;
  328.                         }

  330.                         try {
  331.                             yield(frame, block, n);
  332.                             continue outer;
  333.                         } catch (BreakException e) {
  334.                             breakProfile.enter();
  335.                             return e.getResult();
  336.                         } catch (NextException e) {
  337.                             nextProfile.enter();
  338.                             continue outer;
  339.                         } catch (RedoException e) {
  340.                             redoProfile.enter();
  341.                         }
  342.                     }
  343.                 }
  344.             } finally {
  345.                 if (CompilerDirectives.inInterpreter()) {
  346.                     ((RubyRootNode) getRootNode()).reportLoopCount(count);
  347.                 }
  348.             }

  350.             return range;
  351.         }

  353.     }

  355.     @CoreMethod(names = "to_a", lowerFixnumSelf = true)
  356.     public abstract static class ToANode extends CoreMethodNode {

  358.         public ToANode(RubyContext context, SourceSection sourceSection) {
  359.             super(context, sourceSection);
  360.         }

  362.         public ToANode(ToANode prev) {
  363.             super(prev);
  364.         }

  366.         @Specialization
  367.         public RubyArray toA(RubyRange.IntegerFixnumRange range) {
  368.             final int begin = range.getBegin();
  369.             final int length = range.getExclusiveEnd() - begin;

  371.             if (length < 0) {
  372.                 return new RubyArray(getContext().getCoreLibrary().getArrayClass());
  373.             } else {
  374.                 final int[] values = new int[length];

  376.                 for (int n = 0; n < length; n++) {
  377.                     values[n] = begin + n;
  378.                 }

  380.                 return new RubyArray(getContext().getCoreLibrary().getArrayClass(), values, length);
  381.             }
  382.         }

  384.     }

  386.     @CoreMethod(names = "to_s")
  387.     public abstract static class ToSNode extends CoreMethodNode {

  389.         @Child protected DispatchHeadNode toS;

  391.         public ToSNode(RubyContext context, SourceSection sourceSection) {
  392.             super(context, sourceSection);
  393.             toS = new DispatchHeadNode(context);
  394.         }

  396.         public ToSNode(ToSNode prev) {
  397.             super(prev);
  398.             toS = prev.toS;
  399.         }

  401.         @Specialization
  402.         public RubyString toS(RubyRange.IntegerFixnumRange range) {
  403.             notDesignedForCompilation();

  405.             return getContext().makeString(range.getBegin() + (range.doesExcludeEnd() ? "..." : "..") + range.getEnd());
  406.         }

  408.         @Specialization
  409.         public RubyString toS(VirtualFrame frame, RubyRange.ObjectRange range) {
  410.             notDesignedForCompilation();

  412.             // TODO(CS): cast?
  413.             final RubyString begin = (RubyString) toS.call(frame, range.getBegin(), "to_s", null);
  414.             final RubyString end = (RubyString) toS.call(frame, range.getBegin(), "to_s", null);

  416.             return getContext().makeString(begin + (range.doesExcludeEnd() ? "..." : "..") + end);
  417.         }
  418.     }

  420. }
Created with JaCoCo 0.7.3.201501050207