Uses of Interface
edu.vub.at.objects.ATContext

Packages that use ATContext

edu.vub.at
edu.vub.at.eval
edu.vub.at.objects
edu.vub.at.objects.mirrors
edu.vub.at.objects.natives
edu.vub.at.objects.natives.grammar
edu.vub.at.objects.symbiosis

Uses of ATContext in edu.vub.at

Fields in edu.vub.at declared as ATContext

protected ATContext	AmbientTalkTestCase.ctx_
protected ATContext	AmbientTalkTest.ctx_
private ATContext	OBJUnit.ctx_

Methods in edu.vub.at with parameters of type ATContext

protected void	AmbientTalkTestCase.evaluateInput(java.lang.String input, ATContext ctx)
static ATObject	AmbientTalkTest.evalSnippet(java.lang.Class forTestClass, java.lang.String name, ATContext inContext) Loads and evaluates the content of a code snippet file and returns the resulting AmbientTalk ATObject.

Uses of ATContext in edu.vub.at.eval

Methods in edu.vub.at.eval with parameters of type ATContext

protected abstract void	PartialBinder.bind(ATObject[] arguments, ATContext inContext, PartialBinder.BindClosure binder) Bind the given actual arguments to the formal parameters encapsulated by this partial bind function.
static void	PartialBinder.defineParamsForArgs(PartialBinder residual, ATContext context, ATTable arguments) Bind all of the given parameters as newly defined slots in the given scope to the given arguments.
static void	PartialBinder.assignArgsToParams(PartialBinder residual, ATContext context, ATTable arguments) Assign all of the formal parameter names in the scope object to the given arguments The scope is defined as the lexical scope of the given context.
static NATTable	Evaluator.evaluateArguments(NATTable args, ATContext ctx) This function is called whenever arguments to a function, message, method need to be evaluated.
private static void	Evaluator.bindArguments(java.lang.String funnam, ATContext context, ATTable parameters, ATTable arguments, Evaluator.BindClosure binder) Deprecated. use partial evalation using PartialBinder.bind(ATObject[], ATContext, edu.vub.at.eval.PartialBinder.BindClosure) instead.
static void	Evaluator.defineParamsForArgs(java.lang.String funnam, ATContext context, ATTable parameters, ATTable arguments) Deprecated. use partial evalation using PartialBinder.bind(ATObject[], ATContext, edu.vub.at.eval.PartialBinder.BindClosure) instead.
static void	Evaluator.assignArgsToParams(java.lang.String funnam, ATContext context, ATTable parameters, ATTable arguments) Deprecated. use partial evalation using PartialBinder.bind(ATObject[], ATContext, edu.vub.at.eval.PartialBinder.BindClosure) instead.
static NATTable	Evaluator.evalMandatoryPars(ATTable formals, ATContext ctx) Given a formal parameter list, this auxiliary method returns a new table consisting of the values of the bindings of the mandatory parameters of formals within the context ctx.

Uses of ATContext in edu.vub.at.objects

Methods in edu.vub.at.objects that return ATContext

ATContext	ATContext.base_withLexicalEnvironment(ATObject scope)
ATContext	ATContext.base_withDynamicReceiver(ATObject self)
ATContext	ATClosure.base_getContext() Structural access to the scope of the closure.

Methods in edu.vub.at.objects with parameters of type ATContext

ATObject	ATMethod.base_apply(ATTable arguments, ATContext ctx) Applies the method to the given arguments in the given context.
ATObject	ATMethod.base_applyInScope(ATTable arguments, ATContext ctx) Applies the method to the given arguments in the given context.
ATObject	ATObject.meta_eval(ATContext ctx) Evaluates a particular parsetree with respect to a particular context.
ATObject	ATObject.meta_quote(ATContext ctx) Quotes a parsetree, in other words allows the parsetree to return itself instead of evaluating.

Uses of ATContext in edu.vub.at.objects.mirrors

