public int readFixnum(RubyBasicObject object, boolean condition)
throws UnexpectedResultException {
if (isSet(object)) {
return CompilerDirectives.unsafeGetInt(object, offset, condition, this);
} else {
throw new UnexpectedResultException(NilPlaceholder.INSTANCE);
}
}
@Override
public Object execute(VirtualFrame frame) {
if (CompilerDirectives.injectBranchProbability(
getBranchProbability(), condition.executeBoolean(frame))) {
if (CompilerDirectives.inInterpreter()) {
thenCount++;
}
thenProfile.enter();
return thenBody.execute(frame);
} else {
if (CompilerDirectives.inInterpreter()) {
elseCount++;
}
elseProfile.enter();
return elseBody.execute(frame);
}
}
@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);
}
}
@Override
public void setValue(VirtualFrame frame, PythonObject primary, Object value) {
CompilerDirectives.transferToInterpreterAndInvalidate();
assert primary.verifyLayout();
if (!primary.getStableAssumption().isValid()) {
primary.syncObjectLayoutWithClass();
}
assert primary.verifyLayout();
SetDispatchNode current = this;
int depth = 0;
while (current.getParent() instanceof SetDispatchNode) {
current = (SetDispatchNode) current.getParent();
depth++;
if (!(current instanceof LinkedSetDispatchNode)) {
continue;
}
/**
* After the layout sync, if a previously missed dispatch node caches the updated layout, we
* should reuse the existing dispatch node.
*/
LinkedSetDispatchNode linked = (LinkedSetDispatchNode) current;
try {
if (linked.check.accept(primary)) {
linked.setValue(frame, primary, value);
return;
}
} catch (InvalidAssumptionException e) {
throw new RuntimeException();
}
}
if (depth < PythonOptions.AttributeAccessInlineCacheMaxDepth) {
primary.setAttribute(attributeId, value);
StorageLocation location = primary.getOwnValidLocation(attributeId);
replace(
new LinkedSetDispatchNode(
attributeId, AttributeWriteNode.create(location), primary, this));
} else {
replace(new GenericSetDispatchNode(attributeId)).setValue(frame, primary, value);
}
}
@Override
public Object execute(VirtualFrame frame) {
while (true) {
try {
final Object result = tryPart.execute(frame);
elsePart.executeVoid(frame);
return result;
} catch (ControlFlowException exception) {
controlFlowProfile.enter();
throw exception;
} catch (RuntimeException exception) {
CompilerDirectives.transferToInterpreter();
try {
return handleException(frame, exception);
} catch (RetryException e) {
continue;
}
}
}
}
@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);
}
public void writeFixnum(RubyBasicObject object, int value) {
CompilerDirectives.unsafePutInt(object, offset, value, null);
markAsSet(object);
}
