@Override
public Object execute(VirtualFrame frame) {
while (true) {
Object result;
try {
result = tryPart.execute(frame);
} catch (RaiseException exception) {
raiseExceptionProfile.enter();
try {
return handleException(frame, exception);
} catch (RetryException e) {
getContext().getSafepointManager().poll(this);
continue;
}
} catch (ControlFlowException exception) {
controlFlowProfile.enter();
throw exception;
}
elseProfile.enter();
if (elsePart != null) {
result = elsePart.execute(frame);
}
return result;
}
}
@Specialization
protected Object doInternal(VirtualFrame frame, RPromise x) {
if (builtinCallNode == null) {
RNode call = (RNode) x.getRep();
RNode operand = (RNode) RASTUtils.unwrap(call);
if (!(operand instanceof RCallNode)) {
errorProfile.enter();
throw RError.error(this, RError.Message.INVALID_INTERNAL);
}
RCallNode callNode = (RCallNode) operand;
RNode func = callNode.getFunctionNode();
String name = ((ReadVariableNode) func).getIdentifier();
RFunction function = RContext.lookupBuiltin(name);
if (function == null
|| function.isBuiltin() && function.getRBuiltin().getKind() != RBuiltinKind.INTERNAL) {
errorProfile.enter();
if (function == null && notImplemented(name)) {
throw RInternalError.unimplemented(".Internal " + name);
}
throw RError.error(this, RError.Message.NO_SUCH_INTERNAL, name);
}
// .Internal function is validated
CompilerDirectives.transferToInterpreterAndInvalidate();
builtinCallNode = insert(RCallNode.createInternalCall(callNode, function));
}
return builtinCallNode.execute(frame);
}
private void verifyDimensions(int[] vectorDimensions) {
if (vectorDimensions == null) {
if (isMultiDimension()) {
errorBranch.enter();
throw dimensionsError();
}
} else {
if (getDimensions() > vectorDimensions.length || getDimensions() < vectorDimensions.length) {
errorBranch.enter();
throw dimensionsError();
}
}
}
@ExplodeLoop
public boolean isSupported(Object[] positions) {
if (positionsCheck.length != positions.length) {
unsupportedProfile.enter();
return false;
}
for (int i = 0; i < positionsCheck.length; i++) {
if (!positionsCheck[i].isSupported(positions[i])) {
unsupportedProfile.enter();
return false;
}
}
return true;
}
@Specialization
protected Object getDimNames(RAbstractContainer container) {
controlVisibility();
RList names;
if (container instanceof RDataFrame) {
dataframeProfile.enter();
names = ((RDataFrame) container).getVector().getDimNames();
} else if (container instanceof RFactor) {
factorProfile.enter();
names = ((RFactor) container).getVector().getDimNames();
} else {
otherProfile.enter();
names = container.getDimNames(attrProfiles);
}
return nullProfile.profile(names == null) ? RNull.instance : names;
}
// TODO Figure out how to distinguish f(,,a) from f(a) - RMissing is used in both contexts
@RBuiltin(
name = "nargs",
kind = PRIMITIVE,
parameterNames = {})
public abstract class NArgs extends RBuiltinNode {
private final BranchProfile isPromiseProfile = BranchProfile.create();
@Specialization
protected int doNArgs(VirtualFrame frame) {
int result = 0;
if (RArguments.getFunction(frame) == null) {
return RRuntime.INT_NA;
}
int l = RArguments.getArgumentsLength(frame);
for (int i = 0; i < l; i++) {
Object arg = RArguments.getArgument(frame, i);
if (arg instanceof RPromise) {
isPromiseProfile.enter();
RPromise promise = (RPromise) arg;
if (!promise.isDefault()) {
result++;
}
} else if (arg instanceof RArgsValuesAndNames) {
result += ((RArgsValuesAndNames) arg).getLength();
} else if (!(arg instanceof RMissing)) {
result++;
}
}
return result;
}
}
@Specialization(guards = {"each > 1", "hasNames(x)"})
protected RAbstractVector repEachNames(
RAbstractVector x,
RAbstractIntVector times,
int lengthOut,
int each,
@Cached("create()") InitAttributesNode initAttributes,
@Cached("createNames()") SetFixedAttributeNode putNames) {
if (times.getLength() > 1) {
errorBranch.enter();
throw invalidTimes();
}
RAbstractVector input = handleEach(x, each);
RStringVector names = (RStringVector) handleEach(getNames.getNames(x), each);
RVector<?> r;
if (lengthOutOrTimes.profile(!RRuntime.isNA(lengthOut))) {
names = (RStringVector) handleLengthOut(names, lengthOut, false);
r = handleLengthOut(input, lengthOut, false);
} else {
names = (RStringVector) handleTimes(names, times, false);
r = handleTimes(input, times, false);
}
putNames.execute(initAttributes.execute(r), names);
return r;
}
/** Replicate the vector a given number of times. */
private RVector<?> handleTimes(
RAbstractVector x, RAbstractIntVector times, boolean copyIfSameSize) {
if (oneTimeGiven.profile(times.getLength() == 1)) {
// only one times value is given
final int howManyTimes = times.getDataAt(0);
if (howManyTimes < 0) {
errorBranch.enter();
throw invalidTimes();
}
if (replicateOnce.profile(howManyTimes == 1)) {
return (RVector<?>) (copyIfSameSize ? x.copy() : x);
} else {
return x.copyResized(x.getLength() * howManyTimes, false);
}
} else {
// times is a vector with several elements
if (x.getLength() != times.getLength()) {
errorBranch.enter();
invalidTimes();
}
// iterate once over the times vector to determine result vector size
int resultLength = 0;
for (int i = 0; i < times.getLength(); i++) {
int t = times.getDataAt(i);
if (t < 0) {
errorBranch.enter();
throw invalidTimes();
}
resultLength += t;
}
// create and populate result vector
RVector<?> r = x.createEmptySameType(resultLength, x.isComplete());
int wp = 0; // write pointer
for (int i = 0; i < x.getLength(); i++) {
for (int j = 0; j < times.getDataAt(i); ++j, ++wp) {
r.transferElementSameType(wp, x, i);
}
}
return r;
}
}
@NodeChild(value = "lexicalParentModule", type = RubyNode.class)
public abstract class DefineModuleNode extends RubyNode {
private final String name;
@Child LookupForExistingModuleNode lookupForExistingModuleNode;
private final ConditionProfile needToDefineProfile = ConditionProfile.createBinaryProfile();
private final BranchProfile errorProfile = BranchProfile.create();
public DefineModuleNode(RubyContext context, SourceSection sourceSection, String name) {
super(context, sourceSection);
this.name = name;
}
@Specialization(guards = "isRubyModule(lexicalParentModule)")
public Object defineModule(VirtualFrame frame, DynamicObject lexicalParentModule) {
final RubyConstant constant = lookupForExistingModule(frame, name, lexicalParentModule);
final DynamicObject definingModule;
if (needToDefineProfile.profile(constant == null)) {
definingModule =
ModuleNodes.createModule(
getContext(), coreLibrary().getModuleClass(), lexicalParentModule, name, this);
} else {
final Object constantValue = constant.getValue();
if (!RubyGuards.isRubyModule(constantValue) || RubyGuards.isRubyClass(constantValue)) {
errorProfile.enter();
throw new RaiseException(coreExceptions().typeErrorIsNotA(name, "module", this));
}
definingModule = (DynamicObject) constantValue;
}
return definingModule;
}
@Specialization(guards = "!isRubyModule(lexicalParentObject)")
public Object defineModuleWrongParent(VirtualFrame frame, Object lexicalParentObject) {
throw new RaiseException(coreExceptions().typeErrorIsNotA(lexicalParentObject, "module", this));
}
private RubyConstant lookupForExistingModule(
VirtualFrame frame, String name, DynamicObject lexicalParent) {
if (lookupForExistingModuleNode == null) {
CompilerDirectives.transferToInterpreterAndInvalidate();
lookupForExistingModuleNode = insert(LookupForExistingModuleNodeGen.create(null, null));
}
return lookupForExistingModuleNode.executeLookupForExistingModule(frame, name, lexicalParent);
}
}
@Specialization
public Object callNamedFunctionWithPackage(
String name, RArgsValuesAndNames args, String packageName) {
controlVisibility();
SymbolInfo symbolInfo = DLL.findSymbolInfo(name, packageName);
if (symbolInfo == null) {
errorProfile.enter();
throw RError.error(this, Message.C_SYMBOL_NOT_IN_TABLE, name);
}
return RFFIFactory.getRFFI()
.getCallRFFI()
.invokeCall(symbolInfo.address, symbolInfo.symbol, args.getArguments());
}
@Specialization(guards = {"each > 1", "!hasNames(x)"})
protected RAbstractVector repEachNoNames(
RAbstractVector x, RAbstractIntVector times, int lengthOut, int each) {
if (times.getLength() > 1) {
errorBranch.enter();
throw invalidTimes();
}
RAbstractVector input = handleEach(x, each);
if (lengthOutOrTimes.profile(!RRuntime.isNA(lengthOut))) {
return handleLengthOut(input, lengthOut, false);
} else {
return handleTimes(input, times, false);
}
}
@Specialization
public Object callNamedFunctionWithPackage(
String name, RArgsValuesAndNames args, String packageName) {
controlVisibility();
SymbolInfo symbolInfo = DLL.findSymbolInfo(name, packageName);
if (symbolInfo == null) {
errorProfile.enter();
throw RError.error(this, Message.C_SYMBOL_NOT_IN_TABLE, name);
}
Object list = encodeArgumentPairList(args, symbolInfo.symbol);
// TODO: provide proper values for the CALL, OP and RHO parameters
return RFFIFactory.getRFFI()
.getCallRFFI()
.invokeCall(symbolInfo.address, symbolInfo.symbol, new Object[] {CALL, OP, list, RHO});
}
@RBuiltin(
name = "dimnames",
kind = PRIMITIVE,
parameterNames = {"x"},
dispatch = INTERNAL_GENERIC)
public abstract class DimNames extends RBuiltinNode {
private final RAttributeProfiles attrProfiles = RAttributeProfiles.create();
private final ConditionProfile nullProfile = ConditionProfile.createBinaryProfile();
private final BranchProfile dataframeProfile = BranchProfile.create();
private final BranchProfile factorProfile = BranchProfile.create();
private final BranchProfile otherProfile = BranchProfile.create();
@Specialization
protected RNull getDimNames(@SuppressWarnings("unused") RNull operand) {
controlVisibility();
return RNull.instance;
}
@Specialization
protected Object getDimNames(RAbstractContainer container) {
controlVisibility();
RList names;
if (container instanceof RDataFrame) {
dataframeProfile.enter();
names = ((RDataFrame) container).getVector().getDimNames();
} else if (container instanceof RFactor) {
factorProfile.enter();
names = ((RFactor) container).getVector().getDimNames();
} else {
otherProfile.enter();
names = container.getDimNames(attrProfiles);
}
return nullProfile.profile(names == null) ? RNull.instance : names;
}
}
@NodeChildren({
@NodeChild(value = "enclosingFrame", type = AccessEnclosingFrameNode.class),
@NodeChild(value = "frameSlotNode", type = FrameSlotNode.class)
})
protected abstract static class ResolvedWriteSuperFrameVariableNode
extends WriteSuperFrameVariableNode {
private final ValueProfile storedObjectProfile = ValueProfile.createClassProfile();
private final BranchProfile invalidateProfile = BranchProfile.create();
private final ValueProfile enclosingFrameProfile = ValueProfile.createClassProfile();
private final Mode mode;
public ResolvedWriteSuperFrameVariableNode(Mode mode) {
this.mode = mode;
}
protected abstract FrameSlotNode getFrameSlotNode();
@Specialization(guards = "isLogicalKind(enclosingFrame, frameSlot)")
protected void doLogical(byte value, MaterializedFrame enclosingFrame, FrameSlot frameSlot) {
FrameSlotChangeMonitor.setByteAndInvalidate(
enclosingFrameProfile.profile(enclosingFrame), frameSlot, value, true, invalidateProfile);
}
@Specialization(guards = "isIntegerKind(enclosingFrame, frameSlot)")
protected void doInteger(int value, MaterializedFrame enclosingFrame, FrameSlot frameSlot) {
FrameSlotChangeMonitor.setIntAndInvalidate(
enclosingFrameProfile.profile(enclosingFrame), frameSlot, value, true, invalidateProfile);
}
@Specialization(guards = "isDoubleKind(enclosingFrame, frameSlot)")
protected void doDouble(double value, MaterializedFrame enclosingFrame, FrameSlot frameSlot) {
FrameSlotChangeMonitor.setDoubleAndInvalidate(
enclosingFrameProfile.profile(enclosingFrame), frameSlot, value, true, invalidateProfile);
}
@Specialization
protected void doObject(Object value, MaterializedFrame enclosingFrame, FrameSlot frameSlot) {
MaterializedFrame profiledFrame = enclosingFrameProfile.profile(enclosingFrame);
Object newValue =
shareObjectValue(
profiledFrame, frameSlot, storedObjectProfile.profile(value), mode, true);
FrameSlotChangeMonitor.setObjectAndInvalidate(
profiledFrame, frameSlot, newValue, true, invalidateProfile);
}
}
@Specialization(
guards = {"x.getLength() == 1", "times.getLength() == 1", "each <= 1", "!hasNames(x)"})
protected RAbstractVector repNoEachNoNamesSimple(
RAbstractDoubleVector x,
RAbstractIntVector times,
int lengthOut,
@SuppressWarnings("unused") int each) {
int t = times.getDataAt(0);
if (t < 0) {
errorBranch.enter();
throw invalidTimes();
}
int length = lengthOutOrTimes.profile(!RRuntime.isNA(lengthOut)) ? lengthOut : t;
double[] data = new double[length];
Arrays.fill(data, x.getDataAt(0));
return RDataFactory.createDoubleVector(data, !RRuntime.isNA(x.getDataAt(0)));
}
@Specialization
protected RList c(
String f,
RArgsValuesAndNames args,
byte naok,
byte dup,
@SuppressWarnings("unused") RMissing rPackage,
@SuppressWarnings("unused") RMissing encoding, //
@Cached("create()") BranchProfile errorProfile) {
controlVisibility();
SymbolInfo symbolInfo = DLL.findRegisteredSymbolinInDLL(f, null, "");
if (symbolInfo == null) {
errorProfile.enter();
throw RError.error(this, RError.Message.C_SYMBOL_NOT_IN_TABLE, f);
}
return DotC.dispatch(
this, symbolInfo.address, symbolInfo.symbol, naok, dup, args.getArguments());
}
@Specialization
protected int doNArgs(VirtualFrame frame) {
int result = 0;
if (RArguments.getFunction(frame) == null) {
return RRuntime.INT_NA;
}
int l = RArguments.getArgumentsLength(frame);
for (int i = 0; i < l; i++) {
Object arg = RArguments.getArgument(frame, i);
if (arg instanceof RPromise) {
isPromiseProfile.enter();
RPromise promise = (RPromise) arg;
if (!promise.isDefault()) {
result++;
}
} else if (arg instanceof RArgsValuesAndNames) {
result += ((RArgsValuesAndNames) arg).getLength();
} else if (!(arg instanceof RMissing)) {
result++;
}
}
return result;
}
@Specialization(guards = "isRubyModule(lexicalParentModule)")
public Object defineModule(VirtualFrame frame, DynamicObject lexicalParentModule) {
final RubyConstant constant = lookupForExistingModule(frame, name, lexicalParentModule);
final DynamicObject definingModule;
if (needToDefineProfile.profile(constant == null)) {
definingModule =
ModuleNodes.createModule(
getContext(), coreLibrary().getModuleClass(), lexicalParentModule, name, this);
} else {
final Object constantValue = constant.getValue();
if (!RubyGuards.isRubyModule(constantValue) || RubyGuards.isRubyClass(constantValue)) {
errorProfile.enter();
throw new RaiseException(coreExceptions().typeErrorIsNotA(name, "module", this));
}
definingModule = (DynamicObject) constantValue;
}
return definingModule;
}
/**
* The {@code rep} builtin works as follows.
*
* <ol>
* <li>If {@code each} is greater than one, all elements of {@code x} are first replicated {@code
* each} times.
* <li>If {@code length.out} is given, the result of the first step is truncated or extended as
* required. In this case, {@code times} is ignored.
* <li>If {@code length.out} is not given, {@code times} is regarded:
* <ul>
* <li>If {@code times} is a one-element vector, the result of the first step is replicated
* {@code times} times.
* <li>If {@code times} is a vector longer than one, and {@code each} is greater than one,
* an error is issued.
* <li>If {@code times} is a vector longer than one, and {@code each} is one, and {@code
* times} is as long as {@code x}, each element of {@code x} is given the number of
* times indicated by the value at the same index of {@code times}. If {@code times} has
* a different length, an error is issued.
* </ul>
* </ol>
*/
@RBuiltin(
name = "rep",
kind = PRIMITIVE,
parameterNames = {"x", "times", "length.out", "each"},
dispatch = INTERNAL_GENERIC,
behavior = PURE)
public abstract class Repeat extends RBuiltinNode {
protected abstract Object execute(
RAbstractVector x, RAbstractIntVector times, int lengthOut, int each);
private final ConditionProfile lengthOutOrTimes = ConditionProfile.createBinaryProfile();
private final BranchProfile errorBranch = BranchProfile.create();
private final ConditionProfile oneTimeGiven = ConditionProfile.createBinaryProfile();
private final ConditionProfile replicateOnce = ConditionProfile.createBinaryProfile();
@Child private GetNamesAttributeNode getNames = GetNamesAttributeNode.create();
@Override
public Object[] getDefaultParameterValues() {
return new Object[] {RMissing.instance, 1, RRuntime.INT_NA, 1};
}
private String argType(Object arg) {
return ((RTypedValue) arg).getRType().getName();
}
@Override
protected void createCasts(CastBuilder casts) {
Function<Object, Object> argType = this::argType;
casts.arg("x").mustBe(abstractVectorValue(), RError.Message.ATTEMPT_TO_REPLICATE, argType);
casts
.arg("times")
.defaultError(RError.Message.INVALID_ARGUMENT, "times")
.mustNotBeNull()
.asIntegerVector();
casts
.arg("length.out")
.mustNotBeNull()
.asIntegerVector()
.shouldBe(size(1).or(size(0)), RError.Message.FIRST_ELEMENT_USED, "length.out")
.findFirst(RRuntime.INT_NA, RError.Message.FIRST_ELEMENT_USED, "length.out")
.mustBe(intNA().or(gte(0)));
casts
.arg("each")
.asIntegerVector()
.shouldBe(size(1).or(size(0)), RError.Message.FIRST_ELEMENT_USED, "each")
.findFirst(1, RError.Message.FIRST_ELEMENT_USED, "each")
.notNA(1)
.mustBe(gte(0));
}
protected boolean hasNames(RAbstractVector x) {
return getNames.getNames(x) != null;
}
private RError invalidTimes() {
throw RError.error(this, RError.Message.INVALID_ARGUMENT, "times");
}
@Specialization(
guards = {"x.getLength() == 1", "times.getLength() == 1", "each <= 1", "!hasNames(x)"})
protected RAbstractVector repNoEachNoNamesSimple(
RAbstractDoubleVector x,
RAbstractIntVector times,
int lengthOut,
@SuppressWarnings("unused") int each) {
int t = times.getDataAt(0);
if (t < 0) {
errorBranch.enter();
throw invalidTimes();
}
int length = lengthOutOrTimes.profile(!RRuntime.isNA(lengthOut)) ? lengthOut : t;
double[] data = new double[length];
Arrays.fill(data, x.getDataAt(0));
return RDataFactory.createDoubleVector(data, !RRuntime.isNA(x.getDataAt(0)));
}
@Specialization(guards = {"each > 1", "!hasNames(x)"})
protected RAbstractVector repEachNoNames(
RAbstractVector x, RAbstractIntVector times, int lengthOut, int each) {
if (times.getLength() > 1) {
errorBranch.enter();
throw invalidTimes();
}
RAbstractVector input = handleEach(x, each);
if (lengthOutOrTimes.profile(!RRuntime.isNA(lengthOut))) {
return handleLengthOut(input, lengthOut, false);
} else {
return handleTimes(input, times, false);
}
}
@Specialization(guards = {"each <= 1", "!hasNames(x)"})
protected RAbstractVector repNoEachNoNames(
RAbstractVector x,
RAbstractIntVector times,
int lengthOut,
@SuppressWarnings("unused") int each) {
if (lengthOutOrTimes.profile(!RRuntime.isNA(lengthOut))) {
return handleLengthOut(x, lengthOut, true);
} else {
return handleTimes(x, times, true);
}
}
@Specialization(guards = {"each > 1", "hasNames(x)"})
protected RAbstractVector repEachNames(
RAbstractVector x,
RAbstractIntVector times,
int lengthOut,
int each,
@Cached("create()") InitAttributesNode initAttributes,
@Cached("createNames()") SetFixedAttributeNode putNames) {
if (times.getLength() > 1) {
errorBranch.enter();
throw invalidTimes();
}
RAbstractVector input = handleEach(x, each);
RStringVector names = (RStringVector) handleEach(getNames.getNames(x), each);
RVector<?> r;
if (lengthOutOrTimes.profile(!RRuntime.isNA(lengthOut))) {
names = (RStringVector) handleLengthOut(names, lengthOut, false);
r = handleLengthOut(input, lengthOut, false);
} else {
names = (RStringVector) handleTimes(names, times, false);
r = handleTimes(input, times, false);
}
putNames.execute(initAttributes.execute(r), names);
return r;
}
@Specialization(guards = {"each <= 1", "hasNames(x)"})
protected RAbstractVector repNoEachNames(
RAbstractVector x,
RAbstractIntVector times,
int lengthOut,
@SuppressWarnings("unused") int each,
@Cached("create()") InitAttributesNode initAttributes,
@Cached("createNames()") SetFixedAttributeNode putNames) {
RStringVector names;
RVector<?> r;
if (lengthOutOrTimes.profile(!RRuntime.isNA(lengthOut))) {
names = (RStringVector) handleLengthOut(getNames.getNames(x), lengthOut, true);
r = handleLengthOut(x, lengthOut, true);
} else {
names = (RStringVector) handleTimes(getNames.getNames(x), times, true);
r = handleTimes(x, times, true);
}
putNames.execute(initAttributes.execute(r), names);
return r;
}
/** Prepare the input vector by replicating its elements. */
private static RVector<?> handleEach(RAbstractVector x, int each) {
RVector<?> r = x.createEmptySameType(x.getLength() * each, x.isComplete());
for (int i = 0; i < x.getLength(); i++) {
for (int j = i * each; j < (i + 1) * each; j++) {
r.transferElementSameType(j, x, i);
}
}
return r;
}
/** Extend or truncate the vector to a specified length. */
private static RVector<?> handleLengthOut(
RAbstractVector x, int lengthOut, boolean copyIfSameSize) {
if (x.getLength() == lengthOut) {
return (RVector<?>) (copyIfSameSize ? x.copy() : x);
}
return x.copyResized(lengthOut, false);
}
/** Replicate the vector a given number of times. */
private RVector<?> handleTimes(
RAbstractVector x, RAbstractIntVector times, boolean copyIfSameSize) {
if (oneTimeGiven.profile(times.getLength() == 1)) {
// only one times value is given
final int howManyTimes = times.getDataAt(0);
if (howManyTimes < 0) {
errorBranch.enter();
throw invalidTimes();
}
if (replicateOnce.profile(howManyTimes == 1)) {
return (RVector<?>) (copyIfSameSize ? x.copy() : x);
} else {
return x.copyResized(x.getLength() * howManyTimes, false);
}
} else {
// times is a vector with several elements
if (x.getLength() != times.getLength()) {
errorBranch.enter();
invalidTimes();
}
// iterate once over the times vector to determine result vector size
int resultLength = 0;
for (int i = 0; i < times.getLength(); i++) {
int t = times.getDataAt(i);
if (t < 0) {
errorBranch.enter();
throw invalidTimes();
}
resultLength += t;
}
// create and populate result vector
RVector<?> r = x.createEmptySameType(resultLength, x.isComplete());
int wp = 0; // write pointer
for (int i = 0; i < x.getLength(); i++) {
for (int j = 0; j < times.getDataAt(i); ++j, ++wp) {
r.transferElementSameType(wp, x, i);
}
}
return r;
}
}
}
abstract class PositionCheckNode extends Node {
protected final Class<?> positionClass;
protected final int dimensionIndex;
protected final int numDimensions;
protected final VectorLengthProfile positionLengthProfile = VectorLengthProfile.create();
protected final BranchProfile error = BranchProfile.create();
protected final boolean replace;
protected final RType containerType;
@Child private PositionCastNode castNode;
@Child private RLengthNode positionLengthNode = RLengthNode.create();
@Child private PositionCharacterLookupNode characterLookup;
PositionCheckNode(
ElementAccessMode mode,
RType containerType,
Object positionValue,
int dimensionIndex,
int numDimensions,
boolean exact,
boolean replace) {
this.positionClass = positionValue.getClass();
this.dimensionIndex = dimensionIndex;
this.numDimensions = numDimensions;
this.replace = replace;
this.containerType = containerType;
this.castNode = PositionCastNode.create(mode, replace);
if (positionValue instanceof String || positionValue instanceof RAbstractStringVector) {
boolean useNAForNotFound = !replace && isListLike(containerType) && mode.isSubscript();
characterLookup =
new PositionCharacterLookupNode(
mode, numDimensions, dimensionIndex, useNAForNotFound, exact);
}
}
protected static boolean isListLike(RType type) {
switch (type) {
case Language:
case DataFrame:
case Expression:
case PairList:
case List:
return true;
}
return false;
}
public boolean isIgnoreDimension() {
return positionClass == RMissing.class;
}
public Class<?> getPositionClass() {
return positionClass;
}
public final boolean isSupported(Object object) {
return object.getClass() == positionClass;
}
public static PositionCheckNode createNode(
ElementAccessMode mode,
RType containerType,
Object position,
int positionIndex,
int numDimensions,
boolean exact,
boolean replace,
boolean recursive) {
if (mode.isSubset()) {
return PositionCheckSubsetNodeGen.create(
mode, containerType, position, positionIndex, numDimensions, exact, replace);
} else {
return PositionCheckSubscriptNodeGen.create(
mode, containerType, position, positionIndex, numDimensions, exact, replace, recursive);
}
}
protected boolean isMultiDimension() {
return numDimensions > 1;
}
public final Object execute(
PositionProfile profile,
RAbstractContainer vector,
int[] vectorDimensions,
int vectorLength,
Object position) {
Object castPosition = castNode.execute(positionClass.cast(position));
int dimensionLength;
if (numDimensions == 1) {
dimensionLength = vectorLength;
} else {
assert vectorDimensions != null;
assert vectorDimensions.length == numDimensions;
dimensionLength = vectorDimensions[dimensionIndex];
}
if (characterLookup != null) {
castPosition =
characterLookup.execute(vector, (RAbstractStringVector) castPosition, dimensionLength);
}
RTypedValue positionVector = (RTypedValue) profilePosition(castPosition);
int positionLength;
if (positionVector instanceof RMissing) {
positionLength = -1;
} else {
positionLength =
positionLengthProfile.profile(((RAbstractVector) positionVector).getLength());
}
assert isValidCastedType(positionVector)
: "result type of a position cast node must be integer or logical";
return execute(profile, dimensionLength, positionVector, positionLength);
}
private final ValueProfile castedValue = ValueProfile.createClassProfile();
Object profilePosition(Object positionVector) {
return castedValue.profile(positionVector);
}
private static boolean isValidCastedType(RTypedValue positionVector) {
RType type = positionVector.getRType();
return type == RType.Integer
|| type == RType.Logical
|| type == RType.Character
|| type == RType.Double
|| type == RType.Null;
}
public abstract Object execute(
PositionProfile statistics, int dimensionLength, Object position, int positionLength);
}
public class TryNode extends RubyNode {
@Child private RubyNode tryPart;
@Children private final RescueNode[] rescueParts;
@Child private RubyNode elsePart;
@Child private SetExceptionVariableNode setExceptionVariableNode;
private final BranchProfile elseProfile = BranchProfile.create();
private final BranchProfile controlFlowProfile = BranchProfile.create();
private final BranchProfile raiseExceptionProfile = BranchProfile.create();
public TryNode(
RubyContext context,
SourceSection sourceSection,
ExceptionTranslatingNode tryPart,
RescueNode[] rescueParts,
RubyNode elsePart) {
super(context, sourceSection);
this.tryPart = tryPart;
this.rescueParts = rescueParts;
this.elsePart = elsePart;
}
@Override
public Object execute(VirtualFrame frame) {
while (true) {
Object result;
try {
result = tryPart.execute(frame);
} catch (RaiseException exception) {
raiseExceptionProfile.enter();
try {
return handleException(frame, exception);
} catch (RetryException e) {
getContext().getSafepointManager().poll(this);
continue;
}
} catch (ControlFlowException exception) {
controlFlowProfile.enter();
throw exception;
}
elseProfile.enter();
if (elsePart != null) {
result = elsePart.execute(frame);
}
return result;
}
}
@ExplodeLoop
private Object handleException(VirtualFrame frame, RaiseException exception) {
for (RescueNode rescue : rescueParts) {
if (rescue.canHandle(frame, exception.getException())) {
return setLastExceptionAndRunRescue(frame, exception, rescue);
}
}
throw exception;
}
private Object setLastExceptionAndRunRescue(
VirtualFrame frame, RaiseException exception, RubyNode rescue) {
if (setExceptionVariableNode == null) {
CompilerDirectives.transferToInterpreterAndInvalidate();
setExceptionVariableNode = insert(new SetExceptionVariableNode(getContext()));
}
return setExceptionVariableNode.setLastExceptionAndRun(frame, exception, rescue);
}
}
/**
* The {@code .Internal} builtin. In {@code .Internal(func(args))} we have an AST where the
* RCallNode.Uninitialized and the function child should be a {@link ReadVariableNode} node with
* symbol {@code func}. We want to rewrite the AST as if the {@code func} had been called directly.
* However, we must do this in a non-destructive way otherwise deparsing and serialization will
* fail.
*
* <p>A note on {@link RInstrumentableNode}. Since both the {@code .Internal} and the argument are
* {@link RCallNode}s both may have been wrapped. The call to {@link RASTUtils#unwrap} will go
* through any {@code RNodeWrapper} and the rewrite will remove one level of wrapping. However the
* parent of the the {@code .Internal}, which will be an {@code RNodeWrapper}, will remain so any
* instrumentation at that level will remain in place.
*/
@TypeSystemReference(EmptyTypeSystemFlatLayout.class)
@NodeInfo(cost = NONE)
@RBuiltin(
name = ".Internal",
visibility = CUSTOM,
kind = PRIMITIVE,
parameterNames = {"call"},
nonEvalArgs = 0,
behavior = COMPLEX)
public abstract class Internal extends RBuiltinNode {
private final BranchProfile errorProfile = BranchProfile.create();
@Child private RNode builtinCallNode;
@Specialization
protected Object doInternal(@SuppressWarnings("unused") RMissing x) {
errorProfile.enter();
throw RError.error(this, RError.Message.ARGUMENTS_PASSED_0_1, getRBuiltin().name());
}
@Specialization
protected Object doInternal(VirtualFrame frame, RPromise x) {
if (builtinCallNode == null) {
RNode call = (RNode) x.getRep();
RNode operand = (RNode) RASTUtils.unwrap(call);
if (!(operand instanceof RCallNode)) {
errorProfile.enter();
throw RError.error(this, RError.Message.INVALID_INTERNAL);
}
RCallNode callNode = (RCallNode) operand;
RNode func = callNode.getFunctionNode();
String name = ((ReadVariableNode) func).getIdentifier();
RFunction function = RContext.lookupBuiltin(name);
if (function == null
|| function.isBuiltin() && function.getRBuiltin().getKind() != RBuiltinKind.INTERNAL) {
errorProfile.enter();
if (function == null && notImplemented(name)) {
throw RInternalError.unimplemented(".Internal " + name);
}
throw RError.error(this, RError.Message.NO_SUCH_INTERNAL, name);
}
// .Internal function is validated
CompilerDirectives.transferToInterpreterAndInvalidate();
builtinCallNode = insert(RCallNode.createInternalCall(callNode, function));
}
return builtinCallNode.execute(frame);
}
private static boolean notImplemented(String name) {
for (String internal : NOT_IMPLEMENTED) {
if (internal.equals(name)) {
return true;
}
}
return false;
}
// TODO check this; it is out of date
private static final String[] NOT_IMPLEMENTED =
new String[] {
".addTryHandlers",
"interruptsSuspended",
"restart",
"backsolve",
"max.col",
"row",
"all.names",
"comment",
"`comment<-`",
"list2env",
"tcrossprod",
"lbeta",
"beta",
"lchoose",
"choose",
"dchisq",
"pchisq",
"qchisq",
"dexp",
"pexp",
"qexp",
"dgeom",
"pgeom",
"qgeom",
"dpois",
"ppois",
"qpois",
"dt",
"pt",
"qt",
"dsignrank",
"psignrank",
"qsignrank",
"besselJ",
"besselY",
"psigamma",
"dbeta",
"pbeta",
"qbeta",
"dbinom",
"pbinom",
"qbinom",
"dcauchy",
"pcauchy",
"qcauchy",
"df",
"pf",
"qf",
"dgamma",
"pgamma",
"qgamma",
"dlnorm",
"plnorm",
"qlnorm",
"dlogis",
"plogis",
"qlogis",
"dnbinom",
"pnbinom",
"qnbinom",
"dnorm",
"pnorm",
"qnorm",
"dunif",
"punif",
"qunif",
"dweibull",
"pweibull",
"qweibull",
"dnchisq",
"pnchisq",
"qnchisq",
"dnt",
"pnt",
"qnt",
"dwilcox",
"pwilcox",
"qwilcox",
"besselI",
"besselK",
"dnbinom_mu",
"pnbinom_mu",
"qnbinom_mu",
"dhyper",
"phyper",
"qhyper",
"dnbeta",
"pnbeta",
"qnbeta",
"dnf",
"pnf",
"qnf",
"dtukey",
"ptukey",
"qtukey",
"rchisq",
"rexp",
"rgeom",
"rpois",
"rt",
"rsignrank",
"rbeta",
"rbinom",
"rcauchy",
"rf",
"rgamma",
"rlnorm",
"rlogis",
"rnbinom",
"rnbinom_mu",
"rnchisq",
"rnorm",
"runif",
"rweibull",
"rwilcox",
"rhyper",
"sample2",
"format.info",
"grepRaw",
"regexec",
"adist",
"aregexec",
"chartr",
"intToBits",
"rawToBits",
"packBits",
"utf8ToInt",
"intToUtf8",
"strtrim",
"eapply",
"machine",
"save",
"saveToConn",
"dput",
"dump",
"prmatrix",
"gcinfo",
"gctorture",
"gctorture2",
"memory.profile",
"recordGraphics",
"sys.calls",
"sys.on.exit",
"rank",
"builtins",
"bodyCode",
"rapply",
"islistfactor",
"inspect",
"mem.limits",
"merge",
"capabilitiesX11",
"Cstack_info",
"file.show",
"file.choose",
"polyroot",
"mkCode",
"bcClose",
"is.builtin.internal",
"disassemble",
"bcVersion",
"load.from.file",
"save.to.file",
"growconst",
"putconst",
"getconst",
"enableJIT",
"setNumMathThreads",
"setMaxNumMathThreads",
"isatty",
"isIncomplete",
"pipe",
"fifo",
"bzfile",
"xzfile",
"unz",
"truncate",
"rawConnection",
"rawConnectionValue",
"sockSelect",
"gzcon",
"memCompress",
"memDecompress",
"mkUnbound",
"env.profile",
"setTimeLimit",
"setSessionTimeLimit",
"icuSetCollate",
"lazyLoadDBflush",
"findInterval",
"pretty",
"crc64",
"rowsum_matrix",
"rowsum_df",
"setS4Object",
"traceOnOff",
"La_qr_cmplx",
"La_rs_cmplx",
"La_rg_cmplx",
"La_rs",
"La_rs_cmplx",
"La_dlange",
"La_dgecon",
"La_dtrcon",
"La_zgecon",
"La_ztrcon",
"La_solve_cmplx",
"La_chol2inv",
"qr_qy_real",
"qr_coef_cmplx",
"qr_qy_cmpl",
"La_svd",
"La_svd_cmplx"
};
}
final class PositionsCheckNode extends Node {
@Children private final PositionCheckNode[] positionsCheck;
private final ElementAccessMode mode;
private final BranchProfile errorBranch = BranchProfile.create();
private final VectorLengthProfile selectedPositionsCountProfile = VectorLengthProfile.create();
private final VectorLengthProfile maxOutOfBoundsProfile = VectorLengthProfile.create();
private final ConditionProfile containsNAProfile = ConditionProfile.createBinaryProfile();
private final BranchProfile unsupportedProfile = BranchProfile.create();
private final boolean replace;
private final int positionsLength;
PositionsCheckNode(
ElementAccessMode mode,
RType containerType,
Object[] positions,
boolean exact,
boolean replace,
boolean recursive) {
this.mode = mode;
this.replace = replace;
this.positionsCheck = new PositionCheckNode[positions.length];
for (int i = 0; i < positions.length; i++) {
positionsCheck[i] =
PositionCheckNode.createNode(
mode, containerType, positions[i], i, positions.length, exact, replace, recursive);
}
this.positionsLength = positions.length;
}
public PositionCheckNode getPositionCheckAt(int index) {
return positionsCheck[index];
}
@ExplodeLoop
public boolean isSupported(Object[] positions) {
if (positionsCheck.length != positions.length) {
unsupportedProfile.enter();
return false;
}
for (int i = 0; i < positionsCheck.length; i++) {
if (!positionsCheck[i].isSupported(positions[i])) {
unsupportedProfile.enter();
return false;
}
}
return true;
}
public int getDimensions() {
return positionsCheck.length;
}
public boolean isSingleDimension() {
return positionsCheck.length == 1;
}
public boolean isMultiDimension() {
return positionsCheck.length > 1;
}
@ExplodeLoop
public PositionProfile[] executeCheck(
RAbstractContainer vector, int[] vectorDimensions, int vectorLength, Object[] positions) {
assert isSupported(positions);
verifyDimensions(vectorDimensions);
PositionProfile[] statistics = new PositionProfile[positionsLength];
for (int i = 0; i < positionsLength; i++) {
Object position = positions[i];
PositionProfile profile = new PositionProfile();
positions[i] =
positionsCheck[i].execute(profile, vector, vectorDimensions, vectorLength, position);
statistics[i] = profile;
}
return statistics;
}
@TruffleBoundary
private void print() {
System.out.println(positionsCheck.length);
}
private void verifyDimensions(int[] vectorDimensions) {
if (vectorDimensions == null) {
if (isMultiDimension()) {
errorBranch.enter();
throw dimensionsError();
}
} else {
if (getDimensions() > vectorDimensions.length || getDimensions() < vectorDimensions.length) {
errorBranch.enter();
throw dimensionsError();
}
}
}
private RError dimensionsError() {
if (replace) {
if (mode.isSubset()) {
if (getDimensions() == 2) {
return RError.error(this, RError.Message.INCORRECT_SUBSCRIPTS_MATRIX);
} else {
return RError.error(this, RError.Message.INCORRECT_SUBSCRIPTS);
}
} else {
return RError.error(this, RError.Message.IMPROPER_SUBSCRIPT);
}
} else {
return RError.error(this, RError.Message.INCORRECT_DIMENSIONS);
}
}
@ExplodeLoop
public int getSelectedPositionsCount(PositionProfile[] profiles) {
if (positionsCheck.length == 1) {
return selectedPositionsCountProfile.profile(profiles[0].selectedPositionsCount);
} else {
int newSize = 1;
for (int i = 0; i < positionsCheck.length; i++) {
newSize *= profiles[i].selectedPositionsCount;
}
return selectedPositionsCountProfile.profile(newSize);
}
}
public int getCachedSelectedPositionsCount() {
return selectedPositionsCountProfile.getCachedLength();
}
@ExplodeLoop
public boolean getContainsNA(PositionProfile[] profiles) {
if (positionsCheck.length == 1) {
return containsNAProfile.profile(profiles[0].containsNA);
} else {
boolean containsNA = false;
for (int i = 0; i < positionsCheck.length; i++) {
containsNA |= profiles[i].containsNA;
}
return containsNAProfile.profile(containsNA);
}
}
@ExplodeLoop
public int getMaxOutOfBounds(PositionProfile[] replacementStatistics) {
if (positionsCheck.length == 1) {
return maxOutOfBoundsProfile.profile(replacementStatistics[0].maxOutOfBoundsIndex);
} else {
// impossible to be relevant as position check will throw an error in this case.
return 0;
}
}
public boolean isMissing() {
return positionsCheck.length == 1
&& //
(positionsCheck[0].getPositionClass() == RMissing.class
|| positionsCheck[0].getPositionClass() == REmpty.class
|| //
positionsCheck[0].getPositionClass() == RSymbol.class);
}
final class PositionProfile {
int selectedPositionsCount;
int maxOutOfBoundsIndex;
boolean containsNA;
}
}
@Specialization
protected Object doInternal(@SuppressWarnings("unused") RMissing x) {
errorProfile.enter();
throw RError.error(this, RError.Message.ARGUMENTS_PASSED_0_1, getRBuiltin().name());
}
@RBuiltin(
name = ".Call.graphics",
kind = RBuiltinKind.PRIMITIVE,
parameterNames = {".NAME", "...", "PACKAGE"})
public abstract static class DotCallGraphics extends LookupAdapter {
private final BranchProfile errorProfile = BranchProfile.create();
@Override
public Object[] getDefaultParameterValues() {
return new Object[] {RMissing.instance, RArgsValuesAndNames.EMPTY, RMissing.instance};
}
@Override
protected RExternalBuiltinNode lookupBuiltin(RList f) {
switch (lookupName(f)) {
default:
return null;
}
}
@SuppressWarnings("unused")
@Specialization(
limit = "1",
guards = {"cached == f", "builtin != null"})
protected Object doExternal(
RList f,
RArgsValuesAndNames args,
RMissing packageName, //
@Cached("f") RList cached, //
@Cached("lookupBuiltin(f)") RExternalBuiltinNode builtin) {
controlVisibility();
return builtin.call(args);
}
@Specialization
public Object callNamedFunction(
VirtualFrame frame,
RList symbol,
RArgsValuesAndNames args,
@SuppressWarnings("unused") Object packageName) {
return RFFIFactory.getRFFI()
.getCallRFFI()
.invokeCall(
getAddressFromSymbolInfo(frame, symbol),
getNameFromSymbolInfo(frame, symbol),
args.getArguments());
}
@Specialization
public Object callNamedFunction(
String name, RArgsValuesAndNames args, @SuppressWarnings("unused") RMissing packageName) {
return callNamedFunctionWithPackage(name, args, null);
}
@Specialization
public Object callNamedFunctionWithPackage(
String name, RArgsValuesAndNames args, String packageName) {
controlVisibility();
SymbolInfo symbolInfo = DLL.findSymbolInfo(name, packageName);
if (symbolInfo == null) {
errorProfile.enter();
throw RError.error(this, Message.C_SYMBOL_NOT_IN_TABLE, name);
}
return RFFIFactory.getRFFI()
.getCallRFFI()
.invokeCall(symbolInfo.address, symbolInfo.symbol, args.getArguments());
}
@Fallback
protected Object dotCallFallback(
Object fobj,
@SuppressWarnings("unused") Object args,
@SuppressWarnings("unused") Object packageName) {
throw fallback(fobj);
}
}
@RBuiltin(
name = ".External.graphics",
kind = RBuiltinKind.PRIMITIVE,
parameterNames = {".NAME", "...", "PACKAGE"})
public abstract static class DotExternalGraphics extends LookupAdapter {
private final BranchProfile errorProfile = BranchProfile.create();
@Override
protected RExternalBuiltinNode lookupBuiltin(RList f) {
if (FastROptions.UseInternalGraphics.getBooleanValue()) {
switch (lookupName(f)) {
case "C_mtext":
return new GraphicsCCalls.C_mtext();
case "C_plotXY":
return new C_PlotXY();
}
}
return null;
}
@SuppressWarnings("unused")
@Specialization(
limit = "1",
guards = {"cached == f", "builtin != null"})
protected Object doExternal(
RList f,
RArgsValuesAndNames args,
RMissing packageName, //
@Cached("f") RList cached, //
@Cached("lookupBuiltin(f)") RExternalBuiltinNode builtin) {
controlVisibility();
return builtin.call(args);
}
@Specialization
public Object callNamedFunction(
VirtualFrame frame,
RList symbol,
RArgsValuesAndNames args,
@SuppressWarnings("unused") Object packageName) {
String name = getNameFromSymbolInfo(frame, symbol);
Object list = encodeArgumentPairList(args, name);
return RFFIFactory.getRFFI()
.getCallRFFI()
.invokeCall(getAddressFromSymbolInfo(frame, symbol), name, new Object[] {list});
}
@Specialization
public Object callNamedFunction(
String name, RArgsValuesAndNames args, @SuppressWarnings("unused") RMissing packageName) {
return callNamedFunctionWithPackage(name, args, null);
}
@Specialization
public Object callNamedFunctionWithPackage(
String name, RArgsValuesAndNames args, String packageName) {
controlVisibility();
SymbolInfo symbolInfo = DLL.findSymbolInfo(name, packageName);
if (symbolInfo == null) {
errorProfile.enter();
throw RError.error(this, Message.C_SYMBOL_NOT_IN_TABLE, name);
}
Object list = encodeArgumentPairList(args, symbolInfo.symbol);
return RFFIFactory.getRFFI()
.getCallRFFI()
.invokeCall(symbolInfo.address, symbolInfo.symbol, new Object[] {list});
}
@Fallback
protected Object fallback(
Object f,
@SuppressWarnings("unused") Object args,
@SuppressWarnings("unused") Object packageName) {
throw fallback(f);
}
}
/**
* {@link WriteSuperFrameVariableNode} captures a write to a variable in some parent frame.
*
* <p>The state starts out a "unresolved" and transforms to "resolved".
*/
@SuppressWarnings("unused")
@NodeChildren({
@NodeChild(value = "enclosingFrame", type = AccessEnclosingFrameNode.class),
@NodeChild(value = "frameSlotNode", type = FrameSlotNode.class)
})
@NodeField(name = "mode", type = Mode.class)
public abstract class WriteSuperFrameVariableNode extends WriteSuperFrameVariableNodeHelper {
private final ValueProfile storedObjectProfile = ValueProfile.createClassProfile();
private final BranchProfile invalidateProfile = BranchProfile.create();
private final ValueProfile enclosingFrameProfile = ValueProfile.createClassProfile();
protected abstract FrameSlotNode getFrameSlotNode();
public abstract Mode getMode();
public static WriteVariableNode create(String name, RNode rhs, Mode mode) {
return new UnresolvedWriteSuperFrameVariableNode(name, rhs, mode);
}
@Specialization(guards = "isLogicalKind(frame, frameSlot)")
protected void doLogical(
VirtualFrame frame, byte value, MaterializedFrame enclosingFrame, FrameSlot frameSlot) {
FrameSlotChangeMonitor.setByteAndInvalidate(
enclosingFrameProfile.profile(enclosingFrame), frameSlot, value, true, invalidateProfile);
}
@Specialization(guards = "isIntegerKind(frame, frameSlot)")
protected void doInteger(
VirtualFrame frame, int value, MaterializedFrame enclosingFrame, FrameSlot frameSlot) {
FrameSlotChangeMonitor.setIntAndInvalidate(
enclosingFrameProfile.profile(enclosingFrame), frameSlot, value, true, invalidateProfile);
}
@Specialization(guards = "isDoubleKind(frame, frameSlot)")
protected void doDouble(
VirtualFrame frame, double value, MaterializedFrame enclosingFrame, FrameSlot frameSlot) {
FrameSlotChangeMonitor.setDoubleAndInvalidate(
enclosingFrameProfile.profile(enclosingFrame), frameSlot, value, true, invalidateProfile);
}
@Specialization
protected void doObject(
VirtualFrame frame, Object value, MaterializedFrame enclosingFrame, FrameSlot frameSlot) {
MaterializedFrame profiledFrame = enclosingFrameProfile.profile(enclosingFrame);
Object newValue =
shareObjectValue(
profiledFrame, frameSlot, storedObjectProfile.profile(value), getMode(), true);
FrameSlotChangeMonitor.setObjectAndInvalidate(
profiledFrame, frameSlot, newValue, true, invalidateProfile);
}
public static class UnresolvedWriteSuperFrameVariableNode
extends WriteSuperFrameVariableNodeHelper {
@Child private RNode rhs;
private final String symbol;
private final BaseWriteVariableNode.Mode mode;
public UnresolvedWriteSuperFrameVariableNode(
String symbol, RNode rhs, BaseWriteVariableNode.Mode mode) {
this.rhs = rhs;
this.symbol = symbol;
this.mode = mode;
}
@Override
public String getName() {
return symbol;
}
@Override
public RNode getRhs() {
return rhs;
}
@Override
public void execute(VirtualFrame frame, Object value, MaterializedFrame enclosingFrame) {
CompilerDirectives.transferToInterpreterAndInvalidate();
if (getName().isEmpty()) {
throw RError.error(this, RError.Message.ZERO_LENGTH_VARIABLE);
}
final WriteSuperFrameVariableNodeHelper writeNode;
if (REnvironment.isGlobalEnvFrame(enclosingFrame)) {
/*
* we've reached the global scope, do unconditional write. if this is the first node
* in the chain, needs the rhs and enclosingFrame nodes
*/
AccessEnclosingFrameNode enclosingFrameNode =
RArguments.getEnclosingFrame(frame) == enclosingFrame
? new AccessEnclosingFrameNode()
: null;
writeNode =
WriteSuperFrameVariableNodeGen.create(
getRhs(),
enclosingFrameNode,
FrameSlotNode.create(
findOrAddFrameSlot(
enclosingFrame.getFrameDescriptor(), symbol, FrameSlotKind.Illegal)),
getName(),
mode);
} else {
WriteSuperFrameVariableNode actualWriteNode =
WriteSuperFrameVariableNodeGen.create(
null, null, FrameSlotNode.create(symbol), this.getName(), mode);
writeNode =
new WriteSuperFrameVariableConditionalNode(
actualWriteNode,
new UnresolvedWriteSuperFrameVariableNode(symbol, null, mode),
getRhs());
}
replace(writeNode).execute(frame, value, enclosingFrame);
}
@Override
public void execute(VirtualFrame frame, Object value) {
CompilerDirectives.transferToInterpreterAndInvalidate();
MaterializedFrame enclosingFrame = RArguments.getEnclosingFrame(frame);
if (enclosingFrame != null) {
execute(frame, value, enclosingFrame);
} else {
// we're in global scope, do a local write instead
replace(UnresolvedWriteLocalFrameVariableNodeGen.create(getRhs(), symbol, mode))
.execute(frame, value);
}
}
}
public static class WriteSuperFrameVariableConditionalNode
extends WriteSuperFrameVariableNodeHelper {
@Child private WriteSuperFrameVariableNode writeNode;
@Child private WriteSuperFrameVariableNodeHelper nextNode;
@Child private RNode rhs;
private final ValueProfile enclosingFrameProfile = ValueProfile.createClassProfile();
private final ConditionProfile hasValueProfile = ConditionProfile.createBinaryProfile();
private final ConditionProfile nullSuperFrameProfile = ConditionProfile.createBinaryProfile();
WriteSuperFrameVariableConditionalNode(
WriteSuperFrameVariableNode writeNode,
WriteSuperFrameVariableNodeHelper nextNode,
RNode rhs) {
this.writeNode = writeNode;
this.nextNode = nextNode;
this.rhs = rhs;
}
@Override
public Object getName() {
return writeNode.getName();
}
@Override
public RNode getRhs() {
return rhs;
}
@Override
public void execute(VirtualFrame frame, Object value, MaterializedFrame enclosingFrame) {
MaterializedFrame profiledEnclosingFrame = enclosingFrameProfile.profile(enclosingFrame);
if (hasValueProfile.profile(writeNode.getFrameSlotNode().hasValue(profiledEnclosingFrame))) {
writeNode.execute(frame, value, profiledEnclosingFrame);
} else {
MaterializedFrame superFrame = RArguments.getEnclosingFrame(profiledEnclosingFrame);
if (nullSuperFrameProfile.profile(superFrame == null)) {
// Might be the case if "{ x <<- 42 }": This is in globalEnv!
superFrame = REnvironment.globalEnv().getFrame();
}
nextNode.execute(frame, value, superFrame);
}
}
@Override
public void execute(VirtualFrame frame, Object value) {
assert RArguments.getEnclosingFrame(frame) != null;
execute(frame, value, RArguments.getEnclosingFrame(frame));
}
}
}
@RBuiltin(
name = ".External2",
kind = RBuiltinKind.PRIMITIVE,
parameterNames = {".NAME", "...", "PACKAGE"})
public abstract static class DotExternal2 extends LookupAdapter {
private static final Object CALL = "call";
private static final Object OP = "op";
private static final Object RHO = "rho";
private final BranchProfile errorProfile = BranchProfile.create();
@Override
protected RExternalBuiltinNode lookupBuiltin(RList f) {
if (FastROptions.UseInternalGraphics.getBooleanValue()) {
switch (lookupName(f)) {
case "C_par":
return new C_Par();
}
}
String name = lookupName(f);
switch (name) {
// tools
case "writetable":
return new WriteTable();
case "typeconvert":
return TypeConvertNodeGen.create();
case "C_parseRd":
return C_ParseRdNodeGen.create();
default:
return null;
}
}
@SuppressWarnings("unused")
@Specialization(
limit = "1",
guards = {"cached == f", "builtin != null"})
protected Object doExternal(
RList f,
RArgsValuesAndNames args,
RMissing packageName, //
@Cached("f") RList cached, //
@Cached("lookupBuiltin(f)") RExternalBuiltinNode builtin) {
controlVisibility();
return builtin.call(args);
}
@Specialization
public Object callNamedFunction(
VirtualFrame frame,
RList symbol,
RArgsValuesAndNames args,
@SuppressWarnings("unused") Object packageName) {
String name = getNameFromSymbolInfo(frame, symbol);
Object list = encodeArgumentPairList(args, name);
// TODO: provide proper values for the CALL, OP and RHO parameters
return RFFIFactory.getRFFI()
.getCallRFFI()
.invokeCall(
getAddressFromSymbolInfo(frame, symbol), name, new Object[] {CALL, OP, list, RHO});
}
@Specialization
public Object callNamedFunction(
String name, RArgsValuesAndNames args, @SuppressWarnings("unused") RMissing packageName) {
return callNamedFunctionWithPackage(name, args, null);
}
@Specialization
public Object callNamedFunctionWithPackage(
String name, RArgsValuesAndNames args, String packageName) {
controlVisibility();
SymbolInfo symbolInfo = DLL.findSymbolInfo(name, packageName);
if (symbolInfo == null) {
errorProfile.enter();
throw RError.error(this, Message.C_SYMBOL_NOT_IN_TABLE, name);
}
Object list = encodeArgumentPairList(args, symbolInfo.symbol);
// TODO: provide proper values for the CALL, OP and RHO parameters
return RFFIFactory.getRFFI()
.getCallRFFI()
.invokeCall(symbolInfo.address, symbolInfo.symbol, new Object[] {CALL, OP, list, RHO});
}
@Fallback
protected Object fallback(
Object f,
@SuppressWarnings("unused") Object args,
@SuppressWarnings("unused") Object packageName) {
throw fallback(f);
}
}
@RBuiltin(
name = ".External",
kind = RBuiltinKind.PRIMITIVE,
parameterNames = {".NAME", "...", "PACKAGE"})
public abstract static class DotExternal extends LookupAdapter {
private final BranchProfile errorProfile = BranchProfile.create();
@Override
protected RExternalBuiltinNode lookupBuiltin(RList f) {
String name = lookupName(f);
if (FastROptions.UseInternalGraphics.getBooleanValue()) {
switch (name) {
case "PDF":
return new DevicesCCalls.C_PDF();
case "devoff":
return new DevicesCCalls.C_DevOff();
case "devcur":
return new DevicesCCalls.C_DevCur();
}
}
switch (name) {
case "compcases":
return new CompleteCases();
// utils
case "countfields":
return new CountFields();
case "readtablehead":
return new ReadTableHead();
case "rnorm":
return RnormNodeGen.create();
case "runif":
return RunifNodeGen.create();
case "qgamma":
return QgammaNodeGen.create();
case "download":
return new Download();
case "unzip":
case "Rprof":
case "Rprofmem":
case "addhistory":
case "loadhistory":
case "savehistory":
case "dataentry":
case "dataviewer":
case "edit":
case "fileedit":
case "selectlist":
return new UnimplementedExternal(name);
default:
return null;
}
}
@SuppressWarnings("unused")
@Specialization(
limit = "1",
guards = {"cached == f", "builtin != null"})
protected Object doExternal(
RList f,
RArgsValuesAndNames args,
RMissing packageName, //
@Cached("f") RList cached, //
@Cached("lookupBuiltin(f)") RExternalBuiltinNode builtin) {
controlVisibility();
return builtin.call(args);
}
@Specialization
public Object callNamedFunction(
VirtualFrame frame,
RList symbol,
RArgsValuesAndNames args,
@SuppressWarnings("unused") Object packageName) {
String name = getNameFromSymbolInfo(frame, symbol);
Object list = encodeArgumentPairList(args, name);
return RFFIFactory.getRFFI()
.getCallRFFI()
.invokeCall(getAddressFromSymbolInfo(frame, symbol), name, new Object[] {list});
}
@Specialization
public Object callNamedFunction(
String name, RArgsValuesAndNames args, @SuppressWarnings("unused") RMissing packageName) {
return callNamedFunctionWithPackage(name, args, null);
}
@Specialization
public Object callNamedFunctionWithPackage(
String name, RArgsValuesAndNames args, String packageName) {
controlVisibility();
SymbolInfo symbolInfo = DLL.findSymbolInfo(name, packageName);
if (symbolInfo == null) {
errorProfile.enter();
throw RError.error(this, Message.C_SYMBOL_NOT_IN_TABLE, name);
}
Object list = encodeArgumentPairList(args, symbolInfo.symbol);
return RFFIFactory.getRFFI()
.getCallRFFI()
.invokeCall(symbolInfo.address, symbolInfo.symbol, new Object[] {list});
}
@Fallback
protected Object fallback(
Object f,
@SuppressWarnings("unused") Object args,
@SuppressWarnings("unused") Object packageName) {
throw fallback(f);
}
}
/**
* Handles the generic case, but also many special case functions that are called from the default
* packages.
*/
@RBuiltin(
name = ".Call",
kind = RBuiltinKind.PRIMITIVE,
parameterNames = {".NAME", "...", "PACKAGE"})
public abstract static class DotCall extends LookupAdapter {
private final BranchProfile errorProfile = BranchProfile.create();
@Override
public Object[] getDefaultParameterValues() {
return new Object[] {RMissing.instance, RArgsValuesAndNames.EMPTY, RMissing.instance};
}
@Override
protected RExternalBuiltinNode lookupBuiltin(RList f) {
String name = lookupName(f);
switch (name) {
// methods
case "R_initMethodDispatch":
return R_initMethodDispatchNodeGen.create();
case "R_methodsPackageMetaName":
return R_methodsPackageMetaNameNodeGen.create();
case "R_set_method_dispatch":
return R_set_method_dispatchNodeGen.create();
case "R_M_setPrimitiveMethods":
return R_M_setPrimitiveMethodsNodeGen.create();
case "R_getClassFromCache":
return R_getClassFromCacheNodeGen.create();
case "R_clear_method_selection":
case "R_dummy_extern_place":
case "R_el_named":
return new UnimplementedExternal(name);
case "R_externalptr_prototype_object":
return R_externalPtrPrototypeObjectNodeGen.create();
case "R_getGeneric":
return R_getGenericNodeGen.create();
case "R_get_slot":
return R_getSlotNodeGen.create();
case "R_hasSlot":
return new UnimplementedExternal(name);
case "R_identC":
return R_identCNodeGen.create();
case "R_methods_test_MAKE_CLASS":
case "R_methods_test_NEW":
case "R_missingArg":
case "R_nextMethodCall":
return R_nextMethodCallNodeGen.create();
case "R_quick_method_check":
case "R_selectMethod":
case "R_set_el_named":
return new UnimplementedExternal(name);
case "R_set_slot":
return R_setSlotNodeGen.create();
case "R_standardGeneric":
return new UnimplementedExternal(name);
case "do_substitute_direct":
return SubstituteDirectNodeGen.create();
case "Rf_allocS4Object":
case "R_get_primname":
return new UnimplementedExternal(name);
case "new_object":
return NewObjectNodeGen.create();
// stats
case "fft":
return new Fft();
case "cov":
return new Covcor(false);
case "cor":
return new Covcor(true);
case "SplineCoef":
return SplineCoefNodeGen.create();
case "SplineEval":
return SplineEvalNodeGen.create();
case "cutree":
case "isoreg":
case "monoFC_m":
case "numeric_deriv":
case "nls_iter":
case "setup_starma":
case "free_starma":
case "set_trans":
case "arma0fa":
case "get_s2":
case "get_resid":
case "Dotrans":
case "arma0_kfore":
case "Starma_method":
case "Invtrans":
case "Gradtrans":
case "ARMAtoMA":
case "KalmanLike":
case "KalmanFore":
case "KalmanSmooth":
case "ARIMA_undoPars":
case "ARIMA_transPars":
case "ARIMA_Invtrans":
case "ARIMA_Gradtrans":
case "ARIMA_Like":
case "ARIMA_CSS":
case "TSconv":
case "getQ0":
case "getQ0bis":
case "port_ivset":
case "port_nlminb":
case "port_nlsb":
case "logit_link":
case "logit_linkinv":
case "logit_mu_eta":
case "binomial_dev_resids":
case "rWishart":
case "Cdqrls":
case "Cdist":
case "updateform":
case "mvfft":
case "nextn":
case "r2dtable":
case "cfilter":
case "rfilter":
case "lowess":
case "DoubleCentre":
case "BinDist":
case "Rsm":
case "tukeyline":
case "runmed":
case "influence":
case "pSmirnov2x":
case "pKolmogorov2x":
case "pKS2":
case "ksmooth":
case "Approx":
case "ApproxTest":
case "LogLin":
case "pAnsari":
case "qAnsari":
case "pKendall":
case "pRho":
case "SWilk":
case "bw_den":
case "bw_ucv":
case "bw_bcv":
case "bw_phi4":
case "bw_phi6":
case "acf":
case "pacf1":
case "ar2ma":
case "Burg":
case "intgrt_vec":
case "pp_sum":
case "Fexact":
case "Fisher_sim":
case "chisq_sim":
case "d2x2xk":
return new UnimplementedExternal(name);
// tools
case "doTabExpand":
return DoTabExpandNodeGen.create();
case "codeFilesAppend":
return CodeFilesAppendNodeGen.create();
case "Rmd5":
return Rmd5NodeGen.create();
case "dirchmod":
return DirChmodNodeGen.create();
case "delim_match":
case "C_getfmts":
case "check_nonASCII":
case "check_nonASCII2":
case "ps_kill":
case "ps_sigs":
case "ps_priority":
case "startHTTPD":
case "stopHTTPD":
case "C_deparseRd":
return new UnimplementedExternal(name);
// utils
case "crc64":
return Crc64NodeGen.create();
case "flushconsole":
return new Flushconsole();
case "menu":
return MenuNodeGen.create();
case "nsl":
case "objectSize":
case "processevents":
case "octsize":
case "sockconnect":
case "sockread":
case "sockclose":
case "sockopen":
case "socklisten":
case "sockwrite":
return new UnimplementedExternal(name);
// grDevices
case "cairoProps":
return CairoPropsNodeGen.create();
case "makeQuartzDefault":
return new MakeQuartzDefault();
// grid
case "L_initGrid":
return InitGridNodeGen.create();
default:
return null;
}
}
@SuppressWarnings("unused")
@Specialization(
limit = "1",
guards = {"cached == f", "builtin != null"})
protected Object doExternal(
RList f,
RArgsValuesAndNames args,
RMissing packageName, //
@Cached("f") RList cached, //
@Cached("lookupBuiltin(f)") RExternalBuiltinNode builtin) {
controlVisibility();
return builtin.call(args);
}
@Specialization
public Object callNamedFunction(
VirtualFrame frame,
RList symbol,
RArgsValuesAndNames args,
@SuppressWarnings("unused") Object packageName) {
controlVisibility();
return RFFIFactory.getRFFI()
.getCallRFFI()
.invokeCall(
getAddressFromSymbolInfo(frame, symbol),
getNameFromSymbolInfo(frame, symbol),
args.getArguments());
}
@Specialization
public Object callNamedFunction(
String name, RArgsValuesAndNames args, @SuppressWarnings("unused") RMissing packageName) {
return callNamedFunctionWithPackage(name, args, null);
}
@Specialization
public Object callNamedFunctionWithPackage(
String name, RArgsValuesAndNames args, String packageName) {
controlVisibility();
SymbolInfo symbolInfo = DLL.findSymbolInfo(name, packageName);
if (symbolInfo == null) {
errorProfile.enter();
throw RError.error(this, Message.C_SYMBOL_NOT_IN_TABLE, name);
}
return RFFIFactory.getRFFI()
.getCallRFFI()
.invokeCall(symbolInfo.address, symbolInfo.symbol, args.getArguments());
}
@Fallback
protected Object dotCallFallback(
Object fobj,
@SuppressWarnings("unused") Object args,
@SuppressWarnings("unused") Object packageName) {
throw fallback(fobj);
}
}