Methods in edu.vub.at.objects.mirrors that return ATContext

ATContext

NativeClosure.base_getContext() Overridden to allow for lazy instantiation of the context.

Methods in edu.vub.at.objects.mirrors with parameters of type ATContext

protected void	ReflectiveAccessTest.evaluateInput(java.lang.String input, ATContext ctx)
abstract ATObject	PrimitiveMethod.base_apply(ATTable arguments, ATContext ctx)
ATObject	PrimitiveMethod.base_applyInScope(ATTable arguments, ATContext ctx)
ATObject	NATMirage.magic_eval(ATContext ctx)
ATObject	NATMirage.magic_quote(ATContext ctx)
ATObject	NATMirage.meta_eval(ATContext ctx)
ATObject	NATMirage.meta_quote(ATContext ctx)
ATObject	NativeMethod.base_apply(ATTable arguments, ATContext ctx)
ATObject	NativeMethod.base_applyInScope(ATTable arguments, ATContext ctx)
ATObject	NativeAnonymousMethod.base_apply(ATTable arguments, ATContext ctx) It is an error to directly apply an anonymous method.
ATObject	NativeAnonymousMethod.base_applyInScope(ATTable arguments, ATContext ctx)

Uses of ATContext in edu.vub.at.objects.natives

Classes in edu.vub.at.objects.natives that implement ATContext

class

NATContext NATContext is a purely functional implementation of the ATContext interface.

Fields in edu.vub.at.objects.natives declared as ATContext

protected ATContext

NATClosure.context_

Methods in edu.vub.at.objects.natives that return ATContext

ATContext	NATContext.base_withLexicalEnvironment(ATObject scope)
ATContext	NATContext.base_withDynamicReceiver(ATObject self)
ATContext	NATClosure.base_getContext()

Methods in edu.vub.at.objects.natives with parameters of type ATContext

private static ATObject	OBJLexicalRoot.performImport(ATObject sourceObject, ATContext ctx, java.util.Hashtable aliases, java.util.HashSet exclude) Performs the actual copying of the slots from the source object to the importing object.
ATObject	NATTable.meta_eval(ATContext ctx) To evaluate a table, evaluate all of its constituent expressions, taking special care to take into account spliced expressions.
ATObject	NATTable.meta_quote(ATContext ctx) To quote a table, quote all elements of the table.
ATObject	NATObjectClosureTest.AGScopeTest.meta_eval(ATContext ctx)
ATObject	NATNil.meta_eval(ATContext ctx) All NATObjects which are not Abstract Grammar elements are self-evaluating.
ATObject	NATNil.meta_quote(ATContext ctx) Quoting a native object returns itself, except for pure AG elements.
ATObject	NATMethod.base_apply(ATTable arguments, ATContext ctx) To apply a function, first bind its parameters to the evaluated arguments within a new call frame.
ATObject	NATMethod.base_applyInScope(ATTable arguments, ATContext ctx) Applies the method in the context given, without first inserting a call frame to bind parameters.
ATObject	NATClosureMethod.base_apply(ATTable arguments, ATContext ctx) A closure method application acts exactly like a regular direct method application, except that the given lexical scope is disregarded and replaced by the lexical scope encapsulated by the closure method.
ATObject	NATClosureMethod.base_applyInScope(ATTable arguments, ATContext ctx)

Constructors in edu.vub.at.objects.natives with parameters of type ATContext

NATClosure(ATMethod method, ATContext context)

Uses of ATContext in edu.vub.at.objects.natives.grammar

Methods in edu.vub.at.objects.natives.grammar with parameters of type ATContext

