@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);
   }
 }
示例#2
0
    @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 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);
 }