Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   ***** BEGIN LICENSE BLOCK *****
   * Version: EPL 1.0/GPL 2.0/LGPL 2.1
   *
   * The contents of this file are subject to the Eclipse Public
   * License Version 1.0 (the "License"); you may not use this file
   * except in compliance with the License. You may obtain a copy of
   * the License at http://www.eclipse.org/legal/epl-v10.html
   *
  * Software distributed under the License is distributed on an "AS
  * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  * implied. See the License for the specific language governing
  * rights and limitations under the License.
  *
  * Copyright (C) 2006-2007 Thomas E Enebo <enebo@acm.org>
  * 
  * Alternatively, the contents of this file may be used under the terms of
  * either of the GNU General Public License Version 2 or later (the "GPL"),
  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  * in which case the provisions of the GPL or the LGPL are applicable instead
  * of those above. If you wish to allow use of your version of this file only
  * under the terms of either the GPL or the LGPL, and not to allow others to
  * use your version of this file under the terms of the EPL, indicate your
  * decision by deleting the provisions above and replace them with the notice
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the EPL, the GPL or the LGPL.
  ***** END LICENSE BLOCK *****/
 package org.jruby.ast;
 
 import java.util.List;
 
 import org.jruby.Ruby;
Node that represents an assignment of either an array element or attribute.
 
 public class AttrAssignNode extends Node implements INameNodeIArgumentNode {
     protected final Node receiverNode;
     private String name;
     private Node argsNode;
     public CallSite callAdapter;
 
     public AttrAssignNode(ISourcePosition positionNode receiverNodeString nameNode argsNode) {
         super(position);
         
         assert receiverNode != null : "receiverNode is not null";
         // TODO: At least ParserSupport.attrset passes argsNode as null.  ImplicitNil is wrong magic for 
         // setupArgs since it will IRubyObject[] { nil }.  So we need to figure out a nice fast
         // null pattern for setupArgs.
         // assert argsNode != null : "receiverNode is not null";
         
         this. = receiverNode;
         this. = name;
         setArgsInternal(argsNode);
         this. = receiverNode instanceof SelfNode ?
                 MethodIndex.getFunctionalCallSite(name) :
                 MethodIndex.getCallSite(name);
     }
 
     public NodeType getNodeType() {
         return .;
     }

    
Accept for the visitor pattern.

Parameters:
visitor the visitor
 
     public Object accept(NodeVisitor visitor) {
         return visitor.visitAttrAssignNode(this);
     }

    
Gets the name. name is the name of the method called

Returns:
name
 
     public String getName() {
         return ;
     }
    
    
Gets the receiverNode. receiverNode is the object on which the method is being called

Returns:
receiverNode
    public Node getReceiverNode() {
        return ;
    }
    
    
Gets the argsNode. argsNode representing the method's arguments' value for this call.

Returns:
argsNode
    public Node getArgsNode() {
        return ;
    }
    
    
    protected Node newAttrAssignNode(ArrayNode argsNode) {
        int size = argsNode.size();
        
        switch (size) {
            case 1:
                return new AttrAssignOneArgNode(getPosition(), argsNode);
            case 2:
                return new AttrAssignTwoArgNode(getPosition(), argsNode);
            case 3:
                return new AttrAssignThreeArgNode(getPosition(), argsNode);
            default:
                return new AttrAssignNode(getPosition(), argsNode);
        }
    }
    
    protected Node newMutatedAttrAssignNode(ArrayNode argsNode) {
        int size = argsNode.size();
        
        switch (size) {
            case 1:
                if (!(this instanceof AttrAssignOneArgNode)) {
                    return new AttrAssignOneArgNode(getPosition(), argsNode);
                } else {
                    return this;
                }
            case 2:
                if (!(this instanceof AttrAssignTwoArgNode)) {
                    return new AttrAssignTwoArgNode(getPosition(), argsNode);
                } else {
                    return this;
                }
            case 3:
                if (!(this instanceof AttrAssignThreeArgNode)) {
                    return new AttrAssignThreeArgNode(getPosition(), argsNode);
                } else {
                    return this;
                }
            default:
                return new AttrAssignNode(getPosition(), argsNode);
        }
    }
    
    
Set the argsNode

Parameters:
argsNode set the arguments for this node.
    public Node setArgsNode(Node argsNode) {
        // Empirical Observations:
        // null -> Some arity
        // argsNode == this.argsNode then check for arity changes
        // newline(splatnode) -> argspushnode
        if (this. == null && argsNode instanceof ArrayNode) {
            return newAttrAssignNode((ArrayNodeargsNode);
        } else if (this. == argsNode) {
            return newMutatedAttrAssignNode((ArrayNode)argsNode);
        }
        
        setArgsInternal(argsNode);
        
        return this;
    }
    
    private void setArgsInternal(Node argsNode) {
        this. = argsNode;
        
        if (argsNode instanceof ArrayNode) ((ArrayNode)argsNode).setLightweight(true);
    }
    public List<NodechildNodes() {
        return Node.createList();
    }
    @Override
    public IRubyObject interpret(Ruby runtimeThreadContext contextIRubyObject selfBlock aBlock) {
        IRubyObject receiver = .interpret(runtimecontextselfaBlock);
        IRubyObject[] args = ASTInterpreter.setupArgs(runtimecontextselfaBlock);
        
        assert hasMetaClass(receiver) : receiverClassName(receiver);
        
        // If reciever is self then we do the call the same way as vcall
        CallSite callSite;
        callSite = ;
        callSite.call(contextselfreceiverargs);
        return args[args.length - 1];
    }
    
    protected static boolean hasMetaClass(IRubyObject object) {
        return object.getMetaClass() != null;
    }
    
    protected static String receiverClassName(IRubyObject object) {
        return object.getClass().getName();
    }
    
    @Override
    public IRubyObject assign(Ruby runtimeThreadContext contextIRubyObject selfIRubyObject valueBlock blockboolean checkArity) {        
        IRubyObject receiver = .interpret(runtimecontextselfblock);
        
        // If reciever is self then we do the call the same way as vcall
        if (receiver == self) {
            return selfAssign(runtimecontextselfvalueblockcheckArity);
        } else {
            return otherAssign(runtimecontextselfvalueblockcheckArity);
        }
    }
    
    private IRubyObject selfAssign(Ruby runtimeThreadContext contextIRubyObject selfIRubyObject valueBlock blockboolean checkArity) {        
        IRubyObject receiver = .interpret(runtimecontextselfblock);
        
        if ( == null) { // attribute set.
            Helpers.invoke(contextreceivervalue);
        } else { // element set
            RubyArray args = (RubyArray.interpret(runtimecontextselfblock);
            args.append(value);
            Helpers.invoke(contextreceiverargs.toJavaArray());
        } 
        
        return runtime.getNil();
    }
    
    private IRubyObject otherAssign(Ruby runtimeThreadContext contextIRubyObject selfIRubyObject valueBlock blockboolean checkArity) {        
        IRubyObject receiver = .interpret(runtimecontextselfblock);
        if ( == null) { // attribute set.
            Helpers.invoke(contextreceivervalue..);
        } else { // element set
            RubyArray args = (RubyArray.interpret(runtimecontextselfblock);
            args.append(value);
            Helpers.invoke(contextreceiverargs.toJavaArray(), ..);
        } 
        
        return runtime.getNil();
    }
    
    @Override
    public RubyString definition(Ruby runtimeThreadContext contextIRubyObject selfBlock aBlock) {
        if (.definition(runtimecontextselfaBlock) != null) {
            try {
                IRubyObject receiver = .interpret(runtimecontextselfaBlock);
                RubyClass metaClass = receiver.getMetaClass();
                DynamicMethod method = metaClass.searchMethod();
                Visibility visibility = method.getVisibility();
                if (visibility != . && 
                        (visibility != . || metaClass.getRealClass().isInstance(self))) {
                    if (metaClass.isMethodBound(false)) {
                        return ASTInterpreter.getArgumentDefinition(runtimecontextruntime.getDefinedMessage(.), selfaBlock);
                    }
                }
            } catch (JumpException e) {
            }
        }
        return null;
    }
New to GrepCode? Check out our FAQ X