ATObject	AGUnquoteSplice.meta_eval(ATContext ctx) An unquotation cannot be evaluated, but rather gives rise to an XIllegalUnquote exception.
ATObject	AGUnquoteSplice.meta_quote(ATContext ctx) Quoting a spliced unquotation means evaluating its contained expression, and returning its value as the result of the quote.
ATObject	AGUnquote.meta_eval(ATContext ctx) An unquotation cannot be evaluated, but rather gives rise to an XIllegalUnquote exception.
ATObject	AGUnquote.meta_quote(ATContext ctx) Quoting an unquotation means evaluating its contained expression, and returning its value as the result of the quote.
ATObject	AGTabulation.meta_eval(ATContext ctx) To evaluate a tabulation, evaluate the tabulation expression to a table, evaluate the index expression into a valid index, and then access the table at the given index slot.
ATObject	AGTabulation.meta_quote(ATContext ctx) Quoting a tabulation results in a new quoted tabulation AGTBL(tbl,idx).quote(ctx) = AGTBL(tbl.quote(ctx),idx.quote(ctx))
ATObject	AGSymbol.meta_eval(ATContext ctx) To evaluate a symbol reference, look up the symbol in the lexical scope.
ATObject	AGSymbol.meta_quote(ATContext ctx) Quoting a symbol results in the same symbol.
ATObject	AGSplice.meta_eval(ATContext ctx) A spliced element cannot be evaluated, but rather gives rise to an XIllegalSplice exception.
ATObject	AGSplice.meta_quote(ATContext ctx) Quoting a splice means quoting its contained expression, and returning a new splice.
ATObject	AGSelf.meta_eval(ATContext ctx) To evaluate a self reference, simply select the current self from the current evaluation context.
ATObject	AGSelf.meta_quote(ATContext ctx) Quoting a self reference results in the same self reference.
ATObject	AGSelection.meta_eval(ATContext ctx) To evaluate a selection, evaluate the receiver expression to an object and select the slot with the given name from that object.
ATObject	AGSelection.meta_quote(ATContext ctx) Quoting a selection results in a new quoted selection.
ATObject	AGQuote.meta_eval(ATContext ctx) To evaluate a quotation, start quoting its contained statement.
ATObject	AGQuote.meta_quote(ATContext ctx) Quoting a quotation results in a bare quotation, where quotations and unquotations are left unexpanded.
ATObject	AGMultiDefinition.meta_eval(ATContext ctx) To evaluate a multiple definition, evaluate the right hand side to a table and bind the parameters on the left hand side to the 'arguments' of the right hand side, exactly as if they were bound during a function call.
ATObject	AGMultiDefinition.meta_quote(ATContext ctx) AGMULTIDEF(par,val).quote(ctx) = AGMULTIDEF(par.quote(ctx), val.quote(ctx))
ATObject	AGMultiAssignment.meta_eval(ATContext ctx) To evaluate a multiple assignment, evaluate the right hand side to a table and assign the parameters on the left hand side to the 'arguments' of the right hand side, almost as if they were bound during a function call (the parameters are assigned instead of defined).
ATObject	AGMultiAssignment.meta_quote(ATContext ctx) AGMULTIASS(par,val).quote(ctx) = AGMULTIASS(par.quote(ctx), val.quote(ctx))
ATObject	AGMethodInvocationCreation.meta_eval(ATContext ctx) To evaluate a first-class synchronous message creation AG element, transform the selector and evaluated arguments into a first-class MethodInvocation.
ATObject	AGMessageSend.meta_eval(ATContext ctx) To evaluate a message send, evaluate the receiver expression into an object.
ATObject	AGMessageSend.meta_quote(ATContext ctx) Quoting a message send returns a new quoted message send.
ATObject	AGMessageCreation.meta_quote(ATContext ctx) Quoting a message creation element returns a new quoted message creation element.
ATObject	AGDelegationCreation.meta_eval(ATContext ctx) To evaluate a first-class delegation message creation AG element, transform the selector and evaluated arguments into a first-class NATDelegation object.
ATObject	AGDefTable.meta_eval(ATContext ctx) Defining a table requires evaluating its index expression to a size s, then allocating a new table of size s and finally initializing it by evaluating its initializer body s times.
ATObject	AGDefTable.meta_quote(ATContext ctx) Quoting a table definition results in a new quoted table definition.
ATObject	AGDefStripe.meta_eval(ATContext ctx) Defines a new stripe in the current scope.
ATObject	AGDefStripe.meta_quote(ATContext ctx) Quoting a stripe definition results in a new quoted stripe definition.
ATObject	AGDefFunction.meta_eval(ATContext ctx) Defines a new function (method or closure) in the current scope.
ATObject	AGDefFunction.meta_quote(ATContext ctx) Quoting a function definition results in a new quoted function definition.
ATObject	AGDefField.meta_eval(ATContext ctx) Defines a new field in the current scope.
ATObject	AGDefField.meta_quote(ATContext ctx) Quoting a field definition results in a new quoted field definition.
ATObject	AGDefExternalMethod.meta_eval(ATContext ctx) Evaluates the receiver symbol to an object to which a new 'closure method' will be added.
ATObject	AGDefExternalMethod.meta_quote(ATContext ctx) Quoting an external method definition results in a new quoted external method definition.
ATObject	AGDefExternalField.meta_eval(ATContext ctx) Defines a new field in the object denoted by the receiver symbol.
ATObject	AGDefExternalField.meta_quote(ATContext ctx) Quoting an external field definition results in a new quoted external field definition.
ATObject	AGClosureLiteral.meta_eval(ATContext ctx) To evaluate a closure literal, construct a closure pairing the literal's arguments and body with the current evaluation context.
ATObject	AGClosureLiteral.meta_quote(ATContext ctx) Quoting a closure literal results in a new quoted closure literal.
ATObject	AGBegin.meta_eval(ATContext ctx) AGBEGIN encapsulates a sequence of statements and evaluates each of these statements in turn.
ATObject	AGBegin.meta_quote(ATContext ctx) AGBEGIN(statements*).quote(ctx) = AGBEGIN((statements*).quote(ctx))
ATObject	AGAsyncMessageCreation.meta_eval(ATContext ctx) To evaluate an async message creation element, simply return a new native asynchronous message.
ATObject	AGAssignVariable.meta_eval(ATContext ctx) To evaluate a variable assignment, evaluate the right hand side and ask the current object to assign that value to the field corresponding to the left hand side.
ATObject	AGAssignVariable.meta_quote(ATContext ctx) AGASSVAR(nam,val).quote(ctx) = AGASSVAR(nam.quote(ctx), val.quote(ctx))
ATObject	AGAssignTable.meta_eval(ATContext ctx) To evaluate a table assignment, evaluate its table expression to a valid ATTable.
ATObject	AGAssignTable.meta_quote(ATContext ctx) Quoting a table assignment results in a new quoted table assignment.
ATObject	AGAssignField.meta_eval(ATContext ctx) To evaluate a field assignment, evaluate the receiver expression, evaluate the right hand side and ask the receiver object to assign the RHS value to the field corresponding to the given field name.
ATObject	AGAssignField.meta_quote(ATContext ctx) AGASSFIELD(rcv,nam,val).quote(ctx) = AGASSFIELD(rcv.quote(ctx), nam.quote(ctx), val.quote(ctx))
ATObject	AGApplication.meta_eval(ATContext ctx) To evaluate a function application, evaluate the receiver expression to a function, then evaluate the arguments to the function application eagerly and apply the function.
ATObject	AGApplication.meta_quote(ATContext ctx) Quoting an application results in a new quoted application.

Uses of ATContext in edu.vub.at.objects.symbiosis

Methods in edu.vub.at.objects.symbiosis that return ATContext

ATContext

JavaClosure.base_getContext() Overridden to allow for lazy instantiation of the context.

Methods in edu.vub.at.objects.symbiosis with parameters of type ATContext

ATObject	JavaMethod.base_apply(ATTable arguments, ATContext ctx)
ATObject	JavaMethod.base_applyInScope(ATTable arguments, ATContext ctx)