org.jruby.truffle.stdlib.bigdecimal.BigDecimalNodesFactory Maven / Gradle / Ivy
// CheckStyle: start generated
package org.jruby.truffle.stdlib.bigdecimal;
import com.oracle.truffle.api.CompilerDirectives;
import com.oracle.truffle.api.CompilerDirectives.CompilationFinal;
import com.oracle.truffle.api.dsl.GeneratedBy;
import com.oracle.truffle.api.dsl.NodeFactory;
import com.oracle.truffle.api.dsl.UnsupportedSpecializationException;
import com.oracle.truffle.api.dsl.internal.SpecializationNode;
import com.oracle.truffle.api.dsl.internal.SpecializedNode;
import com.oracle.truffle.api.dsl.internal.SuppressFBWarnings;
import com.oracle.truffle.api.frame.Frame;
import com.oracle.truffle.api.frame.VirtualFrame;
import com.oracle.truffle.api.nodes.Node;
import com.oracle.truffle.api.nodes.NodeCost;
import com.oracle.truffle.api.nodes.UnexpectedResultException;
import com.oracle.truffle.api.object.DynamicObject;
import com.oracle.truffle.api.profiles.BranchProfile;
import com.oracle.truffle.api.profiles.ConditionProfile;
import java.util.Arrays;
import java.util.List;
import org.jruby.truffle.builtins.CoreMethodNode;
import org.jruby.truffle.core.cast.IntegerCastNode;
import org.jruby.truffle.core.numeric.FixnumOrBignumNode;
import org.jruby.truffle.language.NotProvided;
import org.jruby.truffle.language.RubyGuards;
import org.jruby.truffle.language.RubyNode;
import org.jruby.truffle.language.RubyTypes;
import org.jruby.truffle.language.RubyTypesGen;
import org.jruby.truffle.language.SnippetNode;
import org.jruby.truffle.language.dispatch.CallDispatchHeadNode;
import org.jruby.truffle.stdlib.bigdecimal.BigDecimalNodes.AbsNode;
import org.jruby.truffle.stdlib.bigdecimal.BigDecimalNodes.AddNode;
import org.jruby.truffle.stdlib.bigdecimal.BigDecimalNodes.AddOpNode;
import org.jruby.truffle.stdlib.bigdecimal.BigDecimalNodes.AllocateNode;
import org.jruby.truffle.stdlib.bigdecimal.BigDecimalNodes.CompareNode;
import org.jruby.truffle.stdlib.bigdecimal.BigDecimalNodes.DivModNode;
import org.jruby.truffle.stdlib.bigdecimal.BigDecimalNodes.DivNode;
import org.jruby.truffle.stdlib.bigdecimal.BigDecimalNodes.DivOpNode;
import org.jruby.truffle.stdlib.bigdecimal.BigDecimalNodes.ExponentNode;
import org.jruby.truffle.stdlib.bigdecimal.BigDecimalNodes.FiniteNode;
import org.jruby.truffle.stdlib.bigdecimal.BigDecimalNodes.InfiniteNode;
import org.jruby.truffle.stdlib.bigdecimal.BigDecimalNodes.InitializeNode;
import org.jruby.truffle.stdlib.bigdecimal.BigDecimalNodes.ModuloNode;
import org.jruby.truffle.stdlib.bigdecimal.BigDecimalNodes.MultNode;
import org.jruby.truffle.stdlib.bigdecimal.BigDecimalNodes.MultOpNode;
import org.jruby.truffle.stdlib.bigdecimal.BigDecimalNodes.NanNode;
import org.jruby.truffle.stdlib.bigdecimal.BigDecimalNodes.NegNode;
import org.jruby.truffle.stdlib.bigdecimal.BigDecimalNodes.PowerNode;
import org.jruby.truffle.stdlib.bigdecimal.BigDecimalNodes.PrecsNode;
import org.jruby.truffle.stdlib.bigdecimal.BigDecimalNodes.RemainderNode;
import org.jruby.truffle.stdlib.bigdecimal.BigDecimalNodes.RoundNode;
import org.jruby.truffle.stdlib.bigdecimal.BigDecimalNodes.SignNode;
import org.jruby.truffle.stdlib.bigdecimal.BigDecimalNodes.SqrtNode;
import org.jruby.truffle.stdlib.bigdecimal.BigDecimalNodes.SubNode;
import org.jruby.truffle.stdlib.bigdecimal.BigDecimalNodes.SubOpNode;
import org.jruby.truffle.stdlib.bigdecimal.BigDecimalNodes.ToFNode;
import org.jruby.truffle.stdlib.bigdecimal.BigDecimalNodes.ToINode;
import org.jruby.truffle.stdlib.bigdecimal.BigDecimalNodes.UnscaledNode;
import org.jruby.truffle.stdlib.bigdecimal.BigDecimalNodes.ZeroNode;
@GeneratedBy(BigDecimalNodes.class)
public final class BigDecimalNodesFactory {
public static List> getFactories() {
return Arrays.asList(InitializeNodeFactory.getInstance(), AddOpNodeFactory.getInstance(), AddNodeFactory.getInstance(), SubOpNodeFactory.getInstance(), SubNodeFactory.getInstance(), NegNodeFactory.getInstance(), MultOpNodeFactory.getInstance(), MultNodeFactory.getInstance(), DivOpNodeFactory.getInstance(), DivNodeFactory.getInstance(), DivModNodeFactory.getInstance(), RemainderNodeFactory.getInstance(), ModuloNodeFactory.getInstance(), PowerNodeFactory.getInstance(), SqrtNodeFactory.getInstance(), CompareNodeFactory.getInstance(), ZeroNodeFactory.getInstance(), SignNodeFactory.getInstance(), NanNodeFactory.getInstance(), ExponentNodeFactory.getInstance(), AbsNodeFactory.getInstance(), RoundNodeFactory.getInstance(), FiniteNodeFactory.getInstance(), InfiniteNodeFactory.getInstance(), PrecsNodeFactory.getInstance(), ToFNodeFactory.getInstance(), UnscaledNodeFactory.getInstance(), ToINodeFactory.getInstance(), AllocateNodeFactory.getInstance());
}
@GeneratedBy(InitializeNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class InitializeNodeFactory implements NodeFactory {
private static InitializeNodeFactory initializeNodeFactoryInstance;
private InitializeNodeFactory() {
}
@Override
public Class getNodeClass() {
return InitializeNode.class;
}
@Override
public List getExecutionSignature() {
return Arrays.asList(RubyNode.class, RubyNode.class, RubyNode.class);
}
@Override
public List getNodeSignatures() {
return Arrays.asList(Arrays.asList(RubyNode[].class));
}
@Override
public InitializeNode createNode(Object... arguments) {
if (arguments.length == 1 && (arguments[0] == null || arguments[0] instanceof RubyNode[])) {
return create((RubyNode[]) arguments[0]);
} else {
throw new IllegalArgumentException("Invalid create signature.");
}
}
public static NodeFactory getInstance() {
if (initializeNodeFactoryInstance == null) {
initializeNodeFactoryInstance = new InitializeNodeFactory();
}
return initializeNodeFactoryInstance;
}
public static InitializeNode create(RubyNode[] arguments) {
return new InitializeNodeGen(arguments);
}
@GeneratedBy(InitializeNode.class)
public static final class InitializeNodeGen extends InitializeNode implements SpecializedNode {
@Child private RubyNode arguments0_;
@Child private RubyNode arguments1_;
@Child private RubyNode arguments2_;
@CompilationFinal private Class arguments2Type_;
@Child private BaseNode_ specialization_;
private InitializeNodeGen(RubyNode[] arguments) {
this.arguments0_ = arguments != null && 0 < arguments.length ? arguments[0] : null;
this.arguments1_ = arguments != null && 1 < arguments.length ? arguments[1] : null;
this.arguments2_ = arguments != null && 2 < arguments.length ? arguments[2] : null;
this.specialization_ = UninitializedNode_.create(this);
}
@Override
public NodeCost getCost() {
return specialization_.getNodeCost();
}
@Override
public Object execute(VirtualFrame frameValue) {
return specialization_.execute(frameValue);
}
@Override
public void executeVoid(VirtualFrame frameValue) {
specialization_.executeVoid(frameValue);
return;
}
@Override
public SpecializationNode getSpecializationNode() {
return specialization_;
}
@Override
public Node deepCopy() {
return SpecializationNode.updateRoot(super.deepCopy());
}
@GeneratedBy(InitializeNode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected InitializeNodeGen root;
BaseNode_(InitializeNodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (InitializeNodeGen) root;
}
@Override
protected final Node[] getSuppliedChildren() {
return new Node[] {root.arguments0_, root.arguments1_, root.arguments2_};
}
@Override
public final Object acceptAndExecute(Frame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value) {
return this.execute_((VirtualFrame) frameValue, arguments0Value, arguments1Value, arguments2Value);
}
public abstract Object execute_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value);
public Object execute(VirtualFrame frameValue) {
Object arguments0Value_ = root.arguments0_.execute(frameValue);
Object arguments1Value_ = root.arguments1_.execute(frameValue);
Object arguments2Value_ = executeArguments2_(frameValue);
return execute_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_);
}
public void executeVoid(VirtualFrame frameValue) {
execute(frameValue);
return;
}
@Override
protected final SpecializationNode createNext(Frame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value) {
if (arguments0Value instanceof DynamicObject) {
if (arguments2Value instanceof NotProvided) {
return Initialize0Node_.create(root);
}
if (RubyTypesGen.isImplicitInteger(arguments2Value)) {
return Initialize1Node_.create(root, arguments2Value);
}
}
return null;
}
@Override
protected final SpecializationNode createPolymorphic() {
return PolymorphicNode_.create(root);
}
protected final BaseNode_ getNext() {
return (BaseNode_) this.next;
}
protected final Object executeArguments2_(Frame frameValue) {
Class arguments2Type_ = root.arguments2Type_;
try {
if (arguments2Type_ == int.class) {
return root.arguments2_.executeInteger((VirtualFrame) frameValue);
} else if (arguments2Type_ == null) {
CompilerDirectives.transferToInterpreterAndInvalidate();
Class _type = Object.class;
try {
Object _value = root.arguments2_.execute((VirtualFrame) frameValue);
if (_value instanceof Integer) {
_type = int.class;
} else {
_type = Object.class;
}
return _value;
} finally {
root.arguments2Type_ = _type;
}
} else {
return root.arguments2_.execute((VirtualFrame) frameValue);
}
} catch (UnexpectedResultException ex) {
root.arguments2Type_ = Object.class;
return ex.getResult();
}
}
}
@GeneratedBy(InitializeNode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(InitializeNodeGen root) {
super(root, 2147483647);
}
@Override
public Object execute_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value) {
return uninitialized(frameValue, arguments0Value, arguments1Value, arguments2Value);
}
static BaseNode_ create(InitializeNodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(InitializeNode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(InitializeNodeGen root) {
super(root, 0);
}
@Override
public SpecializationNode merge(SpecializationNode newNode, Frame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value) {
return polymorphicMerge(newNode, super.merge(newNode, frameValue, arguments0Value, arguments1Value, arguments2Value));
}
@Override
public Object execute_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value) {
return getNext().execute_(frameValue, arguments0Value, arguments1Value, arguments2Value);
}
static BaseNode_ create(InitializeNodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "initialize(VirtualFrame, DynamicObject, Object, NotProvided)", value = InitializeNode.class)
private static final class Initialize0Node_ extends BaseNode_ {
Initialize0Node_(InitializeNodeGen root) {
super(root, 1);
}
@Override
public Object execute_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value) {
if (arguments0Value instanceof DynamicObject && arguments2Value instanceof NotProvided) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
NotProvided arguments2Value_ = (NotProvided) arguments2Value;
return root.initialize(frameValue, arguments0Value_, arguments1Value, arguments2Value_);
}
return getNext().execute_(frameValue, arguments0Value, arguments1Value, arguments2Value);
}
static BaseNode_ create(InitializeNodeGen root) {
return new Initialize0Node_(root);
}
}
@GeneratedBy(methodName = "initialize(VirtualFrame, DynamicObject, Object, int)", value = InitializeNode.class)
private static final class Initialize1Node_ extends BaseNode_ {
private final Class arguments2ImplicitType;
Initialize1Node_(InitializeNodeGen root, Object arguments2Value) {
super(root, 2);
this.arguments2ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments2Value);
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.arguments2ImplicitType == ((Initialize1Node_) other).arguments2ImplicitType;
}
@Override
public Object execute(VirtualFrame frameValue) {
DynamicObject arguments0Value_;
try {
arguments0Value_ = root.arguments0_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object arguments1Value = root.arguments1_.execute(frameValue);
Object arguments2Value = executeArguments2_(frameValue);
return getNext().execute_(frameValue, ex.getResult(), arguments1Value, arguments2Value);
}
Object arguments1Value_ = root.arguments1_.execute(frameValue);
int arguments2Value_;
try {
if (arguments2ImplicitType == int.class) {
arguments2Value_ = root.arguments2_.executeInteger(frameValue);
} else {
Object arguments2Value__ = executeArguments2_(frameValue);
arguments2Value_ = RubyTypesGen.expectImplicitInteger(arguments2Value__, arguments2ImplicitType);
}
} catch (UnexpectedResultException ex) {
return getNext().execute_(frameValue, arguments0Value_, arguments1Value_, ex.getResult());
}
return root.initialize(frameValue, arguments0Value_, arguments1Value_, arguments2Value_);
}
@Override
public Object execute_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value) {
if (arguments0Value instanceof DynamicObject && RubyTypesGen.isImplicitInteger(arguments2Value, arguments2ImplicitType)) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
int arguments2Value_ = RubyTypesGen.asImplicitInteger(arguments2Value, arguments2ImplicitType);
return root.initialize(frameValue, arguments0Value_, arguments1Value, arguments2Value_);
}
return getNext().execute_(frameValue, arguments0Value, arguments1Value, arguments2Value);
}
static BaseNode_ create(InitializeNodeGen root, Object arguments2Value) {
return new Initialize1Node_(root, arguments2Value);
}
}
}
}
@GeneratedBy(AddOpNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class AddOpNodeFactory implements NodeFactory {
private static AddOpNodeFactory addOpNodeFactoryInstance;
private AddOpNodeFactory() {
}
@Override
public Class getNodeClass() {
return AddOpNode.class;
}
@Override
public List getExecutionSignature() {
return Arrays.asList(RubyNode.class, RubyNode.class);
}
@Override
public List getNodeSignatures() {
return Arrays.asList(Arrays.asList(RubyNode.class, RubyNode.class));
}
@Override
public AddOpNode createNode(Object... arguments) {
if (arguments.length == 2 && (arguments[0] == null || arguments[0] instanceof RubyNode) && (arguments[1] == null || arguments[1] instanceof RubyNode)) {
return create((RubyNode) arguments[0], (RubyNode) arguments[1]);
} else {
throw new IllegalArgumentException("Invalid create signature.");
}
}
public static NodeFactory getInstance() {
if (addOpNodeFactoryInstance == null) {
addOpNodeFactoryInstance = new AddOpNodeFactory();
}
return addOpNodeFactoryInstance;
}
public static AddOpNode create(RubyNode a, RubyNode b) {
return new AddOpNodeGen(a, b);
}
@GeneratedBy(AddOpNode.class)
public static final class AddOpNodeGen extends AddOpNode implements SpecializedNode {
@Child private RubyNode a_;
@Child private RubyNode b_;
@Child private BaseNode_ specialization_;
private AddOpNodeGen(RubyNode a, RubyNode b) {
this.a_ = a;
this.b_ = castB(b);
this.specialization_ = UninitializedNode_.create(this);
}
@Override
public NodeCost getCost() {
return specialization_.getNodeCost();
}
@Override
public Object execute(VirtualFrame frameValue) {
return specialization_.execute(frameValue);
}
@Override
public void executeVoid(VirtualFrame frameValue) {
specialization_.executeVoid(frameValue);
return;
}
@Override
public SpecializationNode getSpecializationNode() {
return specialization_;
}
@Override
public Node deepCopy() {
return SpecializationNode.updateRoot(super.deepCopy());
}
@GeneratedBy(AddOpNode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected AddOpNodeGen root;
BaseNode_(AddOpNodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (AddOpNodeGen) root;
}
@Override
protected final Node[] getSuppliedChildren() {
return new Node[] {root.a_, root.b_};
}
@Override
public final Object acceptAndExecute(Frame frameValue, Object aValue, Object bValue) {
return this.execute_((VirtualFrame) frameValue, aValue, bValue);
}
public abstract Object execute_(VirtualFrame frameValue, Object aValue, Object bValue);
public Object execute(VirtualFrame frameValue) {
Object aValue_ = root.a_.execute(frameValue);
Object bValue_ = root.b_.execute(frameValue);
return execute_(frameValue, aValue_, bValue_);
}
public void executeVoid(VirtualFrame frameValue) {
execute(frameValue);
return;
}
@Override
protected final SpecializationNode createNext(Frame frameValue, Object aValue, Object bValue) {
if (aValue instanceof DynamicObject && bValue instanceof DynamicObject) {
DynamicObject aValue_ = (DynamicObject) aValue;
DynamicObject bValue_ = (DynamicObject) bValue;
if ((BigDecimalCoreMethodNode.isNormal(aValue_)) && (BigDecimalCoreMethodNode.isNormalRubyBigDecimal(bValue_))) {
return AddNode_.create(root);
}
if ((RubyGuards.isRubyBigDecimal(bValue_)) && (!(BigDecimalCoreMethodNode.isNormal(aValue_)) || !(BigDecimalCoreMethodNode.isNormal(bValue_)))) {
return AddSpecialNode_.create(root);
}
}
return null;
}
@Override
protected final SpecializationNode createPolymorphic() {
return PolymorphicNode_.create(root);
}
protected final BaseNode_ getNext() {
return (BaseNode_) this.next;
}
}
@GeneratedBy(AddOpNode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(AddOpNodeGen root) {
super(root, 2147483647);
}
@Override
public Object execute_(VirtualFrame frameValue, Object aValue, Object bValue) {
return uninitialized(frameValue, aValue, bValue);
}
static BaseNode_ create(AddOpNodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(AddOpNode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(AddOpNodeGen root) {
super(root, 0);
}
@Override
public SpecializationNode merge(SpecializationNode newNode, Frame frameValue, Object aValue, Object bValue) {
return polymorphicMerge(newNode, super.merge(newNode, frameValue, aValue, bValue));
}
@Override
public Object execute_(VirtualFrame frameValue, Object aValue, Object bValue) {
return getNext().execute_(frameValue, aValue, bValue);
}
static BaseNode_ create(AddOpNodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "add(VirtualFrame, DynamicObject, DynamicObject)", value = AddOpNode.class)
private static final class AddNode_ extends BaseNode_ {
AddNode_(AddOpNodeGen root) {
super(root, 1);
}
@Override
public Object execute_(VirtualFrame frameValue, Object aValue, Object bValue) {
if (aValue instanceof DynamicObject && bValue instanceof DynamicObject) {
DynamicObject aValue_ = (DynamicObject) aValue;
DynamicObject bValue_ = (DynamicObject) bValue;
if ((BigDecimalCoreMethodNode.isNormal(aValue_)) && (BigDecimalCoreMethodNode.isNormalRubyBigDecimal(bValue_))) {
return root.add(frameValue, aValue_, bValue_);
}
}
return getNext().execute_(frameValue, aValue, bValue);
}
static BaseNode_ create(AddOpNodeGen root) {
return new AddNode_(root);
}
}
@GeneratedBy(methodName = "addSpecial(VirtualFrame, DynamicObject, DynamicObject)", value = AddOpNode.class)
private static final class AddSpecialNode_ extends BaseNode_ {
AddSpecialNode_(AddOpNodeGen root) {
super(root, 2);
}
@Override
public Object execute_(VirtualFrame frameValue, Object aValue, Object bValue) {
if (aValue instanceof DynamicObject && bValue instanceof DynamicObject) {
DynamicObject aValue_ = (DynamicObject) aValue;
DynamicObject bValue_ = (DynamicObject) bValue;
if ((RubyGuards.isRubyBigDecimal(bValue_)) && (!(BigDecimalCoreMethodNode.isNormal(aValue_)) || !(BigDecimalCoreMethodNode.isNormal(bValue_)))) {
return root.addSpecial(frameValue, aValue_, bValue_);
}
}
return getNext().execute_(frameValue, aValue, bValue);
}
static BaseNode_ create(AddOpNodeGen root) {
return new AddSpecialNode_(root);
}
}
}
}
@GeneratedBy(AddNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class AddNodeFactory implements NodeFactory {
private static AddNodeFactory addNodeFactoryInstance;
private AddNodeFactory() {
}
@Override
public Class getNodeClass() {
return AddNode.class;
}
@Override
public List getExecutionSignature() {
return Arrays.asList(RubyNode.class, RubyNode.class, RubyNode.class);
}
@Override
public List getNodeSignatures() {
return Arrays.asList(Arrays.asList(RubyNode.class, RubyNode.class, RubyNode.class));
}
@Override
public AddNode createNode(Object... arguments) {
if (arguments.length == 3 && (arguments[0] == null || arguments[0] instanceof RubyNode) && (arguments[1] == null || arguments[1] instanceof RubyNode) && (arguments[2] == null || arguments[2] instanceof RubyNode)) {
return create((RubyNode) arguments[0], (RubyNode) arguments[1], (RubyNode) arguments[2]);
} else {
throw new IllegalArgumentException("Invalid create signature.");
}
}
public static NodeFactory getInstance() {
if (addNodeFactoryInstance == null) {
addNodeFactoryInstance = new AddNodeFactory();
}
return addNodeFactoryInstance;
}
public static AddNode create(RubyNode a, RubyNode b, RubyNode precision) {
return new AddNodeGen(a, b, precision);
}
@GeneratedBy(AddNode.class)
public static final class AddNodeGen extends AddNode implements SpecializedNode {
@Child private RubyNode a_;
@Child private RubyNode b_;
@Child private RubyNode precision_;
@CompilationFinal private Class precisionType_;
@Child private BaseNode_ specialization_;
private AddNodeGen(RubyNode a, RubyNode b, RubyNode precision) {
this.a_ = a;
this.b_ = castB(b);
this.precision_ = precision;
this.specialization_ = UninitializedNode_.create(this);
}
@Override
public NodeCost getCost() {
return specialization_.getNodeCost();
}
@Override
public Object execute(VirtualFrame frameValue) {
return specialization_.execute(frameValue);
}
@Override
public void executeVoid(VirtualFrame frameValue) {
specialization_.executeVoid(frameValue);
return;
}
@Override
public SpecializationNode getSpecializationNode() {
return specialization_;
}
@Override
public Node deepCopy() {
return SpecializationNode.updateRoot(super.deepCopy());
}
@GeneratedBy(AddNode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected AddNodeGen root;
BaseNode_(AddNodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (AddNodeGen) root;
}
@Override
protected final Node[] getSuppliedChildren() {
return new Node[] {root.a_, root.b_, root.precision_};
}
@Override
public final Object acceptAndExecute(Frame frameValue, Object aValue, Object bValue, Object precisionValue) {
return this.execute_((VirtualFrame) frameValue, aValue, bValue, precisionValue);
}
public abstract Object execute_(VirtualFrame frameValue, Object aValue, Object bValue, Object precisionValue);
public Object execute(VirtualFrame frameValue) {
Object aValue_ = root.a_.execute(frameValue);
Object bValue_ = root.b_.execute(frameValue);
Object precisionValue_ = executePrecision_(frameValue);
return execute_(frameValue, aValue_, bValue_, precisionValue_);
}
public void executeVoid(VirtualFrame frameValue) {
execute(frameValue);
return;
}
@Override
protected final SpecializationNode createNext(Frame frameValue, Object aValue, Object bValue, Object precisionValue) {
if (aValue instanceof DynamicObject && bValue instanceof DynamicObject && RubyTypesGen.isImplicitInteger(precisionValue)) {
DynamicObject aValue_ = (DynamicObject) aValue;
DynamicObject bValue_ = (DynamicObject) bValue;
if ((BigDecimalCoreMethodNode.isNormal(aValue_)) && (BigDecimalCoreMethodNode.isNormalRubyBigDecimal(bValue_))) {
return AddNode_.create(root, precisionValue);
}
if ((RubyGuards.isRubyBigDecimal(bValue_)) && (!(BigDecimalCoreMethodNode.isNormal(aValue_)) || !(BigDecimalCoreMethodNode.isNormal(bValue_)))) {
return AddSpecialNode_.create(root, precisionValue);
}
}
return null;
}
@Override
protected final SpecializationNode createPolymorphic() {
return PolymorphicNode_.create(root);
}
protected final BaseNode_ getNext() {
return (BaseNode_) this.next;
}
protected final Object executePrecision_(Frame frameValue) {
Class precisionType_ = root.precisionType_;
try {
if (precisionType_ == int.class) {
return root.precision_.executeInteger((VirtualFrame) frameValue);
} else if (precisionType_ == null) {
CompilerDirectives.transferToInterpreterAndInvalidate();
Class _type = Object.class;
try {
Object _value = root.precision_.execute((VirtualFrame) frameValue);
if (_value instanceof Integer) {
_type = int.class;
} else {
_type = Object.class;
}
return _value;
} finally {
root.precisionType_ = _type;
}
} else {
return root.precision_.execute((VirtualFrame) frameValue);
}
} catch (UnexpectedResultException ex) {
root.precisionType_ = Object.class;
return ex.getResult();
}
}
}
@GeneratedBy(AddNode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(AddNodeGen root) {
super(root, 2147483647);
}
@Override
public Object execute_(VirtualFrame frameValue, Object aValue, Object bValue, Object precisionValue) {
return uninitialized(frameValue, aValue, bValue, precisionValue);
}
static BaseNode_ create(AddNodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(AddNode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(AddNodeGen root) {
super(root, 0);
}
@Override
public SpecializationNode merge(SpecializationNode newNode, Frame frameValue, Object aValue, Object bValue, Object precisionValue) {
return polymorphicMerge(newNode, super.merge(newNode, frameValue, aValue, bValue, precisionValue));
}
@Override
public Object execute_(VirtualFrame frameValue, Object aValue, Object bValue, Object precisionValue) {
return getNext().execute_(frameValue, aValue, bValue, precisionValue);
}
static BaseNode_ create(AddNodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "add(VirtualFrame, DynamicObject, DynamicObject, int)", value = AddNode.class)
private static final class AddNode_ extends BaseNode_ {
private final Class precisionImplicitType;
AddNode_(AddNodeGen root, Object precisionValue) {
super(root, 1);
this.precisionImplicitType = RubyTypesGen.getImplicitIntegerClass(precisionValue);
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.precisionImplicitType == ((AddNode_) other).precisionImplicitType;
}
@Override
public Object execute(VirtualFrame frameValue) {
DynamicObject aValue_;
try {
aValue_ = root.a_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object bValue = root.b_.execute(frameValue);
Object precisionValue = executePrecision_(frameValue);
return getNext().execute_(frameValue, ex.getResult(), bValue, precisionValue);
}
DynamicObject bValue_;
try {
bValue_ = root.b_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object precisionValue = executePrecision_(frameValue);
return getNext().execute_(frameValue, aValue_, ex.getResult(), precisionValue);
}
int precisionValue_;
try {
if (precisionImplicitType == int.class) {
precisionValue_ = root.precision_.executeInteger(frameValue);
} else {
Object precisionValue__ = executePrecision_(frameValue);
precisionValue_ = RubyTypesGen.expectImplicitInteger(precisionValue__, precisionImplicitType);
}
} catch (UnexpectedResultException ex) {
return getNext().execute_(frameValue, aValue_, bValue_, ex.getResult());
}
if ((BigDecimalCoreMethodNode.isNormal(aValue_)) && (BigDecimalCoreMethodNode.isNormalRubyBigDecimal(bValue_))) {
return root.add(frameValue, aValue_, bValue_, precisionValue_);
}
return getNext().execute_(frameValue, aValue_, bValue_, precisionValue_);
}
@Override
public Object execute_(VirtualFrame frameValue, Object aValue, Object bValue, Object precisionValue) {
if (aValue instanceof DynamicObject && bValue instanceof DynamicObject && RubyTypesGen.isImplicitInteger(precisionValue, precisionImplicitType)) {
DynamicObject aValue_ = (DynamicObject) aValue;
DynamicObject bValue_ = (DynamicObject) bValue;
int precisionValue_ = RubyTypesGen.asImplicitInteger(precisionValue, precisionImplicitType);
if ((BigDecimalCoreMethodNode.isNormal(aValue_)) && (BigDecimalCoreMethodNode.isNormalRubyBigDecimal(bValue_))) {
return root.add(frameValue, aValue_, bValue_, precisionValue_);
}
}
return getNext().execute_(frameValue, aValue, bValue, precisionValue);
}
static BaseNode_ create(AddNodeGen root, Object precisionValue) {
return new AddNode_(root, precisionValue);
}
}
@GeneratedBy(methodName = "addSpecial(VirtualFrame, DynamicObject, DynamicObject, int)", value = AddNode.class)
private static final class AddSpecialNode_ extends BaseNode_ {
private final Class precisionImplicitType;
AddSpecialNode_(AddNodeGen root, Object precisionValue) {
super(root, 2);
this.precisionImplicitType = RubyTypesGen.getImplicitIntegerClass(precisionValue);
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.precisionImplicitType == ((AddSpecialNode_) other).precisionImplicitType;
}
@Override
public Object execute(VirtualFrame frameValue) {
DynamicObject aValue_;
try {
aValue_ = root.a_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object bValue = root.b_.execute(frameValue);
Object precisionValue = executePrecision_(frameValue);
return getNext().execute_(frameValue, ex.getResult(), bValue, precisionValue);
}
DynamicObject bValue_;
try {
bValue_ = root.b_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object precisionValue = executePrecision_(frameValue);
return getNext().execute_(frameValue, aValue_, ex.getResult(), precisionValue);
}
int precisionValue_;
try {
if (precisionImplicitType == int.class) {
precisionValue_ = root.precision_.executeInteger(frameValue);
} else {
Object precisionValue__ = executePrecision_(frameValue);
precisionValue_ = RubyTypesGen.expectImplicitInteger(precisionValue__, precisionImplicitType);
}
} catch (UnexpectedResultException ex) {
return getNext().execute_(frameValue, aValue_, bValue_, ex.getResult());
}
if ((RubyGuards.isRubyBigDecimal(bValue_)) && (!(BigDecimalCoreMethodNode.isNormal(aValue_)) || !(BigDecimalCoreMethodNode.isNormal(bValue_)))) {
return root.addSpecial(frameValue, aValue_, bValue_, precisionValue_);
}
return getNext().execute_(frameValue, aValue_, bValue_, precisionValue_);
}
@Override
public Object execute_(VirtualFrame frameValue, Object aValue, Object bValue, Object precisionValue) {
if (aValue instanceof DynamicObject && bValue instanceof DynamicObject && RubyTypesGen.isImplicitInteger(precisionValue, precisionImplicitType)) {
DynamicObject aValue_ = (DynamicObject) aValue;
DynamicObject bValue_ = (DynamicObject) bValue;
int precisionValue_ = RubyTypesGen.asImplicitInteger(precisionValue, precisionImplicitType);
if ((RubyGuards.isRubyBigDecimal(bValue_)) && (!(BigDecimalCoreMethodNode.isNormal(aValue_)) || !(BigDecimalCoreMethodNode.isNormal(bValue_)))) {
return root.addSpecial(frameValue, aValue_, bValue_, precisionValue_);
}
}
return getNext().execute_(frameValue, aValue, bValue, precisionValue);
}
static BaseNode_ create(AddNodeGen root, Object precisionValue) {
return new AddSpecialNode_(root, precisionValue);
}
}
}
}
@GeneratedBy(SubOpNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class SubOpNodeFactory implements NodeFactory {
private static SubOpNodeFactory subOpNodeFactoryInstance;
private SubOpNodeFactory() {
}
@Override
public Class getNodeClass() {
return SubOpNode.class;
}
@Override
public List getExecutionSignature() {
return Arrays.asList(RubyNode.class, RubyNode.class);
}
@Override
public List getNodeSignatures() {
return Arrays.asList(Arrays.asList(RubyNode.class, RubyNode.class));
}
@Override
public SubOpNode createNode(Object... arguments) {
if (arguments.length == 2 && (arguments[0] == null || arguments[0] instanceof RubyNode) && (arguments[1] == null || arguments[1] instanceof RubyNode)) {
return create((RubyNode) arguments[0], (RubyNode) arguments[1]);
} else {
throw new IllegalArgumentException("Invalid create signature.");
}
}
public static NodeFactory getInstance() {
if (subOpNodeFactoryInstance == null) {
subOpNodeFactoryInstance = new SubOpNodeFactory();
}
return subOpNodeFactoryInstance;
}
public static SubOpNode create(RubyNode a, RubyNode b) {
return new SubOpNodeGen(a, b);
}
@GeneratedBy(SubOpNode.class)
public static final class SubOpNodeGen extends SubOpNode implements SpecializedNode {
@Child private RubyNode a_;
@Child private RubyNode b_;
@Child private BaseNode_ specialization_;
private SubOpNodeGen(RubyNode a, RubyNode b) {
this.a_ = a;
this.b_ = castB(b);
this.specialization_ = UninitializedNode_.create(this);
}
@Override
public NodeCost getCost() {
return specialization_.getNodeCost();
}
@Override
public Object execute(VirtualFrame frameValue) {
return specialization_.execute(frameValue);
}
@Override
public void executeVoid(VirtualFrame frameValue) {
specialization_.executeVoid(frameValue);
return;
}
@Override
public SpecializationNode getSpecializationNode() {
return specialization_;
}
@Override
public Node deepCopy() {
return SpecializationNode.updateRoot(super.deepCopy());
}
@GeneratedBy(SubOpNode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected SubOpNodeGen root;
BaseNode_(SubOpNodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (SubOpNodeGen) root;
}
@Override
protected final Node[] getSuppliedChildren() {
return new Node[] {root.a_, root.b_};
}
@Override
public final Object acceptAndExecute(Frame frameValue, Object aValue, Object bValue) {
return this.execute_((VirtualFrame) frameValue, aValue, bValue);
}
public abstract Object execute_(VirtualFrame frameValue, Object aValue, Object bValue);
public Object execute(VirtualFrame frameValue) {
Object aValue_ = root.a_.execute(frameValue);
Object bValue_ = root.b_.execute(frameValue);
return execute_(frameValue, aValue_, bValue_);
}
public void executeVoid(VirtualFrame frameValue) {
execute(frameValue);
return;
}
@Override
protected final SpecializationNode createNext(Frame frameValue, Object aValue, Object bValue) {
if (aValue instanceof DynamicObject && bValue instanceof DynamicObject) {
DynamicObject aValue_ = (DynamicObject) aValue;
DynamicObject bValue_ = (DynamicObject) bValue;
if ((BigDecimalCoreMethodNode.isNormal(aValue_)) && (BigDecimalCoreMethodNode.isNormalRubyBigDecimal(bValue_))) {
return SubNormalNode_.create(root);
}
if ((RubyGuards.isRubyBigDecimal(bValue_)) && (!(BigDecimalCoreMethodNode.isNormal(aValue_)) || !(BigDecimalCoreMethodNode.isNormal(bValue_)))) {
return SubSpecialNode_.create(root);
}
}
return null;
}
@Override
protected final SpecializationNode createPolymorphic() {
return PolymorphicNode_.create(root);
}
protected final BaseNode_ getNext() {
return (BaseNode_) this.next;
}
}
@GeneratedBy(SubOpNode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(SubOpNodeGen root) {
super(root, 2147483647);
}
@Override
public Object execute_(VirtualFrame frameValue, Object aValue, Object bValue) {
return uninitialized(frameValue, aValue, bValue);
}
static BaseNode_ create(SubOpNodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(SubOpNode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(SubOpNodeGen root) {
super(root, 0);
}
@Override
public SpecializationNode merge(SpecializationNode newNode, Frame frameValue, Object aValue, Object bValue) {
return polymorphicMerge(newNode, super.merge(newNode, frameValue, aValue, bValue));
}
@Override
public Object execute_(VirtualFrame frameValue, Object aValue, Object bValue) {
return getNext().execute_(frameValue, aValue, bValue);
}
static BaseNode_ create(SubOpNodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "subNormal(VirtualFrame, DynamicObject, DynamicObject)", value = SubOpNode.class)
private static final class SubNormalNode_ extends BaseNode_ {
SubNormalNode_(SubOpNodeGen root) {
super(root, 1);
}
@Override
public Object execute_(VirtualFrame frameValue, Object aValue, Object bValue) {
if (aValue instanceof DynamicObject && bValue instanceof DynamicObject) {
DynamicObject aValue_ = (DynamicObject) aValue;
DynamicObject bValue_ = (DynamicObject) bValue;
if ((BigDecimalCoreMethodNode.isNormal(aValue_)) && (BigDecimalCoreMethodNode.isNormalRubyBigDecimal(bValue_))) {
return root.subNormal(frameValue, aValue_, bValue_);
}
}
return getNext().execute_(frameValue, aValue, bValue);
}
static BaseNode_ create(SubOpNodeGen root) {
return new SubNormalNode_(root);
}
}
@GeneratedBy(methodName = "subSpecial(VirtualFrame, DynamicObject, DynamicObject)", value = SubOpNode.class)
private static final class SubSpecialNode_ extends BaseNode_ {
SubSpecialNode_(SubOpNodeGen root) {
super(root, 2);
}
@Override
public Object execute_(VirtualFrame frameValue, Object aValue, Object bValue) {
if (aValue instanceof DynamicObject && bValue instanceof DynamicObject) {
DynamicObject aValue_ = (DynamicObject) aValue;
DynamicObject bValue_ = (DynamicObject) bValue;
if ((RubyGuards.isRubyBigDecimal(bValue_)) && (!(BigDecimalCoreMethodNode.isNormal(aValue_)) || !(BigDecimalCoreMethodNode.isNormal(bValue_)))) {
return root.subSpecial(frameValue, aValue_, bValue_);
}
}
return getNext().execute_(frameValue, aValue, bValue);
}
static BaseNode_ create(SubOpNodeGen root) {
return new SubSpecialNode_(root);
}
}
}
}
@GeneratedBy(SubNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class SubNodeFactory implements NodeFactory {
private static SubNodeFactory subNodeFactoryInstance;
private SubNodeFactory() {
}
@Override
public Class getNodeClass() {
return SubNode.class;
}
@Override
public List getExecutionSignature() {
return Arrays.asList(RubyNode.class, RubyNode.class, RubyNode.class);
}
@Override
public List getNodeSignatures() {
return Arrays.asList(Arrays.asList(RubyNode.class, RubyNode.class, RubyNode.class));
}
@Override
public SubNode createNode(Object... arguments) {
if (arguments.length == 3 && (arguments[0] == null || arguments[0] instanceof RubyNode) && (arguments[1] == null || arguments[1] instanceof RubyNode) && (arguments[2] == null || arguments[2] instanceof RubyNode)) {
return create((RubyNode) arguments[0], (RubyNode) arguments[1], (RubyNode) arguments[2]);
} else {
throw new IllegalArgumentException("Invalid create signature.");
}
}
public static NodeFactory getInstance() {
if (subNodeFactoryInstance == null) {
subNodeFactoryInstance = new SubNodeFactory();
}
return subNodeFactoryInstance;
}
public static SubNode create(RubyNode a, RubyNode b, RubyNode precision) {
return new SubNodeGen(a, b, precision);
}
@GeneratedBy(SubNode.class)
public static final class SubNodeGen extends SubNode implements SpecializedNode {
@Child private RubyNode a_;
@Child private RubyNode b_;
@Child private RubyNode precision_;
@CompilationFinal private Class precisionType_;
@Child private BaseNode_ specialization_;
private SubNodeGen(RubyNode a, RubyNode b, RubyNode precision) {
this.a_ = a;
this.b_ = castB(b);
this.precision_ = precision;
this.specialization_ = UninitializedNode_.create(this);
}
@Override
public NodeCost getCost() {
return specialization_.getNodeCost();
}
@Override
public Object execute(VirtualFrame frameValue) {
return specialization_.execute(frameValue);
}
@Override
public void executeVoid(VirtualFrame frameValue) {
specialization_.executeVoid(frameValue);
return;
}
@Override
public SpecializationNode getSpecializationNode() {
return specialization_;
}
@Override
public Node deepCopy() {
return SpecializationNode.updateRoot(super.deepCopy());
}
@GeneratedBy(SubNode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected SubNodeGen root;
BaseNode_(SubNodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (SubNodeGen) root;
}
@Override
protected final Node[] getSuppliedChildren() {
return new Node[] {root.a_, root.b_, root.precision_};
}
@Override
public final Object acceptAndExecute(Frame frameValue, Object aValue, Object bValue, Object precisionValue) {
return this.execute_((VirtualFrame) frameValue, aValue, bValue, precisionValue);
}
public abstract Object execute_(VirtualFrame frameValue, Object aValue, Object bValue, Object precisionValue);
public Object execute(VirtualFrame frameValue) {
Object aValue_ = root.a_.execute(frameValue);
Object bValue_ = root.b_.execute(frameValue);
Object precisionValue_ = executePrecision_(frameValue);
return execute_(frameValue, aValue_, bValue_, precisionValue_);
}
public void executeVoid(VirtualFrame frameValue) {
execute(frameValue);
return;
}
@Override
protected final SpecializationNode createNext(Frame frameValue, Object aValue, Object bValue, Object precisionValue) {
if (aValue instanceof DynamicObject && bValue instanceof DynamicObject && RubyTypesGen.isImplicitInteger(precisionValue)) {
DynamicObject aValue_ = (DynamicObject) aValue;
DynamicObject bValue_ = (DynamicObject) bValue;
if ((BigDecimalCoreMethodNode.isNormal(aValue_)) && (BigDecimalCoreMethodNode.isNormalRubyBigDecimal(bValue_))) {
return SubNormalNode_.create(root, precisionValue);
}
if ((RubyGuards.isRubyBigDecimal(bValue_)) && (!(BigDecimalCoreMethodNode.isNormal(aValue_)) || !(BigDecimalCoreMethodNode.isNormal(bValue_)))) {
return SubSpecialNode_.create(root, precisionValue);
}
}
return null;
}
@Override
protected final SpecializationNode createPolymorphic() {
return PolymorphicNode_.create(root);
}
protected final BaseNode_ getNext() {
return (BaseNode_) this.next;
}
protected final Object executePrecision_(Frame frameValue) {
Class precisionType_ = root.precisionType_;
try {
if (precisionType_ == int.class) {
return root.precision_.executeInteger((VirtualFrame) frameValue);
} else if (precisionType_ == null) {
CompilerDirectives.transferToInterpreterAndInvalidate();
Class _type = Object.class;
try {
Object _value = root.precision_.execute((VirtualFrame) frameValue);
if (_value instanceof Integer) {
_type = int.class;
} else {
_type = Object.class;
}
return _value;
} finally {
root.precisionType_ = _type;
}
} else {
return root.precision_.execute((VirtualFrame) frameValue);
}
} catch (UnexpectedResultException ex) {
root.precisionType_ = Object.class;
return ex.getResult();
}
}
}
@GeneratedBy(SubNode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(SubNodeGen root) {
super(root, 2147483647);
}
@Override
public Object execute_(VirtualFrame frameValue, Object aValue, Object bValue, Object precisionValue) {
return uninitialized(frameValue, aValue, bValue, precisionValue);
}
static BaseNode_ create(SubNodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(SubNode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(SubNodeGen root) {
super(root, 0);
}
@Override
public SpecializationNode merge(SpecializationNode newNode, Frame frameValue, Object aValue, Object bValue, Object precisionValue) {
return polymorphicMerge(newNode, super.merge(newNode, frameValue, aValue, bValue, precisionValue));
}
@Override
public Object execute_(VirtualFrame frameValue, Object aValue, Object bValue, Object precisionValue) {
return getNext().execute_(frameValue, aValue, bValue, precisionValue);
}
static BaseNode_ create(SubNodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "subNormal(VirtualFrame, DynamicObject, DynamicObject, int)", value = SubNode.class)
private static final class SubNormalNode_ extends BaseNode_ {
private final Class precisionImplicitType;
SubNormalNode_(SubNodeGen root, Object precisionValue) {
super(root, 1);
this.precisionImplicitType = RubyTypesGen.getImplicitIntegerClass(precisionValue);
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.precisionImplicitType == ((SubNormalNode_) other).precisionImplicitType;
}
@Override
public Object execute(VirtualFrame frameValue) {
DynamicObject aValue_;
try {
aValue_ = root.a_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object bValue = root.b_.execute(frameValue);
Object precisionValue = executePrecision_(frameValue);
return getNext().execute_(frameValue, ex.getResult(), bValue, precisionValue);
}
DynamicObject bValue_;
try {
bValue_ = root.b_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object precisionValue = executePrecision_(frameValue);
return getNext().execute_(frameValue, aValue_, ex.getResult(), precisionValue);
}
int precisionValue_;
try {
if (precisionImplicitType == int.class) {
precisionValue_ = root.precision_.executeInteger(frameValue);
} else {
Object precisionValue__ = executePrecision_(frameValue);
precisionValue_ = RubyTypesGen.expectImplicitInteger(precisionValue__, precisionImplicitType);
}
} catch (UnexpectedResultException ex) {
return getNext().execute_(frameValue, aValue_, bValue_, ex.getResult());
}
if ((BigDecimalCoreMethodNode.isNormal(aValue_)) && (BigDecimalCoreMethodNode.isNormalRubyBigDecimal(bValue_))) {
return root.subNormal(frameValue, aValue_, bValue_, precisionValue_);
}
return getNext().execute_(frameValue, aValue_, bValue_, precisionValue_);
}
@Override
public Object execute_(VirtualFrame frameValue, Object aValue, Object bValue, Object precisionValue) {
if (aValue instanceof DynamicObject && bValue instanceof DynamicObject && RubyTypesGen.isImplicitInteger(precisionValue, precisionImplicitType)) {
DynamicObject aValue_ = (DynamicObject) aValue;
DynamicObject bValue_ = (DynamicObject) bValue;
int precisionValue_ = RubyTypesGen.asImplicitInteger(precisionValue, precisionImplicitType);
if ((BigDecimalCoreMethodNode.isNormal(aValue_)) && (BigDecimalCoreMethodNode.isNormalRubyBigDecimal(bValue_))) {
return root.subNormal(frameValue, aValue_, bValue_, precisionValue_);
}
}
return getNext().execute_(frameValue, aValue, bValue, precisionValue);
}
static BaseNode_ create(SubNodeGen root, Object precisionValue) {
return new SubNormalNode_(root, precisionValue);
}
}
@GeneratedBy(methodName = "subSpecial(VirtualFrame, DynamicObject, DynamicObject, int)", value = SubNode.class)
private static final class SubSpecialNode_ extends BaseNode_ {
private final Class precisionImplicitType;
SubSpecialNode_(SubNodeGen root, Object precisionValue) {
super(root, 2);
this.precisionImplicitType = RubyTypesGen.getImplicitIntegerClass(precisionValue);
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.precisionImplicitType == ((SubSpecialNode_) other).precisionImplicitType;
}
@Override
public Object execute(VirtualFrame frameValue) {
DynamicObject aValue_;
try {
aValue_ = root.a_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object bValue = root.b_.execute(frameValue);
Object precisionValue = executePrecision_(frameValue);
return getNext().execute_(frameValue, ex.getResult(), bValue, precisionValue);
}
DynamicObject bValue_;
try {
bValue_ = root.b_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object precisionValue = executePrecision_(frameValue);
return getNext().execute_(frameValue, aValue_, ex.getResult(), precisionValue);
}
int precisionValue_;
try {
if (precisionImplicitType == int.class) {
precisionValue_ = root.precision_.executeInteger(frameValue);
} else {
Object precisionValue__ = executePrecision_(frameValue);
precisionValue_ = RubyTypesGen.expectImplicitInteger(precisionValue__, precisionImplicitType);
}
} catch (UnexpectedResultException ex) {
return getNext().execute_(frameValue, aValue_, bValue_, ex.getResult());
}
if ((RubyGuards.isRubyBigDecimal(bValue_)) && (!(BigDecimalCoreMethodNode.isNormal(aValue_)) || !(BigDecimalCoreMethodNode.isNormal(bValue_)))) {
return root.subSpecial(frameValue, aValue_, bValue_, precisionValue_);
}
return getNext().execute_(frameValue, aValue_, bValue_, precisionValue_);
}
@Override
public Object execute_(VirtualFrame frameValue, Object aValue, Object bValue, Object precisionValue) {
if (aValue instanceof DynamicObject && bValue instanceof DynamicObject && RubyTypesGen.isImplicitInteger(precisionValue, precisionImplicitType)) {
DynamicObject aValue_ = (DynamicObject) aValue;
DynamicObject bValue_ = (DynamicObject) bValue;
int precisionValue_ = RubyTypesGen.asImplicitInteger(precisionValue, precisionImplicitType);
if ((RubyGuards.isRubyBigDecimal(bValue_)) && (!(BigDecimalCoreMethodNode.isNormal(aValue_)) || !(BigDecimalCoreMethodNode.isNormal(bValue_)))) {
return root.subSpecial(frameValue, aValue_, bValue_, precisionValue_);
}
}
return getNext().execute_(frameValue, aValue, bValue, precisionValue);
}
static BaseNode_ create(SubNodeGen root, Object precisionValue) {
return new SubSpecialNode_(root, precisionValue);
}
}
}
}
@GeneratedBy(NegNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class NegNodeFactory implements NodeFactory {
private static NegNodeFactory negNodeFactoryInstance;
private NegNodeFactory() {
}
@Override
public Class getNodeClass() {
return NegNode.class;
}
@Override
public List getExecutionSignature() {
return Arrays.asList(RubyNode.class);
}
@Override
public List getNodeSignatures() {
return Arrays.asList(Arrays.asList(RubyNode[].class));
}
@Override
public NegNode createNode(Object... arguments) {
if (arguments.length == 1 && (arguments[0] == null || arguments[0] instanceof RubyNode[])) {
return create((RubyNode[]) arguments[0]);
} else {
throw new IllegalArgumentException("Invalid create signature.");
}
}
public static NodeFactory getInstance() {
if (negNodeFactoryInstance == null) {
negNodeFactoryInstance = new NegNodeFactory();
}
return negNodeFactoryInstance;
}
public static NegNode create(RubyNode[] arguments) {
return new NegNodeGen(arguments);
}
@GeneratedBy(NegNode.class)
public static final class NegNodeGen extends NegNode implements SpecializedNode {
@Child private RubyNode arguments0_;
@Child private BaseNode_ specialization_;
private NegNodeGen(RubyNode[] arguments) {
this.arguments0_ = arguments != null && 0 < arguments.length ? arguments[0] : null;
this.specialization_ = UninitializedNode_.create(this);
}
@Override
public NodeCost getCost() {
return specialization_.getNodeCost();
}
@Override
public Object execute(VirtualFrame frameValue) {
return specialization_.execute(frameValue);
}
@Override
public void executeVoid(VirtualFrame frameValue) {
specialization_.executeVoid(frameValue);
return;
}
@Override
public SpecializationNode getSpecializationNode() {
return specialization_;
}
@Override
public Node deepCopy() {
return SpecializationNode.updateRoot(super.deepCopy());
}
@GeneratedBy(NegNode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected NegNodeGen root;
BaseNode_(NegNodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (NegNodeGen) root;
}
@Override
protected final Node[] getSuppliedChildren() {
return new Node[] {root.arguments0_};
}
@Override
public final Object acceptAndExecute(Frame frameValue, Object arguments0Value) {
return this.execute_((VirtualFrame) frameValue, arguments0Value);
}
public abstract Object execute_(VirtualFrame frameValue, Object arguments0Value);
public Object execute(VirtualFrame frameValue) {
Object arguments0Value_ = root.arguments0_.execute(frameValue);
return execute_(frameValue, arguments0Value_);
}
public void executeVoid(VirtualFrame frameValue) {
execute(frameValue);
return;
}
@Override
protected final SpecializationNode createNext(Frame frameValue, Object arguments0Value) {
if (arguments0Value instanceof DynamicObject) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
if ((BigDecimalCoreMethodNode.isNormal(arguments0Value_)) && (!(BigDecimalCoreMethodNode.isNormalZero(arguments0Value_)))) {
return NegNormalNode_.create(root);
}
if ((BigDecimalCoreMethodNode.isNormal(arguments0Value_)) && (BigDecimalCoreMethodNode.isNormalZero(arguments0Value_))) {
return NegNormalZeroNode_.create(root);
}
if ((!(BigDecimalCoreMethodNode.isNormal(arguments0Value_)))) {
ConditionProfile nanProfile3 = (ConditionProfile.createBinaryProfile());
ConditionProfile negZeroProfile3 = (ConditionProfile.createBinaryProfile());
ConditionProfile infProfile3 = (ConditionProfile.createBinaryProfile());
return NegSpecialNode_.create(root, nanProfile3, negZeroProfile3, infProfile3);
}
}
return null;
}
@Override
protected final SpecializationNode createPolymorphic() {
return PolymorphicNode_.create(root);
}
protected final BaseNode_ getNext() {
return (BaseNode_) this.next;
}
}
@GeneratedBy(NegNode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(NegNodeGen root) {
super(root, 2147483647);
}
@Override
public Object execute_(VirtualFrame frameValue, Object arguments0Value) {
return uninitialized(frameValue, arguments0Value);
}
static BaseNode_ create(NegNodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(NegNode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(NegNodeGen root) {
super(root, 0);
}
@Override
public SpecializationNode merge(SpecializationNode newNode, Frame frameValue, Object arguments0Value) {
return polymorphicMerge(newNode, super.merge(newNode, frameValue, arguments0Value));
}
@Override
public Object execute_(VirtualFrame frameValue, Object arguments0Value) {
return getNext().execute_(frameValue, arguments0Value);
}
static BaseNode_ create(NegNodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "negNormal(VirtualFrame, DynamicObject)", value = NegNode.class)
private static final class NegNormalNode_ extends BaseNode_ {
NegNormalNode_(NegNodeGen root) {
super(root, 1);
}
@Override
public Object execute_(VirtualFrame frameValue, Object arguments0Value) {
if (arguments0Value instanceof DynamicObject) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
if ((BigDecimalCoreMethodNode.isNormal(arguments0Value_)) && (!(BigDecimalCoreMethodNode.isNormalZero(arguments0Value_)))) {
return root.negNormal(frameValue, arguments0Value_);
}
}
return getNext().execute_(frameValue, arguments0Value);
}
static BaseNode_ create(NegNodeGen root) {
return new NegNormalNode_(root);
}
}
@GeneratedBy(methodName = "negNormalZero(VirtualFrame, DynamicObject)", value = NegNode.class)
private static final class NegNormalZeroNode_ extends BaseNode_ {
NegNormalZeroNode_(NegNodeGen root) {
super(root, 2);
}
@Override
public Object execute_(VirtualFrame frameValue, Object arguments0Value) {
if (arguments0Value instanceof DynamicObject) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
if ((BigDecimalCoreMethodNode.isNormal(arguments0Value_)) && (BigDecimalCoreMethodNode.isNormalZero(arguments0Value_))) {
return root.negNormalZero(frameValue, arguments0Value_);
}
}
return getNext().execute_(frameValue, arguments0Value);
}
static BaseNode_ create(NegNodeGen root) {
return new NegNormalZeroNode_(root);
}
}
@GeneratedBy(methodName = "negSpecial(VirtualFrame, DynamicObject, ConditionProfile, ConditionProfile, ConditionProfile)", value = NegNode.class)
private static final class NegSpecialNode_ extends BaseNode_ {
private final ConditionProfile nanProfile;
private final ConditionProfile negZeroProfile;
private final ConditionProfile infProfile;
NegSpecialNode_(NegNodeGen root, ConditionProfile nanProfile, ConditionProfile negZeroProfile, ConditionProfile infProfile) {
super(root, 3);
this.nanProfile = nanProfile;
this.negZeroProfile = negZeroProfile;
this.infProfile = infProfile;
}
@Override
public Object execute_(VirtualFrame frameValue, Object arguments0Value) {
if (arguments0Value instanceof DynamicObject) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
if ((!(BigDecimalCoreMethodNode.isNormal(arguments0Value_)))) {
return root.negSpecial(frameValue, arguments0Value_, this.nanProfile, this.negZeroProfile, this.infProfile);
}
}
return getNext().execute_(frameValue, arguments0Value);
}
static BaseNode_ create(NegNodeGen root, ConditionProfile nanProfile, ConditionProfile negZeroProfile, ConditionProfile infProfile) {
return new NegSpecialNode_(root, nanProfile, negZeroProfile, infProfile);
}
}
}
}
@GeneratedBy(MultOpNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class MultOpNodeFactory implements NodeFactory {
private static MultOpNodeFactory multOpNodeFactoryInstance;
private MultOpNodeFactory() {
}
@Override
public Class getNodeClass() {
return MultOpNode.class;
}
@Override
public List getExecutionSignature() {
return Arrays.asList(RubyNode.class, RubyNode.class);
}
@Override
public List getNodeSignatures() {
return Arrays.asList(Arrays.asList(RubyNode.class, RubyNode.class));
}
@Override
public MultOpNode createNode(Object... arguments) {
if (arguments.length == 2 && (arguments[0] == null || arguments[0] instanceof RubyNode) && (arguments[1] == null || arguments[1] instanceof RubyNode)) {
return create((RubyNode) arguments[0], (RubyNode) arguments[1]);
} else {
throw new IllegalArgumentException("Invalid create signature.");
}
}
public static NodeFactory getInstance() {
if (multOpNodeFactoryInstance == null) {
multOpNodeFactoryInstance = new MultOpNodeFactory();
}
return multOpNodeFactoryInstance;
}
public static MultOpNode create(RubyNode a, RubyNode b) {
return new MultOpNodeGen(a, b);
}
@GeneratedBy(MultOpNode.class)
public static final class MultOpNodeGen extends MultOpNode implements SpecializedNode {
@Child private RubyNode a_;
@Child private RubyNode b_;
@Child private BaseNode_ specialization_;
private MultOpNodeGen(RubyNode a, RubyNode b) {
this.a_ = a;
this.b_ = castB(b);
this.specialization_ = UninitializedNode_.create(this);
}
@Override
public NodeCost getCost() {
return specialization_.getNodeCost();
}
@Override
public Object execute(VirtualFrame frameValue) {
return specialization_.execute(frameValue);
}
@Override
public void executeVoid(VirtualFrame frameValue) {
specialization_.executeVoid(frameValue);
return;
}
@Override
public SpecializationNode getSpecializationNode() {
return specialization_;
}
@Override
public Node deepCopy() {
return SpecializationNode.updateRoot(super.deepCopy());
}
@GeneratedBy(MultOpNode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected MultOpNodeGen root;
BaseNode_(MultOpNodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (MultOpNodeGen) root;
}
@Override
protected final Node[] getSuppliedChildren() {
return new Node[] {root.a_, root.b_};
}
@Override
public final Object acceptAndExecute(Frame frameValue, Object aValue, Object bValue) {
return this.execute_((VirtualFrame) frameValue, aValue, bValue);
}
public abstract Object execute_(VirtualFrame frameValue, Object aValue, Object bValue);
public Object execute(VirtualFrame frameValue) {
Object aValue_ = root.a_.execute(frameValue);
Object bValue_ = root.b_.execute(frameValue);
return execute_(frameValue, aValue_, bValue_);
}
public void executeVoid(VirtualFrame frameValue) {
execute(frameValue);
return;
}
@Override
protected final SpecializationNode createNext(Frame frameValue, Object aValue, Object bValue) {
if (aValue instanceof DynamicObject && bValue instanceof DynamicObject) {
DynamicObject aValue_ = (DynamicObject) aValue;
DynamicObject bValue_ = (DynamicObject) bValue;
if ((BigDecimalCoreMethodNode.isNormal(aValue_)) && (BigDecimalCoreMethodNode.isNormalRubyBigDecimal(bValue_))) {
return MultNode_.create(root);
}
if ((BigDecimalCoreMethodNode.isNormal(aValue_)) && (BigDecimalCoreMethodNode.isSpecialRubyBigDecimal(bValue_))) {
return MultNormalSpecialNode_.create(root);
}
if ((!(BigDecimalCoreMethodNode.isNormal(aValue_))) && (BigDecimalCoreMethodNode.isNormalRubyBigDecimal(bValue_))) {
return MultSpecialNormalNode_.create(root);
}
if ((!(BigDecimalCoreMethodNode.isNormal(aValue_))) && (BigDecimalCoreMethodNode.isSpecialRubyBigDecimal(bValue_))) {
return MultSpecialNode_.create(root);
}
}
return null;
}
@Override
protected final SpecializationNode createPolymorphic() {
return PolymorphicNode_.create(root);
}
protected final BaseNode_ getNext() {
return (BaseNode_) this.next;
}
}
@GeneratedBy(MultOpNode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(MultOpNodeGen root) {
super(root, 2147483647);
}
@Override
public Object execute_(VirtualFrame frameValue, Object aValue, Object bValue) {
return uninitialized(frameValue, aValue, bValue);
}
static BaseNode_ create(MultOpNodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(MultOpNode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(MultOpNodeGen root) {
super(root, 0);
}
@Override
public SpecializationNode merge(SpecializationNode newNode, Frame frameValue, Object aValue, Object bValue) {
return polymorphicMerge(newNode, super.merge(newNode, frameValue, aValue, bValue));
}
@Override
public Object execute_(VirtualFrame frameValue, Object aValue, Object bValue) {
return getNext().execute_(frameValue, aValue, bValue);
}
static BaseNode_ create(MultOpNodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "mult(VirtualFrame, DynamicObject, DynamicObject)", value = MultOpNode.class)
private static final class MultNode_ extends BaseNode_ {
MultNode_(MultOpNodeGen root) {
super(root, 1);
}
@Override
public Object execute_(VirtualFrame frameValue, Object aValue, Object bValue) {
if (aValue instanceof DynamicObject && bValue instanceof DynamicObject) {
DynamicObject aValue_ = (DynamicObject) aValue;
DynamicObject bValue_ = (DynamicObject) bValue;
if ((BigDecimalCoreMethodNode.isNormal(aValue_)) && (BigDecimalCoreMethodNode.isNormalRubyBigDecimal(bValue_))) {
return root.mult(frameValue, aValue_, bValue_);
}
}
return getNext().execute_(frameValue, aValue, bValue);
}
static BaseNode_ create(MultOpNodeGen root) {
return new MultNode_(root);
}
}
@GeneratedBy(methodName = "multNormalSpecial(VirtualFrame, DynamicObject, DynamicObject)", value = MultOpNode.class)
private static final class MultNormalSpecialNode_ extends BaseNode_ {
MultNormalSpecialNode_(MultOpNodeGen root) {
super(root, 2);
}
@Override
public Object execute_(VirtualFrame frameValue, Object aValue, Object bValue) {
if (aValue instanceof DynamicObject && bValue instanceof DynamicObject) {
DynamicObject aValue_ = (DynamicObject) aValue;
DynamicObject bValue_ = (DynamicObject) bValue;
if ((BigDecimalCoreMethodNode.isNormal(aValue_)) && (BigDecimalCoreMethodNode.isSpecialRubyBigDecimal(bValue_))) {
return root.multNormalSpecial(frameValue, aValue_, bValue_);
}
}
return getNext().execute_(frameValue, aValue, bValue);
}
static BaseNode_ create(MultOpNodeGen root) {
return new MultNormalSpecialNode_(root);
}
}
@GeneratedBy(methodName = "multSpecialNormal(VirtualFrame, DynamicObject, DynamicObject)", value = MultOpNode.class)
private static final class MultSpecialNormalNode_ extends BaseNode_ {
MultSpecialNormalNode_(MultOpNodeGen root) {
super(root, 3);
}
@Override
public Object execute_(VirtualFrame frameValue, Object aValue, Object bValue) {
if (aValue instanceof DynamicObject && bValue instanceof DynamicObject) {
DynamicObject aValue_ = (DynamicObject) aValue;
DynamicObject bValue_ = (DynamicObject) bValue;
if ((!(BigDecimalCoreMethodNode.isNormal(aValue_))) && (BigDecimalCoreMethodNode.isNormalRubyBigDecimal(bValue_))) {
return root.multSpecialNormal(frameValue, aValue_, bValue_);
}
}
return getNext().execute_(frameValue, aValue, bValue);
}
static BaseNode_ create(MultOpNodeGen root) {
return new MultSpecialNormalNode_(root);
}
}
@GeneratedBy(methodName = "multSpecial(VirtualFrame, DynamicObject, DynamicObject)", value = MultOpNode.class)
private static final class MultSpecialNode_ extends BaseNode_ {
MultSpecialNode_(MultOpNodeGen root) {
super(root, 4);
}
@Override
public Object execute_(VirtualFrame frameValue, Object aValue, Object bValue) {
if (aValue instanceof DynamicObject && bValue instanceof DynamicObject) {
DynamicObject aValue_ = (DynamicObject) aValue;
DynamicObject bValue_ = (DynamicObject) bValue;
if ((!(BigDecimalCoreMethodNode.isNormal(aValue_))) && (BigDecimalCoreMethodNode.isSpecialRubyBigDecimal(bValue_))) {
return root.multSpecial(frameValue, aValue_, bValue_);
}
}
return getNext().execute_(frameValue, aValue, bValue);
}
static BaseNode_ create(MultOpNodeGen root) {
return new MultSpecialNode_(root);
}
}
}
}
@GeneratedBy(MultNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class MultNodeFactory implements NodeFactory {
private static MultNodeFactory multNodeFactoryInstance;
private MultNodeFactory() {
}
@Override
public Class getNodeClass() {
return MultNode.class;
}
@Override
public List getExecutionSignature() {
return Arrays.asList(RubyNode.class, RubyNode.class, RubyNode.class);
}
@Override
public List getNodeSignatures() {
return Arrays.asList(Arrays.asList(RubyNode.class, RubyNode.class, RubyNode.class));
}
@Override
public MultNode createNode(Object... arguments) {
if (arguments.length == 3 && (arguments[0] == null || arguments[0] instanceof RubyNode) && (arguments[1] == null || arguments[1] instanceof RubyNode) && (arguments[2] == null || arguments[2] instanceof RubyNode)) {
return create((RubyNode) arguments[0], (RubyNode) arguments[1], (RubyNode) arguments[2]);
} else {
throw new IllegalArgumentException("Invalid create signature.");
}
}
public static NodeFactory getInstance() {
if (multNodeFactoryInstance == null) {
multNodeFactoryInstance = new MultNodeFactory();
}
return multNodeFactoryInstance;
}
public static MultNode create(RubyNode a, RubyNode b, RubyNode precision) {
return new MultNodeGen(a, b, precision);
}
@GeneratedBy(MultNode.class)
public static final class MultNodeGen extends MultNode implements SpecializedNode {
@Child private RubyNode a_;
@Child private RubyNode b_;
@Child private RubyNode precision_;
@CompilationFinal private Class precisionType_;
@Child private BaseNode_ specialization_;
private MultNodeGen(RubyNode a, RubyNode b, RubyNode precision) {
this.a_ = a;
this.b_ = castB(b);
this.precision_ = precision;
this.specialization_ = UninitializedNode_.create(this);
}
@Override
public NodeCost getCost() {
return specialization_.getNodeCost();
}
@Override
public Object execute(VirtualFrame frameValue) {
return specialization_.execute(frameValue);
}
@Override
public void executeVoid(VirtualFrame frameValue) {
specialization_.executeVoid(frameValue);
return;
}
@Override
public SpecializationNode getSpecializationNode() {
return specialization_;
}
@Override
public Node deepCopy() {
return SpecializationNode.updateRoot(super.deepCopy());
}
@GeneratedBy(MultNode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected MultNodeGen root;
BaseNode_(MultNodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (MultNodeGen) root;
}
@Override
protected final Node[] getSuppliedChildren() {
return new Node[] {root.a_, root.b_, root.precision_};
}
@Override
public final Object acceptAndExecute(Frame frameValue, Object aValue, Object bValue, Object precisionValue) {
return this.execute_((VirtualFrame) frameValue, aValue, bValue, precisionValue);
}
public abstract Object execute_(VirtualFrame frameValue, Object aValue, Object bValue, Object precisionValue);
public Object execute(VirtualFrame frameValue) {
Object aValue_ = root.a_.execute(frameValue);
Object bValue_ = root.b_.execute(frameValue);
Object precisionValue_ = executePrecision_(frameValue);
return execute_(frameValue, aValue_, bValue_, precisionValue_);
}
public void executeVoid(VirtualFrame frameValue) {
execute(frameValue);
return;
}
@Override
protected final SpecializationNode createNext(Frame frameValue, Object aValue, Object bValue, Object precisionValue) {
if (aValue instanceof DynamicObject && bValue instanceof DynamicObject && RubyTypesGen.isImplicitInteger(precisionValue)) {
DynamicObject aValue_ = (DynamicObject) aValue;
DynamicObject bValue_ = (DynamicObject) bValue;
if ((BigDecimalCoreMethodNode.isNormal(aValue_)) && (BigDecimalCoreMethodNode.isNormalRubyBigDecimal(bValue_))) {
return MultNode_.create(root, precisionValue);
}
if ((BigDecimalCoreMethodNode.isNormal(aValue_)) && (BigDecimalCoreMethodNode.isSpecialRubyBigDecimal(bValue_))) {
return MultNormalSpecialNode_.create(root, precisionValue);
}
if ((!(BigDecimalCoreMethodNode.isNormal(aValue_))) && (BigDecimalCoreMethodNode.isNormalRubyBigDecimal(bValue_))) {
return MultSpecialNormalNode_.create(root, precisionValue);
}
if ((!(BigDecimalCoreMethodNode.isNormal(aValue_))) && (BigDecimalCoreMethodNode.isSpecialRubyBigDecimal(bValue_))) {
return MultSpecialNode_.create(root, precisionValue);
}
}
return null;
}
@Override
protected final SpecializationNode createPolymorphic() {
return PolymorphicNode_.create(root);
}
protected final BaseNode_ getNext() {
return (BaseNode_) this.next;
}
protected final Object executePrecision_(Frame frameValue) {
Class precisionType_ = root.precisionType_;
try {
if (precisionType_ == int.class) {
return root.precision_.executeInteger((VirtualFrame) frameValue);
} else if (precisionType_ == null) {
CompilerDirectives.transferToInterpreterAndInvalidate();
Class _type = Object.class;
try {
Object _value = root.precision_.execute((VirtualFrame) frameValue);
if (_value instanceof Integer) {
_type = int.class;
} else {
_type = Object.class;
}
return _value;
} finally {
root.precisionType_ = _type;
}
} else {
return root.precision_.execute((VirtualFrame) frameValue);
}
} catch (UnexpectedResultException ex) {
root.precisionType_ = Object.class;
return ex.getResult();
}
}
}
@GeneratedBy(MultNode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(MultNodeGen root) {
super(root, 2147483647);
}
@Override
public Object execute_(VirtualFrame frameValue, Object aValue, Object bValue, Object precisionValue) {
return uninitialized(frameValue, aValue, bValue, precisionValue);
}
static BaseNode_ create(MultNodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(MultNode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(MultNodeGen root) {
super(root, 0);
}
@Override
public SpecializationNode merge(SpecializationNode newNode, Frame frameValue, Object aValue, Object bValue, Object precisionValue) {
return polymorphicMerge(newNode, super.merge(newNode, frameValue, aValue, bValue, precisionValue));
}
@Override
public Object execute_(VirtualFrame frameValue, Object aValue, Object bValue, Object precisionValue) {
return getNext().execute_(frameValue, aValue, bValue, precisionValue);
}
static BaseNode_ create(MultNodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "mult(VirtualFrame, DynamicObject, DynamicObject, int)", value = MultNode.class)
private static final class MultNode_ extends BaseNode_ {
private final Class precisionImplicitType;
MultNode_(MultNodeGen root, Object precisionValue) {
super(root, 1);
this.precisionImplicitType = RubyTypesGen.getImplicitIntegerClass(precisionValue);
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.precisionImplicitType == ((MultNode_) other).precisionImplicitType;
}
@Override
public Object execute(VirtualFrame frameValue) {
DynamicObject aValue_;
try {
aValue_ = root.a_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object bValue = root.b_.execute(frameValue);
Object precisionValue = executePrecision_(frameValue);
return getNext().execute_(frameValue, ex.getResult(), bValue, precisionValue);
}
DynamicObject bValue_;
try {
bValue_ = root.b_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object precisionValue = executePrecision_(frameValue);
return getNext().execute_(frameValue, aValue_, ex.getResult(), precisionValue);
}
int precisionValue_;
try {
if (precisionImplicitType == int.class) {
precisionValue_ = root.precision_.executeInteger(frameValue);
} else {
Object precisionValue__ = executePrecision_(frameValue);
precisionValue_ = RubyTypesGen.expectImplicitInteger(precisionValue__, precisionImplicitType);
}
} catch (UnexpectedResultException ex) {
return getNext().execute_(frameValue, aValue_, bValue_, ex.getResult());
}
if ((BigDecimalCoreMethodNode.isNormal(aValue_)) && (BigDecimalCoreMethodNode.isNormalRubyBigDecimal(bValue_))) {
return root.mult(frameValue, aValue_, bValue_, precisionValue_);
}
return getNext().execute_(frameValue, aValue_, bValue_, precisionValue_);
}
@Override
public Object execute_(VirtualFrame frameValue, Object aValue, Object bValue, Object precisionValue) {
if (aValue instanceof DynamicObject && bValue instanceof DynamicObject && RubyTypesGen.isImplicitInteger(precisionValue, precisionImplicitType)) {
DynamicObject aValue_ = (DynamicObject) aValue;
DynamicObject bValue_ = (DynamicObject) bValue;
int precisionValue_ = RubyTypesGen.asImplicitInteger(precisionValue, precisionImplicitType);
if ((BigDecimalCoreMethodNode.isNormal(aValue_)) && (BigDecimalCoreMethodNode.isNormalRubyBigDecimal(bValue_))) {
return root.mult(frameValue, aValue_, bValue_, precisionValue_);
}
}
return getNext().execute_(frameValue, aValue, bValue, precisionValue);
}
static BaseNode_ create(MultNodeGen root, Object precisionValue) {
return new MultNode_(root, precisionValue);
}
}
@GeneratedBy(methodName = "multNormalSpecial(VirtualFrame, DynamicObject, DynamicObject, int)", value = MultNode.class)
private static final class MultNormalSpecialNode_ extends BaseNode_ {
private final Class precisionImplicitType;
MultNormalSpecialNode_(MultNodeGen root, Object precisionValue) {
super(root, 2);
this.precisionImplicitType = RubyTypesGen.getImplicitIntegerClass(precisionValue);
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.precisionImplicitType == ((MultNormalSpecialNode_) other).precisionImplicitType;
}
@Override
public Object execute(VirtualFrame frameValue) {
DynamicObject aValue_;
try {
aValue_ = root.a_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object bValue = root.b_.execute(frameValue);
Object precisionValue = executePrecision_(frameValue);
return getNext().execute_(frameValue, ex.getResult(), bValue, precisionValue);
}
DynamicObject bValue_;
try {
bValue_ = root.b_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object precisionValue = executePrecision_(frameValue);
return getNext().execute_(frameValue, aValue_, ex.getResult(), precisionValue);
}
int precisionValue_;
try {
if (precisionImplicitType == int.class) {
precisionValue_ = root.precision_.executeInteger(frameValue);
} else {
Object precisionValue__ = executePrecision_(frameValue);
precisionValue_ = RubyTypesGen.expectImplicitInteger(precisionValue__, precisionImplicitType);
}
} catch (UnexpectedResultException ex) {
return getNext().execute_(frameValue, aValue_, bValue_, ex.getResult());
}
if ((BigDecimalCoreMethodNode.isNormal(aValue_)) && (BigDecimalCoreMethodNode.isSpecialRubyBigDecimal(bValue_))) {
return root.multNormalSpecial(frameValue, aValue_, bValue_, precisionValue_);
}
return getNext().execute_(frameValue, aValue_, bValue_, precisionValue_);
}
@Override
public Object execute_(VirtualFrame frameValue, Object aValue, Object bValue, Object precisionValue) {
if (aValue instanceof DynamicObject && bValue instanceof DynamicObject && RubyTypesGen.isImplicitInteger(precisionValue, precisionImplicitType)) {
DynamicObject aValue_ = (DynamicObject) aValue;
DynamicObject bValue_ = (DynamicObject) bValue;
int precisionValue_ = RubyTypesGen.asImplicitInteger(precisionValue, precisionImplicitType);
if ((BigDecimalCoreMethodNode.isNormal(aValue_)) && (BigDecimalCoreMethodNode.isSpecialRubyBigDecimal(bValue_))) {
return root.multNormalSpecial(frameValue, aValue_, bValue_, precisionValue_);
}
}
return getNext().execute_(frameValue, aValue, bValue, precisionValue);
}
static BaseNode_ create(MultNodeGen root, Object precisionValue) {
return new MultNormalSpecialNode_(root, precisionValue);
}
}
@GeneratedBy(methodName = "multSpecialNormal(VirtualFrame, DynamicObject, DynamicObject, int)", value = MultNode.class)
private static final class MultSpecialNormalNode_ extends BaseNode_ {
private final Class precisionImplicitType;
MultSpecialNormalNode_(MultNodeGen root, Object precisionValue) {
super(root, 3);
this.precisionImplicitType = RubyTypesGen.getImplicitIntegerClass(precisionValue);
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.precisionImplicitType == ((MultSpecialNormalNode_) other).precisionImplicitType;
}
@Override
public Object execute(VirtualFrame frameValue) {
DynamicObject aValue_;
try {
aValue_ = root.a_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object bValue = root.b_.execute(frameValue);
Object precisionValue = executePrecision_(frameValue);
return getNext().execute_(frameValue, ex.getResult(), bValue, precisionValue);
}
DynamicObject bValue_;
try {
bValue_ = root.b_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object precisionValue = executePrecision_(frameValue);
return getNext().execute_(frameValue, aValue_, ex.getResult(), precisionValue);
}
int precisionValue_;
try {
if (precisionImplicitType == int.class) {
precisionValue_ = root.precision_.executeInteger(frameValue);
} else {
Object precisionValue__ = executePrecision_(frameValue);
precisionValue_ = RubyTypesGen.expectImplicitInteger(precisionValue__, precisionImplicitType);
}
} catch (UnexpectedResultException ex) {
return getNext().execute_(frameValue, aValue_, bValue_, ex.getResult());
}
if ((!(BigDecimalCoreMethodNode.isNormal(aValue_))) && (BigDecimalCoreMethodNode.isNormalRubyBigDecimal(bValue_))) {
return root.multSpecialNormal(frameValue, aValue_, bValue_, precisionValue_);
}
return getNext().execute_(frameValue, aValue_, bValue_, precisionValue_);
}
@Override
public Object execute_(VirtualFrame frameValue, Object aValue, Object bValue, Object precisionValue) {
if (aValue instanceof DynamicObject && bValue instanceof DynamicObject && RubyTypesGen.isImplicitInteger(precisionValue, precisionImplicitType)) {
DynamicObject aValue_ = (DynamicObject) aValue;
DynamicObject bValue_ = (DynamicObject) bValue;
int precisionValue_ = RubyTypesGen.asImplicitInteger(precisionValue, precisionImplicitType);
if ((!(BigDecimalCoreMethodNode.isNormal(aValue_))) && (BigDecimalCoreMethodNode.isNormalRubyBigDecimal(bValue_))) {
return root.multSpecialNormal(frameValue, aValue_, bValue_, precisionValue_);
}
}
return getNext().execute_(frameValue, aValue, bValue, precisionValue);
}
static BaseNode_ create(MultNodeGen root, Object precisionValue) {
return new MultSpecialNormalNode_(root, precisionValue);
}
}
@GeneratedBy(methodName = "multSpecial(VirtualFrame, DynamicObject, DynamicObject, int)", value = MultNode.class)
private static final class MultSpecialNode_ extends BaseNode_ {
private final Class precisionImplicitType;
MultSpecialNode_(MultNodeGen root, Object precisionValue) {
super(root, 4);
this.precisionImplicitType = RubyTypesGen.getImplicitIntegerClass(precisionValue);
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.precisionImplicitType == ((MultSpecialNode_) other).precisionImplicitType;
}
@Override
public Object execute(VirtualFrame frameValue) {
DynamicObject aValue_;
try {
aValue_ = root.a_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object bValue = root.b_.execute(frameValue);
Object precisionValue = executePrecision_(frameValue);
return getNext().execute_(frameValue, ex.getResult(), bValue, precisionValue);
}
DynamicObject bValue_;
try {
bValue_ = root.b_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object precisionValue = executePrecision_(frameValue);
return getNext().execute_(frameValue, aValue_, ex.getResult(), precisionValue);
}
int precisionValue_;
try {
if (precisionImplicitType == int.class) {
precisionValue_ = root.precision_.executeInteger(frameValue);
} else {
Object precisionValue__ = executePrecision_(frameValue);
precisionValue_ = RubyTypesGen.expectImplicitInteger(precisionValue__, precisionImplicitType);
}
} catch (UnexpectedResultException ex) {
return getNext().execute_(frameValue, aValue_, bValue_, ex.getResult());
}
if ((!(BigDecimalCoreMethodNode.isNormal(aValue_))) && (BigDecimalCoreMethodNode.isSpecialRubyBigDecimal(bValue_))) {
return root.multSpecial(frameValue, aValue_, bValue_, precisionValue_);
}
return getNext().execute_(frameValue, aValue_, bValue_, precisionValue_);
}
@Override
public Object execute_(VirtualFrame frameValue, Object aValue, Object bValue, Object precisionValue) {
if (aValue instanceof DynamicObject && bValue instanceof DynamicObject && RubyTypesGen.isImplicitInteger(precisionValue, precisionImplicitType)) {
DynamicObject aValue_ = (DynamicObject) aValue;
DynamicObject bValue_ = (DynamicObject) bValue;
int precisionValue_ = RubyTypesGen.asImplicitInteger(precisionValue, precisionImplicitType);
if ((!(BigDecimalCoreMethodNode.isNormal(aValue_))) && (BigDecimalCoreMethodNode.isSpecialRubyBigDecimal(bValue_))) {
return root.multSpecial(frameValue, aValue_, bValue_, precisionValue_);
}
}
return getNext().execute_(frameValue, aValue, bValue, precisionValue);
}
static BaseNode_ create(MultNodeGen root, Object precisionValue) {
return new MultSpecialNode_(root, precisionValue);
}
}
}
}
@GeneratedBy(DivOpNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class DivOpNodeFactory implements NodeFactory {
private static DivOpNodeFactory divOpNodeFactoryInstance;
private DivOpNodeFactory() {
}
@Override
public Class getNodeClass() {
return DivOpNode.class;
}
@Override
public List getExecutionSignature() {
return Arrays.asList(RubyNode.class, RubyNode.class);
}
@Override
public List getNodeSignatures() {
return Arrays.asList(Arrays.asList(RubyNode.class, RubyNode.class));
}
@Override
public DivOpNode createNode(Object... arguments) {
if (arguments.length == 2 && (arguments[0] == null || arguments[0] instanceof RubyNode) && (arguments[1] == null || arguments[1] instanceof RubyNode)) {
return create((RubyNode) arguments[0], (RubyNode) arguments[1]);
} else {
throw new IllegalArgumentException("Invalid create signature.");
}
}
public static NodeFactory getInstance() {
if (divOpNodeFactoryInstance == null) {
divOpNodeFactoryInstance = new DivOpNodeFactory();
}
return divOpNodeFactoryInstance;
}
public static DivOpNode create(RubyNode a, RubyNode b) {
return new DivOpNodeGen(a, b);
}
@GeneratedBy(DivOpNode.class)
public static final class DivOpNodeGen extends DivOpNode implements SpecializedNode {
@Child private RubyNode a_;
@Child private RubyNode b_;
@Child private BaseNode_ specialization_;
private DivOpNodeGen(RubyNode a, RubyNode b) {
this.a_ = a;
this.b_ = castB(b);
this.specialization_ = UninitializedNode_.create(this);
}
@Override
public NodeCost getCost() {
return specialization_.getNodeCost();
}
@Override
public Object execute(VirtualFrame frameValue) {
return specialization_.execute(frameValue);
}
@Override
public void executeVoid(VirtualFrame frameValue) {
specialization_.executeVoid(frameValue);
return;
}
@Override
public SpecializationNode getSpecializationNode() {
return specialization_;
}
@Override
public Node deepCopy() {
return SpecializationNode.updateRoot(super.deepCopy());
}
@GeneratedBy(DivOpNode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected DivOpNodeGen root;
BaseNode_(DivOpNodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (DivOpNodeGen) root;
}
@Override
protected final Node[] getSuppliedChildren() {
return new Node[] {root.a_, root.b_};
}
@Override
public final Object acceptAndExecute(Frame frameValue, Object aValue, Object bValue) {
return this.execute_((VirtualFrame) frameValue, aValue, bValue);
}
public abstract Object execute_(VirtualFrame frameValue, Object aValue, Object bValue);
public Object execute(VirtualFrame frameValue) {
Object aValue_ = root.a_.execute(frameValue);
Object bValue_ = root.b_.execute(frameValue);
return execute_(frameValue, aValue_, bValue_);
}
public void executeVoid(VirtualFrame frameValue) {
execute(frameValue);
return;
}
@Override
protected final SpecializationNode createNext(Frame frameValue, Object aValue, Object bValue) {
if (aValue instanceof DynamicObject && bValue instanceof DynamicObject) {
DynamicObject aValue_ = (DynamicObject) aValue;
DynamicObject bValue_ = (DynamicObject) bValue;
if ((BigDecimalCoreMethodNode.isNormal(aValue_)) && (BigDecimalCoreMethodNode.isNormalRubyBigDecimal(bValue_))) {
return DivNode_.create(root);
}
if ((BigDecimalCoreMethodNode.isNormal(aValue_)) && (BigDecimalCoreMethodNode.isSpecialRubyBigDecimal(bValue_))) {
return DivNormalSpecialNode_.create(root);
}
if ((!(BigDecimalCoreMethodNode.isNormal(aValue_))) && (BigDecimalCoreMethodNode.isNormalRubyBigDecimal(bValue_))) {
return DivSpecialNormalNode_.create(root);
}
if ((!(BigDecimalCoreMethodNode.isNormal(aValue_))) && (BigDecimalCoreMethodNode.isSpecialRubyBigDecimal(bValue_))) {
return DivSpecialSpecialNode_.create(root);
}
}
return null;
}
@Override
protected final SpecializationNode createPolymorphic() {
return PolymorphicNode_.create(root);
}
protected final BaseNode_ getNext() {
return (BaseNode_) this.next;
}
}
@GeneratedBy(DivOpNode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(DivOpNodeGen root) {
super(root, 2147483647);
}
@Override
public Object execute_(VirtualFrame frameValue, Object aValue, Object bValue) {
return uninitialized(frameValue, aValue, bValue);
}
static BaseNode_ create(DivOpNodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(DivOpNode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(DivOpNodeGen root) {
super(root, 0);
}
@Override
public SpecializationNode merge(SpecializationNode newNode, Frame frameValue, Object aValue, Object bValue) {
return polymorphicMerge(newNode, super.merge(newNode, frameValue, aValue, bValue));
}
@Override
public Object execute_(VirtualFrame frameValue, Object aValue, Object bValue) {
return getNext().execute_(frameValue, aValue, bValue);
}
static BaseNode_ create(DivOpNodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "div(VirtualFrame, DynamicObject, DynamicObject)", value = DivOpNode.class)
private static final class DivNode_ extends BaseNode_ {
DivNode_(DivOpNodeGen root) {
super(root, 1);
}
@Override
public Object execute_(VirtualFrame frameValue, Object aValue, Object bValue) {
if (aValue instanceof DynamicObject && bValue instanceof DynamicObject) {
DynamicObject aValue_ = (DynamicObject) aValue;
DynamicObject bValue_ = (DynamicObject) bValue;
if ((BigDecimalCoreMethodNode.isNormal(aValue_)) && (BigDecimalCoreMethodNode.isNormalRubyBigDecimal(bValue_))) {
return root.div(frameValue, aValue_, bValue_);
}
}
return getNext().execute_(frameValue, aValue, bValue);
}
static BaseNode_ create(DivOpNodeGen root) {
return new DivNode_(root);
}
}
@GeneratedBy(methodName = "divNormalSpecial(VirtualFrame, DynamicObject, DynamicObject)", value = DivOpNode.class)
private static final class DivNormalSpecialNode_ extends BaseNode_ {
DivNormalSpecialNode_(DivOpNodeGen root) {
super(root, 2);
}
@Override
public Object execute_(VirtualFrame frameValue, Object aValue, Object bValue) {
if (aValue instanceof DynamicObject && bValue instanceof DynamicObject) {
DynamicObject aValue_ = (DynamicObject) aValue;
DynamicObject bValue_ = (DynamicObject) bValue;
if ((BigDecimalCoreMethodNode.isNormal(aValue_)) && (BigDecimalCoreMethodNode.isSpecialRubyBigDecimal(bValue_))) {
return root.divNormalSpecial(frameValue, aValue_, bValue_);
}
}
return getNext().execute_(frameValue, aValue, bValue);
}
static BaseNode_ create(DivOpNodeGen root) {
return new DivNormalSpecialNode_(root);
}
}
@GeneratedBy(methodName = "divSpecialNormal(VirtualFrame, DynamicObject, DynamicObject)", value = DivOpNode.class)
private static final class DivSpecialNormalNode_ extends BaseNode_ {
DivSpecialNormalNode_(DivOpNodeGen root) {
super(root, 3);
}
@Override
public Object execute_(VirtualFrame frameValue, Object aValue, Object bValue) {
if (aValue instanceof DynamicObject && bValue instanceof DynamicObject) {
DynamicObject aValue_ = (DynamicObject) aValue;
DynamicObject bValue_ = (DynamicObject) bValue;
if ((!(BigDecimalCoreMethodNode.isNormal(aValue_))) && (BigDecimalCoreMethodNode.isNormalRubyBigDecimal(bValue_))) {
return root.divSpecialNormal(frameValue, aValue_, bValue_);
}
}
return getNext().execute_(frameValue, aValue, bValue);
}
static BaseNode_ create(DivOpNodeGen root) {
return new DivSpecialNormalNode_(root);
}
}
@GeneratedBy(methodName = "divSpecialSpecial(VirtualFrame, DynamicObject, DynamicObject)", value = DivOpNode.class)
private static final class DivSpecialSpecialNode_ extends BaseNode_ {
DivSpecialSpecialNode_(DivOpNodeGen root) {
super(root, 4);
}
@Override
public Object execute_(VirtualFrame frameValue, Object aValue, Object bValue) {
if (aValue instanceof DynamicObject && bValue instanceof DynamicObject) {
DynamicObject aValue_ = (DynamicObject) aValue;
DynamicObject bValue_ = (DynamicObject) bValue;
if ((!(BigDecimalCoreMethodNode.isNormal(aValue_))) && (BigDecimalCoreMethodNode.isSpecialRubyBigDecimal(bValue_))) {
return root.divSpecialSpecial(frameValue, aValue_, bValue_);
}
}
return getNext().execute_(frameValue, aValue, bValue);
}
static BaseNode_ create(DivOpNodeGen root) {
return new DivSpecialSpecialNode_(root);
}
}
}
}
@GeneratedBy(DivNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class DivNodeFactory implements NodeFactory {
private static DivNodeFactory divNodeFactoryInstance;
private DivNodeFactory() {
}
@Override
public Class getNodeClass() {
return DivNode.class;
}
@Override
public List getExecutionSignature() {
return Arrays.asList(RubyNode.class, RubyNode.class, RubyNode.class);
}
@Override
public List getNodeSignatures() {
return Arrays.asList(Arrays.asList(RubyNode.class, RubyNode.class, RubyNode.class));
}
@Override
public DivNode createNode(Object... arguments) {
if (arguments.length == 3 && (arguments[0] == null || arguments[0] instanceof RubyNode) && (arguments[1] == null || arguments[1] instanceof RubyNode) && (arguments[2] == null || arguments[2] instanceof RubyNode)) {
return create((RubyNode) arguments[0], (RubyNode) arguments[1], (RubyNode) arguments[2]);
} else {
throw new IllegalArgumentException("Invalid create signature.");
}
}
public static NodeFactory getInstance() {
if (divNodeFactoryInstance == null) {
divNodeFactoryInstance = new DivNodeFactory();
}
return divNodeFactoryInstance;
}
public static DivNode create(RubyNode a, RubyNode b, RubyNode precision) {
return new DivNodeGen(a, b, precision);
}
@GeneratedBy(DivNode.class)
public static final class DivNodeGen extends DivNode implements SpecializedNode {
@Child private RubyNode a_;
@Child private RubyNode b_;
@Child private RubyNode precision_;
@CompilationFinal private Class precisionType_;
@Child private BaseNode_ specialization_;
private DivNodeGen(RubyNode a, RubyNode b, RubyNode precision) {
this.a_ = a;
this.b_ = castB(b);
this.precision_ = precision;
this.specialization_ = UninitializedNode_.create(this);
}
@Override
public NodeCost getCost() {
return specialization_.getNodeCost();
}
@Override
public Object execute(VirtualFrame frameValue) {
return specialization_.execute(frameValue);
}
@Override
public void executeVoid(VirtualFrame frameValue) {
specialization_.executeVoid(frameValue);
return;
}
@Override
public SpecializationNode getSpecializationNode() {
return specialization_;
}
@Override
public Node deepCopy() {
return SpecializationNode.updateRoot(super.deepCopy());
}
@GeneratedBy(DivNode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected DivNodeGen root;
BaseNode_(DivNodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (DivNodeGen) root;
}
@Override
protected final Node[] getSuppliedChildren() {
return new Node[] {root.a_, root.b_, root.precision_};
}
@Override
public final Object acceptAndExecute(Frame frameValue, Object aValue, Object bValue, Object precisionValue) {
return this.execute_((VirtualFrame) frameValue, aValue, bValue, precisionValue);
}
public abstract Object execute_(VirtualFrame frameValue, Object aValue, Object bValue, Object precisionValue);
public Object execute(VirtualFrame frameValue) {
Object aValue_ = root.a_.execute(frameValue);
Object bValue_ = root.b_.execute(frameValue);
Object precisionValue_ = executePrecision_(frameValue);
return execute_(frameValue, aValue_, bValue_, precisionValue_);
}
public void executeVoid(VirtualFrame frameValue) {
execute(frameValue);
return;
}
@Override
protected final SpecializationNode createNext(Frame frameValue, Object aValue, Object bValue, Object precisionValue) {
if (aValue instanceof DynamicObject && bValue instanceof DynamicObject) {
DynamicObject aValue_ = (DynamicObject) aValue;
DynamicObject bValue_ = (DynamicObject) bValue;
if (precisionValue instanceof NotProvided) {
if ((BigDecimalCoreMethodNode.isNormal(aValue_)) && (BigDecimalCoreMethodNode.isNormalRubyBigDecimal(bValue_))) {
ConditionProfile bZeroProfile1 = (ConditionProfile.createBinaryProfile());
CallDispatchHeadNode floorNode1 = (CallDispatchHeadNode.createMethodCall());
return Div0Node_.create(root, bZeroProfile1, floorNode1);
}
}
if (RubyTypesGen.isImplicitInteger(precisionValue)) {
if ((BigDecimalCoreMethodNode.isNormal(aValue_)) && (BigDecimalCoreMethodNode.isNormalRubyBigDecimal(bValue_))) {
ConditionProfile zeroPrecisionProfile2 = (ConditionProfile.createBinaryProfile());
return Div1Node_.create(root, precisionValue, zeroPrecisionProfile2);
}
}
if (precisionValue instanceof NotProvided) {
if ((BigDecimalCoreMethodNode.isNormal(aValue_)) && (BigDecimalCoreMethodNode.isSpecialRubyBigDecimal(bValue_))) {
ConditionProfile negativeZeroProfile3 = (ConditionProfile.createBinaryProfile());
ConditionProfile nanProfile3 = (ConditionProfile.createBinaryProfile());
return DivNormalSpecial0Node_.create(root, negativeZeroProfile3, nanProfile3);
}
}
if (RubyTypesGen.isImplicitInteger(precisionValue)) {
if ((BigDecimalCoreMethodNode.isNormal(aValue_)) && (BigDecimalCoreMethodNode.isSpecialRubyBigDecimal(bValue_))) {
return DivNormalSpecial1Node_.create(root, precisionValue);
}
}
if (precisionValue instanceof NotProvided) {
if ((!(BigDecimalCoreMethodNode.isNormal(aValue_))) && (BigDecimalCoreMethodNode.isNormalRubyBigDecimal(bValue_))) {
ConditionProfile zeroDivisionProfile5 = (ConditionProfile.createBinaryProfile());
ConditionProfile nanProfile5 = (ConditionProfile.createBinaryProfile());
ConditionProfile infinityProfile5 = (ConditionProfile.createBinaryProfile());
return DivSpecialNormal0Node_.create(root, zeroDivisionProfile5, nanProfile5, infinityProfile5);
}
}
if (RubyTypesGen.isImplicitInteger(precisionValue)) {
if ((!(BigDecimalCoreMethodNode.isNormal(aValue_))) && (BigDecimalCoreMethodNode.isNormalRubyBigDecimal(bValue_))) {
return DivSpecialNormal1Node_.create(root, precisionValue);
}
}
if (precisionValue instanceof NotProvided) {
if ((!(BigDecimalCoreMethodNode.isNormal(aValue_))) && (BigDecimalCoreMethodNode.isSpecialRubyBigDecimal(bValue_))) {
ConditionProfile negZeroProfile7 = (ConditionProfile.createBinaryProfile());
ConditionProfile nanProfile7 = (ConditionProfile.createBinaryProfile());
return DivSpecialSpecial0Node_.create(root, negZeroProfile7, nanProfile7);
}
}
if (RubyTypesGen.isImplicitInteger(precisionValue)) {
if ((!(BigDecimalCoreMethodNode.isNormal(aValue_))) && (BigDecimalCoreMethodNode.isSpecialRubyBigDecimal(bValue_))) {
return DivSpecialSpecial1Node_.create(root, precisionValue);
}
}
}
return null;
}
@Override
protected final SpecializationNode createPolymorphic() {
return PolymorphicNode_.create(root);
}
protected final BaseNode_ getNext() {
return (BaseNode_) this.next;
}
protected final Object executePrecision_(Frame frameValue) {
Class precisionType_ = root.precisionType_;
try {
if (precisionType_ == int.class) {
return root.precision_.executeInteger((VirtualFrame) frameValue);
} else if (precisionType_ == null) {
CompilerDirectives.transferToInterpreterAndInvalidate();
Class _type = Object.class;
try {
Object _value = root.precision_.execute((VirtualFrame) frameValue);
if (_value instanceof Integer) {
_type = int.class;
} else {
_type = Object.class;
}
return _value;
} finally {
root.precisionType_ = _type;
}
} else {
return root.precision_.execute((VirtualFrame) frameValue);
}
} catch (UnexpectedResultException ex) {
root.precisionType_ = Object.class;
return ex.getResult();
}
}
}
@GeneratedBy(DivNode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(DivNodeGen root) {
super(root, 2147483647);
}
@Override
public Object execute_(VirtualFrame frameValue, Object aValue, Object bValue, Object precisionValue) {
return uninitialized(frameValue, aValue, bValue, precisionValue);
}
static BaseNode_ create(DivNodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(DivNode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(DivNodeGen root) {
super(root, 0);
}
@Override
public SpecializationNode merge(SpecializationNode newNode, Frame frameValue, Object aValue, Object bValue, Object precisionValue) {
return polymorphicMerge(newNode, super.merge(newNode, frameValue, aValue, bValue, precisionValue));
}
@Override
public Object execute_(VirtualFrame frameValue, Object aValue, Object bValue, Object precisionValue) {
return getNext().execute_(frameValue, aValue, bValue, precisionValue);
}
static BaseNode_ create(DivNodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "div(VirtualFrame, DynamicObject, DynamicObject, NotProvided, ConditionProfile, CallDispatchHeadNode)", value = DivNode.class)
private static final class Div0Node_ extends BaseNode_ {
private final ConditionProfile bZeroProfile;
@Child private CallDispatchHeadNode floorNode;
Div0Node_(DivNodeGen root, ConditionProfile bZeroProfile, CallDispatchHeadNode floorNode) {
super(root, 1);
this.bZeroProfile = bZeroProfile;
this.floorNode = floorNode;
}
@Override
public Object execute_(VirtualFrame frameValue, Object aValue, Object bValue, Object precisionValue) {
if (aValue instanceof DynamicObject && bValue instanceof DynamicObject && precisionValue instanceof NotProvided) {
DynamicObject aValue_ = (DynamicObject) aValue;
DynamicObject bValue_ = (DynamicObject) bValue;
NotProvided precisionValue_ = (NotProvided) precisionValue;
if ((BigDecimalCoreMethodNode.isNormal(aValue_)) && (BigDecimalCoreMethodNode.isNormalRubyBigDecimal(bValue_))) {
return root.div(frameValue, aValue_, bValue_, precisionValue_, this.bZeroProfile, this.floorNode);
}
}
return getNext().execute_(frameValue, aValue, bValue, precisionValue);
}
static BaseNode_ create(DivNodeGen root, ConditionProfile bZeroProfile, CallDispatchHeadNode floorNode) {
return new Div0Node_(root, bZeroProfile, floorNode);
}
}
@GeneratedBy(methodName = "div(VirtualFrame, DynamicObject, DynamicObject, int, ConditionProfile)", value = DivNode.class)
private static final class Div1Node_ extends BaseNode_ {
private final ConditionProfile zeroPrecisionProfile;
private final Class precisionImplicitType;
Div1Node_(DivNodeGen root, Object precisionValue, ConditionProfile zeroPrecisionProfile) {
super(root, 2);
this.precisionImplicitType = RubyTypesGen.getImplicitIntegerClass(precisionValue);
this.zeroPrecisionProfile = zeroPrecisionProfile;
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.precisionImplicitType == ((Div1Node_) other).precisionImplicitType;
}
@Override
public Object execute(VirtualFrame frameValue) {
DynamicObject aValue_;
try {
aValue_ = root.a_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object bValue = root.b_.execute(frameValue);
Object precisionValue = executePrecision_(frameValue);
return getNext().execute_(frameValue, ex.getResult(), bValue, precisionValue);
}
DynamicObject bValue_;
try {
bValue_ = root.b_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object precisionValue = executePrecision_(frameValue);
return getNext().execute_(frameValue, aValue_, ex.getResult(), precisionValue);
}
int precisionValue_;
try {
if (precisionImplicitType == int.class) {
precisionValue_ = root.precision_.executeInteger(frameValue);
} else {
Object precisionValue__ = executePrecision_(frameValue);
precisionValue_ = RubyTypesGen.expectImplicitInteger(precisionValue__, precisionImplicitType);
}
} catch (UnexpectedResultException ex) {
return getNext().execute_(frameValue, aValue_, bValue_, ex.getResult());
}
if ((BigDecimalCoreMethodNode.isNormal(aValue_)) && (BigDecimalCoreMethodNode.isNormalRubyBigDecimal(bValue_))) {
return root.div(frameValue, aValue_, bValue_, precisionValue_, this.zeroPrecisionProfile);
}
return getNext().execute_(frameValue, aValue_, bValue_, precisionValue_);
}
@Override
public Object execute_(VirtualFrame frameValue, Object aValue, Object bValue, Object precisionValue) {
if (aValue instanceof DynamicObject && bValue instanceof DynamicObject && RubyTypesGen.isImplicitInteger(precisionValue, precisionImplicitType)) {
DynamicObject aValue_ = (DynamicObject) aValue;
DynamicObject bValue_ = (DynamicObject) bValue;
int precisionValue_ = RubyTypesGen.asImplicitInteger(precisionValue, precisionImplicitType);
if ((BigDecimalCoreMethodNode.isNormal(aValue_)) && (BigDecimalCoreMethodNode.isNormalRubyBigDecimal(bValue_))) {
return root.div(frameValue, aValue_, bValue_, precisionValue_, this.zeroPrecisionProfile);
}
}
return getNext().execute_(frameValue, aValue, bValue, precisionValue);
}
static BaseNode_ create(DivNodeGen root, Object precisionValue, ConditionProfile zeroPrecisionProfile) {
return new Div1Node_(root, precisionValue, zeroPrecisionProfile);
}
}
@GeneratedBy(methodName = "divNormalSpecial(VirtualFrame, DynamicObject, DynamicObject, NotProvided, ConditionProfile, ConditionProfile)", value = DivNode.class)
private static final class DivNormalSpecial0Node_ extends BaseNode_ {
private final ConditionProfile negativeZeroProfile;
private final ConditionProfile nanProfile;
DivNormalSpecial0Node_(DivNodeGen root, ConditionProfile negativeZeroProfile, ConditionProfile nanProfile) {
super(root, 3);
this.negativeZeroProfile = negativeZeroProfile;
this.nanProfile = nanProfile;
}
@Override
public Object execute_(VirtualFrame frameValue, Object aValue, Object bValue, Object precisionValue) {
if (aValue instanceof DynamicObject && bValue instanceof DynamicObject && precisionValue instanceof NotProvided) {
DynamicObject aValue_ = (DynamicObject) aValue;
DynamicObject bValue_ = (DynamicObject) bValue;
NotProvided precisionValue_ = (NotProvided) precisionValue;
if ((BigDecimalCoreMethodNode.isNormal(aValue_)) && (BigDecimalCoreMethodNode.isSpecialRubyBigDecimal(bValue_))) {
return root.divNormalSpecial(frameValue, aValue_, bValue_, precisionValue_, this.negativeZeroProfile, this.nanProfile);
}
}
return getNext().execute_(frameValue, aValue, bValue, precisionValue);
}
static BaseNode_ create(DivNodeGen root, ConditionProfile negativeZeroProfile, ConditionProfile nanProfile) {
return new DivNormalSpecial0Node_(root, negativeZeroProfile, nanProfile);
}
}
@GeneratedBy(methodName = "divNormalSpecial(VirtualFrame, DynamicObject, DynamicObject, int)", value = DivNode.class)
private static final class DivNormalSpecial1Node_ extends BaseNode_ {
private final Class precisionImplicitType;
DivNormalSpecial1Node_(DivNodeGen root, Object precisionValue) {
super(root, 4);
this.precisionImplicitType = RubyTypesGen.getImplicitIntegerClass(precisionValue);
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.precisionImplicitType == ((DivNormalSpecial1Node_) other).precisionImplicitType;
}
@Override
public Object execute(VirtualFrame frameValue) {
DynamicObject aValue_;
try {
aValue_ = root.a_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object bValue = root.b_.execute(frameValue);
Object precisionValue = executePrecision_(frameValue);
return getNext().execute_(frameValue, ex.getResult(), bValue, precisionValue);
}
DynamicObject bValue_;
try {
bValue_ = root.b_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object precisionValue = executePrecision_(frameValue);
return getNext().execute_(frameValue, aValue_, ex.getResult(), precisionValue);
}
int precisionValue_;
try {
if (precisionImplicitType == int.class) {
precisionValue_ = root.precision_.executeInteger(frameValue);
} else {
Object precisionValue__ = executePrecision_(frameValue);
precisionValue_ = RubyTypesGen.expectImplicitInteger(precisionValue__, precisionImplicitType);
}
} catch (UnexpectedResultException ex) {
return getNext().execute_(frameValue, aValue_, bValue_, ex.getResult());
}
if ((BigDecimalCoreMethodNode.isNormal(aValue_)) && (BigDecimalCoreMethodNode.isSpecialRubyBigDecimal(bValue_))) {
return root.divNormalSpecial(frameValue, aValue_, bValue_, precisionValue_);
}
return getNext().execute_(frameValue, aValue_, bValue_, precisionValue_);
}
@Override
public Object execute_(VirtualFrame frameValue, Object aValue, Object bValue, Object precisionValue) {
if (aValue instanceof DynamicObject && bValue instanceof DynamicObject && RubyTypesGen.isImplicitInteger(precisionValue, precisionImplicitType)) {
DynamicObject aValue_ = (DynamicObject) aValue;
DynamicObject bValue_ = (DynamicObject) bValue;
int precisionValue_ = RubyTypesGen.asImplicitInteger(precisionValue, precisionImplicitType);
if ((BigDecimalCoreMethodNode.isNormal(aValue_)) && (BigDecimalCoreMethodNode.isSpecialRubyBigDecimal(bValue_))) {
return root.divNormalSpecial(frameValue, aValue_, bValue_, precisionValue_);
}
}
return getNext().execute_(frameValue, aValue, bValue, precisionValue);
}
static BaseNode_ create(DivNodeGen root, Object precisionValue) {
return new DivNormalSpecial1Node_(root, precisionValue);
}
}
@GeneratedBy(methodName = "divSpecialNormal(VirtualFrame, DynamicObject, DynamicObject, NotProvided, ConditionProfile, ConditionProfile, ConditionProfile)", value = DivNode.class)
private static final class DivSpecialNormal0Node_ extends BaseNode_ {
private final ConditionProfile zeroDivisionProfile;
private final ConditionProfile nanProfile;
private final ConditionProfile infinityProfile;
DivSpecialNormal0Node_(DivNodeGen root, ConditionProfile zeroDivisionProfile, ConditionProfile nanProfile, ConditionProfile infinityProfile) {
super(root, 5);
this.zeroDivisionProfile = zeroDivisionProfile;
this.nanProfile = nanProfile;
this.infinityProfile = infinityProfile;
}
@Override
public Object execute_(VirtualFrame frameValue, Object aValue, Object bValue, Object precisionValue) {
if (aValue instanceof DynamicObject && bValue instanceof DynamicObject && precisionValue instanceof NotProvided) {
DynamicObject aValue_ = (DynamicObject) aValue;
DynamicObject bValue_ = (DynamicObject) bValue;
NotProvided precisionValue_ = (NotProvided) precisionValue;
if ((!(BigDecimalCoreMethodNode.isNormal(aValue_))) && (BigDecimalCoreMethodNode.isNormalRubyBigDecimal(bValue_))) {
return root.divSpecialNormal(frameValue, aValue_, bValue_, precisionValue_, this.zeroDivisionProfile, this.nanProfile, this.infinityProfile);
}
}
return getNext().execute_(frameValue, aValue, bValue, precisionValue);
}
static BaseNode_ create(DivNodeGen root, ConditionProfile zeroDivisionProfile, ConditionProfile nanProfile, ConditionProfile infinityProfile) {
return new DivSpecialNormal0Node_(root, zeroDivisionProfile, nanProfile, infinityProfile);
}
}
@GeneratedBy(methodName = "divSpecialNormal(VirtualFrame, DynamicObject, DynamicObject, int)", value = DivNode.class)
private static final class DivSpecialNormal1Node_ extends BaseNode_ {
private final Class precisionImplicitType;
DivSpecialNormal1Node_(DivNodeGen root, Object precisionValue) {
super(root, 6);
this.precisionImplicitType = RubyTypesGen.getImplicitIntegerClass(precisionValue);
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.precisionImplicitType == ((DivSpecialNormal1Node_) other).precisionImplicitType;
}
@Override
public Object execute(VirtualFrame frameValue) {
DynamicObject aValue_;
try {
aValue_ = root.a_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object bValue = root.b_.execute(frameValue);
Object precisionValue = executePrecision_(frameValue);
return getNext().execute_(frameValue, ex.getResult(), bValue, precisionValue);
}
DynamicObject bValue_;
try {
bValue_ = root.b_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object precisionValue = executePrecision_(frameValue);
return getNext().execute_(frameValue, aValue_, ex.getResult(), precisionValue);
}
int precisionValue_;
try {
if (precisionImplicitType == int.class) {
precisionValue_ = root.precision_.executeInteger(frameValue);
} else {
Object precisionValue__ = executePrecision_(frameValue);
precisionValue_ = RubyTypesGen.expectImplicitInteger(precisionValue__, precisionImplicitType);
}
} catch (UnexpectedResultException ex) {
return getNext().execute_(frameValue, aValue_, bValue_, ex.getResult());
}
if ((!(BigDecimalCoreMethodNode.isNormal(aValue_))) && (BigDecimalCoreMethodNode.isNormalRubyBigDecimal(bValue_))) {
return root.divSpecialNormal(frameValue, aValue_, bValue_, precisionValue_);
}
return getNext().execute_(frameValue, aValue_, bValue_, precisionValue_);
}
@Override
public Object execute_(VirtualFrame frameValue, Object aValue, Object bValue, Object precisionValue) {
if (aValue instanceof DynamicObject && bValue instanceof DynamicObject && RubyTypesGen.isImplicitInteger(precisionValue, precisionImplicitType)) {
DynamicObject aValue_ = (DynamicObject) aValue;
DynamicObject bValue_ = (DynamicObject) bValue;
int precisionValue_ = RubyTypesGen.asImplicitInteger(precisionValue, precisionImplicitType);
if ((!(BigDecimalCoreMethodNode.isNormal(aValue_))) && (BigDecimalCoreMethodNode.isNormalRubyBigDecimal(bValue_))) {
return root.divSpecialNormal(frameValue, aValue_, bValue_, precisionValue_);
}
}
return getNext().execute_(frameValue, aValue, bValue, precisionValue);
}
static BaseNode_ create(DivNodeGen root, Object precisionValue) {
return new DivSpecialNormal1Node_(root, precisionValue);
}
}
@GeneratedBy(methodName = "divSpecialSpecial(VirtualFrame, DynamicObject, DynamicObject, NotProvided, ConditionProfile, ConditionProfile)", value = DivNode.class)
private static final class DivSpecialSpecial0Node_ extends BaseNode_ {
private final ConditionProfile negZeroProfile;
private final ConditionProfile nanProfile;
DivSpecialSpecial0Node_(DivNodeGen root, ConditionProfile negZeroProfile, ConditionProfile nanProfile) {
super(root, 7);
this.negZeroProfile = negZeroProfile;
this.nanProfile = nanProfile;
}
@Override
public Object execute_(VirtualFrame frameValue, Object aValue, Object bValue, Object precisionValue) {
if (aValue instanceof DynamicObject && bValue instanceof DynamicObject && precisionValue instanceof NotProvided) {
DynamicObject aValue_ = (DynamicObject) aValue;
DynamicObject bValue_ = (DynamicObject) bValue;
NotProvided precisionValue_ = (NotProvided) precisionValue;
if ((!(BigDecimalCoreMethodNode.isNormal(aValue_))) && (BigDecimalCoreMethodNode.isSpecialRubyBigDecimal(bValue_))) {
return root.divSpecialSpecial(frameValue, aValue_, bValue_, precisionValue_, this.negZeroProfile, this.nanProfile);
}
}
return getNext().execute_(frameValue, aValue, bValue, precisionValue);
}
static BaseNode_ create(DivNodeGen root, ConditionProfile negZeroProfile, ConditionProfile nanProfile) {
return new DivSpecialSpecial0Node_(root, negZeroProfile, nanProfile);
}
}
@GeneratedBy(methodName = "divSpecialSpecial(VirtualFrame, DynamicObject, DynamicObject, int)", value = DivNode.class)
private static final class DivSpecialSpecial1Node_ extends BaseNode_ {
private final Class precisionImplicitType;
DivSpecialSpecial1Node_(DivNodeGen root, Object precisionValue) {
super(root, 8);
this.precisionImplicitType = RubyTypesGen.getImplicitIntegerClass(precisionValue);
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.precisionImplicitType == ((DivSpecialSpecial1Node_) other).precisionImplicitType;
}
@Override
public Object execute(VirtualFrame frameValue) {
DynamicObject aValue_;
try {
aValue_ = root.a_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object bValue = root.b_.execute(frameValue);
Object precisionValue = executePrecision_(frameValue);
return getNext().execute_(frameValue, ex.getResult(), bValue, precisionValue);
}
DynamicObject bValue_;
try {
bValue_ = root.b_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object precisionValue = executePrecision_(frameValue);
return getNext().execute_(frameValue, aValue_, ex.getResult(), precisionValue);
}
int precisionValue_;
try {
if (precisionImplicitType == int.class) {
precisionValue_ = root.precision_.executeInteger(frameValue);
} else {
Object precisionValue__ = executePrecision_(frameValue);
precisionValue_ = RubyTypesGen.expectImplicitInteger(precisionValue__, precisionImplicitType);
}
} catch (UnexpectedResultException ex) {
return getNext().execute_(frameValue, aValue_, bValue_, ex.getResult());
}
if ((!(BigDecimalCoreMethodNode.isNormal(aValue_))) && (BigDecimalCoreMethodNode.isSpecialRubyBigDecimal(bValue_))) {
return root.divSpecialSpecial(frameValue, aValue_, bValue_, precisionValue_);
}
return getNext().execute_(frameValue, aValue_, bValue_, precisionValue_);
}
@Override
public Object execute_(VirtualFrame frameValue, Object aValue, Object bValue, Object precisionValue) {
if (aValue instanceof DynamicObject && bValue instanceof DynamicObject && RubyTypesGen.isImplicitInteger(precisionValue, precisionImplicitType)) {
DynamicObject aValue_ = (DynamicObject) aValue;
DynamicObject bValue_ = (DynamicObject) bValue;
int precisionValue_ = RubyTypesGen.asImplicitInteger(precisionValue, precisionImplicitType);
if ((!(BigDecimalCoreMethodNode.isNormal(aValue_))) && (BigDecimalCoreMethodNode.isSpecialRubyBigDecimal(bValue_))) {
return root.divSpecialSpecial(frameValue, aValue_, bValue_, precisionValue_);
}
}
return getNext().execute_(frameValue, aValue, bValue, precisionValue);
}
static BaseNode_ create(DivNodeGen root, Object precisionValue) {
return new DivSpecialSpecial1Node_(root, precisionValue);
}
}
}
}
@GeneratedBy(DivModNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class DivModNodeFactory implements NodeFactory {
private static DivModNodeFactory divModNodeFactoryInstance;
private DivModNodeFactory() {
}
@Override
public Class getNodeClass() {
return DivModNode.class;
}
@Override
public List getExecutionSignature() {
return Arrays.asList(RubyNode.class, RubyNode.class);
}
@Override
public List getNodeSignatures() {
return Arrays.asList(Arrays.asList(RubyNode.class, RubyNode.class));
}
@Override
public DivModNode createNode(Object... arguments) {
if (arguments.length == 2 && (arguments[0] == null || arguments[0] instanceof RubyNode) && (arguments[1] == null || arguments[1] instanceof RubyNode)) {
return create((RubyNode) arguments[0], (RubyNode) arguments[1]);
} else {
throw new IllegalArgumentException("Invalid create signature.");
}
}
public static NodeFactory getInstance() {
if (divModNodeFactoryInstance == null) {
divModNodeFactoryInstance = new DivModNodeFactory();
}
return divModNodeFactoryInstance;
}
public static DivModNode create(RubyNode a, RubyNode b) {
return new DivModNodeGen(a, b);
}
@GeneratedBy(DivModNode.class)
public static final class DivModNodeGen extends DivModNode implements SpecializedNode {
@Child private RubyNode a_;
@Child private RubyNode b_;
@Child private BaseNode_ specialization_;
private DivModNodeGen(RubyNode a, RubyNode b) {
this.a_ = a;
this.b_ = castB(b);
this.specialization_ = UninitializedNode_.create(this);
}
@Override
public NodeCost getCost() {
return specialization_.getNodeCost();
}
@Override
public Object execute(VirtualFrame frameValue) {
return specialization_.execute(frameValue);
}
@Override
public void executeVoid(VirtualFrame frameValue) {
specialization_.executeVoid(frameValue);
return;
}
@Override
public SpecializationNode getSpecializationNode() {
return specialization_;
}
@Override
public Node deepCopy() {
return SpecializationNode.updateRoot(super.deepCopy());
}
@GeneratedBy(DivModNode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected DivModNodeGen root;
BaseNode_(DivModNodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (DivModNodeGen) root;
}
@Override
protected final Node[] getSuppliedChildren() {
return new Node[] {root.a_, root.b_};
}
@Override
public final Object acceptAndExecute(Frame frameValue, Object aValue, Object bValue) {
return this.execute_((VirtualFrame) frameValue, aValue, bValue);
}
public abstract Object execute_(VirtualFrame frameValue, Object aValue, Object bValue);
public Object execute(VirtualFrame frameValue) {
Object aValue_ = root.a_.execute(frameValue);
Object bValue_ = root.b_.execute(frameValue);
return execute_(frameValue, aValue_, bValue_);
}
public void executeVoid(VirtualFrame frameValue) {
execute(frameValue);
return;
}
@Override
protected final SpecializationNode createNext(Frame frameValue, Object aValue, Object bValue) {
if (aValue instanceof DynamicObject && bValue instanceof DynamicObject) {
DynamicObject aValue_ = (DynamicObject) aValue;
DynamicObject bValue_ = (DynamicObject) bValue;
if ((BigDecimalCoreMethodNode.isNormal(aValue_)) && (BigDecimalCoreMethodNode.isNormalRubyBigDecimal(bValue_)) && (!(BigDecimalCoreMethodNode.isNormalZero(aValue_))) && (!(BigDecimalCoreMethodNode.isNormalZero(bValue_)))) {
return DivmodNode_.create(root);
}
if ((BigDecimalCoreMethodNode.isNormal(aValue_)) && (BigDecimalCoreMethodNode.isNormalRubyBigDecimal(bValue_)) && (BigDecimalCoreMethodNode.isNormalZero(aValue_)) && (!(BigDecimalCoreMethodNode.isNormalZero(bValue_)))) {
return DivmodZeroDividendNode_.create(root);
}
if ((BigDecimalCoreMethodNode.isNormal(aValue_)) && (BigDecimalCoreMethodNode.isNormalRubyBigDecimal(bValue_)) && (BigDecimalCoreMethodNode.isNormalZero(bValue_))) {
return DivmodZeroDivisorNode_.create(root);
}
if ((RubyGuards.isRubyBigDecimal(bValue_)) && (!(BigDecimalCoreMethodNode.isNormal(aValue_)) || !(BigDecimalCoreMethodNode.isNormal(bValue_)))) {
CallDispatchHeadNode signCall4 = (CallDispatchHeadNode.createMethodCall());
IntegerCastNode signIntegerCast4 = (root.createIntegerCastNode());
ConditionProfile nanProfile4 = (ConditionProfile.createBinaryProfile());
ConditionProfile normalNegProfile4 = (ConditionProfile.createBinaryProfile());
ConditionProfile negNormalProfile4 = (ConditionProfile.createBinaryProfile());
ConditionProfile infinityProfile4 = (ConditionProfile.createBinaryProfile());
return DivmodSpecialNode_.create(root, signCall4, signIntegerCast4, nanProfile4, normalNegProfile4, negNormalProfile4, infinityProfile4);
}
}
return null;
}
@Override
protected final SpecializationNode createPolymorphic() {
return PolymorphicNode_.create(root);
}
protected final BaseNode_ getNext() {
return (BaseNode_) this.next;
}
}
@GeneratedBy(DivModNode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(DivModNodeGen root) {
super(root, 2147483647);
}
@Override
public Object execute_(VirtualFrame frameValue, Object aValue, Object bValue) {
return uninitialized(frameValue, aValue, bValue);
}
static BaseNode_ create(DivModNodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(DivModNode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(DivModNodeGen root) {
super(root, 0);
}
@Override
public SpecializationNode merge(SpecializationNode newNode, Frame frameValue, Object aValue, Object bValue) {
return polymorphicMerge(newNode, super.merge(newNode, frameValue, aValue, bValue));
}
@Override
public Object execute_(VirtualFrame frameValue, Object aValue, Object bValue) {
return getNext().execute_(frameValue, aValue, bValue);
}
static BaseNode_ create(DivModNodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "divmod(VirtualFrame, DynamicObject, DynamicObject)", value = DivModNode.class)
private static final class DivmodNode_ extends BaseNode_ {
DivmodNode_(DivModNodeGen root) {
super(root, 1);
}
@Override
public Object execute_(VirtualFrame frameValue, Object aValue, Object bValue) {
if (aValue instanceof DynamicObject && bValue instanceof DynamicObject) {
DynamicObject aValue_ = (DynamicObject) aValue;
DynamicObject bValue_ = (DynamicObject) bValue;
if ((BigDecimalCoreMethodNode.isNormal(aValue_)) && (BigDecimalCoreMethodNode.isNormalRubyBigDecimal(bValue_)) && (!(BigDecimalCoreMethodNode.isNormalZero(aValue_))) && (!(BigDecimalCoreMethodNode.isNormalZero(bValue_)))) {
return root.divmod(frameValue, aValue_, bValue_);
}
}
return getNext().execute_(frameValue, aValue, bValue);
}
static BaseNode_ create(DivModNodeGen root) {
return new DivmodNode_(root);
}
}
@GeneratedBy(methodName = "divmodZeroDividend(VirtualFrame, DynamicObject, DynamicObject)", value = DivModNode.class)
private static final class DivmodZeroDividendNode_ extends BaseNode_ {
DivmodZeroDividendNode_(DivModNodeGen root) {
super(root, 2);
}
@Override
public Object execute_(VirtualFrame frameValue, Object aValue, Object bValue) {
if (aValue instanceof DynamicObject && bValue instanceof DynamicObject) {
DynamicObject aValue_ = (DynamicObject) aValue;
DynamicObject bValue_ = (DynamicObject) bValue;
if ((BigDecimalCoreMethodNode.isNormal(aValue_)) && (BigDecimalCoreMethodNode.isNormalRubyBigDecimal(bValue_)) && (BigDecimalCoreMethodNode.isNormalZero(aValue_)) && (!(BigDecimalCoreMethodNode.isNormalZero(bValue_)))) {
return root.divmodZeroDividend(frameValue, aValue_, bValue_);
}
}
return getNext().execute_(frameValue, aValue, bValue);
}
static BaseNode_ create(DivModNodeGen root) {
return new DivmodZeroDividendNode_(root);
}
}
@GeneratedBy(methodName = "divmodZeroDivisor(DynamicObject, DynamicObject)", value = DivModNode.class)
private static final class DivmodZeroDivisorNode_ extends BaseNode_ {
DivmodZeroDivisorNode_(DivModNodeGen root) {
super(root, 3);
}
@Override
public Object execute_(VirtualFrame frameValue, Object aValue, Object bValue) {
if (aValue instanceof DynamicObject && bValue instanceof DynamicObject) {
DynamicObject aValue_ = (DynamicObject) aValue;
DynamicObject bValue_ = (DynamicObject) bValue;
if ((BigDecimalCoreMethodNode.isNormal(aValue_)) && (BigDecimalCoreMethodNode.isNormalRubyBigDecimal(bValue_)) && (BigDecimalCoreMethodNode.isNormalZero(bValue_))) {
return root.divmodZeroDivisor(aValue_, bValue_);
}
}
return getNext().execute_(frameValue, aValue, bValue);
}
static BaseNode_ create(DivModNodeGen root) {
return new DivmodZeroDivisorNode_(root);
}
}
@GeneratedBy(methodName = "divmodSpecial(VirtualFrame, DynamicObject, DynamicObject, CallDispatchHeadNode, IntegerCastNode, ConditionProfile, ConditionProfile, ConditionProfile, ConditionProfile)", value = DivModNode.class)
private static final class DivmodSpecialNode_ extends BaseNode_ {
@Child private CallDispatchHeadNode signCall;
@Child private IntegerCastNode signIntegerCast;
private final ConditionProfile nanProfile;
private final ConditionProfile normalNegProfile;
private final ConditionProfile negNormalProfile;
private final ConditionProfile infinityProfile;
DivmodSpecialNode_(DivModNodeGen root, CallDispatchHeadNode signCall, IntegerCastNode signIntegerCast, ConditionProfile nanProfile, ConditionProfile normalNegProfile, ConditionProfile negNormalProfile, ConditionProfile infinityProfile) {
super(root, 4);
this.signCall = signCall;
this.signIntegerCast = signIntegerCast;
this.nanProfile = nanProfile;
this.normalNegProfile = normalNegProfile;
this.negNormalProfile = negNormalProfile;
this.infinityProfile = infinityProfile;
}
@Override
public Object execute_(VirtualFrame frameValue, Object aValue, Object bValue) {
if (aValue instanceof DynamicObject && bValue instanceof DynamicObject) {
DynamicObject aValue_ = (DynamicObject) aValue;
DynamicObject bValue_ = (DynamicObject) bValue;
if ((RubyGuards.isRubyBigDecimal(bValue_)) && (!(BigDecimalCoreMethodNode.isNormal(aValue_)) || !(BigDecimalCoreMethodNode.isNormal(bValue_)))) {
return root.divmodSpecial(frameValue, aValue_, bValue_, this.signCall, this.signIntegerCast, this.nanProfile, this.normalNegProfile, this.negNormalProfile, this.infinityProfile);
}
}
return getNext().execute_(frameValue, aValue, bValue);
}
static BaseNode_ create(DivModNodeGen root, CallDispatchHeadNode signCall, IntegerCastNode signIntegerCast, ConditionProfile nanProfile, ConditionProfile normalNegProfile, ConditionProfile negNormalProfile, ConditionProfile infinityProfile) {
return new DivmodSpecialNode_(root, signCall, signIntegerCast, nanProfile, normalNegProfile, negNormalProfile, infinityProfile);
}
}
}
}
@GeneratedBy(RemainderNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class RemainderNodeFactory implements NodeFactory {
private static RemainderNodeFactory remainderNodeFactoryInstance;
private RemainderNodeFactory() {
}
@Override
public Class getNodeClass() {
return RemainderNode.class;
}
@Override
public List getExecutionSignature() {
return Arrays.asList(RubyNode.class, RubyNode.class);
}
@Override
public List getNodeSignatures() {
return Arrays.asList(Arrays.asList(RubyNode.class, RubyNode.class));
}
@Override
public RemainderNode createNode(Object... arguments) {
if (arguments.length == 2 && (arguments[0] == null || arguments[0] instanceof RubyNode) && (arguments[1] == null || arguments[1] instanceof RubyNode)) {
return create((RubyNode) arguments[0], (RubyNode) arguments[1]);
} else {
throw new IllegalArgumentException("Invalid create signature.");
}
}
public static NodeFactory getInstance() {
if (remainderNodeFactoryInstance == null) {
remainderNodeFactoryInstance = new RemainderNodeFactory();
}
return remainderNodeFactoryInstance;
}
public static RemainderNode create(RubyNode a, RubyNode b) {
return new RemainderNodeGen(a, b);
}
@GeneratedBy(RemainderNode.class)
public static final class RemainderNodeGen extends RemainderNode implements SpecializedNode {
@Child private RubyNode a_;
@Child private RubyNode b_;
@Child private BaseNode_ specialization_;
private RemainderNodeGen(RubyNode a, RubyNode b) {
this.a_ = a;
this.b_ = castB(b);
this.specialization_ = UninitializedNode_.create(this);
}
@Override
public NodeCost getCost() {
return specialization_.getNodeCost();
}
@Override
public Object execute(VirtualFrame frameValue) {
return specialization_.execute(frameValue);
}
@Override
public void executeVoid(VirtualFrame frameValue) {
specialization_.executeVoid(frameValue);
return;
}
@Override
public SpecializationNode getSpecializationNode() {
return specialization_;
}
@Override
public Node deepCopy() {
return SpecializationNode.updateRoot(super.deepCopy());
}
@GeneratedBy(RemainderNode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected RemainderNodeGen root;
BaseNode_(RemainderNodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (RemainderNodeGen) root;
}
@Override
protected final Node[] getSuppliedChildren() {
return new Node[] {root.a_, root.b_};
}
@Override
public final Object acceptAndExecute(Frame frameValue, Object aValue, Object bValue) {
return this.execute_((VirtualFrame) frameValue, aValue, bValue);
}
public abstract Object execute_(VirtualFrame frameValue, Object aValue, Object bValue);
public Object execute(VirtualFrame frameValue) {
Object aValue_ = root.a_.execute(frameValue);
Object bValue_ = root.b_.execute(frameValue);
return execute_(frameValue, aValue_, bValue_);
}
public void executeVoid(VirtualFrame frameValue) {
execute(frameValue);
return;
}
@Override
protected final SpecializationNode createNext(Frame frameValue, Object aValue, Object bValue) {
if (aValue instanceof DynamicObject && bValue instanceof DynamicObject) {
DynamicObject aValue_ = (DynamicObject) aValue;
DynamicObject bValue_ = (DynamicObject) bValue;
if ((BigDecimalCoreMethodNode.isNormal(aValue_)) && (BigDecimalCoreMethodNode.isNormalRubyBigDecimal(bValue_)) && (!(BigDecimalCoreMethodNode.isNormalZero(bValue_)))) {
return RemainderNode_.create(root);
}
if ((BigDecimalCoreMethodNode.isNormal(aValue_)) && (BigDecimalCoreMethodNode.isNormalRubyBigDecimal(bValue_)) && (BigDecimalCoreMethodNode.isNormalZero(bValue_))) {
return RemainderZeroNode_.create(root);
}
if ((RubyGuards.isRubyBigDecimal(bValue_)) && (!(BigDecimalCoreMethodNode.isNormal(aValue_)) || !(BigDecimalCoreMethodNode.isNormal(bValue_)))) {
ConditionProfile zeroProfile3 = (ConditionProfile.createBinaryProfile());
return RemainderSpecialNode_.create(root, zeroProfile3);
}
}
return null;
}
@Override
protected final SpecializationNode createPolymorphic() {
return PolymorphicNode_.create(root);
}
protected final BaseNode_ getNext() {
return (BaseNode_) this.next;
}
}
@GeneratedBy(RemainderNode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(RemainderNodeGen root) {
super(root, 2147483647);
}
@Override
public Object execute_(VirtualFrame frameValue, Object aValue, Object bValue) {
return uninitialized(frameValue, aValue, bValue);
}
static BaseNode_ create(RemainderNodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(RemainderNode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(RemainderNodeGen root) {
super(root, 0);
}
@Override
public SpecializationNode merge(SpecializationNode newNode, Frame frameValue, Object aValue, Object bValue) {
return polymorphicMerge(newNode, super.merge(newNode, frameValue, aValue, bValue));
}
@Override
public Object execute_(VirtualFrame frameValue, Object aValue, Object bValue) {
return getNext().execute_(frameValue, aValue, bValue);
}
static BaseNode_ create(RemainderNodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "remainder(VirtualFrame, DynamicObject, DynamicObject)", value = RemainderNode.class)
private static final class RemainderNode_ extends BaseNode_ {
RemainderNode_(RemainderNodeGen root) {
super(root, 1);
}
@Override
public Object execute_(VirtualFrame frameValue, Object aValue, Object bValue) {
if (aValue instanceof DynamicObject && bValue instanceof DynamicObject) {
DynamicObject aValue_ = (DynamicObject) aValue;
DynamicObject bValue_ = (DynamicObject) bValue;
if ((BigDecimalCoreMethodNode.isNormal(aValue_)) && (BigDecimalCoreMethodNode.isNormalRubyBigDecimal(bValue_)) && (!(BigDecimalCoreMethodNode.isNormalZero(bValue_)))) {
return root.remainder(frameValue, aValue_, bValue_);
}
}
return getNext().execute_(frameValue, aValue, bValue);
}
static BaseNode_ create(RemainderNodeGen root) {
return new RemainderNode_(root);
}
}
@GeneratedBy(methodName = "remainderZero(VirtualFrame, DynamicObject, DynamicObject)", value = RemainderNode.class)
private static final class RemainderZeroNode_ extends BaseNode_ {
RemainderZeroNode_(RemainderNodeGen root) {
super(root, 2);
}
@Override
public Object execute_(VirtualFrame frameValue, Object aValue, Object bValue) {
if (aValue instanceof DynamicObject && bValue instanceof DynamicObject) {
DynamicObject aValue_ = (DynamicObject) aValue;
DynamicObject bValue_ = (DynamicObject) bValue;
if ((BigDecimalCoreMethodNode.isNormal(aValue_)) && (BigDecimalCoreMethodNode.isNormalRubyBigDecimal(bValue_)) && (BigDecimalCoreMethodNode.isNormalZero(bValue_))) {
return root.remainderZero(frameValue, aValue_, bValue_);
}
}
return getNext().execute_(frameValue, aValue, bValue);
}
static BaseNode_ create(RemainderNodeGen root) {
return new RemainderZeroNode_(root);
}
}
@GeneratedBy(methodName = "remainderSpecial(VirtualFrame, DynamicObject, DynamicObject, ConditionProfile)", value = RemainderNode.class)
private static final class RemainderSpecialNode_ extends BaseNode_ {
private final ConditionProfile zeroProfile;
RemainderSpecialNode_(RemainderNodeGen root, ConditionProfile zeroProfile) {
super(root, 3);
this.zeroProfile = zeroProfile;
}
@Override
public Object execute_(VirtualFrame frameValue, Object aValue, Object bValue) {
if (aValue instanceof DynamicObject && bValue instanceof DynamicObject) {
DynamicObject aValue_ = (DynamicObject) aValue;
DynamicObject bValue_ = (DynamicObject) bValue;
if ((RubyGuards.isRubyBigDecimal(bValue_)) && (!(BigDecimalCoreMethodNode.isNormal(aValue_)) || !(BigDecimalCoreMethodNode.isNormal(bValue_)))) {
return root.remainderSpecial(frameValue, aValue_, bValue_, this.zeroProfile);
}
}
return getNext().execute_(frameValue, aValue, bValue);
}
static BaseNode_ create(RemainderNodeGen root, ConditionProfile zeroProfile) {
return new RemainderSpecialNode_(root, zeroProfile);
}
}
}
}
@GeneratedBy(ModuloNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class ModuloNodeFactory implements NodeFactory {
private static ModuloNodeFactory moduloNodeFactoryInstance;
private ModuloNodeFactory() {
}
@Override
public Class getNodeClass() {
return ModuloNode.class;
}
@Override
public List getExecutionSignature() {
return Arrays.asList(RubyNode.class, RubyNode.class);
}
@Override
public List getNodeSignatures() {
return Arrays.asList(Arrays.asList(RubyNode.class, RubyNode.class));
}
@Override
public ModuloNode createNode(Object... arguments) {
if (arguments.length == 2 && (arguments[0] == null || arguments[0] instanceof RubyNode) && (arguments[1] == null || arguments[1] instanceof RubyNode)) {
return create((RubyNode) arguments[0], (RubyNode) arguments[1]);
} else {
throw new IllegalArgumentException("Invalid create signature.");
}
}
public static NodeFactory getInstance() {
if (moduloNodeFactoryInstance == null) {
moduloNodeFactoryInstance = new ModuloNodeFactory();
}
return moduloNodeFactoryInstance;
}
public static ModuloNode create(RubyNode a, RubyNode b) {
return new ModuloNodeGen(a, b);
}
@GeneratedBy(ModuloNode.class)
public static final class ModuloNodeGen extends ModuloNode implements SpecializedNode {
@Child private RubyNode a_;
@Child private RubyNode b_;
@Child private BaseNode_ specialization_;
private ModuloNodeGen(RubyNode a, RubyNode b) {
this.a_ = a;
this.b_ = castB(b);
this.specialization_ = UninitializedNode_.create(this);
}
@Override
public NodeCost getCost() {
return specialization_.getNodeCost();
}
@Override
public Object execute(VirtualFrame frameValue) {
return specialization_.execute(frameValue);
}
@Override
public void executeVoid(VirtualFrame frameValue) {
specialization_.executeVoid(frameValue);
return;
}
@Override
public SpecializationNode getSpecializationNode() {
return specialization_;
}
@Override
public Node deepCopy() {
return SpecializationNode.updateRoot(super.deepCopy());
}
@GeneratedBy(ModuloNode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected ModuloNodeGen root;
BaseNode_(ModuloNodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (ModuloNodeGen) root;
}
@Override
protected final Node[] getSuppliedChildren() {
return new Node[] {root.a_, root.b_};
}
@Override
public final Object acceptAndExecute(Frame frameValue, Object aValue, Object bValue) {
return this.execute_((VirtualFrame) frameValue, aValue, bValue);
}
public abstract Object execute_(VirtualFrame frameValue, Object aValue, Object bValue);
public Object execute(VirtualFrame frameValue) {
Object aValue_ = root.a_.execute(frameValue);
Object bValue_ = root.b_.execute(frameValue);
return execute_(frameValue, aValue_, bValue_);
}
public void executeVoid(VirtualFrame frameValue) {
execute(frameValue);
return;
}
@Override
protected final SpecializationNode createNext(Frame frameValue, Object aValue, Object bValue) {
if (aValue instanceof DynamicObject && bValue instanceof DynamicObject) {
DynamicObject aValue_ = (DynamicObject) aValue;
DynamicObject bValue_ = (DynamicObject) bValue;
if ((BigDecimalCoreMethodNode.isNormal(aValue_)) && (BigDecimalCoreMethodNode.isNormalRubyBigDecimal(bValue_)) && (!(BigDecimalCoreMethodNode.isNormalZero(bValue_)))) {
return ModuloNode_.create(root);
}
if ((BigDecimalCoreMethodNode.isNormal(aValue_)) && (BigDecimalCoreMethodNode.isNormalRubyBigDecimal(bValue_)) && (BigDecimalCoreMethodNode.isNormalZero(bValue_))) {
return ModuloZeroNode_.create(root);
}
if ((RubyGuards.isRubyBigDecimal(bValue_)) && (!(BigDecimalCoreMethodNode.isNormal(aValue_)) || !(BigDecimalCoreMethodNode.isNormal(bValue_)))) {
ConditionProfile nanProfile3 = (ConditionProfile.createBinaryProfile());
ConditionProfile normalNegProfile3 = (ConditionProfile.createBinaryProfile());
ConditionProfile negNormalProfile3 = (ConditionProfile.createBinaryProfile());
ConditionProfile posNegInfProfile3 = (ConditionProfile.createBinaryProfile());
ConditionProfile negPosInfProfile3 = (ConditionProfile.createBinaryProfile());
return ModuloSpecialNode_.create(root, nanProfile3, normalNegProfile3, negNormalProfile3, posNegInfProfile3, negPosInfProfile3);
}
}
return null;
}
@Override
protected final SpecializationNode createPolymorphic() {
return PolymorphicNode_.create(root);
}
protected final BaseNode_ getNext() {
return (BaseNode_) this.next;
}
}
@GeneratedBy(ModuloNode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(ModuloNodeGen root) {
super(root, 2147483647);
}
@Override
public Object execute_(VirtualFrame frameValue, Object aValue, Object bValue) {
return uninitialized(frameValue, aValue, bValue);
}
static BaseNode_ create(ModuloNodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(ModuloNode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(ModuloNodeGen root) {
super(root, 0);
}
@Override
public SpecializationNode merge(SpecializationNode newNode, Frame frameValue, Object aValue, Object bValue) {
return polymorphicMerge(newNode, super.merge(newNode, frameValue, aValue, bValue));
}
@Override
public Object execute_(VirtualFrame frameValue, Object aValue, Object bValue) {
return getNext().execute_(frameValue, aValue, bValue);
}
static BaseNode_ create(ModuloNodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "modulo(VirtualFrame, DynamicObject, DynamicObject)", value = ModuloNode.class)
private static final class ModuloNode_ extends BaseNode_ {
ModuloNode_(ModuloNodeGen root) {
super(root, 1);
}
@Override
public Object execute_(VirtualFrame frameValue, Object aValue, Object bValue) {
if (aValue instanceof DynamicObject && bValue instanceof DynamicObject) {
DynamicObject aValue_ = (DynamicObject) aValue;
DynamicObject bValue_ = (DynamicObject) bValue;
if ((BigDecimalCoreMethodNode.isNormal(aValue_)) && (BigDecimalCoreMethodNode.isNormalRubyBigDecimal(bValue_)) && (!(BigDecimalCoreMethodNode.isNormalZero(bValue_)))) {
return root.modulo(frameValue, aValue_, bValue_);
}
}
return getNext().execute_(frameValue, aValue, bValue);
}
static BaseNode_ create(ModuloNodeGen root) {
return new ModuloNode_(root);
}
}
@GeneratedBy(methodName = "moduloZero(DynamicObject, DynamicObject)", value = ModuloNode.class)
private static final class ModuloZeroNode_ extends BaseNode_ {
ModuloZeroNode_(ModuloNodeGen root) {
super(root, 2);
}
@Override
public Object execute_(VirtualFrame frameValue, Object aValue, Object bValue) {
if (aValue instanceof DynamicObject && bValue instanceof DynamicObject) {
DynamicObject aValue_ = (DynamicObject) aValue;
DynamicObject bValue_ = (DynamicObject) bValue;
if ((BigDecimalCoreMethodNode.isNormal(aValue_)) && (BigDecimalCoreMethodNode.isNormalRubyBigDecimal(bValue_)) && (BigDecimalCoreMethodNode.isNormalZero(bValue_))) {
return root.moduloZero(aValue_, bValue_);
}
}
return getNext().execute_(frameValue, aValue, bValue);
}
static BaseNode_ create(ModuloNodeGen root) {
return new ModuloZeroNode_(root);
}
}
@GeneratedBy(methodName = "moduloSpecial(VirtualFrame, DynamicObject, DynamicObject, ConditionProfile, ConditionProfile, ConditionProfile, ConditionProfile, ConditionProfile)", value = ModuloNode.class)
private static final class ModuloSpecialNode_ extends BaseNode_ {
private final ConditionProfile nanProfile;
private final ConditionProfile normalNegProfile;
private final ConditionProfile negNormalProfile;
private final ConditionProfile posNegInfProfile;
private final ConditionProfile negPosInfProfile;
ModuloSpecialNode_(ModuloNodeGen root, ConditionProfile nanProfile, ConditionProfile normalNegProfile, ConditionProfile negNormalProfile, ConditionProfile posNegInfProfile, ConditionProfile negPosInfProfile) {
super(root, 3);
this.nanProfile = nanProfile;
this.normalNegProfile = normalNegProfile;
this.negNormalProfile = negNormalProfile;
this.posNegInfProfile = posNegInfProfile;
this.negPosInfProfile = negPosInfProfile;
}
@Override
public Object execute_(VirtualFrame frameValue, Object aValue, Object bValue) {
if (aValue instanceof DynamicObject && bValue instanceof DynamicObject) {
DynamicObject aValue_ = (DynamicObject) aValue;
DynamicObject bValue_ = (DynamicObject) bValue;
if ((RubyGuards.isRubyBigDecimal(bValue_)) && (!(BigDecimalCoreMethodNode.isNormal(aValue_)) || !(BigDecimalCoreMethodNode.isNormal(bValue_)))) {
return root.moduloSpecial(frameValue, aValue_, bValue_, this.nanProfile, this.normalNegProfile, this.negNormalProfile, this.posNegInfProfile, this.negPosInfProfile);
}
}
return getNext().execute_(frameValue, aValue, bValue);
}
static BaseNode_ create(ModuloNodeGen root, ConditionProfile nanProfile, ConditionProfile normalNegProfile, ConditionProfile negNormalProfile, ConditionProfile posNegInfProfile, ConditionProfile negPosInfProfile) {
return new ModuloSpecialNode_(root, nanProfile, normalNegProfile, negNormalProfile, posNegInfProfile, negPosInfProfile);
}
}
}
}
@GeneratedBy(PowerNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class PowerNodeFactory implements NodeFactory {
private static PowerNodeFactory powerNodeFactoryInstance;
private PowerNodeFactory() {
}
@Override
public Class getNodeClass() {
return PowerNode.class;
}
@Override
public List getExecutionSignature() {
return Arrays.asList(RubyNode.class, RubyNode.class, RubyNode.class);
}
@Override
public List getNodeSignatures() {
return Arrays.asList(Arrays.asList(RubyNode.class, RubyNode.class, RubyNode.class));
}
@Override
public PowerNode createNode(Object... arguments) {
if (arguments.length == 3 && (arguments[0] == null || arguments[0] instanceof RubyNode) && (arguments[1] == null || arguments[1] instanceof RubyNode) && (arguments[2] == null || arguments[2] instanceof RubyNode)) {
return create((RubyNode) arguments[0], (RubyNode) arguments[1], (RubyNode) arguments[2]);
} else {
throw new IllegalArgumentException("Invalid create signature.");
}
}
public static NodeFactory getInstance() {
if (powerNodeFactoryInstance == null) {
powerNodeFactoryInstance = new PowerNodeFactory();
}
return powerNodeFactoryInstance;
}
public static PowerNode create(RubyNode self, RubyNode exponent, RubyNode precision) {
return new PowerNodeGen(self, exponent, precision);
}
@GeneratedBy(PowerNode.class)
public static final class PowerNodeGen extends PowerNode implements SpecializedNode {
@Child private RubyNode self_;
@Child private RubyNode exponent_;
@Child private RubyNode precision_;
@CompilationFinal private Class exponentType_;
@CompilationFinal private Class precisionType_;
@Child private BaseNode_ specialization_;
private PowerNodeGen(RubyNode self, RubyNode exponent, RubyNode precision) {
this.self_ = self;
this.exponent_ = exponent;
this.precision_ = precision;
this.specialization_ = UninitializedNode_.create(this);
}
@Override
public NodeCost getCost() {
return specialization_.getNodeCost();
}
@Override
public Object executePower(VirtualFrame frameValue, Object selfValue, Object exponentValue, Object precisionValue) {
return specialization_.execute1(frameValue, selfValue, exponentValue, precisionValue);
}
@Override
public Object execute(VirtualFrame frameValue) {
return specialization_.execute0(frameValue);
}
@Override
public void executeVoid(VirtualFrame frameValue) {
specialization_.executeVoid(frameValue);
return;
}
@Override
public SpecializationNode getSpecializationNode() {
return specialization_;
}
@Override
public Node deepCopy() {
return SpecializationNode.updateRoot(super.deepCopy());
}
@GeneratedBy(PowerNode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected PowerNodeGen root;
BaseNode_(PowerNodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (PowerNodeGen) root;
}
@Override
protected final Node[] getSuppliedChildren() {
return new Node[] {root.self_, root.exponent_, root.precision_};
}
@Override
public final Object acceptAndExecute(Frame frameValue, Object selfValue, Object exponentValue, Object precisionValue) {
return this.execute1((VirtualFrame) frameValue, selfValue, exponentValue, precisionValue);
}
public abstract Object execute1(VirtualFrame frameValue, Object selfValue, Object exponentValue, Object precisionValue);
public Object execute0(VirtualFrame frameValue) {
Object selfValue_ = root.self_.execute(frameValue);
Object exponentValue_ = executeExponent_(frameValue);
Object precisionValue_ = executePrecision_(frameValue);
return execute1(frameValue, selfValue_, exponentValue_, precisionValue_);
}
public void executeVoid(VirtualFrame frameValue) {
execute0(frameValue);
return;
}
@Override
protected final SpecializationNode createNext(Frame frameValue, Object selfValue, Object exponentValue, Object precisionValue) {
if (selfValue instanceof DynamicObject && RubyTypesGen.isImplicitInteger(exponentValue)) {
DynamicObject selfValue_ = (DynamicObject) selfValue;
if (precisionValue instanceof NotProvided) {
if ((BigDecimalCoreMethodNode.isNormal(selfValue_))) {
return Power0Node_.create(root, exponentValue);
}
}
if (RubyTypesGen.isImplicitInteger(precisionValue)) {
if ((BigDecimalCoreMethodNode.isNormal(selfValue_))) {
ConditionProfile positiveExponentProfile2 = (ConditionProfile.createBinaryProfile());
ConditionProfile zeroProfile2 = (ConditionProfile.createBinaryProfile());
ConditionProfile zeroExponentProfile2 = (ConditionProfile.createBinaryProfile());
return Power1Node_.create(root, exponentValue, precisionValue, positiveExponentProfile2, zeroProfile2, zeroExponentProfile2);
}
}
if ((!(BigDecimalCoreMethodNode.isNormal(selfValue_)))) {
BranchProfile nanProfile3 = (BranchProfile.create());
BranchProfile posInfinityProfile3 = (BranchProfile.create());
BranchProfile negInfinityProfile3 = (BranchProfile.create());
BranchProfile negZeroProfile3 = (BranchProfile.create());
return Power2Node_.create(root, exponentValue, nanProfile3, posInfinityProfile3, negInfinityProfile3, negZeroProfile3);
}
}
return null;
}
@Override
protected final SpecializationNode createPolymorphic() {
return PolymorphicNode_.create(root);
}
protected final BaseNode_ getNext() {
return (BaseNode_) this.next;
}
protected final Object executeExponent_(Frame frameValue) {
Class exponentType_ = root.exponentType_;
try {
if (exponentType_ == int.class) {
return root.exponent_.executeInteger((VirtualFrame) frameValue);
} else if (exponentType_ == null) {
CompilerDirectives.transferToInterpreterAndInvalidate();
Class _type = Object.class;
try {
Object _value = root.exponent_.execute((VirtualFrame) frameValue);
if (_value instanceof Integer) {
_type = int.class;
} else {
_type = Object.class;
}
return _value;
} finally {
root.exponentType_ = _type;
}
} else {
return root.exponent_.execute((VirtualFrame) frameValue);
}
} catch (UnexpectedResultException ex) {
root.exponentType_ = Object.class;
return ex.getResult();
}
}
protected final Object executePrecision_(Frame frameValue) {
Class precisionType_ = root.precisionType_;
try {
if (precisionType_ == int.class) {
return root.precision_.executeInteger((VirtualFrame) frameValue);
} else if (precisionType_ == null) {
CompilerDirectives.transferToInterpreterAndInvalidate();
Class _type = Object.class;
try {
Object _value = root.precision_.execute((VirtualFrame) frameValue);
if (_value instanceof Integer) {
_type = int.class;
} else {
_type = Object.class;
}
return _value;
} finally {
root.precisionType_ = _type;
}
} else {
return root.precision_.execute((VirtualFrame) frameValue);
}
} catch (UnexpectedResultException ex) {
root.precisionType_ = Object.class;
return ex.getResult();
}
}
}
@GeneratedBy(PowerNode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(PowerNodeGen root) {
super(root, 2147483647);
}
@Override
public Object execute1(VirtualFrame frameValue, Object selfValue, Object exponentValue, Object precisionValue) {
return uninitialized(frameValue, selfValue, exponentValue, precisionValue);
}
static BaseNode_ create(PowerNodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(PowerNode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(PowerNodeGen root) {
super(root, 0);
}
@Override
public SpecializationNode merge(SpecializationNode newNode, Frame frameValue, Object selfValue, Object exponentValue, Object precisionValue) {
return polymorphicMerge(newNode, super.merge(newNode, frameValue, selfValue, exponentValue, precisionValue));
}
@Override
public Object execute1(VirtualFrame frameValue, Object selfValue, Object exponentValue, Object precisionValue) {
return getNext().execute1(frameValue, selfValue, exponentValue, precisionValue);
}
static BaseNode_ create(PowerNodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "power(VirtualFrame, DynamicObject, int, NotProvided)", value = PowerNode.class)
private static final class Power0Node_ extends BaseNode_ {
private final Class exponentImplicitType;
Power0Node_(PowerNodeGen root, Object exponentValue) {
super(root, 1);
this.exponentImplicitType = RubyTypesGen.getImplicitIntegerClass(exponentValue);
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.exponentImplicitType == ((Power0Node_) other).exponentImplicitType;
}
@Override
public Object execute0(VirtualFrame frameValue) {
DynamicObject selfValue_;
try {
selfValue_ = root.self_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object exponentValue = executeExponent_(frameValue);
Object precisionValue = executePrecision_(frameValue);
return getNext().execute1(frameValue, ex.getResult(), exponentValue, precisionValue);
}
int exponentValue_;
try {
if (exponentImplicitType == int.class) {
exponentValue_ = root.exponent_.executeInteger(frameValue);
} else {
Object exponentValue__ = executeExponent_(frameValue);
exponentValue_ = RubyTypesGen.expectImplicitInteger(exponentValue__, exponentImplicitType);
}
} catch (UnexpectedResultException ex) {
Object precisionValue = executePrecision_(frameValue);
return getNext().execute1(frameValue, selfValue_, ex.getResult(), precisionValue);
}
NotProvided precisionValue_;
try {
precisionValue_ = root.precision_.executeNotProvided(frameValue);
} catch (UnexpectedResultException ex) {
return getNext().execute1(frameValue, selfValue_, exponentValue_, ex.getResult());
}
if ((BigDecimalCoreMethodNode.isNormal(selfValue_))) {
return root.power(frameValue, selfValue_, exponentValue_, precisionValue_);
}
return getNext().execute1(frameValue, selfValue_, exponentValue_, precisionValue_);
}
@Override
public Object execute1(VirtualFrame frameValue, Object selfValue, Object exponentValue, Object precisionValue) {
if (selfValue instanceof DynamicObject && RubyTypesGen.isImplicitInteger(exponentValue, exponentImplicitType) && precisionValue instanceof NotProvided) {
DynamicObject selfValue_ = (DynamicObject) selfValue;
int exponentValue_ = RubyTypesGen.asImplicitInteger(exponentValue, exponentImplicitType);
NotProvided precisionValue_ = (NotProvided) precisionValue;
if ((BigDecimalCoreMethodNode.isNormal(selfValue_))) {
return root.power(frameValue, selfValue_, exponentValue_, precisionValue_);
}
}
return getNext().execute1(frameValue, selfValue, exponentValue, precisionValue);
}
static BaseNode_ create(PowerNodeGen root, Object exponentValue) {
return new Power0Node_(root, exponentValue);
}
}
@GeneratedBy(methodName = "power(VirtualFrame, DynamicObject, int, int, ConditionProfile, ConditionProfile, ConditionProfile)", value = PowerNode.class)
private static final class Power1Node_ extends BaseNode_ {
private final ConditionProfile positiveExponentProfile;
private final ConditionProfile zeroProfile;
private final ConditionProfile zeroExponentProfile;
private final Class exponentImplicitType;
private final Class precisionImplicitType;
Power1Node_(PowerNodeGen root, Object exponentValue, Object precisionValue, ConditionProfile positiveExponentProfile, ConditionProfile zeroProfile, ConditionProfile zeroExponentProfile) {
super(root, 2);
this.exponentImplicitType = RubyTypesGen.getImplicitIntegerClass(exponentValue);
this.precisionImplicitType = RubyTypesGen.getImplicitIntegerClass(precisionValue);
this.positiveExponentProfile = positiveExponentProfile;
this.zeroProfile = zeroProfile;
this.zeroExponentProfile = zeroExponentProfile;
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.exponentImplicitType == ((Power1Node_) other).exponentImplicitType && this.precisionImplicitType == ((Power1Node_) other).precisionImplicitType;
}
@Override
public Object execute0(VirtualFrame frameValue) {
DynamicObject selfValue_;
try {
selfValue_ = root.self_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object exponentValue = executeExponent_(frameValue);
Object precisionValue = executePrecision_(frameValue);
return getNext().execute1(frameValue, ex.getResult(), exponentValue, precisionValue);
}
int exponentValue_;
try {
if (exponentImplicitType == int.class) {
exponentValue_ = root.exponent_.executeInteger(frameValue);
} else {
Object exponentValue__ = executeExponent_(frameValue);
exponentValue_ = RubyTypesGen.expectImplicitInteger(exponentValue__, exponentImplicitType);
}
} catch (UnexpectedResultException ex) {
Object precisionValue = executePrecision_(frameValue);
return getNext().execute1(frameValue, selfValue_, ex.getResult(), precisionValue);
}
int precisionValue_;
try {
if (precisionImplicitType == int.class) {
precisionValue_ = root.precision_.executeInteger(frameValue);
} else {
Object precisionValue__ = executePrecision_(frameValue);
precisionValue_ = RubyTypesGen.expectImplicitInteger(precisionValue__, precisionImplicitType);
}
} catch (UnexpectedResultException ex) {
return getNext().execute1(frameValue, selfValue_, exponentValue_, ex.getResult());
}
if ((BigDecimalCoreMethodNode.isNormal(selfValue_))) {
return root.power(frameValue, selfValue_, exponentValue_, precisionValue_, this.positiveExponentProfile, this.zeroProfile, this.zeroExponentProfile);
}
return getNext().execute1(frameValue, selfValue_, exponentValue_, precisionValue_);
}
@Override
public Object execute1(VirtualFrame frameValue, Object selfValue, Object exponentValue, Object precisionValue) {
if (selfValue instanceof DynamicObject && RubyTypesGen.isImplicitInteger(exponentValue, exponentImplicitType) && RubyTypesGen.isImplicitInteger(precisionValue, precisionImplicitType)) {
DynamicObject selfValue_ = (DynamicObject) selfValue;
int exponentValue_ = RubyTypesGen.asImplicitInteger(exponentValue, exponentImplicitType);
int precisionValue_ = RubyTypesGen.asImplicitInteger(precisionValue, precisionImplicitType);
if ((BigDecimalCoreMethodNode.isNormal(selfValue_))) {
return root.power(frameValue, selfValue_, exponentValue_, precisionValue_, this.positiveExponentProfile, this.zeroProfile, this.zeroExponentProfile);
}
}
return getNext().execute1(frameValue, selfValue, exponentValue, precisionValue);
}
static BaseNode_ create(PowerNodeGen root, Object exponentValue, Object precisionValue, ConditionProfile positiveExponentProfile, ConditionProfile zeroProfile, ConditionProfile zeroExponentProfile) {
return new Power1Node_(root, exponentValue, precisionValue, positiveExponentProfile, zeroProfile, zeroExponentProfile);
}
}
@GeneratedBy(methodName = "power(VirtualFrame, DynamicObject, int, Object, BranchProfile, BranchProfile, BranchProfile, BranchProfile)", value = PowerNode.class)
private static final class Power2Node_ extends BaseNode_ {
private final BranchProfile nanProfile;
private final BranchProfile posInfinityProfile;
private final BranchProfile negInfinityProfile;
private final BranchProfile negZeroProfile;
private final Class exponentImplicitType;
Power2Node_(PowerNodeGen root, Object exponentValue, BranchProfile nanProfile, BranchProfile posInfinityProfile, BranchProfile negInfinityProfile, BranchProfile negZeroProfile) {
super(root, 3);
this.exponentImplicitType = RubyTypesGen.getImplicitIntegerClass(exponentValue);
this.nanProfile = nanProfile;
this.posInfinityProfile = posInfinityProfile;
this.negInfinityProfile = negInfinityProfile;
this.negZeroProfile = negZeroProfile;
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.exponentImplicitType == ((Power2Node_) other).exponentImplicitType;
}
@Override
public Object execute0(VirtualFrame frameValue) {
DynamicObject selfValue_;
try {
selfValue_ = root.self_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object exponentValue = executeExponent_(frameValue);
Object precisionValue = executePrecision_(frameValue);
return getNext().execute1(frameValue, ex.getResult(), exponentValue, precisionValue);
}
int exponentValue_;
try {
if (exponentImplicitType == int.class) {
exponentValue_ = root.exponent_.executeInteger(frameValue);
} else {
Object exponentValue__ = executeExponent_(frameValue);
exponentValue_ = RubyTypesGen.expectImplicitInteger(exponentValue__, exponentImplicitType);
}
} catch (UnexpectedResultException ex) {
Object precisionValue = executePrecision_(frameValue);
return getNext().execute1(frameValue, selfValue_, ex.getResult(), precisionValue);
}
Object precisionValue_ = executePrecision_(frameValue);
if ((!(BigDecimalCoreMethodNode.isNormal(selfValue_)))) {
return root.power(frameValue, selfValue_, exponentValue_, precisionValue_, this.nanProfile, this.posInfinityProfile, this.negInfinityProfile, this.negZeroProfile);
}
return getNext().execute1(frameValue, selfValue_, exponentValue_, precisionValue_);
}
@Override
public Object execute1(VirtualFrame frameValue, Object selfValue, Object exponentValue, Object precisionValue) {
if (selfValue instanceof DynamicObject && RubyTypesGen.isImplicitInteger(exponentValue, exponentImplicitType)) {
DynamicObject selfValue_ = (DynamicObject) selfValue;
int exponentValue_ = RubyTypesGen.asImplicitInteger(exponentValue, exponentImplicitType);
if ((!(BigDecimalCoreMethodNode.isNormal(selfValue_)))) {
return root.power(frameValue, selfValue_, exponentValue_, precisionValue, this.nanProfile, this.posInfinityProfile, this.negInfinityProfile, this.negZeroProfile);
}
}
return getNext().execute1(frameValue, selfValue, exponentValue, precisionValue);
}
static BaseNode_ create(PowerNodeGen root, Object exponentValue, BranchProfile nanProfile, BranchProfile posInfinityProfile, BranchProfile negInfinityProfile, BranchProfile negZeroProfile) {
return new Power2Node_(root, exponentValue, nanProfile, posInfinityProfile, negInfinityProfile, negZeroProfile);
}
}
}
}
@GeneratedBy(SqrtNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class SqrtNodeFactory implements NodeFactory {
private static SqrtNodeFactory sqrtNodeFactoryInstance;
private SqrtNodeFactory() {
}
@Override
public Class getNodeClass() {
return SqrtNode.class;
}
@Override
public List getExecutionSignature() {
return Arrays.asList(RubyNode.class, RubyNode.class);
}
@Override
public List getNodeSignatures() {
return Arrays.asList(Arrays.asList(RubyNode.class, RubyNode.class));
}
@Override
public SqrtNode createNode(Object... arguments) {
if (arguments.length == 2 && (arguments[0] == null || arguments[0] instanceof RubyNode) && (arguments[1] == null || arguments[1] instanceof RubyNode)) {
return create((RubyNode) arguments[0], (RubyNode) arguments[1]);
} else {
throw new IllegalArgumentException("Invalid create signature.");
}
}
public static NodeFactory getInstance() {
if (sqrtNodeFactoryInstance == null) {
sqrtNodeFactoryInstance = new SqrtNodeFactory();
}
return sqrtNodeFactoryInstance;
}
public static SqrtNode create(RubyNode self, RubyNode precision) {
return new SqrtNodeGen(self, precision);
}
@GeneratedBy(SqrtNode.class)
@SuppressFBWarnings("SA_LOCAL_SELF_COMPARISON")
public static final class SqrtNodeGen extends SqrtNode implements SpecializedNode {
@Child private RubyNode self_;
@Child private RubyNode precision_;
@CompilationFinal private Class precisionType_;
@Child private BaseNode_ specialization_;
private SqrtNodeGen(RubyNode self, RubyNode precision) {
this.self_ = self;
this.precision_ = precision;
this.specialization_ = UninitializedNode_.create(this);
}
@Override
public NodeCost getCost() {
return specialization_.getNodeCost();
}
@Override
public Object executeSqrt(VirtualFrame frameValue, DynamicObject selfValue, int precisionValue) {
return specialization_.execute1(frameValue, selfValue, precisionValue);
}
@Override
public Object execute(VirtualFrame frameValue) {
return specialization_.execute0(frameValue);
}
@Override
public void executeVoid(VirtualFrame frameValue) {
specialization_.executeVoid(frameValue);
return;
}
@Override
public SpecializationNode getSpecializationNode() {
return specialization_;
}
@Override
public Node deepCopy() {
return SpecializationNode.updateRoot(super.deepCopy());
}
@GeneratedBy(SqrtNode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected SqrtNodeGen root;
BaseNode_(SqrtNodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (SqrtNodeGen) root;
}
@Override
protected final Node[] getSuppliedChildren() {
return new Node[] {root.self_, root.precision_};
}
@Override
public final Object acceptAndExecute(Frame frameValue, Object selfValue, Object precisionValue) {
return this.execute_((VirtualFrame) frameValue, selfValue, precisionValue);
}
public abstract Object execute_(VirtualFrame frameValue, Object selfValue, Object precisionValue);
public Object execute1(VirtualFrame frameValue, DynamicObject selfValue, int precisionValue) {
return execute_(frameValue, selfValue, precisionValue);
}
public Object execute0(VirtualFrame frameValue) {
Object selfValue_ = root.self_.execute(frameValue);
Object precisionValue_ = executePrecision_(frameValue);
return execute_(frameValue, selfValue_, precisionValue_);
}
public void executeVoid(VirtualFrame frameValue) {
execute0(frameValue);
return;
}
@Override
protected final SpecializationNode createNext(Frame frameValue, Object selfValue, Object precisionValue) {
if (selfValue instanceof DynamicObject && RubyTypesGen.isImplicitInteger(precisionValue)) {
DynamicObject selfValue_ = (DynamicObject) selfValue;
int precisionValue_ = RubyTypesGen.asImplicitInteger(precisionValue);
if ((precisionValue_ < 0)) {
return SqrtNegativePrecisionNode_.create(root, precisionValue);
}
if ((precisionValue_ == 0)) {
return SqrtZeroPrecisionNode_.create(root, precisionValue);
}
if ((BigDecimalCoreMethodNode.isNormal(selfValue_)) && (precisionValue_ > 0)) {
ConditionProfile positiveValueProfile3 = (ConditionProfile.createBinaryProfile());
return SqrtNode_.create(root, precisionValue, positiveValueProfile3);
}
if ((!(BigDecimalCoreMethodNode.isNormal(selfValue_))) && (precisionValue_ > 0)) {
BranchProfile nanProfile4 = (BranchProfile.create());
BranchProfile posInfProfile4 = (BranchProfile.create());
BranchProfile negInfProfile4 = (BranchProfile.create());
BranchProfile negZeroProfile4 = (BranchProfile.create());
return SqrtSpecialNode_.create(root, precisionValue, nanProfile4, posInfProfile4, negInfProfile4, negZeroProfile4);
}
}
return null;
}
@Override
protected final SpecializationNode createPolymorphic() {
return PolymorphicNode_.create(root);
}
protected final BaseNode_ getNext() {
return (BaseNode_) this.next;
}
protected final Object executePrecision_(Frame frameValue) {
Class precisionType_ = root.precisionType_;
try {
if (precisionType_ == int.class) {
return root.precision_.executeInteger((VirtualFrame) frameValue);
} else if (precisionType_ == null) {
CompilerDirectives.transferToInterpreterAndInvalidate();
Class _type = Object.class;
try {
Object _value = root.precision_.execute((VirtualFrame) frameValue);
if (_value instanceof Integer) {
_type = int.class;
} else {
_type = Object.class;
}
return _value;
} finally {
root.precisionType_ = _type;
}
} else {
return root.precision_.execute((VirtualFrame) frameValue);
}
} catch (UnexpectedResultException ex) {
root.precisionType_ = Object.class;
return ex.getResult();
}
}
}
@GeneratedBy(SqrtNode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(SqrtNodeGen root) {
super(root, 2147483647);
}
@Override
public Object execute_(VirtualFrame frameValue, Object selfValue, Object precisionValue) {
return uninitialized(frameValue, selfValue, precisionValue);
}
static BaseNode_ create(SqrtNodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(SqrtNode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(SqrtNodeGen root) {
super(root, 0);
}
@Override
public SpecializationNode merge(SpecializationNode newNode, Frame frameValue, Object selfValue, Object precisionValue) {
return polymorphicMerge(newNode, super.merge(newNode, frameValue, selfValue, precisionValue));
}
@Override
public Object execute_(VirtualFrame frameValue, Object selfValue, Object precisionValue) {
return getNext().execute_(frameValue, selfValue, precisionValue);
}
static BaseNode_ create(SqrtNodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "sqrtNegativePrecision(VirtualFrame, DynamicObject, int)", value = SqrtNode.class)
private static final class SqrtNegativePrecisionNode_ extends BaseNode_ {
private final Class precisionImplicitType;
SqrtNegativePrecisionNode_(SqrtNodeGen root, Object precisionValue) {
super(root, 1);
this.precisionImplicitType = RubyTypesGen.getImplicitIntegerClass(precisionValue);
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.precisionImplicitType == ((SqrtNegativePrecisionNode_) other).precisionImplicitType;
}
@Override
public Object execute0(VirtualFrame frameValue) {
DynamicObject selfValue_;
try {
selfValue_ = root.self_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object precisionValue = executePrecision_(frameValue);
return getNext().execute_(frameValue, ex.getResult(), precisionValue);
}
int precisionValue_;
try {
if (precisionImplicitType == int.class) {
precisionValue_ = root.precision_.executeInteger(frameValue);
} else {
Object precisionValue__ = executePrecision_(frameValue);
precisionValue_ = RubyTypesGen.expectImplicitInteger(precisionValue__, precisionImplicitType);
}
} catch (UnexpectedResultException ex) {
return getNext().execute_(frameValue, selfValue_, ex.getResult());
}
if ((precisionValue_ < 0)) {
return root.sqrtNegativePrecision(frameValue, selfValue_, precisionValue_);
}
return getNext().execute_(frameValue, selfValue_, precisionValue_);
}
@Override
public Object execute1(VirtualFrame frameValue, DynamicObject selfValue, int precisionValue) {
if ((precisionValue < 0)) {
return root.sqrtNegativePrecision(frameValue, selfValue, precisionValue);
}
return getNext().execute1(frameValue, selfValue, precisionValue);
}
@Override
public Object execute_(VirtualFrame frameValue, Object selfValue, Object precisionValue) {
if (selfValue instanceof DynamicObject && RubyTypesGen.isImplicitInteger(precisionValue, precisionImplicitType)) {
DynamicObject selfValue_ = (DynamicObject) selfValue;
int precisionValue_ = RubyTypesGen.asImplicitInteger(precisionValue, precisionImplicitType);
if ((precisionValue_ < 0)) {
return root.sqrtNegativePrecision(frameValue, selfValue_, precisionValue_);
}
}
return getNext().execute_(frameValue, selfValue, precisionValue);
}
static BaseNode_ create(SqrtNodeGen root, Object precisionValue) {
return new SqrtNegativePrecisionNode_(root, precisionValue);
}
}
@GeneratedBy(methodName = "sqrtZeroPrecision(VirtualFrame, DynamicObject, int)", value = SqrtNode.class)
private static final class SqrtZeroPrecisionNode_ extends BaseNode_ {
private final Class precisionImplicitType;
SqrtZeroPrecisionNode_(SqrtNodeGen root, Object precisionValue) {
super(root, 2);
this.precisionImplicitType = RubyTypesGen.getImplicitIntegerClass(precisionValue);
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.precisionImplicitType == ((SqrtZeroPrecisionNode_) other).precisionImplicitType;
}
@Override
public Object execute0(VirtualFrame frameValue) {
DynamicObject selfValue_;
try {
selfValue_ = root.self_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object precisionValue = executePrecision_(frameValue);
return getNext().execute_(frameValue, ex.getResult(), precisionValue);
}
int precisionValue_;
try {
if (precisionImplicitType == int.class) {
precisionValue_ = root.precision_.executeInteger(frameValue);
} else {
Object precisionValue__ = executePrecision_(frameValue);
precisionValue_ = RubyTypesGen.expectImplicitInteger(precisionValue__, precisionImplicitType);
}
} catch (UnexpectedResultException ex) {
return getNext().execute_(frameValue, selfValue_, ex.getResult());
}
if ((precisionValue_ == 0)) {
return root.sqrtZeroPrecision(frameValue, selfValue_, precisionValue_);
}
return getNext().execute_(frameValue, selfValue_, precisionValue_);
}
@Override
public Object execute1(VirtualFrame frameValue, DynamicObject selfValue, int precisionValue) {
if ((precisionValue == 0)) {
return root.sqrtZeroPrecision(frameValue, selfValue, precisionValue);
}
return getNext().execute1(frameValue, selfValue, precisionValue);
}
@Override
public Object execute_(VirtualFrame frameValue, Object selfValue, Object precisionValue) {
if (selfValue instanceof DynamicObject && RubyTypesGen.isImplicitInteger(precisionValue, precisionImplicitType)) {
DynamicObject selfValue_ = (DynamicObject) selfValue;
int precisionValue_ = RubyTypesGen.asImplicitInteger(precisionValue, precisionImplicitType);
if ((precisionValue_ == 0)) {
return root.sqrtZeroPrecision(frameValue, selfValue_, precisionValue_);
}
}
return getNext().execute_(frameValue, selfValue, precisionValue);
}
static BaseNode_ create(SqrtNodeGen root, Object precisionValue) {
return new SqrtZeroPrecisionNode_(root, precisionValue);
}
}
@GeneratedBy(methodName = "sqrt(VirtualFrame, DynamicObject, int, ConditionProfile)", value = SqrtNode.class)
private static final class SqrtNode_ extends BaseNode_ {
private final ConditionProfile positiveValueProfile;
private final Class precisionImplicitType;
SqrtNode_(SqrtNodeGen root, Object precisionValue, ConditionProfile positiveValueProfile) {
super(root, 3);
this.precisionImplicitType = RubyTypesGen.getImplicitIntegerClass(precisionValue);
this.positiveValueProfile = positiveValueProfile;
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.precisionImplicitType == ((SqrtNode_) other).precisionImplicitType;
}
@Override
public Object execute0(VirtualFrame frameValue) {
DynamicObject selfValue_;
try {
selfValue_ = root.self_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object precisionValue = executePrecision_(frameValue);
return getNext().execute_(frameValue, ex.getResult(), precisionValue);
}
int precisionValue_;
try {
if (precisionImplicitType == int.class) {
precisionValue_ = root.precision_.executeInteger(frameValue);
} else {
Object precisionValue__ = executePrecision_(frameValue);
precisionValue_ = RubyTypesGen.expectImplicitInteger(precisionValue__, precisionImplicitType);
}
} catch (UnexpectedResultException ex) {
return getNext().execute_(frameValue, selfValue_, ex.getResult());
}
if ((BigDecimalCoreMethodNode.isNormal(selfValue_)) && (precisionValue_ > 0)) {
return root.sqrt(frameValue, selfValue_, precisionValue_, this.positiveValueProfile);
}
return getNext().execute_(frameValue, selfValue_, precisionValue_);
}
@Override
public Object execute1(VirtualFrame frameValue, DynamicObject selfValue, int precisionValue) {
if ((BigDecimalCoreMethodNode.isNormal(selfValue)) && (precisionValue > 0)) {
return root.sqrt(frameValue, selfValue, precisionValue, this.positiveValueProfile);
}
return getNext().execute1(frameValue, selfValue, precisionValue);
}
@Override
public Object execute_(VirtualFrame frameValue, Object selfValue, Object precisionValue) {
if (selfValue instanceof DynamicObject && RubyTypesGen.isImplicitInteger(precisionValue, precisionImplicitType)) {
DynamicObject selfValue_ = (DynamicObject) selfValue;
int precisionValue_ = RubyTypesGen.asImplicitInteger(precisionValue, precisionImplicitType);
if ((BigDecimalCoreMethodNode.isNormal(selfValue_)) && (precisionValue_ > 0)) {
return root.sqrt(frameValue, selfValue_, precisionValue_, this.positiveValueProfile);
}
}
return getNext().execute_(frameValue, selfValue, precisionValue);
}
static BaseNode_ create(SqrtNodeGen root, Object precisionValue, ConditionProfile positiveValueProfile) {
return new SqrtNode_(root, precisionValue, positiveValueProfile);
}
}
@GeneratedBy(methodName = "sqrtSpecial(VirtualFrame, DynamicObject, int, BranchProfile, BranchProfile, BranchProfile, BranchProfile)", value = SqrtNode.class)
private static final class SqrtSpecialNode_ extends BaseNode_ {
private final BranchProfile nanProfile;
private final BranchProfile posInfProfile;
private final BranchProfile negInfProfile;
private final BranchProfile negZeroProfile;
private final Class precisionImplicitType;
SqrtSpecialNode_(SqrtNodeGen root, Object precisionValue, BranchProfile nanProfile, BranchProfile posInfProfile, BranchProfile negInfProfile, BranchProfile negZeroProfile) {
super(root, 4);
this.precisionImplicitType = RubyTypesGen.getImplicitIntegerClass(precisionValue);
this.nanProfile = nanProfile;
this.posInfProfile = posInfProfile;
this.negInfProfile = negInfProfile;
this.negZeroProfile = negZeroProfile;
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.precisionImplicitType == ((SqrtSpecialNode_) other).precisionImplicitType;
}
@Override
public Object execute0(VirtualFrame frameValue) {
DynamicObject selfValue_;
try {
selfValue_ = root.self_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object precisionValue = executePrecision_(frameValue);
return getNext().execute_(frameValue, ex.getResult(), precisionValue);
}
int precisionValue_;
try {
if (precisionImplicitType == int.class) {
precisionValue_ = root.precision_.executeInteger(frameValue);
} else {
Object precisionValue__ = executePrecision_(frameValue);
precisionValue_ = RubyTypesGen.expectImplicitInteger(precisionValue__, precisionImplicitType);
}
} catch (UnexpectedResultException ex) {
return getNext().execute_(frameValue, selfValue_, ex.getResult());
}
if ((!(BigDecimalCoreMethodNode.isNormal(selfValue_))) && (precisionValue_ > 0)) {
return root.sqrtSpecial(frameValue, selfValue_, precisionValue_, this.nanProfile, this.posInfProfile, this.negInfProfile, this.negZeroProfile);
}
return getNext().execute_(frameValue, selfValue_, precisionValue_);
}
@Override
public Object execute1(VirtualFrame frameValue, DynamicObject selfValue, int precisionValue) {
if ((!(BigDecimalCoreMethodNode.isNormal(selfValue))) && (precisionValue > 0)) {
return root.sqrtSpecial(frameValue, selfValue, precisionValue, this.nanProfile, this.posInfProfile, this.negInfProfile, this.negZeroProfile);
}
return getNext().execute1(frameValue, selfValue, precisionValue);
}
@Override
public Object execute_(VirtualFrame frameValue, Object selfValue, Object precisionValue) {
if (selfValue instanceof DynamicObject && RubyTypesGen.isImplicitInteger(precisionValue, precisionImplicitType)) {
DynamicObject selfValue_ = (DynamicObject) selfValue;
int precisionValue_ = RubyTypesGen.asImplicitInteger(precisionValue, precisionImplicitType);
if ((!(BigDecimalCoreMethodNode.isNormal(selfValue_))) && (precisionValue_ > 0)) {
return root.sqrtSpecial(frameValue, selfValue_, precisionValue_, this.nanProfile, this.posInfProfile, this.negInfProfile, this.negZeroProfile);
}
}
return getNext().execute_(frameValue, selfValue, precisionValue);
}
static BaseNode_ create(SqrtNodeGen root, Object precisionValue, BranchProfile nanProfile, BranchProfile posInfProfile, BranchProfile negInfProfile, BranchProfile negZeroProfile) {
return new SqrtSpecialNode_(root, precisionValue, nanProfile, posInfProfile, negInfProfile, negZeroProfile);
}
}
}
}
@GeneratedBy(CompareNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class CompareNodeFactory implements NodeFactory {
private static CompareNodeFactory compareNodeFactoryInstance;
private CompareNodeFactory() {
}
@Override
public Class getNodeClass() {
return CompareNode.class;
}
@Override
public List getExecutionSignature() {
return Arrays.asList(RubyNode.class, RubyNode.class);
}
@Override
public List getNodeSignatures() {
return Arrays.asList(Arrays.asList(RubyNode[].class));
}
@Override
public CompareNode createNode(Object... arguments) {
if (arguments.length == 1 && (arguments[0] == null || arguments[0] instanceof RubyNode[])) {
return create((RubyNode[]) arguments[0]);
} else {
throw new IllegalArgumentException("Invalid create signature.");
}
}
public static NodeFactory getInstance() {
if (compareNodeFactoryInstance == null) {
compareNodeFactoryInstance = new CompareNodeFactory();
}
return compareNodeFactoryInstance;
}
public static CompareNode create(RubyNode[] arguments) {
return new CompareNodeGen(arguments);
}
@GeneratedBy(CompareNode.class)
public static final class CompareNodeGen extends CompareNode implements SpecializedNode {
@Child private RubyNode arguments0_;
@Child private RubyNode arguments1_;
@CompilationFinal private Class arguments1Type_;
@Child private BaseNode_ specialization_;
private CompareNodeGen(RubyNode[] arguments) {
this.arguments0_ = arguments != null && 0 < arguments.length ? arguments[0] : null;
this.arguments1_ = arguments != null && 1 < arguments.length ? arguments[1] : null;
this.specialization_ = UninitializedNode_.create(this);
}
@Override
public NodeCost getCost() {
return specialization_.getNodeCost();
}
@Override
public Object execute(VirtualFrame frameValue) {
return specialization_.execute(frameValue);
}
@Override
public void executeVoid(VirtualFrame frameValue) {
specialization_.executeVoid(frameValue);
return;
}
@Override
public int executeInteger(VirtualFrame frameValue) throws UnexpectedResultException {
return specialization_.executeInt(frameValue);
}
@Override
public SpecializationNode getSpecializationNode() {
return specialization_;
}
@Override
public Node deepCopy() {
return SpecializationNode.updateRoot(super.deepCopy());
}
private static int expectInteger(Object value) throws UnexpectedResultException {
if (value instanceof Integer) {
return (int) value;
}
throw new UnexpectedResultException(value);
}
@GeneratedBy(CompareNode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected CompareNodeGen root;
BaseNode_(CompareNodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (CompareNodeGen) root;
}
@Override
protected final Node[] getSuppliedChildren() {
return new Node[] {root.arguments0_, root.arguments1_};
}
@Override
public final Object acceptAndExecute(Frame frameValue, Object arguments0Value, Object arguments1Value) {
return this.execute_((VirtualFrame) frameValue, arguments0Value, arguments1Value);
}
public abstract Object execute_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value);
public Object execute(VirtualFrame frameValue) {
Object arguments0Value_ = root.arguments0_.execute(frameValue);
Object arguments1Value_ = executeArguments1_(frameValue);
return execute_(frameValue, arguments0Value_, arguments1Value_);
}
public void executeVoid(VirtualFrame frameValue) {
execute(frameValue);
return;
}
public int executeInt(VirtualFrame frameValue) throws UnexpectedResultException {
return expectInteger(execute(frameValue));
}
@Override
protected final SpecializationNode createNext(Frame frameValue, Object arguments0Value, Object arguments1Value) {
if (arguments0Value instanceof DynamicObject) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
if (RubyTypesGen.isImplicitLong(arguments1Value)) {
if ((BigDecimalCoreMethodNode.isNormal(arguments0Value_))) {
return Compare0Node_.create(root, arguments1Value);
}
}
if (RubyTypesGen.isImplicitDouble(arguments1Value)) {
if ((BigDecimalCoreMethodNode.isNormal(arguments0Value_))) {
return Compare1Node_.create(root, arguments1Value);
}
}
if (arguments1Value instanceof DynamicObject) {
DynamicObject arguments1Value_ = (DynamicObject) arguments1Value;
if ((BigDecimalCoreMethodNode.isNormal(arguments0Value_)) && (RubyGuards.isRubyBignum(arguments1Value_))) {
return Compare2Node_.create(root);
}
if ((BigDecimalCoreMethodNode.isNormal(arguments0Value_)) && (BigDecimalCoreMethodNode.isNormalRubyBigDecimal(arguments1Value_))) {
return CompareNormalNode_.create(root);
}
}
if (RubyTypesGen.isImplicitLong(arguments1Value)) {
if ((!(BigDecimalCoreMethodNode.isNormal(arguments0Value_)))) {
return CompareSpecial0Node_.create(root, arguments1Value);
}
}
if (RubyTypesGen.isImplicitDouble(arguments1Value)) {
if ((!(BigDecimalCoreMethodNode.isNormal(arguments0Value_)))) {
return CompareSpecial1Node_.create(root, arguments1Value);
}
}
if (arguments1Value instanceof DynamicObject) {
DynamicObject arguments1Value_ = (DynamicObject) arguments1Value;
if ((!(BigDecimalCoreMethodNode.isNormal(arguments0Value_))) && (RubyGuards.isRubyBignum(arguments1Value_))) {
return CompareSpecialBignumNode_.create(root);
}
if ((!(BigDecimalCoreMethodNode.isNormal(arguments0Value_))) && (BigDecimalCoreMethodNode.isNan(arguments0Value_))) {
return CompareSpecialNanNode_.create(root);
}
if ((RubyGuards.isRubyBigDecimal(arguments1Value_)) && (!(BigDecimalCoreMethodNode.isNormal(arguments0Value_)) || !(BigDecimalCoreMethodNode.isNormal(arguments1Value_))) && (BigDecimalCoreMethodNode.isNormal(arguments0Value_) || !(BigDecimalCoreMethodNode.isNan(arguments0Value_)))) {
return CompareSpecial2Node_.create(root);
}
if ((root.isNil(arguments1Value_))) {
return CompareNilNode_.create(root);
}
if ((!(RubyGuards.isRubyBigDecimal(arguments1Value_))) && (!(root.isNil(arguments1Value_)))) {
SnippetNode snippetNode11 = (new SnippetNode());
return CompareCoercedNode_.create(root, snippetNode11);
}
}
}
return null;
}
@Override
protected final SpecializationNode createPolymorphic() {
return PolymorphicNode_.create(root);
}
protected final BaseNode_ getNext() {
return (BaseNode_) this.next;
}
protected final long executeArguments1Long_(Frame frameValue, Class arguments1ImplicitType) throws UnexpectedResultException {
if (arguments1ImplicitType == long.class) {
return root.arguments1_.executeLong((VirtualFrame) frameValue);
} else if (arguments1ImplicitType == int.class) {
return RubyTypes.promoteToLong(root.arguments1_.executeInteger((VirtualFrame) frameValue));
} else {
Object arguments1Value_ = executeArguments1_(frameValue);
return RubyTypesGen.expectImplicitLong(arguments1Value_, arguments1ImplicitType);
}
}
protected final Object executeArguments1_(Frame frameValue) {
Class arguments1Type_ = root.arguments1Type_;
try {
if (arguments1Type_ == double.class) {
return root.arguments1_.executeDouble((VirtualFrame) frameValue);
} else if (arguments1Type_ == int.class) {
return root.arguments1_.executeInteger((VirtualFrame) frameValue);
} else if (arguments1Type_ == long.class) {
return root.arguments1_.executeLong((VirtualFrame) frameValue);
} else if (arguments1Type_ == null) {
CompilerDirectives.transferToInterpreterAndInvalidate();
Class _type = Object.class;
try {
Object _value = root.arguments1_.execute((VirtualFrame) frameValue);
if (_value instanceof Double) {
_type = double.class;
} else if (_value instanceof Integer) {
_type = int.class;
} else if (_value instanceof Long) {
_type = long.class;
} else {
_type = Object.class;
}
return _value;
} finally {
root.arguments1Type_ = _type;
}
} else {
return root.arguments1_.execute((VirtualFrame) frameValue);
}
} catch (UnexpectedResultException ex) {
root.arguments1Type_ = Object.class;
return ex.getResult();
}
}
}
@GeneratedBy(CompareNode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(CompareNodeGen root) {
super(root, 2147483647);
}
@Override
public Object execute_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value) {
return uninitialized(frameValue, arguments0Value, arguments1Value);
}
static BaseNode_ create(CompareNodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(CompareNode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(CompareNodeGen root) {
super(root, 0);
}
@Override
public SpecializationNode merge(SpecializationNode newNode, Frame frameValue, Object arguments0Value, Object arguments1Value) {
return polymorphicMerge(newNode, super.merge(newNode, frameValue, arguments0Value, arguments1Value));
}
@Override
public Object execute_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value) {
return getNext().execute_(frameValue, arguments0Value, arguments1Value);
}
static BaseNode_ create(CompareNodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "compare(DynamicObject, long)", value = CompareNode.class)
private static final class Compare0Node_ extends BaseNode_ {
private final Class arguments1ImplicitType;
Compare0Node_(CompareNodeGen root, Object arguments1Value) {
super(root, 1);
this.arguments1ImplicitType = RubyTypesGen.getImplicitLongClass(arguments1Value);
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.arguments1ImplicitType == ((Compare0Node_) other).arguments1ImplicitType;
}
@Override
public Object execute(VirtualFrame frameValue) {
try {
return executeInt(frameValue);
} catch (UnexpectedResultException ex) {
return ex.getResult();
}
}
@Override
public int executeInt(VirtualFrame frameValue) throws UnexpectedResultException {
DynamicObject arguments0Value_;
try {
arguments0Value_ = root.arguments0_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object arguments1Value = executeArguments1_(frameValue);
return expectInteger(getNext().execute_(frameValue, ex.getResult(), arguments1Value));
}
long arguments1Value_;
try {
arguments1Value_ = executeArguments1Long_(frameValue, arguments1ImplicitType);
} catch (UnexpectedResultException ex) {
return expectInteger(getNext().execute_(frameValue, arguments0Value_, ex.getResult()));
}
if ((BigDecimalCoreMethodNode.isNormal(arguments0Value_))) {
return root.compare(arguments0Value_, arguments1Value_);
}
return expectInteger(getNext().execute_(frameValue, arguments0Value_, arguments1Value_));
}
@Override
public Object execute_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value) {
if (arguments0Value instanceof DynamicObject && RubyTypesGen.isImplicitLong(arguments1Value, arguments1ImplicitType)) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
long arguments1Value_ = RubyTypesGen.asImplicitLong(arguments1Value, arguments1ImplicitType);
if ((BigDecimalCoreMethodNode.isNormal(arguments0Value_))) {
return root.compare(arguments0Value_, arguments1Value_);
}
}
return getNext().execute_(frameValue, arguments0Value, arguments1Value);
}
static BaseNode_ create(CompareNodeGen root, Object arguments1Value) {
return new Compare0Node_(root, arguments1Value);
}
}
@GeneratedBy(methodName = "compare(DynamicObject, double)", value = CompareNode.class)
private static final class Compare1Node_ extends BaseNode_ {
private final Class arguments1ImplicitType;
Compare1Node_(CompareNodeGen root, Object arguments1Value) {
super(root, 2);
this.arguments1ImplicitType = RubyTypesGen.getImplicitDoubleClass(arguments1Value);
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.arguments1ImplicitType == ((Compare1Node_) other).arguments1ImplicitType;
}
@Override
public Object execute(VirtualFrame frameValue) {
try {
return executeInt(frameValue);
} catch (UnexpectedResultException ex) {
return ex.getResult();
}
}
@Override
public int executeInt(VirtualFrame frameValue) throws UnexpectedResultException {
DynamicObject arguments0Value_;
try {
arguments0Value_ = root.arguments0_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object arguments1Value = executeArguments1_(frameValue);
return expectInteger(getNext().execute_(frameValue, ex.getResult(), arguments1Value));
}
double arguments1Value_;
try {
if (arguments1ImplicitType == double.class) {
arguments1Value_ = root.arguments1_.executeDouble(frameValue);
} else {
Object arguments1Value__ = executeArguments1_(frameValue);
arguments1Value_ = RubyTypesGen.expectImplicitDouble(arguments1Value__, arguments1ImplicitType);
}
} catch (UnexpectedResultException ex) {
return expectInteger(getNext().execute_(frameValue, arguments0Value_, ex.getResult()));
}
if ((BigDecimalCoreMethodNode.isNormal(arguments0Value_))) {
return root.compare(arguments0Value_, arguments1Value_);
}
return expectInteger(getNext().execute_(frameValue, arguments0Value_, arguments1Value_));
}
@Override
public Object execute_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value) {
if (arguments0Value instanceof DynamicObject && RubyTypesGen.isImplicitDouble(arguments1Value, arguments1ImplicitType)) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
double arguments1Value_ = RubyTypesGen.asImplicitDouble(arguments1Value, arguments1ImplicitType);
if ((BigDecimalCoreMethodNode.isNormal(arguments0Value_))) {
return root.compare(arguments0Value_, arguments1Value_);
}
}
return getNext().execute_(frameValue, arguments0Value, arguments1Value);
}
static BaseNode_ create(CompareNodeGen root, Object arguments1Value) {
return new Compare1Node_(root, arguments1Value);
}
}
@GeneratedBy(methodName = "compare(DynamicObject, DynamicObject)", value = CompareNode.class)
private static final class Compare2Node_ extends BaseNode_ {
Compare2Node_(CompareNodeGen root) {
super(root, 3);
}
@Override
public int executeInt(VirtualFrame frameValue) throws UnexpectedResultException {
DynamicObject arguments0Value_;
try {
arguments0Value_ = root.arguments0_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object arguments1Value = executeArguments1_(frameValue);
return expectInteger(getNext().execute_(frameValue, ex.getResult(), arguments1Value));
}
DynamicObject arguments1Value_;
try {
arguments1Value_ = root.arguments1_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
return expectInteger(getNext().execute_(frameValue, arguments0Value_, ex.getResult()));
}
if ((BigDecimalCoreMethodNode.isNormal(arguments0Value_)) && (RubyGuards.isRubyBignum(arguments1Value_))) {
return root.compare(arguments0Value_, arguments1Value_);
}
return expectInteger(getNext().execute_(frameValue, arguments0Value_, arguments1Value_));
}
@Override
public Object execute_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value) {
if (arguments0Value instanceof DynamicObject && arguments1Value instanceof DynamicObject) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
DynamicObject arguments1Value_ = (DynamicObject) arguments1Value;
if ((BigDecimalCoreMethodNode.isNormal(arguments0Value_)) && (RubyGuards.isRubyBignum(arguments1Value_))) {
return root.compare(arguments0Value_, arguments1Value_);
}
}
return getNext().execute_(frameValue, arguments0Value, arguments1Value);
}
static BaseNode_ create(CompareNodeGen root) {
return new Compare2Node_(root);
}
}
@GeneratedBy(methodName = "compareNormal(DynamicObject, DynamicObject)", value = CompareNode.class)
private static final class CompareNormalNode_ extends BaseNode_ {
CompareNormalNode_(CompareNodeGen root) {
super(root, 4);
}
@Override
public int executeInt(VirtualFrame frameValue) throws UnexpectedResultException {
DynamicObject arguments0Value_;
try {
arguments0Value_ = root.arguments0_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object arguments1Value = executeArguments1_(frameValue);
return expectInteger(getNext().execute_(frameValue, ex.getResult(), arguments1Value));
}
DynamicObject arguments1Value_;
try {
arguments1Value_ = root.arguments1_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
return expectInteger(getNext().execute_(frameValue, arguments0Value_, ex.getResult()));
}
if ((BigDecimalCoreMethodNode.isNormal(arguments0Value_)) && (BigDecimalCoreMethodNode.isNormalRubyBigDecimal(arguments1Value_))) {
return root.compareNormal(arguments0Value_, arguments1Value_);
}
return expectInteger(getNext().execute_(frameValue, arguments0Value_, arguments1Value_));
}
@Override
public Object execute_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value) {
if (arguments0Value instanceof DynamicObject && arguments1Value instanceof DynamicObject) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
DynamicObject arguments1Value_ = (DynamicObject) arguments1Value;
if ((BigDecimalCoreMethodNode.isNormal(arguments0Value_)) && (BigDecimalCoreMethodNode.isNormalRubyBigDecimal(arguments1Value_))) {
return root.compareNormal(arguments0Value_, arguments1Value_);
}
}
return getNext().execute_(frameValue, arguments0Value, arguments1Value);
}
static BaseNode_ create(CompareNodeGen root) {
return new CompareNormalNode_(root);
}
}
@GeneratedBy(methodName = "compareSpecial(VirtualFrame, DynamicObject, long)", value = CompareNode.class)
private static final class CompareSpecial0Node_ extends BaseNode_ {
private final Class arguments1ImplicitType;
CompareSpecial0Node_(CompareNodeGen root, Object arguments1Value) {
super(root, 5);
this.arguments1ImplicitType = RubyTypesGen.getImplicitLongClass(arguments1Value);
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.arguments1ImplicitType == ((CompareSpecial0Node_) other).arguments1ImplicitType;
}
@Override
public Object execute(VirtualFrame frameValue) {
DynamicObject arguments0Value_;
try {
arguments0Value_ = root.arguments0_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object arguments1Value = executeArguments1_(frameValue);
return getNext().execute_(frameValue, ex.getResult(), arguments1Value);
}
long arguments1Value_;
try {
arguments1Value_ = executeArguments1Long_(frameValue, arguments1ImplicitType);
} catch (UnexpectedResultException ex) {
return getNext().execute_(frameValue, arguments0Value_, ex.getResult());
}
if ((!(BigDecimalCoreMethodNode.isNormal(arguments0Value_)))) {
return root.compareSpecial(frameValue, arguments0Value_, arguments1Value_);
}
return getNext().execute_(frameValue, arguments0Value_, arguments1Value_);
}
@Override
public Object execute_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value) {
if (arguments0Value instanceof DynamicObject && RubyTypesGen.isImplicitLong(arguments1Value, arguments1ImplicitType)) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
long arguments1Value_ = RubyTypesGen.asImplicitLong(arguments1Value, arguments1ImplicitType);
if ((!(BigDecimalCoreMethodNode.isNormal(arguments0Value_)))) {
return root.compareSpecial(frameValue, arguments0Value_, arguments1Value_);
}
}
return getNext().execute_(frameValue, arguments0Value, arguments1Value);
}
static BaseNode_ create(CompareNodeGen root, Object arguments1Value) {
return new CompareSpecial0Node_(root, arguments1Value);
}
}
@GeneratedBy(methodName = "compareSpecial(VirtualFrame, DynamicObject, double)", value = CompareNode.class)
private static final class CompareSpecial1Node_ extends BaseNode_ {
private final Class arguments1ImplicitType;
CompareSpecial1Node_(CompareNodeGen root, Object arguments1Value) {
super(root, 6);
this.arguments1ImplicitType = RubyTypesGen.getImplicitDoubleClass(arguments1Value);
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.arguments1ImplicitType == ((CompareSpecial1Node_) other).arguments1ImplicitType;
}
@Override
public Object execute(VirtualFrame frameValue) {
DynamicObject arguments0Value_;
try {
arguments0Value_ = root.arguments0_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object arguments1Value = executeArguments1_(frameValue);
return getNext().execute_(frameValue, ex.getResult(), arguments1Value);
}
double arguments1Value_;
try {
if (arguments1ImplicitType == double.class) {
arguments1Value_ = root.arguments1_.executeDouble(frameValue);
} else {
Object arguments1Value__ = executeArguments1_(frameValue);
arguments1Value_ = RubyTypesGen.expectImplicitDouble(arguments1Value__, arguments1ImplicitType);
}
} catch (UnexpectedResultException ex) {
return getNext().execute_(frameValue, arguments0Value_, ex.getResult());
}
if ((!(BigDecimalCoreMethodNode.isNormal(arguments0Value_)))) {
return root.compareSpecial(frameValue, arguments0Value_, arguments1Value_);
}
return getNext().execute_(frameValue, arguments0Value_, arguments1Value_);
}
@Override
public Object execute_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value) {
if (arguments0Value instanceof DynamicObject && RubyTypesGen.isImplicitDouble(arguments1Value, arguments1ImplicitType)) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
double arguments1Value_ = RubyTypesGen.asImplicitDouble(arguments1Value, arguments1ImplicitType);
if ((!(BigDecimalCoreMethodNode.isNormal(arguments0Value_)))) {
return root.compareSpecial(frameValue, arguments0Value_, arguments1Value_);
}
}
return getNext().execute_(frameValue, arguments0Value, arguments1Value);
}
static BaseNode_ create(CompareNodeGen root, Object arguments1Value) {
return new CompareSpecial1Node_(root, arguments1Value);
}
}
@GeneratedBy(methodName = "compareSpecialBignum(VirtualFrame, DynamicObject, DynamicObject)", value = CompareNode.class)
private static final class CompareSpecialBignumNode_ extends BaseNode_ {
CompareSpecialBignumNode_(CompareNodeGen root) {
super(root, 7);
}
@Override
public Object execute_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value) {
if (arguments0Value instanceof DynamicObject && arguments1Value instanceof DynamicObject) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
DynamicObject arguments1Value_ = (DynamicObject) arguments1Value;
if ((!(BigDecimalCoreMethodNode.isNormal(arguments0Value_))) && (RubyGuards.isRubyBignum(arguments1Value_))) {
return root.compareSpecialBignum(frameValue, arguments0Value_, arguments1Value_);
}
}
return getNext().execute_(frameValue, arguments0Value, arguments1Value);
}
static BaseNode_ create(CompareNodeGen root) {
return new CompareSpecialBignumNode_(root);
}
}
@GeneratedBy(methodName = "compareSpecialNan(DynamicObject, DynamicObject)", value = CompareNode.class)
private static final class CompareSpecialNanNode_ extends BaseNode_ {
CompareSpecialNanNode_(CompareNodeGen root) {
super(root, 8);
}
@Override
public Object execute_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value) {
if (arguments0Value instanceof DynamicObject && arguments1Value instanceof DynamicObject) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
DynamicObject arguments1Value_ = (DynamicObject) arguments1Value;
if ((!(BigDecimalCoreMethodNode.isNormal(arguments0Value_))) && (BigDecimalCoreMethodNode.isNan(arguments0Value_))) {
return root.compareSpecialNan(arguments0Value_, arguments1Value_);
}
}
return getNext().execute_(frameValue, arguments0Value, arguments1Value);
}
static BaseNode_ create(CompareNodeGen root) {
return new CompareSpecialNanNode_(root);
}
}
@GeneratedBy(methodName = "compareSpecial(DynamicObject, DynamicObject)", value = CompareNode.class)
private static final class CompareSpecial2Node_ extends BaseNode_ {
CompareSpecial2Node_(CompareNodeGen root) {
super(root, 9);
}
@Override
public Object execute_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value) {
if (arguments0Value instanceof DynamicObject && arguments1Value instanceof DynamicObject) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
DynamicObject arguments1Value_ = (DynamicObject) arguments1Value;
if ((RubyGuards.isRubyBigDecimal(arguments1Value_)) && (!(BigDecimalCoreMethodNode.isNormal(arguments0Value_)) || !(BigDecimalCoreMethodNode.isNormal(arguments1Value_))) && (BigDecimalCoreMethodNode.isNormal(arguments0Value_) || !(BigDecimalCoreMethodNode.isNan(arguments0Value_)))) {
return root.compareSpecial(arguments0Value_, arguments1Value_);
}
}
return getNext().execute_(frameValue, arguments0Value, arguments1Value);
}
static BaseNode_ create(CompareNodeGen root) {
return new CompareSpecial2Node_(root);
}
}
@GeneratedBy(methodName = "compareNil(DynamicObject, DynamicObject)", value = CompareNode.class)
private static final class CompareNilNode_ extends BaseNode_ {
CompareNilNode_(CompareNodeGen root) {
super(root, 10);
}
@Override
public Object execute_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value) {
if (arguments0Value instanceof DynamicObject && arguments1Value instanceof DynamicObject) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
DynamicObject arguments1Value_ = (DynamicObject) arguments1Value;
if ((root.isNil(arguments1Value_))) {
return root.compareNil(arguments0Value_, arguments1Value_);
}
}
return getNext().execute_(frameValue, arguments0Value, arguments1Value);
}
static BaseNode_ create(CompareNodeGen root) {
return new CompareNilNode_(root);
}
}
@GeneratedBy(methodName = "compareCoerced(VirtualFrame, DynamicObject, DynamicObject, SnippetNode)", value = CompareNode.class)
private static final class CompareCoercedNode_ extends BaseNode_ {
@Child private SnippetNode snippetNode;
CompareCoercedNode_(CompareNodeGen root, SnippetNode snippetNode) {
super(root, 11);
this.snippetNode = snippetNode;
}
@Override
public Object execute_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value) {
if (arguments0Value instanceof DynamicObject && arguments1Value instanceof DynamicObject) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
DynamicObject arguments1Value_ = (DynamicObject) arguments1Value;
if ((!(RubyGuards.isRubyBigDecimal(arguments1Value_))) && (!(root.isNil(arguments1Value_)))) {
return root.compareCoerced(frameValue, arguments0Value_, arguments1Value_, this.snippetNode);
}
}
return getNext().execute_(frameValue, arguments0Value, arguments1Value);
}
static BaseNode_ create(CompareNodeGen root, SnippetNode snippetNode) {
return new CompareCoercedNode_(root, snippetNode);
}
}
}
}
@GeneratedBy(ZeroNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class ZeroNodeFactory implements NodeFactory {
private static ZeroNodeFactory zeroNodeFactoryInstance;
private ZeroNodeFactory() {
}
@Override
public Class getNodeClass() {
return ZeroNode.class;
}
@Override
public List getExecutionSignature() {
return Arrays.asList(RubyNode.class);
}
@Override
public List getNodeSignatures() {
return Arrays.asList(Arrays.asList(RubyNode[].class));
}
@Override
public ZeroNode createNode(Object... arguments) {
if (arguments.length == 1 && (arguments[0] == null || arguments[0] instanceof RubyNode[])) {
return create((RubyNode[]) arguments[0]);
} else {
throw new IllegalArgumentException("Invalid create signature.");
}
}
public static NodeFactory getInstance() {
if (zeroNodeFactoryInstance == null) {
zeroNodeFactoryInstance = new ZeroNodeFactory();
}
return zeroNodeFactoryInstance;
}
public static ZeroNode create(RubyNode[] arguments) {
return new ZeroNodeGen(arguments);
}
@GeneratedBy(ZeroNode.class)
public static final class ZeroNodeGen extends ZeroNode implements SpecializedNode {
@Child private RubyNode arguments0_;
@Child private BaseNode_ specialization_;
private ZeroNodeGen(RubyNode[] arguments) {
this.arguments0_ = arguments != null && 0 < arguments.length ? arguments[0] : null;
this.specialization_ = UninitializedNode_.create(this);
}
@Override
public NodeCost getCost() {
return specialization_.getNodeCost();
}
@Override
public Object execute(VirtualFrame frameValue) {
return specialization_.execute(frameValue);
}
@Override
public void executeVoid(VirtualFrame frameValue) {
specialization_.executeVoid(frameValue);
return;
}
@Override
public boolean executeBoolean(VirtualFrame frameValue) {
return specialization_.executeBoolean(frameValue);
}
@Override
public SpecializationNode getSpecializationNode() {
return specialization_;
}
@Override
public Node deepCopy() {
return SpecializationNode.updateRoot(super.deepCopy());
}
@GeneratedBy(ZeroNode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected ZeroNodeGen root;
BaseNode_(ZeroNodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (ZeroNodeGen) root;
}
@Override
protected final Node[] getSuppliedChildren() {
return new Node[] {root.arguments0_};
}
@Override
public final Object acceptAndExecute(Frame frameValue, Object arguments0Value) {
return this.executeBoolean_((VirtualFrame) frameValue, arguments0Value);
}
public abstract boolean executeBoolean_(VirtualFrame frameValue, Object arguments0Value);
public Object execute(VirtualFrame frameValue) {
Object arguments0Value_ = root.arguments0_.execute(frameValue);
return executeBoolean_(frameValue, arguments0Value_);
}
public void executeVoid(VirtualFrame frameValue) {
execute(frameValue);
return;
}
public boolean executeBoolean(VirtualFrame frameValue) {
return (boolean) execute(frameValue);
}
@Override
protected final SpecializationNode createNext(Frame frameValue, Object arguments0Value) {
if (arguments0Value instanceof DynamicObject) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
if ((BigDecimalCoreMethodNode.isNormal(arguments0Value_))) {
return ZeroNormalNode_.create(root);
} else {
return ZeroSpecialNode_.create(root);
}
}
return null;
}
@Override
protected final SpecializationNode createPolymorphic() {
return PolymorphicNode_.create(root);
}
protected final BaseNode_ getNext() {
return (BaseNode_) this.next;
}
}
@GeneratedBy(ZeroNode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(ZeroNodeGen root) {
super(root, 2147483647);
}
@Override
public boolean executeBoolean_(VirtualFrame frameValue, Object arguments0Value) {
return (boolean) uninitialized(frameValue, arguments0Value);
}
static BaseNode_ create(ZeroNodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(ZeroNode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(ZeroNodeGen root) {
super(root, 0);
}
@Override
public SpecializationNode merge(SpecializationNode newNode, Frame frameValue, Object arguments0Value) {
return polymorphicMerge(newNode, super.merge(newNode, frameValue, arguments0Value));
}
@Override
public boolean executeBoolean(VirtualFrame frameValue) {
Object arguments0Value_ = root.arguments0_.execute(frameValue);
return getNext().executeBoolean_(frameValue, arguments0Value_);
}
@Override
public boolean executeBoolean_(VirtualFrame frameValue, Object arguments0Value) {
return getNext().executeBoolean_(frameValue, arguments0Value);
}
static BaseNode_ create(ZeroNodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "zeroNormal(DynamicObject)", value = ZeroNode.class)
private static final class ZeroNormalNode_ extends BaseNode_ {
ZeroNormalNode_(ZeroNodeGen root) {
super(root, 1);
}
@Override
public boolean executeBoolean(VirtualFrame frameValue) {
DynamicObject arguments0Value_;
try {
arguments0Value_ = root.arguments0_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
return getNext().executeBoolean_(frameValue, ex.getResult());
}
if ((BigDecimalCoreMethodNode.isNormal(arguments0Value_))) {
return root.zeroNormal(arguments0Value_);
}
return getNext().executeBoolean_(frameValue, arguments0Value_);
}
@Override
public boolean executeBoolean_(VirtualFrame frameValue, Object arguments0Value) {
if (arguments0Value instanceof DynamicObject) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
if ((BigDecimalCoreMethodNode.isNormal(arguments0Value_))) {
return root.zeroNormal(arguments0Value_);
}
}
return getNext().executeBoolean_(frameValue, arguments0Value);
}
static BaseNode_ create(ZeroNodeGen root) {
return new ZeroNormalNode_(root);
}
}
@GeneratedBy(methodName = "zeroSpecial(DynamicObject)", value = ZeroNode.class)
private static final class ZeroSpecialNode_ extends BaseNode_ {
ZeroSpecialNode_(ZeroNodeGen root) {
super(root, 2);
}
@Override
public boolean executeBoolean(VirtualFrame frameValue) {
DynamicObject arguments0Value_;
try {
arguments0Value_ = root.arguments0_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
return getNext().executeBoolean_(frameValue, ex.getResult());
}
if ((!(BigDecimalCoreMethodNode.isNormal(arguments0Value_)))) {
return root.zeroSpecial(arguments0Value_);
}
return getNext().executeBoolean_(frameValue, arguments0Value_);
}
@Override
public boolean executeBoolean_(VirtualFrame frameValue, Object arguments0Value) {
if (arguments0Value instanceof DynamicObject) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
if ((!(BigDecimalCoreMethodNode.isNormal(arguments0Value_)))) {
return root.zeroSpecial(arguments0Value_);
}
}
return getNext().executeBoolean_(frameValue, arguments0Value);
}
static BaseNode_ create(ZeroNodeGen root) {
return new ZeroSpecialNode_(root);
}
}
}
}
@GeneratedBy(SignNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class SignNodeFactory implements NodeFactory {
private static SignNodeFactory signNodeFactoryInstance;
private SignNodeFactory() {
}
@Override
public Class getNodeClass() {
return SignNode.class;
}
@Override
public List getExecutionSignature() {
return Arrays.asList(RubyNode.class);
}
@Override
public List getNodeSignatures() {
return Arrays.asList(Arrays.asList(RubyNode[].class));
}
@Override
public SignNode createNode(Object... arguments) {
if (arguments.length == 1 && (arguments[0] == null || arguments[0] instanceof RubyNode[])) {
return create((RubyNode[]) arguments[0]);
} else {
throw new IllegalArgumentException("Invalid create signature.");
}
}
public static NodeFactory getInstance() {
if (signNodeFactoryInstance == null) {
signNodeFactoryInstance = new SignNodeFactory();
}
return signNodeFactoryInstance;
}
public static SignNode create(RubyNode[] arguments) {
return new SignNodeGen(arguments);
}
@GeneratedBy(SignNode.class)
public static final class SignNodeGen extends SignNode implements SpecializedNode {
@Child private RubyNode arguments0_;
@Child private BaseNode_ specialization_;
private SignNodeGen(RubyNode[] arguments) {
this.arguments0_ = arguments != null && 0 < arguments.length ? arguments[0] : null;
this.specialization_ = UninitializedNode_.create(this);
}
@Override
public NodeCost getCost() {
return specialization_.getNodeCost();
}
@Override
public Object execute(VirtualFrame frameValue) {
return specialization_.execute(frameValue);
}
@Override
public void executeVoid(VirtualFrame frameValue) {
specialization_.executeVoid(frameValue);
return;
}
@Override
public int executeInteger(VirtualFrame frameValue) {
return specialization_.executeInt(frameValue);
}
@Override
public SpecializationNode getSpecializationNode() {
return specialization_;
}
@Override
public Node deepCopy() {
return SpecializationNode.updateRoot(super.deepCopy());
}
@GeneratedBy(SignNode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected SignNodeGen root;
BaseNode_(SignNodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (SignNodeGen) root;
}
@Override
protected final Node[] getSuppliedChildren() {
return new Node[] {root.arguments0_};
}
@Override
public final Object acceptAndExecute(Frame frameValue, Object arguments0Value) {
return this.executeInt_((VirtualFrame) frameValue, arguments0Value);
}
public abstract int executeInt_(VirtualFrame frameValue, Object arguments0Value);
public Object execute(VirtualFrame frameValue) {
Object arguments0Value_ = root.arguments0_.execute(frameValue);
return executeInt_(frameValue, arguments0Value_);
}
public void executeVoid(VirtualFrame frameValue) {
execute(frameValue);
return;
}
public int executeInt(VirtualFrame frameValue) {
return (int) execute(frameValue);
}
@Override
protected final SpecializationNode createNext(Frame frameValue, Object arguments0Value) {
if (arguments0Value instanceof DynamicObject) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
if ((BigDecimalCoreMethodNode.isNormal(arguments0Value_)) && (BigDecimalCoreMethodNode.isNormalZero(arguments0Value_))) {
return SignNormalZeroNode_.create(root);
}
if ((BigDecimalCoreMethodNode.isNormal(arguments0Value_)) && (!(BigDecimalCoreMethodNode.isNormalZero(arguments0Value_)))) {
ConditionProfile positiveProfile2 = (ConditionProfile.createBinaryProfile());
return SignNormalNode_.create(root, positiveProfile2);
}
if ((!(BigDecimalCoreMethodNode.isNormal(arguments0Value_)))) {
return SignSpecialNode_.create(root);
}
}
return null;
}
@Override
protected final SpecializationNode createPolymorphic() {
return PolymorphicNode_.create(root);
}
protected final BaseNode_ getNext() {
return (BaseNode_) this.next;
}
}
@GeneratedBy(SignNode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(SignNodeGen root) {
super(root, 2147483647);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value) {
return (int) uninitialized(frameValue, arguments0Value);
}
static BaseNode_ create(SignNodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(SignNode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(SignNodeGen root) {
super(root, 0);
}
@Override
public SpecializationNode merge(SpecializationNode newNode, Frame frameValue, Object arguments0Value) {
return polymorphicMerge(newNode, super.merge(newNode, frameValue, arguments0Value));
}
@Override
public int executeInt(VirtualFrame frameValue) {
Object arguments0Value_ = root.arguments0_.execute(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value) {
return getNext().executeInt_(frameValue, arguments0Value);
}
static BaseNode_ create(SignNodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "signNormalZero(VirtualFrame, DynamicObject)", value = SignNode.class)
private static final class SignNormalZeroNode_ extends BaseNode_ {
SignNormalZeroNode_(SignNodeGen root) {
super(root, 1);
}
@Override
public int executeInt(VirtualFrame frameValue) {
DynamicObject arguments0Value_;
try {
arguments0Value_ = root.arguments0_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
return getNext().executeInt_(frameValue, ex.getResult());
}
if ((BigDecimalCoreMethodNode.isNormal(arguments0Value_)) && (BigDecimalCoreMethodNode.isNormalZero(arguments0Value_))) {
return root.signNormalZero(frameValue, arguments0Value_);
}
return getNext().executeInt_(frameValue, arguments0Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value) {
if (arguments0Value instanceof DynamicObject) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
if ((BigDecimalCoreMethodNode.isNormal(arguments0Value_)) && (BigDecimalCoreMethodNode.isNormalZero(arguments0Value_))) {
return root.signNormalZero(frameValue, arguments0Value_);
}
}
return getNext().executeInt_(frameValue, arguments0Value);
}
static BaseNode_ create(SignNodeGen root) {
return new SignNormalZeroNode_(root);
}
}
@GeneratedBy(methodName = "signNormal(VirtualFrame, DynamicObject, ConditionProfile)", value = SignNode.class)
private static final class SignNormalNode_ extends BaseNode_ {
private final ConditionProfile positiveProfile;
SignNormalNode_(SignNodeGen root, ConditionProfile positiveProfile) {
super(root, 2);
this.positiveProfile = positiveProfile;
}
@Override
public int executeInt(VirtualFrame frameValue) {
DynamicObject arguments0Value_;
try {
arguments0Value_ = root.arguments0_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
return getNext().executeInt_(frameValue, ex.getResult());
}
if ((BigDecimalCoreMethodNode.isNormal(arguments0Value_)) && (!(BigDecimalCoreMethodNode.isNormalZero(arguments0Value_)))) {
return root.signNormal(frameValue, arguments0Value_, this.positiveProfile);
}
return getNext().executeInt_(frameValue, arguments0Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value) {
if (arguments0Value instanceof DynamicObject) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
if ((BigDecimalCoreMethodNode.isNormal(arguments0Value_)) && (!(BigDecimalCoreMethodNode.isNormalZero(arguments0Value_)))) {
return root.signNormal(frameValue, arguments0Value_, this.positiveProfile);
}
}
return getNext().executeInt_(frameValue, arguments0Value);
}
static BaseNode_ create(SignNodeGen root, ConditionProfile positiveProfile) {
return new SignNormalNode_(root, positiveProfile);
}
}
@GeneratedBy(methodName = "signSpecial(VirtualFrame, DynamicObject)", value = SignNode.class)
private static final class SignSpecialNode_ extends BaseNode_ {
SignSpecialNode_(SignNodeGen root) {
super(root, 3);
}
@Override
public int executeInt(VirtualFrame frameValue) {
DynamicObject arguments0Value_;
try {
arguments0Value_ = root.arguments0_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
return getNext().executeInt_(frameValue, ex.getResult());
}
if ((!(BigDecimalCoreMethodNode.isNormal(arguments0Value_)))) {
return root.signSpecial(frameValue, arguments0Value_);
}
return getNext().executeInt_(frameValue, arguments0Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value) {
if (arguments0Value instanceof DynamicObject) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
if ((!(BigDecimalCoreMethodNode.isNormal(arguments0Value_)))) {
return root.signSpecial(frameValue, arguments0Value_);
}
}
return getNext().executeInt_(frameValue, arguments0Value);
}
static BaseNode_ create(SignNodeGen root) {
return new SignSpecialNode_(root);
}
}
}
}
@GeneratedBy(NanNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class NanNodeFactory implements NodeFactory {
private static NanNodeFactory nanNodeFactoryInstance;
private NanNodeFactory() {
}
@Override
public Class getNodeClass() {
return NanNode.class;
}
@Override
public List getExecutionSignature() {
return Arrays.asList(RubyNode.class);
}
@Override
public List getNodeSignatures() {
return Arrays.asList(Arrays.asList(RubyNode[].class));
}
@Override
public NanNode createNode(Object... arguments) {
if (arguments.length == 1 && (arguments[0] == null || arguments[0] instanceof RubyNode[])) {
return create((RubyNode[]) arguments[0]);
} else {
throw new IllegalArgumentException("Invalid create signature.");
}
}
public static NodeFactory getInstance() {
if (nanNodeFactoryInstance == null) {
nanNodeFactoryInstance = new NanNodeFactory();
}
return nanNodeFactoryInstance;
}
public static NanNode create(RubyNode[] arguments) {
return new NanNodeGen(arguments);
}
@GeneratedBy(NanNode.class)
public static final class NanNodeGen extends NanNode implements SpecializedNode {
@Child private RubyNode arguments0_;
@Child private BaseNode_ specialization_;
private NanNodeGen(RubyNode[] arguments) {
this.arguments0_ = arguments != null && 0 < arguments.length ? arguments[0] : null;
this.specialization_ = UninitializedNode_.create(this);
}
@Override
public NodeCost getCost() {
return specialization_.getNodeCost();
}
@Override
public Object execute(VirtualFrame frameValue) {
return specialization_.execute(frameValue);
}
@Override
public void executeVoid(VirtualFrame frameValue) {
specialization_.executeVoid(frameValue);
return;
}
@Override
public boolean executeBoolean(VirtualFrame frameValue) {
return specialization_.executeBoolean(frameValue);
}
@Override
public SpecializationNode getSpecializationNode() {
return specialization_;
}
@Override
public Node deepCopy() {
return SpecializationNode.updateRoot(super.deepCopy());
}
@GeneratedBy(NanNode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected NanNodeGen root;
BaseNode_(NanNodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (NanNodeGen) root;
}
@Override
protected final Node[] getSuppliedChildren() {
return new Node[] {root.arguments0_};
}
@Override
public final Object acceptAndExecute(Frame frameValue, Object arguments0Value) {
return this.executeBoolean_((VirtualFrame) frameValue, arguments0Value);
}
public abstract boolean executeBoolean_(VirtualFrame frameValue, Object arguments0Value);
public Object execute(VirtualFrame frameValue) {
Object arguments0Value_ = root.arguments0_.execute(frameValue);
return executeBoolean_(frameValue, arguments0Value_);
}
public void executeVoid(VirtualFrame frameValue) {
execute(frameValue);
return;
}
public boolean executeBoolean(VirtualFrame frameValue) {
return (boolean) execute(frameValue);
}
@Override
protected final SpecializationNode createNext(Frame frameValue, Object arguments0Value) {
if (arguments0Value instanceof DynamicObject) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
if ((BigDecimalCoreMethodNode.isNormal(arguments0Value_))) {
return NanNormalNode_.create(root);
} else {
return NanSpecialNode_.create(root);
}
}
return null;
}
@Override
protected final SpecializationNode createPolymorphic() {
return PolymorphicNode_.create(root);
}
protected final BaseNode_ getNext() {
return (BaseNode_) this.next;
}
}
@GeneratedBy(NanNode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(NanNodeGen root) {
super(root, 2147483647);
}
@Override
public boolean executeBoolean_(VirtualFrame frameValue, Object arguments0Value) {
return (boolean) uninitialized(frameValue, arguments0Value);
}
static BaseNode_ create(NanNodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(NanNode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(NanNodeGen root) {
super(root, 0);
}
@Override
public SpecializationNode merge(SpecializationNode newNode, Frame frameValue, Object arguments0Value) {
return polymorphicMerge(newNode, super.merge(newNode, frameValue, arguments0Value));
}
@Override
public boolean executeBoolean(VirtualFrame frameValue) {
Object arguments0Value_ = root.arguments0_.execute(frameValue);
return getNext().executeBoolean_(frameValue, arguments0Value_);
}
@Override
public boolean executeBoolean_(VirtualFrame frameValue, Object arguments0Value) {
return getNext().executeBoolean_(frameValue, arguments0Value);
}
static BaseNode_ create(NanNodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "nanNormal(DynamicObject)", value = NanNode.class)
private static final class NanNormalNode_ extends BaseNode_ {
NanNormalNode_(NanNodeGen root) {
super(root, 1);
}
@Override
public boolean executeBoolean(VirtualFrame frameValue) {
DynamicObject arguments0Value_;
try {
arguments0Value_ = root.arguments0_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
return getNext().executeBoolean_(frameValue, ex.getResult());
}
if ((BigDecimalCoreMethodNode.isNormal(arguments0Value_))) {
return root.nanNormal(arguments0Value_);
}
return getNext().executeBoolean_(frameValue, arguments0Value_);
}
@Override
public boolean executeBoolean_(VirtualFrame frameValue, Object arguments0Value) {
if (arguments0Value instanceof DynamicObject) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
if ((BigDecimalCoreMethodNode.isNormal(arguments0Value_))) {
return root.nanNormal(arguments0Value_);
}
}
return getNext().executeBoolean_(frameValue, arguments0Value);
}
static BaseNode_ create(NanNodeGen root) {
return new NanNormalNode_(root);
}
}
@GeneratedBy(methodName = "nanSpecial(DynamicObject)", value = NanNode.class)
private static final class NanSpecialNode_ extends BaseNode_ {
NanSpecialNode_(NanNodeGen root) {
super(root, 2);
}
@Override
public boolean executeBoolean(VirtualFrame frameValue) {
DynamicObject arguments0Value_;
try {
arguments0Value_ = root.arguments0_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
return getNext().executeBoolean_(frameValue, ex.getResult());
}
if ((!(BigDecimalCoreMethodNode.isNormal(arguments0Value_)))) {
return root.nanSpecial(arguments0Value_);
}
return getNext().executeBoolean_(frameValue, arguments0Value_);
}
@Override
public boolean executeBoolean_(VirtualFrame frameValue, Object arguments0Value) {
if (arguments0Value instanceof DynamicObject) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
if ((!(BigDecimalCoreMethodNode.isNormal(arguments0Value_)))) {
return root.nanSpecial(arguments0Value_);
}
}
return getNext().executeBoolean_(frameValue, arguments0Value);
}
static BaseNode_ create(NanNodeGen root) {
return new NanSpecialNode_(root);
}
}
}
}
@GeneratedBy(ExponentNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class ExponentNodeFactory implements NodeFactory {
private static ExponentNodeFactory exponentNodeFactoryInstance;
private ExponentNodeFactory() {
}
@Override
public Class getNodeClass() {
return ExponentNode.class;
}
@Override
public List getExecutionSignature() {
return Arrays.asList(RubyNode.class);
}
@Override
public List getNodeSignatures() {
return Arrays.asList(Arrays.asList(RubyNode[].class));
}
@Override
public ExponentNode createNode(Object... arguments) {
if (arguments.length == 1 && (arguments[0] == null || arguments[0] instanceof RubyNode[])) {
return create((RubyNode[]) arguments[0]);
} else {
throw new IllegalArgumentException("Invalid create signature.");
}
}
public static NodeFactory getInstance() {
if (exponentNodeFactoryInstance == null) {
exponentNodeFactoryInstance = new ExponentNodeFactory();
}
return exponentNodeFactoryInstance;
}
public static ExponentNode create(RubyNode[] arguments) {
return new ExponentNodeGen(arguments);
}
@GeneratedBy(ExponentNode.class)
public static final class ExponentNodeGen extends ExponentNode implements SpecializedNode {
@Child private RubyNode arguments0_;
@Child private BaseNode_ specialization_;
private ExponentNodeGen(RubyNode[] arguments) {
this.arguments0_ = arguments != null && 0 < arguments.length ? arguments[0] : null;
this.specialization_ = UninitializedNode_.create(this);
}
@Override
public NodeCost getCost() {
return specialization_.getNodeCost();
}
@Override
public Object execute(VirtualFrame frameValue) {
return specialization_.execute(frameValue);
}
@Override
public void executeVoid(VirtualFrame frameValue) {
specialization_.executeVoid(frameValue);
return;
}
@Override
public int executeInteger(VirtualFrame frameValue) throws UnexpectedResultException {
return specialization_.executeInt(frameValue);
}
@Override
public long executeLong(VirtualFrame frameValue) throws UnexpectedResultException {
return specialization_.executeLong(frameValue);
}
@Override
public SpecializationNode getSpecializationNode() {
return specialization_;
}
@Override
public Node deepCopy() {
return SpecializationNode.updateRoot(super.deepCopy());
}
private static int expectInteger(Object value) throws UnexpectedResultException {
if (value instanceof Integer) {
return (int) value;
}
throw new UnexpectedResultException(value);
}
private static long expectLong(Object value) throws UnexpectedResultException {
if (value instanceof Long) {
return (long) value;
}
throw new UnexpectedResultException(value);
}
@GeneratedBy(ExponentNode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected ExponentNodeGen root;
BaseNode_(ExponentNodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (ExponentNodeGen) root;
}
@Override
protected final Node[] getSuppliedChildren() {
return new Node[] {root.arguments0_};
}
@Override
public final Object acceptAndExecute(Frame frameValue, Object arguments0Value) {
return this.execute_((VirtualFrame) frameValue, arguments0Value);
}
public abstract Object execute_(VirtualFrame frameValue, Object arguments0Value);
public Object execute(VirtualFrame frameValue) {
Object arguments0Value_ = root.arguments0_.execute(frameValue);
return execute_(frameValue, arguments0Value_);
}
public void executeVoid(VirtualFrame frameValue) {
execute(frameValue);
return;
}
public int executeInt(VirtualFrame frameValue) throws UnexpectedResultException {
return expectInteger(execute(frameValue));
}
public long executeLong(VirtualFrame frameValue) throws UnexpectedResultException {
return expectLong(execute(frameValue));
}
@Override
protected final SpecializationNode createNext(Frame frameValue, Object arguments0Value) {
if (arguments0Value instanceof DynamicObject) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
if ((BigDecimalCoreMethodNode.isNormal(arguments0Value_)) && (!(BigDecimalCoreMethodNode.isNormalZero(arguments0Value_)))) {
return ExponentNode_.create(root);
}
if ((BigDecimalCoreMethodNode.isNormal(arguments0Value_)) && (BigDecimalCoreMethodNode.isNormalZero(arguments0Value_))) {
return ExponentZeroNode_.create(root);
}
if ((!(BigDecimalCoreMethodNode.isNormal(arguments0Value_)))) {
return ExponentSpecialNode_.create(root);
}
}
return null;
}
@Override
protected final SpecializationNode createPolymorphic() {
return PolymorphicNode_.create(root);
}
protected final BaseNode_ getNext() {
return (BaseNode_) this.next;
}
}
@GeneratedBy(ExponentNode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(ExponentNodeGen root) {
super(root, 2147483647);
}
@Override
public Object execute_(VirtualFrame frameValue, Object arguments0Value) {
return uninitialized(frameValue, arguments0Value);
}
static BaseNode_ create(ExponentNodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(ExponentNode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(ExponentNodeGen root) {
super(root, 0);
}
@Override
public SpecializationNode merge(SpecializationNode newNode, Frame frameValue, Object arguments0Value) {
return polymorphicMerge(newNode, super.merge(newNode, frameValue, arguments0Value));
}
@Override
public Object execute_(VirtualFrame frameValue, Object arguments0Value) {
return getNext().execute_(frameValue, arguments0Value);
}
static BaseNode_ create(ExponentNodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "exponent(DynamicObject)", value = ExponentNode.class)
private static final class ExponentNode_ extends BaseNode_ {
ExponentNode_(ExponentNodeGen root) {
super(root, 1);
}
@Override
public long executeLong(VirtualFrame frameValue) throws UnexpectedResultException {
DynamicObject arguments0Value_;
try {
arguments0Value_ = root.arguments0_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
return expectLong(getNext().execute_(frameValue, ex.getResult()));
}
if ((BigDecimalCoreMethodNode.isNormal(arguments0Value_)) && (!(BigDecimalCoreMethodNode.isNormalZero(arguments0Value_)))) {
return root.exponent(arguments0Value_);
}
return expectLong(getNext().execute_(frameValue, arguments0Value_));
}
@Override
public Object execute_(VirtualFrame frameValue, Object arguments0Value) {
if (arguments0Value instanceof DynamicObject) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
if ((BigDecimalCoreMethodNode.isNormal(arguments0Value_)) && (!(BigDecimalCoreMethodNode.isNormalZero(arguments0Value_)))) {
return root.exponent(arguments0Value_);
}
}
return getNext().execute_(frameValue, arguments0Value);
}
static BaseNode_ create(ExponentNodeGen root) {
return new ExponentNode_(root);
}
}
@GeneratedBy(methodName = "exponentZero(DynamicObject)", value = ExponentNode.class)
private static final class ExponentZeroNode_ extends BaseNode_ {
ExponentZeroNode_(ExponentNodeGen root) {
super(root, 2);
}
@Override
public int executeInt(VirtualFrame frameValue) throws UnexpectedResultException {
DynamicObject arguments0Value_;
try {
arguments0Value_ = root.arguments0_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
return expectInteger(getNext().execute_(frameValue, ex.getResult()));
}
if ((BigDecimalCoreMethodNode.isNormal(arguments0Value_)) && (BigDecimalCoreMethodNode.isNormalZero(arguments0Value_))) {
return root.exponentZero(arguments0Value_);
}
return expectInteger(getNext().execute_(frameValue, arguments0Value_));
}
@Override
public Object execute_(VirtualFrame frameValue, Object arguments0Value) {
if (arguments0Value instanceof DynamicObject) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
if ((BigDecimalCoreMethodNode.isNormal(arguments0Value_)) && (BigDecimalCoreMethodNode.isNormalZero(arguments0Value_))) {
return root.exponentZero(arguments0Value_);
}
}
return getNext().execute_(frameValue, arguments0Value);
}
static BaseNode_ create(ExponentNodeGen root) {
return new ExponentZeroNode_(root);
}
}
@GeneratedBy(methodName = "exponentSpecial(DynamicObject)", value = ExponentNode.class)
private static final class ExponentSpecialNode_ extends BaseNode_ {
ExponentSpecialNode_(ExponentNodeGen root) {
super(root, 3);
}
@Override
public int executeInt(VirtualFrame frameValue) throws UnexpectedResultException {
DynamicObject arguments0Value_;
try {
arguments0Value_ = root.arguments0_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
return expectInteger(getNext().execute_(frameValue, ex.getResult()));
}
if ((!(BigDecimalCoreMethodNode.isNormal(arguments0Value_)))) {
return root.exponentSpecial(arguments0Value_);
}
return expectInteger(getNext().execute_(frameValue, arguments0Value_));
}
@Override
public Object execute_(VirtualFrame frameValue, Object arguments0Value) {
if (arguments0Value instanceof DynamicObject) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
if ((!(BigDecimalCoreMethodNode.isNormal(arguments0Value_)))) {
return root.exponentSpecial(arguments0Value_);
}
}
return getNext().execute_(frameValue, arguments0Value);
}
static BaseNode_ create(ExponentNodeGen root) {
return new ExponentSpecialNode_(root);
}
}
}
}
@GeneratedBy(AbsNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class AbsNodeFactory implements NodeFactory {
private static AbsNodeFactory absNodeFactoryInstance;
private AbsNodeFactory() {
}
@Override
public Class getNodeClass() {
return AbsNode.class;
}
@Override
public List getExecutionSignature() {
return Arrays.asList(RubyNode.class);
}
@Override
public List getNodeSignatures() {
return Arrays.asList(Arrays.asList(RubyNode[].class));
}
@Override
public AbsNode createNode(Object... arguments) {
if (arguments.length == 1 && (arguments[0] == null || arguments[0] instanceof RubyNode[])) {
return create((RubyNode[]) arguments[0]);
} else {
throw new IllegalArgumentException("Invalid create signature.");
}
}
public static NodeFactory getInstance() {
if (absNodeFactoryInstance == null) {
absNodeFactoryInstance = new AbsNodeFactory();
}
return absNodeFactoryInstance;
}
public static AbsNode create(RubyNode[] arguments) {
return new AbsNodeGen(arguments);
}
@GeneratedBy(AbsNode.class)
public static final class AbsNodeGen extends AbsNode implements SpecializedNode {
@Child private RubyNode arguments0_;
@Child private BaseNode_ specialization_;
private AbsNodeGen(RubyNode[] arguments) {
this.arguments0_ = arguments != null && 0 < arguments.length ? arguments[0] : null;
this.specialization_ = UninitializedNode_.create(this);
}
@Override
public NodeCost getCost() {
return specialization_.getNodeCost();
}
@Override
public Object execute(VirtualFrame frameValue) {
return specialization_.execute(frameValue);
}
@Override
public void executeVoid(VirtualFrame frameValue) {
specialization_.executeVoid(frameValue);
return;
}
@Override
public SpecializationNode getSpecializationNode() {
return specialization_;
}
@Override
public Node deepCopy() {
return SpecializationNode.updateRoot(super.deepCopy());
}
@GeneratedBy(AbsNode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected AbsNodeGen root;
BaseNode_(AbsNodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (AbsNodeGen) root;
}
@Override
protected final Node[] getSuppliedChildren() {
return new Node[] {root.arguments0_};
}
@Override
public final Object acceptAndExecute(Frame frameValue, Object arguments0Value) {
return this.execute_((VirtualFrame) frameValue, arguments0Value);
}
public abstract Object execute_(VirtualFrame frameValue, Object arguments0Value);
public Object execute(VirtualFrame frameValue) {
Object arguments0Value_ = root.arguments0_.execute(frameValue);
return execute_(frameValue, arguments0Value_);
}
public void executeVoid(VirtualFrame frameValue) {
execute(frameValue);
return;
}
@Override
protected final SpecializationNode createNext(Frame frameValue, Object arguments0Value) {
if (arguments0Value instanceof DynamicObject) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
if ((BigDecimalCoreMethodNode.isNormal(arguments0Value_))) {
return AbsNode_.create(root);
} else {
BranchProfile negInfProfile2 = (BranchProfile.create());
BranchProfile negZeroProfile2 = (BranchProfile.create());
BranchProfile posInfProfile2 = (BranchProfile.create());
return AbsSpecialNode_.create(root, negInfProfile2, negZeroProfile2, posInfProfile2);
}
}
return null;
}
@Override
protected final SpecializationNode createPolymorphic() {
return PolymorphicNode_.create(root);
}
protected final BaseNode_ getNext() {
return (BaseNode_) this.next;
}
}
@GeneratedBy(AbsNode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(AbsNodeGen root) {
super(root, 2147483647);
}
@Override
public Object execute_(VirtualFrame frameValue, Object arguments0Value) {
return uninitialized(frameValue, arguments0Value);
}
static BaseNode_ create(AbsNodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(AbsNode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(AbsNodeGen root) {
super(root, 0);
}
@Override
public SpecializationNode merge(SpecializationNode newNode, Frame frameValue, Object arguments0Value) {
return polymorphicMerge(newNode, super.merge(newNode, frameValue, arguments0Value));
}
@Override
public Object execute_(VirtualFrame frameValue, Object arguments0Value) {
return getNext().execute_(frameValue, arguments0Value);
}
static BaseNode_ create(AbsNodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "abs(VirtualFrame, DynamicObject)", value = AbsNode.class)
private static final class AbsNode_ extends BaseNode_ {
AbsNode_(AbsNodeGen root) {
super(root, 1);
}
@Override
public Object execute_(VirtualFrame frameValue, Object arguments0Value) {
if (arguments0Value instanceof DynamicObject) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
if ((BigDecimalCoreMethodNode.isNormal(arguments0Value_))) {
return root.abs(frameValue, arguments0Value_);
}
}
return getNext().execute_(frameValue, arguments0Value);
}
static BaseNode_ create(AbsNodeGen root) {
return new AbsNode_(root);
}
}
@GeneratedBy(methodName = "absSpecial(VirtualFrame, DynamicObject, BranchProfile, BranchProfile, BranchProfile)", value = AbsNode.class)
private static final class AbsSpecialNode_ extends BaseNode_ {
private final BranchProfile negInfProfile;
private final BranchProfile negZeroProfile;
private final BranchProfile posInfProfile;
AbsSpecialNode_(AbsNodeGen root, BranchProfile negInfProfile, BranchProfile negZeroProfile, BranchProfile posInfProfile) {
super(root, 2);
this.negInfProfile = negInfProfile;
this.negZeroProfile = negZeroProfile;
this.posInfProfile = posInfProfile;
}
@Override
public Object execute_(VirtualFrame frameValue, Object arguments0Value) {
if (arguments0Value instanceof DynamicObject) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
if ((!(BigDecimalCoreMethodNode.isNormal(arguments0Value_)))) {
return root.absSpecial(frameValue, arguments0Value_, this.negInfProfile, this.negZeroProfile, this.posInfProfile);
}
}
return getNext().execute_(frameValue, arguments0Value);
}
static BaseNode_ create(AbsNodeGen root, BranchProfile negInfProfile, BranchProfile negZeroProfile, BranchProfile posInfProfile) {
return new AbsSpecialNode_(root, negInfProfile, negZeroProfile, posInfProfile);
}
}
}
}
@GeneratedBy(RoundNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class RoundNodeFactory implements NodeFactory {
private static RoundNodeFactory roundNodeFactoryInstance;
private RoundNodeFactory() {
}
@Override
public Class getNodeClass() {
return RoundNode.class;
}
@Override
public List getExecutionSignature() {
return Arrays.asList(RubyNode.class, RubyNode.class, RubyNode.class);
}
@Override
public List getNodeSignatures() {
return Arrays.asList(Arrays.asList(RubyNode[].class));
}
@Override
public RoundNode createNode(Object... arguments) {
if (arguments.length == 1 && (arguments[0] == null || arguments[0] instanceof RubyNode[])) {
return create((RubyNode[]) arguments[0]);
} else {
throw new IllegalArgumentException("Invalid create signature.");
}
}
public static NodeFactory getInstance() {
if (roundNodeFactoryInstance == null) {
roundNodeFactoryInstance = new RoundNodeFactory();
}
return roundNodeFactoryInstance;
}
public static RoundNode create(RubyNode[] arguments) {
return new RoundNodeGen(arguments);
}
@GeneratedBy(RoundNode.class)
public static final class RoundNodeGen extends RoundNode implements SpecializedNode {
@Child private RubyNode arguments0_;
@Child private RubyNode arguments1_;
@Child private RubyNode arguments2_;
@CompilationFinal private Class arguments1Type_;
@CompilationFinal private Class arguments2Type_;
@Child private BaseNode_ specialization_;
private RoundNodeGen(RubyNode[] arguments) {
this.arguments0_ = arguments != null && 0 < arguments.length ? arguments[0] : null;
this.arguments1_ = arguments != null && 1 < arguments.length ? arguments[1] : null;
this.arguments2_ = arguments != null && 2 < arguments.length ? arguments[2] : null;
this.specialization_ = UninitializedNode_.create(this);
}
@Override
public NodeCost getCost() {
return specialization_.getNodeCost();
}
@Override
public Object execute(VirtualFrame frameValue) {
return specialization_.execute(frameValue);
}
@Override
public void executeVoid(VirtualFrame frameValue) {
specialization_.executeVoid(frameValue);
return;
}
@Override
public SpecializationNode getSpecializationNode() {
return specialization_;
}
@Override
public Node deepCopy() {
return SpecializationNode.updateRoot(super.deepCopy());
}
@GeneratedBy(RoundNode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected RoundNodeGen root;
BaseNode_(RoundNodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (RoundNodeGen) root;
}
@Override
protected final Node[] getSuppliedChildren() {
return new Node[] {root.arguments0_, root.arguments1_, root.arguments2_};
}
@Override
public final Object acceptAndExecute(Frame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value) {
return this.execute_((VirtualFrame) frameValue, arguments0Value, arguments1Value, arguments2Value);
}
public abstract Object execute_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value);
public Object execute(VirtualFrame frameValue) {
Object arguments0Value_ = root.arguments0_.execute(frameValue);
Object arguments1Value_ = executeArguments1_(frameValue);
Object arguments2Value_ = executeArguments2_(frameValue);
return execute_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_);
}
public void executeVoid(VirtualFrame frameValue) {
execute(frameValue);
return;
}
@Override
protected final SpecializationNode createNext(Frame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value) {
if (arguments0Value instanceof DynamicObject) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
if (arguments2Value instanceof NotProvided) {
if (arguments1Value instanceof NotProvided) {
if ((BigDecimalCoreMethodNode.isNormal(arguments0Value_))) {
FixnumOrBignumNode fixnumOrBignumNode1 = (new FixnumOrBignumNode());
return Round0Node_.create(root, fixnumOrBignumNode1);
}
}
if (RubyTypesGen.isImplicitInteger(arguments1Value)) {
if ((BigDecimalCoreMethodNode.isNormal(arguments0Value_))) {
return Round1Node_.create(root, arguments1Value);
}
}
}
if (RubyTypesGen.isImplicitInteger(arguments1Value) && RubyTypesGen.isImplicitInteger(arguments2Value)) {
if ((BigDecimalCoreMethodNode.isNormal(arguments0Value_))) {
return Round2Node_.create(root, arguments1Value, arguments2Value);
}
}
if (arguments1Value instanceof NotProvided) {
if ((!(BigDecimalCoreMethodNode.isNormal(arguments0Value_)))) {
FixnumOrBignumNode fixnumOrBignumNode4 = (new FixnumOrBignumNode());
BranchProfile negInfinityProfile4 = (BranchProfile.create());
BranchProfile posInfinityProfile4 = (BranchProfile.create());
BranchProfile negZeroProfile4 = (BranchProfile.create());
BranchProfile nanProfile4 = (BranchProfile.create());
return RoundSpecial0Node_.create(root, fixnumOrBignumNode4, negInfinityProfile4, posInfinityProfile4, negZeroProfile4, nanProfile4);
}
}
if ((!(BigDecimalCoreMethodNode.isNormal(arguments0Value_))) && (RubyGuards.wasProvided(arguments1Value))) {
return RoundSpecial1Node_.create(root);
}
}
return null;
}
@Override
protected final SpecializationNode createPolymorphic() {
return PolymorphicNode_.create(root);
}
protected final BaseNode_ getNext() {
return (BaseNode_) this.next;
}
protected final Object executeArguments1_(Frame frameValue) {
Class arguments1Type_ = root.arguments1Type_;
try {
if (arguments1Type_ == int.class) {
return root.arguments1_.executeInteger((VirtualFrame) frameValue);
} else if (arguments1Type_ == null) {
CompilerDirectives.transferToInterpreterAndInvalidate();
Class _type = Object.class;
try {
Object _value = root.arguments1_.execute((VirtualFrame) frameValue);
if (_value instanceof Integer) {
_type = int.class;
} else {
_type = Object.class;
}
return _value;
} finally {
root.arguments1Type_ = _type;
}
} else {
return root.arguments1_.execute((VirtualFrame) frameValue);
}
} catch (UnexpectedResultException ex) {
root.arguments1Type_ = Object.class;
return ex.getResult();
}
}
protected final Object executeArguments2_(Frame frameValue) {
Class arguments2Type_ = root.arguments2Type_;
try {
if (arguments2Type_ == int.class) {
return root.arguments2_.executeInteger((VirtualFrame) frameValue);
} else if (arguments2Type_ == null) {
CompilerDirectives.transferToInterpreterAndInvalidate();
Class _type = Object.class;
try {
Object _value = root.arguments2_.execute((VirtualFrame) frameValue);
if (_value instanceof Integer) {
_type = int.class;
} else {
_type = Object.class;
}
return _value;
} finally {
root.arguments2Type_ = _type;
}
} else {
return root.arguments2_.execute((VirtualFrame) frameValue);
}
} catch (UnexpectedResultException ex) {
root.arguments2Type_ = Object.class;
return ex.getResult();
}
}
}
@GeneratedBy(RoundNode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(RoundNodeGen root) {
super(root, 2147483647);
}
@Override
public Object execute_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value) {
return uninitialized(frameValue, arguments0Value, arguments1Value, arguments2Value);
}
static BaseNode_ create(RoundNodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(RoundNode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(RoundNodeGen root) {
super(root, 0);
}
@Override
public SpecializationNode merge(SpecializationNode newNode, Frame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value) {
return polymorphicMerge(newNode, super.merge(newNode, frameValue, arguments0Value, arguments1Value, arguments2Value));
}
@Override
public Object execute_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value) {
return getNext().execute_(frameValue, arguments0Value, arguments1Value, arguments2Value);
}
static BaseNode_ create(RoundNodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "round(VirtualFrame, DynamicObject, NotProvided, NotProvided, FixnumOrBignumNode)", value = RoundNode.class)
private static final class Round0Node_ extends BaseNode_ {
@Child private FixnumOrBignumNode fixnumOrBignumNode;
Round0Node_(RoundNodeGen root, FixnumOrBignumNode fixnumOrBignumNode) {
super(root, 1);
this.fixnumOrBignumNode = fixnumOrBignumNode;
}
@Override
public Object execute_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value) {
if (arguments0Value instanceof DynamicObject && arguments1Value instanceof NotProvided && arguments2Value instanceof NotProvided) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
NotProvided arguments1Value_ = (NotProvided) arguments1Value;
NotProvided arguments2Value_ = (NotProvided) arguments2Value;
if ((BigDecimalCoreMethodNode.isNormal(arguments0Value_))) {
return root.round(frameValue, arguments0Value_, arguments1Value_, arguments2Value_, this.fixnumOrBignumNode);
}
}
return getNext().execute_(frameValue, arguments0Value, arguments1Value, arguments2Value);
}
static BaseNode_ create(RoundNodeGen root, FixnumOrBignumNode fixnumOrBignumNode) {
return new Round0Node_(root, fixnumOrBignumNode);
}
}
@GeneratedBy(methodName = "round(VirtualFrame, DynamicObject, int, NotProvided)", value = RoundNode.class)
private static final class Round1Node_ extends BaseNode_ {
private final Class arguments1ImplicitType;
Round1Node_(RoundNodeGen root, Object arguments1Value) {
super(root, 2);
this.arguments1ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments1Value);
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.arguments1ImplicitType == ((Round1Node_) other).arguments1ImplicitType;
}
@Override
public Object execute(VirtualFrame frameValue) {
DynamicObject arguments0Value_;
try {
arguments0Value_ = root.arguments0_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object arguments1Value = executeArguments1_(frameValue);
Object arguments2Value = executeArguments2_(frameValue);
return getNext().execute_(frameValue, ex.getResult(), arguments1Value, arguments2Value);
}
int arguments1Value_;
try {
if (arguments1ImplicitType == int.class) {
arguments1Value_ = root.arguments1_.executeInteger(frameValue);
} else {
Object arguments1Value__ = executeArguments1_(frameValue);
arguments1Value_ = RubyTypesGen.expectImplicitInteger(arguments1Value__, arguments1ImplicitType);
}
} catch (UnexpectedResultException ex) {
Object arguments2Value = executeArguments2_(frameValue);
return getNext().execute_(frameValue, arguments0Value_, ex.getResult(), arguments2Value);
}
NotProvided arguments2Value_;
try {
arguments2Value_ = root.arguments2_.executeNotProvided(frameValue);
} catch (UnexpectedResultException ex) {
return getNext().execute_(frameValue, arguments0Value_, arguments1Value_, ex.getResult());
}
if ((BigDecimalCoreMethodNode.isNormal(arguments0Value_))) {
return root.round(frameValue, arguments0Value_, arguments1Value_, arguments2Value_);
}
return getNext().execute_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_);
}
@Override
public Object execute_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value) {
if (arguments0Value instanceof DynamicObject && RubyTypesGen.isImplicitInteger(arguments1Value, arguments1ImplicitType) && arguments2Value instanceof NotProvided) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
int arguments1Value_ = RubyTypesGen.asImplicitInteger(arguments1Value, arguments1ImplicitType);
NotProvided arguments2Value_ = (NotProvided) arguments2Value;
if ((BigDecimalCoreMethodNode.isNormal(arguments0Value_))) {
return root.round(frameValue, arguments0Value_, arguments1Value_, arguments2Value_);
}
}
return getNext().execute_(frameValue, arguments0Value, arguments1Value, arguments2Value);
}
static BaseNode_ create(RoundNodeGen root, Object arguments1Value) {
return new Round1Node_(root, arguments1Value);
}
}
@GeneratedBy(methodName = "round(VirtualFrame, DynamicObject, int, int)", value = RoundNode.class)
private static final class Round2Node_ extends BaseNode_ {
private final Class arguments1ImplicitType;
private final Class arguments2ImplicitType;
Round2Node_(RoundNodeGen root, Object arguments1Value, Object arguments2Value) {
super(root, 3);
this.arguments1ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments1Value);
this.arguments2ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments2Value);
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.arguments1ImplicitType == ((Round2Node_) other).arguments1ImplicitType && this.arguments2ImplicitType == ((Round2Node_) other).arguments2ImplicitType;
}
@Override
public Object execute(VirtualFrame frameValue) {
DynamicObject arguments0Value_;
try {
arguments0Value_ = root.arguments0_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object arguments1Value = executeArguments1_(frameValue);
Object arguments2Value = executeArguments2_(frameValue);
return getNext().execute_(frameValue, ex.getResult(), arguments1Value, arguments2Value);
}
int arguments1Value_;
try {
if (arguments1ImplicitType == int.class) {
arguments1Value_ = root.arguments1_.executeInteger(frameValue);
} else {
Object arguments1Value__ = executeArguments1_(frameValue);
arguments1Value_ = RubyTypesGen.expectImplicitInteger(arguments1Value__, arguments1ImplicitType);
}
} catch (UnexpectedResultException ex) {
Object arguments2Value = executeArguments2_(frameValue);
return getNext().execute_(frameValue, arguments0Value_, ex.getResult(), arguments2Value);
}
int arguments2Value_;
try {
if (arguments2ImplicitType == int.class) {
arguments2Value_ = root.arguments2_.executeInteger(frameValue);
} else {
Object arguments2Value__ = executeArguments2_(frameValue);
arguments2Value_ = RubyTypesGen.expectImplicitInteger(arguments2Value__, arguments2ImplicitType);
}
} catch (UnexpectedResultException ex) {
return getNext().execute_(frameValue, arguments0Value_, arguments1Value_, ex.getResult());
}
if ((BigDecimalCoreMethodNode.isNormal(arguments0Value_))) {
return root.round(frameValue, arguments0Value_, arguments1Value_, arguments2Value_);
}
return getNext().execute_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_);
}
@Override
public Object execute_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value) {
if (arguments0Value instanceof DynamicObject && RubyTypesGen.isImplicitInteger(arguments1Value, arguments1ImplicitType) && RubyTypesGen.isImplicitInteger(arguments2Value, arguments2ImplicitType)) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
int arguments1Value_ = RubyTypesGen.asImplicitInteger(arguments1Value, arguments1ImplicitType);
int arguments2Value_ = RubyTypesGen.asImplicitInteger(arguments2Value, arguments2ImplicitType);
if ((BigDecimalCoreMethodNode.isNormal(arguments0Value_))) {
return root.round(frameValue, arguments0Value_, arguments1Value_, arguments2Value_);
}
}
return getNext().execute_(frameValue, arguments0Value, arguments1Value, arguments2Value);
}
static BaseNode_ create(RoundNodeGen root, Object arguments1Value, Object arguments2Value) {
return new Round2Node_(root, arguments1Value, arguments2Value);
}
}
@GeneratedBy(methodName = "roundSpecial(DynamicObject, NotProvided, Object, FixnumOrBignumNode, BranchProfile, BranchProfile, BranchProfile, BranchProfile)", value = RoundNode.class)
private static final class RoundSpecial0Node_ extends BaseNode_ {
@Child private FixnumOrBignumNode fixnumOrBignumNode;
private final BranchProfile negInfinityProfile;
private final BranchProfile posInfinityProfile;
private final BranchProfile negZeroProfile;
private final BranchProfile nanProfile;
RoundSpecial0Node_(RoundNodeGen root, FixnumOrBignumNode fixnumOrBignumNode, BranchProfile negInfinityProfile, BranchProfile posInfinityProfile, BranchProfile negZeroProfile, BranchProfile nanProfile) {
super(root, 4);
this.fixnumOrBignumNode = fixnumOrBignumNode;
this.negInfinityProfile = negInfinityProfile;
this.posInfinityProfile = posInfinityProfile;
this.negZeroProfile = negZeroProfile;
this.nanProfile = nanProfile;
}
@Override
public Object execute_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value) {
if (arguments0Value instanceof DynamicObject && arguments1Value instanceof NotProvided) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
NotProvided arguments1Value_ = (NotProvided) arguments1Value;
if ((!(BigDecimalCoreMethodNode.isNormal(arguments0Value_)))) {
return root.roundSpecial(arguments0Value_, arguments1Value_, arguments2Value, this.fixnumOrBignumNode, this.negInfinityProfile, this.posInfinityProfile, this.negZeroProfile, this.nanProfile);
}
}
return getNext().execute_(frameValue, arguments0Value, arguments1Value, arguments2Value);
}
static BaseNode_ create(RoundNodeGen root, FixnumOrBignumNode fixnumOrBignumNode, BranchProfile negInfinityProfile, BranchProfile posInfinityProfile, BranchProfile negZeroProfile, BranchProfile nanProfile) {
return new RoundSpecial0Node_(root, fixnumOrBignumNode, negInfinityProfile, posInfinityProfile, negZeroProfile, nanProfile);
}
}
@GeneratedBy(methodName = "roundSpecial(DynamicObject, Object, Object)", value = RoundNode.class)
private static final class RoundSpecial1Node_ extends BaseNode_ {
RoundSpecial1Node_(RoundNodeGen root) {
super(root, 5);
}
@Override
public Object execute_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value) {
if (arguments0Value instanceof DynamicObject) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
if ((!(BigDecimalCoreMethodNode.isNormal(arguments0Value_))) && (RubyGuards.wasProvided(arguments1Value))) {
return root.roundSpecial(arguments0Value_, arguments1Value, arguments2Value);
}
}
return getNext().execute_(frameValue, arguments0Value, arguments1Value, arguments2Value);
}
static BaseNode_ create(RoundNodeGen root) {
return new RoundSpecial1Node_(root);
}
}
}
}
@GeneratedBy(FiniteNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class FiniteNodeFactory implements NodeFactory {
private static FiniteNodeFactory finiteNodeFactoryInstance;
private FiniteNodeFactory() {
}
@Override
public Class getNodeClass() {
return FiniteNode.class;
}
@Override
public List getExecutionSignature() {
return Arrays.asList(RubyNode.class);
}
@Override
public List getNodeSignatures() {
return Arrays.asList(Arrays.asList(RubyNode[].class));
}
@Override
public FiniteNode createNode(Object... arguments) {
if (arguments.length == 1 && (arguments[0] == null || arguments[0] instanceof RubyNode[])) {
return create((RubyNode[]) arguments[0]);
} else {
throw new IllegalArgumentException("Invalid create signature.");
}
}
public static NodeFactory getInstance() {
if (finiteNodeFactoryInstance == null) {
finiteNodeFactoryInstance = new FiniteNodeFactory();
}
return finiteNodeFactoryInstance;
}
public static FiniteNode create(RubyNode[] arguments) {
return new FiniteNodeGen(arguments);
}
@GeneratedBy(FiniteNode.class)
public static final class FiniteNodeGen extends FiniteNode implements SpecializedNode {
@Child private RubyNode arguments0_;
@Child private BaseNode_ specialization_;
private FiniteNodeGen(RubyNode[] arguments) {
this.arguments0_ = arguments != null && 0 < arguments.length ? arguments[0] : null;
this.specialization_ = UninitializedNode_.create(this);
}
@Override
public NodeCost getCost() {
return specialization_.getNodeCost();
}
@Override
public Object execute(VirtualFrame frameValue) {
return specialization_.execute(frameValue);
}
@Override
public void executeVoid(VirtualFrame frameValue) {
specialization_.executeVoid(frameValue);
return;
}
@Override
public boolean executeBoolean(VirtualFrame frameValue) {
return specialization_.executeBoolean(frameValue);
}
@Override
public SpecializationNode getSpecializationNode() {
return specialization_;
}
@Override
public Node deepCopy() {
return SpecializationNode.updateRoot(super.deepCopy());
}
@GeneratedBy(FiniteNode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected FiniteNodeGen root;
BaseNode_(FiniteNodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (FiniteNodeGen) root;
}
@Override
protected final Node[] getSuppliedChildren() {
return new Node[] {root.arguments0_};
}
@Override
public final Object acceptAndExecute(Frame frameValue, Object arguments0Value) {
return this.executeBoolean_((VirtualFrame) frameValue, arguments0Value);
}
public abstract boolean executeBoolean_(VirtualFrame frameValue, Object arguments0Value);
public Object execute(VirtualFrame frameValue) {
Object arguments0Value_ = root.arguments0_.execute(frameValue);
return executeBoolean_(frameValue, arguments0Value_);
}
public void executeVoid(VirtualFrame frameValue) {
execute(frameValue);
return;
}
public boolean executeBoolean(VirtualFrame frameValue) {
return (boolean) execute(frameValue);
}
@Override
protected final SpecializationNode createNext(Frame frameValue, Object arguments0Value) {
if (arguments0Value instanceof DynamicObject) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
if ((BigDecimalCoreMethodNode.isNormal(arguments0Value_))) {
return FiniteNormalNode_.create(root);
} else {
return FiniteSpecialNode_.create(root);
}
}
return null;
}
@Override
protected final SpecializationNode createPolymorphic() {
return PolymorphicNode_.create(root);
}
protected final BaseNode_ getNext() {
return (BaseNode_) this.next;
}
}
@GeneratedBy(FiniteNode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(FiniteNodeGen root) {
super(root, 2147483647);
}
@Override
public boolean executeBoolean_(VirtualFrame frameValue, Object arguments0Value) {
return (boolean) uninitialized(frameValue, arguments0Value);
}
static BaseNode_ create(FiniteNodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(FiniteNode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(FiniteNodeGen root) {
super(root, 0);
}
@Override
public SpecializationNode merge(SpecializationNode newNode, Frame frameValue, Object arguments0Value) {
return polymorphicMerge(newNode, super.merge(newNode, frameValue, arguments0Value));
}
@Override
public boolean executeBoolean(VirtualFrame frameValue) {
Object arguments0Value_ = root.arguments0_.execute(frameValue);
return getNext().executeBoolean_(frameValue, arguments0Value_);
}
@Override
public boolean executeBoolean_(VirtualFrame frameValue, Object arguments0Value) {
return getNext().executeBoolean_(frameValue, arguments0Value);
}
static BaseNode_ create(FiniteNodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "finiteNormal(DynamicObject)", value = FiniteNode.class)
private static final class FiniteNormalNode_ extends BaseNode_ {
FiniteNormalNode_(FiniteNodeGen root) {
super(root, 1);
}
@Override
public boolean executeBoolean(VirtualFrame frameValue) {
DynamicObject arguments0Value_;
try {
arguments0Value_ = root.arguments0_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
return getNext().executeBoolean_(frameValue, ex.getResult());
}
if ((BigDecimalCoreMethodNode.isNormal(arguments0Value_))) {
return root.finiteNormal(arguments0Value_);
}
return getNext().executeBoolean_(frameValue, arguments0Value_);
}
@Override
public boolean executeBoolean_(VirtualFrame frameValue, Object arguments0Value) {
if (arguments0Value instanceof DynamicObject) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
if ((BigDecimalCoreMethodNode.isNormal(arguments0Value_))) {
return root.finiteNormal(arguments0Value_);
}
}
return getNext().executeBoolean_(frameValue, arguments0Value);
}
static BaseNode_ create(FiniteNodeGen root) {
return new FiniteNormalNode_(root);
}
}
@GeneratedBy(methodName = "finiteSpecial(DynamicObject)", value = FiniteNode.class)
private static final class FiniteSpecialNode_ extends BaseNode_ {
FiniteSpecialNode_(FiniteNodeGen root) {
super(root, 2);
}
@Override
public boolean executeBoolean(VirtualFrame frameValue) {
DynamicObject arguments0Value_;
try {
arguments0Value_ = root.arguments0_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
return getNext().executeBoolean_(frameValue, ex.getResult());
}
if ((!(BigDecimalCoreMethodNode.isNormal(arguments0Value_)))) {
return root.finiteSpecial(arguments0Value_);
}
return getNext().executeBoolean_(frameValue, arguments0Value_);
}
@Override
public boolean executeBoolean_(VirtualFrame frameValue, Object arguments0Value) {
if (arguments0Value instanceof DynamicObject) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
if ((!(BigDecimalCoreMethodNode.isNormal(arguments0Value_)))) {
return root.finiteSpecial(arguments0Value_);
}
}
return getNext().executeBoolean_(frameValue, arguments0Value);
}
static BaseNode_ create(FiniteNodeGen root) {
return new FiniteSpecialNode_(root);
}
}
}
}
@GeneratedBy(InfiniteNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class InfiniteNodeFactory implements NodeFactory {
private static InfiniteNodeFactory infiniteNodeFactoryInstance;
private InfiniteNodeFactory() {
}
@Override
public Class getNodeClass() {
return InfiniteNode.class;
}
@Override
public List getExecutionSignature() {
return Arrays.asList(RubyNode.class);
}
@Override
public List getNodeSignatures() {
return Arrays.asList(Arrays.asList(RubyNode[].class));
}
@Override
public InfiniteNode createNode(Object... arguments) {
if (arguments.length == 1 && (arguments[0] == null || arguments[0] instanceof RubyNode[])) {
return create((RubyNode[]) arguments[0]);
} else {
throw new IllegalArgumentException("Invalid create signature.");
}
}
public static NodeFactory getInstance() {
if (infiniteNodeFactoryInstance == null) {
infiniteNodeFactoryInstance = new InfiniteNodeFactory();
}
return infiniteNodeFactoryInstance;
}
public static InfiniteNode create(RubyNode[] arguments) {
return new InfiniteNodeGen(arguments);
}
@GeneratedBy(InfiniteNode.class)
public static final class InfiniteNodeGen extends InfiniteNode implements SpecializedNode {
@Child private RubyNode arguments0_;
@Child private BaseNode_ specialization_;
private InfiniteNodeGen(RubyNode[] arguments) {
this.arguments0_ = arguments != null && 0 < arguments.length ? arguments[0] : null;
this.specialization_ = UninitializedNode_.create(this);
}
@Override
public NodeCost getCost() {
return specialization_.getNodeCost();
}
@Override
public Object execute(VirtualFrame frameValue) {
return specialization_.execute(frameValue);
}
@Override
public void executeVoid(VirtualFrame frameValue) {
specialization_.executeVoid(frameValue);
return;
}
@Override
public SpecializationNode getSpecializationNode() {
return specialization_;
}
@Override
public Node deepCopy() {
return SpecializationNode.updateRoot(super.deepCopy());
}
@GeneratedBy(InfiniteNode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected InfiniteNodeGen root;
BaseNode_(InfiniteNodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (InfiniteNodeGen) root;
}
@Override
protected final Node[] getSuppliedChildren() {
return new Node[] {root.arguments0_};
}
@Override
public final Object acceptAndExecute(Frame frameValue, Object arguments0Value) {
return this.execute_((VirtualFrame) frameValue, arguments0Value);
}
public abstract Object execute_(VirtualFrame frameValue, Object arguments0Value);
public Object execute(VirtualFrame frameValue) {
Object arguments0Value_ = root.arguments0_.execute(frameValue);
return execute_(frameValue, arguments0Value_);
}
public void executeVoid(VirtualFrame frameValue) {
execute(frameValue);
return;
}
@Override
protected final SpecializationNode createNext(Frame frameValue, Object arguments0Value) {
if (arguments0Value instanceof DynamicObject) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
if ((BigDecimalCoreMethodNode.isNormal(arguments0Value_))) {
return InfiniteNormalNode_.create(root);
} else {
return InfiniteSpecialNode_.create(root);
}
}
return null;
}
@Override
protected final SpecializationNode createPolymorphic() {
return PolymorphicNode_.create(root);
}
protected final BaseNode_ getNext() {
return (BaseNode_) this.next;
}
}
@GeneratedBy(InfiniteNode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(InfiniteNodeGen root) {
super(root, 2147483647);
}
@Override
public Object execute_(VirtualFrame frameValue, Object arguments0Value) {
return uninitialized(frameValue, arguments0Value);
}
static BaseNode_ create(InfiniteNodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(InfiniteNode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(InfiniteNodeGen root) {
super(root, 0);
}
@Override
public SpecializationNode merge(SpecializationNode newNode, Frame frameValue, Object arguments0Value) {
return polymorphicMerge(newNode, super.merge(newNode, frameValue, arguments0Value));
}
@Override
public Object execute_(VirtualFrame frameValue, Object arguments0Value) {
return getNext().execute_(frameValue, arguments0Value);
}
static BaseNode_ create(InfiniteNodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "infiniteNormal(DynamicObject)", value = InfiniteNode.class)
private static final class InfiniteNormalNode_ extends BaseNode_ {
InfiniteNormalNode_(InfiniteNodeGen root) {
super(root, 1);
}
@Override
public Object execute_(VirtualFrame frameValue, Object arguments0Value) {
if (arguments0Value instanceof DynamicObject) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
if ((BigDecimalCoreMethodNode.isNormal(arguments0Value_))) {
return root.infiniteNormal(arguments0Value_);
}
}
return getNext().execute_(frameValue, arguments0Value);
}
static BaseNode_ create(InfiniteNodeGen root) {
return new InfiniteNormalNode_(root);
}
}
@GeneratedBy(methodName = "infiniteSpecial(DynamicObject)", value = InfiniteNode.class)
private static final class InfiniteSpecialNode_ extends BaseNode_ {
InfiniteSpecialNode_(InfiniteNodeGen root) {
super(root, 2);
}
@Override
public Object execute_(VirtualFrame frameValue, Object arguments0Value) {
if (arguments0Value instanceof DynamicObject) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
if ((!(BigDecimalCoreMethodNode.isNormal(arguments0Value_)))) {
return root.infiniteSpecial(arguments0Value_);
}
}
return getNext().execute_(frameValue, arguments0Value);
}
static BaseNode_ create(InfiniteNodeGen root) {
return new InfiniteSpecialNode_(root);
}
}
}
}
@GeneratedBy(PrecsNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class PrecsNodeFactory implements NodeFactory {
private static PrecsNodeFactory precsNodeFactoryInstance;
private PrecsNodeFactory() {
}
@Override
public Class getNodeClass() {
return PrecsNode.class;
}
@Override
public List getExecutionSignature() {
return Arrays.asList(RubyNode.class);
}
@Override
public List getNodeSignatures() {
return Arrays.asList(Arrays.asList(RubyNode[].class));
}
@Override
public PrecsNode createNode(Object... arguments) {
if (arguments.length == 1 && (arguments[0] == null || arguments[0] instanceof RubyNode[])) {
return create((RubyNode[]) arguments[0]);
} else {
throw new IllegalArgumentException("Invalid create signature.");
}
}
public static NodeFactory getInstance() {
if (precsNodeFactoryInstance == null) {
precsNodeFactoryInstance = new PrecsNodeFactory();
}
return precsNodeFactoryInstance;
}
public static PrecsNode create(RubyNode[] arguments) {
return new PrecsNodeGen(arguments);
}
@GeneratedBy(PrecsNode.class)
public static final class PrecsNodeGen extends PrecsNode implements SpecializedNode {
@Child private RubyNode arguments0_;
@Child private BaseNode_ specialization_;
private PrecsNodeGen(RubyNode[] arguments) {
this.arguments0_ = arguments != null && 0 < arguments.length ? arguments[0] : null;
this.specialization_ = UninitializedNode_.create(this);
}
@Override
public NodeCost getCost() {
return specialization_.getNodeCost();
}
@Override
public Object execute(VirtualFrame frameValue) {
return specialization_.execute(frameValue);
}
@Override
public void executeVoid(VirtualFrame frameValue) {
specialization_.executeVoid(frameValue);
return;
}
@Override
public SpecializationNode getSpecializationNode() {
return specialization_;
}
@Override
public Node deepCopy() {
return SpecializationNode.updateRoot(super.deepCopy());
}
@GeneratedBy(PrecsNode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected PrecsNodeGen root;
BaseNode_(PrecsNodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (PrecsNodeGen) root;
}
@Override
protected final Node[] getSuppliedChildren() {
return new Node[] {root.arguments0_};
}
@Override
public final Object acceptAndExecute(Frame frameValue, Object arguments0Value) {
return this.execute_((VirtualFrame) frameValue, arguments0Value);
}
public abstract Object execute_(VirtualFrame frameValue, Object arguments0Value);
public Object execute(VirtualFrame frameValue) {
Object arguments0Value_ = root.arguments0_.execute(frameValue);
return execute_(frameValue, arguments0Value_);
}
public void executeVoid(VirtualFrame frameValue) {
execute(frameValue);
return;
}
@Override
protected final SpecializationNode createNext(Frame frameValue, Object arguments0Value) {
if (arguments0Value instanceof DynamicObject) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
if ((BigDecimalCoreMethodNode.isNormal(arguments0Value_))) {
return PrecsNormalNode_.create(root);
} else {
return PrecsSpecialNode_.create(root);
}
}
return null;
}
@Override
protected final SpecializationNode createPolymorphic() {
return PolymorphicNode_.create(root);
}
protected final BaseNode_ getNext() {
return (BaseNode_) this.next;
}
}
@GeneratedBy(PrecsNode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(PrecsNodeGen root) {
super(root, 2147483647);
}
@Override
public Object execute_(VirtualFrame frameValue, Object arguments0Value) {
return uninitialized(frameValue, arguments0Value);
}
static BaseNode_ create(PrecsNodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(PrecsNode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(PrecsNodeGen root) {
super(root, 0);
}
@Override
public SpecializationNode merge(SpecializationNode newNode, Frame frameValue, Object arguments0Value) {
return polymorphicMerge(newNode, super.merge(newNode, frameValue, arguments0Value));
}
@Override
public Object execute_(VirtualFrame frameValue, Object arguments0Value) {
return getNext().execute_(frameValue, arguments0Value);
}
static BaseNode_ create(PrecsNodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "precsNormal(DynamicObject)", value = PrecsNode.class)
private static final class PrecsNormalNode_ extends BaseNode_ {
PrecsNormalNode_(PrecsNodeGen root) {
super(root, 1);
}
@Override
public Object execute_(VirtualFrame frameValue, Object arguments0Value) {
if (arguments0Value instanceof DynamicObject) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
if ((BigDecimalCoreMethodNode.isNormal(arguments0Value_))) {
return root.precsNormal(arguments0Value_);
}
}
return getNext().execute_(frameValue, arguments0Value);
}
static BaseNode_ create(PrecsNodeGen root) {
return new PrecsNormalNode_(root);
}
}
@GeneratedBy(methodName = "precsSpecial(DynamicObject)", value = PrecsNode.class)
private static final class PrecsSpecialNode_ extends BaseNode_ {
PrecsSpecialNode_(PrecsNodeGen root) {
super(root, 2);
}
@Override
public Object execute_(VirtualFrame frameValue, Object arguments0Value) {
if (arguments0Value instanceof DynamicObject) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
if ((!(BigDecimalCoreMethodNode.isNormal(arguments0Value_)))) {
return root.precsSpecial(arguments0Value_);
}
}
return getNext().execute_(frameValue, arguments0Value);
}
static BaseNode_ create(PrecsNodeGen root) {
return new PrecsSpecialNode_(root);
}
}
}
}
@GeneratedBy(ToFNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class ToFNodeFactory implements NodeFactory {
private static ToFNodeFactory toFNodeFactoryInstance;
private ToFNodeFactory() {
}
@Override
public Class getNodeClass() {
return ToFNode.class;
}
@Override
public List getExecutionSignature() {
return Arrays.asList(RubyNode.class);
}
@Override
public List getNodeSignatures() {
return Arrays.asList(Arrays.asList(RubyNode[].class));
}
@Override
public ToFNode createNode(Object... arguments) {
if (arguments.length == 1 && (arguments[0] == null || arguments[0] instanceof RubyNode[])) {
return create((RubyNode[]) arguments[0]);
} else {
throw new IllegalArgumentException("Invalid create signature.");
}
}
public static NodeFactory getInstance() {
if (toFNodeFactoryInstance == null) {
toFNodeFactoryInstance = new ToFNodeFactory();
}
return toFNodeFactoryInstance;
}
public static ToFNode create(RubyNode[] arguments) {
return new ToFNodeGen(arguments);
}
@GeneratedBy(ToFNode.class)
public static final class ToFNodeGen extends ToFNode implements SpecializedNode {
@Child private RubyNode arguments0_;
@Child private BaseNode_ specialization_;
private ToFNodeGen(RubyNode[] arguments) {
this.arguments0_ = arguments != null && 0 < arguments.length ? arguments[0] : null;
this.specialization_ = UninitializedNode_.create(this);
}
@Override
public NodeCost getCost() {
return specialization_.getNodeCost();
}
@Override
public Object execute(VirtualFrame frameValue) {
return specialization_.execute(frameValue);
}
@Override
public void executeVoid(VirtualFrame frameValue) {
specialization_.executeVoid(frameValue);
return;
}
@Override
public double executeDouble(VirtualFrame frameValue) {
return specialization_.executeDouble(frameValue);
}
@Override
public SpecializationNode getSpecializationNode() {
return specialization_;
}
@Override
public Node deepCopy() {
return SpecializationNode.updateRoot(super.deepCopy());
}
@GeneratedBy(ToFNode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected ToFNodeGen root;
BaseNode_(ToFNodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (ToFNodeGen) root;
}
@Override
protected final Node[] getSuppliedChildren() {
return new Node[] {root.arguments0_};
}
@Override
public final Object acceptAndExecute(Frame frameValue, Object arguments0Value) {
return this.executeDouble_((VirtualFrame) frameValue, arguments0Value);
}
public abstract double executeDouble_(VirtualFrame frameValue, Object arguments0Value);
public Object execute(VirtualFrame frameValue) {
Object arguments0Value_ = root.arguments0_.execute(frameValue);
return executeDouble_(frameValue, arguments0Value_);
}
public void executeVoid(VirtualFrame frameValue) {
execute(frameValue);
return;
}
public double executeDouble(VirtualFrame frameValue) {
return (double) execute(frameValue);
}
@Override
protected final SpecializationNode createNext(Frame frameValue, Object arguments0Value) {
if (arguments0Value instanceof DynamicObject) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
if ((BigDecimalCoreMethodNode.isNormal(arguments0Value_))) {
return ToFNormalNode_.create(root);
} else {
BranchProfile negInfinityProfile2 = (BranchProfile.create());
BranchProfile posInfinityProfile2 = (BranchProfile.create());
BranchProfile negZeroProfile2 = (BranchProfile.create());
BranchProfile nanProfile2 = (BranchProfile.create());
return ToFSpecialNode_.create(root, negInfinityProfile2, posInfinityProfile2, negZeroProfile2, nanProfile2);
}
}
return null;
}
@Override
protected final SpecializationNode createPolymorphic() {
return PolymorphicNode_.create(root);
}
protected final BaseNode_ getNext() {
return (BaseNode_) this.next;
}
}
@GeneratedBy(ToFNode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(ToFNodeGen root) {
super(root, 2147483647);
}
@Override
public double executeDouble_(VirtualFrame frameValue, Object arguments0Value) {
return (double) uninitialized(frameValue, arguments0Value);
}
static BaseNode_ create(ToFNodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(ToFNode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(ToFNodeGen root) {
super(root, 0);
}
@Override
public SpecializationNode merge(SpecializationNode newNode, Frame frameValue, Object arguments0Value) {
return polymorphicMerge(newNode, super.merge(newNode, frameValue, arguments0Value));
}
@Override
public double executeDouble(VirtualFrame frameValue) {
Object arguments0Value_ = root.arguments0_.execute(frameValue);
return getNext().executeDouble_(frameValue, arguments0Value_);
}
@Override
public double executeDouble_(VirtualFrame frameValue, Object arguments0Value) {
return getNext().executeDouble_(frameValue, arguments0Value);
}
static BaseNode_ create(ToFNodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "toFNormal(DynamicObject)", value = ToFNode.class)
private static final class ToFNormalNode_ extends BaseNode_ {
ToFNormalNode_(ToFNodeGen root) {
super(root, 1);
}
@Override
public double executeDouble(VirtualFrame frameValue) {
DynamicObject arguments0Value_;
try {
arguments0Value_ = root.arguments0_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
return getNext().executeDouble_(frameValue, ex.getResult());
}
if ((BigDecimalCoreMethodNode.isNormal(arguments0Value_))) {
return root.toFNormal(arguments0Value_);
}
return getNext().executeDouble_(frameValue, arguments0Value_);
}
@Override
public double executeDouble_(VirtualFrame frameValue, Object arguments0Value) {
if (arguments0Value instanceof DynamicObject) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
if ((BigDecimalCoreMethodNode.isNormal(arguments0Value_))) {
return root.toFNormal(arguments0Value_);
}
}
return getNext().executeDouble_(frameValue, arguments0Value);
}
static BaseNode_ create(ToFNodeGen root) {
return new ToFNormalNode_(root);
}
}
@GeneratedBy(methodName = "toFSpecial(DynamicObject, BranchProfile, BranchProfile, BranchProfile, BranchProfile)", value = ToFNode.class)
private static final class ToFSpecialNode_ extends BaseNode_ {
private final BranchProfile negInfinityProfile;
private final BranchProfile posInfinityProfile;
private final BranchProfile negZeroProfile;
private final BranchProfile nanProfile;
ToFSpecialNode_(ToFNodeGen root, BranchProfile negInfinityProfile, BranchProfile posInfinityProfile, BranchProfile negZeroProfile, BranchProfile nanProfile) {
super(root, 2);
this.negInfinityProfile = negInfinityProfile;
this.posInfinityProfile = posInfinityProfile;
this.negZeroProfile = negZeroProfile;
this.nanProfile = nanProfile;
}
@Override
public double executeDouble(VirtualFrame frameValue) {
DynamicObject arguments0Value_;
try {
arguments0Value_ = root.arguments0_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
return getNext().executeDouble_(frameValue, ex.getResult());
}
if ((!(BigDecimalCoreMethodNode.isNormal(arguments0Value_)))) {
return root.toFSpecial(arguments0Value_, this.negInfinityProfile, this.posInfinityProfile, this.negZeroProfile, this.nanProfile);
}
return getNext().executeDouble_(frameValue, arguments0Value_);
}
@Override
public double executeDouble_(VirtualFrame frameValue, Object arguments0Value) {
if (arguments0Value instanceof DynamicObject) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
if ((!(BigDecimalCoreMethodNode.isNormal(arguments0Value_)))) {
return root.toFSpecial(arguments0Value_, this.negInfinityProfile, this.posInfinityProfile, this.negZeroProfile, this.nanProfile);
}
}
return getNext().executeDouble_(frameValue, arguments0Value);
}
static BaseNode_ create(ToFNodeGen root, BranchProfile negInfinityProfile, BranchProfile posInfinityProfile, BranchProfile negZeroProfile, BranchProfile nanProfile) {
return new ToFSpecialNode_(root, negInfinityProfile, posInfinityProfile, negZeroProfile, nanProfile);
}
}
}
}
@GeneratedBy(UnscaledNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class UnscaledNodeFactory implements NodeFactory {
private static UnscaledNodeFactory unscaledNodeFactoryInstance;
private UnscaledNodeFactory() {
}
@Override
public Class getNodeClass() {
return UnscaledNode.class;
}
@Override
public List getExecutionSignature() {
return Arrays.asList(RubyNode.class);
}
@Override
public List getNodeSignatures() {
return Arrays.asList(Arrays.asList(RubyNode[].class));
}
@Override
public UnscaledNode createNode(Object... arguments) {
if (arguments.length == 1 && (arguments[0] == null || arguments[0] instanceof RubyNode[])) {
return create((RubyNode[]) arguments[0]);
} else {
throw new IllegalArgumentException("Invalid create signature.");
}
}
public static NodeFactory getInstance() {
if (unscaledNodeFactoryInstance == null) {
unscaledNodeFactoryInstance = new UnscaledNodeFactory();
}
return unscaledNodeFactoryInstance;
}
public static UnscaledNode create(RubyNode[] arguments) {
return new UnscaledNodeGen(arguments);
}
@GeneratedBy(UnscaledNode.class)
public static final class UnscaledNodeGen extends UnscaledNode implements SpecializedNode {
@Child private RubyNode arguments0_;
@Child private BaseNode_ specialization_;
private UnscaledNodeGen(RubyNode[] arguments) {
this.arguments0_ = arguments != null && 0 < arguments.length ? arguments[0] : null;
this.specialization_ = UninitializedNode_.create(this);
}
@Override
public NodeCost getCost() {
return specialization_.getNodeCost();
}
@Override
public Object execute(VirtualFrame frameValue) {
return specialization_.execute(frameValue);
}
@Override
public void executeVoid(VirtualFrame frameValue) {
specialization_.executeVoid(frameValue);
return;
}
@Override
public SpecializationNode getSpecializationNode() {
return specialization_;
}
@Override
public Node deepCopy() {
return SpecializationNode.updateRoot(super.deepCopy());
}
@GeneratedBy(UnscaledNode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected UnscaledNodeGen root;
BaseNode_(UnscaledNodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (UnscaledNodeGen) root;
}
@Override
protected final Node[] getSuppliedChildren() {
return new Node[] {root.arguments0_};
}
@Override
public final Object acceptAndExecute(Frame frameValue, Object arguments0Value) {
return this.execute_((VirtualFrame) frameValue, arguments0Value);
}
public abstract Object execute_(VirtualFrame frameValue, Object arguments0Value);
public Object execute(VirtualFrame frameValue) {
Object arguments0Value_ = root.arguments0_.execute(frameValue);
return execute_(frameValue, arguments0Value_);
}
public void executeVoid(VirtualFrame frameValue) {
execute(frameValue);
return;
}
@Override
protected final SpecializationNode createNext(Frame frameValue, Object arguments0Value) {
if (arguments0Value instanceof DynamicObject) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
if ((BigDecimalCoreMethodNode.isNormal(arguments0Value_))) {
return UnscaledNode_.create(root);
} else {
return UnscaledSpecialNode_.create(root);
}
}
return null;
}
@Override
protected final SpecializationNode createPolymorphic() {
return PolymorphicNode_.create(root);
}
protected final BaseNode_ getNext() {
return (BaseNode_) this.next;
}
}
@GeneratedBy(UnscaledNode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(UnscaledNodeGen root) {
super(root, 2147483647);
}
@Override
public Object execute_(VirtualFrame frameValue, Object arguments0Value) {
return uninitialized(frameValue, arguments0Value);
}
static BaseNode_ create(UnscaledNodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(UnscaledNode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(UnscaledNodeGen root) {
super(root, 0);
}
@Override
public SpecializationNode merge(SpecializationNode newNode, Frame frameValue, Object arguments0Value) {
return polymorphicMerge(newNode, super.merge(newNode, frameValue, arguments0Value));
}
@Override
public Object execute_(VirtualFrame frameValue, Object arguments0Value) {
return getNext().execute_(frameValue, arguments0Value);
}
static BaseNode_ create(UnscaledNodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "unscaled(DynamicObject)", value = UnscaledNode.class)
private static final class UnscaledNode_ extends BaseNode_ {
UnscaledNode_(UnscaledNodeGen root) {
super(root, 1);
}
@Override
public Object execute_(VirtualFrame frameValue, Object arguments0Value) {
if (arguments0Value instanceof DynamicObject) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
if ((BigDecimalCoreMethodNode.isNormal(arguments0Value_))) {
return root.unscaled(arguments0Value_);
}
}
return getNext().execute_(frameValue, arguments0Value);
}
static BaseNode_ create(UnscaledNodeGen root) {
return new UnscaledNode_(root);
}
}
@GeneratedBy(methodName = "unscaledSpecial(DynamicObject)", value = UnscaledNode.class)
private static final class UnscaledSpecialNode_ extends BaseNode_ {
UnscaledSpecialNode_(UnscaledNodeGen root) {
super(root, 2);
}
@Override
public Object execute_(VirtualFrame frameValue, Object arguments0Value) {
if (arguments0Value instanceof DynamicObject) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
if ((!(BigDecimalCoreMethodNode.isNormal(arguments0Value_)))) {
return root.unscaledSpecial(arguments0Value_);
}
}
return getNext().execute_(frameValue, arguments0Value);
}
static BaseNode_ create(UnscaledNodeGen root) {
return new UnscaledSpecialNode_(root);
}
}
}
}
@GeneratedBy(ToINode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class ToINodeFactory implements NodeFactory {
private static ToINodeFactory toINodeFactoryInstance;
private ToINodeFactory() {
}
@Override
public Class getNodeClass() {
return ToINode.class;
}
@Override
public List getExecutionSignature() {
return Arrays.asList(RubyNode.class);
}
@Override
public List getNodeSignatures() {
return Arrays.asList(Arrays.asList(RubyNode[].class));
}
@Override
public ToINode createNode(Object... arguments) {
if (arguments.length == 1 && (arguments[0] == null || arguments[0] instanceof RubyNode[])) {
return create((RubyNode[]) arguments[0]);
} else {
throw new IllegalArgumentException("Invalid create signature.");
}
}
public static NodeFactory getInstance() {
if (toINodeFactoryInstance == null) {
toINodeFactoryInstance = new ToINodeFactory();
}
return toINodeFactoryInstance;
}
public static ToINode create(RubyNode[] arguments) {
return new ToINodeGen(arguments);
}
@GeneratedBy(ToINode.class)
public static final class ToINodeGen extends ToINode implements SpecializedNode {
@Child private RubyNode arguments0_;
@Child private BaseNode_ specialization_;
private ToINodeGen(RubyNode[] arguments) {
this.arguments0_ = arguments != null && 0 < arguments.length ? arguments[0] : null;
this.specialization_ = UninitializedNode_.create(this);
}
@Override
public NodeCost getCost() {
return specialization_.getNodeCost();
}
@Override
public Object execute(VirtualFrame frameValue) {
return specialization_.execute(frameValue);
}
@Override
public void executeVoid(VirtualFrame frameValue) {
specialization_.executeVoid(frameValue);
return;
}
@Override
public int executeInteger(VirtualFrame frameValue) throws UnexpectedResultException {
return specialization_.executeInt(frameValue);
}
@Override
public SpecializationNode getSpecializationNode() {
return specialization_;
}
@Override
public Node deepCopy() {
return SpecializationNode.updateRoot(super.deepCopy());
}
private static int expectInteger(Object value) throws UnexpectedResultException {
if (value instanceof Integer) {
return (int) value;
}
throw new UnexpectedResultException(value);
}
@GeneratedBy(ToINode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected ToINodeGen root;
BaseNode_(ToINodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (ToINodeGen) root;
}
@Override
protected final Node[] getSuppliedChildren() {
return new Node[] {root.arguments0_};
}
@Override
public final Object acceptAndExecute(Frame frameValue, Object arguments0Value) {
return this.execute_((VirtualFrame) frameValue, arguments0Value);
}
public abstract Object execute_(VirtualFrame frameValue, Object arguments0Value);
public Object execute(VirtualFrame frameValue) {
Object arguments0Value_ = root.arguments0_.execute(frameValue);
return execute_(frameValue, arguments0Value_);
}
public void executeVoid(VirtualFrame frameValue) {
execute(frameValue);
return;
}
public int executeInt(VirtualFrame frameValue) throws UnexpectedResultException {
return expectInteger(execute(frameValue));
}
@Override
protected final SpecializationNode createNext(Frame frameValue, Object arguments0Value) {
if (arguments0Value instanceof DynamicObject) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
if ((BigDecimalCoreMethodNode.isNormal(arguments0Value_))) {
FixnumOrBignumNode fixnumOrBignumNode1 = (new FixnumOrBignumNode());
return ToINormalNode_.create(root, fixnumOrBignumNode1);
} else {
return ToISpecialNode_.create(root);
}
}
return null;
}
@Override
protected final SpecializationNode createPolymorphic() {
return PolymorphicNode_.create(root);
}
protected final BaseNode_ getNext() {
return (BaseNode_) this.next;
}
}
@GeneratedBy(ToINode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(ToINodeGen root) {
super(root, 2147483647);
}
@Override
public Object execute_(VirtualFrame frameValue, Object arguments0Value) {
return uninitialized(frameValue, arguments0Value);
}
static BaseNode_ create(ToINodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(ToINode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(ToINodeGen root) {
super(root, 0);
}
@Override
public SpecializationNode merge(SpecializationNode newNode, Frame frameValue, Object arguments0Value) {
return polymorphicMerge(newNode, super.merge(newNode, frameValue, arguments0Value));
}
@Override
public Object execute_(VirtualFrame frameValue, Object arguments0Value) {
return getNext().execute_(frameValue, arguments0Value);
}
static BaseNode_ create(ToINodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "toINormal(DynamicObject, FixnumOrBignumNode)", value = ToINode.class)
private static final class ToINormalNode_ extends BaseNode_ {
@Child private FixnumOrBignumNode fixnumOrBignumNode;
ToINormalNode_(ToINodeGen root, FixnumOrBignumNode fixnumOrBignumNode) {
super(root, 1);
this.fixnumOrBignumNode = fixnumOrBignumNode;
}
@Override
public Object execute_(VirtualFrame frameValue, Object arguments0Value) {
if (arguments0Value instanceof DynamicObject) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
if ((BigDecimalCoreMethodNode.isNormal(arguments0Value_))) {
return root.toINormal(arguments0Value_, this.fixnumOrBignumNode);
}
}
return getNext().execute_(frameValue, arguments0Value);
}
static BaseNode_ create(ToINodeGen root, FixnumOrBignumNode fixnumOrBignumNode) {
return new ToINormalNode_(root, fixnumOrBignumNode);
}
}
@GeneratedBy(methodName = "toISpecial(DynamicObject)", value = ToINode.class)
private static final class ToISpecialNode_ extends BaseNode_ {
ToISpecialNode_(ToINodeGen root) {
super(root, 2);
}
@Override
public int executeInt(VirtualFrame frameValue) throws UnexpectedResultException {
DynamicObject arguments0Value_;
try {
arguments0Value_ = root.arguments0_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
return expectInteger(getNext().execute_(frameValue, ex.getResult()));
}
if ((!(BigDecimalCoreMethodNode.isNormal(arguments0Value_)))) {
return root.toISpecial(arguments0Value_);
}
return expectInteger(getNext().execute_(frameValue, arguments0Value_));
}
@Override
public Object execute_(VirtualFrame frameValue, Object arguments0Value) {
if (arguments0Value instanceof DynamicObject) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
if ((!(BigDecimalCoreMethodNode.isNormal(arguments0Value_)))) {
return root.toISpecial(arguments0Value_);
}
}
return getNext().execute_(frameValue, arguments0Value);
}
static BaseNode_ create(ToINodeGen root) {
return new ToISpecialNode_(root);
}
}
}
}
@GeneratedBy(AllocateNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class AllocateNodeFactory implements NodeFactory {
private static AllocateNodeFactory allocateNodeFactoryInstance;
private AllocateNodeFactory() {
}
@Override
public Class getNodeClass() {
return AllocateNode.class;
}
@Override
public List getExecutionSignature() {
return Arrays.asList(RubyNode.class);
}
@Override
public List getNodeSignatures() {
return Arrays.asList(Arrays.asList(RubyNode[].class));
}
@Override
public AllocateNode createNode(Object... arguments) {
if (arguments.length == 1 && (arguments[0] == null || arguments[0] instanceof RubyNode[])) {
return create((RubyNode[]) arguments[0]);
} else {
throw new IllegalArgumentException("Invalid create signature.");
}
}
public static NodeFactory getInstance() {
if (allocateNodeFactoryInstance == null) {
allocateNodeFactoryInstance = new AllocateNodeFactory();
}
return allocateNodeFactoryInstance;
}
public static AllocateNode create(RubyNode[] arguments) {
return new AllocateNodeGen(arguments);
}
@GeneratedBy(AllocateNode.class)
public static final class AllocateNodeGen extends AllocateNode {
@Child private RubyNode arguments0_;
@CompilationFinal private boolean seenUnsupported0;
private AllocateNodeGen(RubyNode[] arguments) {
this.arguments0_ = arguments != null && 0 < arguments.length ? arguments[0] : null;
}
@Override
public NodeCost getCost() {
return NodeCost.MONOMORPHIC;
}
@Override
public Object execute(VirtualFrame frameValue) {
DynamicObject arguments0Value_;
try {
arguments0Value_ = arguments0_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
throw unsupported(ex.getResult());
}
return this.allocate(arguments0Value_);
}
@Override
public void executeVoid(VirtualFrame frameValue) {
execute(frameValue);
return;
}
private UnsupportedSpecializationException unsupported(Object arguments0Value) {
if (!seenUnsupported0) {
CompilerDirectives.transferToInterpreterAndInvalidate();
seenUnsupported0 = true;
}
return new UnsupportedSpecializationException(this, new Node[] {arguments0_}, arguments0Value);
}
}
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy