org.jruby.truffle.extra.TrufflePosixNodesFactory Maven / Gradle / Ivy
The newest version!
// CheckStyle: start generated
package org.jruby.truffle.extra;
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.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 java.util.Arrays;
import java.util.List;
import org.jruby.truffle.builtins.CoreMethodArrayArgumentsNode;
import org.jruby.truffle.extra.TrufflePosixNodes.AccessNode;
import org.jruby.truffle.extra.TrufflePosixNodes.BindNode;
import org.jruby.truffle.extra.TrufflePosixNodes.ChdirNode;
import org.jruby.truffle.extra.TrufflePosixNodes.ChmodNode;
import org.jruby.truffle.extra.TrufflePosixNodes.ChownNode;
import org.jruby.truffle.extra.TrufflePosixNodes.CloseNode;
import org.jruby.truffle.extra.TrufflePosixNodes.ConnectNode;
import org.jruby.truffle.extra.TrufflePosixNodes.Dup2Node;
import org.jruby.truffle.extra.TrufflePosixNodes.DupNode;
import org.jruby.truffle.extra.TrufflePosixNodes.ErrnoAssignNode;
import org.jruby.truffle.extra.TrufflePosixNodes.ErrnoNode;
import org.jruby.truffle.extra.TrufflePosixNodes.FchmodNode;
import org.jruby.truffle.extra.TrufflePosixNodes.FchownNode;
import org.jruby.truffle.extra.TrufflePosixNodes.FcntlNode;
import org.jruby.truffle.extra.TrufflePosixNodes.FlockNode;
import org.jruby.truffle.extra.TrufflePosixNodes.FreeAddrInfoNode;
import org.jruby.truffle.extra.TrufflePosixNodes.FsyncNode;
import org.jruby.truffle.extra.TrufflePosixNodes.GetAddrInfoNode;
import org.jruby.truffle.extra.TrufflePosixNodes.GetEGIDNode;
import org.jruby.truffle.extra.TrufflePosixNodes.GetEUIDNode;
import org.jruby.truffle.extra.TrufflePosixNodes.GetGIDNode;
import org.jruby.truffle.extra.TrufflePosixNodes.GetGroupsNode;
import org.jruby.truffle.extra.TrufflePosixNodes.GetHostNameNode;
import org.jruby.truffle.extra.TrufflePosixNodes.GetNameInfoNode;
import org.jruby.truffle.extra.TrufflePosixNodes.GetPeerNameNode;
import org.jruby.truffle.extra.TrufflePosixNodes.GetPriorityNode;
import org.jruby.truffle.extra.TrufflePosixNodes.GetRLimitNode;
import org.jruby.truffle.extra.TrufflePosixNodes.GetSockNameNode;
import org.jruby.truffle.extra.TrufflePosixNodes.GetSockOptNode;
import org.jruby.truffle.extra.TrufflePosixNodes.GetUIDNode;
import org.jruby.truffle.extra.TrufflePosixNodes.GetcwdNode;
import org.jruby.truffle.extra.TrufflePosixNodes.GetenvNode;
import org.jruby.truffle.extra.TrufflePosixNodes.GetpgidNode;
import org.jruby.truffle.extra.TrufflePosixNodes.GetpgrpNode;
import org.jruby.truffle.extra.TrufflePosixNodes.GetppidNode;
import org.jruby.truffle.extra.TrufflePosixNodes.IsATTYNode;
import org.jruby.truffle.extra.TrufflePosixNodes.KillNode;
import org.jruby.truffle.extra.TrufflePosixNodes.LchmodNode;
import org.jruby.truffle.extra.TrufflePosixNodes.LinkNode;
import org.jruby.truffle.extra.TrufflePosixNodes.ListenNode;
import org.jruby.truffle.extra.TrufflePosixNodes.MajorNode;
import org.jruby.truffle.extra.TrufflePosixNodes.MemsetNode;
import org.jruby.truffle.extra.TrufflePosixNodes.MinorNode;
import org.jruby.truffle.extra.TrufflePosixNodes.MkdirNode;
import org.jruby.truffle.extra.TrufflePosixNodes.MkfifoNode;
import org.jruby.truffle.extra.TrufflePosixNodes.ReadlinkNode;
import org.jruby.truffle.extra.TrufflePosixNodes.RenameNode;
import org.jruby.truffle.extra.TrufflePosixNodes.RmdirNode;
import org.jruby.truffle.extra.TrufflePosixNodes.SendNode;
import org.jruby.truffle.extra.TrufflePosixNodes.SetEuidNode;
import org.jruby.truffle.extra.TrufflePosixNodes.SetPriorityNode;
import org.jruby.truffle.extra.TrufflePosixNodes.SetRLimitNode;
import org.jruby.truffle.extra.TrufflePosixNodes.SetResuidNode;
import org.jruby.truffle.extra.TrufflePosixNodes.SetReuidNode;
import org.jruby.truffle.extra.TrufflePosixNodes.SetRuidNode;
import org.jruby.truffle.extra.TrufflePosixNodes.SetSidNode;
import org.jruby.truffle.extra.TrufflePosixNodes.SetSockOptNode;
import org.jruby.truffle.extra.TrufflePosixNodes.SetUidNode;
import org.jruby.truffle.extra.TrufflePosixNodes.SetenvNode;
import org.jruby.truffle.extra.TrufflePosixNodes.SetgidNode;
import org.jruby.truffle.extra.TrufflePosixNodes.SetpgidNode;
import org.jruby.truffle.extra.TrufflePosixNodes.ShutdownNode;
import org.jruby.truffle.extra.TrufflePosixNodes.SocketNode;
import org.jruby.truffle.extra.TrufflePosixNodes.SymlinkNode;
import org.jruby.truffle.extra.TrufflePosixNodes.UmaskNode;
import org.jruby.truffle.extra.TrufflePosixNodes.UnlinkNode;
import org.jruby.truffle.extra.TrufflePosixNodes.UnsetenvNode;
import org.jruby.truffle.extra.TrufflePosixNodes.UtimesNode;
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;
@GeneratedBy(TrufflePosixNodes.class)
public final class TrufflePosixNodesFactory {
public static List> getFactories() {
return Arrays.asList(AccessNodeFactory.getInstance(), ChmodNodeFactory.getInstance(), ChownNodeFactory.getInstance(), DupNodeFactory.getInstance(), Dup2NodeFactory.getInstance(), FchmodNodeFactory.getInstance(), FsyncNodeFactory.getInstance(), FchownNodeFactory.getInstance(), GetEGIDNodeFactory.getInstance(), GetenvNodeFactory.getInstance(), GetEUIDNodeFactory.getInstance(), GetGIDNodeFactory.getInstance(), GetGroupsNodeFactory.getInstance(), GetRLimitNodeFactory.getInstance(), GetUIDNodeFactory.getInstance(), MemsetNodeFactory.getInstance(), MkfifoNodeFactory.getInstance(), ReadlinkNodeFactory.getInstance(), SetenvNodeFactory.getInstance(), LchmodNodeFactory.getInstance(), LinkNodeFactory.getInstance(), UnlinkNodeFactory.getInstance(), UmaskNodeFactory.getInstance(), UnsetenvNodeFactory.getInstance(), UtimesNodeFactory.getInstance(), MkdirNodeFactory.getInstance(), ChdirNodeFactory.getInstance(), GetPriorityNodeFactory.getInstance(), SetgidNodeFactory.getInstance(), SetpgidNodeFactory.getInstance(), SetPriorityNodeFactory.getInstance(), SetResuidNodeFactory.getInstance(), SetEuidNodeFactory.getInstance(), SetReuidNodeFactory.getInstance(), SetRLimitNodeFactory.getInstance(), SetRuidNodeFactory.getInstance(), SetUidNodeFactory.getInstance(), SetSidNodeFactory.getInstance(), FlockNodeFactory.getInstance(), MajorNodeFactory.getInstance(), MinorNodeFactory.getInstance(), RenameNodeFactory.getInstance(), RmdirNodeFactory.getInstance(), GetcwdNodeFactory.getInstance(), ErrnoNodeFactory.getInstance(), ErrnoAssignNodeFactory.getInstance(), FcntlNodeFactory.getInstance(), GetpgidNodeFactory.getInstance(), GetpgrpNodeFactory.getInstance(), IsATTYNodeFactory.getInstance(), GetppidNodeFactory.getInstance(), SendNodeFactory.getInstance(), SymlinkNodeFactory.getInstance(), GetAddrInfoNodeFactory.getInstance(), ConnectNodeFactory.getInstance(), FreeAddrInfoNodeFactory.getInstance(), GetNameInfoNodeFactory.getInstance(), ShutdownNodeFactory.getInstance(), SocketNodeFactory.getInstance(), SetSockOptNodeFactory.getInstance(), BindNodeFactory.getInstance(), ListenNodeFactory.getInstance(), GetHostNameNodeFactory.getInstance(), GetPeerNameNodeFactory.getInstance(), GetSockNameNodeFactory.getInstance(), GetSockOptNodeFactory.getInstance(), CloseNodeFactory.getInstance(), KillNodeFactory.getInstance());
}
@GeneratedBy(AccessNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class AccessNodeFactory implements NodeFactory {
private static AccessNodeFactory accessNodeFactoryInstance;
private AccessNodeFactory() {
}
@Override
public Class getNodeClass() {
return AccessNode.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 AccessNode 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 (accessNodeFactoryInstance == null) {
accessNodeFactoryInstance = new AccessNodeFactory();
}
return accessNodeFactoryInstance;
}
public static AccessNode create(RubyNode[] arguments) {
return new AccessNodeGen(arguments);
}
@GeneratedBy(AccessNode.class)
public static final class AccessNodeGen extends AccessNode implements SpecializedNode {
@Child private RubyNode arguments0_;
@Child private RubyNode arguments1_;
@CompilationFinal private Class arguments1Type_;
@Child private BaseNode_ specialization_;
private AccessNodeGen(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) {
return specialization_.executeInt(frameValue);
}
@Override
public SpecializationNode getSpecializationNode() {
return specialization_;
}
@Override
public Node deepCopy() {
return SpecializationNode.updateRoot(super.deepCopy());
}
@GeneratedBy(AccessNode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected AccessNodeGen root;
BaseNode_(AccessNodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (AccessNodeGen) 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.executeInt_((VirtualFrame) frameValue, arguments0Value, arguments1Value);
}
public abstract int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value);
public Object execute(VirtualFrame frameValue) {
Object arguments0Value_ = root.arguments0_.execute(frameValue);
Object arguments1Value_ = executeArguments1_(frameValue);
return executeInt_(frameValue, arguments0Value_, arguments1Value_);
}
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, Object arguments1Value) {
if (arguments0Value instanceof DynamicObject && RubyTypesGen.isImplicitInteger(arguments1Value)) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
if ((RubyGuards.isRubyString(arguments0Value_))) {
return AccessNode_.create(root, arguments1Value);
}
}
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();
}
}
}
@GeneratedBy(AccessNode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(AccessNodeGen root) {
super(root, 2147483647);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value) {
return (int) uninitialized(frameValue, arguments0Value, arguments1Value);
}
static BaseNode_ create(AccessNodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(AccessNode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(AccessNodeGen 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 int executeInt(VirtualFrame frameValue) {
Object arguments0Value_ = root.arguments0_.execute(frameValue);
Object arguments1Value_ = executeArguments1_(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value) {
return getNext().executeInt_(frameValue, arguments0Value, arguments1Value);
}
static BaseNode_ create(AccessNodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "access(DynamicObject, int)", value = AccessNode.class)
private static final class AccessNode_ extends BaseNode_ {
private final Class arguments1ImplicitType;
AccessNode_(AccessNodeGen root, Object arguments1Value) {
super(root, 1);
this.arguments1ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments1Value);
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.arguments1ImplicitType == ((AccessNode_) other).arguments1ImplicitType;
}
@Override
public Object execute(VirtualFrame frameValue) {
return executeInt(frameValue);
}
@Override
public int executeInt(VirtualFrame frameValue) {
DynamicObject arguments0Value_;
try {
arguments0Value_ = root.arguments0_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object arguments1Value = executeArguments1_(frameValue);
return getNext().executeInt_(frameValue, ex.getResult(), arguments1Value);
}
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) {
return getNext().executeInt_(frameValue, arguments0Value_, ex.getResult());
}
if ((RubyGuards.isRubyString(arguments0Value_))) {
return root.access(arguments0Value_, arguments1Value_);
}
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value) {
if (arguments0Value instanceof DynamicObject && RubyTypesGen.isImplicitInteger(arguments1Value, arguments1ImplicitType)) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
int arguments1Value_ = RubyTypesGen.asImplicitInteger(arguments1Value, arguments1ImplicitType);
if ((RubyGuards.isRubyString(arguments0Value_))) {
return root.access(arguments0Value_, arguments1Value_);
}
}
return getNext().executeInt_(frameValue, arguments0Value, arguments1Value);
}
static BaseNode_ create(AccessNodeGen root, Object arguments1Value) {
return new AccessNode_(root, arguments1Value);
}
}
}
}
@GeneratedBy(ChmodNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class ChmodNodeFactory implements NodeFactory {
private static ChmodNodeFactory chmodNodeFactoryInstance;
private ChmodNodeFactory() {
}
@Override
public Class getNodeClass() {
return ChmodNode.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 ChmodNode 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 (chmodNodeFactoryInstance == null) {
chmodNodeFactoryInstance = new ChmodNodeFactory();
}
return chmodNodeFactoryInstance;
}
public static ChmodNode create(RubyNode[] arguments) {
return new ChmodNodeGen(arguments);
}
@GeneratedBy(ChmodNode.class)
public static final class ChmodNodeGen extends ChmodNode implements SpecializedNode {
@Child private RubyNode arguments0_;
@Child private RubyNode arguments1_;
@CompilationFinal private Class arguments1Type_;
@Child private BaseNode_ specialization_;
private ChmodNodeGen(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) {
return specialization_.executeInt(frameValue);
}
@Override
public SpecializationNode getSpecializationNode() {
return specialization_;
}
@Override
public Node deepCopy() {
return SpecializationNode.updateRoot(super.deepCopy());
}
@GeneratedBy(ChmodNode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected ChmodNodeGen root;
BaseNode_(ChmodNodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (ChmodNodeGen) 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.executeInt_((VirtualFrame) frameValue, arguments0Value, arguments1Value);
}
public abstract int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value);
public Object execute(VirtualFrame frameValue) {
Object arguments0Value_ = root.arguments0_.execute(frameValue);
Object arguments1Value_ = executeArguments1_(frameValue);
return executeInt_(frameValue, arguments0Value_, arguments1Value_);
}
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, Object arguments1Value) {
if (arguments0Value instanceof DynamicObject && RubyTypesGen.isImplicitInteger(arguments1Value)) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
if ((RubyGuards.isRubyString(arguments0Value_))) {
return ChmodNode_.create(root, arguments1Value);
}
}
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();
}
}
}
@GeneratedBy(ChmodNode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(ChmodNodeGen root) {
super(root, 2147483647);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value) {
return (int) uninitialized(frameValue, arguments0Value, arguments1Value);
}
static BaseNode_ create(ChmodNodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(ChmodNode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(ChmodNodeGen 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 int executeInt(VirtualFrame frameValue) {
Object arguments0Value_ = root.arguments0_.execute(frameValue);
Object arguments1Value_ = executeArguments1_(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value) {
return getNext().executeInt_(frameValue, arguments0Value, arguments1Value);
}
static BaseNode_ create(ChmodNodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "chmod(DynamicObject, int)", value = ChmodNode.class)
private static final class ChmodNode_ extends BaseNode_ {
private final Class arguments1ImplicitType;
ChmodNode_(ChmodNodeGen root, Object arguments1Value) {
super(root, 1);
this.arguments1ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments1Value);
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.arguments1ImplicitType == ((ChmodNode_) other).arguments1ImplicitType;
}
@Override
public Object execute(VirtualFrame frameValue) {
return executeInt(frameValue);
}
@Override
public int executeInt(VirtualFrame frameValue) {
DynamicObject arguments0Value_;
try {
arguments0Value_ = root.arguments0_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object arguments1Value = executeArguments1_(frameValue);
return getNext().executeInt_(frameValue, ex.getResult(), arguments1Value);
}
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) {
return getNext().executeInt_(frameValue, arguments0Value_, ex.getResult());
}
if ((RubyGuards.isRubyString(arguments0Value_))) {
return root.chmod(arguments0Value_, arguments1Value_);
}
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value) {
if (arguments0Value instanceof DynamicObject && RubyTypesGen.isImplicitInteger(arguments1Value, arguments1ImplicitType)) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
int arguments1Value_ = RubyTypesGen.asImplicitInteger(arguments1Value, arguments1ImplicitType);
if ((RubyGuards.isRubyString(arguments0Value_))) {
return root.chmod(arguments0Value_, arguments1Value_);
}
}
return getNext().executeInt_(frameValue, arguments0Value, arguments1Value);
}
static BaseNode_ create(ChmodNodeGen root, Object arguments1Value) {
return new ChmodNode_(root, arguments1Value);
}
}
}
}
@GeneratedBy(ChownNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class ChownNodeFactory implements NodeFactory {
private static ChownNodeFactory chownNodeFactoryInstance;
private ChownNodeFactory() {
}
@Override
public Class getNodeClass() {
return ChownNode.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 ChownNode 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 (chownNodeFactoryInstance == null) {
chownNodeFactoryInstance = new ChownNodeFactory();
}
return chownNodeFactoryInstance;
}
public static ChownNode create(RubyNode[] arguments) {
return new ChownNodeGen(arguments);
}
@GeneratedBy(ChownNode.class)
public static final class ChownNodeGen extends ChownNode 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 ChownNodeGen(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 int executeInteger(VirtualFrame frameValue) {
return specialization_.executeInt(frameValue);
}
@Override
public SpecializationNode getSpecializationNode() {
return specialization_;
}
@Override
public Node deepCopy() {
return SpecializationNode.updateRoot(super.deepCopy());
}
@GeneratedBy(ChownNode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected ChownNodeGen root;
BaseNode_(ChownNodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (ChownNodeGen) 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.executeInt_((VirtualFrame) frameValue, arguments0Value, arguments1Value, arguments2Value);
}
public abstract int executeInt_(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 executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_);
}
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, Object arguments1Value, Object arguments2Value) {
if (arguments0Value instanceof DynamicObject && RubyTypesGen.isImplicitInteger(arguments1Value) && RubyTypesGen.isImplicitInteger(arguments2Value)) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
if ((RubyGuards.isRubyString(arguments0Value_))) {
return ChownNode_.create(root, arguments1Value, arguments2Value);
}
}
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(ChownNode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(ChownNodeGen root) {
super(root, 2147483647);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value) {
return (int) uninitialized(frameValue, arguments0Value, arguments1Value, arguments2Value);
}
static BaseNode_ create(ChownNodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(ChownNode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(ChownNodeGen 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 int executeInt(VirtualFrame frameValue) {
Object arguments0Value_ = root.arguments0_.execute(frameValue);
Object arguments1Value_ = executeArguments1_(frameValue);
Object arguments2Value_ = executeArguments2_(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value) {
return getNext().executeInt_(frameValue, arguments0Value, arguments1Value, arguments2Value);
}
static BaseNode_ create(ChownNodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "chown(DynamicObject, int, int)", value = ChownNode.class)
private static final class ChownNode_ extends BaseNode_ {
private final Class arguments1ImplicitType;
private final Class arguments2ImplicitType;
ChownNode_(ChownNodeGen root, Object arguments1Value, Object arguments2Value) {
super(root, 1);
this.arguments1ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments1Value);
this.arguments2ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments2Value);
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.arguments1ImplicitType == ((ChownNode_) other).arguments1ImplicitType && this.arguments2ImplicitType == ((ChownNode_) other).arguments2ImplicitType;
}
@Override
public Object execute(VirtualFrame frameValue) {
return executeInt(frameValue);
}
@Override
public int executeInt(VirtualFrame frameValue) {
DynamicObject arguments0Value_;
try {
arguments0Value_ = root.arguments0_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object arguments1Value = executeArguments1_(frameValue);
Object arguments2Value = executeArguments2_(frameValue);
return getNext().executeInt_(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().executeInt_(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().executeInt_(frameValue, arguments0Value_, arguments1Value_, ex.getResult());
}
if ((RubyGuards.isRubyString(arguments0Value_))) {
return root.chown(arguments0Value_, arguments1Value_, arguments2Value_);
}
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_);
}
@Override
public int executeInt_(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 ((RubyGuards.isRubyString(arguments0Value_))) {
return root.chown(arguments0Value_, arguments1Value_, arguments2Value_);
}
}
return getNext().executeInt_(frameValue, arguments0Value, arguments1Value, arguments2Value);
}
static BaseNode_ create(ChownNodeGen root, Object arguments1Value, Object arguments2Value) {
return new ChownNode_(root, arguments1Value, arguments2Value);
}
}
}
}
@GeneratedBy(DupNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class DupNodeFactory implements NodeFactory {
private static DupNodeFactory dupNodeFactoryInstance;
private DupNodeFactory() {
}
@Override
public Class getNodeClass() {
return DupNode.class;
}
@Override
public List getExecutionSignature() {
return Arrays.asList(RubyNode.class);
}
@Override
public List getNodeSignatures() {
return Arrays.asList(Arrays.asList(RubyNode[].class));
}
@Override
public DupNode 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 (dupNodeFactoryInstance == null) {
dupNodeFactoryInstance = new DupNodeFactory();
}
return dupNodeFactoryInstance;
}
public static DupNode create(RubyNode[] arguments) {
return new DupNodeGen(arguments);
}
@GeneratedBy(DupNode.class)
public static final class DupNodeGen extends DupNode implements SpecializedNode {
@Child private RubyNode arguments0_;
@CompilationFinal private Class arguments0Type_;
@Child private BaseNode_ specialization_;
private DupNodeGen(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(DupNode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected DupNodeGen root;
BaseNode_(DupNodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (DupNodeGen) 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_ = executeArguments0_(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 (RubyTypesGen.isImplicitInteger(arguments0Value)) {
return DupNode_.create(root, arguments0Value);
}
return null;
}
@Override
protected final SpecializationNode createPolymorphic() {
return PolymorphicNode_.create(root);
}
protected final BaseNode_ getNext() {
return (BaseNode_) this.next;
}
protected final Object executeArguments0_(Frame frameValue) {
Class arguments0Type_ = root.arguments0Type_;
try {
if (arguments0Type_ == int.class) {
return root.arguments0_.executeInteger((VirtualFrame) frameValue);
} else if (arguments0Type_ == null) {
CompilerDirectives.transferToInterpreterAndInvalidate();
Class _type = Object.class;
try {
Object _value = root.arguments0_.execute((VirtualFrame) frameValue);
if (_value instanceof Integer) {
_type = int.class;
} else {
_type = Object.class;
}
return _value;
} finally {
root.arguments0Type_ = _type;
}
} else {
return root.arguments0_.execute((VirtualFrame) frameValue);
}
} catch (UnexpectedResultException ex) {
root.arguments0Type_ = Object.class;
return ex.getResult();
}
}
}
@GeneratedBy(DupNode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(DupNodeGen root) {
super(root, 2147483647);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value) {
return (int) uninitialized(frameValue, arguments0Value);
}
static BaseNode_ create(DupNodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(DupNode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(DupNodeGen 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_ = executeArguments0_(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value) {
return getNext().executeInt_(frameValue, arguments0Value);
}
static BaseNode_ create(DupNodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "dup(int)", value = DupNode.class)
private static final class DupNode_ extends BaseNode_ {
private final Class arguments0ImplicitType;
DupNode_(DupNodeGen root, Object arguments0Value) {
super(root, 1);
this.arguments0ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments0Value);
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.arguments0ImplicitType == ((DupNode_) other).arguments0ImplicitType;
}
@Override
public Object execute(VirtualFrame frameValue) {
return executeInt(frameValue);
}
@Override
public int executeInt(VirtualFrame frameValue) {
int arguments0Value_;
try {
if (arguments0ImplicitType == int.class) {
arguments0Value_ = root.arguments0_.executeInteger(frameValue);
} else {
Object arguments0Value__ = executeArguments0_(frameValue);
arguments0Value_ = RubyTypesGen.expectImplicitInteger(arguments0Value__, arguments0ImplicitType);
}
} catch (UnexpectedResultException ex) {
return getNext().executeInt_(frameValue, ex.getResult());
}
return root.dup(arguments0Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value) {
if (RubyTypesGen.isImplicitInteger(arguments0Value, arguments0ImplicitType)) {
int arguments0Value_ = RubyTypesGen.asImplicitInteger(arguments0Value, arguments0ImplicitType);
return root.dup(arguments0Value_);
}
return getNext().executeInt_(frameValue, arguments0Value);
}
static BaseNode_ create(DupNodeGen root, Object arguments0Value) {
return new DupNode_(root, arguments0Value);
}
}
}
}
@GeneratedBy(Dup2Node.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class Dup2NodeFactory implements NodeFactory {
private static Dup2NodeFactory dup2NodeFactoryInstance;
private Dup2NodeFactory() {
}
@Override
public Class getNodeClass() {
return Dup2Node.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 Dup2Node 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 (dup2NodeFactoryInstance == null) {
dup2NodeFactoryInstance = new Dup2NodeFactory();
}
return dup2NodeFactoryInstance;
}
public static Dup2Node create(RubyNode[] arguments) {
return new Dup2NodeGen(arguments);
}
@GeneratedBy(Dup2Node.class)
public static final class Dup2NodeGen extends Dup2Node implements SpecializedNode {
@Child private RubyNode arguments0_;
@Child private RubyNode arguments1_;
@CompilationFinal private Class arguments0Type_;
@CompilationFinal private Class arguments1Type_;
@Child private BaseNode_ specialization_;
private Dup2NodeGen(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) {
return specialization_.executeInt(frameValue);
}
@Override
public SpecializationNode getSpecializationNode() {
return specialization_;
}
@Override
public Node deepCopy() {
return SpecializationNode.updateRoot(super.deepCopy());
}
@GeneratedBy(Dup2Node.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected Dup2NodeGen root;
BaseNode_(Dup2NodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (Dup2NodeGen) 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.executeInt_((VirtualFrame) frameValue, arguments0Value, arguments1Value);
}
public abstract int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value);
public Object execute(VirtualFrame frameValue) {
Object arguments0Value_ = executeArguments0_(frameValue);
Object arguments1Value_ = executeArguments1_(frameValue);
return executeInt_(frameValue, arguments0Value_, arguments1Value_);
}
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, Object arguments1Value) {
if (RubyTypesGen.isImplicitInteger(arguments0Value) && RubyTypesGen.isImplicitInteger(arguments1Value)) {
return Dup2Node_.create(root, arguments0Value, arguments1Value);
}
return null;
}
@Override
protected final SpecializationNode createPolymorphic() {
return PolymorphicNode_.create(root);
}
protected final BaseNode_ getNext() {
return (BaseNode_) this.next;
}
protected final Object executeArguments0_(Frame frameValue) {
Class arguments0Type_ = root.arguments0Type_;
try {
if (arguments0Type_ == int.class) {
return root.arguments0_.executeInteger((VirtualFrame) frameValue);
} else if (arguments0Type_ == null) {
CompilerDirectives.transferToInterpreterAndInvalidate();
Class _type = Object.class;
try {
Object _value = root.arguments0_.execute((VirtualFrame) frameValue);
if (_value instanceof Integer) {
_type = int.class;
} else {
_type = Object.class;
}
return _value;
} finally {
root.arguments0Type_ = _type;
}
} else {
return root.arguments0_.execute((VirtualFrame) frameValue);
}
} catch (UnexpectedResultException ex) {
root.arguments0Type_ = Object.class;
return ex.getResult();
}
}
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();
}
}
}
@GeneratedBy(Dup2Node.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(Dup2NodeGen root) {
super(root, 2147483647);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value) {
return (int) uninitialized(frameValue, arguments0Value, arguments1Value);
}
static BaseNode_ create(Dup2NodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(Dup2Node.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(Dup2NodeGen 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 int executeInt(VirtualFrame frameValue) {
Object arguments0Value_ = executeArguments0_(frameValue);
Object arguments1Value_ = executeArguments1_(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value) {
return getNext().executeInt_(frameValue, arguments0Value, arguments1Value);
}
static BaseNode_ create(Dup2NodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "dup2(int, int)", value = Dup2Node.class)
private static final class Dup2Node_ extends BaseNode_ {
private final Class arguments0ImplicitType;
private final Class arguments1ImplicitType;
Dup2Node_(Dup2NodeGen root, Object arguments0Value, Object arguments1Value) {
super(root, 1);
this.arguments0ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments0Value);
this.arguments1ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments1Value);
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.arguments0ImplicitType == ((Dup2Node_) other).arguments0ImplicitType && this.arguments1ImplicitType == ((Dup2Node_) other).arguments1ImplicitType;
}
@Override
public Object execute(VirtualFrame frameValue) {
return executeInt(frameValue);
}
@Override
public int executeInt(VirtualFrame frameValue) {
int arguments0Value_;
try {
if (arguments0ImplicitType == int.class) {
arguments0Value_ = root.arguments0_.executeInteger(frameValue);
} else {
Object arguments0Value__ = executeArguments0_(frameValue);
arguments0Value_ = RubyTypesGen.expectImplicitInteger(arguments0Value__, arguments0ImplicitType);
}
} catch (UnexpectedResultException ex) {
Object arguments1Value = executeArguments1_(frameValue);
return getNext().executeInt_(frameValue, ex.getResult(), arguments1Value);
}
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) {
return getNext().executeInt_(frameValue, arguments0Value_, ex.getResult());
}
return root.dup2(arguments0Value_, arguments1Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value) {
if (RubyTypesGen.isImplicitInteger(arguments0Value, arguments0ImplicitType) && RubyTypesGen.isImplicitInteger(arguments1Value, arguments1ImplicitType)) {
int arguments0Value_ = RubyTypesGen.asImplicitInteger(arguments0Value, arguments0ImplicitType);
int arguments1Value_ = RubyTypesGen.asImplicitInteger(arguments1Value, arguments1ImplicitType);
return root.dup2(arguments0Value_, arguments1Value_);
}
return getNext().executeInt_(frameValue, arguments0Value, arguments1Value);
}
static BaseNode_ create(Dup2NodeGen root, Object arguments0Value, Object arguments1Value) {
return new Dup2Node_(root, arguments0Value, arguments1Value);
}
}
}
}
@GeneratedBy(FchmodNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class FchmodNodeFactory implements NodeFactory {
private static FchmodNodeFactory fchmodNodeFactoryInstance;
private FchmodNodeFactory() {
}
@Override
public Class getNodeClass() {
return FchmodNode.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 FchmodNode 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 (fchmodNodeFactoryInstance == null) {
fchmodNodeFactoryInstance = new FchmodNodeFactory();
}
return fchmodNodeFactoryInstance;
}
public static FchmodNode create(RubyNode[] arguments) {
return new FchmodNodeGen(arguments);
}
@GeneratedBy(FchmodNode.class)
public static final class FchmodNodeGen extends FchmodNode implements SpecializedNode {
@Child private RubyNode arguments0_;
@Child private RubyNode arguments1_;
@CompilationFinal private Class arguments0Type_;
@CompilationFinal private Class arguments1Type_;
@Child private BaseNode_ specialization_;
private FchmodNodeGen(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) {
return specialization_.executeInt(frameValue);
}
@Override
public SpecializationNode getSpecializationNode() {
return specialization_;
}
@Override
public Node deepCopy() {
return SpecializationNode.updateRoot(super.deepCopy());
}
@GeneratedBy(FchmodNode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected FchmodNodeGen root;
BaseNode_(FchmodNodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (FchmodNodeGen) 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.executeInt_((VirtualFrame) frameValue, arguments0Value, arguments1Value);
}
public abstract int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value);
public Object execute(VirtualFrame frameValue) {
Object arguments0Value_ = executeArguments0_(frameValue);
Object arguments1Value_ = executeArguments1_(frameValue);
return executeInt_(frameValue, arguments0Value_, arguments1Value_);
}
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, Object arguments1Value) {
if (RubyTypesGen.isImplicitInteger(arguments0Value) && RubyTypesGen.isImplicitInteger(arguments1Value)) {
return FchmodNode_.create(root, arguments0Value, arguments1Value);
}
return null;
}
@Override
protected final SpecializationNode createPolymorphic() {
return PolymorphicNode_.create(root);
}
protected final BaseNode_ getNext() {
return (BaseNode_) this.next;
}
protected final Object executeArguments0_(Frame frameValue) {
Class arguments0Type_ = root.arguments0Type_;
try {
if (arguments0Type_ == int.class) {
return root.arguments0_.executeInteger((VirtualFrame) frameValue);
} else if (arguments0Type_ == null) {
CompilerDirectives.transferToInterpreterAndInvalidate();
Class _type = Object.class;
try {
Object _value = root.arguments0_.execute((VirtualFrame) frameValue);
if (_value instanceof Integer) {
_type = int.class;
} else {
_type = Object.class;
}
return _value;
} finally {
root.arguments0Type_ = _type;
}
} else {
return root.arguments0_.execute((VirtualFrame) frameValue);
}
} catch (UnexpectedResultException ex) {
root.arguments0Type_ = Object.class;
return ex.getResult();
}
}
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();
}
}
}
@GeneratedBy(FchmodNode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(FchmodNodeGen root) {
super(root, 2147483647);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value) {
return (int) uninitialized(frameValue, arguments0Value, arguments1Value);
}
static BaseNode_ create(FchmodNodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(FchmodNode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(FchmodNodeGen 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 int executeInt(VirtualFrame frameValue) {
Object arguments0Value_ = executeArguments0_(frameValue);
Object arguments1Value_ = executeArguments1_(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value) {
return getNext().executeInt_(frameValue, arguments0Value, arguments1Value);
}
static BaseNode_ create(FchmodNodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "fchmod(int, int)", value = FchmodNode.class)
private static final class FchmodNode_ extends BaseNode_ {
private final Class arguments0ImplicitType;
private final Class arguments1ImplicitType;
FchmodNode_(FchmodNodeGen root, Object arguments0Value, Object arguments1Value) {
super(root, 1);
this.arguments0ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments0Value);
this.arguments1ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments1Value);
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.arguments0ImplicitType == ((FchmodNode_) other).arguments0ImplicitType && this.arguments1ImplicitType == ((FchmodNode_) other).arguments1ImplicitType;
}
@Override
public Object execute(VirtualFrame frameValue) {
return executeInt(frameValue);
}
@Override
public int executeInt(VirtualFrame frameValue) {
int arguments0Value_;
try {
if (arguments0ImplicitType == int.class) {
arguments0Value_ = root.arguments0_.executeInteger(frameValue);
} else {
Object arguments0Value__ = executeArguments0_(frameValue);
arguments0Value_ = RubyTypesGen.expectImplicitInteger(arguments0Value__, arguments0ImplicitType);
}
} catch (UnexpectedResultException ex) {
Object arguments1Value = executeArguments1_(frameValue);
return getNext().executeInt_(frameValue, ex.getResult(), arguments1Value);
}
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) {
return getNext().executeInt_(frameValue, arguments0Value_, ex.getResult());
}
return root.fchmod(arguments0Value_, arguments1Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value) {
if (RubyTypesGen.isImplicitInteger(arguments0Value, arguments0ImplicitType) && RubyTypesGen.isImplicitInteger(arguments1Value, arguments1ImplicitType)) {
int arguments0Value_ = RubyTypesGen.asImplicitInteger(arguments0Value, arguments0ImplicitType);
int arguments1Value_ = RubyTypesGen.asImplicitInteger(arguments1Value, arguments1ImplicitType);
return root.fchmod(arguments0Value_, arguments1Value_);
}
return getNext().executeInt_(frameValue, arguments0Value, arguments1Value);
}
static BaseNode_ create(FchmodNodeGen root, Object arguments0Value, Object arguments1Value) {
return new FchmodNode_(root, arguments0Value, arguments1Value);
}
}
}
}
@GeneratedBy(FsyncNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class FsyncNodeFactory implements NodeFactory {
private static FsyncNodeFactory fsyncNodeFactoryInstance;
private FsyncNodeFactory() {
}
@Override
public Class getNodeClass() {
return FsyncNode.class;
}
@Override
public List getExecutionSignature() {
return Arrays.asList(RubyNode.class);
}
@Override
public List getNodeSignatures() {
return Arrays.asList(Arrays.asList(RubyNode[].class));
}
@Override
public FsyncNode 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 (fsyncNodeFactoryInstance == null) {
fsyncNodeFactoryInstance = new FsyncNodeFactory();
}
return fsyncNodeFactoryInstance;
}
public static FsyncNode create(RubyNode[] arguments) {
return new FsyncNodeGen(arguments);
}
@GeneratedBy(FsyncNode.class)
public static final class FsyncNodeGen extends FsyncNode implements SpecializedNode {
@Child private RubyNode arguments0_;
@CompilationFinal private Class arguments0Type_;
@Child private BaseNode_ specialization_;
private FsyncNodeGen(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(FsyncNode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected FsyncNodeGen root;
BaseNode_(FsyncNodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (FsyncNodeGen) 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_ = executeArguments0_(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 (RubyTypesGen.isImplicitInteger(arguments0Value)) {
return FsyncNode_.create(root, arguments0Value);
}
return null;
}
@Override
protected final SpecializationNode createPolymorphic() {
return PolymorphicNode_.create(root);
}
protected final BaseNode_ getNext() {
return (BaseNode_) this.next;
}
protected final Object executeArguments0_(Frame frameValue) {
Class arguments0Type_ = root.arguments0Type_;
try {
if (arguments0Type_ == int.class) {
return root.arguments0_.executeInteger((VirtualFrame) frameValue);
} else if (arguments0Type_ == null) {
CompilerDirectives.transferToInterpreterAndInvalidate();
Class _type = Object.class;
try {
Object _value = root.arguments0_.execute((VirtualFrame) frameValue);
if (_value instanceof Integer) {
_type = int.class;
} else {
_type = Object.class;
}
return _value;
} finally {
root.arguments0Type_ = _type;
}
} else {
return root.arguments0_.execute((VirtualFrame) frameValue);
}
} catch (UnexpectedResultException ex) {
root.arguments0Type_ = Object.class;
return ex.getResult();
}
}
}
@GeneratedBy(FsyncNode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(FsyncNodeGen root) {
super(root, 2147483647);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value) {
return (int) uninitialized(frameValue, arguments0Value);
}
static BaseNode_ create(FsyncNodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(FsyncNode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(FsyncNodeGen 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_ = executeArguments0_(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value) {
return getNext().executeInt_(frameValue, arguments0Value);
}
static BaseNode_ create(FsyncNodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "fsync(int)", value = FsyncNode.class)
private static final class FsyncNode_ extends BaseNode_ {
private final Class arguments0ImplicitType;
FsyncNode_(FsyncNodeGen root, Object arguments0Value) {
super(root, 1);
this.arguments0ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments0Value);
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.arguments0ImplicitType == ((FsyncNode_) other).arguments0ImplicitType;
}
@Override
public Object execute(VirtualFrame frameValue) {
return executeInt(frameValue);
}
@Override
public int executeInt(VirtualFrame frameValue) {
int arguments0Value_;
try {
if (arguments0ImplicitType == int.class) {
arguments0Value_ = root.arguments0_.executeInteger(frameValue);
} else {
Object arguments0Value__ = executeArguments0_(frameValue);
arguments0Value_ = RubyTypesGen.expectImplicitInteger(arguments0Value__, arguments0ImplicitType);
}
} catch (UnexpectedResultException ex) {
return getNext().executeInt_(frameValue, ex.getResult());
}
return root.fsync(arguments0Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value) {
if (RubyTypesGen.isImplicitInteger(arguments0Value, arguments0ImplicitType)) {
int arguments0Value_ = RubyTypesGen.asImplicitInteger(arguments0Value, arguments0ImplicitType);
return root.fsync(arguments0Value_);
}
return getNext().executeInt_(frameValue, arguments0Value);
}
static BaseNode_ create(FsyncNodeGen root, Object arguments0Value) {
return new FsyncNode_(root, arguments0Value);
}
}
}
}
@GeneratedBy(FchownNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class FchownNodeFactory implements NodeFactory {
private static FchownNodeFactory fchownNodeFactoryInstance;
private FchownNodeFactory() {
}
@Override
public Class getNodeClass() {
return FchownNode.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 FchownNode 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 (fchownNodeFactoryInstance == null) {
fchownNodeFactoryInstance = new FchownNodeFactory();
}
return fchownNodeFactoryInstance;
}
public static FchownNode create(RubyNode[] arguments) {
return new FchownNodeGen(arguments);
}
@GeneratedBy(FchownNode.class)
public static final class FchownNodeGen extends FchownNode implements SpecializedNode {
@Child private RubyNode arguments0_;
@Child private RubyNode arguments1_;
@Child private RubyNode arguments2_;
@CompilationFinal private Class arguments0Type_;
@CompilationFinal private Class arguments1Type_;
@CompilationFinal private Class arguments2Type_;
@Child private BaseNode_ specialization_;
private FchownNodeGen(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 int executeInteger(VirtualFrame frameValue) {
return specialization_.executeInt(frameValue);
}
@Override
public SpecializationNode getSpecializationNode() {
return specialization_;
}
@Override
public Node deepCopy() {
return SpecializationNode.updateRoot(super.deepCopy());
}
@GeneratedBy(FchownNode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected FchownNodeGen root;
BaseNode_(FchownNodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (FchownNodeGen) 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.executeInt_((VirtualFrame) frameValue, arguments0Value, arguments1Value, arguments2Value);
}
public abstract int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value);
public Object execute(VirtualFrame frameValue) {
Object arguments0Value_ = executeArguments0_(frameValue);
Object arguments1Value_ = executeArguments1_(frameValue);
Object arguments2Value_ = executeArguments2_(frameValue);
return executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_);
}
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, Object arguments1Value, Object arguments2Value) {
if (RubyTypesGen.isImplicitInteger(arguments0Value) && RubyTypesGen.isImplicitInteger(arguments1Value) && RubyTypesGen.isImplicitInteger(arguments2Value)) {
return FchownNode_.create(root, arguments0Value, arguments1Value, arguments2Value);
}
return null;
}
@Override
protected final SpecializationNode createPolymorphic() {
return PolymorphicNode_.create(root);
}
protected final BaseNode_ getNext() {
return (BaseNode_) this.next;
}
protected final Object executeArguments0_(Frame frameValue) {
Class arguments0Type_ = root.arguments0Type_;
try {
if (arguments0Type_ == int.class) {
return root.arguments0_.executeInteger((VirtualFrame) frameValue);
} else if (arguments0Type_ == null) {
CompilerDirectives.transferToInterpreterAndInvalidate();
Class _type = Object.class;
try {
Object _value = root.arguments0_.execute((VirtualFrame) frameValue);
if (_value instanceof Integer) {
_type = int.class;
} else {
_type = Object.class;
}
return _value;
} finally {
root.arguments0Type_ = _type;
}
} else {
return root.arguments0_.execute((VirtualFrame) frameValue);
}
} catch (UnexpectedResultException ex) {
root.arguments0Type_ = Object.class;
return ex.getResult();
}
}
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(FchownNode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(FchownNodeGen root) {
super(root, 2147483647);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value) {
return (int) uninitialized(frameValue, arguments0Value, arguments1Value, arguments2Value);
}
static BaseNode_ create(FchownNodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(FchownNode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(FchownNodeGen 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 int executeInt(VirtualFrame frameValue) {
Object arguments0Value_ = executeArguments0_(frameValue);
Object arguments1Value_ = executeArguments1_(frameValue);
Object arguments2Value_ = executeArguments2_(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value) {
return getNext().executeInt_(frameValue, arguments0Value, arguments1Value, arguments2Value);
}
static BaseNode_ create(FchownNodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "fchown(int, int, int)", value = FchownNode.class)
private static final class FchownNode_ extends BaseNode_ {
private final Class arguments0ImplicitType;
private final Class arguments1ImplicitType;
private final Class arguments2ImplicitType;
FchownNode_(FchownNodeGen root, Object arguments0Value, Object arguments1Value, Object arguments2Value) {
super(root, 1);
this.arguments0ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments0Value);
this.arguments1ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments1Value);
this.arguments2ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments2Value);
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.arguments0ImplicitType == ((FchownNode_) other).arguments0ImplicitType && this.arguments1ImplicitType == ((FchownNode_) other).arguments1ImplicitType && this.arguments2ImplicitType == ((FchownNode_) other).arguments2ImplicitType;
}
@Override
public Object execute(VirtualFrame frameValue) {
return executeInt(frameValue);
}
@Override
public int executeInt(VirtualFrame frameValue) {
int arguments0Value_;
try {
if (arguments0ImplicitType == int.class) {
arguments0Value_ = root.arguments0_.executeInteger(frameValue);
} else {
Object arguments0Value__ = executeArguments0_(frameValue);
arguments0Value_ = RubyTypesGen.expectImplicitInteger(arguments0Value__, arguments0ImplicitType);
}
} catch (UnexpectedResultException ex) {
Object arguments1Value = executeArguments1_(frameValue);
Object arguments2Value = executeArguments2_(frameValue);
return getNext().executeInt_(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().executeInt_(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().executeInt_(frameValue, arguments0Value_, arguments1Value_, ex.getResult());
}
return root.fchown(arguments0Value_, arguments1Value_, arguments2Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value) {
if (RubyTypesGen.isImplicitInteger(arguments0Value, arguments0ImplicitType) && RubyTypesGen.isImplicitInteger(arguments1Value, arguments1ImplicitType) && RubyTypesGen.isImplicitInteger(arguments2Value, arguments2ImplicitType)) {
int arguments0Value_ = RubyTypesGen.asImplicitInteger(arguments0Value, arguments0ImplicitType);
int arguments1Value_ = RubyTypesGen.asImplicitInteger(arguments1Value, arguments1ImplicitType);
int arguments2Value_ = RubyTypesGen.asImplicitInteger(arguments2Value, arguments2ImplicitType);
return root.fchown(arguments0Value_, arguments1Value_, arguments2Value_);
}
return getNext().executeInt_(frameValue, arguments0Value, arguments1Value, arguments2Value);
}
static BaseNode_ create(FchownNodeGen root, Object arguments0Value, Object arguments1Value, Object arguments2Value) {
return new FchownNode_(root, arguments0Value, arguments1Value, arguments2Value);
}
}
}
}
@GeneratedBy(GetEGIDNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class GetEGIDNodeFactory implements NodeFactory {
private static GetEGIDNodeFactory getEGIDNodeFactoryInstance;
private GetEGIDNodeFactory() {
}
@Override
public Class getNodeClass() {
return GetEGIDNode.class;
}
@Override
public List getExecutionSignature() {
return Arrays.asList();
}
@Override
public List getNodeSignatures() {
return Arrays.asList(Arrays.asList(RubyNode[].class));
}
@Override
public GetEGIDNode 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 (getEGIDNodeFactoryInstance == null) {
getEGIDNodeFactoryInstance = new GetEGIDNodeFactory();
}
return getEGIDNodeFactoryInstance;
}
public static GetEGIDNode create(RubyNode[] arguments) {
return new GetEGIDNodeGen(arguments);
}
@GeneratedBy(GetEGIDNode.class)
public static final class GetEGIDNodeGen extends GetEGIDNode {
@SuppressWarnings("unused")
private GetEGIDNodeGen(RubyNode[] arguments) {
}
@Override
public NodeCost getCost() {
return NodeCost.MONOMORPHIC;
}
@Override
public Object execute(VirtualFrame frameValue) {
return executeInteger(frameValue);
}
@Override
public void executeVoid(VirtualFrame frameValue) {
executeInteger(frameValue);
return;
}
@Override
public int executeInteger(VirtualFrame frameValue) {
return this.getEGID();
}
}
}
@GeneratedBy(GetenvNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class GetenvNodeFactory implements NodeFactory {
private static GetenvNodeFactory getenvNodeFactoryInstance;
private GetenvNodeFactory() {
}
@Override
public Class getNodeClass() {
return GetenvNode.class;
}
@Override
public List getExecutionSignature() {
return Arrays.asList(RubyNode.class);
}
@Override
public List getNodeSignatures() {
return Arrays.asList(Arrays.asList(RubyNode[].class));
}
@Override
public GetenvNode 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 (getenvNodeFactoryInstance == null) {
getenvNodeFactoryInstance = new GetenvNodeFactory();
}
return getenvNodeFactoryInstance;
}
public static GetenvNode create(RubyNode[] arguments) {
return new GetenvNodeGen(arguments);
}
@GeneratedBy(GetenvNode.class)
public static final class GetenvNodeGen extends GetenvNode {
@Child private RubyNode arguments0_;
@CompilationFinal private boolean seenUnsupported0;
private GetenvNodeGen(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());
}
if ((RubyGuards.isRubyString(arguments0Value_))) {
return this.getenv(arguments0Value_);
}
throw unsupported(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);
}
}
}
@GeneratedBy(GetEUIDNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class GetEUIDNodeFactory implements NodeFactory {
private static GetEUIDNodeFactory getEUIDNodeFactoryInstance;
private GetEUIDNodeFactory() {
}
@Override
public Class getNodeClass() {
return GetEUIDNode.class;
}
@Override
public List getExecutionSignature() {
return Arrays.asList();
}
@Override
public List getNodeSignatures() {
return Arrays.asList(Arrays.asList(RubyNode[].class));
}
@Override
public GetEUIDNode 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 (getEUIDNodeFactoryInstance == null) {
getEUIDNodeFactoryInstance = new GetEUIDNodeFactory();
}
return getEUIDNodeFactoryInstance;
}
public static GetEUIDNode create(RubyNode[] arguments) {
return new GetEUIDNodeGen(arguments);
}
@GeneratedBy(GetEUIDNode.class)
public static final class GetEUIDNodeGen extends GetEUIDNode {
@SuppressWarnings("unused")
private GetEUIDNodeGen(RubyNode[] arguments) {
}
@Override
public NodeCost getCost() {
return NodeCost.MONOMORPHIC;
}
@Override
public Object execute(VirtualFrame frameValue) {
return executeInteger(frameValue);
}
@Override
public void executeVoid(VirtualFrame frameValue) {
executeInteger(frameValue);
return;
}
@Override
public int executeInteger(VirtualFrame frameValue) {
return this.getEUID();
}
}
}
@GeneratedBy(GetGIDNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class GetGIDNodeFactory implements NodeFactory {
private static GetGIDNodeFactory getGIDNodeFactoryInstance;
private GetGIDNodeFactory() {
}
@Override
public Class getNodeClass() {
return GetGIDNode.class;
}
@Override
public List getExecutionSignature() {
return Arrays.asList();
}
@Override
public List getNodeSignatures() {
return Arrays.asList(Arrays.asList(RubyNode[].class));
}
@Override
public GetGIDNode 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 (getGIDNodeFactoryInstance == null) {
getGIDNodeFactoryInstance = new GetGIDNodeFactory();
}
return getGIDNodeFactoryInstance;
}
public static GetGIDNode create(RubyNode[] arguments) {
return new GetGIDNodeGen(arguments);
}
@GeneratedBy(GetGIDNode.class)
public static final class GetGIDNodeGen extends GetGIDNode {
@SuppressWarnings("unused")
private GetGIDNodeGen(RubyNode[] arguments) {
}
@Override
public NodeCost getCost() {
return NodeCost.MONOMORPHIC;
}
@Override
public Object execute(VirtualFrame frameValue) {
return executeInteger(frameValue);
}
@Override
public void executeVoid(VirtualFrame frameValue) {
executeInteger(frameValue);
return;
}
@Override
public int executeInteger(VirtualFrame frameValue) {
return this.getGID();
}
}
}
@GeneratedBy(GetGroupsNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class GetGroupsNodeFactory implements NodeFactory {
private static GetGroupsNodeFactory getGroupsNodeFactoryInstance;
private GetGroupsNodeFactory() {
}
@Override
public Class getNodeClass() {
return GetGroupsNode.class;
}
@Override
public List getExecutionSignature() {
return Arrays.asList();
}
@Override
public List getNodeSignatures() {
return Arrays.asList(Arrays.asList(RubyNode[].class));
}
@Override
public GetGroupsNode 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 (getGroupsNodeFactoryInstance == null) {
getGroupsNodeFactoryInstance = new GetGroupsNodeFactory();
}
return getGroupsNodeFactoryInstance;
}
public static GetGroupsNode create(RubyNode[] arguments) {
return new GetGroupsNodeGen(arguments);
}
@GeneratedBy(GetGroupsNode.class)
public static final class GetGroupsNodeGen extends GetGroupsNode {
@SuppressWarnings("unused")
private GetGroupsNodeGen(RubyNode[] arguments) {
}
@Override
public NodeCost getCost() {
return NodeCost.MONOMORPHIC;
}
@Override
public Object execute(VirtualFrame frameValue) {
return this.getgroups();
}
@Override
public void executeVoid(VirtualFrame frameValue) {
execute(frameValue);
return;
}
}
}
@GeneratedBy(GetRLimitNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class GetRLimitNodeFactory implements NodeFactory {
private static GetRLimitNodeFactory getRLimitNodeFactoryInstance;
private GetRLimitNodeFactory() {
}
@Override
public Class getNodeClass() {
return GetRLimitNode.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 GetRLimitNode 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 (getRLimitNodeFactoryInstance == null) {
getRLimitNodeFactoryInstance = new GetRLimitNodeFactory();
}
return getRLimitNodeFactoryInstance;
}
public static GetRLimitNode create(RubyNode[] arguments) {
return new GetRLimitNodeGen(arguments);
}
@GeneratedBy(GetRLimitNode.class)
public static final class GetRLimitNodeGen extends GetRLimitNode implements SpecializedNode {
@Child private RubyNode arguments0_;
@Child private RubyNode arguments1_;
@CompilationFinal private Class arguments0Type_;
@Child private BaseNode_ specialization_;
private GetRLimitNodeGen(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) {
return specialization_.executeInt(frameValue);
}
@Override
public SpecializationNode getSpecializationNode() {
return specialization_;
}
@Override
public Node deepCopy() {
return SpecializationNode.updateRoot(super.deepCopy());
}
@GeneratedBy(GetRLimitNode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected GetRLimitNodeGen root;
BaseNode_(GetRLimitNodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (GetRLimitNodeGen) 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.executeInt_((VirtualFrame) frameValue, arguments0Value, arguments1Value);
}
public abstract int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value);
public Object execute(VirtualFrame frameValue) {
Object arguments0Value_ = executeArguments0_(frameValue);
Object arguments1Value_ = root.arguments1_.execute(frameValue);
return executeInt_(frameValue, arguments0Value_, arguments1Value_);
}
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, Object arguments1Value) {
if (RubyTypesGen.isImplicitInteger(arguments0Value) && arguments1Value instanceof DynamicObject) {
DynamicObject arguments1Value_ = (DynamicObject) arguments1Value;
if ((RubyGuards.isRubyPointer(arguments1Value_))) {
return GetrlimitNode_.create(root, arguments0Value);
}
}
return null;
}
@Override
protected final SpecializationNode createPolymorphic() {
return PolymorphicNode_.create(root);
}
protected final BaseNode_ getNext() {
return (BaseNode_) this.next;
}
protected final Object executeArguments0_(Frame frameValue) {
Class arguments0Type_ = root.arguments0Type_;
try {
if (arguments0Type_ == int.class) {
return root.arguments0_.executeInteger((VirtualFrame) frameValue);
} else if (arguments0Type_ == null) {
CompilerDirectives.transferToInterpreterAndInvalidate();
Class _type = Object.class;
try {
Object _value = root.arguments0_.execute((VirtualFrame) frameValue);
if (_value instanceof Integer) {
_type = int.class;
} else {
_type = Object.class;
}
return _value;
} finally {
root.arguments0Type_ = _type;
}
} else {
return root.arguments0_.execute((VirtualFrame) frameValue);
}
} catch (UnexpectedResultException ex) {
root.arguments0Type_ = Object.class;
return ex.getResult();
}
}
}
@GeneratedBy(GetRLimitNode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(GetRLimitNodeGen root) {
super(root, 2147483647);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value) {
return (int) uninitialized(frameValue, arguments0Value, arguments1Value);
}
static BaseNode_ create(GetRLimitNodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(GetRLimitNode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(GetRLimitNodeGen 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 int executeInt(VirtualFrame frameValue) {
Object arguments0Value_ = executeArguments0_(frameValue);
Object arguments1Value_ = root.arguments1_.execute(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value) {
return getNext().executeInt_(frameValue, arguments0Value, arguments1Value);
}
static BaseNode_ create(GetRLimitNodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "getrlimit(int, DynamicObject)", value = GetRLimitNode.class)
private static final class GetrlimitNode_ extends BaseNode_ {
private final Class arguments0ImplicitType;
GetrlimitNode_(GetRLimitNodeGen root, Object arguments0Value) {
super(root, 1);
this.arguments0ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments0Value);
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.arguments0ImplicitType == ((GetrlimitNode_) other).arguments0ImplicitType;
}
@Override
public Object execute(VirtualFrame frameValue) {
return executeInt(frameValue);
}
@Override
public int executeInt(VirtualFrame frameValue) {
int arguments0Value_;
try {
if (arguments0ImplicitType == int.class) {
arguments0Value_ = root.arguments0_.executeInteger(frameValue);
} else {
Object arguments0Value__ = executeArguments0_(frameValue);
arguments0Value_ = RubyTypesGen.expectImplicitInteger(arguments0Value__, arguments0ImplicitType);
}
} catch (UnexpectedResultException ex) {
Object arguments1Value = root.arguments1_.execute(frameValue);
return getNext().executeInt_(frameValue, ex.getResult(), arguments1Value);
}
DynamicObject arguments1Value_;
try {
arguments1Value_ = root.arguments1_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
return getNext().executeInt_(frameValue, arguments0Value_, ex.getResult());
}
if ((RubyGuards.isRubyPointer(arguments1Value_))) {
return root.getrlimit(arguments0Value_, arguments1Value_);
}
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value) {
if (RubyTypesGen.isImplicitInteger(arguments0Value, arguments0ImplicitType) && arguments1Value instanceof DynamicObject) {
int arguments0Value_ = RubyTypesGen.asImplicitInteger(arguments0Value, arguments0ImplicitType);
DynamicObject arguments1Value_ = (DynamicObject) arguments1Value;
if ((RubyGuards.isRubyPointer(arguments1Value_))) {
return root.getrlimit(arguments0Value_, arguments1Value_);
}
}
return getNext().executeInt_(frameValue, arguments0Value, arguments1Value);
}
static BaseNode_ create(GetRLimitNodeGen root, Object arguments0Value) {
return new GetrlimitNode_(root, arguments0Value);
}
}
}
}
@GeneratedBy(GetUIDNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class GetUIDNodeFactory implements NodeFactory {
private static GetUIDNodeFactory getUIDNodeFactoryInstance;
private GetUIDNodeFactory() {
}
@Override
public Class getNodeClass() {
return GetUIDNode.class;
}
@Override
public List getExecutionSignature() {
return Arrays.asList();
}
@Override
public List getNodeSignatures() {
return Arrays.asList(Arrays.asList(RubyNode[].class));
}
@Override
public GetUIDNode 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 (getUIDNodeFactoryInstance == null) {
getUIDNodeFactoryInstance = new GetUIDNodeFactory();
}
return getUIDNodeFactoryInstance;
}
public static GetUIDNode create(RubyNode[] arguments) {
return new GetUIDNodeGen(arguments);
}
@GeneratedBy(GetUIDNode.class)
public static final class GetUIDNodeGen extends GetUIDNode {
@SuppressWarnings("unused")
private GetUIDNodeGen(RubyNode[] arguments) {
}
@Override
public NodeCost getCost() {
return NodeCost.MONOMORPHIC;
}
@Override
public Object execute(VirtualFrame frameValue) {
return executeInteger(frameValue);
}
@Override
public void executeVoid(VirtualFrame frameValue) {
executeInteger(frameValue);
return;
}
@Override
public int executeInteger(VirtualFrame frameValue) {
return this.getUID();
}
}
}
@GeneratedBy(MemsetNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class MemsetNodeFactory implements NodeFactory {
private static MemsetNodeFactory memsetNodeFactoryInstance;
private MemsetNodeFactory() {
}
@Override
public Class getNodeClass() {
return MemsetNode.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 MemsetNode 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 (memsetNodeFactoryInstance == null) {
memsetNodeFactoryInstance = new MemsetNodeFactory();
}
return memsetNodeFactoryInstance;
}
public static MemsetNode create(RubyNode[] arguments) {
return new MemsetNodeGen(arguments);
}
@GeneratedBy(MemsetNode.class)
public static final class MemsetNodeGen extends MemsetNode 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 MemsetNodeGen(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 DynamicObject executeDynamicObject(VirtualFrame frameValue) {
return specialization_.executeDynamicObject(frameValue);
}
@Override
public SpecializationNode getSpecializationNode() {
return specialization_;
}
@Override
public Node deepCopy() {
return SpecializationNode.updateRoot(super.deepCopy());
}
@GeneratedBy(MemsetNode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected MemsetNodeGen root;
BaseNode_(MemsetNodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (MemsetNodeGen) 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.executeDynamicObject_((VirtualFrame) frameValue, arguments0Value, arguments1Value, arguments2Value);
}
public abstract DynamicObject executeDynamicObject_(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 executeDynamicObject_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_);
}
public void executeVoid(VirtualFrame frameValue) {
execute(frameValue);
return;
}
public DynamicObject executeDynamicObject(VirtualFrame frameValue) {
return (DynamicObject) execute(frameValue);
}
@Override
protected final SpecializationNode createNext(Frame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value) {
if (arguments0Value instanceof DynamicObject && RubyTypesGen.isImplicitInteger(arguments1Value) && RubyTypesGen.isImplicitLong(arguments2Value)) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
if ((RubyGuards.isRubyPointer(arguments0Value_))) {
return MemsetNode_.create(root, arguments1Value, arguments2Value);
}
}
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_ == long.class) {
return root.arguments2_.executeLong((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 if (_value instanceof Long) {
_type = long.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(MemsetNode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(MemsetNodeGen root) {
super(root, 2147483647);
}
@Override
public DynamicObject executeDynamicObject_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value) {
return (DynamicObject) uninitialized(frameValue, arguments0Value, arguments1Value, arguments2Value);
}
static BaseNode_ create(MemsetNodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(MemsetNode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(MemsetNodeGen 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 DynamicObject executeDynamicObject_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value) {
return getNext().executeDynamicObject_(frameValue, arguments0Value, arguments1Value, arguments2Value);
}
static BaseNode_ create(MemsetNodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "memset(DynamicObject, int, long)", value = MemsetNode.class)
private static final class MemsetNode_ extends BaseNode_ {
private final Class arguments1ImplicitType;
private final Class arguments2ImplicitType;
MemsetNode_(MemsetNodeGen root, Object arguments1Value, Object arguments2Value) {
super(root, 1);
this.arguments1ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments1Value);
this.arguments2ImplicitType = RubyTypesGen.getImplicitLongClass(arguments2Value);
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.arguments1ImplicitType == ((MemsetNode_) other).arguments1ImplicitType && this.arguments2ImplicitType == ((MemsetNode_) other).arguments2ImplicitType;
}
@Override
public Object execute(VirtualFrame frameValue) {
return executeDynamicObject(frameValue);
}
@Override
public DynamicObject executeDynamicObject(VirtualFrame frameValue) {
DynamicObject arguments0Value_;
try {
arguments0Value_ = root.arguments0_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object arguments1Value = executeArguments1_(frameValue);
Object arguments2Value = executeArguments2_(frameValue);
return getNext().executeDynamicObject_(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().executeDynamicObject_(frameValue, arguments0Value_, ex.getResult(), arguments2Value);
}
long arguments2Value_;
try {
if (arguments2ImplicitType == long.class) {
arguments2Value_ = root.arguments2_.executeLong(frameValue);
} else if (arguments2ImplicitType == int.class) {
arguments2Value_ = RubyTypes.promoteToLong(root.arguments2_.executeInteger(frameValue));
} else {
Object arguments2Value__ = executeArguments2_(frameValue);
arguments2Value_ = RubyTypesGen.expectImplicitLong(arguments2Value__, arguments2ImplicitType);
}
} catch (UnexpectedResultException ex) {
return getNext().executeDynamicObject_(frameValue, arguments0Value_, arguments1Value_, ex.getResult());
}
if ((RubyGuards.isRubyPointer(arguments0Value_))) {
return root.memset(arguments0Value_, arguments1Value_, arguments2Value_);
}
return getNext().executeDynamicObject_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_);
}
@Override
public DynamicObject executeDynamicObject_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value) {
if (arguments0Value instanceof DynamicObject && RubyTypesGen.isImplicitInteger(arguments1Value, arguments1ImplicitType) && RubyTypesGen.isImplicitLong(arguments2Value, arguments2ImplicitType)) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
int arguments1Value_ = RubyTypesGen.asImplicitInteger(arguments1Value, arguments1ImplicitType);
long arguments2Value_ = RubyTypesGen.asImplicitLong(arguments2Value, arguments2ImplicitType);
if ((RubyGuards.isRubyPointer(arguments0Value_))) {
return root.memset(arguments0Value_, arguments1Value_, arguments2Value_);
}
}
return getNext().executeDynamicObject_(frameValue, arguments0Value, arguments1Value, arguments2Value);
}
static BaseNode_ create(MemsetNodeGen root, Object arguments1Value, Object arguments2Value) {
return new MemsetNode_(root, arguments1Value, arguments2Value);
}
}
}
}
@GeneratedBy(MkfifoNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class MkfifoNodeFactory implements NodeFactory {
private static MkfifoNodeFactory mkfifoNodeFactoryInstance;
private MkfifoNodeFactory() {
}
@Override
public Class getNodeClass() {
return MkfifoNode.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 MkfifoNode 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 (mkfifoNodeFactoryInstance == null) {
mkfifoNodeFactoryInstance = new MkfifoNodeFactory();
}
return mkfifoNodeFactoryInstance;
}
public static MkfifoNode create(RubyNode[] arguments) {
return new MkfifoNodeGen(arguments);
}
@GeneratedBy(MkfifoNode.class)
public static final class MkfifoNodeGen extends MkfifoNode implements SpecializedNode {
@Child private RubyNode arguments0_;
@Child private RubyNode arguments1_;
@CompilationFinal private Class arguments1Type_;
@Child private BaseNode_ specialization_;
private MkfifoNodeGen(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) {
return specialization_.executeInt(frameValue);
}
@Override
public SpecializationNode getSpecializationNode() {
return specialization_;
}
@Override
public Node deepCopy() {
return SpecializationNode.updateRoot(super.deepCopy());
}
@GeneratedBy(MkfifoNode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected MkfifoNodeGen root;
BaseNode_(MkfifoNodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (MkfifoNodeGen) 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.executeInt_((VirtualFrame) frameValue, arguments0Value, arguments1Value);
}
public abstract int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value);
public Object execute(VirtualFrame frameValue) {
Object arguments0Value_ = root.arguments0_.execute(frameValue);
Object arguments1Value_ = executeArguments1_(frameValue);
return executeInt_(frameValue, arguments0Value_, arguments1Value_);
}
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, Object arguments1Value) {
if (arguments0Value instanceof DynamicObject && RubyTypesGen.isImplicitInteger(arguments1Value)) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
if ((RubyGuards.isRubyString(arguments0Value_))) {
return MkfifoNode_.create(root, arguments1Value);
}
}
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();
}
}
}
@GeneratedBy(MkfifoNode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(MkfifoNodeGen root) {
super(root, 2147483647);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value) {
return (int) uninitialized(frameValue, arguments0Value, arguments1Value);
}
static BaseNode_ create(MkfifoNodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(MkfifoNode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(MkfifoNodeGen 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 int executeInt(VirtualFrame frameValue) {
Object arguments0Value_ = root.arguments0_.execute(frameValue);
Object arguments1Value_ = executeArguments1_(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value) {
return getNext().executeInt_(frameValue, arguments0Value, arguments1Value);
}
static BaseNode_ create(MkfifoNodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "mkfifo(DynamicObject, int)", value = MkfifoNode.class)
private static final class MkfifoNode_ extends BaseNode_ {
private final Class arguments1ImplicitType;
MkfifoNode_(MkfifoNodeGen root, Object arguments1Value) {
super(root, 1);
this.arguments1ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments1Value);
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.arguments1ImplicitType == ((MkfifoNode_) other).arguments1ImplicitType;
}
@Override
public Object execute(VirtualFrame frameValue) {
return executeInt(frameValue);
}
@Override
public int executeInt(VirtualFrame frameValue) {
DynamicObject arguments0Value_;
try {
arguments0Value_ = root.arguments0_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object arguments1Value = executeArguments1_(frameValue);
return getNext().executeInt_(frameValue, ex.getResult(), arguments1Value);
}
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) {
return getNext().executeInt_(frameValue, arguments0Value_, ex.getResult());
}
if ((RubyGuards.isRubyString(arguments0Value_))) {
return root.mkfifo(arguments0Value_, arguments1Value_);
}
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value) {
if (arguments0Value instanceof DynamicObject && RubyTypesGen.isImplicitInteger(arguments1Value, arguments1ImplicitType)) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
int arguments1Value_ = RubyTypesGen.asImplicitInteger(arguments1Value, arguments1ImplicitType);
if ((RubyGuards.isRubyString(arguments0Value_))) {
return root.mkfifo(arguments0Value_, arguments1Value_);
}
}
return getNext().executeInt_(frameValue, arguments0Value, arguments1Value);
}
static BaseNode_ create(MkfifoNodeGen root, Object arguments1Value) {
return new MkfifoNode_(root, arguments1Value);
}
}
}
}
@GeneratedBy(ReadlinkNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class ReadlinkNodeFactory implements NodeFactory {
private static ReadlinkNodeFactory readlinkNodeFactoryInstance;
private ReadlinkNodeFactory() {
}
@Override
public Class getNodeClass() {
return ReadlinkNode.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 ReadlinkNode 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 (readlinkNodeFactoryInstance == null) {
readlinkNodeFactoryInstance = new ReadlinkNodeFactory();
}
return readlinkNodeFactoryInstance;
}
public static ReadlinkNode create(RubyNode[] arguments) {
return new ReadlinkNodeGen(arguments);
}
@GeneratedBy(ReadlinkNode.class)
public static final class ReadlinkNodeGen extends ReadlinkNode implements SpecializedNode {
@Child private RubyNode arguments0_;
@Child private RubyNode arguments1_;
@Child private RubyNode arguments2_;
@CompilationFinal private Class arguments2Type_;
@Child private BaseNode_ specialization_;
private ReadlinkNodeGen(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 int executeInteger(VirtualFrame frameValue) {
return specialization_.executeInt(frameValue);
}
@Override
public SpecializationNode getSpecializationNode() {
return specialization_;
}
@Override
public Node deepCopy() {
return SpecializationNode.updateRoot(super.deepCopy());
}
@GeneratedBy(ReadlinkNode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected ReadlinkNodeGen root;
BaseNode_(ReadlinkNodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (ReadlinkNodeGen) 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.executeInt_((VirtualFrame) frameValue, arguments0Value, arguments1Value, arguments2Value);
}
public abstract int executeInt_(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 executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_);
}
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, Object arguments1Value, Object arguments2Value) {
if (arguments0Value instanceof DynamicObject && arguments1Value instanceof DynamicObject && RubyTypesGen.isImplicitInteger(arguments2Value)) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
DynamicObject arguments1Value_ = (DynamicObject) arguments1Value;
if ((RubyGuards.isRubyString(arguments0Value_)) && (RubyGuards.isRubyPointer(arguments1Value_))) {
return ReadlinkNode_.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(ReadlinkNode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(ReadlinkNodeGen root) {
super(root, 2147483647);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value) {
return (int) uninitialized(frameValue, arguments0Value, arguments1Value, arguments2Value);
}
static BaseNode_ create(ReadlinkNodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(ReadlinkNode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(ReadlinkNodeGen 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 int executeInt(VirtualFrame frameValue) {
Object arguments0Value_ = root.arguments0_.execute(frameValue);
Object arguments1Value_ = root.arguments1_.execute(frameValue);
Object arguments2Value_ = executeArguments2_(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value) {
return getNext().executeInt_(frameValue, arguments0Value, arguments1Value, arguments2Value);
}
static BaseNode_ create(ReadlinkNodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "readlink(DynamicObject, DynamicObject, int)", value = ReadlinkNode.class)
private static final class ReadlinkNode_ extends BaseNode_ {
private final Class arguments2ImplicitType;
ReadlinkNode_(ReadlinkNodeGen root, Object arguments2Value) {
super(root, 1);
this.arguments2ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments2Value);
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.arguments2ImplicitType == ((ReadlinkNode_) other).arguments2ImplicitType;
}
@Override
public Object execute(VirtualFrame frameValue) {
return executeInt(frameValue);
}
@Override
public int executeInt(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().executeInt_(frameValue, ex.getResult(), arguments1Value, arguments2Value);
}
DynamicObject arguments1Value_;
try {
arguments1Value_ = root.arguments1_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object arguments2Value = executeArguments2_(frameValue);
return getNext().executeInt_(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().executeInt_(frameValue, arguments0Value_, arguments1Value_, ex.getResult());
}
if ((RubyGuards.isRubyString(arguments0Value_)) && (RubyGuards.isRubyPointer(arguments1Value_))) {
return root.readlink(arguments0Value_, arguments1Value_, arguments2Value_);
}
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value) {
if (arguments0Value instanceof DynamicObject && arguments1Value instanceof DynamicObject && RubyTypesGen.isImplicitInteger(arguments2Value, arguments2ImplicitType)) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
DynamicObject arguments1Value_ = (DynamicObject) arguments1Value;
int arguments2Value_ = RubyTypesGen.asImplicitInteger(arguments2Value, arguments2ImplicitType);
if ((RubyGuards.isRubyString(arguments0Value_)) && (RubyGuards.isRubyPointer(arguments1Value_))) {
return root.readlink(arguments0Value_, arguments1Value_, arguments2Value_);
}
}
return getNext().executeInt_(frameValue, arguments0Value, arguments1Value, arguments2Value);
}
static BaseNode_ create(ReadlinkNodeGen root, Object arguments2Value) {
return new ReadlinkNode_(root, arguments2Value);
}
}
}
}
@GeneratedBy(SetenvNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class SetenvNodeFactory implements NodeFactory {
private static SetenvNodeFactory setenvNodeFactoryInstance;
private SetenvNodeFactory() {
}
@Override
public Class getNodeClass() {
return SetenvNode.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 SetenvNode 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 (setenvNodeFactoryInstance == null) {
setenvNodeFactoryInstance = new SetenvNodeFactory();
}
return setenvNodeFactoryInstance;
}
public static SetenvNode create(RubyNode[] arguments) {
return new SetenvNodeGen(arguments);
}
@GeneratedBy(SetenvNode.class)
public static final class SetenvNodeGen extends SetenvNode implements SpecializedNode {
@Child private RubyNode arguments0_;
@Child private RubyNode arguments1_;
@Child private RubyNode arguments2_;
@CompilationFinal private Class arguments2Type_;
@Child private BaseNode_ specialization_;
private SetenvNodeGen(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 int executeInteger(VirtualFrame frameValue) {
return specialization_.executeInt(frameValue);
}
@Override
public SpecializationNode getSpecializationNode() {
return specialization_;
}
@Override
public Node deepCopy() {
return SpecializationNode.updateRoot(super.deepCopy());
}
@GeneratedBy(SetenvNode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected SetenvNodeGen root;
BaseNode_(SetenvNodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (SetenvNodeGen) 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.executeInt_((VirtualFrame) frameValue, arguments0Value, arguments1Value, arguments2Value);
}
public abstract int executeInt_(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 executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_);
}
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, Object arguments1Value, Object arguments2Value) {
if (arguments0Value instanceof DynamicObject && arguments1Value instanceof DynamicObject && RubyTypesGen.isImplicitInteger(arguments2Value)) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
DynamicObject arguments1Value_ = (DynamicObject) arguments1Value;
if ((RubyGuards.isRubyString(arguments0Value_)) && (RubyGuards.isRubyString(arguments1Value_))) {
return SetenvNode_.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(SetenvNode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(SetenvNodeGen root) {
super(root, 2147483647);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value) {
return (int) uninitialized(frameValue, arguments0Value, arguments1Value, arguments2Value);
}
static BaseNode_ create(SetenvNodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(SetenvNode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(SetenvNodeGen 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 int executeInt(VirtualFrame frameValue) {
Object arguments0Value_ = root.arguments0_.execute(frameValue);
Object arguments1Value_ = root.arguments1_.execute(frameValue);
Object arguments2Value_ = executeArguments2_(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value) {
return getNext().executeInt_(frameValue, arguments0Value, arguments1Value, arguments2Value);
}
static BaseNode_ create(SetenvNodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "setenv(DynamicObject, DynamicObject, int)", value = SetenvNode.class)
private static final class SetenvNode_ extends BaseNode_ {
private final Class arguments2ImplicitType;
SetenvNode_(SetenvNodeGen root, Object arguments2Value) {
super(root, 1);
this.arguments2ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments2Value);
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.arguments2ImplicitType == ((SetenvNode_) other).arguments2ImplicitType;
}
@Override
public Object execute(VirtualFrame frameValue) {
return executeInt(frameValue);
}
@Override
public int executeInt(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().executeInt_(frameValue, ex.getResult(), arguments1Value, arguments2Value);
}
DynamicObject arguments1Value_;
try {
arguments1Value_ = root.arguments1_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object arguments2Value = executeArguments2_(frameValue);
return getNext().executeInt_(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().executeInt_(frameValue, arguments0Value_, arguments1Value_, ex.getResult());
}
if ((RubyGuards.isRubyString(arguments0Value_)) && (RubyGuards.isRubyString(arguments1Value_))) {
return root.setenv(arguments0Value_, arguments1Value_, arguments2Value_);
}
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value) {
if (arguments0Value instanceof DynamicObject && arguments1Value instanceof DynamicObject && RubyTypesGen.isImplicitInteger(arguments2Value, arguments2ImplicitType)) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
DynamicObject arguments1Value_ = (DynamicObject) arguments1Value;
int arguments2Value_ = RubyTypesGen.asImplicitInteger(arguments2Value, arguments2ImplicitType);
if ((RubyGuards.isRubyString(arguments0Value_)) && (RubyGuards.isRubyString(arguments1Value_))) {
return root.setenv(arguments0Value_, arguments1Value_, arguments2Value_);
}
}
return getNext().executeInt_(frameValue, arguments0Value, arguments1Value, arguments2Value);
}
static BaseNode_ create(SetenvNodeGen root, Object arguments2Value) {
return new SetenvNode_(root, arguments2Value);
}
}
}
}
@GeneratedBy(LchmodNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class LchmodNodeFactory implements NodeFactory {
private static LchmodNodeFactory lchmodNodeFactoryInstance;
private LchmodNodeFactory() {
}
@Override
public Class getNodeClass() {
return LchmodNode.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 LchmodNode 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 (lchmodNodeFactoryInstance == null) {
lchmodNodeFactoryInstance = new LchmodNodeFactory();
}
return lchmodNodeFactoryInstance;
}
public static LchmodNode create(RubyNode[] arguments) {
return new LchmodNodeGen(arguments);
}
@GeneratedBy(LchmodNode.class)
public static final class LchmodNodeGen extends LchmodNode implements SpecializedNode {
@Child private RubyNode arguments0_;
@Child private RubyNode arguments1_;
@CompilationFinal private Class arguments1Type_;
@Child private BaseNode_ specialization_;
private LchmodNodeGen(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) {
return specialization_.executeInt(frameValue);
}
@Override
public SpecializationNode getSpecializationNode() {
return specialization_;
}
@Override
public Node deepCopy() {
return SpecializationNode.updateRoot(super.deepCopy());
}
@GeneratedBy(LchmodNode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected LchmodNodeGen root;
BaseNode_(LchmodNodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (LchmodNodeGen) 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.executeInt_((VirtualFrame) frameValue, arguments0Value, arguments1Value);
}
public abstract int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value);
public Object execute(VirtualFrame frameValue) {
Object arguments0Value_ = root.arguments0_.execute(frameValue);
Object arguments1Value_ = executeArguments1_(frameValue);
return executeInt_(frameValue, arguments0Value_, arguments1Value_);
}
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, Object arguments1Value) {
if (arguments0Value instanceof DynamicObject && RubyTypesGen.isImplicitInteger(arguments1Value)) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
if ((RubyGuards.isRubyString(arguments0Value_))) {
return LchmodNode_.create(root, arguments1Value);
}
}
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();
}
}
}
@GeneratedBy(LchmodNode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(LchmodNodeGen root) {
super(root, 2147483647);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value) {
return (int) uninitialized(frameValue, arguments0Value, arguments1Value);
}
static BaseNode_ create(LchmodNodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(LchmodNode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(LchmodNodeGen 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 int executeInt(VirtualFrame frameValue) {
Object arguments0Value_ = root.arguments0_.execute(frameValue);
Object arguments1Value_ = executeArguments1_(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value) {
return getNext().executeInt_(frameValue, arguments0Value, arguments1Value);
}
static BaseNode_ create(LchmodNodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "lchmod(DynamicObject, int)", value = LchmodNode.class)
private static final class LchmodNode_ extends BaseNode_ {
private final Class arguments1ImplicitType;
LchmodNode_(LchmodNodeGen root, Object arguments1Value) {
super(root, 1);
this.arguments1ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments1Value);
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.arguments1ImplicitType == ((LchmodNode_) other).arguments1ImplicitType;
}
@Override
public Object execute(VirtualFrame frameValue) {
return executeInt(frameValue);
}
@Override
public int executeInt(VirtualFrame frameValue) {
DynamicObject arguments0Value_;
try {
arguments0Value_ = root.arguments0_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object arguments1Value = executeArguments1_(frameValue);
return getNext().executeInt_(frameValue, ex.getResult(), arguments1Value);
}
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) {
return getNext().executeInt_(frameValue, arguments0Value_, ex.getResult());
}
if ((RubyGuards.isRubyString(arguments0Value_))) {
return root.lchmod(arguments0Value_, arguments1Value_);
}
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value) {
if (arguments0Value instanceof DynamicObject && RubyTypesGen.isImplicitInteger(arguments1Value, arguments1ImplicitType)) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
int arguments1Value_ = RubyTypesGen.asImplicitInteger(arguments1Value, arguments1ImplicitType);
if ((RubyGuards.isRubyString(arguments0Value_))) {
return root.lchmod(arguments0Value_, arguments1Value_);
}
}
return getNext().executeInt_(frameValue, arguments0Value, arguments1Value);
}
static BaseNode_ create(LchmodNodeGen root, Object arguments1Value) {
return new LchmodNode_(root, arguments1Value);
}
}
}
}
@GeneratedBy(LinkNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class LinkNodeFactory implements NodeFactory {
private static LinkNodeFactory linkNodeFactoryInstance;
private LinkNodeFactory() {
}
@Override
public Class getNodeClass() {
return LinkNode.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 LinkNode 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 (linkNodeFactoryInstance == null) {
linkNodeFactoryInstance = new LinkNodeFactory();
}
return linkNodeFactoryInstance;
}
public static LinkNode create(RubyNode[] arguments) {
return new LinkNodeGen(arguments);
}
@GeneratedBy(LinkNode.class)
public static final class LinkNodeGen extends LinkNode {
@Child private RubyNode arguments0_;
@Child private RubyNode arguments1_;
@CompilationFinal private boolean seenUnsupported0;
private LinkNodeGen(RubyNode[] arguments) {
this.arguments0_ = arguments != null && 0 < arguments.length ? arguments[0] : null;
this.arguments1_ = arguments != null && 1 < arguments.length ? arguments[1] : null;
}
@Override
public NodeCost getCost() {
return NodeCost.MONOMORPHIC;
}
@Override
public Object execute(VirtualFrame frameValue) {
return executeInteger(frameValue);
}
@Override
public void executeVoid(VirtualFrame frameValue) {
executeInteger(frameValue);
return;
}
@Override
public int executeInteger(VirtualFrame frameValue) {
DynamicObject arguments0Value_;
try {
arguments0Value_ = arguments0_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object arguments1Value = arguments1_.execute(frameValue);
throw unsupported(ex.getResult(), arguments1Value);
}
DynamicObject arguments1Value_;
try {
arguments1Value_ = arguments1_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
throw unsupported(arguments0Value_, ex.getResult());
}
if ((RubyGuards.isRubyString(arguments0Value_)) && (RubyGuards.isRubyString(arguments1Value_))) {
return this.link(arguments0Value_, arguments1Value_);
}
throw unsupported(arguments0Value_, arguments1Value_);
}
private UnsupportedSpecializationException unsupported(Object arguments0Value, Object arguments1Value) {
if (!seenUnsupported0) {
CompilerDirectives.transferToInterpreterAndInvalidate();
seenUnsupported0 = true;
}
return new UnsupportedSpecializationException(this, new Node[] {arguments0_, arguments1_}, arguments0Value, arguments1Value);
}
}
}
@GeneratedBy(UnlinkNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class UnlinkNodeFactory implements NodeFactory {
private static UnlinkNodeFactory unlinkNodeFactoryInstance;
private UnlinkNodeFactory() {
}
@Override
public Class getNodeClass() {
return UnlinkNode.class;
}
@Override
public List getExecutionSignature() {
return Arrays.asList(RubyNode.class);
}
@Override
public List getNodeSignatures() {
return Arrays.asList(Arrays.asList(RubyNode[].class));
}
@Override
public UnlinkNode 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 (unlinkNodeFactoryInstance == null) {
unlinkNodeFactoryInstance = new UnlinkNodeFactory();
}
return unlinkNodeFactoryInstance;
}
public static UnlinkNode create(RubyNode[] arguments) {
return new UnlinkNodeGen(arguments);
}
@GeneratedBy(UnlinkNode.class)
public static final class UnlinkNodeGen extends UnlinkNode {
@Child private RubyNode arguments0_;
@CompilationFinal private boolean seenUnsupported0;
private UnlinkNodeGen(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) {
return executeInteger(frameValue);
}
@Override
public void executeVoid(VirtualFrame frameValue) {
executeInteger(frameValue);
return;
}
@Override
public int executeInteger(VirtualFrame frameValue) {
DynamicObject arguments0Value_;
try {
arguments0Value_ = arguments0_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
throw unsupported(ex.getResult());
}
if ((RubyGuards.isRubyString(arguments0Value_))) {
return this.unlink(arguments0Value_);
}
throw unsupported(arguments0Value_);
}
private UnsupportedSpecializationException unsupported(Object arguments0Value) {
if (!seenUnsupported0) {
CompilerDirectives.transferToInterpreterAndInvalidate();
seenUnsupported0 = true;
}
return new UnsupportedSpecializationException(this, new Node[] {arguments0_}, arguments0Value);
}
}
}
@GeneratedBy(UmaskNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class UmaskNodeFactory implements NodeFactory {
private static UmaskNodeFactory umaskNodeFactoryInstance;
private UmaskNodeFactory() {
}
@Override
public Class getNodeClass() {
return UmaskNode.class;
}
@Override
public List getExecutionSignature() {
return Arrays.asList(RubyNode.class);
}
@Override
public List getNodeSignatures() {
return Arrays.asList(Arrays.asList(RubyNode[].class));
}
@Override
public UmaskNode 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 (umaskNodeFactoryInstance == null) {
umaskNodeFactoryInstance = new UmaskNodeFactory();
}
return umaskNodeFactoryInstance;
}
public static UmaskNode create(RubyNode[] arguments) {
return new UmaskNodeGen(arguments);
}
@GeneratedBy(UmaskNode.class)
public static final class UmaskNodeGen extends UmaskNode implements SpecializedNode {
@Child private RubyNode arguments0_;
@CompilationFinal private Class arguments0Type_;
@Child private BaseNode_ specialization_;
private UmaskNodeGen(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(UmaskNode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected UmaskNodeGen root;
BaseNode_(UmaskNodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (UmaskNodeGen) 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_ = executeArguments0_(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 (RubyTypesGen.isImplicitInteger(arguments0Value)) {
return UmaskNode_.create(root, arguments0Value);
}
return null;
}
@Override
protected final SpecializationNode createPolymorphic() {
return PolymorphicNode_.create(root);
}
protected final BaseNode_ getNext() {
return (BaseNode_) this.next;
}
protected final Object executeArguments0_(Frame frameValue) {
Class arguments0Type_ = root.arguments0Type_;
try {
if (arguments0Type_ == int.class) {
return root.arguments0_.executeInteger((VirtualFrame) frameValue);
} else if (arguments0Type_ == null) {
CompilerDirectives.transferToInterpreterAndInvalidate();
Class _type = Object.class;
try {
Object _value = root.arguments0_.execute((VirtualFrame) frameValue);
if (_value instanceof Integer) {
_type = int.class;
} else {
_type = Object.class;
}
return _value;
} finally {
root.arguments0Type_ = _type;
}
} else {
return root.arguments0_.execute((VirtualFrame) frameValue);
}
} catch (UnexpectedResultException ex) {
root.arguments0Type_ = Object.class;
return ex.getResult();
}
}
}
@GeneratedBy(UmaskNode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(UmaskNodeGen root) {
super(root, 2147483647);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value) {
return (int) uninitialized(frameValue, arguments0Value);
}
static BaseNode_ create(UmaskNodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(UmaskNode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(UmaskNodeGen 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_ = executeArguments0_(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value) {
return getNext().executeInt_(frameValue, arguments0Value);
}
static BaseNode_ create(UmaskNodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "umask(int)", value = UmaskNode.class)
private static final class UmaskNode_ extends BaseNode_ {
private final Class arguments0ImplicitType;
UmaskNode_(UmaskNodeGen root, Object arguments0Value) {
super(root, 1);
this.arguments0ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments0Value);
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.arguments0ImplicitType == ((UmaskNode_) other).arguments0ImplicitType;
}
@Override
public Object execute(VirtualFrame frameValue) {
return executeInt(frameValue);
}
@Override
public int executeInt(VirtualFrame frameValue) {
int arguments0Value_;
try {
if (arguments0ImplicitType == int.class) {
arguments0Value_ = root.arguments0_.executeInteger(frameValue);
} else {
Object arguments0Value__ = executeArguments0_(frameValue);
arguments0Value_ = RubyTypesGen.expectImplicitInteger(arguments0Value__, arguments0ImplicitType);
}
} catch (UnexpectedResultException ex) {
return getNext().executeInt_(frameValue, ex.getResult());
}
return root.umask(arguments0Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value) {
if (RubyTypesGen.isImplicitInteger(arguments0Value, arguments0ImplicitType)) {
int arguments0Value_ = RubyTypesGen.asImplicitInteger(arguments0Value, arguments0ImplicitType);
return root.umask(arguments0Value_);
}
return getNext().executeInt_(frameValue, arguments0Value);
}
static BaseNode_ create(UmaskNodeGen root, Object arguments0Value) {
return new UmaskNode_(root, arguments0Value);
}
}
}
}
@GeneratedBy(UnsetenvNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class UnsetenvNodeFactory implements NodeFactory {
private static UnsetenvNodeFactory unsetenvNodeFactoryInstance;
private UnsetenvNodeFactory() {
}
@Override
public Class getNodeClass() {
return UnsetenvNode.class;
}
@Override
public List getExecutionSignature() {
return Arrays.asList(RubyNode.class);
}
@Override
public List getNodeSignatures() {
return Arrays.asList(Arrays.asList(RubyNode[].class));
}
@Override
public UnsetenvNode 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 (unsetenvNodeFactoryInstance == null) {
unsetenvNodeFactoryInstance = new UnsetenvNodeFactory();
}
return unsetenvNodeFactoryInstance;
}
public static UnsetenvNode create(RubyNode[] arguments) {
return new UnsetenvNodeGen(arguments);
}
@GeneratedBy(UnsetenvNode.class)
public static final class UnsetenvNodeGen extends UnsetenvNode {
@Child private RubyNode arguments0_;
@CompilationFinal private boolean seenUnsupported0;
private UnsetenvNodeGen(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) {
return executeInteger(frameValue);
}
@Override
public void executeVoid(VirtualFrame frameValue) {
executeInteger(frameValue);
return;
}
@Override
public int executeInteger(VirtualFrame frameValue) {
DynamicObject arguments0Value_;
try {
arguments0Value_ = arguments0_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
throw unsupported(ex.getResult());
}
if ((RubyGuards.isRubyString(arguments0Value_))) {
return this.unsetenv(arguments0Value_);
}
throw unsupported(arguments0Value_);
}
private UnsupportedSpecializationException unsupported(Object arguments0Value) {
if (!seenUnsupported0) {
CompilerDirectives.transferToInterpreterAndInvalidate();
seenUnsupported0 = true;
}
return new UnsupportedSpecializationException(this, new Node[] {arguments0_}, arguments0Value);
}
}
}
@GeneratedBy(UtimesNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class UtimesNodeFactory implements NodeFactory {
private static UtimesNodeFactory utimesNodeFactoryInstance;
private UtimesNodeFactory() {
}
@Override
public Class getNodeClass() {
return UtimesNode.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 UtimesNode 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 (utimesNodeFactoryInstance == null) {
utimesNodeFactoryInstance = new UtimesNodeFactory();
}
return utimesNodeFactoryInstance;
}
public static UtimesNode create(RubyNode[] arguments) {
return new UtimesNodeGen(arguments);
}
@GeneratedBy(UtimesNode.class)
public static final class UtimesNodeGen extends UtimesNode {
@Child private RubyNode arguments0_;
@Child private RubyNode arguments1_;
@CompilationFinal private boolean seenUnsupported0;
private UtimesNodeGen(RubyNode[] arguments) {
this.arguments0_ = arguments != null && 0 < arguments.length ? arguments[0] : null;
this.arguments1_ = arguments != null && 1 < arguments.length ? arguments[1] : null;
}
@Override
public NodeCost getCost() {
return NodeCost.MONOMORPHIC;
}
@Override
public Object execute(VirtualFrame frameValue) {
return executeInteger(frameValue);
}
@Override
public void executeVoid(VirtualFrame frameValue) {
executeInteger(frameValue);
return;
}
@Override
public int executeInteger(VirtualFrame frameValue) {
DynamicObject arguments0Value_;
try {
arguments0Value_ = arguments0_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object arguments1Value = arguments1_.execute(frameValue);
throw unsupported(ex.getResult(), arguments1Value);
}
DynamicObject arguments1Value_;
try {
arguments1Value_ = arguments1_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
throw unsupported(arguments0Value_, ex.getResult());
}
if ((RubyGuards.isRubyString(arguments0Value_)) && (RubyGuards.isRubyPointer(arguments1Value_))) {
return this.utimes(arguments0Value_, arguments1Value_);
}
throw unsupported(arguments0Value_, arguments1Value_);
}
private UnsupportedSpecializationException unsupported(Object arguments0Value, Object arguments1Value) {
if (!seenUnsupported0) {
CompilerDirectives.transferToInterpreterAndInvalidate();
seenUnsupported0 = true;
}
return new UnsupportedSpecializationException(this, new Node[] {arguments0_, arguments1_}, arguments0Value, arguments1Value);
}
}
}
@GeneratedBy(MkdirNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class MkdirNodeFactory implements NodeFactory {
private static MkdirNodeFactory mkdirNodeFactoryInstance;
private MkdirNodeFactory() {
}
@Override
public Class getNodeClass() {
return MkdirNode.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 MkdirNode 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 (mkdirNodeFactoryInstance == null) {
mkdirNodeFactoryInstance = new MkdirNodeFactory();
}
return mkdirNodeFactoryInstance;
}
public static MkdirNode create(RubyNode[] arguments) {
return new MkdirNodeGen(arguments);
}
@GeneratedBy(MkdirNode.class)
public static final class MkdirNodeGen extends MkdirNode implements SpecializedNode {
@Child private RubyNode arguments0_;
@Child private RubyNode arguments1_;
@CompilationFinal private Class arguments1Type_;
@Child private BaseNode_ specialization_;
private MkdirNodeGen(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) {
return specialization_.executeInt(frameValue);
}
@Override
public SpecializationNode getSpecializationNode() {
return specialization_;
}
@Override
public Node deepCopy() {
return SpecializationNode.updateRoot(super.deepCopy());
}
@GeneratedBy(MkdirNode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected MkdirNodeGen root;
BaseNode_(MkdirNodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (MkdirNodeGen) 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.executeInt_((VirtualFrame) frameValue, arguments0Value, arguments1Value);
}
public abstract int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value);
public Object execute(VirtualFrame frameValue) {
Object arguments0Value_ = root.arguments0_.execute(frameValue);
Object arguments1Value_ = executeArguments1_(frameValue);
return executeInt_(frameValue, arguments0Value_, arguments1Value_);
}
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, Object arguments1Value) {
if (arguments0Value instanceof DynamicObject && RubyTypesGen.isImplicitInteger(arguments1Value)) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
if ((RubyGuards.isRubyString(arguments0Value_))) {
return MkdirNode_.create(root, arguments1Value);
}
}
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();
}
}
}
@GeneratedBy(MkdirNode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(MkdirNodeGen root) {
super(root, 2147483647);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value) {
return (int) uninitialized(frameValue, arguments0Value, arguments1Value);
}
static BaseNode_ create(MkdirNodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(MkdirNode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(MkdirNodeGen 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 int executeInt(VirtualFrame frameValue) {
Object arguments0Value_ = root.arguments0_.execute(frameValue);
Object arguments1Value_ = executeArguments1_(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value) {
return getNext().executeInt_(frameValue, arguments0Value, arguments1Value);
}
static BaseNode_ create(MkdirNodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "mkdir(DynamicObject, int)", value = MkdirNode.class)
private static final class MkdirNode_ extends BaseNode_ {
private final Class arguments1ImplicitType;
MkdirNode_(MkdirNodeGen root, Object arguments1Value) {
super(root, 1);
this.arguments1ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments1Value);
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.arguments1ImplicitType == ((MkdirNode_) other).arguments1ImplicitType;
}
@Override
public Object execute(VirtualFrame frameValue) {
return executeInt(frameValue);
}
@Override
public int executeInt(VirtualFrame frameValue) {
DynamicObject arguments0Value_;
try {
arguments0Value_ = root.arguments0_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object arguments1Value = executeArguments1_(frameValue);
return getNext().executeInt_(frameValue, ex.getResult(), arguments1Value);
}
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) {
return getNext().executeInt_(frameValue, arguments0Value_, ex.getResult());
}
if ((RubyGuards.isRubyString(arguments0Value_))) {
return root.mkdir(arguments0Value_, arguments1Value_);
}
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value) {
if (arguments0Value instanceof DynamicObject && RubyTypesGen.isImplicitInteger(arguments1Value, arguments1ImplicitType)) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
int arguments1Value_ = RubyTypesGen.asImplicitInteger(arguments1Value, arguments1ImplicitType);
if ((RubyGuards.isRubyString(arguments0Value_))) {
return root.mkdir(arguments0Value_, arguments1Value_);
}
}
return getNext().executeInt_(frameValue, arguments0Value, arguments1Value);
}
static BaseNode_ create(MkdirNodeGen root, Object arguments1Value) {
return new MkdirNode_(root, arguments1Value);
}
}
}
}
@GeneratedBy(ChdirNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class ChdirNodeFactory implements NodeFactory {
private static ChdirNodeFactory chdirNodeFactoryInstance;
private ChdirNodeFactory() {
}
@Override
public Class getNodeClass() {
return ChdirNode.class;
}
@Override
public List getExecutionSignature() {
return Arrays.asList(RubyNode.class);
}
@Override
public List getNodeSignatures() {
return Arrays.asList(Arrays.asList(RubyNode[].class));
}
@Override
public ChdirNode 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 (chdirNodeFactoryInstance == null) {
chdirNodeFactoryInstance = new ChdirNodeFactory();
}
return chdirNodeFactoryInstance;
}
public static ChdirNode create(RubyNode[] arguments) {
return new ChdirNodeGen(arguments);
}
@GeneratedBy(ChdirNode.class)
public static final class ChdirNodeGen extends ChdirNode {
@Child private RubyNode arguments0_;
@CompilationFinal private boolean seenUnsupported0;
private ChdirNodeGen(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) {
return executeInteger(frameValue);
}
@Override
public void executeVoid(VirtualFrame frameValue) {
executeInteger(frameValue);
return;
}
@Override
public int executeInteger(VirtualFrame frameValue) {
DynamicObject arguments0Value_;
try {
arguments0Value_ = arguments0_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
throw unsupported(ex.getResult());
}
if ((RubyGuards.isRubyString(arguments0Value_))) {
return this.chdir(arguments0Value_);
}
throw unsupported(arguments0Value_);
}
private UnsupportedSpecializationException unsupported(Object arguments0Value) {
if (!seenUnsupported0) {
CompilerDirectives.transferToInterpreterAndInvalidate();
seenUnsupported0 = true;
}
return new UnsupportedSpecializationException(this, new Node[] {arguments0_}, arguments0Value);
}
}
}
@GeneratedBy(GetPriorityNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class GetPriorityNodeFactory implements NodeFactory {
private static GetPriorityNodeFactory getPriorityNodeFactoryInstance;
private GetPriorityNodeFactory() {
}
@Override
public Class getNodeClass() {
return GetPriorityNode.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 GetPriorityNode 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 (getPriorityNodeFactoryInstance == null) {
getPriorityNodeFactoryInstance = new GetPriorityNodeFactory();
}
return getPriorityNodeFactoryInstance;
}
public static GetPriorityNode create(RubyNode[] arguments) {
return new GetPriorityNodeGen(arguments);
}
@GeneratedBy(GetPriorityNode.class)
public static final class GetPriorityNodeGen extends GetPriorityNode implements SpecializedNode {
@Child private RubyNode arguments0_;
@Child private RubyNode arguments1_;
@CompilationFinal private Class arguments0Type_;
@CompilationFinal private Class arguments1Type_;
@Child private BaseNode_ specialization_;
private GetPriorityNodeGen(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) {
return specialization_.executeInt(frameValue);
}
@Override
public SpecializationNode getSpecializationNode() {
return specialization_;
}
@Override
public Node deepCopy() {
return SpecializationNode.updateRoot(super.deepCopy());
}
@GeneratedBy(GetPriorityNode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected GetPriorityNodeGen root;
BaseNode_(GetPriorityNodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (GetPriorityNodeGen) 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.executeInt_((VirtualFrame) frameValue, arguments0Value, arguments1Value);
}
public abstract int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value);
public Object execute(VirtualFrame frameValue) {
Object arguments0Value_ = executeArguments0_(frameValue);
Object arguments1Value_ = executeArguments1_(frameValue);
return executeInt_(frameValue, arguments0Value_, arguments1Value_);
}
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, Object arguments1Value) {
if (RubyTypesGen.isImplicitInteger(arguments0Value) && RubyTypesGen.isImplicitInteger(arguments1Value)) {
return GetpriorityNode_.create(root, arguments0Value, arguments1Value);
}
return null;
}
@Override
protected final SpecializationNode createPolymorphic() {
return PolymorphicNode_.create(root);
}
protected final BaseNode_ getNext() {
return (BaseNode_) this.next;
}
protected final Object executeArguments0_(Frame frameValue) {
Class arguments0Type_ = root.arguments0Type_;
try {
if (arguments0Type_ == int.class) {
return root.arguments0_.executeInteger((VirtualFrame) frameValue);
} else if (arguments0Type_ == null) {
CompilerDirectives.transferToInterpreterAndInvalidate();
Class _type = Object.class;
try {
Object _value = root.arguments0_.execute((VirtualFrame) frameValue);
if (_value instanceof Integer) {
_type = int.class;
} else {
_type = Object.class;
}
return _value;
} finally {
root.arguments0Type_ = _type;
}
} else {
return root.arguments0_.execute((VirtualFrame) frameValue);
}
} catch (UnexpectedResultException ex) {
root.arguments0Type_ = Object.class;
return ex.getResult();
}
}
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();
}
}
}
@GeneratedBy(GetPriorityNode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(GetPriorityNodeGen root) {
super(root, 2147483647);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value) {
return (int) uninitialized(frameValue, arguments0Value, arguments1Value);
}
static BaseNode_ create(GetPriorityNodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(GetPriorityNode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(GetPriorityNodeGen 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 int executeInt(VirtualFrame frameValue) {
Object arguments0Value_ = executeArguments0_(frameValue);
Object arguments1Value_ = executeArguments1_(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value) {
return getNext().executeInt_(frameValue, arguments0Value, arguments1Value);
}
static BaseNode_ create(GetPriorityNodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "getpriority(int, int)", value = GetPriorityNode.class)
private static final class GetpriorityNode_ extends BaseNode_ {
private final Class arguments0ImplicitType;
private final Class arguments1ImplicitType;
GetpriorityNode_(GetPriorityNodeGen root, Object arguments0Value, Object arguments1Value) {
super(root, 1);
this.arguments0ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments0Value);
this.arguments1ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments1Value);
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.arguments0ImplicitType == ((GetpriorityNode_) other).arguments0ImplicitType && this.arguments1ImplicitType == ((GetpriorityNode_) other).arguments1ImplicitType;
}
@Override
public Object execute(VirtualFrame frameValue) {
return executeInt(frameValue);
}
@Override
public int executeInt(VirtualFrame frameValue) {
int arguments0Value_;
try {
if (arguments0ImplicitType == int.class) {
arguments0Value_ = root.arguments0_.executeInteger(frameValue);
} else {
Object arguments0Value__ = executeArguments0_(frameValue);
arguments0Value_ = RubyTypesGen.expectImplicitInteger(arguments0Value__, arguments0ImplicitType);
}
} catch (UnexpectedResultException ex) {
Object arguments1Value = executeArguments1_(frameValue);
return getNext().executeInt_(frameValue, ex.getResult(), arguments1Value);
}
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) {
return getNext().executeInt_(frameValue, arguments0Value_, ex.getResult());
}
return root.getpriority(arguments0Value_, arguments1Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value) {
if (RubyTypesGen.isImplicitInteger(arguments0Value, arguments0ImplicitType) && RubyTypesGen.isImplicitInteger(arguments1Value, arguments1ImplicitType)) {
int arguments0Value_ = RubyTypesGen.asImplicitInteger(arguments0Value, arguments0ImplicitType);
int arguments1Value_ = RubyTypesGen.asImplicitInteger(arguments1Value, arguments1ImplicitType);
return root.getpriority(arguments0Value_, arguments1Value_);
}
return getNext().executeInt_(frameValue, arguments0Value, arguments1Value);
}
static BaseNode_ create(GetPriorityNodeGen root, Object arguments0Value, Object arguments1Value) {
return new GetpriorityNode_(root, arguments0Value, arguments1Value);
}
}
}
}
@GeneratedBy(SetgidNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class SetgidNodeFactory implements NodeFactory {
private static SetgidNodeFactory setgidNodeFactoryInstance;
private SetgidNodeFactory() {
}
@Override
public Class getNodeClass() {
return SetgidNode.class;
}
@Override
public List getExecutionSignature() {
return Arrays.asList(RubyNode.class);
}
@Override
public List getNodeSignatures() {
return Arrays.asList(Arrays.asList(RubyNode[].class));
}
@Override
public SetgidNode 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 (setgidNodeFactoryInstance == null) {
setgidNodeFactoryInstance = new SetgidNodeFactory();
}
return setgidNodeFactoryInstance;
}
public static SetgidNode create(RubyNode[] arguments) {
return new SetgidNodeGen(arguments);
}
@GeneratedBy(SetgidNode.class)
public static final class SetgidNodeGen extends SetgidNode implements SpecializedNode {
@Child private RubyNode arguments0_;
@CompilationFinal private Class arguments0Type_;
@Child private BaseNode_ specialization_;
private SetgidNodeGen(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(SetgidNode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected SetgidNodeGen root;
BaseNode_(SetgidNodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (SetgidNodeGen) 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_ = executeArguments0_(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 (RubyTypesGen.isImplicitInteger(arguments0Value)) {
return SetgidNode_.create(root, arguments0Value);
}
return null;
}
@Override
protected final SpecializationNode createPolymorphic() {
return PolymorphicNode_.create(root);
}
protected final BaseNode_ getNext() {
return (BaseNode_) this.next;
}
protected final Object executeArguments0_(Frame frameValue) {
Class arguments0Type_ = root.arguments0Type_;
try {
if (arguments0Type_ == int.class) {
return root.arguments0_.executeInteger((VirtualFrame) frameValue);
} else if (arguments0Type_ == null) {
CompilerDirectives.transferToInterpreterAndInvalidate();
Class _type = Object.class;
try {
Object _value = root.arguments0_.execute((VirtualFrame) frameValue);
if (_value instanceof Integer) {
_type = int.class;
} else {
_type = Object.class;
}
return _value;
} finally {
root.arguments0Type_ = _type;
}
} else {
return root.arguments0_.execute((VirtualFrame) frameValue);
}
} catch (UnexpectedResultException ex) {
root.arguments0Type_ = Object.class;
return ex.getResult();
}
}
}
@GeneratedBy(SetgidNode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(SetgidNodeGen root) {
super(root, 2147483647);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value) {
return (int) uninitialized(frameValue, arguments0Value);
}
static BaseNode_ create(SetgidNodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(SetgidNode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(SetgidNodeGen 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_ = executeArguments0_(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value) {
return getNext().executeInt_(frameValue, arguments0Value);
}
static BaseNode_ create(SetgidNodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "setgid(int)", value = SetgidNode.class)
private static final class SetgidNode_ extends BaseNode_ {
private final Class arguments0ImplicitType;
SetgidNode_(SetgidNodeGen root, Object arguments0Value) {
super(root, 1);
this.arguments0ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments0Value);
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.arguments0ImplicitType == ((SetgidNode_) other).arguments0ImplicitType;
}
@Override
public Object execute(VirtualFrame frameValue) {
return executeInt(frameValue);
}
@Override
public int executeInt(VirtualFrame frameValue) {
int arguments0Value_;
try {
if (arguments0ImplicitType == int.class) {
arguments0Value_ = root.arguments0_.executeInteger(frameValue);
} else {
Object arguments0Value__ = executeArguments0_(frameValue);
arguments0Value_ = RubyTypesGen.expectImplicitInteger(arguments0Value__, arguments0ImplicitType);
}
} catch (UnexpectedResultException ex) {
return getNext().executeInt_(frameValue, ex.getResult());
}
return root.setgid(arguments0Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value) {
if (RubyTypesGen.isImplicitInteger(arguments0Value, arguments0ImplicitType)) {
int arguments0Value_ = RubyTypesGen.asImplicitInteger(arguments0Value, arguments0ImplicitType);
return root.setgid(arguments0Value_);
}
return getNext().executeInt_(frameValue, arguments0Value);
}
static BaseNode_ create(SetgidNodeGen root, Object arguments0Value) {
return new SetgidNode_(root, arguments0Value);
}
}
}
}
@GeneratedBy(SetpgidNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class SetpgidNodeFactory implements NodeFactory {
private static SetpgidNodeFactory setpgidNodeFactoryInstance;
private SetpgidNodeFactory() {
}
@Override
public Class getNodeClass() {
return SetpgidNode.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 SetpgidNode 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 (setpgidNodeFactoryInstance == null) {
setpgidNodeFactoryInstance = new SetpgidNodeFactory();
}
return setpgidNodeFactoryInstance;
}
public static SetpgidNode create(RubyNode[] arguments) {
return new SetpgidNodeGen(arguments);
}
@GeneratedBy(SetpgidNode.class)
public static final class SetpgidNodeGen extends SetpgidNode implements SpecializedNode {
@Child private RubyNode arguments0_;
@Child private RubyNode arguments1_;
@CompilationFinal private Class arguments0Type_;
@CompilationFinal private Class arguments1Type_;
@Child private BaseNode_ specialization_;
private SetpgidNodeGen(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) {
return specialization_.executeInt(frameValue);
}
@Override
public SpecializationNode getSpecializationNode() {
return specialization_;
}
@Override
public Node deepCopy() {
return SpecializationNode.updateRoot(super.deepCopy());
}
@GeneratedBy(SetpgidNode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected SetpgidNodeGen root;
BaseNode_(SetpgidNodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (SetpgidNodeGen) 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.executeInt_((VirtualFrame) frameValue, arguments0Value, arguments1Value);
}
public abstract int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value);
public Object execute(VirtualFrame frameValue) {
Object arguments0Value_ = executeArguments0_(frameValue);
Object arguments1Value_ = executeArguments1_(frameValue);
return executeInt_(frameValue, arguments0Value_, arguments1Value_);
}
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, Object arguments1Value) {
if (RubyTypesGen.isImplicitInteger(arguments0Value) && RubyTypesGen.isImplicitInteger(arguments1Value)) {
return SetpgidNode_.create(root, arguments0Value, arguments1Value);
}
return null;
}
@Override
protected final SpecializationNode createPolymorphic() {
return PolymorphicNode_.create(root);
}
protected final BaseNode_ getNext() {
return (BaseNode_) this.next;
}
protected final Object executeArguments0_(Frame frameValue) {
Class arguments0Type_ = root.arguments0Type_;
try {
if (arguments0Type_ == int.class) {
return root.arguments0_.executeInteger((VirtualFrame) frameValue);
} else if (arguments0Type_ == null) {
CompilerDirectives.transferToInterpreterAndInvalidate();
Class _type = Object.class;
try {
Object _value = root.arguments0_.execute((VirtualFrame) frameValue);
if (_value instanceof Integer) {
_type = int.class;
} else {
_type = Object.class;
}
return _value;
} finally {
root.arguments0Type_ = _type;
}
} else {
return root.arguments0_.execute((VirtualFrame) frameValue);
}
} catch (UnexpectedResultException ex) {
root.arguments0Type_ = Object.class;
return ex.getResult();
}
}
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();
}
}
}
@GeneratedBy(SetpgidNode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(SetpgidNodeGen root) {
super(root, 2147483647);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value) {
return (int) uninitialized(frameValue, arguments0Value, arguments1Value);
}
static BaseNode_ create(SetpgidNodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(SetpgidNode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(SetpgidNodeGen 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 int executeInt(VirtualFrame frameValue) {
Object arguments0Value_ = executeArguments0_(frameValue);
Object arguments1Value_ = executeArguments1_(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value) {
return getNext().executeInt_(frameValue, arguments0Value, arguments1Value);
}
static BaseNode_ create(SetpgidNodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "setpgid(int, int)", value = SetpgidNode.class)
private static final class SetpgidNode_ extends BaseNode_ {
private final Class arguments0ImplicitType;
private final Class arguments1ImplicitType;
SetpgidNode_(SetpgidNodeGen root, Object arguments0Value, Object arguments1Value) {
super(root, 1);
this.arguments0ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments0Value);
this.arguments1ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments1Value);
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.arguments0ImplicitType == ((SetpgidNode_) other).arguments0ImplicitType && this.arguments1ImplicitType == ((SetpgidNode_) other).arguments1ImplicitType;
}
@Override
public Object execute(VirtualFrame frameValue) {
return executeInt(frameValue);
}
@Override
public int executeInt(VirtualFrame frameValue) {
int arguments0Value_;
try {
if (arguments0ImplicitType == int.class) {
arguments0Value_ = root.arguments0_.executeInteger(frameValue);
} else {
Object arguments0Value__ = executeArguments0_(frameValue);
arguments0Value_ = RubyTypesGen.expectImplicitInteger(arguments0Value__, arguments0ImplicitType);
}
} catch (UnexpectedResultException ex) {
Object arguments1Value = executeArguments1_(frameValue);
return getNext().executeInt_(frameValue, ex.getResult(), arguments1Value);
}
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) {
return getNext().executeInt_(frameValue, arguments0Value_, ex.getResult());
}
return root.setpgid(arguments0Value_, arguments1Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value) {
if (RubyTypesGen.isImplicitInteger(arguments0Value, arguments0ImplicitType) && RubyTypesGen.isImplicitInteger(arguments1Value, arguments1ImplicitType)) {
int arguments0Value_ = RubyTypesGen.asImplicitInteger(arguments0Value, arguments0ImplicitType);
int arguments1Value_ = RubyTypesGen.asImplicitInteger(arguments1Value, arguments1ImplicitType);
return root.setpgid(arguments0Value_, arguments1Value_);
}
return getNext().executeInt_(frameValue, arguments0Value, arguments1Value);
}
static BaseNode_ create(SetpgidNodeGen root, Object arguments0Value, Object arguments1Value) {
return new SetpgidNode_(root, arguments0Value, arguments1Value);
}
}
}
}
@GeneratedBy(SetPriorityNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class SetPriorityNodeFactory implements NodeFactory {
private static SetPriorityNodeFactory setPriorityNodeFactoryInstance;
private SetPriorityNodeFactory() {
}
@Override
public Class getNodeClass() {
return SetPriorityNode.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 SetPriorityNode 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 (setPriorityNodeFactoryInstance == null) {
setPriorityNodeFactoryInstance = new SetPriorityNodeFactory();
}
return setPriorityNodeFactoryInstance;
}
public static SetPriorityNode create(RubyNode[] arguments) {
return new SetPriorityNodeGen(arguments);
}
@GeneratedBy(SetPriorityNode.class)
public static final class SetPriorityNodeGen extends SetPriorityNode implements SpecializedNode {
@Child private RubyNode arguments0_;
@Child private RubyNode arguments1_;
@Child private RubyNode arguments2_;
@CompilationFinal private Class arguments0Type_;
@CompilationFinal private Class arguments1Type_;
@CompilationFinal private Class arguments2Type_;
@Child private BaseNode_ specialization_;
private SetPriorityNodeGen(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 int executeInteger(VirtualFrame frameValue) {
return specialization_.executeInt(frameValue);
}
@Override
public SpecializationNode getSpecializationNode() {
return specialization_;
}
@Override
public Node deepCopy() {
return SpecializationNode.updateRoot(super.deepCopy());
}
@GeneratedBy(SetPriorityNode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected SetPriorityNodeGen root;
BaseNode_(SetPriorityNodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (SetPriorityNodeGen) 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.executeInt_((VirtualFrame) frameValue, arguments0Value, arguments1Value, arguments2Value);
}
public abstract int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value);
public Object execute(VirtualFrame frameValue) {
Object arguments0Value_ = executeArguments0_(frameValue);
Object arguments1Value_ = executeArguments1_(frameValue);
Object arguments2Value_ = executeArguments2_(frameValue);
return executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_);
}
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, Object arguments1Value, Object arguments2Value) {
if (RubyTypesGen.isImplicitInteger(arguments0Value) && RubyTypesGen.isImplicitInteger(arguments1Value) && RubyTypesGen.isImplicitInteger(arguments2Value)) {
return SetpriorityNode_.create(root, arguments0Value, arguments1Value, arguments2Value);
}
return null;
}
@Override
protected final SpecializationNode createPolymorphic() {
return PolymorphicNode_.create(root);
}
protected final BaseNode_ getNext() {
return (BaseNode_) this.next;
}
protected final Object executeArguments0_(Frame frameValue) {
Class arguments0Type_ = root.arguments0Type_;
try {
if (arguments0Type_ == int.class) {
return root.arguments0_.executeInteger((VirtualFrame) frameValue);
} else if (arguments0Type_ == null) {
CompilerDirectives.transferToInterpreterAndInvalidate();
Class _type = Object.class;
try {
Object _value = root.arguments0_.execute((VirtualFrame) frameValue);
if (_value instanceof Integer) {
_type = int.class;
} else {
_type = Object.class;
}
return _value;
} finally {
root.arguments0Type_ = _type;
}
} else {
return root.arguments0_.execute((VirtualFrame) frameValue);
}
} catch (UnexpectedResultException ex) {
root.arguments0Type_ = Object.class;
return ex.getResult();
}
}
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(SetPriorityNode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(SetPriorityNodeGen root) {
super(root, 2147483647);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value) {
return (int) uninitialized(frameValue, arguments0Value, arguments1Value, arguments2Value);
}
static BaseNode_ create(SetPriorityNodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(SetPriorityNode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(SetPriorityNodeGen 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 int executeInt(VirtualFrame frameValue) {
Object arguments0Value_ = executeArguments0_(frameValue);
Object arguments1Value_ = executeArguments1_(frameValue);
Object arguments2Value_ = executeArguments2_(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value) {
return getNext().executeInt_(frameValue, arguments0Value, arguments1Value, arguments2Value);
}
static BaseNode_ create(SetPriorityNodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "setpriority(int, int, int)", value = SetPriorityNode.class)
private static final class SetpriorityNode_ extends BaseNode_ {
private final Class arguments0ImplicitType;
private final Class arguments1ImplicitType;
private final Class arguments2ImplicitType;
SetpriorityNode_(SetPriorityNodeGen root, Object arguments0Value, Object arguments1Value, Object arguments2Value) {
super(root, 1);
this.arguments0ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments0Value);
this.arguments1ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments1Value);
this.arguments2ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments2Value);
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.arguments0ImplicitType == ((SetpriorityNode_) other).arguments0ImplicitType && this.arguments1ImplicitType == ((SetpriorityNode_) other).arguments1ImplicitType && this.arguments2ImplicitType == ((SetpriorityNode_) other).arguments2ImplicitType;
}
@Override
public Object execute(VirtualFrame frameValue) {
return executeInt(frameValue);
}
@Override
public int executeInt(VirtualFrame frameValue) {
int arguments0Value_;
try {
if (arguments0ImplicitType == int.class) {
arguments0Value_ = root.arguments0_.executeInteger(frameValue);
} else {
Object arguments0Value__ = executeArguments0_(frameValue);
arguments0Value_ = RubyTypesGen.expectImplicitInteger(arguments0Value__, arguments0ImplicitType);
}
} catch (UnexpectedResultException ex) {
Object arguments1Value = executeArguments1_(frameValue);
Object arguments2Value = executeArguments2_(frameValue);
return getNext().executeInt_(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().executeInt_(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().executeInt_(frameValue, arguments0Value_, arguments1Value_, ex.getResult());
}
return root.setpriority(arguments0Value_, arguments1Value_, arguments2Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value) {
if (RubyTypesGen.isImplicitInteger(arguments0Value, arguments0ImplicitType) && RubyTypesGen.isImplicitInteger(arguments1Value, arguments1ImplicitType) && RubyTypesGen.isImplicitInteger(arguments2Value, arguments2ImplicitType)) {
int arguments0Value_ = RubyTypesGen.asImplicitInteger(arguments0Value, arguments0ImplicitType);
int arguments1Value_ = RubyTypesGen.asImplicitInteger(arguments1Value, arguments1ImplicitType);
int arguments2Value_ = RubyTypesGen.asImplicitInteger(arguments2Value, arguments2ImplicitType);
return root.setpriority(arguments0Value_, arguments1Value_, arguments2Value_);
}
return getNext().executeInt_(frameValue, arguments0Value, arguments1Value, arguments2Value);
}
static BaseNode_ create(SetPriorityNodeGen root, Object arguments0Value, Object arguments1Value, Object arguments2Value) {
return new SetpriorityNode_(root, arguments0Value, arguments1Value, arguments2Value);
}
}
}
}
@GeneratedBy(SetResuidNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class SetResuidNodeFactory implements NodeFactory {
private static SetResuidNodeFactory setResuidNodeFactoryInstance;
private SetResuidNodeFactory() {
}
@Override
public Class getNodeClass() {
return SetResuidNode.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 SetResuidNode 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 (setResuidNodeFactoryInstance == null) {
setResuidNodeFactoryInstance = new SetResuidNodeFactory();
}
return setResuidNodeFactoryInstance;
}
public static SetResuidNode create(RubyNode[] arguments) {
return new SetResuidNodeGen(arguments);
}
@GeneratedBy(SetResuidNode.class)
public static final class SetResuidNodeGen extends SetResuidNode implements SpecializedNode {
@Child private RubyNode arguments0_;
@Child private RubyNode arguments1_;
@Child private RubyNode arguments2_;
@CompilationFinal private Class arguments0Type_;
@CompilationFinal private Class arguments1Type_;
@CompilationFinal private Class arguments2Type_;
@Child private BaseNode_ specialization_;
private SetResuidNodeGen(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 int executeInteger(VirtualFrame frameValue) {
return specialization_.executeInt(frameValue);
}
@Override
public SpecializationNode getSpecializationNode() {
return specialization_;
}
@Override
public Node deepCopy() {
return SpecializationNode.updateRoot(super.deepCopy());
}
@GeneratedBy(SetResuidNode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected SetResuidNodeGen root;
BaseNode_(SetResuidNodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (SetResuidNodeGen) 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.executeInt_((VirtualFrame) frameValue, arguments0Value, arguments1Value, arguments2Value);
}
public abstract int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value);
public Object execute(VirtualFrame frameValue) {
Object arguments0Value_ = executeArguments0_(frameValue);
Object arguments1Value_ = executeArguments1_(frameValue);
Object arguments2Value_ = executeArguments2_(frameValue);
return executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_);
}
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, Object arguments1Value, Object arguments2Value) {
if (RubyTypesGen.isImplicitInteger(arguments0Value) && RubyTypesGen.isImplicitInteger(arguments1Value) && RubyTypesGen.isImplicitInteger(arguments2Value)) {
return SetresuidNode_.create(root, arguments0Value, arguments1Value, arguments2Value);
}
return null;
}
@Override
protected final SpecializationNode createPolymorphic() {
return PolymorphicNode_.create(root);
}
protected final BaseNode_ getNext() {
return (BaseNode_) this.next;
}
protected final Object executeArguments0_(Frame frameValue) {
Class arguments0Type_ = root.arguments0Type_;
try {
if (arguments0Type_ == int.class) {
return root.arguments0_.executeInteger((VirtualFrame) frameValue);
} else if (arguments0Type_ == null) {
CompilerDirectives.transferToInterpreterAndInvalidate();
Class _type = Object.class;
try {
Object _value = root.arguments0_.execute((VirtualFrame) frameValue);
if (_value instanceof Integer) {
_type = int.class;
} else {
_type = Object.class;
}
return _value;
} finally {
root.arguments0Type_ = _type;
}
} else {
return root.arguments0_.execute((VirtualFrame) frameValue);
}
} catch (UnexpectedResultException ex) {
root.arguments0Type_ = Object.class;
return ex.getResult();
}
}
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(SetResuidNode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(SetResuidNodeGen root) {
super(root, 2147483647);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value) {
return (int) uninitialized(frameValue, arguments0Value, arguments1Value, arguments2Value);
}
static BaseNode_ create(SetResuidNodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(SetResuidNode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(SetResuidNodeGen 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 int executeInt(VirtualFrame frameValue) {
Object arguments0Value_ = executeArguments0_(frameValue);
Object arguments1Value_ = executeArguments1_(frameValue);
Object arguments2Value_ = executeArguments2_(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value) {
return getNext().executeInt_(frameValue, arguments0Value, arguments1Value, arguments2Value);
}
static BaseNode_ create(SetResuidNodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "setresuid(int, int, int)", value = SetResuidNode.class)
private static final class SetresuidNode_ extends BaseNode_ {
private final Class arguments0ImplicitType;
private final Class arguments1ImplicitType;
private final Class arguments2ImplicitType;
SetresuidNode_(SetResuidNodeGen root, Object arguments0Value, Object arguments1Value, Object arguments2Value) {
super(root, 1);
this.arguments0ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments0Value);
this.arguments1ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments1Value);
this.arguments2ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments2Value);
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.arguments0ImplicitType == ((SetresuidNode_) other).arguments0ImplicitType && this.arguments1ImplicitType == ((SetresuidNode_) other).arguments1ImplicitType && this.arguments2ImplicitType == ((SetresuidNode_) other).arguments2ImplicitType;
}
@Override
public Object execute(VirtualFrame frameValue) {
return executeInt(frameValue);
}
@Override
public int executeInt(VirtualFrame frameValue) {
int arguments0Value_;
try {
if (arguments0ImplicitType == int.class) {
arguments0Value_ = root.arguments0_.executeInteger(frameValue);
} else {
Object arguments0Value__ = executeArguments0_(frameValue);
arguments0Value_ = RubyTypesGen.expectImplicitInteger(arguments0Value__, arguments0ImplicitType);
}
} catch (UnexpectedResultException ex) {
Object arguments1Value = executeArguments1_(frameValue);
Object arguments2Value = executeArguments2_(frameValue);
return getNext().executeInt_(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().executeInt_(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().executeInt_(frameValue, arguments0Value_, arguments1Value_, ex.getResult());
}
return root.setresuid(arguments0Value_, arguments1Value_, arguments2Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value) {
if (RubyTypesGen.isImplicitInteger(arguments0Value, arguments0ImplicitType) && RubyTypesGen.isImplicitInteger(arguments1Value, arguments1ImplicitType) && RubyTypesGen.isImplicitInteger(arguments2Value, arguments2ImplicitType)) {
int arguments0Value_ = RubyTypesGen.asImplicitInteger(arguments0Value, arguments0ImplicitType);
int arguments1Value_ = RubyTypesGen.asImplicitInteger(arguments1Value, arguments1ImplicitType);
int arguments2Value_ = RubyTypesGen.asImplicitInteger(arguments2Value, arguments2ImplicitType);
return root.setresuid(arguments0Value_, arguments1Value_, arguments2Value_);
}
return getNext().executeInt_(frameValue, arguments0Value, arguments1Value, arguments2Value);
}
static BaseNode_ create(SetResuidNodeGen root, Object arguments0Value, Object arguments1Value, Object arguments2Value) {
return new SetresuidNode_(root, arguments0Value, arguments1Value, arguments2Value);
}
}
}
}
@GeneratedBy(SetEuidNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class SetEuidNodeFactory implements NodeFactory {
private static SetEuidNodeFactory setEuidNodeFactoryInstance;
private SetEuidNodeFactory() {
}
@Override
public Class getNodeClass() {
return SetEuidNode.class;
}
@Override
public List getExecutionSignature() {
return Arrays.asList(RubyNode.class);
}
@Override
public List getNodeSignatures() {
return Arrays.asList(Arrays.asList(RubyNode[].class));
}
@Override
public SetEuidNode 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 (setEuidNodeFactoryInstance == null) {
setEuidNodeFactoryInstance = new SetEuidNodeFactory();
}
return setEuidNodeFactoryInstance;
}
public static SetEuidNode create(RubyNode[] arguments) {
return new SetEuidNodeGen(arguments);
}
@GeneratedBy(SetEuidNode.class)
public static final class SetEuidNodeGen extends SetEuidNode implements SpecializedNode {
@Child private RubyNode arguments0_;
@CompilationFinal private Class arguments0Type_;
@Child private BaseNode_ specialization_;
private SetEuidNodeGen(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(SetEuidNode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected SetEuidNodeGen root;
BaseNode_(SetEuidNodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (SetEuidNodeGen) 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_ = executeArguments0_(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 (RubyTypesGen.isImplicitInteger(arguments0Value)) {
return SeteuidNode_.create(root, arguments0Value);
}
return null;
}
@Override
protected final SpecializationNode createPolymorphic() {
return PolymorphicNode_.create(root);
}
protected final BaseNode_ getNext() {
return (BaseNode_) this.next;
}
protected final Object executeArguments0_(Frame frameValue) {
Class arguments0Type_ = root.arguments0Type_;
try {
if (arguments0Type_ == int.class) {
return root.arguments0_.executeInteger((VirtualFrame) frameValue);
} else if (arguments0Type_ == null) {
CompilerDirectives.transferToInterpreterAndInvalidate();
Class _type = Object.class;
try {
Object _value = root.arguments0_.execute((VirtualFrame) frameValue);
if (_value instanceof Integer) {
_type = int.class;
} else {
_type = Object.class;
}
return _value;
} finally {
root.arguments0Type_ = _type;
}
} else {
return root.arguments0_.execute((VirtualFrame) frameValue);
}
} catch (UnexpectedResultException ex) {
root.arguments0Type_ = Object.class;
return ex.getResult();
}
}
}
@GeneratedBy(SetEuidNode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(SetEuidNodeGen root) {
super(root, 2147483647);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value) {
return (int) uninitialized(frameValue, arguments0Value);
}
static BaseNode_ create(SetEuidNodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(SetEuidNode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(SetEuidNodeGen 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_ = executeArguments0_(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value) {
return getNext().executeInt_(frameValue, arguments0Value);
}
static BaseNode_ create(SetEuidNodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "seteuid(int)", value = SetEuidNode.class)
private static final class SeteuidNode_ extends BaseNode_ {
private final Class arguments0ImplicitType;
SeteuidNode_(SetEuidNodeGen root, Object arguments0Value) {
super(root, 1);
this.arguments0ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments0Value);
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.arguments0ImplicitType == ((SeteuidNode_) other).arguments0ImplicitType;
}
@Override
public Object execute(VirtualFrame frameValue) {
return executeInt(frameValue);
}
@Override
public int executeInt(VirtualFrame frameValue) {
int arguments0Value_;
try {
if (arguments0ImplicitType == int.class) {
arguments0Value_ = root.arguments0_.executeInteger(frameValue);
} else {
Object arguments0Value__ = executeArguments0_(frameValue);
arguments0Value_ = RubyTypesGen.expectImplicitInteger(arguments0Value__, arguments0ImplicitType);
}
} catch (UnexpectedResultException ex) {
return getNext().executeInt_(frameValue, ex.getResult());
}
return root.seteuid(arguments0Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value) {
if (RubyTypesGen.isImplicitInteger(arguments0Value, arguments0ImplicitType)) {
int arguments0Value_ = RubyTypesGen.asImplicitInteger(arguments0Value, arguments0ImplicitType);
return root.seteuid(arguments0Value_);
}
return getNext().executeInt_(frameValue, arguments0Value);
}
static BaseNode_ create(SetEuidNodeGen root, Object arguments0Value) {
return new SeteuidNode_(root, arguments0Value);
}
}
}
}
@GeneratedBy(SetReuidNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class SetReuidNodeFactory implements NodeFactory {
private static SetReuidNodeFactory setReuidNodeFactoryInstance;
private SetReuidNodeFactory() {
}
@Override
public Class getNodeClass() {
return SetReuidNode.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 SetReuidNode 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 (setReuidNodeFactoryInstance == null) {
setReuidNodeFactoryInstance = new SetReuidNodeFactory();
}
return setReuidNodeFactoryInstance;
}
public static SetReuidNode create(RubyNode[] arguments) {
return new SetReuidNodeGen(arguments);
}
@GeneratedBy(SetReuidNode.class)
public static final class SetReuidNodeGen extends SetReuidNode implements SpecializedNode {
@Child private RubyNode arguments0_;
@Child private RubyNode arguments1_;
@CompilationFinal private Class arguments0Type_;
@CompilationFinal private Class arguments1Type_;
@Child private BaseNode_ specialization_;
private SetReuidNodeGen(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) {
return specialization_.executeInt(frameValue);
}
@Override
public SpecializationNode getSpecializationNode() {
return specialization_;
}
@Override
public Node deepCopy() {
return SpecializationNode.updateRoot(super.deepCopy());
}
@GeneratedBy(SetReuidNode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected SetReuidNodeGen root;
BaseNode_(SetReuidNodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (SetReuidNodeGen) 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.executeInt_((VirtualFrame) frameValue, arguments0Value, arguments1Value);
}
public abstract int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value);
public Object execute(VirtualFrame frameValue) {
Object arguments0Value_ = executeArguments0_(frameValue);
Object arguments1Value_ = executeArguments1_(frameValue);
return executeInt_(frameValue, arguments0Value_, arguments1Value_);
}
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, Object arguments1Value) {
if (RubyTypesGen.isImplicitInteger(arguments0Value) && RubyTypesGen.isImplicitInteger(arguments1Value)) {
return SetreuidNode_.create(root, arguments0Value, arguments1Value);
}
return null;
}
@Override
protected final SpecializationNode createPolymorphic() {
return PolymorphicNode_.create(root);
}
protected final BaseNode_ getNext() {
return (BaseNode_) this.next;
}
protected final Object executeArguments0_(Frame frameValue) {
Class arguments0Type_ = root.arguments0Type_;
try {
if (arguments0Type_ == int.class) {
return root.arguments0_.executeInteger((VirtualFrame) frameValue);
} else if (arguments0Type_ == null) {
CompilerDirectives.transferToInterpreterAndInvalidate();
Class _type = Object.class;
try {
Object _value = root.arguments0_.execute((VirtualFrame) frameValue);
if (_value instanceof Integer) {
_type = int.class;
} else {
_type = Object.class;
}
return _value;
} finally {
root.arguments0Type_ = _type;
}
} else {
return root.arguments0_.execute((VirtualFrame) frameValue);
}
} catch (UnexpectedResultException ex) {
root.arguments0Type_ = Object.class;
return ex.getResult();
}
}
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();
}
}
}
@GeneratedBy(SetReuidNode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(SetReuidNodeGen root) {
super(root, 2147483647);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value) {
return (int) uninitialized(frameValue, arguments0Value, arguments1Value);
}
static BaseNode_ create(SetReuidNodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(SetReuidNode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(SetReuidNodeGen 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 int executeInt(VirtualFrame frameValue) {
Object arguments0Value_ = executeArguments0_(frameValue);
Object arguments1Value_ = executeArguments1_(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value) {
return getNext().executeInt_(frameValue, arguments0Value, arguments1Value);
}
static BaseNode_ create(SetReuidNodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "setreuid(int, int)", value = SetReuidNode.class)
private static final class SetreuidNode_ extends BaseNode_ {
private final Class arguments0ImplicitType;
private final Class arguments1ImplicitType;
SetreuidNode_(SetReuidNodeGen root, Object arguments0Value, Object arguments1Value) {
super(root, 1);
this.arguments0ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments0Value);
this.arguments1ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments1Value);
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.arguments0ImplicitType == ((SetreuidNode_) other).arguments0ImplicitType && this.arguments1ImplicitType == ((SetreuidNode_) other).arguments1ImplicitType;
}
@Override
public Object execute(VirtualFrame frameValue) {
return executeInt(frameValue);
}
@Override
public int executeInt(VirtualFrame frameValue) {
int arguments0Value_;
try {
if (arguments0ImplicitType == int.class) {
arguments0Value_ = root.arguments0_.executeInteger(frameValue);
} else {
Object arguments0Value__ = executeArguments0_(frameValue);
arguments0Value_ = RubyTypesGen.expectImplicitInteger(arguments0Value__, arguments0ImplicitType);
}
} catch (UnexpectedResultException ex) {
Object arguments1Value = executeArguments1_(frameValue);
return getNext().executeInt_(frameValue, ex.getResult(), arguments1Value);
}
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) {
return getNext().executeInt_(frameValue, arguments0Value_, ex.getResult());
}
return root.setreuid(arguments0Value_, arguments1Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value) {
if (RubyTypesGen.isImplicitInteger(arguments0Value, arguments0ImplicitType) && RubyTypesGen.isImplicitInteger(arguments1Value, arguments1ImplicitType)) {
int arguments0Value_ = RubyTypesGen.asImplicitInteger(arguments0Value, arguments0ImplicitType);
int arguments1Value_ = RubyTypesGen.asImplicitInteger(arguments1Value, arguments1ImplicitType);
return root.setreuid(arguments0Value_, arguments1Value_);
}
return getNext().executeInt_(frameValue, arguments0Value, arguments1Value);
}
static BaseNode_ create(SetReuidNodeGen root, Object arguments0Value, Object arguments1Value) {
return new SetreuidNode_(root, arguments0Value, arguments1Value);
}
}
}
}
@GeneratedBy(SetRLimitNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class SetRLimitNodeFactory implements NodeFactory {
private static SetRLimitNodeFactory setRLimitNodeFactoryInstance;
private SetRLimitNodeFactory() {
}
@Override
public Class getNodeClass() {
return SetRLimitNode.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 SetRLimitNode 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 (setRLimitNodeFactoryInstance == null) {
setRLimitNodeFactoryInstance = new SetRLimitNodeFactory();
}
return setRLimitNodeFactoryInstance;
}
public static SetRLimitNode create(RubyNode[] arguments) {
return new SetRLimitNodeGen(arguments);
}
@GeneratedBy(SetRLimitNode.class)
public static final class SetRLimitNodeGen extends SetRLimitNode implements SpecializedNode {
@Child private RubyNode arguments0_;
@Child private RubyNode arguments1_;
@CompilationFinal private Class arguments0Type_;
@Child private BaseNode_ specialization_;
private SetRLimitNodeGen(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) {
return specialization_.executeInt(frameValue);
}
@Override
public SpecializationNode getSpecializationNode() {
return specialization_;
}
@Override
public Node deepCopy() {
return SpecializationNode.updateRoot(super.deepCopy());
}
@GeneratedBy(SetRLimitNode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected SetRLimitNodeGen root;
BaseNode_(SetRLimitNodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (SetRLimitNodeGen) 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.executeInt_((VirtualFrame) frameValue, arguments0Value, arguments1Value);
}
public abstract int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value);
public Object execute(VirtualFrame frameValue) {
Object arguments0Value_ = executeArguments0_(frameValue);
Object arguments1Value_ = root.arguments1_.execute(frameValue);
return executeInt_(frameValue, arguments0Value_, arguments1Value_);
}
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, Object arguments1Value) {
if (RubyTypesGen.isImplicitInteger(arguments0Value) && arguments1Value instanceof DynamicObject) {
DynamicObject arguments1Value_ = (DynamicObject) arguments1Value;
if ((RubyGuards.isRubyPointer(arguments1Value_))) {
BranchProfile errorProfile1 = (BranchProfile.create());
return SetrlimitNode_.create(root, arguments0Value, errorProfile1);
}
}
return null;
}
@Override
protected final SpecializationNode createPolymorphic() {
return PolymorphicNode_.create(root);
}
protected final BaseNode_ getNext() {
return (BaseNode_) this.next;
}
protected final Object executeArguments0_(Frame frameValue) {
Class arguments0Type_ = root.arguments0Type_;
try {
if (arguments0Type_ == int.class) {
return root.arguments0_.executeInteger((VirtualFrame) frameValue);
} else if (arguments0Type_ == null) {
CompilerDirectives.transferToInterpreterAndInvalidate();
Class _type = Object.class;
try {
Object _value = root.arguments0_.execute((VirtualFrame) frameValue);
if (_value instanceof Integer) {
_type = int.class;
} else {
_type = Object.class;
}
return _value;
} finally {
root.arguments0Type_ = _type;
}
} else {
return root.arguments0_.execute((VirtualFrame) frameValue);
}
} catch (UnexpectedResultException ex) {
root.arguments0Type_ = Object.class;
return ex.getResult();
}
}
}
@GeneratedBy(SetRLimitNode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(SetRLimitNodeGen root) {
super(root, 2147483647);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value) {
return (int) uninitialized(frameValue, arguments0Value, arguments1Value);
}
static BaseNode_ create(SetRLimitNodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(SetRLimitNode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(SetRLimitNodeGen 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 int executeInt(VirtualFrame frameValue) {
Object arguments0Value_ = executeArguments0_(frameValue);
Object arguments1Value_ = root.arguments1_.execute(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value) {
return getNext().executeInt_(frameValue, arguments0Value, arguments1Value);
}
static BaseNode_ create(SetRLimitNodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "setrlimit(int, DynamicObject, BranchProfile)", value = SetRLimitNode.class)
private static final class SetrlimitNode_ extends BaseNode_ {
private final BranchProfile errorProfile;
private final Class arguments0ImplicitType;
SetrlimitNode_(SetRLimitNodeGen root, Object arguments0Value, BranchProfile errorProfile) {
super(root, 1);
this.arguments0ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments0Value);
this.errorProfile = errorProfile;
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.arguments0ImplicitType == ((SetrlimitNode_) other).arguments0ImplicitType;
}
@Override
public Object execute(VirtualFrame frameValue) {
return executeInt(frameValue);
}
@Override
public int executeInt(VirtualFrame frameValue) {
int arguments0Value_;
try {
if (arguments0ImplicitType == int.class) {
arguments0Value_ = root.arguments0_.executeInteger(frameValue);
} else {
Object arguments0Value__ = executeArguments0_(frameValue);
arguments0Value_ = RubyTypesGen.expectImplicitInteger(arguments0Value__, arguments0ImplicitType);
}
} catch (UnexpectedResultException ex) {
Object arguments1Value = root.arguments1_.execute(frameValue);
return getNext().executeInt_(frameValue, ex.getResult(), arguments1Value);
}
DynamicObject arguments1Value_;
try {
arguments1Value_ = root.arguments1_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
return getNext().executeInt_(frameValue, arguments0Value_, ex.getResult());
}
if ((RubyGuards.isRubyPointer(arguments1Value_))) {
return root.setrlimit(arguments0Value_, arguments1Value_, this.errorProfile);
}
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value) {
if (RubyTypesGen.isImplicitInteger(arguments0Value, arguments0ImplicitType) && arguments1Value instanceof DynamicObject) {
int arguments0Value_ = RubyTypesGen.asImplicitInteger(arguments0Value, arguments0ImplicitType);
DynamicObject arguments1Value_ = (DynamicObject) arguments1Value;
if ((RubyGuards.isRubyPointer(arguments1Value_))) {
return root.setrlimit(arguments0Value_, arguments1Value_, this.errorProfile);
}
}
return getNext().executeInt_(frameValue, arguments0Value, arguments1Value);
}
static BaseNode_ create(SetRLimitNodeGen root, Object arguments0Value, BranchProfile errorProfile) {
return new SetrlimitNode_(root, arguments0Value, errorProfile);
}
}
}
}
@GeneratedBy(SetRuidNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class SetRuidNodeFactory implements NodeFactory {
private static SetRuidNodeFactory setRuidNodeFactoryInstance;
private SetRuidNodeFactory() {
}
@Override
public Class getNodeClass() {
return SetRuidNode.class;
}
@Override
public List getExecutionSignature() {
return Arrays.asList(RubyNode.class);
}
@Override
public List getNodeSignatures() {
return Arrays.asList(Arrays.asList(RubyNode[].class));
}
@Override
public SetRuidNode 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 (setRuidNodeFactoryInstance == null) {
setRuidNodeFactoryInstance = new SetRuidNodeFactory();
}
return setRuidNodeFactoryInstance;
}
public static SetRuidNode create(RubyNode[] arguments) {
return new SetRuidNodeGen(arguments);
}
@GeneratedBy(SetRuidNode.class)
public static final class SetRuidNodeGen extends SetRuidNode implements SpecializedNode {
@Child private RubyNode arguments0_;
@CompilationFinal private Class arguments0Type_;
@Child private BaseNode_ specialization_;
private SetRuidNodeGen(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(SetRuidNode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected SetRuidNodeGen root;
BaseNode_(SetRuidNodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (SetRuidNodeGen) 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_ = executeArguments0_(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 (RubyTypesGen.isImplicitInteger(arguments0Value)) {
return SetruidNode_.create(root, arguments0Value);
}
return null;
}
@Override
protected final SpecializationNode createPolymorphic() {
return PolymorphicNode_.create(root);
}
protected final BaseNode_ getNext() {
return (BaseNode_) this.next;
}
protected final Object executeArguments0_(Frame frameValue) {
Class arguments0Type_ = root.arguments0Type_;
try {
if (arguments0Type_ == int.class) {
return root.arguments0_.executeInteger((VirtualFrame) frameValue);
} else if (arguments0Type_ == null) {
CompilerDirectives.transferToInterpreterAndInvalidate();
Class _type = Object.class;
try {
Object _value = root.arguments0_.execute((VirtualFrame) frameValue);
if (_value instanceof Integer) {
_type = int.class;
} else {
_type = Object.class;
}
return _value;
} finally {
root.arguments0Type_ = _type;
}
} else {
return root.arguments0_.execute((VirtualFrame) frameValue);
}
} catch (UnexpectedResultException ex) {
root.arguments0Type_ = Object.class;
return ex.getResult();
}
}
}
@GeneratedBy(SetRuidNode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(SetRuidNodeGen root) {
super(root, 2147483647);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value) {
return (int) uninitialized(frameValue, arguments0Value);
}
static BaseNode_ create(SetRuidNodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(SetRuidNode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(SetRuidNodeGen 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_ = executeArguments0_(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value) {
return getNext().executeInt_(frameValue, arguments0Value);
}
static BaseNode_ create(SetRuidNodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "setruid(int)", value = SetRuidNode.class)
private static final class SetruidNode_ extends BaseNode_ {
private final Class arguments0ImplicitType;
SetruidNode_(SetRuidNodeGen root, Object arguments0Value) {
super(root, 1);
this.arguments0ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments0Value);
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.arguments0ImplicitType == ((SetruidNode_) other).arguments0ImplicitType;
}
@Override
public Object execute(VirtualFrame frameValue) {
return executeInt(frameValue);
}
@Override
public int executeInt(VirtualFrame frameValue) {
int arguments0Value_;
try {
if (arguments0ImplicitType == int.class) {
arguments0Value_ = root.arguments0_.executeInteger(frameValue);
} else {
Object arguments0Value__ = executeArguments0_(frameValue);
arguments0Value_ = RubyTypesGen.expectImplicitInteger(arguments0Value__, arguments0ImplicitType);
}
} catch (UnexpectedResultException ex) {
return getNext().executeInt_(frameValue, ex.getResult());
}
return root.setruid(arguments0Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value) {
if (RubyTypesGen.isImplicitInteger(arguments0Value, arguments0ImplicitType)) {
int arguments0Value_ = RubyTypesGen.asImplicitInteger(arguments0Value, arguments0ImplicitType);
return root.setruid(arguments0Value_);
}
return getNext().executeInt_(frameValue, arguments0Value);
}
static BaseNode_ create(SetRuidNodeGen root, Object arguments0Value) {
return new SetruidNode_(root, arguments0Value);
}
}
}
}
@GeneratedBy(SetUidNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class SetUidNodeFactory implements NodeFactory {
private static SetUidNodeFactory setUidNodeFactoryInstance;
private SetUidNodeFactory() {
}
@Override
public Class getNodeClass() {
return SetUidNode.class;
}
@Override
public List getExecutionSignature() {
return Arrays.asList(RubyNode.class);
}
@Override
public List getNodeSignatures() {
return Arrays.asList(Arrays.asList(RubyNode[].class));
}
@Override
public SetUidNode 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 (setUidNodeFactoryInstance == null) {
setUidNodeFactoryInstance = new SetUidNodeFactory();
}
return setUidNodeFactoryInstance;
}
public static SetUidNode create(RubyNode[] arguments) {
return new SetUidNodeGen(arguments);
}
@GeneratedBy(SetUidNode.class)
public static final class SetUidNodeGen extends SetUidNode implements SpecializedNode {
@Child private RubyNode arguments0_;
@CompilationFinal private Class arguments0Type_;
@Child private BaseNode_ specialization_;
private SetUidNodeGen(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(SetUidNode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected SetUidNodeGen root;
BaseNode_(SetUidNodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (SetUidNodeGen) 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_ = executeArguments0_(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 (RubyTypesGen.isImplicitInteger(arguments0Value)) {
return SetuidNode_.create(root, arguments0Value);
}
return null;
}
@Override
protected final SpecializationNode createPolymorphic() {
return PolymorphicNode_.create(root);
}
protected final BaseNode_ getNext() {
return (BaseNode_) this.next;
}
protected final Object executeArguments0_(Frame frameValue) {
Class arguments0Type_ = root.arguments0Type_;
try {
if (arguments0Type_ == int.class) {
return root.arguments0_.executeInteger((VirtualFrame) frameValue);
} else if (arguments0Type_ == null) {
CompilerDirectives.transferToInterpreterAndInvalidate();
Class _type = Object.class;
try {
Object _value = root.arguments0_.execute((VirtualFrame) frameValue);
if (_value instanceof Integer) {
_type = int.class;
} else {
_type = Object.class;
}
return _value;
} finally {
root.arguments0Type_ = _type;
}
} else {
return root.arguments0_.execute((VirtualFrame) frameValue);
}
} catch (UnexpectedResultException ex) {
root.arguments0Type_ = Object.class;
return ex.getResult();
}
}
}
@GeneratedBy(SetUidNode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(SetUidNodeGen root) {
super(root, 2147483647);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value) {
return (int) uninitialized(frameValue, arguments0Value);
}
static BaseNode_ create(SetUidNodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(SetUidNode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(SetUidNodeGen 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_ = executeArguments0_(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value) {
return getNext().executeInt_(frameValue, arguments0Value);
}
static BaseNode_ create(SetUidNodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "setuid(int)", value = SetUidNode.class)
private static final class SetuidNode_ extends BaseNode_ {
private final Class arguments0ImplicitType;
SetuidNode_(SetUidNodeGen root, Object arguments0Value) {
super(root, 1);
this.arguments0ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments0Value);
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.arguments0ImplicitType == ((SetuidNode_) other).arguments0ImplicitType;
}
@Override
public Object execute(VirtualFrame frameValue) {
return executeInt(frameValue);
}
@Override
public int executeInt(VirtualFrame frameValue) {
int arguments0Value_;
try {
if (arguments0ImplicitType == int.class) {
arguments0Value_ = root.arguments0_.executeInteger(frameValue);
} else {
Object arguments0Value__ = executeArguments0_(frameValue);
arguments0Value_ = RubyTypesGen.expectImplicitInteger(arguments0Value__, arguments0ImplicitType);
}
} catch (UnexpectedResultException ex) {
return getNext().executeInt_(frameValue, ex.getResult());
}
return root.setuid(arguments0Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value) {
if (RubyTypesGen.isImplicitInteger(arguments0Value, arguments0ImplicitType)) {
int arguments0Value_ = RubyTypesGen.asImplicitInteger(arguments0Value, arguments0ImplicitType);
return root.setuid(arguments0Value_);
}
return getNext().executeInt_(frameValue, arguments0Value);
}
static BaseNode_ create(SetUidNodeGen root, Object arguments0Value) {
return new SetuidNode_(root, arguments0Value);
}
}
}
}
@GeneratedBy(SetSidNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class SetSidNodeFactory implements NodeFactory {
private static SetSidNodeFactory setSidNodeFactoryInstance;
private SetSidNodeFactory() {
}
@Override
public Class getNodeClass() {
return SetSidNode.class;
}
@Override
public List getExecutionSignature() {
return Arrays.asList();
}
@Override
public List getNodeSignatures() {
return Arrays.asList(Arrays.asList(RubyNode[].class));
}
@Override
public SetSidNode 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 (setSidNodeFactoryInstance == null) {
setSidNodeFactoryInstance = new SetSidNodeFactory();
}
return setSidNodeFactoryInstance;
}
public static SetSidNode create(RubyNode[] arguments) {
return new SetSidNodeGen(arguments);
}
@GeneratedBy(SetSidNode.class)
public static final class SetSidNodeGen extends SetSidNode {
@SuppressWarnings("unused")
private SetSidNodeGen(RubyNode[] arguments) {
}
@Override
public NodeCost getCost() {
return NodeCost.MONOMORPHIC;
}
@Override
public Object execute(VirtualFrame frameValue) {
return executeInteger(frameValue);
}
@Override
public void executeVoid(VirtualFrame frameValue) {
executeInteger(frameValue);
return;
}
@Override
public int executeInteger(VirtualFrame frameValue) {
return this.setsid();
}
}
}
@GeneratedBy(FlockNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class FlockNodeFactory implements NodeFactory {
private static FlockNodeFactory flockNodeFactoryInstance;
private FlockNodeFactory() {
}
@Override
public Class getNodeClass() {
return FlockNode.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 FlockNode 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 (flockNodeFactoryInstance == null) {
flockNodeFactoryInstance = new FlockNodeFactory();
}
return flockNodeFactoryInstance;
}
public static FlockNode create(RubyNode[] arguments) {
return new FlockNodeGen(arguments);
}
@GeneratedBy(FlockNode.class)
public static final class FlockNodeGen extends FlockNode implements SpecializedNode {
@Child private RubyNode arguments0_;
@Child private RubyNode arguments1_;
@CompilationFinal private Class arguments0Type_;
@CompilationFinal private Class arguments1Type_;
@Child private BaseNode_ specialization_;
private FlockNodeGen(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) {
return specialization_.executeInt(frameValue);
}
@Override
public SpecializationNode getSpecializationNode() {
return specialization_;
}
@Override
public Node deepCopy() {
return SpecializationNode.updateRoot(super.deepCopy());
}
@GeneratedBy(FlockNode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected FlockNodeGen root;
BaseNode_(FlockNodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (FlockNodeGen) 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.executeInt_((VirtualFrame) frameValue, arguments0Value, arguments1Value);
}
public abstract int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value);
public Object execute(VirtualFrame frameValue) {
Object arguments0Value_ = executeArguments0_(frameValue);
Object arguments1Value_ = executeArguments1_(frameValue);
return executeInt_(frameValue, arguments0Value_, arguments1Value_);
}
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, Object arguments1Value) {
if (RubyTypesGen.isImplicitInteger(arguments0Value) && RubyTypesGen.isImplicitInteger(arguments1Value)) {
return FlockNode_.create(root, arguments0Value, arguments1Value);
}
return null;
}
@Override
protected final SpecializationNode createPolymorphic() {
return PolymorphicNode_.create(root);
}
protected final BaseNode_ getNext() {
return (BaseNode_) this.next;
}
protected final Object executeArguments0_(Frame frameValue) {
Class arguments0Type_ = root.arguments0Type_;
try {
if (arguments0Type_ == int.class) {
return root.arguments0_.executeInteger((VirtualFrame) frameValue);
} else if (arguments0Type_ == null) {
CompilerDirectives.transferToInterpreterAndInvalidate();
Class _type = Object.class;
try {
Object _value = root.arguments0_.execute((VirtualFrame) frameValue);
if (_value instanceof Integer) {
_type = int.class;
} else {
_type = Object.class;
}
return _value;
} finally {
root.arguments0Type_ = _type;
}
} else {
return root.arguments0_.execute((VirtualFrame) frameValue);
}
} catch (UnexpectedResultException ex) {
root.arguments0Type_ = Object.class;
return ex.getResult();
}
}
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();
}
}
}
@GeneratedBy(FlockNode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(FlockNodeGen root) {
super(root, 2147483647);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value) {
return (int) uninitialized(frameValue, arguments0Value, arguments1Value);
}
static BaseNode_ create(FlockNodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(FlockNode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(FlockNodeGen 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 int executeInt(VirtualFrame frameValue) {
Object arguments0Value_ = executeArguments0_(frameValue);
Object arguments1Value_ = executeArguments1_(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value) {
return getNext().executeInt_(frameValue, arguments0Value, arguments1Value);
}
static BaseNode_ create(FlockNodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "flock(int, int)", value = FlockNode.class)
private static final class FlockNode_ extends BaseNode_ {
private final Class arguments0ImplicitType;
private final Class arguments1ImplicitType;
FlockNode_(FlockNodeGen root, Object arguments0Value, Object arguments1Value) {
super(root, 1);
this.arguments0ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments0Value);
this.arguments1ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments1Value);
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.arguments0ImplicitType == ((FlockNode_) other).arguments0ImplicitType && this.arguments1ImplicitType == ((FlockNode_) other).arguments1ImplicitType;
}
@Override
public Object execute(VirtualFrame frameValue) {
return executeInt(frameValue);
}
@Override
public int executeInt(VirtualFrame frameValue) {
int arguments0Value_;
try {
if (arguments0ImplicitType == int.class) {
arguments0Value_ = root.arguments0_.executeInteger(frameValue);
} else {
Object arguments0Value__ = executeArguments0_(frameValue);
arguments0Value_ = RubyTypesGen.expectImplicitInteger(arguments0Value__, arguments0ImplicitType);
}
} catch (UnexpectedResultException ex) {
Object arguments1Value = executeArguments1_(frameValue);
return getNext().executeInt_(frameValue, ex.getResult(), arguments1Value);
}
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) {
return getNext().executeInt_(frameValue, arguments0Value_, ex.getResult());
}
return root.flock(arguments0Value_, arguments1Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value) {
if (RubyTypesGen.isImplicitInteger(arguments0Value, arguments0ImplicitType) && RubyTypesGen.isImplicitInteger(arguments1Value, arguments1ImplicitType)) {
int arguments0Value_ = RubyTypesGen.asImplicitInteger(arguments0Value, arguments0ImplicitType);
int arguments1Value_ = RubyTypesGen.asImplicitInteger(arguments1Value, arguments1ImplicitType);
return root.flock(arguments0Value_, arguments1Value_);
}
return getNext().executeInt_(frameValue, arguments0Value, arguments1Value);
}
static BaseNode_ create(FlockNodeGen root, Object arguments0Value, Object arguments1Value) {
return new FlockNode_(root, arguments0Value, arguments1Value);
}
}
}
}
@GeneratedBy(MajorNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class MajorNodeFactory implements NodeFactory {
private static MajorNodeFactory majorNodeFactoryInstance;
private MajorNodeFactory() {
}
@Override
public Class getNodeClass() {
return MajorNode.class;
}
@Override
public List getExecutionSignature() {
return Arrays.asList(RubyNode.class);
}
@Override
public List getNodeSignatures() {
return Arrays.asList(Arrays.asList(RubyNode[].class));
}
@Override
public MajorNode 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 (majorNodeFactoryInstance == null) {
majorNodeFactoryInstance = new MajorNodeFactory();
}
return majorNodeFactoryInstance;
}
public static MajorNode create(RubyNode[] arguments) {
return new MajorNodeGen(arguments);
}
@GeneratedBy(MajorNode.class)
public static final class MajorNodeGen extends MajorNode implements SpecializedNode {
@Child private RubyNode arguments0_;
@CompilationFinal private Class arguments0Type_;
@Child private BaseNode_ specialization_;
private MajorNodeGen(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(MajorNode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected MajorNodeGen root;
BaseNode_(MajorNodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (MajorNodeGen) 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_ = executeArguments0_(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 (RubyTypesGen.isImplicitLong(arguments0Value)) {
return MajorNode_.create(root, arguments0Value);
}
return null;
}
@Override
protected final SpecializationNode createPolymorphic() {
return PolymorphicNode_.create(root);
}
protected final BaseNode_ getNext() {
return (BaseNode_) this.next;
}
protected final Object executeArguments0_(Frame frameValue) {
Class arguments0Type_ = root.arguments0Type_;
try {
if (arguments0Type_ == int.class) {
return root.arguments0_.executeInteger((VirtualFrame) frameValue);
} else if (arguments0Type_ == long.class) {
return root.arguments0_.executeLong((VirtualFrame) frameValue);
} else if (arguments0Type_ == null) {
CompilerDirectives.transferToInterpreterAndInvalidate();
Class _type = Object.class;
try {
Object _value = root.arguments0_.execute((VirtualFrame) frameValue);
if (_value instanceof Integer) {
_type = int.class;
} else if (_value instanceof Long) {
_type = long.class;
} else {
_type = Object.class;
}
return _value;
} finally {
root.arguments0Type_ = _type;
}
} else {
return root.arguments0_.execute((VirtualFrame) frameValue);
}
} catch (UnexpectedResultException ex) {
root.arguments0Type_ = Object.class;
return ex.getResult();
}
}
}
@GeneratedBy(MajorNode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(MajorNodeGen root) {
super(root, 2147483647);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value) {
return (int) uninitialized(frameValue, arguments0Value);
}
static BaseNode_ create(MajorNodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(MajorNode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(MajorNodeGen 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_ = executeArguments0_(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value) {
return getNext().executeInt_(frameValue, arguments0Value);
}
static BaseNode_ create(MajorNodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "major(long)", value = MajorNode.class)
private static final class MajorNode_ extends BaseNode_ {
private final Class arguments0ImplicitType;
MajorNode_(MajorNodeGen root, Object arguments0Value) {
super(root, 1);
this.arguments0ImplicitType = RubyTypesGen.getImplicitLongClass(arguments0Value);
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.arguments0ImplicitType == ((MajorNode_) other).arguments0ImplicitType;
}
@Override
public Object execute(VirtualFrame frameValue) {
return executeInt(frameValue);
}
@Override
public int executeInt(VirtualFrame frameValue) {
long arguments0Value_;
try {
if (arguments0ImplicitType == long.class) {
arguments0Value_ = root.arguments0_.executeLong(frameValue);
} else if (arguments0ImplicitType == int.class) {
arguments0Value_ = RubyTypes.promoteToLong(root.arguments0_.executeInteger(frameValue));
} else {
Object arguments0Value__ = executeArguments0_(frameValue);
arguments0Value_ = RubyTypesGen.expectImplicitLong(arguments0Value__, arguments0ImplicitType);
}
} catch (UnexpectedResultException ex) {
return getNext().executeInt_(frameValue, ex.getResult());
}
return root.major(arguments0Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value) {
if (RubyTypesGen.isImplicitLong(arguments0Value, arguments0ImplicitType)) {
long arguments0Value_ = RubyTypesGen.asImplicitLong(arguments0Value, arguments0ImplicitType);
return root.major(arguments0Value_);
}
return getNext().executeInt_(frameValue, arguments0Value);
}
static BaseNode_ create(MajorNodeGen root, Object arguments0Value) {
return new MajorNode_(root, arguments0Value);
}
}
}
}
@GeneratedBy(MinorNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class MinorNodeFactory implements NodeFactory {
private static MinorNodeFactory minorNodeFactoryInstance;
private MinorNodeFactory() {
}
@Override
public Class getNodeClass() {
return MinorNode.class;
}
@Override
public List getExecutionSignature() {
return Arrays.asList(RubyNode.class);
}
@Override
public List getNodeSignatures() {
return Arrays.asList(Arrays.asList(RubyNode[].class));
}
@Override
public MinorNode 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 (minorNodeFactoryInstance == null) {
minorNodeFactoryInstance = new MinorNodeFactory();
}
return minorNodeFactoryInstance;
}
public static MinorNode create(RubyNode[] arguments) {
return new MinorNodeGen(arguments);
}
@GeneratedBy(MinorNode.class)
public static final class MinorNodeGen extends MinorNode implements SpecializedNode {
@Child private RubyNode arguments0_;
@CompilationFinal private Class arguments0Type_;
@Child private BaseNode_ specialization_;
private MinorNodeGen(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(MinorNode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected MinorNodeGen root;
BaseNode_(MinorNodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (MinorNodeGen) 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_ = executeArguments0_(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 (RubyTypesGen.isImplicitLong(arguments0Value)) {
return MinorNode_.create(root, arguments0Value);
}
return null;
}
@Override
protected final SpecializationNode createPolymorphic() {
return PolymorphicNode_.create(root);
}
protected final BaseNode_ getNext() {
return (BaseNode_) this.next;
}
protected final Object executeArguments0_(Frame frameValue) {
Class arguments0Type_ = root.arguments0Type_;
try {
if (arguments0Type_ == int.class) {
return root.arguments0_.executeInteger((VirtualFrame) frameValue);
} else if (arguments0Type_ == long.class) {
return root.arguments0_.executeLong((VirtualFrame) frameValue);
} else if (arguments0Type_ == null) {
CompilerDirectives.transferToInterpreterAndInvalidate();
Class _type = Object.class;
try {
Object _value = root.arguments0_.execute((VirtualFrame) frameValue);
if (_value instanceof Integer) {
_type = int.class;
} else if (_value instanceof Long) {
_type = long.class;
} else {
_type = Object.class;
}
return _value;
} finally {
root.arguments0Type_ = _type;
}
} else {
return root.arguments0_.execute((VirtualFrame) frameValue);
}
} catch (UnexpectedResultException ex) {
root.arguments0Type_ = Object.class;
return ex.getResult();
}
}
}
@GeneratedBy(MinorNode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(MinorNodeGen root) {
super(root, 2147483647);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value) {
return (int) uninitialized(frameValue, arguments0Value);
}
static BaseNode_ create(MinorNodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(MinorNode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(MinorNodeGen 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_ = executeArguments0_(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value) {
return getNext().executeInt_(frameValue, arguments0Value);
}
static BaseNode_ create(MinorNodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "minor(long)", value = MinorNode.class)
private static final class MinorNode_ extends BaseNode_ {
private final Class arguments0ImplicitType;
MinorNode_(MinorNodeGen root, Object arguments0Value) {
super(root, 1);
this.arguments0ImplicitType = RubyTypesGen.getImplicitLongClass(arguments0Value);
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.arguments0ImplicitType == ((MinorNode_) other).arguments0ImplicitType;
}
@Override
public Object execute(VirtualFrame frameValue) {
return executeInt(frameValue);
}
@Override
public int executeInt(VirtualFrame frameValue) {
long arguments0Value_;
try {
if (arguments0ImplicitType == long.class) {
arguments0Value_ = root.arguments0_.executeLong(frameValue);
} else if (arguments0ImplicitType == int.class) {
arguments0Value_ = RubyTypes.promoteToLong(root.arguments0_.executeInteger(frameValue));
} else {
Object arguments0Value__ = executeArguments0_(frameValue);
arguments0Value_ = RubyTypesGen.expectImplicitLong(arguments0Value__, arguments0ImplicitType);
}
} catch (UnexpectedResultException ex) {
return getNext().executeInt_(frameValue, ex.getResult());
}
return root.minor(arguments0Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value) {
if (RubyTypesGen.isImplicitLong(arguments0Value, arguments0ImplicitType)) {
long arguments0Value_ = RubyTypesGen.asImplicitLong(arguments0Value, arguments0ImplicitType);
return root.minor(arguments0Value_);
}
return getNext().executeInt_(frameValue, arguments0Value);
}
static BaseNode_ create(MinorNodeGen root, Object arguments0Value) {
return new MinorNode_(root, arguments0Value);
}
}
}
}
@GeneratedBy(RenameNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class RenameNodeFactory implements NodeFactory {
private static RenameNodeFactory renameNodeFactoryInstance;
private RenameNodeFactory() {
}
@Override
public Class getNodeClass() {
return RenameNode.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 RenameNode 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 (renameNodeFactoryInstance == null) {
renameNodeFactoryInstance = new RenameNodeFactory();
}
return renameNodeFactoryInstance;
}
public static RenameNode create(RubyNode[] arguments) {
return new RenameNodeGen(arguments);
}
@GeneratedBy(RenameNode.class)
public static final class RenameNodeGen extends RenameNode {
@Child private RubyNode arguments0_;
@Child private RubyNode arguments1_;
@CompilationFinal private boolean seenUnsupported0;
private RenameNodeGen(RubyNode[] arguments) {
this.arguments0_ = arguments != null && 0 < arguments.length ? arguments[0] : null;
this.arguments1_ = arguments != null && 1 < arguments.length ? arguments[1] : null;
}
@Override
public NodeCost getCost() {
return NodeCost.MONOMORPHIC;
}
@Override
public Object execute(VirtualFrame frameValue) {
return executeInteger(frameValue);
}
@Override
public void executeVoid(VirtualFrame frameValue) {
executeInteger(frameValue);
return;
}
@Override
public int executeInteger(VirtualFrame frameValue) {
DynamicObject arguments0Value_;
try {
arguments0Value_ = arguments0_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object arguments1Value = arguments1_.execute(frameValue);
throw unsupported(ex.getResult(), arguments1Value);
}
DynamicObject arguments1Value_;
try {
arguments1Value_ = arguments1_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
throw unsupported(arguments0Value_, ex.getResult());
}
if ((RubyGuards.isRubyString(arguments0Value_)) && (RubyGuards.isRubyString(arguments1Value_))) {
return this.rename(arguments0Value_, arguments1Value_);
}
throw unsupported(arguments0Value_, arguments1Value_);
}
private UnsupportedSpecializationException unsupported(Object arguments0Value, Object arguments1Value) {
if (!seenUnsupported0) {
CompilerDirectives.transferToInterpreterAndInvalidate();
seenUnsupported0 = true;
}
return new UnsupportedSpecializationException(this, new Node[] {arguments0_, arguments1_}, arguments0Value, arguments1Value);
}
}
}
@GeneratedBy(RmdirNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class RmdirNodeFactory implements NodeFactory {
private static RmdirNodeFactory rmdirNodeFactoryInstance;
private RmdirNodeFactory() {
}
@Override
public Class getNodeClass() {
return RmdirNode.class;
}
@Override
public List getExecutionSignature() {
return Arrays.asList(RubyNode.class);
}
@Override
public List getNodeSignatures() {
return Arrays.asList(Arrays.asList(RubyNode[].class));
}
@Override
public RmdirNode 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 (rmdirNodeFactoryInstance == null) {
rmdirNodeFactoryInstance = new RmdirNodeFactory();
}
return rmdirNodeFactoryInstance;
}
public static RmdirNode create(RubyNode[] arguments) {
return new RmdirNodeGen(arguments);
}
@GeneratedBy(RmdirNode.class)
public static final class RmdirNodeGen extends RmdirNode {
@Child private RubyNode arguments0_;
@CompilationFinal private boolean seenUnsupported0;
private RmdirNodeGen(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) {
return executeInteger(frameValue);
}
@Override
public void executeVoid(VirtualFrame frameValue) {
executeInteger(frameValue);
return;
}
@Override
public int executeInteger(VirtualFrame frameValue) {
DynamicObject arguments0Value_;
try {
arguments0Value_ = arguments0_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
throw unsupported(ex.getResult());
}
if ((RubyGuards.isRubyString(arguments0Value_))) {
return this.rmdir(arguments0Value_);
}
throw unsupported(arguments0Value_);
}
private UnsupportedSpecializationException unsupported(Object arguments0Value) {
if (!seenUnsupported0) {
CompilerDirectives.transferToInterpreterAndInvalidate();
seenUnsupported0 = true;
}
return new UnsupportedSpecializationException(this, new Node[] {arguments0_}, arguments0Value);
}
}
}
@GeneratedBy(GetcwdNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class GetcwdNodeFactory implements NodeFactory {
private static GetcwdNodeFactory getcwdNodeFactoryInstance;
private GetcwdNodeFactory() {
}
@Override
public Class getNodeClass() {
return GetcwdNode.class;
}
@Override
public List getExecutionSignature() {
return Arrays.asList();
}
@Override
public List getNodeSignatures() {
return Arrays.asList(Arrays.asList(RubyNode[].class));
}
@Override
public GetcwdNode 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 (getcwdNodeFactoryInstance == null) {
getcwdNodeFactoryInstance = new GetcwdNodeFactory();
}
return getcwdNodeFactoryInstance;
}
public static GetcwdNode create(RubyNode[] arguments) {
return new GetcwdNodeGen(arguments);
}
@GeneratedBy(GetcwdNode.class)
public static final class GetcwdNodeGen extends GetcwdNode {
@SuppressWarnings("unused")
private GetcwdNodeGen(RubyNode[] arguments) {
}
@Override
public NodeCost getCost() {
return NodeCost.MONOMORPHIC;
}
@Override
public Object execute(VirtualFrame frameValue) {
return this.getcwd();
}
@Override
public void executeVoid(VirtualFrame frameValue) {
execute(frameValue);
return;
}
}
}
@GeneratedBy(ErrnoNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class ErrnoNodeFactory implements NodeFactory {
private static ErrnoNodeFactory errnoNodeFactoryInstance;
private ErrnoNodeFactory() {
}
@Override
public Class getNodeClass() {
return ErrnoNode.class;
}
@Override
public List getExecutionSignature() {
return Arrays.asList();
}
@Override
public List getNodeSignatures() {
return Arrays.asList(Arrays.asList(RubyNode[].class));
}
@Override
public ErrnoNode 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 (errnoNodeFactoryInstance == null) {
errnoNodeFactoryInstance = new ErrnoNodeFactory();
}
return errnoNodeFactoryInstance;
}
public static ErrnoNode create(RubyNode[] arguments) {
return new ErrnoNodeGen(arguments);
}
@GeneratedBy(ErrnoNode.class)
public static final class ErrnoNodeGen extends ErrnoNode {
@SuppressWarnings("unused")
private ErrnoNodeGen(RubyNode[] arguments) {
}
@Override
public NodeCost getCost() {
return NodeCost.MONOMORPHIC;
}
@Override
public Object execute(VirtualFrame frameValue) {
return executeInteger(frameValue);
}
@Override
public void executeVoid(VirtualFrame frameValue) {
executeInteger(frameValue);
return;
}
@Override
public int executeInteger(VirtualFrame frameValue) {
return this.errno();
}
}
}
@GeneratedBy(ErrnoAssignNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class ErrnoAssignNodeFactory implements NodeFactory {
private static ErrnoAssignNodeFactory errnoAssignNodeFactoryInstance;
private ErrnoAssignNodeFactory() {
}
@Override
public Class getNodeClass() {
return ErrnoAssignNode.class;
}
@Override
public List getExecutionSignature() {
return Arrays.asList(RubyNode.class);
}
@Override
public List getNodeSignatures() {
return Arrays.asList(Arrays.asList(RubyNode[].class));
}
@Override
public ErrnoAssignNode 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 (errnoAssignNodeFactoryInstance == null) {
errnoAssignNodeFactoryInstance = new ErrnoAssignNodeFactory();
}
return errnoAssignNodeFactoryInstance;
}
public static ErrnoAssignNode create(RubyNode[] arguments) {
return new ErrnoAssignNodeGen(arguments);
}
@GeneratedBy(ErrnoAssignNode.class)
public static final class ErrnoAssignNodeGen extends ErrnoAssignNode implements SpecializedNode {
@Child private RubyNode arguments0_;
@CompilationFinal private Class arguments0Type_;
@Child private BaseNode_ specialization_;
private ErrnoAssignNodeGen(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(ErrnoAssignNode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected ErrnoAssignNodeGen root;
BaseNode_(ErrnoAssignNodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (ErrnoAssignNodeGen) 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_ = executeArguments0_(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 (RubyTypesGen.isImplicitInteger(arguments0Value)) {
return ErrnoNode_.create(root, arguments0Value);
}
return null;
}
@Override
protected final SpecializationNode createPolymorphic() {
return PolymorphicNode_.create(root);
}
protected final BaseNode_ getNext() {
return (BaseNode_) this.next;
}
protected final Object executeArguments0_(Frame frameValue) {
Class arguments0Type_ = root.arguments0Type_;
try {
if (arguments0Type_ == int.class) {
return root.arguments0_.executeInteger((VirtualFrame) frameValue);
} else if (arguments0Type_ == null) {
CompilerDirectives.transferToInterpreterAndInvalidate();
Class _type = Object.class;
try {
Object _value = root.arguments0_.execute((VirtualFrame) frameValue);
if (_value instanceof Integer) {
_type = int.class;
} else {
_type = Object.class;
}
return _value;
} finally {
root.arguments0Type_ = _type;
}
} else {
return root.arguments0_.execute((VirtualFrame) frameValue);
}
} catch (UnexpectedResultException ex) {
root.arguments0Type_ = Object.class;
return ex.getResult();
}
}
}
@GeneratedBy(ErrnoAssignNode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(ErrnoAssignNodeGen root) {
super(root, 2147483647);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value) {
return (int) uninitialized(frameValue, arguments0Value);
}
static BaseNode_ create(ErrnoAssignNodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(ErrnoAssignNode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(ErrnoAssignNodeGen 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_ = executeArguments0_(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value) {
return getNext().executeInt_(frameValue, arguments0Value);
}
static BaseNode_ create(ErrnoAssignNodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "errno(int)", value = ErrnoAssignNode.class)
private static final class ErrnoNode_ extends BaseNode_ {
private final Class arguments0ImplicitType;
ErrnoNode_(ErrnoAssignNodeGen root, Object arguments0Value) {
super(root, 1);
this.arguments0ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments0Value);
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.arguments0ImplicitType == ((ErrnoNode_) other).arguments0ImplicitType;
}
@Override
public Object execute(VirtualFrame frameValue) {
return executeInt(frameValue);
}
@Override
public int executeInt(VirtualFrame frameValue) {
int arguments0Value_;
try {
if (arguments0ImplicitType == int.class) {
arguments0Value_ = root.arguments0_.executeInteger(frameValue);
} else {
Object arguments0Value__ = executeArguments0_(frameValue);
arguments0Value_ = RubyTypesGen.expectImplicitInteger(arguments0Value__, arguments0ImplicitType);
}
} catch (UnexpectedResultException ex) {
return getNext().executeInt_(frameValue, ex.getResult());
}
return root.errno(arguments0Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value) {
if (RubyTypesGen.isImplicitInteger(arguments0Value, arguments0ImplicitType)) {
int arguments0Value_ = RubyTypesGen.asImplicitInteger(arguments0Value, arguments0ImplicitType);
return root.errno(arguments0Value_);
}
return getNext().executeInt_(frameValue, arguments0Value);
}
static BaseNode_ create(ErrnoAssignNodeGen root, Object arguments0Value) {
return new ErrnoNode_(root, arguments0Value);
}
}
}
}
@GeneratedBy(FcntlNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class FcntlNodeFactory implements NodeFactory {
private static FcntlNodeFactory fcntlNodeFactoryInstance;
private FcntlNodeFactory() {
}
@Override
public Class getNodeClass() {
return FcntlNode.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 FcntlNode 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 (fcntlNodeFactoryInstance == null) {
fcntlNodeFactoryInstance = new FcntlNodeFactory();
}
return fcntlNodeFactoryInstance;
}
public static FcntlNode create(RubyNode[] arguments) {
return new FcntlNodeGen(arguments);
}
@GeneratedBy(FcntlNode.class)
public static final class FcntlNodeGen extends FcntlNode implements SpecializedNode {
@Child private RubyNode arguments0_;
@Child private RubyNode arguments1_;
@Child private RubyNode arguments2_;
@CompilationFinal private Class arguments0Type_;
@CompilationFinal private Class arguments1Type_;
@CompilationFinal private Class arguments2Type_;
@Child private BaseNode_ specialization_;
private FcntlNodeGen(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 int executeInteger(VirtualFrame frameValue) {
return specialization_.executeInt(frameValue);
}
@Override
public SpecializationNode getSpecializationNode() {
return specialization_;
}
@Override
public Node deepCopy() {
return SpecializationNode.updateRoot(super.deepCopy());
}
@GeneratedBy(FcntlNode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected FcntlNodeGen root;
BaseNode_(FcntlNodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (FcntlNodeGen) 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.executeInt_((VirtualFrame) frameValue, arguments0Value, arguments1Value, arguments2Value);
}
public abstract int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value);
public Object execute(VirtualFrame frameValue) {
Object arguments0Value_ = executeArguments0_(frameValue);
Object arguments1Value_ = executeArguments1_(frameValue);
Object arguments2Value_ = executeArguments2_(frameValue);
return executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_);
}
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, Object arguments1Value, Object arguments2Value) {
if (RubyTypesGen.isImplicitInteger(arguments0Value) && RubyTypesGen.isImplicitInteger(arguments1Value)) {
if ((root.isNil(arguments2Value))) {
return Fcntl0Node_.create(root, arguments0Value, arguments1Value);
}
if (RubyTypesGen.isImplicitInteger(arguments2Value)) {
return Fcntl1Node_.create(root, arguments0Value, arguments1Value, arguments2Value);
}
}
return null;
}
@Override
protected final SpecializationNode createPolymorphic() {
return PolymorphicNode_.create(root);
}
protected final BaseNode_ getNext() {
return (BaseNode_) this.next;
}
protected final Object executeArguments0_(Frame frameValue) {
Class arguments0Type_ = root.arguments0Type_;
try {
if (arguments0Type_ == int.class) {
return root.arguments0_.executeInteger((VirtualFrame) frameValue);
} else if (arguments0Type_ == null) {
CompilerDirectives.transferToInterpreterAndInvalidate();
Class _type = Object.class;
try {
Object _value = root.arguments0_.execute((VirtualFrame) frameValue);
if (_value instanceof Integer) {
_type = int.class;
} else {
_type = Object.class;
}
return _value;
} finally {
root.arguments0Type_ = _type;
}
} else {
return root.arguments0_.execute((VirtualFrame) frameValue);
}
} catch (UnexpectedResultException ex) {
root.arguments0Type_ = Object.class;
return ex.getResult();
}
}
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(FcntlNode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(FcntlNodeGen root) {
super(root, 2147483647);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value) {
return (int) uninitialized(frameValue, arguments0Value, arguments1Value, arguments2Value);
}
static BaseNode_ create(FcntlNodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(FcntlNode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(FcntlNodeGen 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 int executeInt(VirtualFrame frameValue) {
Object arguments0Value_ = executeArguments0_(frameValue);
Object arguments1Value_ = executeArguments1_(frameValue);
Object arguments2Value_ = executeArguments2_(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value) {
return getNext().executeInt_(frameValue, arguments0Value, arguments1Value, arguments2Value);
}
static BaseNode_ create(FcntlNodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "fcntl(int, int, Object)", value = FcntlNode.class)
private static final class Fcntl0Node_ extends BaseNode_ {
private final Class arguments0ImplicitType;
private final Class arguments1ImplicitType;
Fcntl0Node_(FcntlNodeGen root, Object arguments0Value, Object arguments1Value) {
super(root, 1);
this.arguments0ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments0Value);
this.arguments1ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments1Value);
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.arguments0ImplicitType == ((Fcntl0Node_) other).arguments0ImplicitType && this.arguments1ImplicitType == ((Fcntl0Node_) other).arguments1ImplicitType;
}
@Override
public Object execute(VirtualFrame frameValue) {
return executeInt(frameValue);
}
@Override
public int executeInt(VirtualFrame frameValue) {
int arguments0Value_;
try {
if (arguments0ImplicitType == int.class) {
arguments0Value_ = root.arguments0_.executeInteger(frameValue);
} else {
Object arguments0Value__ = executeArguments0_(frameValue);
arguments0Value_ = RubyTypesGen.expectImplicitInteger(arguments0Value__, arguments0ImplicitType);
}
} catch (UnexpectedResultException ex) {
Object arguments1Value = executeArguments1_(frameValue);
Object arguments2Value = executeArguments2_(frameValue);
return getNext().executeInt_(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().executeInt_(frameValue, arguments0Value_, ex.getResult(), arguments2Value);
}
Object arguments2Value_ = executeArguments2_(frameValue);
if ((root.isNil(arguments2Value_))) {
return root.fcntl(arguments0Value_, arguments1Value_, arguments2Value_);
}
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value) {
if (RubyTypesGen.isImplicitInteger(arguments0Value, arguments0ImplicitType) && RubyTypesGen.isImplicitInteger(arguments1Value, arguments1ImplicitType)) {
int arguments0Value_ = RubyTypesGen.asImplicitInteger(arguments0Value, arguments0ImplicitType);
int arguments1Value_ = RubyTypesGen.asImplicitInteger(arguments1Value, arguments1ImplicitType);
if ((root.isNil(arguments2Value))) {
return root.fcntl(arguments0Value_, arguments1Value_, arguments2Value);
}
}
return getNext().executeInt_(frameValue, arguments0Value, arguments1Value, arguments2Value);
}
static BaseNode_ create(FcntlNodeGen root, Object arguments0Value, Object arguments1Value) {
return new Fcntl0Node_(root, arguments0Value, arguments1Value);
}
}
@GeneratedBy(methodName = "fcntl(int, int, int)", value = FcntlNode.class)
private static final class Fcntl1Node_ extends BaseNode_ {
private final Class arguments0ImplicitType;
private final Class arguments1ImplicitType;
private final Class arguments2ImplicitType;
Fcntl1Node_(FcntlNodeGen root, Object arguments0Value, Object arguments1Value, Object arguments2Value) {
super(root, 2);
this.arguments0ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments0Value);
this.arguments1ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments1Value);
this.arguments2ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments2Value);
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.arguments0ImplicitType == ((Fcntl1Node_) other).arguments0ImplicitType && this.arguments1ImplicitType == ((Fcntl1Node_) other).arguments1ImplicitType && this.arguments2ImplicitType == ((Fcntl1Node_) other).arguments2ImplicitType;
}
@Override
public Object execute(VirtualFrame frameValue) {
return executeInt(frameValue);
}
@Override
public int executeInt(VirtualFrame frameValue) {
int arguments0Value_;
try {
if (arguments0ImplicitType == int.class) {
arguments0Value_ = root.arguments0_.executeInteger(frameValue);
} else {
Object arguments0Value__ = executeArguments0_(frameValue);
arguments0Value_ = RubyTypesGen.expectImplicitInteger(arguments0Value__, arguments0ImplicitType);
}
} catch (UnexpectedResultException ex) {
Object arguments1Value = executeArguments1_(frameValue);
Object arguments2Value = executeArguments2_(frameValue);
return getNext().executeInt_(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().executeInt_(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().executeInt_(frameValue, arguments0Value_, arguments1Value_, ex.getResult());
}
return root.fcntl(arguments0Value_, arguments1Value_, arguments2Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value) {
if (RubyTypesGen.isImplicitInteger(arguments0Value, arguments0ImplicitType) && RubyTypesGen.isImplicitInteger(arguments1Value, arguments1ImplicitType) && RubyTypesGen.isImplicitInteger(arguments2Value, arguments2ImplicitType)) {
int arguments0Value_ = RubyTypesGen.asImplicitInteger(arguments0Value, arguments0ImplicitType);
int arguments1Value_ = RubyTypesGen.asImplicitInteger(arguments1Value, arguments1ImplicitType);
int arguments2Value_ = RubyTypesGen.asImplicitInteger(arguments2Value, arguments2ImplicitType);
return root.fcntl(arguments0Value_, arguments1Value_, arguments2Value_);
}
return getNext().executeInt_(frameValue, arguments0Value, arguments1Value, arguments2Value);
}
static BaseNode_ create(FcntlNodeGen root, Object arguments0Value, Object arguments1Value, Object arguments2Value) {
return new Fcntl1Node_(root, arguments0Value, arguments1Value, arguments2Value);
}
}
}
}
@GeneratedBy(GetpgidNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class GetpgidNodeFactory implements NodeFactory {
private static GetpgidNodeFactory getpgidNodeFactoryInstance;
private GetpgidNodeFactory() {
}
@Override
public Class getNodeClass() {
return GetpgidNode.class;
}
@Override
public List getExecutionSignature() {
return Arrays.asList(RubyNode.class);
}
@Override
public List getNodeSignatures() {
return Arrays.asList(Arrays.asList(RubyNode[].class));
}
@Override
public GetpgidNode 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 (getpgidNodeFactoryInstance == null) {
getpgidNodeFactoryInstance = new GetpgidNodeFactory();
}
return getpgidNodeFactoryInstance;
}
public static GetpgidNode create(RubyNode[] arguments) {
return new GetpgidNodeGen(arguments);
}
@GeneratedBy(GetpgidNode.class)
public static final class GetpgidNodeGen extends GetpgidNode implements SpecializedNode {
@Child private RubyNode arguments0_;
@CompilationFinal private Class arguments0Type_;
@Child private BaseNode_ specialization_;
private GetpgidNodeGen(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(GetpgidNode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected GetpgidNodeGen root;
BaseNode_(GetpgidNodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (GetpgidNodeGen) 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_ = executeArguments0_(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 (RubyTypesGen.isImplicitInteger(arguments0Value)) {
return GetpgidNode_.create(root, arguments0Value);
}
return null;
}
@Override
protected final SpecializationNode createPolymorphic() {
return PolymorphicNode_.create(root);
}
protected final BaseNode_ getNext() {
return (BaseNode_) this.next;
}
protected final Object executeArguments0_(Frame frameValue) {
Class arguments0Type_ = root.arguments0Type_;
try {
if (arguments0Type_ == int.class) {
return root.arguments0_.executeInteger((VirtualFrame) frameValue);
} else if (arguments0Type_ == null) {
CompilerDirectives.transferToInterpreterAndInvalidate();
Class _type = Object.class;
try {
Object _value = root.arguments0_.execute((VirtualFrame) frameValue);
if (_value instanceof Integer) {
_type = int.class;
} else {
_type = Object.class;
}
return _value;
} finally {
root.arguments0Type_ = _type;
}
} else {
return root.arguments0_.execute((VirtualFrame) frameValue);
}
} catch (UnexpectedResultException ex) {
root.arguments0Type_ = Object.class;
return ex.getResult();
}
}
}
@GeneratedBy(GetpgidNode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(GetpgidNodeGen root) {
super(root, 2147483647);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value) {
return (int) uninitialized(frameValue, arguments0Value);
}
static BaseNode_ create(GetpgidNodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(GetpgidNode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(GetpgidNodeGen 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_ = executeArguments0_(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value) {
return getNext().executeInt_(frameValue, arguments0Value);
}
static BaseNode_ create(GetpgidNodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "getpgid(int)", value = GetpgidNode.class)
private static final class GetpgidNode_ extends BaseNode_ {
private final Class arguments0ImplicitType;
GetpgidNode_(GetpgidNodeGen root, Object arguments0Value) {
super(root, 1);
this.arguments0ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments0Value);
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.arguments0ImplicitType == ((GetpgidNode_) other).arguments0ImplicitType;
}
@Override
public Object execute(VirtualFrame frameValue) {
return executeInt(frameValue);
}
@Override
public int executeInt(VirtualFrame frameValue) {
int arguments0Value_;
try {
if (arguments0ImplicitType == int.class) {
arguments0Value_ = root.arguments0_.executeInteger(frameValue);
} else {
Object arguments0Value__ = executeArguments0_(frameValue);
arguments0Value_ = RubyTypesGen.expectImplicitInteger(arguments0Value__, arguments0ImplicitType);
}
} catch (UnexpectedResultException ex) {
return getNext().executeInt_(frameValue, ex.getResult());
}
return root.getpgid(arguments0Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value) {
if (RubyTypesGen.isImplicitInteger(arguments0Value, arguments0ImplicitType)) {
int arguments0Value_ = RubyTypesGen.asImplicitInteger(arguments0Value, arguments0ImplicitType);
return root.getpgid(arguments0Value_);
}
return getNext().executeInt_(frameValue, arguments0Value);
}
static BaseNode_ create(GetpgidNodeGen root, Object arguments0Value) {
return new GetpgidNode_(root, arguments0Value);
}
}
}
}
@GeneratedBy(GetpgrpNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class GetpgrpNodeFactory implements NodeFactory {
private static GetpgrpNodeFactory getpgrpNodeFactoryInstance;
private GetpgrpNodeFactory() {
}
@Override
public Class getNodeClass() {
return GetpgrpNode.class;
}
@Override
public List getExecutionSignature() {
return Arrays.asList();
}
@Override
public List getNodeSignatures() {
return Arrays.asList(Arrays.asList(RubyNode[].class));
}
@Override
public GetpgrpNode 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 (getpgrpNodeFactoryInstance == null) {
getpgrpNodeFactoryInstance = new GetpgrpNodeFactory();
}
return getpgrpNodeFactoryInstance;
}
public static GetpgrpNode create(RubyNode[] arguments) {
return new GetpgrpNodeGen(arguments);
}
@GeneratedBy(GetpgrpNode.class)
public static final class GetpgrpNodeGen extends GetpgrpNode {
@SuppressWarnings("unused")
private GetpgrpNodeGen(RubyNode[] arguments) {
}
@Override
public NodeCost getCost() {
return NodeCost.MONOMORPHIC;
}
@Override
public Object execute(VirtualFrame frameValue) {
return executeInteger(frameValue);
}
@Override
public void executeVoid(VirtualFrame frameValue) {
executeInteger(frameValue);
return;
}
@Override
public int executeInteger(VirtualFrame frameValue) {
return this.getpgrp();
}
}
}
@GeneratedBy(IsATTYNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class IsATTYNodeFactory implements NodeFactory {
private static IsATTYNodeFactory isATTYNodeFactoryInstance;
private IsATTYNodeFactory() {
}
@Override
public Class getNodeClass() {
return IsATTYNode.class;
}
@Override
public List getExecutionSignature() {
return Arrays.asList(RubyNode.class);
}
@Override
public List getNodeSignatures() {
return Arrays.asList(Arrays.asList(RubyNode[].class));
}
@Override
public IsATTYNode 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 (isATTYNodeFactoryInstance == null) {
isATTYNodeFactoryInstance = new IsATTYNodeFactory();
}
return isATTYNodeFactoryInstance;
}
public static IsATTYNode create(RubyNode[] arguments) {
return new IsATTYNodeGen(arguments);
}
@GeneratedBy(IsATTYNode.class)
public static final class IsATTYNodeGen extends IsATTYNode implements SpecializedNode {
@Child private RubyNode arguments0_;
@CompilationFinal private Class arguments0Type_;
@Child private BaseNode_ specialization_;
private IsATTYNodeGen(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(IsATTYNode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected IsATTYNodeGen root;
BaseNode_(IsATTYNodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (IsATTYNodeGen) 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_ = executeArguments0_(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 (RubyTypesGen.isImplicitInteger(arguments0Value)) {
return IsATTYNode_.create(root, arguments0Value);
}
return null;
}
@Override
protected final SpecializationNode createPolymorphic() {
return PolymorphicNode_.create(root);
}
protected final BaseNode_ getNext() {
return (BaseNode_) this.next;
}
protected final Object executeArguments0_(Frame frameValue) {
Class arguments0Type_ = root.arguments0Type_;
try {
if (arguments0Type_ == int.class) {
return root.arguments0_.executeInteger((VirtualFrame) frameValue);
} else if (arguments0Type_ == null) {
CompilerDirectives.transferToInterpreterAndInvalidate();
Class _type = Object.class;
try {
Object _value = root.arguments0_.execute((VirtualFrame) frameValue);
if (_value instanceof Integer) {
_type = int.class;
} else {
_type = Object.class;
}
return _value;
} finally {
root.arguments0Type_ = _type;
}
} else {
return root.arguments0_.execute((VirtualFrame) frameValue);
}
} catch (UnexpectedResultException ex) {
root.arguments0Type_ = Object.class;
return ex.getResult();
}
}
}
@GeneratedBy(IsATTYNode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(IsATTYNodeGen root) {
super(root, 2147483647);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value) {
return (int) uninitialized(frameValue, arguments0Value);
}
static BaseNode_ create(IsATTYNodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(IsATTYNode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(IsATTYNodeGen 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_ = executeArguments0_(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value) {
return getNext().executeInt_(frameValue, arguments0Value);
}
static BaseNode_ create(IsATTYNodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "isATTY(int)", value = IsATTYNode.class)
private static final class IsATTYNode_ extends BaseNode_ {
private final Class arguments0ImplicitType;
IsATTYNode_(IsATTYNodeGen root, Object arguments0Value) {
super(root, 1);
this.arguments0ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments0Value);
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.arguments0ImplicitType == ((IsATTYNode_) other).arguments0ImplicitType;
}
@Override
public Object execute(VirtualFrame frameValue) {
return executeInt(frameValue);
}
@Override
public int executeInt(VirtualFrame frameValue) {
int arguments0Value_;
try {
if (arguments0ImplicitType == int.class) {
arguments0Value_ = root.arguments0_.executeInteger(frameValue);
} else {
Object arguments0Value__ = executeArguments0_(frameValue);
arguments0Value_ = RubyTypesGen.expectImplicitInteger(arguments0Value__, arguments0ImplicitType);
}
} catch (UnexpectedResultException ex) {
return getNext().executeInt_(frameValue, ex.getResult());
}
return root.isATTY(arguments0Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value) {
if (RubyTypesGen.isImplicitInteger(arguments0Value, arguments0ImplicitType)) {
int arguments0Value_ = RubyTypesGen.asImplicitInteger(arguments0Value, arguments0ImplicitType);
return root.isATTY(arguments0Value_);
}
return getNext().executeInt_(frameValue, arguments0Value);
}
static BaseNode_ create(IsATTYNodeGen root, Object arguments0Value) {
return new IsATTYNode_(root, arguments0Value);
}
}
}
}
@GeneratedBy(GetppidNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class GetppidNodeFactory implements NodeFactory {
private static GetppidNodeFactory getppidNodeFactoryInstance;
private GetppidNodeFactory() {
}
@Override
public Class getNodeClass() {
return GetppidNode.class;
}
@Override
public List getExecutionSignature() {
return Arrays.asList();
}
@Override
public List getNodeSignatures() {
return Arrays.asList(Arrays.asList(RubyNode[].class));
}
@Override
public GetppidNode 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 (getppidNodeFactoryInstance == null) {
getppidNodeFactoryInstance = new GetppidNodeFactory();
}
return getppidNodeFactoryInstance;
}
public static GetppidNode create(RubyNode[] arguments) {
return new GetppidNodeGen(arguments);
}
@GeneratedBy(GetppidNode.class)
public static final class GetppidNodeGen extends GetppidNode {
@SuppressWarnings("unused")
private GetppidNodeGen(RubyNode[] arguments) {
}
@Override
public NodeCost getCost() {
return NodeCost.MONOMORPHIC;
}
@Override
public Object execute(VirtualFrame frameValue) {
return executeInteger(frameValue);
}
@Override
public void executeVoid(VirtualFrame frameValue) {
executeInteger(frameValue);
return;
}
@Override
public int executeInteger(VirtualFrame frameValue) {
return this.getppid();
}
}
}
@GeneratedBy(SendNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class SendNodeFactory implements NodeFactory {
private static SendNodeFactory sendNodeFactoryInstance;
private SendNodeFactory() {
}
@Override
public Class getNodeClass() {
return SendNode.class;
}
@Override
public List getExecutionSignature() {
return Arrays.asList(RubyNode.class, RubyNode.class, RubyNode.class, RubyNode.class);
}
@Override
public List getNodeSignatures() {
return Arrays.asList(Arrays.asList(RubyNode[].class));
}
@Override
public SendNode 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 (sendNodeFactoryInstance == null) {
sendNodeFactoryInstance = new SendNodeFactory();
}
return sendNodeFactoryInstance;
}
public static SendNode create(RubyNode[] arguments) {
return new SendNodeGen(arguments);
}
@GeneratedBy(SendNode.class)
public static final class SendNodeGen extends SendNode implements SpecializedNode {
@Child private RubyNode arguments0_;
@Child private RubyNode arguments1_;
@Child private RubyNode arguments2_;
@Child private RubyNode arguments3_;
@CompilationFinal private Class arguments0Type_;
@CompilationFinal private Class arguments2Type_;
@CompilationFinal private Class arguments3Type_;
@Child private BaseNode_ specialization_;
private SendNodeGen(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.arguments3_ = arguments != null && 3 < arguments.length ? arguments[3] : 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(SendNode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected SendNodeGen root;
BaseNode_(SendNodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (SendNodeGen) root;
}
@Override
protected final Node[] getSuppliedChildren() {
return new Node[] {root.arguments0_, root.arguments1_, root.arguments2_, root.arguments3_};
}
@Override
public final Object acceptAndExecute(Frame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value, Object arguments3Value) {
return this.executeInt_((VirtualFrame) frameValue, arguments0Value, arguments1Value, arguments2Value, arguments3Value);
}
public abstract int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value, Object arguments3Value);
public Object execute(VirtualFrame frameValue) {
Object arguments0Value_ = executeArguments0_(frameValue);
Object arguments1Value_ = root.arguments1_.execute(frameValue);
Object arguments2Value_ = executeArguments2_(frameValue);
Object arguments3Value_ = executeArguments3_(frameValue);
return executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_, arguments3Value_);
}
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, Object arguments1Value, Object arguments2Value, Object arguments3Value) {
if (RubyTypesGen.isImplicitInteger(arguments0Value) && arguments1Value instanceof DynamicObject && RubyTypesGen.isImplicitInteger(arguments2Value) && RubyTypesGen.isImplicitInteger(arguments3Value)) {
DynamicObject arguments1Value_ = (DynamicObject) arguments1Value;
if ((RubyGuards.isRubyPointer(arguments1Value_))) {
return SendNode_.create(root, arguments0Value, arguments2Value, arguments3Value);
}
}
return null;
}
@Override
protected final SpecializationNode createPolymorphic() {
return PolymorphicNode_.create(root);
}
protected final BaseNode_ getNext() {
return (BaseNode_) this.next;
}
protected final Object executeArguments0_(Frame frameValue) {
Class arguments0Type_ = root.arguments0Type_;
try {
if (arguments0Type_ == int.class) {
return root.arguments0_.executeInteger((VirtualFrame) frameValue);
} else if (arguments0Type_ == null) {
CompilerDirectives.transferToInterpreterAndInvalidate();
Class _type = Object.class;
try {
Object _value = root.arguments0_.execute((VirtualFrame) frameValue);
if (_value instanceof Integer) {
_type = int.class;
} else {
_type = Object.class;
}
return _value;
} finally {
root.arguments0Type_ = _type;
}
} else {
return root.arguments0_.execute((VirtualFrame) frameValue);
}
} catch (UnexpectedResultException ex) {
root.arguments0Type_ = 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();
}
}
protected final Object executeArguments3_(Frame frameValue) {
Class arguments3Type_ = root.arguments3Type_;
try {
if (arguments3Type_ == int.class) {
return root.arguments3_.executeInteger((VirtualFrame) frameValue);
} else if (arguments3Type_ == null) {
CompilerDirectives.transferToInterpreterAndInvalidate();
Class _type = Object.class;
try {
Object _value = root.arguments3_.execute((VirtualFrame) frameValue);
if (_value instanceof Integer) {
_type = int.class;
} else {
_type = Object.class;
}
return _value;
} finally {
root.arguments3Type_ = _type;
}
} else {
return root.arguments3_.execute((VirtualFrame) frameValue);
}
} catch (UnexpectedResultException ex) {
root.arguments3Type_ = Object.class;
return ex.getResult();
}
}
}
@GeneratedBy(SendNode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(SendNodeGen root) {
super(root, 2147483647);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value, Object arguments3Value) {
return (int) uninitialized(frameValue, arguments0Value, arguments1Value, arguments2Value, arguments3Value);
}
static BaseNode_ create(SendNodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(SendNode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(SendNodeGen root) {
super(root, 0);
}
@Override
public SpecializationNode merge(SpecializationNode newNode, Frame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value, Object arguments3Value) {
return polymorphicMerge(newNode, super.merge(newNode, frameValue, arguments0Value, arguments1Value, arguments2Value, arguments3Value));
}
@Override
public int executeInt(VirtualFrame frameValue) {
Object arguments0Value_ = executeArguments0_(frameValue);
Object arguments1Value_ = root.arguments1_.execute(frameValue);
Object arguments2Value_ = executeArguments2_(frameValue);
Object arguments3Value_ = executeArguments3_(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_, arguments3Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value, Object arguments3Value) {
return getNext().executeInt_(frameValue, arguments0Value, arguments1Value, arguments2Value, arguments3Value);
}
static BaseNode_ create(SendNodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "send(int, DynamicObject, int, int)", value = SendNode.class)
private static final class SendNode_ extends BaseNode_ {
private final Class arguments0ImplicitType;
private final Class arguments2ImplicitType;
private final Class arguments3ImplicitType;
SendNode_(SendNodeGen root, Object arguments0Value, Object arguments2Value, Object arguments3Value) {
super(root, 1);
this.arguments0ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments0Value);
this.arguments2ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments2Value);
this.arguments3ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments3Value);
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.arguments0ImplicitType == ((SendNode_) other).arguments0ImplicitType && this.arguments2ImplicitType == ((SendNode_) other).arguments2ImplicitType && this.arguments3ImplicitType == ((SendNode_) other).arguments3ImplicitType;
}
@Override
public Object execute(VirtualFrame frameValue) {
return executeInt(frameValue);
}
@Override
public int executeInt(VirtualFrame frameValue) {
int arguments0Value_;
try {
if (arguments0ImplicitType == int.class) {
arguments0Value_ = root.arguments0_.executeInteger(frameValue);
} else {
Object arguments0Value__ = executeArguments0_(frameValue);
arguments0Value_ = RubyTypesGen.expectImplicitInteger(arguments0Value__, arguments0ImplicitType);
}
} catch (UnexpectedResultException ex) {
Object arguments1Value = root.arguments1_.execute(frameValue);
Object arguments2Value = executeArguments2_(frameValue);
Object arguments3Value = executeArguments3_(frameValue);
return getNext().executeInt_(frameValue, ex.getResult(), arguments1Value, arguments2Value, arguments3Value);
}
DynamicObject arguments1Value_;
try {
arguments1Value_ = root.arguments1_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object arguments2Value = executeArguments2_(frameValue);
Object arguments3Value = executeArguments3_(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_, ex.getResult(), arguments2Value, arguments3Value);
}
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) {
Object arguments3Value = executeArguments3_(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_, ex.getResult(), arguments3Value);
}
int arguments3Value_;
try {
if (arguments3ImplicitType == int.class) {
arguments3Value_ = root.arguments3_.executeInteger(frameValue);
} else {
Object arguments3Value__ = executeArguments3_(frameValue);
arguments3Value_ = RubyTypesGen.expectImplicitInteger(arguments3Value__, arguments3ImplicitType);
}
} catch (UnexpectedResultException ex) {
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_, ex.getResult());
}
if ((RubyGuards.isRubyPointer(arguments1Value_))) {
return root.send(arguments0Value_, arguments1Value_, arguments2Value_, arguments3Value_);
}
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_, arguments3Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value, Object arguments3Value) {
if (RubyTypesGen.isImplicitInteger(arguments0Value, arguments0ImplicitType) && arguments1Value instanceof DynamicObject && RubyTypesGen.isImplicitInteger(arguments2Value, arguments2ImplicitType) && RubyTypesGen.isImplicitInteger(arguments3Value, arguments3ImplicitType)) {
int arguments0Value_ = RubyTypesGen.asImplicitInteger(arguments0Value, arguments0ImplicitType);
DynamicObject arguments1Value_ = (DynamicObject) arguments1Value;
int arguments2Value_ = RubyTypesGen.asImplicitInteger(arguments2Value, arguments2ImplicitType);
int arguments3Value_ = RubyTypesGen.asImplicitInteger(arguments3Value, arguments3ImplicitType);
if ((RubyGuards.isRubyPointer(arguments1Value_))) {
return root.send(arguments0Value_, arguments1Value_, arguments2Value_, arguments3Value_);
}
}
return getNext().executeInt_(frameValue, arguments0Value, arguments1Value, arguments2Value, arguments3Value);
}
static BaseNode_ create(SendNodeGen root, Object arguments0Value, Object arguments2Value, Object arguments3Value) {
return new SendNode_(root, arguments0Value, arguments2Value, arguments3Value);
}
}
}
}
@GeneratedBy(SymlinkNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class SymlinkNodeFactory implements NodeFactory {
private static SymlinkNodeFactory symlinkNodeFactoryInstance;
private SymlinkNodeFactory() {
}
@Override
public Class getNodeClass() {
return SymlinkNode.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 SymlinkNode 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 (symlinkNodeFactoryInstance == null) {
symlinkNodeFactoryInstance = new SymlinkNodeFactory();
}
return symlinkNodeFactoryInstance;
}
public static SymlinkNode create(RubyNode[] arguments) {
return new SymlinkNodeGen(arguments);
}
@GeneratedBy(SymlinkNode.class)
public static final class SymlinkNodeGen extends SymlinkNode {
@Child private RubyNode arguments0_;
@Child private RubyNode arguments1_;
@CompilationFinal private boolean seenUnsupported0;
private SymlinkNodeGen(RubyNode[] arguments) {
this.arguments0_ = arguments != null && 0 < arguments.length ? arguments[0] : null;
this.arguments1_ = arguments != null && 1 < arguments.length ? arguments[1] : null;
}
@Override
public NodeCost getCost() {
return NodeCost.MONOMORPHIC;
}
@Override
public Object execute(VirtualFrame frameValue) {
return executeInteger(frameValue);
}
@Override
public void executeVoid(VirtualFrame frameValue) {
executeInteger(frameValue);
return;
}
@Override
public int executeInteger(VirtualFrame frameValue) {
DynamicObject arguments0Value_;
try {
arguments0Value_ = arguments0_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object arguments1Value = arguments1_.execute(frameValue);
throw unsupported(ex.getResult(), arguments1Value);
}
DynamicObject arguments1Value_;
try {
arguments1Value_ = arguments1_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
throw unsupported(arguments0Value_, ex.getResult());
}
if ((RubyGuards.isRubyString(arguments0Value_)) && (RubyGuards.isRubyString(arguments1Value_))) {
return this.symlink(arguments0Value_, arguments1Value_);
}
throw unsupported(arguments0Value_, arguments1Value_);
}
private UnsupportedSpecializationException unsupported(Object arguments0Value, Object arguments1Value) {
if (!seenUnsupported0) {
CompilerDirectives.transferToInterpreterAndInvalidate();
seenUnsupported0 = true;
}
return new UnsupportedSpecializationException(this, new Node[] {arguments0_, arguments1_}, arguments0Value, arguments1Value);
}
}
}
@GeneratedBy(GetAddrInfoNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class GetAddrInfoNodeFactory implements NodeFactory {
private static GetAddrInfoNodeFactory getAddrInfoNodeFactoryInstance;
private GetAddrInfoNodeFactory() {
}
@Override
public Class getNodeClass() {
return GetAddrInfoNode.class;
}
@Override
public List getExecutionSignature() {
return Arrays.asList(RubyNode.class, RubyNode.class, RubyNode.class, RubyNode.class);
}
@Override
public List getNodeSignatures() {
return Arrays.asList(Arrays.asList(RubyNode[].class));
}
@Override
public GetAddrInfoNode 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 (getAddrInfoNodeFactoryInstance == null) {
getAddrInfoNodeFactoryInstance = new GetAddrInfoNodeFactory();
}
return getAddrInfoNodeFactoryInstance;
}
public static GetAddrInfoNode create(RubyNode[] arguments) {
return new GetAddrInfoNodeGen(arguments);
}
@GeneratedBy(GetAddrInfoNode.class)
public static final class GetAddrInfoNodeGen extends GetAddrInfoNode implements SpecializedNode {
@Child private RubyNode arguments0_;
@Child private RubyNode arguments1_;
@Child private RubyNode arguments2_;
@Child private RubyNode arguments3_;
@Child private BaseNode_ specialization_;
private GetAddrInfoNodeGen(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.arguments3_ = arguments != null && 3 < arguments.length ? arguments[3] : 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(GetAddrInfoNode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected GetAddrInfoNodeGen root;
BaseNode_(GetAddrInfoNodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (GetAddrInfoNodeGen) root;
}
@Override
protected final Node[] getSuppliedChildren() {
return new Node[] {root.arguments0_, root.arguments1_, root.arguments2_, root.arguments3_};
}
@Override
public final Object acceptAndExecute(Frame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value, Object arguments3Value) {
return this.executeInt_((VirtualFrame) frameValue, arguments0Value, arguments1Value, arguments2Value, arguments3Value);
}
public abstract int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value, Object arguments3Value);
public Object execute(VirtualFrame frameValue) {
Object arguments0Value_ = root.arguments0_.execute(frameValue);
Object arguments1Value_ = root.arguments1_.execute(frameValue);
Object arguments2Value_ = root.arguments2_.execute(frameValue);
Object arguments3Value_ = root.arguments3_.execute(frameValue);
return executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_, arguments3Value_);
}
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, Object arguments1Value, Object arguments2Value, Object arguments3Value) {
if (arguments0Value instanceof DynamicObject && arguments1Value instanceof DynamicObject && arguments2Value instanceof DynamicObject && arguments3Value instanceof DynamicObject) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
DynamicObject arguments1Value_ = (DynamicObject) arguments1Value;
DynamicObject arguments2Value_ = (DynamicObject) arguments2Value;
DynamicObject arguments3Value_ = (DynamicObject) arguments3Value;
if ((root.isNil(arguments0Value_)) && (RubyGuards.isRubyString(arguments1Value_))) {
return GetaddrinfoNilNode_.create(root);
}
if ((RubyGuards.isRubyString(arguments0Value_)) && (RubyGuards.isRubyString(arguments1Value_)) && (RubyGuards.isRubyPointer(arguments2Value_)) && (RubyGuards.isRubyPointer(arguments3Value_))) {
return GetaddrinfoStringNode_.create(root);
}
if ((RubyGuards.isRubyString(arguments0Value_)) && (root.isNil(arguments1Value_)) && (RubyGuards.isRubyPointer(arguments2Value_)) && (RubyGuards.isRubyPointer(arguments3Value_))) {
return GetaddrinfoNode_.create(root);
}
}
return null;
}
@Override
protected final SpecializationNode createPolymorphic() {
return PolymorphicNode_.create(root);
}
protected final BaseNode_ getNext() {
return (BaseNode_) this.next;
}
}
@GeneratedBy(GetAddrInfoNode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(GetAddrInfoNodeGen root) {
super(root, 2147483647);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value, Object arguments3Value) {
return (int) uninitialized(frameValue, arguments0Value, arguments1Value, arguments2Value, arguments3Value);
}
static BaseNode_ create(GetAddrInfoNodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(GetAddrInfoNode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(GetAddrInfoNodeGen root) {
super(root, 0);
}
@Override
public SpecializationNode merge(SpecializationNode newNode, Frame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value, Object arguments3Value) {
return polymorphicMerge(newNode, super.merge(newNode, frameValue, arguments0Value, arguments1Value, arguments2Value, arguments3Value));
}
@Override
public int executeInt(VirtualFrame frameValue) {
Object arguments0Value_ = root.arguments0_.execute(frameValue);
Object arguments1Value_ = root.arguments1_.execute(frameValue);
Object arguments2Value_ = root.arguments2_.execute(frameValue);
Object arguments3Value_ = root.arguments3_.execute(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_, arguments3Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value, Object arguments3Value) {
return getNext().executeInt_(frameValue, arguments0Value, arguments1Value, arguments2Value, arguments3Value);
}
static BaseNode_ create(GetAddrInfoNodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "getaddrinfoNil(DynamicObject, DynamicObject, DynamicObject, DynamicObject)", value = GetAddrInfoNode.class)
private static final class GetaddrinfoNilNode_ extends BaseNode_ {
GetaddrinfoNilNode_(GetAddrInfoNodeGen root) {
super(root, 1);
}
@Override
public int executeInt(VirtualFrame frameValue) {
DynamicObject arguments0Value_;
try {
arguments0Value_ = root.arguments0_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object arguments1Value = root.arguments1_.execute(frameValue);
Object arguments2Value = root.arguments2_.execute(frameValue);
Object arguments3Value = root.arguments3_.execute(frameValue);
return getNext().executeInt_(frameValue, ex.getResult(), arguments1Value, arguments2Value, arguments3Value);
}
DynamicObject arguments1Value_;
try {
arguments1Value_ = root.arguments1_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object arguments2Value = root.arguments2_.execute(frameValue);
Object arguments3Value = root.arguments3_.execute(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_, ex.getResult(), arguments2Value, arguments3Value);
}
DynamicObject arguments2Value_;
try {
arguments2Value_ = root.arguments2_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object arguments3Value = root.arguments3_.execute(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_, ex.getResult(), arguments3Value);
}
DynamicObject arguments3Value_;
try {
arguments3Value_ = root.arguments3_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_, ex.getResult());
}
if ((root.isNil(arguments0Value_)) && (RubyGuards.isRubyString(arguments1Value_))) {
return root.getaddrinfoNil(arguments0Value_, arguments1Value_, arguments2Value_, arguments3Value_);
}
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_, arguments3Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value, Object arguments3Value) {
if (arguments0Value instanceof DynamicObject && arguments1Value instanceof DynamicObject && arguments2Value instanceof DynamicObject && arguments3Value instanceof DynamicObject) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
DynamicObject arguments1Value_ = (DynamicObject) arguments1Value;
DynamicObject arguments2Value_ = (DynamicObject) arguments2Value;
DynamicObject arguments3Value_ = (DynamicObject) arguments3Value;
if ((root.isNil(arguments0Value_)) && (RubyGuards.isRubyString(arguments1Value_))) {
return root.getaddrinfoNil(arguments0Value_, arguments1Value_, arguments2Value_, arguments3Value_);
}
}
return getNext().executeInt_(frameValue, arguments0Value, arguments1Value, arguments2Value, arguments3Value);
}
static BaseNode_ create(GetAddrInfoNodeGen root) {
return new GetaddrinfoNilNode_(root);
}
}
@GeneratedBy(methodName = "getaddrinfoString(DynamicObject, DynamicObject, DynamicObject, DynamicObject)", value = GetAddrInfoNode.class)
private static final class GetaddrinfoStringNode_ extends BaseNode_ {
GetaddrinfoStringNode_(GetAddrInfoNodeGen root) {
super(root, 2);
}
@Override
public int executeInt(VirtualFrame frameValue) {
DynamicObject arguments0Value_;
try {
arguments0Value_ = root.arguments0_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object arguments1Value = root.arguments1_.execute(frameValue);
Object arguments2Value = root.arguments2_.execute(frameValue);
Object arguments3Value = root.arguments3_.execute(frameValue);
return getNext().executeInt_(frameValue, ex.getResult(), arguments1Value, arguments2Value, arguments3Value);
}
DynamicObject arguments1Value_;
try {
arguments1Value_ = root.arguments1_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object arguments2Value = root.arguments2_.execute(frameValue);
Object arguments3Value = root.arguments3_.execute(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_, ex.getResult(), arguments2Value, arguments3Value);
}
DynamicObject arguments2Value_;
try {
arguments2Value_ = root.arguments2_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object arguments3Value = root.arguments3_.execute(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_, ex.getResult(), arguments3Value);
}
DynamicObject arguments3Value_;
try {
arguments3Value_ = root.arguments3_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_, ex.getResult());
}
if ((RubyGuards.isRubyString(arguments0Value_)) && (RubyGuards.isRubyString(arguments1Value_)) && (RubyGuards.isRubyPointer(arguments2Value_)) && (RubyGuards.isRubyPointer(arguments3Value_))) {
return root.getaddrinfoString(arguments0Value_, arguments1Value_, arguments2Value_, arguments3Value_);
}
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_, arguments3Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value, Object arguments3Value) {
if (arguments0Value instanceof DynamicObject && arguments1Value instanceof DynamicObject && arguments2Value instanceof DynamicObject && arguments3Value instanceof DynamicObject) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
DynamicObject arguments1Value_ = (DynamicObject) arguments1Value;
DynamicObject arguments2Value_ = (DynamicObject) arguments2Value;
DynamicObject arguments3Value_ = (DynamicObject) arguments3Value;
if ((RubyGuards.isRubyString(arguments0Value_)) && (RubyGuards.isRubyString(arguments1Value_)) && (RubyGuards.isRubyPointer(arguments2Value_)) && (RubyGuards.isRubyPointer(arguments3Value_))) {
return root.getaddrinfoString(arguments0Value_, arguments1Value_, arguments2Value_, arguments3Value_);
}
}
return getNext().executeInt_(frameValue, arguments0Value, arguments1Value, arguments2Value, arguments3Value);
}
static BaseNode_ create(GetAddrInfoNodeGen root) {
return new GetaddrinfoStringNode_(root);
}
}
@GeneratedBy(methodName = "getaddrinfo(DynamicObject, DynamicObject, DynamicObject, DynamicObject)", value = GetAddrInfoNode.class)
private static final class GetaddrinfoNode_ extends BaseNode_ {
GetaddrinfoNode_(GetAddrInfoNodeGen root) {
super(root, 3);
}
@Override
public int executeInt(VirtualFrame frameValue) {
DynamicObject arguments0Value_;
try {
arguments0Value_ = root.arguments0_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object arguments1Value = root.arguments1_.execute(frameValue);
Object arguments2Value = root.arguments2_.execute(frameValue);
Object arguments3Value = root.arguments3_.execute(frameValue);
return getNext().executeInt_(frameValue, ex.getResult(), arguments1Value, arguments2Value, arguments3Value);
}
DynamicObject arguments1Value_;
try {
arguments1Value_ = root.arguments1_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object arguments2Value = root.arguments2_.execute(frameValue);
Object arguments3Value = root.arguments3_.execute(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_, ex.getResult(), arguments2Value, arguments3Value);
}
DynamicObject arguments2Value_;
try {
arguments2Value_ = root.arguments2_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object arguments3Value = root.arguments3_.execute(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_, ex.getResult(), arguments3Value);
}
DynamicObject arguments3Value_;
try {
arguments3Value_ = root.arguments3_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_, ex.getResult());
}
if ((RubyGuards.isRubyString(arguments0Value_)) && (root.isNil(arguments1Value_)) && (RubyGuards.isRubyPointer(arguments2Value_)) && (RubyGuards.isRubyPointer(arguments3Value_))) {
return root.getaddrinfo(arguments0Value_, arguments1Value_, arguments2Value_, arguments3Value_);
}
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_, arguments3Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value, Object arguments3Value) {
if (arguments0Value instanceof DynamicObject && arguments1Value instanceof DynamicObject && arguments2Value instanceof DynamicObject && arguments3Value instanceof DynamicObject) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
DynamicObject arguments1Value_ = (DynamicObject) arguments1Value;
DynamicObject arguments2Value_ = (DynamicObject) arguments2Value;
DynamicObject arguments3Value_ = (DynamicObject) arguments3Value;
if ((RubyGuards.isRubyString(arguments0Value_)) && (root.isNil(arguments1Value_)) && (RubyGuards.isRubyPointer(arguments2Value_)) && (RubyGuards.isRubyPointer(arguments3Value_))) {
return root.getaddrinfo(arguments0Value_, arguments1Value_, arguments2Value_, arguments3Value_);
}
}
return getNext().executeInt_(frameValue, arguments0Value, arguments1Value, arguments2Value, arguments3Value);
}
static BaseNode_ create(GetAddrInfoNodeGen root) {
return new GetaddrinfoNode_(root);
}
}
}
}
@GeneratedBy(ConnectNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class ConnectNodeFactory implements NodeFactory {
private static ConnectNodeFactory connectNodeFactoryInstance;
private ConnectNodeFactory() {
}
@Override
public Class getNodeClass() {
return ConnectNode.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 ConnectNode 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 (connectNodeFactoryInstance == null) {
connectNodeFactoryInstance = new ConnectNodeFactory();
}
return connectNodeFactoryInstance;
}
public static ConnectNode create(RubyNode[] arguments) {
return new ConnectNodeGen(arguments);
}
@GeneratedBy(ConnectNode.class)
public static final class ConnectNodeGen extends ConnectNode implements SpecializedNode {
@Child private RubyNode arguments0_;
@Child private RubyNode arguments1_;
@Child private RubyNode arguments2_;
@CompilationFinal private Class arguments0Type_;
@CompilationFinal private Class arguments2Type_;
@Child private BaseNode_ specialization_;
private ConnectNodeGen(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 int executeInteger(VirtualFrame frameValue) {
return specialization_.executeInt(frameValue);
}
@Override
public SpecializationNode getSpecializationNode() {
return specialization_;
}
@Override
public Node deepCopy() {
return SpecializationNode.updateRoot(super.deepCopy());
}
@GeneratedBy(ConnectNode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected ConnectNodeGen root;
BaseNode_(ConnectNodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (ConnectNodeGen) 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.executeInt_((VirtualFrame) frameValue, arguments0Value, arguments1Value, arguments2Value);
}
public abstract int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value);
public Object execute(VirtualFrame frameValue) {
Object arguments0Value_ = executeArguments0_(frameValue);
Object arguments1Value_ = root.arguments1_.execute(frameValue);
Object arguments2Value_ = executeArguments2_(frameValue);
return executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_);
}
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, Object arguments1Value, Object arguments2Value) {
if (RubyTypesGen.isImplicitInteger(arguments0Value) && arguments1Value instanceof DynamicObject && RubyTypesGen.isImplicitInteger(arguments2Value)) {
DynamicObject arguments1Value_ = (DynamicObject) arguments1Value;
if ((RubyGuards.isRubyPointer(arguments1Value_))) {
return ConnectNode_.create(root, arguments0Value, arguments2Value);
}
}
return null;
}
@Override
protected final SpecializationNode createPolymorphic() {
return PolymorphicNode_.create(root);
}
protected final BaseNode_ getNext() {
return (BaseNode_) this.next;
}
protected final Object executeArguments0_(Frame frameValue) {
Class arguments0Type_ = root.arguments0Type_;
try {
if (arguments0Type_ == int.class) {
return root.arguments0_.executeInteger((VirtualFrame) frameValue);
} else if (arguments0Type_ == null) {
CompilerDirectives.transferToInterpreterAndInvalidate();
Class _type = Object.class;
try {
Object _value = root.arguments0_.execute((VirtualFrame) frameValue);
if (_value instanceof Integer) {
_type = int.class;
} else {
_type = Object.class;
}
return _value;
} finally {
root.arguments0Type_ = _type;
}
} else {
return root.arguments0_.execute((VirtualFrame) frameValue);
}
} catch (UnexpectedResultException ex) {
root.arguments0Type_ = 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(ConnectNode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(ConnectNodeGen root) {
super(root, 2147483647);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value) {
return (int) uninitialized(frameValue, arguments0Value, arguments1Value, arguments2Value);
}
static BaseNode_ create(ConnectNodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(ConnectNode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(ConnectNodeGen 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 int executeInt(VirtualFrame frameValue) {
Object arguments0Value_ = executeArguments0_(frameValue);
Object arguments1Value_ = root.arguments1_.execute(frameValue);
Object arguments2Value_ = executeArguments2_(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value) {
return getNext().executeInt_(frameValue, arguments0Value, arguments1Value, arguments2Value);
}
static BaseNode_ create(ConnectNodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "connect(int, DynamicObject, int)", value = ConnectNode.class)
private static final class ConnectNode_ extends BaseNode_ {
private final Class arguments0ImplicitType;
private final Class arguments2ImplicitType;
ConnectNode_(ConnectNodeGen root, Object arguments0Value, Object arguments2Value) {
super(root, 1);
this.arguments0ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments0Value);
this.arguments2ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments2Value);
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.arguments0ImplicitType == ((ConnectNode_) other).arguments0ImplicitType && this.arguments2ImplicitType == ((ConnectNode_) other).arguments2ImplicitType;
}
@Override
public Object execute(VirtualFrame frameValue) {
return executeInt(frameValue);
}
@Override
public int executeInt(VirtualFrame frameValue) {
int arguments0Value_;
try {
if (arguments0ImplicitType == int.class) {
arguments0Value_ = root.arguments0_.executeInteger(frameValue);
} else {
Object arguments0Value__ = executeArguments0_(frameValue);
arguments0Value_ = RubyTypesGen.expectImplicitInteger(arguments0Value__, arguments0ImplicitType);
}
} catch (UnexpectedResultException ex) {
Object arguments1Value = root.arguments1_.execute(frameValue);
Object arguments2Value = executeArguments2_(frameValue);
return getNext().executeInt_(frameValue, ex.getResult(), arguments1Value, arguments2Value);
}
DynamicObject arguments1Value_;
try {
arguments1Value_ = root.arguments1_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object arguments2Value = executeArguments2_(frameValue);
return getNext().executeInt_(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().executeInt_(frameValue, arguments0Value_, arguments1Value_, ex.getResult());
}
if ((RubyGuards.isRubyPointer(arguments1Value_))) {
return root.connect(arguments0Value_, arguments1Value_, arguments2Value_);
}
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value) {
if (RubyTypesGen.isImplicitInteger(arguments0Value, arguments0ImplicitType) && arguments1Value instanceof DynamicObject && RubyTypesGen.isImplicitInteger(arguments2Value, arguments2ImplicitType)) {
int arguments0Value_ = RubyTypesGen.asImplicitInteger(arguments0Value, arguments0ImplicitType);
DynamicObject arguments1Value_ = (DynamicObject) arguments1Value;
int arguments2Value_ = RubyTypesGen.asImplicitInteger(arguments2Value, arguments2ImplicitType);
if ((RubyGuards.isRubyPointer(arguments1Value_))) {
return root.connect(arguments0Value_, arguments1Value_, arguments2Value_);
}
}
return getNext().executeInt_(frameValue, arguments0Value, arguments1Value, arguments2Value);
}
static BaseNode_ create(ConnectNodeGen root, Object arguments0Value, Object arguments2Value) {
return new ConnectNode_(root, arguments0Value, arguments2Value);
}
}
}
}
@GeneratedBy(FreeAddrInfoNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class FreeAddrInfoNodeFactory implements NodeFactory {
private static FreeAddrInfoNodeFactory freeAddrInfoNodeFactoryInstance;
private FreeAddrInfoNodeFactory() {
}
@Override
public Class getNodeClass() {
return FreeAddrInfoNode.class;
}
@Override
public List getExecutionSignature() {
return Arrays.asList(RubyNode.class);
}
@Override
public List getNodeSignatures() {
return Arrays.asList(Arrays.asList(RubyNode[].class));
}
@Override
public FreeAddrInfoNode 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 (freeAddrInfoNodeFactoryInstance == null) {
freeAddrInfoNodeFactoryInstance = new FreeAddrInfoNodeFactory();
}
return freeAddrInfoNodeFactoryInstance;
}
public static FreeAddrInfoNode create(RubyNode[] arguments) {
return new FreeAddrInfoNodeGen(arguments);
}
@GeneratedBy(FreeAddrInfoNode.class)
public static final class FreeAddrInfoNodeGen extends FreeAddrInfoNode {
@Child private RubyNode arguments0_;
@CompilationFinal private boolean seenUnsupported0;
private FreeAddrInfoNodeGen(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());
}
if ((RubyGuards.isRubyPointer(arguments0Value_))) {
return this.freeaddrinfo(arguments0Value_);
}
throw unsupported(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);
}
}
}
@GeneratedBy(GetNameInfoNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class GetNameInfoNodeFactory implements NodeFactory {
private static GetNameInfoNodeFactory getNameInfoNodeFactoryInstance;
private GetNameInfoNodeFactory() {
}
@Override
public Class getNodeClass() {
return GetNameInfoNode.class;
}
@Override
public List getExecutionSignature() {
return Arrays.asList(RubyNode.class, RubyNode.class, RubyNode.class, RubyNode.class, RubyNode.class, RubyNode.class, RubyNode.class);
}
@Override
public List getNodeSignatures() {
return Arrays.asList(Arrays.asList(RubyNode[].class));
}
@Override
public GetNameInfoNode 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 (getNameInfoNodeFactoryInstance == null) {
getNameInfoNodeFactoryInstance = new GetNameInfoNodeFactory();
}
return getNameInfoNodeFactoryInstance;
}
public static GetNameInfoNode create(RubyNode[] arguments) {
return new GetNameInfoNodeGen(arguments);
}
@GeneratedBy(GetNameInfoNode.class)
public static final class GetNameInfoNodeGen extends GetNameInfoNode implements SpecializedNode {
@Child private RubyNode arguments0_;
@Child private RubyNode arguments1_;
@Child private RubyNode arguments2_;
@Child private RubyNode arguments3_;
@Child private RubyNode arguments4_;
@Child private RubyNode arguments5_;
@Child private RubyNode arguments6_;
@CompilationFinal private Class arguments1Type_;
@CompilationFinal private Class arguments3Type_;
@CompilationFinal private Class arguments5Type_;
@CompilationFinal private Class arguments6Type_;
@Child private BaseNode_ specialization_;
private GetNameInfoNodeGen(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.arguments3_ = arguments != null && 3 < arguments.length ? arguments[3] : null;
this.arguments4_ = arguments != null && 4 < arguments.length ? arguments[4] : null;
this.arguments5_ = arguments != null && 5 < arguments.length ? arguments[5] : null;
this.arguments6_ = arguments != null && 6 < arguments.length ? arguments[6] : 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(GetNameInfoNode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected GetNameInfoNodeGen root;
BaseNode_(GetNameInfoNodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (GetNameInfoNodeGen) root;
}
@Override
protected final Node[] getSuppliedChildren() {
return new Node[] {root.arguments0_, root.arguments1_, root.arguments2_, root.arguments3_, root.arguments4_, root.arguments5_, root.arguments6_};
}
@Override
public final Object acceptAndExecute(Frame frameValue, Object... args_) {
return this.executeInt_((VirtualFrame) frameValue, args_[0], args_[1], args_[2], args_[3], args_[4], args_[5], args_[6]);
}
public abstract int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value, Object arguments3Value, Object arguments4Value, Object arguments5Value, Object arguments6Value);
public Object execute(VirtualFrame frameValue) {
Object arguments0Value_ = root.arguments0_.execute(frameValue);
Object arguments1Value_ = executeArguments1_(frameValue);
Object arguments2Value_ = root.arguments2_.execute(frameValue);
Object arguments3Value_ = executeArguments3_(frameValue);
Object arguments4Value_ = root.arguments4_.execute(frameValue);
Object arguments5Value_ = executeArguments5_(frameValue);
Object arguments6Value_ = executeArguments6_(frameValue);
return executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_, arguments3Value_, arguments4Value_, arguments5Value_, arguments6Value_);
}
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... args_) {
if (args_[0] instanceof DynamicObject && RubyTypesGen.isImplicitInteger(args_[1]) && args_[2] instanceof DynamicObject && RubyTypesGen.isImplicitInteger(args_[3]) && args_[4] instanceof DynamicObject && RubyTypesGen.isImplicitInteger(args_[5]) && RubyTypesGen.isImplicitInteger(args_[6])) {
DynamicObject arguments0Value_ = (DynamicObject) args_[0];
DynamicObject arguments2Value_ = (DynamicObject) args_[2];
DynamicObject arguments4Value_ = (DynamicObject) args_[4];
if ((RubyGuards.isRubyPointer(arguments0Value_)) && (RubyGuards.isRubyPointer(arguments2Value_)) && (RubyGuards.isRubyPointer(arguments4Value_))) {
return GetnameinfoNode_.create(root, args_[1], args_[3], args_[5], args_[6]);
}
if ((RubyGuards.isRubyPointer(arguments0Value_)) && (root.isNil(arguments2Value_)) && (RubyGuards.isRubyPointer(arguments4Value_))) {
return GetnameinfoNullHostNode_.create(root, args_[1], args_[3], args_[5], args_[6]);
}
if ((RubyGuards.isRubyPointer(arguments0Value_)) && (RubyGuards.isRubyPointer(arguments2Value_)) && (root.isNil(arguments4Value_))) {
return GetnameinfoNullServiceNode_.create(root, args_[1], args_[3], args_[5], args_[6]);
}
}
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 executeArguments3_(Frame frameValue) {
Class arguments3Type_ = root.arguments3Type_;
try {
if (arguments3Type_ == int.class) {
return root.arguments3_.executeInteger((VirtualFrame) frameValue);
} else if (arguments3Type_ == null) {
CompilerDirectives.transferToInterpreterAndInvalidate();
Class _type = Object.class;
try {
Object _value = root.arguments3_.execute((VirtualFrame) frameValue);
if (_value instanceof Integer) {
_type = int.class;
} else {
_type = Object.class;
}
return _value;
} finally {
root.arguments3Type_ = _type;
}
} else {
return root.arguments3_.execute((VirtualFrame) frameValue);
}
} catch (UnexpectedResultException ex) {
root.arguments3Type_ = Object.class;
return ex.getResult();
}
}
protected final Object executeArguments5_(Frame frameValue) {
Class arguments5Type_ = root.arguments5Type_;
try {
if (arguments5Type_ == int.class) {
return root.arguments5_.executeInteger((VirtualFrame) frameValue);
} else if (arguments5Type_ == null) {
CompilerDirectives.transferToInterpreterAndInvalidate();
Class _type = Object.class;
try {
Object _value = root.arguments5_.execute((VirtualFrame) frameValue);
if (_value instanceof Integer) {
_type = int.class;
} else {
_type = Object.class;
}
return _value;
} finally {
root.arguments5Type_ = _type;
}
} else {
return root.arguments5_.execute((VirtualFrame) frameValue);
}
} catch (UnexpectedResultException ex) {
root.arguments5Type_ = Object.class;
return ex.getResult();
}
}
protected final Object executeArguments6_(Frame frameValue) {
Class arguments6Type_ = root.arguments6Type_;
try {
if (arguments6Type_ == int.class) {
return root.arguments6_.executeInteger((VirtualFrame) frameValue);
} else if (arguments6Type_ == null) {
CompilerDirectives.transferToInterpreterAndInvalidate();
Class _type = Object.class;
try {
Object _value = root.arguments6_.execute((VirtualFrame) frameValue);
if (_value instanceof Integer) {
_type = int.class;
} else {
_type = Object.class;
}
return _value;
} finally {
root.arguments6Type_ = _type;
}
} else {
return root.arguments6_.execute((VirtualFrame) frameValue);
}
} catch (UnexpectedResultException ex) {
root.arguments6Type_ = Object.class;
return ex.getResult();
}
}
}
@GeneratedBy(GetNameInfoNode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(GetNameInfoNodeGen root) {
super(root, 2147483647);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value, Object arguments3Value, Object arguments4Value, Object arguments5Value, Object arguments6Value) {
return (int) uninitialized(frameValue, arguments0Value, arguments1Value, arguments2Value, arguments3Value, arguments4Value, arguments5Value, arguments6Value);
}
static BaseNode_ create(GetNameInfoNodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(GetNameInfoNode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(GetNameInfoNodeGen root) {
super(root, 0);
}
@Override
public SpecializationNode merge(SpecializationNode newNode, Frame frameValue, Object... args_) {
return polymorphicMerge(newNode, super.merge(newNode, frameValue, args_[0], args_[1], args_[2], args_[3], args_[4], args_[5], args_[6]));
}
@Override
public int executeInt(VirtualFrame frameValue) {
Object arguments0Value_ = root.arguments0_.execute(frameValue);
Object arguments1Value_ = executeArguments1_(frameValue);
Object arguments2Value_ = root.arguments2_.execute(frameValue);
Object arguments3Value_ = executeArguments3_(frameValue);
Object arguments4Value_ = root.arguments4_.execute(frameValue);
Object arguments5Value_ = executeArguments5_(frameValue);
Object arguments6Value_ = executeArguments6_(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_, arguments3Value_, arguments4Value_, arguments5Value_, arguments6Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value, Object arguments3Value, Object arguments4Value, Object arguments5Value, Object arguments6Value) {
return getNext().executeInt_(frameValue, arguments0Value, arguments1Value, arguments2Value, arguments3Value, arguments4Value, arguments5Value, arguments6Value);
}
static BaseNode_ create(GetNameInfoNodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "getnameinfo(DynamicObject, int, DynamicObject, int, DynamicObject, int, int)", value = GetNameInfoNode.class)
private static final class GetnameinfoNode_ extends BaseNode_ {
private final Class arguments1ImplicitType;
private final Class arguments3ImplicitType;
private final Class arguments5ImplicitType;
private final Class arguments6ImplicitType;
GetnameinfoNode_(GetNameInfoNodeGen root, Object arguments1Value, Object arguments3Value, Object arguments5Value, Object arguments6Value) {
super(root, 1);
this.arguments1ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments1Value);
this.arguments3ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments3Value);
this.arguments5ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments5Value);
this.arguments6ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments6Value);
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.arguments1ImplicitType == ((GetnameinfoNode_) other).arguments1ImplicitType && this.arguments3ImplicitType == ((GetnameinfoNode_) other).arguments3ImplicitType && this.arguments5ImplicitType == ((GetnameinfoNode_) other).arguments5ImplicitType && this.arguments6ImplicitType == ((GetnameinfoNode_) other).arguments6ImplicitType;
}
@Override
public Object execute(VirtualFrame frameValue) {
return executeInt(frameValue);
}
@Override
public int executeInt(VirtualFrame frameValue) {
DynamicObject arguments0Value_;
try {
arguments0Value_ = root.arguments0_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object arguments1Value = executeArguments1_(frameValue);
Object arguments2Value = root.arguments2_.execute(frameValue);
Object arguments3Value = executeArguments3_(frameValue);
Object arguments4Value = root.arguments4_.execute(frameValue);
Object arguments5Value = executeArguments5_(frameValue);
Object arguments6Value = executeArguments6_(frameValue);
return getNext().executeInt_(frameValue, ex.getResult(), arguments1Value, arguments2Value, arguments3Value, arguments4Value, arguments5Value, arguments6Value);
}
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 = root.arguments2_.execute(frameValue);
Object arguments3Value = executeArguments3_(frameValue);
Object arguments4Value = root.arguments4_.execute(frameValue);
Object arguments5Value = executeArguments5_(frameValue);
Object arguments6Value = executeArguments6_(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_, ex.getResult(), arguments2Value, arguments3Value, arguments4Value, arguments5Value, arguments6Value);
}
DynamicObject arguments2Value_;
try {
arguments2Value_ = root.arguments2_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object arguments3Value = executeArguments3_(frameValue);
Object arguments4Value = root.arguments4_.execute(frameValue);
Object arguments5Value = executeArguments5_(frameValue);
Object arguments6Value = executeArguments6_(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_, ex.getResult(), arguments3Value, arguments4Value, arguments5Value, arguments6Value);
}
int arguments3Value_;
try {
if (arguments3ImplicitType == int.class) {
arguments3Value_ = root.arguments3_.executeInteger(frameValue);
} else {
Object arguments3Value__ = executeArguments3_(frameValue);
arguments3Value_ = RubyTypesGen.expectImplicitInteger(arguments3Value__, arguments3ImplicitType);
}
} catch (UnexpectedResultException ex) {
Object arguments4Value = root.arguments4_.execute(frameValue);
Object arguments5Value = executeArguments5_(frameValue);
Object arguments6Value = executeArguments6_(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_, ex.getResult(), arguments4Value, arguments5Value, arguments6Value);
}
DynamicObject arguments4Value_;
try {
arguments4Value_ = root.arguments4_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object arguments5Value = executeArguments5_(frameValue);
Object arguments6Value = executeArguments6_(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_, arguments3Value_, ex.getResult(), arguments5Value, arguments6Value);
}
int arguments5Value_;
try {
if (arguments5ImplicitType == int.class) {
arguments5Value_ = root.arguments5_.executeInteger(frameValue);
} else {
Object arguments5Value__ = executeArguments5_(frameValue);
arguments5Value_ = RubyTypesGen.expectImplicitInteger(arguments5Value__, arguments5ImplicitType);
}
} catch (UnexpectedResultException ex) {
Object arguments6Value = executeArguments6_(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_, arguments3Value_, arguments4Value_, ex.getResult(), arguments6Value);
}
int arguments6Value_;
try {
if (arguments6ImplicitType == int.class) {
arguments6Value_ = root.arguments6_.executeInteger(frameValue);
} else {
Object arguments6Value__ = executeArguments6_(frameValue);
arguments6Value_ = RubyTypesGen.expectImplicitInteger(arguments6Value__, arguments6ImplicitType);
}
} catch (UnexpectedResultException ex) {
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_, arguments3Value_, arguments4Value_, arguments5Value_, ex.getResult());
}
if ((RubyGuards.isRubyPointer(arguments0Value_)) && (RubyGuards.isRubyPointer(arguments2Value_)) && (RubyGuards.isRubyPointer(arguments4Value_))) {
return root.getnameinfo(arguments0Value_, arguments1Value_, arguments2Value_, arguments3Value_, arguments4Value_, arguments5Value_, arguments6Value_);
}
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_, arguments3Value_, arguments4Value_, arguments5Value_, arguments6Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value, Object arguments3Value, Object arguments4Value, Object arguments5Value, Object arguments6Value) {
if (arguments0Value instanceof DynamicObject && RubyTypesGen.isImplicitInteger(arguments1Value, arguments1ImplicitType) && arguments2Value instanceof DynamicObject && RubyTypesGen.isImplicitInteger(arguments3Value, arguments3ImplicitType) && arguments4Value instanceof DynamicObject && RubyTypesGen.isImplicitInteger(arguments5Value, arguments5ImplicitType) && RubyTypesGen.isImplicitInteger(arguments6Value, arguments6ImplicitType)) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
int arguments1Value_ = RubyTypesGen.asImplicitInteger(arguments1Value, arguments1ImplicitType);
DynamicObject arguments2Value_ = (DynamicObject) arguments2Value;
int arguments3Value_ = RubyTypesGen.asImplicitInteger(arguments3Value, arguments3ImplicitType);
DynamicObject arguments4Value_ = (DynamicObject) arguments4Value;
int arguments5Value_ = RubyTypesGen.asImplicitInteger(arguments5Value, arguments5ImplicitType);
int arguments6Value_ = RubyTypesGen.asImplicitInteger(arguments6Value, arguments6ImplicitType);
if ((RubyGuards.isRubyPointer(arguments0Value_)) && (RubyGuards.isRubyPointer(arguments2Value_)) && (RubyGuards.isRubyPointer(arguments4Value_))) {
return root.getnameinfo(arguments0Value_, arguments1Value_, arguments2Value_, arguments3Value_, arguments4Value_, arguments5Value_, arguments6Value_);
}
}
return getNext().executeInt_(frameValue, arguments0Value, arguments1Value, arguments2Value, arguments3Value, arguments4Value, arguments5Value, arguments6Value);
}
static BaseNode_ create(GetNameInfoNodeGen root, Object arguments1Value, Object arguments3Value, Object arguments5Value, Object arguments6Value) {
return new GetnameinfoNode_(root, arguments1Value, arguments3Value, arguments5Value, arguments6Value);
}
}
@GeneratedBy(methodName = "getnameinfoNullHost(DynamicObject, int, DynamicObject, int, DynamicObject, int, int)", value = GetNameInfoNode.class)
private static final class GetnameinfoNullHostNode_ extends BaseNode_ {
private final Class arguments1ImplicitType;
private final Class arguments3ImplicitType;
private final Class arguments5ImplicitType;
private final Class arguments6ImplicitType;
GetnameinfoNullHostNode_(GetNameInfoNodeGen root, Object arguments1Value, Object arguments3Value, Object arguments5Value, Object arguments6Value) {
super(root, 2);
this.arguments1ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments1Value);
this.arguments3ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments3Value);
this.arguments5ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments5Value);
this.arguments6ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments6Value);
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.arguments1ImplicitType == ((GetnameinfoNullHostNode_) other).arguments1ImplicitType && this.arguments3ImplicitType == ((GetnameinfoNullHostNode_) other).arguments3ImplicitType && this.arguments5ImplicitType == ((GetnameinfoNullHostNode_) other).arguments5ImplicitType && this.arguments6ImplicitType == ((GetnameinfoNullHostNode_) other).arguments6ImplicitType;
}
@Override
public Object execute(VirtualFrame frameValue) {
return executeInt(frameValue);
}
@Override
public int executeInt(VirtualFrame frameValue) {
DynamicObject arguments0Value_;
try {
arguments0Value_ = root.arguments0_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object arguments1Value = executeArguments1_(frameValue);
Object arguments2Value = root.arguments2_.execute(frameValue);
Object arguments3Value = executeArguments3_(frameValue);
Object arguments4Value = root.arguments4_.execute(frameValue);
Object arguments5Value = executeArguments5_(frameValue);
Object arguments6Value = executeArguments6_(frameValue);
return getNext().executeInt_(frameValue, ex.getResult(), arguments1Value, arguments2Value, arguments3Value, arguments4Value, arguments5Value, arguments6Value);
}
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 = root.arguments2_.execute(frameValue);
Object arguments3Value = executeArguments3_(frameValue);
Object arguments4Value = root.arguments4_.execute(frameValue);
Object arguments5Value = executeArguments5_(frameValue);
Object arguments6Value = executeArguments6_(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_, ex.getResult(), arguments2Value, arguments3Value, arguments4Value, arguments5Value, arguments6Value);
}
DynamicObject arguments2Value_;
try {
arguments2Value_ = root.arguments2_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object arguments3Value = executeArguments3_(frameValue);
Object arguments4Value = root.arguments4_.execute(frameValue);
Object arguments5Value = executeArguments5_(frameValue);
Object arguments6Value = executeArguments6_(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_, ex.getResult(), arguments3Value, arguments4Value, arguments5Value, arguments6Value);
}
int arguments3Value_;
try {
if (arguments3ImplicitType == int.class) {
arguments3Value_ = root.arguments3_.executeInteger(frameValue);
} else {
Object arguments3Value__ = executeArguments3_(frameValue);
arguments3Value_ = RubyTypesGen.expectImplicitInteger(arguments3Value__, arguments3ImplicitType);
}
} catch (UnexpectedResultException ex) {
Object arguments4Value = root.arguments4_.execute(frameValue);
Object arguments5Value = executeArguments5_(frameValue);
Object arguments6Value = executeArguments6_(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_, ex.getResult(), arguments4Value, arguments5Value, arguments6Value);
}
DynamicObject arguments4Value_;
try {
arguments4Value_ = root.arguments4_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object arguments5Value = executeArguments5_(frameValue);
Object arguments6Value = executeArguments6_(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_, arguments3Value_, ex.getResult(), arguments5Value, arguments6Value);
}
int arguments5Value_;
try {
if (arguments5ImplicitType == int.class) {
arguments5Value_ = root.arguments5_.executeInteger(frameValue);
} else {
Object arguments5Value__ = executeArguments5_(frameValue);
arguments5Value_ = RubyTypesGen.expectImplicitInteger(arguments5Value__, arguments5ImplicitType);
}
} catch (UnexpectedResultException ex) {
Object arguments6Value = executeArguments6_(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_, arguments3Value_, arguments4Value_, ex.getResult(), arguments6Value);
}
int arguments6Value_;
try {
if (arguments6ImplicitType == int.class) {
arguments6Value_ = root.arguments6_.executeInteger(frameValue);
} else {
Object arguments6Value__ = executeArguments6_(frameValue);
arguments6Value_ = RubyTypesGen.expectImplicitInteger(arguments6Value__, arguments6ImplicitType);
}
} catch (UnexpectedResultException ex) {
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_, arguments3Value_, arguments4Value_, arguments5Value_, ex.getResult());
}
if ((RubyGuards.isRubyPointer(arguments0Value_)) && (root.isNil(arguments2Value_)) && (RubyGuards.isRubyPointer(arguments4Value_))) {
return root.getnameinfoNullHost(arguments0Value_, arguments1Value_, arguments2Value_, arguments3Value_, arguments4Value_, arguments5Value_, arguments6Value_);
}
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_, arguments3Value_, arguments4Value_, arguments5Value_, arguments6Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value, Object arguments3Value, Object arguments4Value, Object arguments5Value, Object arguments6Value) {
if (arguments0Value instanceof DynamicObject && RubyTypesGen.isImplicitInteger(arguments1Value, arguments1ImplicitType) && arguments2Value instanceof DynamicObject && RubyTypesGen.isImplicitInteger(arguments3Value, arguments3ImplicitType) && arguments4Value instanceof DynamicObject && RubyTypesGen.isImplicitInteger(arguments5Value, arguments5ImplicitType) && RubyTypesGen.isImplicitInteger(arguments6Value, arguments6ImplicitType)) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
int arguments1Value_ = RubyTypesGen.asImplicitInteger(arguments1Value, arguments1ImplicitType);
DynamicObject arguments2Value_ = (DynamicObject) arguments2Value;
int arguments3Value_ = RubyTypesGen.asImplicitInteger(arguments3Value, arguments3ImplicitType);
DynamicObject arguments4Value_ = (DynamicObject) arguments4Value;
int arguments5Value_ = RubyTypesGen.asImplicitInteger(arguments5Value, arguments5ImplicitType);
int arguments6Value_ = RubyTypesGen.asImplicitInteger(arguments6Value, arguments6ImplicitType);
if ((RubyGuards.isRubyPointer(arguments0Value_)) && (root.isNil(arguments2Value_)) && (RubyGuards.isRubyPointer(arguments4Value_))) {
return root.getnameinfoNullHost(arguments0Value_, arguments1Value_, arguments2Value_, arguments3Value_, arguments4Value_, arguments5Value_, arguments6Value_);
}
}
return getNext().executeInt_(frameValue, arguments0Value, arguments1Value, arguments2Value, arguments3Value, arguments4Value, arguments5Value, arguments6Value);
}
static BaseNode_ create(GetNameInfoNodeGen root, Object arguments1Value, Object arguments3Value, Object arguments5Value, Object arguments6Value) {
return new GetnameinfoNullHostNode_(root, arguments1Value, arguments3Value, arguments5Value, arguments6Value);
}
}
@GeneratedBy(methodName = "getnameinfoNullService(DynamicObject, int, DynamicObject, int, DynamicObject, int, int)", value = GetNameInfoNode.class)
private static final class GetnameinfoNullServiceNode_ extends BaseNode_ {
private final Class arguments1ImplicitType;
private final Class arguments3ImplicitType;
private final Class arguments5ImplicitType;
private final Class arguments6ImplicitType;
GetnameinfoNullServiceNode_(GetNameInfoNodeGen root, Object arguments1Value, Object arguments3Value, Object arguments5Value, Object arguments6Value) {
super(root, 3);
this.arguments1ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments1Value);
this.arguments3ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments3Value);
this.arguments5ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments5Value);
this.arguments6ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments6Value);
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.arguments1ImplicitType == ((GetnameinfoNullServiceNode_) other).arguments1ImplicitType && this.arguments3ImplicitType == ((GetnameinfoNullServiceNode_) other).arguments3ImplicitType && this.arguments5ImplicitType == ((GetnameinfoNullServiceNode_) other).arguments5ImplicitType && this.arguments6ImplicitType == ((GetnameinfoNullServiceNode_) other).arguments6ImplicitType;
}
@Override
public Object execute(VirtualFrame frameValue) {
return executeInt(frameValue);
}
@Override
public int executeInt(VirtualFrame frameValue) {
DynamicObject arguments0Value_;
try {
arguments0Value_ = root.arguments0_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object arguments1Value = executeArguments1_(frameValue);
Object arguments2Value = root.arguments2_.execute(frameValue);
Object arguments3Value = executeArguments3_(frameValue);
Object arguments4Value = root.arguments4_.execute(frameValue);
Object arguments5Value = executeArguments5_(frameValue);
Object arguments6Value = executeArguments6_(frameValue);
return getNext().executeInt_(frameValue, ex.getResult(), arguments1Value, arguments2Value, arguments3Value, arguments4Value, arguments5Value, arguments6Value);
}
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 = root.arguments2_.execute(frameValue);
Object arguments3Value = executeArguments3_(frameValue);
Object arguments4Value = root.arguments4_.execute(frameValue);
Object arguments5Value = executeArguments5_(frameValue);
Object arguments6Value = executeArguments6_(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_, ex.getResult(), arguments2Value, arguments3Value, arguments4Value, arguments5Value, arguments6Value);
}
DynamicObject arguments2Value_;
try {
arguments2Value_ = root.arguments2_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object arguments3Value = executeArguments3_(frameValue);
Object arguments4Value = root.arguments4_.execute(frameValue);
Object arguments5Value = executeArguments5_(frameValue);
Object arguments6Value = executeArguments6_(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_, ex.getResult(), arguments3Value, arguments4Value, arguments5Value, arguments6Value);
}
int arguments3Value_;
try {
if (arguments3ImplicitType == int.class) {
arguments3Value_ = root.arguments3_.executeInteger(frameValue);
} else {
Object arguments3Value__ = executeArguments3_(frameValue);
arguments3Value_ = RubyTypesGen.expectImplicitInteger(arguments3Value__, arguments3ImplicitType);
}
} catch (UnexpectedResultException ex) {
Object arguments4Value = root.arguments4_.execute(frameValue);
Object arguments5Value = executeArguments5_(frameValue);
Object arguments6Value = executeArguments6_(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_, ex.getResult(), arguments4Value, arguments5Value, arguments6Value);
}
DynamicObject arguments4Value_;
try {
arguments4Value_ = root.arguments4_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object arguments5Value = executeArguments5_(frameValue);
Object arguments6Value = executeArguments6_(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_, arguments3Value_, ex.getResult(), arguments5Value, arguments6Value);
}
int arguments5Value_;
try {
if (arguments5ImplicitType == int.class) {
arguments5Value_ = root.arguments5_.executeInteger(frameValue);
} else {
Object arguments5Value__ = executeArguments5_(frameValue);
arguments5Value_ = RubyTypesGen.expectImplicitInteger(arguments5Value__, arguments5ImplicitType);
}
} catch (UnexpectedResultException ex) {
Object arguments6Value = executeArguments6_(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_, arguments3Value_, arguments4Value_, ex.getResult(), arguments6Value);
}
int arguments6Value_;
try {
if (arguments6ImplicitType == int.class) {
arguments6Value_ = root.arguments6_.executeInteger(frameValue);
} else {
Object arguments6Value__ = executeArguments6_(frameValue);
arguments6Value_ = RubyTypesGen.expectImplicitInteger(arguments6Value__, arguments6ImplicitType);
}
} catch (UnexpectedResultException ex) {
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_, arguments3Value_, arguments4Value_, arguments5Value_, ex.getResult());
}
if ((RubyGuards.isRubyPointer(arguments0Value_)) && (RubyGuards.isRubyPointer(arguments2Value_)) && (root.isNil(arguments4Value_))) {
return root.getnameinfoNullService(arguments0Value_, arguments1Value_, arguments2Value_, arguments3Value_, arguments4Value_, arguments5Value_, arguments6Value_);
}
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_, arguments3Value_, arguments4Value_, arguments5Value_, arguments6Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value, Object arguments3Value, Object arguments4Value, Object arguments5Value, Object arguments6Value) {
if (arguments0Value instanceof DynamicObject && RubyTypesGen.isImplicitInteger(arguments1Value, arguments1ImplicitType) && arguments2Value instanceof DynamicObject && RubyTypesGen.isImplicitInteger(arguments3Value, arguments3ImplicitType) && arguments4Value instanceof DynamicObject && RubyTypesGen.isImplicitInteger(arguments5Value, arguments5ImplicitType) && RubyTypesGen.isImplicitInteger(arguments6Value, arguments6ImplicitType)) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
int arguments1Value_ = RubyTypesGen.asImplicitInteger(arguments1Value, arguments1ImplicitType);
DynamicObject arguments2Value_ = (DynamicObject) arguments2Value;
int arguments3Value_ = RubyTypesGen.asImplicitInteger(arguments3Value, arguments3ImplicitType);
DynamicObject arguments4Value_ = (DynamicObject) arguments4Value;
int arguments5Value_ = RubyTypesGen.asImplicitInteger(arguments5Value, arguments5ImplicitType);
int arguments6Value_ = RubyTypesGen.asImplicitInteger(arguments6Value, arguments6ImplicitType);
if ((RubyGuards.isRubyPointer(arguments0Value_)) && (RubyGuards.isRubyPointer(arguments2Value_)) && (root.isNil(arguments4Value_))) {
return root.getnameinfoNullService(arguments0Value_, arguments1Value_, arguments2Value_, arguments3Value_, arguments4Value_, arguments5Value_, arguments6Value_);
}
}
return getNext().executeInt_(frameValue, arguments0Value, arguments1Value, arguments2Value, arguments3Value, arguments4Value, arguments5Value, arguments6Value);
}
static BaseNode_ create(GetNameInfoNodeGen root, Object arguments1Value, Object arguments3Value, Object arguments5Value, Object arguments6Value) {
return new GetnameinfoNullServiceNode_(root, arguments1Value, arguments3Value, arguments5Value, arguments6Value);
}
}
}
}
@GeneratedBy(ShutdownNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class ShutdownNodeFactory implements NodeFactory {
private static ShutdownNodeFactory shutdownNodeFactoryInstance;
private ShutdownNodeFactory() {
}
@Override
public Class getNodeClass() {
return ShutdownNode.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 ShutdownNode 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 (shutdownNodeFactoryInstance == null) {
shutdownNodeFactoryInstance = new ShutdownNodeFactory();
}
return shutdownNodeFactoryInstance;
}
public static ShutdownNode create(RubyNode[] arguments) {
return new ShutdownNodeGen(arguments);
}
@GeneratedBy(ShutdownNode.class)
public static final class ShutdownNodeGen extends ShutdownNode implements SpecializedNode {
@Child private RubyNode arguments0_;
@Child private RubyNode arguments1_;
@CompilationFinal private Class arguments0Type_;
@CompilationFinal private Class arguments1Type_;
@Child private BaseNode_ specialization_;
private ShutdownNodeGen(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) {
return specialization_.executeInt(frameValue);
}
@Override
public SpecializationNode getSpecializationNode() {
return specialization_;
}
@Override
public Node deepCopy() {
return SpecializationNode.updateRoot(super.deepCopy());
}
@GeneratedBy(ShutdownNode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected ShutdownNodeGen root;
BaseNode_(ShutdownNodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (ShutdownNodeGen) 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.executeInt_((VirtualFrame) frameValue, arguments0Value, arguments1Value);
}
public abstract int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value);
public Object execute(VirtualFrame frameValue) {
Object arguments0Value_ = executeArguments0_(frameValue);
Object arguments1Value_ = executeArguments1_(frameValue);
return executeInt_(frameValue, arguments0Value_, arguments1Value_);
}
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, Object arguments1Value) {
if (RubyTypesGen.isImplicitInteger(arguments0Value) && RubyTypesGen.isImplicitInteger(arguments1Value)) {
return ShutdownNode_.create(root, arguments0Value, arguments1Value);
}
return null;
}
@Override
protected final SpecializationNode createPolymorphic() {
return PolymorphicNode_.create(root);
}
protected final BaseNode_ getNext() {
return (BaseNode_) this.next;
}
protected final Object executeArguments0_(Frame frameValue) {
Class arguments0Type_ = root.arguments0Type_;
try {
if (arguments0Type_ == int.class) {
return root.arguments0_.executeInteger((VirtualFrame) frameValue);
} else if (arguments0Type_ == null) {
CompilerDirectives.transferToInterpreterAndInvalidate();
Class _type = Object.class;
try {
Object _value = root.arguments0_.execute((VirtualFrame) frameValue);
if (_value instanceof Integer) {
_type = int.class;
} else {
_type = Object.class;
}
return _value;
} finally {
root.arguments0Type_ = _type;
}
} else {
return root.arguments0_.execute((VirtualFrame) frameValue);
}
} catch (UnexpectedResultException ex) {
root.arguments0Type_ = Object.class;
return ex.getResult();
}
}
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();
}
}
}
@GeneratedBy(ShutdownNode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(ShutdownNodeGen root) {
super(root, 2147483647);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value) {
return (int) uninitialized(frameValue, arguments0Value, arguments1Value);
}
static BaseNode_ create(ShutdownNodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(ShutdownNode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(ShutdownNodeGen 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 int executeInt(VirtualFrame frameValue) {
Object arguments0Value_ = executeArguments0_(frameValue);
Object arguments1Value_ = executeArguments1_(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value) {
return getNext().executeInt_(frameValue, arguments0Value, arguments1Value);
}
static BaseNode_ create(ShutdownNodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "shutdown(int, int)", value = ShutdownNode.class)
private static final class ShutdownNode_ extends BaseNode_ {
private final Class arguments0ImplicitType;
private final Class arguments1ImplicitType;
ShutdownNode_(ShutdownNodeGen root, Object arguments0Value, Object arguments1Value) {
super(root, 1);
this.arguments0ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments0Value);
this.arguments1ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments1Value);
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.arguments0ImplicitType == ((ShutdownNode_) other).arguments0ImplicitType && this.arguments1ImplicitType == ((ShutdownNode_) other).arguments1ImplicitType;
}
@Override
public Object execute(VirtualFrame frameValue) {
return executeInt(frameValue);
}
@Override
public int executeInt(VirtualFrame frameValue) {
int arguments0Value_;
try {
if (arguments0ImplicitType == int.class) {
arguments0Value_ = root.arguments0_.executeInteger(frameValue);
} else {
Object arguments0Value__ = executeArguments0_(frameValue);
arguments0Value_ = RubyTypesGen.expectImplicitInteger(arguments0Value__, arguments0ImplicitType);
}
} catch (UnexpectedResultException ex) {
Object arguments1Value = executeArguments1_(frameValue);
return getNext().executeInt_(frameValue, ex.getResult(), arguments1Value);
}
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) {
return getNext().executeInt_(frameValue, arguments0Value_, ex.getResult());
}
return root.shutdown(arguments0Value_, arguments1Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value) {
if (RubyTypesGen.isImplicitInteger(arguments0Value, arguments0ImplicitType) && RubyTypesGen.isImplicitInteger(arguments1Value, arguments1ImplicitType)) {
int arguments0Value_ = RubyTypesGen.asImplicitInteger(arguments0Value, arguments0ImplicitType);
int arguments1Value_ = RubyTypesGen.asImplicitInteger(arguments1Value, arguments1ImplicitType);
return root.shutdown(arguments0Value_, arguments1Value_);
}
return getNext().executeInt_(frameValue, arguments0Value, arguments1Value);
}
static BaseNode_ create(ShutdownNodeGen root, Object arguments0Value, Object arguments1Value) {
return new ShutdownNode_(root, arguments0Value, arguments1Value);
}
}
}
}
@GeneratedBy(SocketNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class SocketNodeFactory implements NodeFactory {
private static SocketNodeFactory socketNodeFactoryInstance;
private SocketNodeFactory() {
}
@Override
public Class getNodeClass() {
return SocketNode.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 SocketNode 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 (socketNodeFactoryInstance == null) {
socketNodeFactoryInstance = new SocketNodeFactory();
}
return socketNodeFactoryInstance;
}
public static SocketNode create(RubyNode[] arguments) {
return new SocketNodeGen(arguments);
}
@GeneratedBy(SocketNode.class)
public static final class SocketNodeGen extends SocketNode implements SpecializedNode {
@Child private RubyNode arguments0_;
@Child private RubyNode arguments1_;
@Child private RubyNode arguments2_;
@CompilationFinal private Class arguments0Type_;
@CompilationFinal private Class arguments1Type_;
@CompilationFinal private Class arguments2Type_;
@Child private BaseNode_ specialization_;
private SocketNodeGen(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 int executeInteger(VirtualFrame frameValue) {
return specialization_.executeInt(frameValue);
}
@Override
public SpecializationNode getSpecializationNode() {
return specialization_;
}
@Override
public Node deepCopy() {
return SpecializationNode.updateRoot(super.deepCopy());
}
@GeneratedBy(SocketNode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected SocketNodeGen root;
BaseNode_(SocketNodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (SocketNodeGen) 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.executeInt_((VirtualFrame) frameValue, arguments0Value, arguments1Value, arguments2Value);
}
public abstract int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value);
public Object execute(VirtualFrame frameValue) {
Object arguments0Value_ = executeArguments0_(frameValue);
Object arguments1Value_ = executeArguments1_(frameValue);
Object arguments2Value_ = executeArguments2_(frameValue);
return executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_);
}
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, Object arguments1Value, Object arguments2Value) {
if (RubyTypesGen.isImplicitInteger(arguments0Value) && RubyTypesGen.isImplicitInteger(arguments1Value) && RubyTypesGen.isImplicitInteger(arguments2Value)) {
return GetnameinfoNode_.create(root, arguments0Value, arguments1Value, arguments2Value);
}
return null;
}
@Override
protected final SpecializationNode createPolymorphic() {
return PolymorphicNode_.create(root);
}
protected final BaseNode_ getNext() {
return (BaseNode_) this.next;
}
protected final Object executeArguments0_(Frame frameValue) {
Class arguments0Type_ = root.arguments0Type_;
try {
if (arguments0Type_ == int.class) {
return root.arguments0_.executeInteger((VirtualFrame) frameValue);
} else if (arguments0Type_ == null) {
CompilerDirectives.transferToInterpreterAndInvalidate();
Class _type = Object.class;
try {
Object _value = root.arguments0_.execute((VirtualFrame) frameValue);
if (_value instanceof Integer) {
_type = int.class;
} else {
_type = Object.class;
}
return _value;
} finally {
root.arguments0Type_ = _type;
}
} else {
return root.arguments0_.execute((VirtualFrame) frameValue);
}
} catch (UnexpectedResultException ex) {
root.arguments0Type_ = Object.class;
return ex.getResult();
}
}
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(SocketNode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(SocketNodeGen root) {
super(root, 2147483647);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value) {
return (int) uninitialized(frameValue, arguments0Value, arguments1Value, arguments2Value);
}
static BaseNode_ create(SocketNodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(SocketNode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(SocketNodeGen 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 int executeInt(VirtualFrame frameValue) {
Object arguments0Value_ = executeArguments0_(frameValue);
Object arguments1Value_ = executeArguments1_(frameValue);
Object arguments2Value_ = executeArguments2_(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value) {
return getNext().executeInt_(frameValue, arguments0Value, arguments1Value, arguments2Value);
}
static BaseNode_ create(SocketNodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "getnameinfo(int, int, int)", value = SocketNode.class)
private static final class GetnameinfoNode_ extends BaseNode_ {
private final Class arguments0ImplicitType;
private final Class arguments1ImplicitType;
private final Class arguments2ImplicitType;
GetnameinfoNode_(SocketNodeGen root, Object arguments0Value, Object arguments1Value, Object arguments2Value) {
super(root, 1);
this.arguments0ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments0Value);
this.arguments1ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments1Value);
this.arguments2ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments2Value);
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.arguments0ImplicitType == ((GetnameinfoNode_) other).arguments0ImplicitType && this.arguments1ImplicitType == ((GetnameinfoNode_) other).arguments1ImplicitType && this.arguments2ImplicitType == ((GetnameinfoNode_) other).arguments2ImplicitType;
}
@Override
public Object execute(VirtualFrame frameValue) {
return executeInt(frameValue);
}
@Override
public int executeInt(VirtualFrame frameValue) {
int arguments0Value_;
try {
if (arguments0ImplicitType == int.class) {
arguments0Value_ = root.arguments0_.executeInteger(frameValue);
} else {
Object arguments0Value__ = executeArguments0_(frameValue);
arguments0Value_ = RubyTypesGen.expectImplicitInteger(arguments0Value__, arguments0ImplicitType);
}
} catch (UnexpectedResultException ex) {
Object arguments1Value = executeArguments1_(frameValue);
Object arguments2Value = executeArguments2_(frameValue);
return getNext().executeInt_(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().executeInt_(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().executeInt_(frameValue, arguments0Value_, arguments1Value_, ex.getResult());
}
return root.getnameinfo(arguments0Value_, arguments1Value_, arguments2Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value) {
if (RubyTypesGen.isImplicitInteger(arguments0Value, arguments0ImplicitType) && RubyTypesGen.isImplicitInteger(arguments1Value, arguments1ImplicitType) && RubyTypesGen.isImplicitInteger(arguments2Value, arguments2ImplicitType)) {
int arguments0Value_ = RubyTypesGen.asImplicitInteger(arguments0Value, arguments0ImplicitType);
int arguments1Value_ = RubyTypesGen.asImplicitInteger(arguments1Value, arguments1ImplicitType);
int arguments2Value_ = RubyTypesGen.asImplicitInteger(arguments2Value, arguments2ImplicitType);
return root.getnameinfo(arguments0Value_, arguments1Value_, arguments2Value_);
}
return getNext().executeInt_(frameValue, arguments0Value, arguments1Value, arguments2Value);
}
static BaseNode_ create(SocketNodeGen root, Object arguments0Value, Object arguments1Value, Object arguments2Value) {
return new GetnameinfoNode_(root, arguments0Value, arguments1Value, arguments2Value);
}
}
}
}
@GeneratedBy(SetSockOptNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class SetSockOptNodeFactory implements NodeFactory {
private static SetSockOptNodeFactory setSockOptNodeFactoryInstance;
private SetSockOptNodeFactory() {
}
@Override
public Class getNodeClass() {
return SetSockOptNode.class;
}
@Override
public List getExecutionSignature() {
return Arrays.asList(RubyNode.class, RubyNode.class, RubyNode.class, RubyNode.class, RubyNode.class);
}
@Override
public List getNodeSignatures() {
return Arrays.asList(Arrays.asList(RubyNode[].class));
}
@Override
public SetSockOptNode 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 (setSockOptNodeFactoryInstance == null) {
setSockOptNodeFactoryInstance = new SetSockOptNodeFactory();
}
return setSockOptNodeFactoryInstance;
}
public static SetSockOptNode create(RubyNode[] arguments) {
return new SetSockOptNodeGen(arguments);
}
@GeneratedBy(SetSockOptNode.class)
public static final class SetSockOptNodeGen extends SetSockOptNode implements SpecializedNode {
@Child private RubyNode arguments0_;
@Child private RubyNode arguments1_;
@Child private RubyNode arguments2_;
@Child private RubyNode arguments3_;
@Child private RubyNode arguments4_;
@CompilationFinal private Class arguments0Type_;
@CompilationFinal private Class arguments1Type_;
@CompilationFinal private Class arguments2Type_;
@CompilationFinal private Class arguments4Type_;
@Child private BaseNode_ specialization_;
private SetSockOptNodeGen(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.arguments3_ = arguments != null && 3 < arguments.length ? arguments[3] : null;
this.arguments4_ = arguments != null && 4 < arguments.length ? arguments[4] : 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(SetSockOptNode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected SetSockOptNodeGen root;
BaseNode_(SetSockOptNodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (SetSockOptNodeGen) root;
}
@Override
protected final Node[] getSuppliedChildren() {
return new Node[] {root.arguments0_, root.arguments1_, root.arguments2_, root.arguments3_, root.arguments4_};
}
@Override
public final Object acceptAndExecute(Frame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value, Object arguments3Value, Object arguments4Value) {
return this.executeInt_((VirtualFrame) frameValue, arguments0Value, arguments1Value, arguments2Value, arguments3Value, arguments4Value);
}
public abstract int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value, Object arguments3Value, Object arguments4Value);
public Object execute(VirtualFrame frameValue) {
Object arguments0Value_ = executeArguments0_(frameValue);
Object arguments1Value_ = executeArguments1_(frameValue);
Object arguments2Value_ = executeArguments2_(frameValue);
Object arguments3Value_ = root.arguments3_.execute(frameValue);
Object arguments4Value_ = executeArguments4_(frameValue);
return executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_, arguments3Value_, arguments4Value_);
}
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, Object arguments1Value, Object arguments2Value, Object arguments3Value, Object arguments4Value) {
if (RubyTypesGen.isImplicitInteger(arguments0Value) && RubyTypesGen.isImplicitInteger(arguments1Value) && RubyTypesGen.isImplicitInteger(arguments2Value) && arguments3Value instanceof DynamicObject && RubyTypesGen.isImplicitInteger(arguments4Value)) {
DynamicObject arguments3Value_ = (DynamicObject) arguments3Value;
if ((RubyGuards.isRubyPointer(arguments3Value_))) {
return SetsockoptNode_.create(root, arguments0Value, arguments1Value, arguments2Value, arguments4Value);
}
}
return null;
}
@Override
protected final SpecializationNode createPolymorphic() {
return PolymorphicNode_.create(root);
}
protected final BaseNode_ getNext() {
return (BaseNode_) this.next;
}
protected final Object executeArguments0_(Frame frameValue) {
Class arguments0Type_ = root.arguments0Type_;
try {
if (arguments0Type_ == int.class) {
return root.arguments0_.executeInteger((VirtualFrame) frameValue);
} else if (arguments0Type_ == null) {
CompilerDirectives.transferToInterpreterAndInvalidate();
Class _type = Object.class;
try {
Object _value = root.arguments0_.execute((VirtualFrame) frameValue);
if (_value instanceof Integer) {
_type = int.class;
} else {
_type = Object.class;
}
return _value;
} finally {
root.arguments0Type_ = _type;
}
} else {
return root.arguments0_.execute((VirtualFrame) frameValue);
}
} catch (UnexpectedResultException ex) {
root.arguments0Type_ = Object.class;
return ex.getResult();
}
}
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();
}
}
protected final Object executeArguments4_(Frame frameValue) {
Class arguments4Type_ = root.arguments4Type_;
try {
if (arguments4Type_ == int.class) {
return root.arguments4_.executeInteger((VirtualFrame) frameValue);
} else if (arguments4Type_ == null) {
CompilerDirectives.transferToInterpreterAndInvalidate();
Class _type = Object.class;
try {
Object _value = root.arguments4_.execute((VirtualFrame) frameValue);
if (_value instanceof Integer) {
_type = int.class;
} else {
_type = Object.class;
}
return _value;
} finally {
root.arguments4Type_ = _type;
}
} else {
return root.arguments4_.execute((VirtualFrame) frameValue);
}
} catch (UnexpectedResultException ex) {
root.arguments4Type_ = Object.class;
return ex.getResult();
}
}
}
@GeneratedBy(SetSockOptNode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(SetSockOptNodeGen root) {
super(root, 2147483647);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value, Object arguments3Value, Object arguments4Value) {
return (int) uninitialized(frameValue, arguments0Value, arguments1Value, arguments2Value, arguments3Value, arguments4Value);
}
static BaseNode_ create(SetSockOptNodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(SetSockOptNode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(SetSockOptNodeGen root) {
super(root, 0);
}
@Override
public SpecializationNode merge(SpecializationNode newNode, Frame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value, Object arguments3Value, Object arguments4Value) {
return polymorphicMerge(newNode, super.merge(newNode, frameValue, arguments0Value, arguments1Value, arguments2Value, arguments3Value, arguments4Value));
}
@Override
public int executeInt(VirtualFrame frameValue) {
Object arguments0Value_ = executeArguments0_(frameValue);
Object arguments1Value_ = executeArguments1_(frameValue);
Object arguments2Value_ = executeArguments2_(frameValue);
Object arguments3Value_ = root.arguments3_.execute(frameValue);
Object arguments4Value_ = executeArguments4_(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_, arguments3Value_, arguments4Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value, Object arguments3Value, Object arguments4Value) {
return getNext().executeInt_(frameValue, arguments0Value, arguments1Value, arguments2Value, arguments3Value, arguments4Value);
}
static BaseNode_ create(SetSockOptNodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "setsockopt(int, int, int, DynamicObject, int)", value = SetSockOptNode.class)
private static final class SetsockoptNode_ extends BaseNode_ {
private final Class arguments0ImplicitType;
private final Class arguments1ImplicitType;
private final Class arguments2ImplicitType;
private final Class arguments4ImplicitType;
SetsockoptNode_(SetSockOptNodeGen root, Object arguments0Value, Object arguments1Value, Object arguments2Value, Object arguments4Value) {
super(root, 1);
this.arguments0ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments0Value);
this.arguments1ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments1Value);
this.arguments2ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments2Value);
this.arguments4ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments4Value);
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.arguments0ImplicitType == ((SetsockoptNode_) other).arguments0ImplicitType && this.arguments1ImplicitType == ((SetsockoptNode_) other).arguments1ImplicitType && this.arguments2ImplicitType == ((SetsockoptNode_) other).arguments2ImplicitType && this.arguments4ImplicitType == ((SetsockoptNode_) other).arguments4ImplicitType;
}
@Override
public Object execute(VirtualFrame frameValue) {
return executeInt(frameValue);
}
@Override
public int executeInt(VirtualFrame frameValue) {
int arguments0Value_;
try {
if (arguments0ImplicitType == int.class) {
arguments0Value_ = root.arguments0_.executeInteger(frameValue);
} else {
Object arguments0Value__ = executeArguments0_(frameValue);
arguments0Value_ = RubyTypesGen.expectImplicitInteger(arguments0Value__, arguments0ImplicitType);
}
} catch (UnexpectedResultException ex) {
Object arguments1Value = executeArguments1_(frameValue);
Object arguments2Value = executeArguments2_(frameValue);
Object arguments3Value = root.arguments3_.execute(frameValue);
Object arguments4Value = executeArguments4_(frameValue);
return getNext().executeInt_(frameValue, ex.getResult(), arguments1Value, arguments2Value, arguments3Value, arguments4Value);
}
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);
Object arguments3Value = root.arguments3_.execute(frameValue);
Object arguments4Value = executeArguments4_(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_, ex.getResult(), arguments2Value, arguments3Value, arguments4Value);
}
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) {
Object arguments3Value = root.arguments3_.execute(frameValue);
Object arguments4Value = executeArguments4_(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_, ex.getResult(), arguments3Value, arguments4Value);
}
DynamicObject arguments3Value_;
try {
arguments3Value_ = root.arguments3_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object arguments4Value = executeArguments4_(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_, ex.getResult(), arguments4Value);
}
int arguments4Value_;
try {
if (arguments4ImplicitType == int.class) {
arguments4Value_ = root.arguments4_.executeInteger(frameValue);
} else {
Object arguments4Value__ = executeArguments4_(frameValue);
arguments4Value_ = RubyTypesGen.expectImplicitInteger(arguments4Value__, arguments4ImplicitType);
}
} catch (UnexpectedResultException ex) {
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_, arguments3Value_, ex.getResult());
}
if ((RubyGuards.isRubyPointer(arguments3Value_))) {
return root.setsockopt(arguments0Value_, arguments1Value_, arguments2Value_, arguments3Value_, arguments4Value_);
}
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_, arguments3Value_, arguments4Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value, Object arguments3Value, Object arguments4Value) {
if (RubyTypesGen.isImplicitInteger(arguments0Value, arguments0ImplicitType) && RubyTypesGen.isImplicitInteger(arguments1Value, arguments1ImplicitType) && RubyTypesGen.isImplicitInteger(arguments2Value, arguments2ImplicitType) && arguments3Value instanceof DynamicObject && RubyTypesGen.isImplicitInteger(arguments4Value, arguments4ImplicitType)) {
int arguments0Value_ = RubyTypesGen.asImplicitInteger(arguments0Value, arguments0ImplicitType);
int arguments1Value_ = RubyTypesGen.asImplicitInteger(arguments1Value, arguments1ImplicitType);
int arguments2Value_ = RubyTypesGen.asImplicitInteger(arguments2Value, arguments2ImplicitType);
DynamicObject arguments3Value_ = (DynamicObject) arguments3Value;
int arguments4Value_ = RubyTypesGen.asImplicitInteger(arguments4Value, arguments4ImplicitType);
if ((RubyGuards.isRubyPointer(arguments3Value_))) {
return root.setsockopt(arguments0Value_, arguments1Value_, arguments2Value_, arguments3Value_, arguments4Value_);
}
}
return getNext().executeInt_(frameValue, arguments0Value, arguments1Value, arguments2Value, arguments3Value, arguments4Value);
}
static BaseNode_ create(SetSockOptNodeGen root, Object arguments0Value, Object arguments1Value, Object arguments2Value, Object arguments4Value) {
return new SetsockoptNode_(root, arguments0Value, arguments1Value, arguments2Value, arguments4Value);
}
}
}
}
@GeneratedBy(BindNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class BindNodeFactory implements NodeFactory {
private static BindNodeFactory bindNodeFactoryInstance;
private BindNodeFactory() {
}
@Override
public Class getNodeClass() {
return BindNode.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 BindNode 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 (bindNodeFactoryInstance == null) {
bindNodeFactoryInstance = new BindNodeFactory();
}
return bindNodeFactoryInstance;
}
public static BindNode create(RubyNode[] arguments) {
return new BindNodeGen(arguments);
}
@GeneratedBy(BindNode.class)
public static final class BindNodeGen extends BindNode implements SpecializedNode {
@Child private RubyNode arguments0_;
@Child private RubyNode arguments1_;
@Child private RubyNode arguments2_;
@CompilationFinal private Class arguments0Type_;
@CompilationFinal private Class arguments2Type_;
@Child private BaseNode_ specialization_;
private BindNodeGen(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 int executeInteger(VirtualFrame frameValue) {
return specialization_.executeInt(frameValue);
}
@Override
public SpecializationNode getSpecializationNode() {
return specialization_;
}
@Override
public Node deepCopy() {
return SpecializationNode.updateRoot(super.deepCopy());
}
@GeneratedBy(BindNode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected BindNodeGen root;
BaseNode_(BindNodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (BindNodeGen) 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.executeInt_((VirtualFrame) frameValue, arguments0Value, arguments1Value, arguments2Value);
}
public abstract int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value);
public Object execute(VirtualFrame frameValue) {
Object arguments0Value_ = executeArguments0_(frameValue);
Object arguments1Value_ = root.arguments1_.execute(frameValue);
Object arguments2Value_ = executeArguments2_(frameValue);
return executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_);
}
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, Object arguments1Value, Object arguments2Value) {
if (RubyTypesGen.isImplicitInteger(arguments0Value) && arguments1Value instanceof DynamicObject && RubyTypesGen.isImplicitInteger(arguments2Value)) {
DynamicObject arguments1Value_ = (DynamicObject) arguments1Value;
if ((RubyGuards.isRubyPointer(arguments1Value_))) {
return BindNode_.create(root, arguments0Value, arguments2Value);
}
}
return null;
}
@Override
protected final SpecializationNode createPolymorphic() {
return PolymorphicNode_.create(root);
}
protected final BaseNode_ getNext() {
return (BaseNode_) this.next;
}
protected final Object executeArguments0_(Frame frameValue) {
Class arguments0Type_ = root.arguments0Type_;
try {
if (arguments0Type_ == int.class) {
return root.arguments0_.executeInteger((VirtualFrame) frameValue);
} else if (arguments0Type_ == null) {
CompilerDirectives.transferToInterpreterAndInvalidate();
Class _type = Object.class;
try {
Object _value = root.arguments0_.execute((VirtualFrame) frameValue);
if (_value instanceof Integer) {
_type = int.class;
} else {
_type = Object.class;
}
return _value;
} finally {
root.arguments0Type_ = _type;
}
} else {
return root.arguments0_.execute((VirtualFrame) frameValue);
}
} catch (UnexpectedResultException ex) {
root.arguments0Type_ = 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(BindNode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(BindNodeGen root) {
super(root, 2147483647);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value) {
return (int) uninitialized(frameValue, arguments0Value, arguments1Value, arguments2Value);
}
static BaseNode_ create(BindNodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(BindNode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(BindNodeGen 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 int executeInt(VirtualFrame frameValue) {
Object arguments0Value_ = executeArguments0_(frameValue);
Object arguments1Value_ = root.arguments1_.execute(frameValue);
Object arguments2Value_ = executeArguments2_(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value) {
return getNext().executeInt_(frameValue, arguments0Value, arguments1Value, arguments2Value);
}
static BaseNode_ create(BindNodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "bind(int, DynamicObject, int)", value = BindNode.class)
private static final class BindNode_ extends BaseNode_ {
private final Class arguments0ImplicitType;
private final Class arguments2ImplicitType;
BindNode_(BindNodeGen root, Object arguments0Value, Object arguments2Value) {
super(root, 1);
this.arguments0ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments0Value);
this.arguments2ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments2Value);
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.arguments0ImplicitType == ((BindNode_) other).arguments0ImplicitType && this.arguments2ImplicitType == ((BindNode_) other).arguments2ImplicitType;
}
@Override
public Object execute(VirtualFrame frameValue) {
return executeInt(frameValue);
}
@Override
public int executeInt(VirtualFrame frameValue) {
int arguments0Value_;
try {
if (arguments0ImplicitType == int.class) {
arguments0Value_ = root.arguments0_.executeInteger(frameValue);
} else {
Object arguments0Value__ = executeArguments0_(frameValue);
arguments0Value_ = RubyTypesGen.expectImplicitInteger(arguments0Value__, arguments0ImplicitType);
}
} catch (UnexpectedResultException ex) {
Object arguments1Value = root.arguments1_.execute(frameValue);
Object arguments2Value = executeArguments2_(frameValue);
return getNext().executeInt_(frameValue, ex.getResult(), arguments1Value, arguments2Value);
}
DynamicObject arguments1Value_;
try {
arguments1Value_ = root.arguments1_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object arguments2Value = executeArguments2_(frameValue);
return getNext().executeInt_(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().executeInt_(frameValue, arguments0Value_, arguments1Value_, ex.getResult());
}
if ((RubyGuards.isRubyPointer(arguments1Value_))) {
return root.bind(arguments0Value_, arguments1Value_, arguments2Value_);
}
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value) {
if (RubyTypesGen.isImplicitInteger(arguments0Value, arguments0ImplicitType) && arguments1Value instanceof DynamicObject && RubyTypesGen.isImplicitInteger(arguments2Value, arguments2ImplicitType)) {
int arguments0Value_ = RubyTypesGen.asImplicitInteger(arguments0Value, arguments0ImplicitType);
DynamicObject arguments1Value_ = (DynamicObject) arguments1Value;
int arguments2Value_ = RubyTypesGen.asImplicitInteger(arguments2Value, arguments2ImplicitType);
if ((RubyGuards.isRubyPointer(arguments1Value_))) {
return root.bind(arguments0Value_, arguments1Value_, arguments2Value_);
}
}
return getNext().executeInt_(frameValue, arguments0Value, arguments1Value, arguments2Value);
}
static BaseNode_ create(BindNodeGen root, Object arguments0Value, Object arguments2Value) {
return new BindNode_(root, arguments0Value, arguments2Value);
}
}
}
}
@GeneratedBy(ListenNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class ListenNodeFactory implements NodeFactory {
private static ListenNodeFactory listenNodeFactoryInstance;
private ListenNodeFactory() {
}
@Override
public Class getNodeClass() {
return ListenNode.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 ListenNode 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 (listenNodeFactoryInstance == null) {
listenNodeFactoryInstance = new ListenNodeFactory();
}
return listenNodeFactoryInstance;
}
public static ListenNode create(RubyNode[] arguments) {
return new ListenNodeGen(arguments);
}
@GeneratedBy(ListenNode.class)
public static final class ListenNodeGen extends ListenNode implements SpecializedNode {
@Child private RubyNode arguments0_;
@Child private RubyNode arguments1_;
@CompilationFinal private Class arguments0Type_;
@CompilationFinal private Class arguments1Type_;
@Child private BaseNode_ specialization_;
private ListenNodeGen(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) {
return specialization_.executeInt(frameValue);
}
@Override
public SpecializationNode getSpecializationNode() {
return specialization_;
}
@Override
public Node deepCopy() {
return SpecializationNode.updateRoot(super.deepCopy());
}
@GeneratedBy(ListenNode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected ListenNodeGen root;
BaseNode_(ListenNodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (ListenNodeGen) 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.executeInt_((VirtualFrame) frameValue, arguments0Value, arguments1Value);
}
public abstract int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value);
public Object execute(VirtualFrame frameValue) {
Object arguments0Value_ = executeArguments0_(frameValue);
Object arguments1Value_ = executeArguments1_(frameValue);
return executeInt_(frameValue, arguments0Value_, arguments1Value_);
}
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, Object arguments1Value) {
if (RubyTypesGen.isImplicitInteger(arguments0Value) && RubyTypesGen.isImplicitInteger(arguments1Value)) {
return ListenNode_.create(root, arguments0Value, arguments1Value);
}
return null;
}
@Override
protected final SpecializationNode createPolymorphic() {
return PolymorphicNode_.create(root);
}
protected final BaseNode_ getNext() {
return (BaseNode_) this.next;
}
protected final Object executeArguments0_(Frame frameValue) {
Class arguments0Type_ = root.arguments0Type_;
try {
if (arguments0Type_ == int.class) {
return root.arguments0_.executeInteger((VirtualFrame) frameValue);
} else if (arguments0Type_ == null) {
CompilerDirectives.transferToInterpreterAndInvalidate();
Class _type = Object.class;
try {
Object _value = root.arguments0_.execute((VirtualFrame) frameValue);
if (_value instanceof Integer) {
_type = int.class;
} else {
_type = Object.class;
}
return _value;
} finally {
root.arguments0Type_ = _type;
}
} else {
return root.arguments0_.execute((VirtualFrame) frameValue);
}
} catch (UnexpectedResultException ex) {
root.arguments0Type_ = Object.class;
return ex.getResult();
}
}
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();
}
}
}
@GeneratedBy(ListenNode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(ListenNodeGen root) {
super(root, 2147483647);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value) {
return (int) uninitialized(frameValue, arguments0Value, arguments1Value);
}
static BaseNode_ create(ListenNodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(ListenNode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(ListenNodeGen 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 int executeInt(VirtualFrame frameValue) {
Object arguments0Value_ = executeArguments0_(frameValue);
Object arguments1Value_ = executeArguments1_(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value) {
return getNext().executeInt_(frameValue, arguments0Value, arguments1Value);
}
static BaseNode_ create(ListenNodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "listen(int, int)", value = ListenNode.class)
private static final class ListenNode_ extends BaseNode_ {
private final Class arguments0ImplicitType;
private final Class arguments1ImplicitType;
ListenNode_(ListenNodeGen root, Object arguments0Value, Object arguments1Value) {
super(root, 1);
this.arguments0ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments0Value);
this.arguments1ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments1Value);
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.arguments0ImplicitType == ((ListenNode_) other).arguments0ImplicitType && this.arguments1ImplicitType == ((ListenNode_) other).arguments1ImplicitType;
}
@Override
public Object execute(VirtualFrame frameValue) {
return executeInt(frameValue);
}
@Override
public int executeInt(VirtualFrame frameValue) {
int arguments0Value_;
try {
if (arguments0ImplicitType == int.class) {
arguments0Value_ = root.arguments0_.executeInteger(frameValue);
} else {
Object arguments0Value__ = executeArguments0_(frameValue);
arguments0Value_ = RubyTypesGen.expectImplicitInteger(arguments0Value__, arguments0ImplicitType);
}
} catch (UnexpectedResultException ex) {
Object arguments1Value = executeArguments1_(frameValue);
return getNext().executeInt_(frameValue, ex.getResult(), arguments1Value);
}
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) {
return getNext().executeInt_(frameValue, arguments0Value_, ex.getResult());
}
return root.listen(arguments0Value_, arguments1Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value) {
if (RubyTypesGen.isImplicitInteger(arguments0Value, arguments0ImplicitType) && RubyTypesGen.isImplicitInteger(arguments1Value, arguments1ImplicitType)) {
int arguments0Value_ = RubyTypesGen.asImplicitInteger(arguments0Value, arguments0ImplicitType);
int arguments1Value_ = RubyTypesGen.asImplicitInteger(arguments1Value, arguments1ImplicitType);
return root.listen(arguments0Value_, arguments1Value_);
}
return getNext().executeInt_(frameValue, arguments0Value, arguments1Value);
}
static BaseNode_ create(ListenNodeGen root, Object arguments0Value, Object arguments1Value) {
return new ListenNode_(root, arguments0Value, arguments1Value);
}
}
}
}
@GeneratedBy(GetHostNameNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class GetHostNameNodeFactory implements NodeFactory {
private static GetHostNameNodeFactory getHostNameNodeFactoryInstance;
private GetHostNameNodeFactory() {
}
@Override
public Class getNodeClass() {
return GetHostNameNode.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 GetHostNameNode 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 (getHostNameNodeFactoryInstance == null) {
getHostNameNodeFactoryInstance = new GetHostNameNodeFactory();
}
return getHostNameNodeFactoryInstance;
}
public static GetHostNameNode create(RubyNode[] arguments) {
return new GetHostNameNodeGen(arguments);
}
@GeneratedBy(GetHostNameNode.class)
public static final class GetHostNameNodeGen extends GetHostNameNode implements SpecializedNode {
@Child private RubyNode arguments0_;
@Child private RubyNode arguments1_;
@CompilationFinal private Class arguments1Type_;
@Child private BaseNode_ specialization_;
private GetHostNameNodeGen(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) {
return specialization_.executeInt(frameValue);
}
@Override
public SpecializationNode getSpecializationNode() {
return specialization_;
}
@Override
public Node deepCopy() {
return SpecializationNode.updateRoot(super.deepCopy());
}
@GeneratedBy(GetHostNameNode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected GetHostNameNodeGen root;
BaseNode_(GetHostNameNodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (GetHostNameNodeGen) 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.executeInt_((VirtualFrame) frameValue, arguments0Value, arguments1Value);
}
public abstract int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value);
public Object execute(VirtualFrame frameValue) {
Object arguments0Value_ = root.arguments0_.execute(frameValue);
Object arguments1Value_ = executeArguments1_(frameValue);
return executeInt_(frameValue, arguments0Value_, arguments1Value_);
}
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, Object arguments1Value) {
if (arguments0Value instanceof DynamicObject && RubyTypesGen.isImplicitInteger(arguments1Value)) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
if ((RubyGuards.isRubyPointer(arguments0Value_))) {
return GetHostNameNode_.create(root, arguments1Value);
}
}
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();
}
}
}
@GeneratedBy(GetHostNameNode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(GetHostNameNodeGen root) {
super(root, 2147483647);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value) {
return (int) uninitialized(frameValue, arguments0Value, arguments1Value);
}
static BaseNode_ create(GetHostNameNodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(GetHostNameNode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(GetHostNameNodeGen 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 int executeInt(VirtualFrame frameValue) {
Object arguments0Value_ = root.arguments0_.execute(frameValue);
Object arguments1Value_ = executeArguments1_(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value) {
return getNext().executeInt_(frameValue, arguments0Value, arguments1Value);
}
static BaseNode_ create(GetHostNameNodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "getHostName(DynamicObject, int)", value = GetHostNameNode.class)
private static final class GetHostNameNode_ extends BaseNode_ {
private final Class arguments1ImplicitType;
GetHostNameNode_(GetHostNameNodeGen root, Object arguments1Value) {
super(root, 1);
this.arguments1ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments1Value);
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.arguments1ImplicitType == ((GetHostNameNode_) other).arguments1ImplicitType;
}
@Override
public Object execute(VirtualFrame frameValue) {
return executeInt(frameValue);
}
@Override
public int executeInt(VirtualFrame frameValue) {
DynamicObject arguments0Value_;
try {
arguments0Value_ = root.arguments0_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object arguments1Value = executeArguments1_(frameValue);
return getNext().executeInt_(frameValue, ex.getResult(), arguments1Value);
}
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) {
return getNext().executeInt_(frameValue, arguments0Value_, ex.getResult());
}
if ((RubyGuards.isRubyPointer(arguments0Value_))) {
return root.getHostName(arguments0Value_, arguments1Value_);
}
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value) {
if (arguments0Value instanceof DynamicObject && RubyTypesGen.isImplicitInteger(arguments1Value, arguments1ImplicitType)) {
DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
int arguments1Value_ = RubyTypesGen.asImplicitInteger(arguments1Value, arguments1ImplicitType);
if ((RubyGuards.isRubyPointer(arguments0Value_))) {
return root.getHostName(arguments0Value_, arguments1Value_);
}
}
return getNext().executeInt_(frameValue, arguments0Value, arguments1Value);
}
static BaseNode_ create(GetHostNameNodeGen root, Object arguments1Value) {
return new GetHostNameNode_(root, arguments1Value);
}
}
}
}
@GeneratedBy(GetPeerNameNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class GetPeerNameNodeFactory implements NodeFactory {
private static GetPeerNameNodeFactory getPeerNameNodeFactoryInstance;
private GetPeerNameNodeFactory() {
}
@Override
public Class getNodeClass() {
return GetPeerNameNode.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 GetPeerNameNode 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 (getPeerNameNodeFactoryInstance == null) {
getPeerNameNodeFactoryInstance = new GetPeerNameNodeFactory();
}
return getPeerNameNodeFactoryInstance;
}
public static GetPeerNameNode create(RubyNode[] arguments) {
return new GetPeerNameNodeGen(arguments);
}
@GeneratedBy(GetPeerNameNode.class)
public static final class GetPeerNameNodeGen extends GetPeerNameNode implements SpecializedNode {
@Child private RubyNode arguments0_;
@Child private RubyNode arguments1_;
@Child private RubyNode arguments2_;
@CompilationFinal private Class arguments0Type_;
@Child private BaseNode_ specialization_;
private GetPeerNameNodeGen(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 int executeInteger(VirtualFrame frameValue) {
return specialization_.executeInt(frameValue);
}
@Override
public SpecializationNode getSpecializationNode() {
return specialization_;
}
@Override
public Node deepCopy() {
return SpecializationNode.updateRoot(super.deepCopy());
}
@GeneratedBy(GetPeerNameNode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected GetPeerNameNodeGen root;
BaseNode_(GetPeerNameNodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (GetPeerNameNodeGen) 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.executeInt_((VirtualFrame) frameValue, arguments0Value, arguments1Value, arguments2Value);
}
public abstract int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value);
public Object execute(VirtualFrame frameValue) {
Object arguments0Value_ = executeArguments0_(frameValue);
Object arguments1Value_ = root.arguments1_.execute(frameValue);
Object arguments2Value_ = root.arguments2_.execute(frameValue);
return executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_);
}
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, Object arguments1Value, Object arguments2Value) {
if (RubyTypesGen.isImplicitInteger(arguments0Value) && arguments1Value instanceof DynamicObject && arguments2Value instanceof DynamicObject) {
DynamicObject arguments1Value_ = (DynamicObject) arguments1Value;
DynamicObject arguments2Value_ = (DynamicObject) arguments2Value;
if ((RubyGuards.isRubyPointer(arguments1Value_)) && (RubyGuards.isRubyPointer(arguments2Value_))) {
return GetPeerNameNode_.create(root, arguments0Value);
}
}
return null;
}
@Override
protected final SpecializationNode createPolymorphic() {
return PolymorphicNode_.create(root);
}
protected final BaseNode_ getNext() {
return (BaseNode_) this.next;
}
protected final Object executeArguments0_(Frame frameValue) {
Class arguments0Type_ = root.arguments0Type_;
try {
if (arguments0Type_ == int.class) {
return root.arguments0_.executeInteger((VirtualFrame) frameValue);
} else if (arguments0Type_ == null) {
CompilerDirectives.transferToInterpreterAndInvalidate();
Class _type = Object.class;
try {
Object _value = root.arguments0_.execute((VirtualFrame) frameValue);
if (_value instanceof Integer) {
_type = int.class;
} else {
_type = Object.class;
}
return _value;
} finally {
root.arguments0Type_ = _type;
}
} else {
return root.arguments0_.execute((VirtualFrame) frameValue);
}
} catch (UnexpectedResultException ex) {
root.arguments0Type_ = Object.class;
return ex.getResult();
}
}
}
@GeneratedBy(GetPeerNameNode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(GetPeerNameNodeGen root) {
super(root, 2147483647);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value) {
return (int) uninitialized(frameValue, arguments0Value, arguments1Value, arguments2Value);
}
static BaseNode_ create(GetPeerNameNodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(GetPeerNameNode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(GetPeerNameNodeGen 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 int executeInt(VirtualFrame frameValue) {
Object arguments0Value_ = executeArguments0_(frameValue);
Object arguments1Value_ = root.arguments1_.execute(frameValue);
Object arguments2Value_ = root.arguments2_.execute(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value) {
return getNext().executeInt_(frameValue, arguments0Value, arguments1Value, arguments2Value);
}
static BaseNode_ create(GetPeerNameNodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "getPeerName(int, DynamicObject, DynamicObject)", value = GetPeerNameNode.class)
private static final class GetPeerNameNode_ extends BaseNode_ {
private final Class arguments0ImplicitType;
GetPeerNameNode_(GetPeerNameNodeGen root, Object arguments0Value) {
super(root, 1);
this.arguments0ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments0Value);
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.arguments0ImplicitType == ((GetPeerNameNode_) other).arguments0ImplicitType;
}
@Override
public Object execute(VirtualFrame frameValue) {
return executeInt(frameValue);
}
@Override
public int executeInt(VirtualFrame frameValue) {
int arguments0Value_;
try {
if (arguments0ImplicitType == int.class) {
arguments0Value_ = root.arguments0_.executeInteger(frameValue);
} else {
Object arguments0Value__ = executeArguments0_(frameValue);
arguments0Value_ = RubyTypesGen.expectImplicitInteger(arguments0Value__, arguments0ImplicitType);
}
} catch (UnexpectedResultException ex) {
Object arguments1Value = root.arguments1_.execute(frameValue);
Object arguments2Value = root.arguments2_.execute(frameValue);
return getNext().executeInt_(frameValue, ex.getResult(), arguments1Value, arguments2Value);
}
DynamicObject arguments1Value_;
try {
arguments1Value_ = root.arguments1_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object arguments2Value = root.arguments2_.execute(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_, ex.getResult(), arguments2Value);
}
DynamicObject arguments2Value_;
try {
arguments2Value_ = root.arguments2_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_, ex.getResult());
}
if ((RubyGuards.isRubyPointer(arguments1Value_)) && (RubyGuards.isRubyPointer(arguments2Value_))) {
return root.getPeerName(arguments0Value_, arguments1Value_, arguments2Value_);
}
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value) {
if (RubyTypesGen.isImplicitInteger(arguments0Value, arguments0ImplicitType) && arguments1Value instanceof DynamicObject && arguments2Value instanceof DynamicObject) {
int arguments0Value_ = RubyTypesGen.asImplicitInteger(arguments0Value, arguments0ImplicitType);
DynamicObject arguments1Value_ = (DynamicObject) arguments1Value;
DynamicObject arguments2Value_ = (DynamicObject) arguments2Value;
if ((RubyGuards.isRubyPointer(arguments1Value_)) && (RubyGuards.isRubyPointer(arguments2Value_))) {
return root.getPeerName(arguments0Value_, arguments1Value_, arguments2Value_);
}
}
return getNext().executeInt_(frameValue, arguments0Value, arguments1Value, arguments2Value);
}
static BaseNode_ create(GetPeerNameNodeGen root, Object arguments0Value) {
return new GetPeerNameNode_(root, arguments0Value);
}
}
}
}
@GeneratedBy(GetSockNameNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class GetSockNameNodeFactory implements NodeFactory {
private static GetSockNameNodeFactory getSockNameNodeFactoryInstance;
private GetSockNameNodeFactory() {
}
@Override
public Class getNodeClass() {
return GetSockNameNode.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 GetSockNameNode 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 (getSockNameNodeFactoryInstance == null) {
getSockNameNodeFactoryInstance = new GetSockNameNodeFactory();
}
return getSockNameNodeFactoryInstance;
}
public static GetSockNameNode create(RubyNode[] arguments) {
return new GetSockNameNodeGen(arguments);
}
@GeneratedBy(GetSockNameNode.class)
public static final class GetSockNameNodeGen extends GetSockNameNode implements SpecializedNode {
@Child private RubyNode arguments0_;
@Child private RubyNode arguments1_;
@Child private RubyNode arguments2_;
@CompilationFinal private Class arguments0Type_;
@Child private BaseNode_ specialization_;
private GetSockNameNodeGen(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 int executeInteger(VirtualFrame frameValue) {
return specialization_.executeInt(frameValue);
}
@Override
public SpecializationNode getSpecializationNode() {
return specialization_;
}
@Override
public Node deepCopy() {
return SpecializationNode.updateRoot(super.deepCopy());
}
@GeneratedBy(GetSockNameNode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected GetSockNameNodeGen root;
BaseNode_(GetSockNameNodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (GetSockNameNodeGen) 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.executeInt_((VirtualFrame) frameValue, arguments0Value, arguments1Value, arguments2Value);
}
public abstract int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value);
public Object execute(VirtualFrame frameValue) {
Object arguments0Value_ = executeArguments0_(frameValue);
Object arguments1Value_ = root.arguments1_.execute(frameValue);
Object arguments2Value_ = root.arguments2_.execute(frameValue);
return executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_);
}
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, Object arguments1Value, Object arguments2Value) {
if (RubyTypesGen.isImplicitInteger(arguments0Value) && arguments1Value instanceof DynamicObject && arguments2Value instanceof DynamicObject) {
DynamicObject arguments1Value_ = (DynamicObject) arguments1Value;
DynamicObject arguments2Value_ = (DynamicObject) arguments2Value;
if ((RubyGuards.isRubyPointer(arguments1Value_)) && (RubyGuards.isRubyPointer(arguments2Value_))) {
return GetSockNameNode_.create(root, arguments0Value);
}
}
return null;
}
@Override
protected final SpecializationNode createPolymorphic() {
return PolymorphicNode_.create(root);
}
protected final BaseNode_ getNext() {
return (BaseNode_) this.next;
}
protected final Object executeArguments0_(Frame frameValue) {
Class arguments0Type_ = root.arguments0Type_;
try {
if (arguments0Type_ == int.class) {
return root.arguments0_.executeInteger((VirtualFrame) frameValue);
} else if (arguments0Type_ == null) {
CompilerDirectives.transferToInterpreterAndInvalidate();
Class _type = Object.class;
try {
Object _value = root.arguments0_.execute((VirtualFrame) frameValue);
if (_value instanceof Integer) {
_type = int.class;
} else {
_type = Object.class;
}
return _value;
} finally {
root.arguments0Type_ = _type;
}
} else {
return root.arguments0_.execute((VirtualFrame) frameValue);
}
} catch (UnexpectedResultException ex) {
root.arguments0Type_ = Object.class;
return ex.getResult();
}
}
}
@GeneratedBy(GetSockNameNode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(GetSockNameNodeGen root) {
super(root, 2147483647);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value) {
return (int) uninitialized(frameValue, arguments0Value, arguments1Value, arguments2Value);
}
static BaseNode_ create(GetSockNameNodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(GetSockNameNode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(GetSockNameNodeGen 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 int executeInt(VirtualFrame frameValue) {
Object arguments0Value_ = executeArguments0_(frameValue);
Object arguments1Value_ = root.arguments1_.execute(frameValue);
Object arguments2Value_ = root.arguments2_.execute(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value) {
return getNext().executeInt_(frameValue, arguments0Value, arguments1Value, arguments2Value);
}
static BaseNode_ create(GetSockNameNodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "getSockName(int, DynamicObject, DynamicObject)", value = GetSockNameNode.class)
private static final class GetSockNameNode_ extends BaseNode_ {
private final Class arguments0ImplicitType;
GetSockNameNode_(GetSockNameNodeGen root, Object arguments0Value) {
super(root, 1);
this.arguments0ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments0Value);
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.arguments0ImplicitType == ((GetSockNameNode_) other).arguments0ImplicitType;
}
@Override
public Object execute(VirtualFrame frameValue) {
return executeInt(frameValue);
}
@Override
public int executeInt(VirtualFrame frameValue) {
int arguments0Value_;
try {
if (arguments0ImplicitType == int.class) {
arguments0Value_ = root.arguments0_.executeInteger(frameValue);
} else {
Object arguments0Value__ = executeArguments0_(frameValue);
arguments0Value_ = RubyTypesGen.expectImplicitInteger(arguments0Value__, arguments0ImplicitType);
}
} catch (UnexpectedResultException ex) {
Object arguments1Value = root.arguments1_.execute(frameValue);
Object arguments2Value = root.arguments2_.execute(frameValue);
return getNext().executeInt_(frameValue, ex.getResult(), arguments1Value, arguments2Value);
}
DynamicObject arguments1Value_;
try {
arguments1Value_ = root.arguments1_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object arguments2Value = root.arguments2_.execute(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_, ex.getResult(), arguments2Value);
}
DynamicObject arguments2Value_;
try {
arguments2Value_ = root.arguments2_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_, ex.getResult());
}
if ((RubyGuards.isRubyPointer(arguments1Value_)) && (RubyGuards.isRubyPointer(arguments2Value_))) {
return root.getSockName(arguments0Value_, arguments1Value_, arguments2Value_);
}
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value) {
if (RubyTypesGen.isImplicitInteger(arguments0Value, arguments0ImplicitType) && arguments1Value instanceof DynamicObject && arguments2Value instanceof DynamicObject) {
int arguments0Value_ = RubyTypesGen.asImplicitInteger(arguments0Value, arguments0ImplicitType);
DynamicObject arguments1Value_ = (DynamicObject) arguments1Value;
DynamicObject arguments2Value_ = (DynamicObject) arguments2Value;
if ((RubyGuards.isRubyPointer(arguments1Value_)) && (RubyGuards.isRubyPointer(arguments2Value_))) {
return root.getSockName(arguments0Value_, arguments1Value_, arguments2Value_);
}
}
return getNext().executeInt_(frameValue, arguments0Value, arguments1Value, arguments2Value);
}
static BaseNode_ create(GetSockNameNodeGen root, Object arguments0Value) {
return new GetSockNameNode_(root, arguments0Value);
}
}
}
}
@GeneratedBy(GetSockOptNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class GetSockOptNodeFactory implements NodeFactory {
private static GetSockOptNodeFactory getSockOptNodeFactoryInstance;
private GetSockOptNodeFactory() {
}
@Override
public Class getNodeClass() {
return GetSockOptNode.class;
}
@Override
public List getExecutionSignature() {
return Arrays.asList(RubyNode.class, RubyNode.class, RubyNode.class, RubyNode.class, RubyNode.class);
}
@Override
public List getNodeSignatures() {
return Arrays.asList(Arrays.asList(RubyNode[].class));
}
@Override
public GetSockOptNode 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 (getSockOptNodeFactoryInstance == null) {
getSockOptNodeFactoryInstance = new GetSockOptNodeFactory();
}
return getSockOptNodeFactoryInstance;
}
public static GetSockOptNode create(RubyNode[] arguments) {
return new GetSockOptNodeGen(arguments);
}
@GeneratedBy(GetSockOptNode.class)
public static final class GetSockOptNodeGen extends GetSockOptNode implements SpecializedNode {
@Child private RubyNode arguments0_;
@Child private RubyNode arguments1_;
@Child private RubyNode arguments2_;
@Child private RubyNode arguments3_;
@Child private RubyNode arguments4_;
@CompilationFinal private Class arguments0Type_;
@CompilationFinal private Class arguments1Type_;
@CompilationFinal private Class arguments2Type_;
@Child private BaseNode_ specialization_;
private GetSockOptNodeGen(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.arguments3_ = arguments != null && 3 < arguments.length ? arguments[3] : null;
this.arguments4_ = arguments != null && 4 < arguments.length ? arguments[4] : 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(GetSockOptNode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected GetSockOptNodeGen root;
BaseNode_(GetSockOptNodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (GetSockOptNodeGen) root;
}
@Override
protected final Node[] getSuppliedChildren() {
return new Node[] {root.arguments0_, root.arguments1_, root.arguments2_, root.arguments3_, root.arguments4_};
}
@Override
public final Object acceptAndExecute(Frame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value, Object arguments3Value, Object arguments4Value) {
return this.executeInt_((VirtualFrame) frameValue, arguments0Value, arguments1Value, arguments2Value, arguments3Value, arguments4Value);
}
public abstract int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value, Object arguments3Value, Object arguments4Value);
public Object execute(VirtualFrame frameValue) {
Object arguments0Value_ = executeArguments0_(frameValue);
Object arguments1Value_ = executeArguments1_(frameValue);
Object arguments2Value_ = executeArguments2_(frameValue);
Object arguments3Value_ = root.arguments3_.execute(frameValue);
Object arguments4Value_ = root.arguments4_.execute(frameValue);
return executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_, arguments3Value_, arguments4Value_);
}
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, Object arguments1Value, Object arguments2Value, Object arguments3Value, Object arguments4Value) {
if (RubyTypesGen.isImplicitInteger(arguments0Value) && arguments3Value instanceof DynamicObject && arguments4Value instanceof DynamicObject) {
DynamicObject arguments3Value_ = (DynamicObject) arguments3Value;
DynamicObject arguments4Value_ = (DynamicObject) arguments4Value;
if (RubyTypesGen.isImplicitInteger(arguments1Value) && RubyTypesGen.isImplicitInteger(arguments2Value)) {
if ((RubyGuards.isRubyPointer(arguments3Value_)) && (RubyGuards.isRubyPointer(arguments4Value_))) {
return GetSockOptionsNode_.create(root, arguments0Value, arguments1Value, arguments2Value);
}
}
if (arguments1Value instanceof DynamicObject && arguments2Value instanceof DynamicObject) {
DynamicObject arguments1Value_ = (DynamicObject) arguments1Value;
DynamicObject arguments2Value_ = (DynamicObject) arguments2Value;
if ((RubyGuards.isRubySymbol(arguments1Value_)) && (RubyGuards.isRubySymbol(arguments2Value_)) && (RubyGuards.isRubyPointer(arguments3Value_)) && (RubyGuards.isRubyPointer(arguments4Value_))) {
SnippetNode snippetNode2 = (new SnippetNode());
return GetSockOptionsSymbolsNode_.create(root, arguments0Value, snippetNode2);
}
}
}
return null;
}
@Override
protected final SpecializationNode createPolymorphic() {
return PolymorphicNode_.create(root);
}
protected final BaseNode_ getNext() {
return (BaseNode_) this.next;
}
protected final Object executeArguments0_(Frame frameValue) {
Class arguments0Type_ = root.arguments0Type_;
try {
if (arguments0Type_ == int.class) {
return root.arguments0_.executeInteger((VirtualFrame) frameValue);
} else if (arguments0Type_ == null) {
CompilerDirectives.transferToInterpreterAndInvalidate();
Class _type = Object.class;
try {
Object _value = root.arguments0_.execute((VirtualFrame) frameValue);
if (_value instanceof Integer) {
_type = int.class;
} else {
_type = Object.class;
}
return _value;
} finally {
root.arguments0Type_ = _type;
}
} else {
return root.arguments0_.execute((VirtualFrame) frameValue);
}
} catch (UnexpectedResultException ex) {
root.arguments0Type_ = Object.class;
return ex.getResult();
}
}
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(GetSockOptNode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(GetSockOptNodeGen root) {
super(root, 2147483647);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value, Object arguments3Value, Object arguments4Value) {
return (int) uninitialized(frameValue, arguments0Value, arguments1Value, arguments2Value, arguments3Value, arguments4Value);
}
static BaseNode_ create(GetSockOptNodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(GetSockOptNode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(GetSockOptNodeGen root) {
super(root, 0);
}
@Override
public SpecializationNode merge(SpecializationNode newNode, Frame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value, Object arguments3Value, Object arguments4Value) {
return polymorphicMerge(newNode, super.merge(newNode, frameValue, arguments0Value, arguments1Value, arguments2Value, arguments3Value, arguments4Value));
}
@Override
public int executeInt(VirtualFrame frameValue) {
Object arguments0Value_ = executeArguments0_(frameValue);
Object arguments1Value_ = executeArguments1_(frameValue);
Object arguments2Value_ = executeArguments2_(frameValue);
Object arguments3Value_ = root.arguments3_.execute(frameValue);
Object arguments4Value_ = root.arguments4_.execute(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_, arguments3Value_, arguments4Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value, Object arguments3Value, Object arguments4Value) {
return getNext().executeInt_(frameValue, arguments0Value, arguments1Value, arguments2Value, arguments3Value, arguments4Value);
}
static BaseNode_ create(GetSockOptNodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "getSockOptions(int, int, int, DynamicObject, DynamicObject)", value = GetSockOptNode.class)
private static final class GetSockOptionsNode_ extends BaseNode_ {
private final Class arguments0ImplicitType;
private final Class arguments1ImplicitType;
private final Class arguments2ImplicitType;
GetSockOptionsNode_(GetSockOptNodeGen root, Object arguments0Value, Object arguments1Value, Object arguments2Value) {
super(root, 1);
this.arguments0ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments0Value);
this.arguments1ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments1Value);
this.arguments2ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments2Value);
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.arguments0ImplicitType == ((GetSockOptionsNode_) other).arguments0ImplicitType && this.arguments1ImplicitType == ((GetSockOptionsNode_) other).arguments1ImplicitType && this.arguments2ImplicitType == ((GetSockOptionsNode_) other).arguments2ImplicitType;
}
@Override
public Object execute(VirtualFrame frameValue) {
return executeInt(frameValue);
}
@Override
public int executeInt(VirtualFrame frameValue) {
int arguments0Value_;
try {
if (arguments0ImplicitType == int.class) {
arguments0Value_ = root.arguments0_.executeInteger(frameValue);
} else {
Object arguments0Value__ = executeArguments0_(frameValue);
arguments0Value_ = RubyTypesGen.expectImplicitInteger(arguments0Value__, arguments0ImplicitType);
}
} catch (UnexpectedResultException ex) {
Object arguments1Value = executeArguments1_(frameValue);
Object arguments2Value = executeArguments2_(frameValue);
Object arguments3Value = root.arguments3_.execute(frameValue);
Object arguments4Value = root.arguments4_.execute(frameValue);
return getNext().executeInt_(frameValue, ex.getResult(), arguments1Value, arguments2Value, arguments3Value, arguments4Value);
}
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);
Object arguments3Value = root.arguments3_.execute(frameValue);
Object arguments4Value = root.arguments4_.execute(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_, ex.getResult(), arguments2Value, arguments3Value, arguments4Value);
}
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) {
Object arguments3Value = root.arguments3_.execute(frameValue);
Object arguments4Value = root.arguments4_.execute(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_, ex.getResult(), arguments3Value, arguments4Value);
}
DynamicObject arguments3Value_;
try {
arguments3Value_ = root.arguments3_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object arguments4Value = root.arguments4_.execute(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_, ex.getResult(), arguments4Value);
}
DynamicObject arguments4Value_;
try {
arguments4Value_ = root.arguments4_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_, arguments3Value_, ex.getResult());
}
if ((RubyGuards.isRubyPointer(arguments3Value_)) && (RubyGuards.isRubyPointer(arguments4Value_))) {
return root.getSockOptions(arguments0Value_, arguments1Value_, arguments2Value_, arguments3Value_, arguments4Value_);
}
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_, arguments3Value_, arguments4Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value, Object arguments3Value, Object arguments4Value) {
if (RubyTypesGen.isImplicitInteger(arguments0Value, arguments0ImplicitType) && RubyTypesGen.isImplicitInteger(arguments1Value, arguments1ImplicitType) && RubyTypesGen.isImplicitInteger(arguments2Value, arguments2ImplicitType) && arguments3Value instanceof DynamicObject && arguments4Value instanceof DynamicObject) {
int arguments0Value_ = RubyTypesGen.asImplicitInteger(arguments0Value, arguments0ImplicitType);
int arguments1Value_ = RubyTypesGen.asImplicitInteger(arguments1Value, arguments1ImplicitType);
int arguments2Value_ = RubyTypesGen.asImplicitInteger(arguments2Value, arguments2ImplicitType);
DynamicObject arguments3Value_ = (DynamicObject) arguments3Value;
DynamicObject arguments4Value_ = (DynamicObject) arguments4Value;
if ((RubyGuards.isRubyPointer(arguments3Value_)) && (RubyGuards.isRubyPointer(arguments4Value_))) {
return root.getSockOptions(arguments0Value_, arguments1Value_, arguments2Value_, arguments3Value_, arguments4Value_);
}
}
return getNext().executeInt_(frameValue, arguments0Value, arguments1Value, arguments2Value, arguments3Value, arguments4Value);
}
static BaseNode_ create(GetSockOptNodeGen root, Object arguments0Value, Object arguments1Value, Object arguments2Value) {
return new GetSockOptionsNode_(root, arguments0Value, arguments1Value, arguments2Value);
}
}
@GeneratedBy(methodName = "getSockOptionsSymbols(VirtualFrame, int, DynamicObject, DynamicObject, DynamicObject, DynamicObject, SnippetNode)", value = GetSockOptNode.class)
private static final class GetSockOptionsSymbolsNode_ extends BaseNode_ {
@Child private SnippetNode snippetNode;
private final Class arguments0ImplicitType;
GetSockOptionsSymbolsNode_(GetSockOptNodeGen root, Object arguments0Value, SnippetNode snippetNode) {
super(root, 2);
this.arguments0ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments0Value);
this.snippetNode = snippetNode;
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.arguments0ImplicitType == ((GetSockOptionsSymbolsNode_) other).arguments0ImplicitType;
}
@Override
public Object execute(VirtualFrame frameValue) {
return executeInt(frameValue);
}
@Override
public int executeInt(VirtualFrame frameValue) {
int arguments0Value_;
try {
if (arguments0ImplicitType == int.class) {
arguments0Value_ = root.arguments0_.executeInteger(frameValue);
} else {
Object arguments0Value__ = executeArguments0_(frameValue);
arguments0Value_ = RubyTypesGen.expectImplicitInteger(arguments0Value__, arguments0ImplicitType);
}
} catch (UnexpectedResultException ex) {
Object arguments1Value = executeArguments1_(frameValue);
Object arguments2Value = executeArguments2_(frameValue);
Object arguments3Value = root.arguments3_.execute(frameValue);
Object arguments4Value = root.arguments4_.execute(frameValue);
return getNext().executeInt_(frameValue, ex.getResult(), arguments1Value, arguments2Value, arguments3Value, arguments4Value);
}
DynamicObject arguments1Value_;
try {
arguments1Value_ = root.arguments1_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object arguments2Value = executeArguments2_(frameValue);
Object arguments3Value = root.arguments3_.execute(frameValue);
Object arguments4Value = root.arguments4_.execute(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_, ex.getResult(), arguments2Value, arguments3Value, arguments4Value);
}
DynamicObject arguments2Value_;
try {
arguments2Value_ = root.arguments2_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object arguments3Value = root.arguments3_.execute(frameValue);
Object arguments4Value = root.arguments4_.execute(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_, ex.getResult(), arguments3Value, arguments4Value);
}
DynamicObject arguments3Value_;
try {
arguments3Value_ = root.arguments3_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
Object arguments4Value = root.arguments4_.execute(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_, ex.getResult(), arguments4Value);
}
DynamicObject arguments4Value_;
try {
arguments4Value_ = root.arguments4_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_, arguments3Value_, ex.getResult());
}
if ((RubyGuards.isRubySymbol(arguments1Value_)) && (RubyGuards.isRubySymbol(arguments2Value_)) && (RubyGuards.isRubyPointer(arguments3Value_)) && (RubyGuards.isRubyPointer(arguments4Value_))) {
return root.getSockOptionsSymbols(frameValue, arguments0Value_, arguments1Value_, arguments2Value_, arguments3Value_, arguments4Value_, this.snippetNode);
}
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_, arguments3Value_, arguments4Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value, Object arguments3Value, Object arguments4Value) {
if (RubyTypesGen.isImplicitInteger(arguments0Value, arguments0ImplicitType) && arguments1Value instanceof DynamicObject && arguments2Value instanceof DynamicObject && arguments3Value instanceof DynamicObject && arguments4Value instanceof DynamicObject) {
int arguments0Value_ = RubyTypesGen.asImplicitInteger(arguments0Value, arguments0ImplicitType);
DynamicObject arguments1Value_ = (DynamicObject) arguments1Value;
DynamicObject arguments2Value_ = (DynamicObject) arguments2Value;
DynamicObject arguments3Value_ = (DynamicObject) arguments3Value;
DynamicObject arguments4Value_ = (DynamicObject) arguments4Value;
if ((RubyGuards.isRubySymbol(arguments1Value_)) && (RubyGuards.isRubySymbol(arguments2Value_)) && (RubyGuards.isRubyPointer(arguments3Value_)) && (RubyGuards.isRubyPointer(arguments4Value_))) {
return root.getSockOptionsSymbols(frameValue, arguments0Value_, arguments1Value_, arguments2Value_, arguments3Value_, arguments4Value_, this.snippetNode);
}
}
return getNext().executeInt_(frameValue, arguments0Value, arguments1Value, arguments2Value, arguments3Value, arguments4Value);
}
static BaseNode_ create(GetSockOptNodeGen root, Object arguments0Value, SnippetNode snippetNode) {
return new GetSockOptionsSymbolsNode_(root, arguments0Value, snippetNode);
}
}
}
}
@GeneratedBy(CloseNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class CloseNodeFactory implements NodeFactory {
private static CloseNodeFactory closeNodeFactoryInstance;
private CloseNodeFactory() {
}
@Override
public Class getNodeClass() {
return CloseNode.class;
}
@Override
public List getExecutionSignature() {
return Arrays.asList(RubyNode.class);
}
@Override
public List getNodeSignatures() {
return Arrays.asList(Arrays.asList(RubyNode[].class));
}
@Override
public CloseNode 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 (closeNodeFactoryInstance == null) {
closeNodeFactoryInstance = new CloseNodeFactory();
}
return closeNodeFactoryInstance;
}
public static CloseNode create(RubyNode[] arguments) {
return new CloseNodeGen(arguments);
}
@GeneratedBy(CloseNode.class)
public static final class CloseNodeGen extends CloseNode implements SpecializedNode {
@Child private RubyNode arguments0_;
@CompilationFinal private Class arguments0Type_;
@Child private BaseNode_ specialization_;
private CloseNodeGen(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(CloseNode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected CloseNodeGen root;
BaseNode_(CloseNodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (CloseNodeGen) 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_ = executeArguments0_(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 (RubyTypesGen.isImplicitInteger(arguments0Value)) {
return CloseNode_.create(root, arguments0Value);
}
return null;
}
@Override
protected final SpecializationNode createPolymorphic() {
return PolymorphicNode_.create(root);
}
protected final BaseNode_ getNext() {
return (BaseNode_) this.next;
}
protected final Object executeArguments0_(Frame frameValue) {
Class arguments0Type_ = root.arguments0Type_;
try {
if (arguments0Type_ == int.class) {
return root.arguments0_.executeInteger((VirtualFrame) frameValue);
} else if (arguments0Type_ == null) {
CompilerDirectives.transferToInterpreterAndInvalidate();
Class _type = Object.class;
try {
Object _value = root.arguments0_.execute((VirtualFrame) frameValue);
if (_value instanceof Integer) {
_type = int.class;
} else {
_type = Object.class;
}
return _value;
} finally {
root.arguments0Type_ = _type;
}
} else {
return root.arguments0_.execute((VirtualFrame) frameValue);
}
} catch (UnexpectedResultException ex) {
root.arguments0Type_ = Object.class;
return ex.getResult();
}
}
}
@GeneratedBy(CloseNode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(CloseNodeGen root) {
super(root, 2147483647);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value) {
return (int) uninitialized(frameValue, arguments0Value);
}
static BaseNode_ create(CloseNodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(CloseNode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(CloseNodeGen 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_ = executeArguments0_(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value) {
return getNext().executeInt_(frameValue, arguments0Value);
}
static BaseNode_ create(CloseNodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "close(int)", value = CloseNode.class)
private static final class CloseNode_ extends BaseNode_ {
private final Class arguments0ImplicitType;
CloseNode_(CloseNodeGen root, Object arguments0Value) {
super(root, 1);
this.arguments0ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments0Value);
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.arguments0ImplicitType == ((CloseNode_) other).arguments0ImplicitType;
}
@Override
public Object execute(VirtualFrame frameValue) {
return executeInt(frameValue);
}
@Override
public int executeInt(VirtualFrame frameValue) {
int arguments0Value_;
try {
if (arguments0ImplicitType == int.class) {
arguments0Value_ = root.arguments0_.executeInteger(frameValue);
} else {
Object arguments0Value__ = executeArguments0_(frameValue);
arguments0Value_ = RubyTypesGen.expectImplicitInteger(arguments0Value__, arguments0ImplicitType);
}
} catch (UnexpectedResultException ex) {
return getNext().executeInt_(frameValue, ex.getResult());
}
return root.close(arguments0Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value) {
if (RubyTypesGen.isImplicitInteger(arguments0Value, arguments0ImplicitType)) {
int arguments0Value_ = RubyTypesGen.asImplicitInteger(arguments0Value, arguments0ImplicitType);
return root.close(arguments0Value_);
}
return getNext().executeInt_(frameValue, arguments0Value);
}
static BaseNode_ create(CloseNodeGen root, Object arguments0Value) {
return new CloseNode_(root, arguments0Value);
}
}
}
}
@GeneratedBy(KillNode.class)
@SuppressWarnings({"unchecked", "rawtypes"})
public static final class KillNodeFactory implements NodeFactory {
private static KillNodeFactory killNodeFactoryInstance;
private KillNodeFactory() {
}
@Override
public Class getNodeClass() {
return KillNode.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 KillNode 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 (killNodeFactoryInstance == null) {
killNodeFactoryInstance = new KillNodeFactory();
}
return killNodeFactoryInstance;
}
public static KillNode create(RubyNode[] arguments) {
return new KillNodeGen(arguments);
}
@GeneratedBy(KillNode.class)
public static final class KillNodeGen extends KillNode implements SpecializedNode {
@Child private RubyNode arguments0_;
@Child private RubyNode arguments1_;
@Child private RubyNode arguments2_;
@CompilationFinal private Class arguments0Type_;
@CompilationFinal private Class arguments1Type_;
@Child private BaseNode_ specialization_;
private KillNodeGen(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 int executeInteger(VirtualFrame frameValue) {
return specialization_.executeInt(frameValue);
}
@Override
public SpecializationNode getSpecializationNode() {
return specialization_;
}
@Override
public Node deepCopy() {
return SpecializationNode.updateRoot(super.deepCopy());
}
@GeneratedBy(KillNode.class)
private abstract static class BaseNode_ extends SpecializationNode {
@CompilationFinal protected KillNodeGen root;
BaseNode_(KillNodeGen root, int index) {
super(index);
this.root = root;
}
@Override
protected final void setRoot(Node root) {
this.root = (KillNodeGen) 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.executeInt_((VirtualFrame) frameValue, arguments0Value, arguments1Value, arguments2Value);
}
public abstract int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value);
public Object execute(VirtualFrame frameValue) {
Object arguments0Value_ = executeArguments0_(frameValue);
Object arguments1Value_ = executeArguments1_(frameValue);
Object arguments2Value_ = root.arguments2_.execute(frameValue);
return executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_);
}
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, Object arguments1Value, Object arguments2Value) {
if (RubyTypesGen.isImplicitInteger(arguments0Value) && RubyTypesGen.isImplicitInteger(arguments1Value) && arguments2Value instanceof DynamicObject) {
DynamicObject arguments2Value_ = (DynamicObject) arguments2Value;
if ((RubyGuards.isRubyString(arguments2Value_))) {
return KillNode_.create(root, arguments0Value, arguments1Value);
}
}
return null;
}
@Override
protected final SpecializationNode createPolymorphic() {
return PolymorphicNode_.create(root);
}
protected final BaseNode_ getNext() {
return (BaseNode_) this.next;
}
protected final Object executeArguments0_(Frame frameValue) {
Class arguments0Type_ = root.arguments0Type_;
try {
if (arguments0Type_ == int.class) {
return root.arguments0_.executeInteger((VirtualFrame) frameValue);
} else if (arguments0Type_ == null) {
CompilerDirectives.transferToInterpreterAndInvalidate();
Class _type = Object.class;
try {
Object _value = root.arguments0_.execute((VirtualFrame) frameValue);
if (_value instanceof Integer) {
_type = int.class;
} else {
_type = Object.class;
}
return _value;
} finally {
root.arguments0Type_ = _type;
}
} else {
return root.arguments0_.execute((VirtualFrame) frameValue);
}
} catch (UnexpectedResultException ex) {
root.arguments0Type_ = Object.class;
return ex.getResult();
}
}
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();
}
}
}
@GeneratedBy(KillNode.class)
private static final class UninitializedNode_ extends BaseNode_ {
UninitializedNode_(KillNodeGen root) {
super(root, 2147483647);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value) {
return (int) uninitialized(frameValue, arguments0Value, arguments1Value, arguments2Value);
}
static BaseNode_ create(KillNodeGen root) {
return new UninitializedNode_(root);
}
}
@GeneratedBy(KillNode.class)
private static final class PolymorphicNode_ extends BaseNode_ {
PolymorphicNode_(KillNodeGen 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 int executeInt(VirtualFrame frameValue) {
Object arguments0Value_ = executeArguments0_(frameValue);
Object arguments1Value_ = executeArguments1_(frameValue);
Object arguments2Value_ = root.arguments2_.execute(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value) {
return getNext().executeInt_(frameValue, arguments0Value, arguments1Value, arguments2Value);
}
static BaseNode_ create(KillNodeGen root) {
return new PolymorphicNode_(root);
}
}
@GeneratedBy(methodName = "kill(int, int, DynamicObject)", value = KillNode.class)
private static final class KillNode_ extends BaseNode_ {
private final Class arguments0ImplicitType;
private final Class arguments1ImplicitType;
KillNode_(KillNodeGen root, Object arguments0Value, Object arguments1Value) {
super(root, 1);
this.arguments0ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments0Value);
this.arguments1ImplicitType = RubyTypesGen.getImplicitIntegerClass(arguments1Value);
}
@Override
public boolean isSame(SpecializationNode other) {
return super.isSame(other) && this.arguments0ImplicitType == ((KillNode_) other).arguments0ImplicitType && this.arguments1ImplicitType == ((KillNode_) other).arguments1ImplicitType;
}
@Override
public Object execute(VirtualFrame frameValue) {
return executeInt(frameValue);
}
@Override
public int executeInt(VirtualFrame frameValue) {
int arguments0Value_;
try {
if (arguments0ImplicitType == int.class) {
arguments0Value_ = root.arguments0_.executeInteger(frameValue);
} else {
Object arguments0Value__ = executeArguments0_(frameValue);
arguments0Value_ = RubyTypesGen.expectImplicitInteger(arguments0Value__, arguments0ImplicitType);
}
} catch (UnexpectedResultException ex) {
Object arguments1Value = executeArguments1_(frameValue);
Object arguments2Value = root.arguments2_.execute(frameValue);
return getNext().executeInt_(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 = root.arguments2_.execute(frameValue);
return getNext().executeInt_(frameValue, arguments0Value_, ex.getResult(), arguments2Value);
}
DynamicObject arguments2Value_;
try {
arguments2Value_ = root.arguments2_.executeDynamicObject(frameValue);
} catch (UnexpectedResultException ex) {
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_, ex.getResult());
}
if ((RubyGuards.isRubyString(arguments2Value_))) {
return root.kill(arguments0Value_, arguments1Value_, arguments2Value_);
}
return getNext().executeInt_(frameValue, arguments0Value_, arguments1Value_, arguments2Value_);
}
@Override
public int executeInt_(VirtualFrame frameValue, Object arguments0Value, Object arguments1Value, Object arguments2Value) {
if (RubyTypesGen.isImplicitInteger(arguments0Value, arguments0ImplicitType) && RubyTypesGen.isImplicitInteger(arguments1Value, arguments1ImplicitType) && arguments2Value instanceof DynamicObject) {
int arguments0Value_ = RubyTypesGen.asImplicitInteger(arguments0Value, arguments0ImplicitType);
int arguments1Value_ = RubyTypesGen.asImplicitInteger(arguments1Value, arguments1ImplicitType);
DynamicObject arguments2Value_ = (DynamicObject) arguments2Value;
if ((RubyGuards.isRubyString(arguments2Value_))) {
return root.kill(arguments0Value_, arguments1Value_, arguments2Value_);
}
}
return getNext().executeInt_(frameValue, arguments0Value, arguments1Value, arguments2Value);
}
static BaseNode_ create(KillNodeGen root, Object arguments0Value, Object arguments1Value) {
return new KillNode_(root, arguments0Value, arguments1Value);
}
}
}
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy