/interpreter/tags/at2dist170907/src/edu/vub/at/objects/natives/NATClosureMethod.java
Java | 135 lines | 50 code | 17 blank | 68 comment | 0 complexity | 7d83bdca2d8fa2513ecd01cb6944064f MD5 | raw file
1/** 2 * AmbientTalk/2 Project 3 * NATClosureMethod.java created on 16-nov-2006 at 9:12:46 4 * (c) Programming Technology Lab, 2006 - 2007 5 * Authors: Tom Van Cutsem & Stijn Mostinckx 6 * 7 * Permission is hereby granted, free of charge, to any person 8 * obtaining a copy of this software and associated documentation 9 * files (the "Software"), to deal in the Software without 10 * restriction, including without limitation the rights to use, 11 * copy, modify, merge, publish, distribute, sublicense, and/or 12 * sell copies of the Software, and to permit persons to whom the 13 * Software is furnished to do so, subject to the following 14 * conditions: 15 * 16 * The above copyright notice and this permission notice shall be 17 * included in all copies or substantial portions of the Software. 18 * 19 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 20 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES 21 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 22 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT 23 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 24 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 25 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 26 * OTHER DEALINGS IN THE SOFTWARE. 27 */ 28package edu.vub.at.objects.natives; 29 30import edu.vub.at.exceptions.InterpreterException; 31import edu.vub.at.exceptions.XTypeMismatch; 32import edu.vub.at.objects.ATClosure; 33import edu.vub.at.objects.ATContext; 34import edu.vub.at.objects.ATMethod; 35import edu.vub.at.objects.ATObject; 36import edu.vub.at.objects.ATTable; 37import edu.vub.at.objects.coercion.NativeTypeTags; 38import edu.vub.at.objects.grammar.ATBegin; 39import edu.vub.at.objects.grammar.ATSymbol; 40 41/** 42 * A 'closure method' is literally a function that sits in between of a full closure and a method. 43 * It is a method that captures only its lexical scope of definition, but not the value of 'self' 44 * and 'super' which are active at that time. When invoked, the method is evaluated in its lexical 45 * scope, but with the values of 'self' and 'super' equal to those given to it at method invocation time. 46 * 47 * Closure methods are used to implement 'externally added' methods to objects. In such cases, 48 * the external methods can only access their own surrounding lexical scope (and not that of the actual 49 * object to which they are added), but their values for 'self' and 'super' will act as if the method 50 * was actually defined within the object itself. 51 * 52 * See the description of the ATDefExternalMethod interface for more information. 53 * 54 * @author tvcutsem 55 */ 56public class NATClosureMethod extends NATByRef implements ATMethod { 57 58 private final ATObject lexicalScope_; 59 private final ATMethod method_; 60 61 /** construct a new closure method */ 62 public NATClosureMethod(ATObject scope, ATMethod method) throws InterpreterException { 63 lexicalScope_ = scope; 64 method_ = method; 65 } 66 67 /** 68 * A closure method application acts exactly like a regular direct method application, except that 69 * the given lexical scope is disregarded and replaced by the lexical scope encapsulated by the 70 * closure method. The bindings for 'self' and 'super' remain intact. 71 * 72 * Closure methods are a result of external method definitions. 73 * 74 * @param arguments the evaluated actual arguments 75 * @param ctx the context whose 'self' binding will be used during the execution of the method. 76 * The lexical scope, however, will be replaced by the closure method's own lexical scope. A call frame will 77 * be inserted into this lexical scope before executing the method body. 78 * To ensure that 'super' points to the parent of the actual 'self' and not the parent of the object 79 * performing the external method definition, a 'super' field is added to the call frame shadowing 80 * the defining object's 'super' field. 81 * @return the value of evaluating the function body 82 */ 83 public ATObject base_apply(ATTable arguments, ATContext ctx) throws InterpreterException { 84 // should be: method_.base_apply(arguments, ctx.base_withLexicalEnvironment(lexicalScope_), 85 // but this version is more efficient, as we immediately create the right context, rather than 86 // creating a temporary context which will in turn be modified by method_.base_apply 87 88 // hostObject = the object to which the external method was added (actually the object in which 89 // the external method was now found) 90 ATObject hostObject = ctx.base_lexicalScope(); 91 ATObject hostParent = hostObject.base_super(); 92 93 NATCallframe externalFrame = new NATCallframe(lexicalScope_); 94 // super = the parent of the object to which this method was added 95 externalFrame.meta_defineField(NATObject._SUPER_NAME_, hostParent); 96 97 return method_.base_applyInScope(arguments, ctx.base_withLexicalEnvironment(externalFrame)); 98 } 99 100 public ATObject base_applyInScope(ATTable arguments, ATContext ctx) throws InterpreterException { 101 return method_.base_applyInScope(arguments, ctx); 102 } 103 104 public ATBegin base_bodyExpression() throws InterpreterException { 105 return method_.base_bodyExpression(); 106 } 107 108 public ATSymbol base_name() throws InterpreterException { 109 return method_.base_name(); 110 } 111 112 public ATTable base_parameters() throws InterpreterException { 113 return method_.base_parameters(); 114 } 115 116 /** 117 * When wrapping a closure method, return a closure that is bound to the given lexical scope. 118 */ 119 public ATClosure base_wrap(ATObject lexicalScope, ATObject dynamicReceiver) throws InterpreterException { 120 return method_.base_wrap(lexicalScope_, dynamicReceiver); 121 } 122 123 public NATText meta_print() throws InterpreterException { 124 return NATText.atValue("<closure:"+method_.base_name()+">"); 125 } 126 127 public ATMethod asMethod() throws XTypeMismatch { 128 return this; 129 } 130 131 public ATTable meta_typeTags() throws InterpreterException { 132 return NATTable.of(NativeTypeTags._METHOD_); 133 } 134 135}