Uses of Class
edu.vub.at.exceptions.InterpreterException

Packages that use InterpreterException

edu.vub.at
edu.vub.at.actors
edu.vub.at.actors.id
edu.vub.at.actors.natives
edu.vub.at.actors.net
edu.vub.at.eval
edu.vub.at.exceptions
edu.vub.at.objects
edu.vub.at.objects.coercion
edu.vub.at.objects.grammar
edu.vub.at.objects.mirrors
edu.vub.at.objects.natives
edu.vub.at.objects.natives.grammar
edu.vub.at.objects.symbiosis
edu.vub.at.parser
edu.vub.at.tutorial

Uses of InterpreterException in edu.vub.at

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

private static void

IAT.handleATException(InterpreterException e)

Methods in edu.vub.at that throw InterpreterException

protected void	AmbientTalkTestCase.evaluateInput(java.lang.String input, ATContext ctx)
private static ATAbstractGrammar	IAT.parseInitFile()
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.
NATNil	OBJUnit.base_echo_(ATObject message)
ATObject	OBJUnit.base_unittest_(ATClosure code) The unittest: primitive, implemented as base-level code.

Uses of InterpreterException in edu.vub.at.actors

Methods in edu.vub.at.actors that throw InterpreterException

ATObject	ATMailbox.base_enqueue(ATObject value)
ATObject	ATMailbox.base_dequeue()
ATTable	ATMailbox.base_flush() Clears the content of the mailbox (i.e. mailbox becomes empty) and return all current messages in a fresh table, which is no longer causally connected to this mailbox.
ATObject	ATAsyncMessage.base_getSender() Signifies the object on behalf of which this asynchronous message is sent.
ATObject	ATAsyncMessage.base_getReceiver() Messages also have an explicitly named receiver, which may either be a local object, or a representative of an object inside another actor.
ATObject	ATAsyncMessage.base_process(ATActorMirror inActor) This method is responsible for processing the message in a certain actor.
ATNil	ATObservable.base_fire_withArgs_(ATSymbol event, NATTable arguments) Fires an event with the given arguments.
ATAsyncMessage	ATActorMirror.base_createMessage(ATObject sender, ATSymbol selector, ATTable arguments) Creates a first-class message in the language.
ATObject	ATActorMirror.base_send(ATAsyncMessage message) This method implements the default asynchronous message sending semantics for this particular actor.
ATObject	ATActorMirror.base_provide(ATStripe topic, ATObject service) This mechanism is the most basic mechanism to provide a service.
ATObject	ATActorMirror.base_require(ATStripe topic, ATClosure handler, ATBoolean bool) This mechanism is the most basic mechanism to require a service.
ATObject	ATActorMirror.base_install_(ATClosure code) def protocol := install: { code } Installs a meta-object protocol into this actor.
ATTable	ATFarReference.meta_retractUnsentMessages() Retracts all of the outgoing messages buffered in this far object reference by passing them in a table.

Uses of InterpreterException in edu.vub.at.actors.id

Methods in edu.vub.at.actors.id that throw InterpreterException

boolean

ATObjectID.isFar()

Uses of InterpreterException in edu.vub.at.actors.natives

Methods in edu.vub.at.actors.natives that throw InterpreterException

abstract ATObject	SharedActorField.initialize() Hook to be overridden in order to initialize the field which should be installed in every actor's lexical root object.
void	SerializationTest.testParseTreeSerialization()
void	SerializationTest.testCoercerSerialization() Tests whether a coercer correctly implements writeReplace to return the principal to serialize, instead of the coercer itself.
NATLocalFarRef	ReceptionistsSet.exportObject(ATObject object) Export a local object such that it now has a unique global identifier which can be distributed to other actors.
void	ReceptionistsSet.addClient(ATObject service, ATFarReference client) Invoked whenever another actor is passed a reference to an object offering a service on this actor.
void	ReceptionistsSet.removeClient(ATObject service, ATFarReference client) Called upon the collection of a service on a remote device, or possibly when the conditions negotiated for the use of the service (e.g. its lease period) have expired.
protected ATObject	NATRemoteFarRef.transmit(ATAsyncMessage message)
ATTable	NATRemoteFarRef.meta_retractUnsentMessages()
void	NATRemoteFarRef.onDisconnection(ATClosure listener)
void	NATRemoteFarRef.onReconnection(ATClosure listener)
protected ATObject	NATLocalFarRef.transmit(ATAsyncMessage passedMessage)
ATTable	NATLocalFarRef.meta_retractUnsentMessages() The 'outbox' of a far reference to a local actor is always empty.
ATObject	NATFarReference.meta_resolve() After deserialization, ensure that only one unique remote reference exists for my target.
ATObject	NATFarReference.meta_receive(ATAsyncMessage message)
protected abstract ATObject	NATFarReference.transmit(ATAsyncMessage passedMessage)
ATObject	NATFarReference.meta_invoke(ATObject receiver, ATSymbol atSelector, ATTable arguments)
ATBoolean	NATFarReference.meta_respondsTo(ATSymbol atSelector)
ATObject	NATFarReference.meta_doesNotUnderstand(ATSymbol selector)
ATObject	NATFarReference.meta_clone() References to objects hosted by another actor are forced to be unique.
ATObject	NATFarReference.meta_newInstance(ATTable initargs) Cannot create a new instance using a farObject, this should be done either by sending rather than invoking new(args) such that the correct method is triggered or by invoking newInstance on a farMirror, which will send the call as well.
ATObject	NATFarReference.meta_extend(ATClosure code) TODO(discuss) Think about extending objects of another actor.
ATObject	NATFarReference.meta_share(ATClosure code) TODO(discuss) Think about sharing objects of another actor.
ATObject	NATFarReference.meta_select(ATObject receiver, ATSymbol selector)
ATObject	NATFarReference.meta_lookup(ATSymbol selector)
ATNil	NATFarReference.meta_defineField(ATSymbol name, ATObject value)
ATNil	NATFarReference.meta_assignField(ATObject receiver, ATSymbol name, ATObject value)
ATNil	NATFarReference.meta_assignVariable(ATSymbol name, ATObject value)
ATBoolean	NATFarReference.meta_isCloneOf(ATObject original)
ATBoolean	NATFarReference.meta_isRelatedTo(ATObject object)
ATNil	NATFarReference.meta_addField(ATField field)
ATNil	NATFarReference.meta_addMethod(ATMethod method)
ATField	NATFarReference.meta_grabField(ATSymbol fieldName)
ATMethod	NATFarReference.meta_grabMethod(ATSymbol methodName)
ATTable	NATFarReference.meta_listFields()
ATTable	NATFarReference.meta_listMethods()
NATText	NATFarReference.meta_print()
ATObject	NATFarReference.meta_getDynamicParent()
ATObject	NATFarReference.meta_getLexicalParent()
ATTable	NATFarReference.meta_getStripes() The stripes of a far reference are the stripes of the remote object it points to, plus the FarReference stripe.
NATText	NATFarReference.NATDisconnectionSubscription.meta_print()
NATText	NATFarReference.NATReconnectionSubscription.meta_print()
ATObject	NATAsyncMessage.base_getSender()
ATObject	NATAsyncMessage.base_getReceiver()
ATObject	NATAsyncMessage.base_process(ATActorMirror inActor)
ATObject	NATAsyncMessage.base_sendTo(ATObject receiver, ATObject sender) To evaluate an asynchronous message send, an asynchronous invoke is performed on the receiver object.
NATText	NATAsyncMessage.meta_print()
static NATLocalFarRef	NATActorMirror.createActor(ELVirtualMachine host, Packet parametersPkt, Packet initcodePkt, ATActorMirror actorMirror) Creates a new actor on the specified host Virtual Machine.
static NATLocalFarRef	NATActorMirror.createEmptyActor(ELVirtualMachine host, ATActorMirror actorMirror) Auxiliary creation method to create an actor with an empty behaviour.
ATAsyncMessage	NATActorMirror.base_createMessage(ATObject sender, ATSymbol selector, ATTable arguments)
ATObject	NATActorMirror.base_provide(ATStripe topic, ATObject service)
ATObject	NATActorMirror.base_require(ATStripe topic, ATClosure handler, ATBoolean isPermanent)
ATObject	NATActorMirror.meta_clone()
ATObject	NATActorMirror.meta_newInstance(ATTable initargs) actor.new(closure) => same effect as evaluating 'actor: closure'
NATText	NATActorMirror.meta_print()
ATObject	NATActorMirror.meta_send(ATAsyncMessage msg) To send a message msg to a receiver object rcv: - if rcv is a local reference, schedule accept(msg) in my incoming event queue - if rcv is a far reference, schedule msg in far reference's outbox
ATObject	NATActorMirror.meta_receive(ATAsyncMessage msg)
ATTable	NATActorMirror.meta_getStripes()
ATObject	NATActorMirror.base_send(ATAsyncMessage message) When default base-level objects send an asynchronous message, they delegate this responsibility to their actor by means of this base-level method.
ATObject	NATActorMirror.base_install_(ATClosure code) def install: { code }
NATText	NATActorMirror.NATPublication.meta_print()
NATText	NATActorMirror.NATSubscription.meta_print()
NATText	NATActorMirror.NATProtocol.meta_print()
ATTable	ELFarReference.retractUnsentMessages()
NATLocalFarRef	ELActor.export(ATObject object) Export the given local object such that it is now remotely accessible via the returned object id.
protected void	ELActor.initRootObject() Initialises the root using the contents of the init file stored by the hosting virtual machine.
protected void	ELActor.initSharedFields() Initialises various fields in the lexical root of the actor, which are defined in the context of every actor.
ATObject	ELActor.sync_event_eval(ATAbstractGrammar ast) This method should only be used for purposes such as the IAT shell or unit testing.
private ELActor	DistributionTest.setUpActor(ELVirtualMachine host)

Constructors in edu.vub.at.actors.natives that throw InterpreterException

NATFarReference.NATDisconnectionSubscription(NATFarReference reference, ATClosure handler)

NATFarReference.NATReconnectionSubscription(NATFarReference reference, ATClosure handler)

NATAsyncMessage(ATObject sender, ATSymbol sel, ATTable arg)

NATAsyncMessage(ATObject sdr, ATObject rcv, ATSymbol sel, ATTable arg)

NATActorMirror.NATPublication(ELDiscoveryActor discoveryActor, ATStripe topic, ATObject service, DiscoveryManager.Publication pub)

NATActorMirror.NATSubscription(ELDiscoveryActor discoveryActor, ATStripe topic, ATClosure handler, DiscoveryManager.Subscription sub)

NATActorMirror.NATProtocol(ELActor eventLoop, ATActorMirror newMirror)

Uses of InterpreterException in edu.vub.at.actors.net

Methods in edu.vub.at.actors.net that throw InterpreterException

ATObject	OBJNetwork.meta_resolve() After deserialization, ensure that the network object remains unique.
NATText	OBJNetwork.meta_print()

Uses of InterpreterException in edu.vub.at.eval

Methods in edu.vub.at.eval that throw InterpreterException

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 PartialBinder	PartialBinder.calculateResidual(java.lang.String forFunction, ATTable parameters) Performs the partial evaluation of the binding algorithm given the formal parameters.
void	PartialBinder.BindClosure.bindParamToArg(ATObject inScope, ATSymbol param, ATObject arg)
void	InvocationStack.methodInvoked(ATExpression methodInvocation, ATObject receiver, ATMessage message)
static NATText	Evaluator.printElements(ATObject[] els, java.lang.String start, java.lang.String sep, java.lang.String stop) Auxiliary function used to print the elements of a table using various separators.
static NATText	Evaluator.printElements(NATTable tab, java.lang.String start, java.lang.String sep, java.lang.String stop) Auxiliary function used to print the elements of a table using various separators.
static NATText	Evaluator.printAsStatements(ATTable tab)
static NATText	Evaluator.printAsList(ATTable tab)
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.
void	Evaluator.BindClosure.bindParamToArg(ATObject inScope, ATSymbol param, ATObject arg)

Uses of InterpreterException in edu.vub.at.exceptions

Subclasses of InterpreterException in edu.vub.at.exceptions

class	XArityMismatch XArityMismatch is thrown during function application when actual arguments are bound to formal parameters and there are either too many or too few actual arguments supplied.
class	XClassNotFound Raised when a request to load a class via a JavaPackage failed.
class	XDuplicateSlot An XDuplicateSlot exception is raised when a field or a method is added to an object that already contains a field or method with the same name.
class	XIllegalApplication XIllegalApplication is thrown when a natively implemented method is applied incorrectly.
class	XIllegalArgument An XIllegalArgument exception is thrown when primitive operations on native types get passed an illegal argument value.
class	XIllegalIndex An XIllegalIndex exception is thrown by the evaluator whenever an invalid value is used as the index into a table (e.g. when defining, assigning or referencing it).
class	XIllegalOperation XIllegalOperation is thrown whenever an operation is requested that is a violation of the expected semantics of the interpreter.
class	XIllegalParameter An XIllegalParameter exception is raised when the interpreter detects a faulty formal parameter list of a function or method when it is invoked.
class	XIllegalQuote An XIllegalQuote exception is raised whenever an unquote-splice unquotation is discovered in an AG node where the resulting table cannot be spliced.
class	XIllegalSplice XIllegalSplice is thrown when an @ token was not encountered in one of its legal positions namely when unquoting a table or in the argument-list of an application.
class	XIllegalUnquote An XIllegalUnquote exception is raised when an unquotation is discovered in a non-quoted piece of source code.
class	XImportConflict An XImportConflict exception is raised when an import: native fails because the importing object already defines one or more methods or fields available in the imported object.
class	XIndexOutOfBounds An XIndexOutOfBounds exception is raised when an attempt is made to access or modify an AGTable beyond its capacity.
class	XIOProblem The class XIOProblem is mainly a wrapper class for Java IOExceptions.
class	XNotInstantiatable Raised whenever a wrapped Java class cannot be instantiated because: - it has no publicly accessible constructors - it is abstract
class	XParseError XParseError is thrown when illegal input is parsed by the AmbientTalk parser.
class	XReflectionFailure An instance of the class XReflectionFailure is thrown when something goes wrong when dealing with mirror or mirage operations.
class	XSelectorNotFound XSelectorNotFound is thrown during lookup when a particular field cannot be found.
class	XSymbiosisFailure An instance of this class is raised whenever a symbiotic method invocation fails due to overloading which could not be resolved given the actual arguments.
class	XTypeMismatch XTypeMismatch instances are thrown when a value conversion failed.
class	XUnassignableField An XUnassignableField exception is raised whenever a variable assignment fails because the variable/field is immutable.
class	XUndefinedField An XUndefinedField exception is raised whenever a variable reference lookup fails, or a field assignment lookup fails.
class	XUserDefined Instances of the XUserDefined act as wrappers for ATObjects which are thrown at the ambienttalk level using the raise: primitive.

Constructors in edu.vub.at.exceptions that throw InterpreterException

XSymbiosisFailure(java.lang.Object symbiont, java.lang.String selector, java.util.LinkedList choices, ATObject[] atArgs)
Reports that an overloaded method could not be resolved to a unique implementation because there are multiple matches.

XSymbiosisFailure(java.lang.Object symbiont, java.lang.String selector, ATObject[] atArgs)
Reports that an overloaded method could not be resolved to a unique implementation because there are no matches for any static types.

XSymbiosisFailure(java.lang.Class failedClass, java.lang.reflect.Constructor[] choices, ATObject[] atArgs, int numMatchingCtors)
Reports that an overloaded constructor could not be resolved to a unique implementation.

XImportConflict(ATSymbol[] conflictingNames)

Uses of InterpreterException in edu.vub.at.objects

Methods in edu.vub.at.objects that throw InterpreterException

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.
ATSymbol	ATMethod.base_getName() Structural access to the name of the method.
ATTable	ATMethod.base_getParameters() Structural access to the parameter list of the method, which is normally a table of symbols.
ATBegin	ATMethod.base_getBodyExpression() Structural access to the body of the method.
ATSymbol	ATStripe.base_getStripeName()
ATTable	ATStripe.base_getParentStripes()
ATBoolean	ATStripe.base_isSubstripeOf(ATStripe other)
ATBoolean	ATHandler.base_canHandle(ATObject anException) Used to determine whether a handler will be triggered when an exception is raised.
ATObject	ATHandler.base_handle(ATObject anException) When a handler has answered that it can handle an exception, the following method is invoked, asking the handler to handle the exception.
ATNumeric	ATFraction.base_inc()
ATNumeric	ATFraction.base_dec()
ATNumeric	ATFraction.base_abs()
ATNumber	ATFraction.base_round()
ATNumber	ATFraction.base_floor()
ATNumber	ATFraction.base_ceiling()
ATObject	ATBoolean.base_ifTrue_(ATClosure cons)
ATObject	ATBoolean.base_ifFalse_(ATClosure alt)
ATObject	ATBoolean.base_ifTrue_ifFalse_(ATClosure cons, ATClosure alt)
ATBoolean	ATBoolean.base__opamp_(ATBoolean other)
ATBoolean	ATBoolean.base__oppls_(ATBoolean other)
ATBoolean	ATBoolean.base_and_(ATClosure other)
ATBoolean	ATBoolean.base_or_(ATClosure other)
ATBoolean	ATBoolean.base_not()
ATNumeric	ATNumber.base_inc()
ATNumeric	ATNumber.base_dec()
ATNumeric	ATNumber.base_abs()
ATNil	ATNumber.base_doTimes_(ATClosure code)
ATNil	ATNumber.base_to_do_(ATNumber end, ATClosure code)
ATNil	ATNumber.base_to_step_do_(ATNumber end, ATNumber inc, ATClosure code)
ATTable	ATNumber.base__optms__optms_(ATNumber end)
ATTable	ATNumber.base__optms__optms__optms_(ATNumber end)
ATFraction	ATNumber.base__opque__opque_(ATNumber nbr)
ATNumber	ATNumber.base__oprem_(ATNumber n)
ATNumber	ATNumber.base__opdiv__opmns_(ATNumber n)
ATSymbol	ATMessage.base_getSelector() Messages always have a selector, a symbol denoting the field or method that needs to be sought for.
ATTable	ATMessage.base_getArguments() Messages may optionally have a table of arguments.
ATNil	ATMessage.base_setArguments(ATTable arguments) Assigns the arguments of a first class method.
ATObject	ATMessage.base_sendTo(ATObject receiver, ATObject sender) Sends this message to a particular receiver object.
ATSymbol	ATField.base_getName()
ATObject	ATField.base_readField()
ATNil	ATField.base_writeField(ATObject newValue) Sets the value of the field if possible
ATObject	ATObject.meta_send(ATAsyncMessage message) Sends a newly created message asynchronously by this object.
ATObject	ATObject.meta_receive(ATAsyncMessage message) Handles a first-class message of which it is the receiver.
ATObject	ATObject.meta_invoke(ATObject receiver, ATSymbol selector, ATTable arguments) Invoke a method corresponding to the selector with the given arguments.
ATBoolean	ATObject.meta_respondsTo(ATSymbol selector) Query an object for a given field or method which is visible to the outside world.
ATObject	ATObject.meta_doesNotUnderstand(ATSymbol selector) Called when a selection fails because the selector was not found along the dynamic delegation hierarchy.
ATObject	ATObject.meta_pass() Allows objects to specify how they should be passed when passed as an argument in a message sent to another actor.
ATObject	ATObject.meta_resolve() When an object is deserialized after it has been passed to another actor, it is given a chance to tell the interpreter which object it represents.
ATObject	ATObject.meta_select(ATObject receiver, ATSymbol selector) Select a slot (field | method) from an object whose name corresponds to the given selector.
ATObject	ATObject.meta_lookup(ATSymbol selector) Select a slot (field | method) from an object whose name corresponds to the given selector.
ATNil	ATObject.meta_defineField(ATSymbol name, ATObject value) Defines a new field in an object.
ATNil	ATObject.meta_assignVariable(ATSymbol name, ATObject value) Sets the value of the variable to the given value.
ATNil	ATObject.meta_assignField(ATObject receiver, ATSymbol name, ATObject value) Sets the value of a field to the given value.
ATObject	ATObject.meta_clone() Clone the receiver object.
ATObject	ATObject.meta_newInstance(ATTable initargs) Create a new instance of the receiver object.
ATObject	ATObject.meta_extend(ATClosure code) Create an is-a extension of the receiver object.
ATObject	ATObject.meta_share(ATClosure code) Create a shares-a extension of the receiver object.
ATNil	ATObject.meta_addField(ATField field) Adds a field slot to an object at runtime.
ATNil	ATObject.meta_addMethod(ATMethod method) Adds a method slot to an object at runtime.
ATField	ATObject.meta_grabField(ATSymbol selector) Queries an object for one of its field slots.
ATMethod	ATObject.meta_grabMethod(ATSymbol selector) Queries an object for one of its method slots.
ATTable	ATObject.meta_listFields() Queries an object for a list of all of its field slots.
ATTable	ATObject.meta_listMethods() Queries an object for a list of all of its method slots.
ATObject	ATObject.meta_getDynamicParent() Objects have a classical dynamic parent chain created using extension primitives.
ATObject	ATObject.meta_getLexicalParent() Objects also have a lexical parent which is the scope in which their definitions are nested.
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.
NATText	ATObject.meta_print() Prints out the object in a human-readable way.
ATBoolean	ATObject.meta_isRelatedTo(ATObject object) Detects whether both objects have a common origin, in other words whether they are related through a combination of the cloning and extension operators.
ATBoolean	ATObject.meta_isCloneOf(ATObject original) Detects whether this object an the passed parameter are the result of cloning from a common ancestor (possibly either one of the objects itself).
ATBoolean	ATObject.meta_isStripedWith(ATStripe stripe) Tests whether the receiver object is striped with a particular stripe.
ATTable	ATObject.meta_getStripes() Returns the stripes of this object.
ATBoolean	ATObject.base__opeql__opeql_(ATObject other) The pointer equality == operator.
ATObject	ATObject.base_new(ATObject[] initargs) The object instantiation method.
ATObject	ATObject.base_init(ATObject[] initargs) The object initialisation method.
ATObject	ATContext.base_getLexicalScope() Structural access to the lexical environment of the current context.
ATObject	ATContext.base_getSelf() Structural access to the receiver (self pseudovariable) in the current context.
ATContext	ATContext.base_withLexicalEnvironment(ATObject scope)
ATContext	ATContext.base_withDynamicReceiver(ATObject self)
ATNumber	ATTable.base_getLength()
ATObject	ATTable.base_at(ATNumber index)
ATObject	ATTable.base_atPut(ATNumber index, ATObject value)
ATBoolean	ATTable.base_isEmpty()
ATNil	ATTable.base_each_(ATClosure clo) Apply a closure to each element of the table
ATTable	ATTable.base_map_(ATClosure clo) Map a closure over each element of the table, resulting in a new table.
ATObject	ATTable.base_with_collect_(ATObject init, ATClosure clo) Collect all elements of the table by combining them using the given closure.
ATTable	ATTable.base_filter_(ATClosure clo) Keep only those elements of the table for which the closure evaluates to true.
ATObject	ATTable.base_find_(ATClosure clo) Return the index of the first element for which the given predicate returns true.
ATText	ATTable.base_implode() Implode the receiver table of characters into a text string
ATText	ATTable.base_join(ATText txt) Join all the text elements of the receiver table into a text string where the argument is used as a separator
ATTable	ATTable.base_select(ATNumber start, ATNumber stop) Select a subrange of the table: idx: 1 2 3 4 5 [a, b, c, d, e].select(2,4) => [b, c, d]
ATTable	ATTable.base__oppls_(ATTable other) [1,2,3] + [4,5] => [1,2,3,4,5]
ATObject	ATMirror.base_getBase() Provides access to the AmbientTalk language value this mirror reflects upon.
ATTable	ATText.base_explode()
ATTable	ATText.base_split(ATText separator)
ATNil	ATText.base_find_do_(ATText regexp, ATClosure consumer)
ATText	ATText.base_replace_by_(ATText regexp, ATClosure transformer)
ATText	ATText.base_toUpperCase()
ATText	ATText.base_toLowerCase()
ATNumber	ATText.base_length()
ATText	ATText.base__oppls_(ATObject other)
ATNumber	ATText.base__opltx__opeql__opgtx_(ATText other)
ATBoolean	ATText.base__optil__opeql_(ATText other)
ATMethod	ATClosure.base_getMethod() Structural access to the encapsulated method.
ATContext	ATClosure.base_getContext() Structural access to the scope of the closure.
ATObject	ATClosure.base_apply(ATTable args) Applies the closure to the given arguments, already wrapped in a table.
ATObject	ATClosure.base_applyInScope(ATTable args, ATObject scope) Applies the closure to the given arguments, already wrapped in a table.
ATObject	ATClosure.base_whileTrue_(ATClosure body) Allows AmbientTalk programmers to write { booleanCondition }.whileTrue: { body } which will execute body as long as the boolean condition evaluates to true.
ATObject	ATClosure.base_escape() { |quit| ... quit(val) ... }.escape() The escape control construct passes to its receiver block a function which when invoked, immediately transfers control back to the caller of escape, returning the value passed to quit.
ATFraction	ATNumeric.base_cos()
ATFraction	ATNumeric.base_sin()
ATFraction	ATNumeric.base_tan()
ATFraction	ATNumeric.base_log()
ATFraction	ATNumeric.base_sqrt()
ATFraction	ATNumeric.base_expt(ATNumeric pow)
ATNumeric	ATNumeric.base__oppls_(ATNumeric other)
ATNumeric	ATNumeric.base_addNumber(ATNumber other)
ATNumeric	ATNumeric.base_addFraction(ATFraction other)
ATNumeric	ATNumeric.base__opmns_(ATNumeric other)
ATNumeric	ATNumeric.base_subtractNumber(ATNumber other)
ATNumeric	ATNumeric.base_subtractFraction(ATFraction other)
ATNumeric	ATNumeric.base__optms_(ATNumeric other)
ATNumeric	ATNumeric.base_timesNumber(ATNumber other)
ATNumeric	ATNumeric.base_timesFraction(ATFraction other)
ATNumeric	ATNumeric.base__opdiv_(ATNumeric other)
ATNumeric	ATNumeric.base_divideNumber(ATNumber other)
ATNumeric	ATNumeric.base_divideFraction(ATFraction other)
ATNumeric	ATNumeric.base__opltx__opeql__opgtx_(ATNumeric other)
ATNumeric	ATNumeric.base_gequalsNumber(ATNumber other)
ATNumeric	ATNumeric.base_gequalsFraction(ATFraction other)
ATBoolean	ATNumeric.base__opltx_(ATNumeric other)
ATBoolean	ATNumeric.base__opgtx_(ATNumeric other)
ATBoolean	ATNumeric.base__opltx__opeql_(ATNumeric other)
ATBoolean	ATNumeric.base__opgtx__opeql_(ATNumeric other)
ATBoolean	ATNumeric.base__opeql_(ATNumeric other)
ATBoolean	ATNumeric.base__opnot__opeql_(ATNumeric other)

Uses of InterpreterException in edu.vub.at.objects.coercion

Methods in edu.vub.at.objects.coercion that throw InterpreterException

boolean	ATConversions.base_isClosure()
boolean	ATConversions.base_isSymbol()
boolean	ATConversions.base_isTable()
boolean	ATConversions.base_isBoolean()
boolean	ATConversions.base_isCallFrame()
boolean	ATConversions.base_isUnquoteSplice()
boolean	ATConversions.base_isVariableAssignment()
boolean	ATConversions.base_isSplice()
boolean	ATConversions.base_isMethod()
boolean	ATConversions.base_isMessageCreation()
boolean	ATConversions.base_isMirror()
boolean	ATConversions.base_isStripe()
boolean	ATConversions.base_isFarReference()
ATClosure	ATConversions.base_asClosure()
ATSymbol	ATConversions.base_asSymbol()
ATTable	ATConversions.base_asTable()
ATBoolean	ATConversions.base_asBoolean()
ATNumber	ATConversions.base_asNumber()
ATMessage	ATConversions.base_asMessage()
ATField	ATConversions.base_asField()
ATMethod	ATConversions.base_asMethod()
ATMirror	ATConversions.base_asMirror()
ATHandler	ATConversions.base_asHandler()
ATStripe	ATConversions.base_asStripe()
ATFarReference	ATConversions.base_asFarReference()
ATAsyncMessage	ATConversions.base_asAsyncMessage()
ATActorMirror	ATConversions.base_asActorMirror()
ATStatement	ATConversions.base_asStatement()
ATDefinition	ATConversions.base_asDefinition()
ATExpression	ATConversions.base_asExpression()
ATBegin	ATConversions.base_asBegin()
ATMessageCreation	ATConversions.base_asMessageCreation()
ATUnquoteSplice	ATConversions.base_asUnquoteSplice()
ATAssignVariable	ATConversions.base_asVariableAssignment()
ATSplice	ATConversions.base_asSplice()

Uses of InterpreterException in edu.vub.at.objects.grammar

Methods in edu.vub.at.objects.grammar that throw InterpreterException

ATText	ATSymbol.base_getText() Transform a symbol into a string.
ATTable	ATSymbol.base__opmns__opgtx_(ATObject obj) Used during import: declarations to conveniently denote aliases for names.

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

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

static ATObject

Reflection.upExceptionCreation(InterpreterException jRcvr, ATTable atInitargs)

Methods in edu.vub.at.objects.mirrors that throw InterpreterException

protected void	ReflectiveAccessTest.evaluateInput(java.lang.String input, ATContext ctx)
void	ReflectionTest.testUpSelector()
static ATSymbol	Reflection.downBaseLevelSelector(java.lang.String jSelector) Transforms a Java selector prefixed with base_ into an AmbientTalk selector without the prefix.
static ATSymbol	Reflection.downMetaLevelSelector(java.lang.String jSelector) Transforms a Java selector prefixed with meta_ into an AmbientTalk selector without the prefix.
static ATSymbol	Reflection.downBaseFieldAccessSelector(java.lang.String jSelector) Transforms a Java selector prefixed with base_get into an equivalent AmbientTalk selector.
static ATSymbol	Reflection.downBaseFieldMutationSelector(java.lang.String jSelector) Transforms a Java selector prefixed with base_set into an equivalent AmbientTalk selector.
static ATSymbol	Reflection.downMetaFieldAccessSelector(java.lang.String jSelector) Transforms a Java selector prefixed with meta_get into an equivalent AmbientTalk selector Example: downMetaFieldAccessSelector("meta_getReceiver") => ATSymbol("receiver")
static ATSymbol	Reflection.downMetaFieldMutationSelector(java.lang.String jSelector) Transforms a Java selector prefixed with meta_set into an equivalent AmbientTalk selector.
static ATSymbol	Reflection.downFieldName(java.lang.String jName) A field name "Field" passed from the Java to the AmbientTalk level undergoes the following transformations: - the same transformations applicable to downSelector
static java.lang.String	Reflection.upSelector(ATSymbol atSelector) A selector passed from the AmbientTalk to the Java level undergoes the following transformations: - any colons (:) are replaced by underscores (_) - any operator symbol is replaced by _op{code}_ where code is generated as follows: Operator codes are: + -> pls - -> mns * -> tms / -> div \ -> bsl & -> and !
static java.lang.String	Reflection.upBaseLevelSelector(ATSymbol atSelector) Transforms an AmbientTalk selector into a Java-level selector prefixed with base_.
static java.lang.String	Reflection.upMetaLevelSelector(ATSymbol atSelector) Transforms an AmbientTalk selector into a Java-level selector prefixed with meta_.
static java.lang.String	Reflection.upMagicLevelSelector(ATSymbol atSelector) Transforms an AmbientTalk selector into a Java-level selector prefixed with magic_.
static java.lang.String	Reflection.upFieldName(ATSymbol atName) A field name "field" passed from the AmbientTalk to the Java level undergoes the following transformations: - the same transformations applicable to upSelector
static java.lang.String	Reflection.upBaseFieldAccessSelector(ATSymbol atName) Transforms an AmbientTalk selector into an equivalent Java selector uppercased and prefixed with "base_get".
static java.lang.String	Reflection.upBaseFieldMutationSelector(ATSymbol atName) Transforms an AmbientTalk selector into an equivalent Java selector uppercased and prefixed with "base_set".
static java.lang.String	Reflection.upMetaFieldAccessSelector(ATSymbol atName) Transforms an AmbientTalk selector into an equivalent Java selector uppercased and prefixed with "meta_get".
static java.lang.String	Reflection.upMetaFieldMutationSelector(ATSymbol atName) Transforms an AmbientTalk selector into an equivalent Java selector uppercased and prefixed with "meta_set".
static java.lang.String	Reflection.upMagicFieldAccessSelector(ATSymbol atName) Transforms an AmbientTalk selector into an equivalent Java selector uppercased and prefixed with "meta_get".
static java.lang.String	Reflection.upMagicFieldMutationSelector(ATSymbol atName) Transforms an AmbientTalk selector into an equivalent Java selector uppercased and prefixed with "meta_set".
static ATField	Reflection.downField(ATObject natObject, ATSymbol atSelector, java.lang.String getPrefix, java.lang.String setPrefix) Constructs an AmbientTalk ATField from a pair of accessor/mutator methods of a Java object.
static ATField	Reflection.downBaseLevelField(ATObject natObject, ATSymbol atSelector)
static ATField	Reflection.downMetaLevelField(ATObject natObject, ATSymbol atSelector)
static ATMethod	Reflection.downMethod(ATObject natObject, java.lang.String jSelector, ATSymbol origName) Constructs an AmbientTalk ATMethod from a Java method.
static ATMethod	Reflection.downBaseLevelMethod(ATObject natObject, ATSymbol atSelector)
static ATMethod	Reflection.downMetaLevelMethod(ATObject natObject, ATSymbol atSelector)
static ATObject	Reflection.downInvocation(ATObject atRcvr, java.lang.reflect.Method jMethod, ATObject[] jArgs) downInvocation takes an implicit Java invocation and turns it into an explicit AmbientTalk invocation process.
static ATObject	Reflection.upInvocation(ATObject atOrigRcvr, java.lang.String jSelector, ATTable atArgs) upInvocation takes an explicit AmbientTalk method invocation and turns it into an implicitly performed Java invocation.
static boolean	Reflection.upRespondsTo(ATObject jRcvr, java.lang.String jSelector) upRespondsTo transforms an explicit AmbientTalk respondsTo meta-level request into an implicit check whether the given jRcvr java object has a method corresponding to the given selector, prefixed with base_
static ATObject	Reflection.upFieldSelection(ATObject atOrigRcvr, java.lang.String jSelector) upFieldSelection takes an explicit AmbientTalk field selection and turns it into an implicitly performed Java selection by invoking a getter method, if such a getter method exists.
static ATObject	Reflection.upFieldAssignment(ATObject atOrigRcvr, java.lang.String jSelector, ATObject value) upFieldAssignment takes an explicit AmbientTalk field assignment and turns it into an implicitly performed Java field assignment by invoking a mutator method, if such a method exists.
static NativeClosure	Reflection.upMethodSelection(ATObject atOrigRcvr, java.lang.String jSelector, ATSymbol origSelector) upMethodSelection takes an explicit AmbientTalk field selection and checks whether a Java method exists that matches the selector.
static ATObject	Reflection.upInstanceCreation(ATObject jRcvr, ATTable atInitargs) upInstanceCreation takes an explicit AmbientTalk 'new' invocation and turns it into an implicit Java instance creation by calling a constructor.
static ATObject	Reflection.upExceptionCreation(InterpreterException jRcvr, ATTable atInitargs)
static ATObject	Reflection.downObject(ATObject metaObject) Pass an AmbientTalk meta-level object into the base-level
static ATField[]	Reflection.downBaseLevelFields(ATObject atObj) Returns, for a given AmbientTalk object atObj, an array of NativeField objects corresponding to all non-static methods of that object's Java class, where each method's name is prefixed with 'base_get'
static ATField[]	Reflection.downMetaLevelFields(ATObject atObj) Returns, for a given AmbientTalk object atObj, an array of NativeField objects corresponding to all non-static methods of that object's Java class, where each method's name is prefixed with 'meta_get'
static ATMethod[]	Reflection.downBaseLevelMethods(ATObject atObj) Returns, for a given AmbientTalk object atObj, an array of NativeMethod objects corresponding to all non-static methods of that object's class, where each method's name: - is prefixed with 'base_' - is not prefixed with 'base_get' - is not prefixed with 'base_set'
static ATMethod[]	Reflection.downMetaLevelMethods(ATObject natObj) Returns, for a given AmbientTalk object natObj, an array of NativeMethod objects corresponding to all non-static methods of that object's class, where each method's name: - is prefixed with 'meta_' - is not prefixed with 'meta_get' - is not prefixed with 'meta_set'
ATSymbol	PrimitiveMethod.base_getName()
ATTable	PrimitiveMethod.base_getParameters()
abstract ATObject	PrimitiveMethod.base_apply(ATTable arguments, ATContext ctx)
ATObject	PrimitiveMethod.base_applyInScope(ATTable arguments, ATContext ctx)
NATText	PrimitiveMethod.meta_print()
ATTable	PrimitiveMethod.meta_getStripes()
ATObject	OBJMirrorRoot.meta_invoke(ATObject receiver, ATSymbol atSelector, ATTable arguments) The effect of invoking methods on a mirror (through meta_invoke) consists of checking whether the requested functionality is provided as a meta-operation by the principal that is wrapped by this mirror.
ATObject	OBJMirrorRoot.meta_clone() OBJMirrorRoot is a singleton object.
protected ATObject	OBJMirrorRoot.createChild(ATClosure code, boolean parentPointerType)
ATObject	OBJMirrorRoot.meta_select(ATObject receiver, ATSymbol atSelector) The effect of selecting fields or methods on a mirror (through meta_select) consists of checking whether the requested selector matches a field of the principal wrapped by this mirror.
ATNil	OBJMirrorRoot.meta_assignField(ATObject receiver, ATSymbol name, ATObject value) The effect of assigning a field on a mirror can be twofold.
ATObject	OBJMirrorRoot.meta_resolve() After deserialization, ensure that the mirror root remains unique.
ATTable	OBJMirrorRoot.meta_getStripes()
ATNil	NATMirage.magic_addMethod(ATMethod method)
ATNil	NATMirage.magic_assignField(ATObject receiver, ATSymbol selector, ATObject value)
NATMirage	NATMirage.magic_clone()
protected NATObject	NATMirage.createClone(FieldMap map, java.util.Vector state, java.util.LinkedList customFields, MethodDictionary methodDict, ATObject dynamicParent, ATObject lexicalParent, byte flags, ATStripe[] stripes)
ATNil	NATMirage.magic_defineField(ATSymbol name, ATObject value)
ATObject	NATMirage.magic_extend(ATClosure code)
ATMethod	NATMirage.magic_getMethod(ATSymbol selector)
ATObject	NATMirage.magic_invoke(ATObject receiver, ATSymbol selector, ATTable arguments)
ATTable	NATMirage.magic_listMethods()
ATObject	NATMirage.magic_lookup(ATSymbol selector)
ATObject	NATMirage.magic_newInstance(ATTable initargs)
NATText	NATMirage.magic_print()
ATBoolean	NATMirage.magic_respondsTo(ATSymbol selector)
ATObject	NATMirage.magic_select(ATObject receiver, ATSymbol selector)
ATObject	NATMirage.magic_share(ATClosure code)
ATNil	NATMirage.magic_addField(ATField field)
ATNil	NATMirage.magic_assignVariable(ATSymbol name, ATObject value)
ATObject	NATMirage.magic_doesNotUnderstand(ATSymbol selector)
ATField	NATMirage.magic_getField(ATSymbol selector)
ATTable	NATMirage.magic_listFields()
ATObject	NATMirage.magic_send(ATAsyncMessage message)
ATObject	NATMirage.magic_eval(ATContext ctx)
ATObject	NATMirage.magic_quote(ATContext ctx)
ATObject	NATMirage.magic_getDynamicParent()
ATObject	NATMirage.magic_getLexicalParent()
ATObject	NATMirage.magic_pass()
ATObject	NATMirage.magic_resolve()
ATBoolean	NATMirage.magic_isStripedWith(ATStripe stripe)
ATTable	NATMirage.magic_getStripes()
ATNil	NATMirage.meta_addMethod(ATMethod method)
ATNil	NATMirage.meta_assignField(ATObject receiver, ATSymbol selector, ATObject value)
ATObject	NATMirage.meta_clone()
ATNil	NATMirage.meta_defineField(ATSymbol name, ATObject value)
ATObject	NATMirage.meta_extend(ATClosure code)
ATMethod	NATMirage.meta_grabMethod(ATSymbol selector)
ATObject	NATMirage.meta_invoke(ATObject receiver, ATSymbol selector, ATTable arguments)
ATTable	NATMirage.meta_listMethods()
ATObject	NATMirage.meta_lookup(ATSymbol selector)
ATObject	NATMirage.meta_newInstance(ATTable initargs)
NATText	NATMirage.meta_print()
ATBoolean	NATMirage.meta_respondsTo(ATSymbol selector)
ATObject	NATMirage.meta_select(ATObject receiver, ATSymbol selector)
ATObject	NATMirage.meta_share(ATClosure code)
ATNil	NATMirage.meta_addField(ATField field)
ATNil	NATMirage.meta_assignVariable(ATSymbol name, ATObject value)
ATObject	NATMirage.meta_doesNotUnderstand(ATSymbol selector)
ATField	NATMirage.meta_grabField(ATSymbol selector)
ATTable	NATMirage.meta_listFields()
ATObject	NATMirage.meta_send(ATAsyncMessage message)
ATObject	NATMirage.meta_eval(ATContext ctx)
ATObject	NATMirage.meta_quote(ATContext ctx)
ATObject	NATMirage.meta_getDynamicParent()
ATObject	NATMirage.meta_getLexicalParent()
ATObject	NATMirage.meta_pass()
ATObject	NATMirage.meta_resolve()
ATBoolean	NATMirage.meta_isStripedWith(ATStripe stripe)
ATTable	NATMirage.meta_getStripes()
ATMirror	NATMirage.base_asMirror()
ATSymbol	NativeMethod.base_getName() The name of a wrapped Java method is the name of the Java method, converted to an AmbientTalk selector name.
ATTable	NativeMethod.base_getParameters() The parameters of a wrapped method are represented as symbols representing the class name of the parameter type.
ATObject	NativeMethod.base_apply(ATTable arguments, ATContext ctx)
ATObject	NativeMethod.base_applyInScope(ATTable arguments, ATContext ctx)
NATText	NativeMethod.meta_print()
ATTable	NativeMethod.meta_getStripes()
ATObject	NativeField.base_readField()
ATNil	NativeField.base_writeField(ATObject newValue)
ATObject	NativeField.meta_newInstance(ATTable initargs) Fields can be re-initialized when installed in an object that is being cloned.
NATText	NativeField.meta_print()
ATTable	NativeField.meta_getStripes()
ATContext	NativeClosure.base_getContext() Overridden to allow for lazy instantiation of the context.
ATObject	NativeClosure.base_apply(ATTable arguments) Apply the NativeClosure, which either gives rise to executing a native piece of code supplied by an anonymous subclass, or executes the wrapped NativeMethod.
ATObject	NativeClosure.base_applyInScope(ATTable args, ATObject scope) A NativeClosure can also be directed to execute its wrapped NativeMethod in an externally specified scope.
NATText	NativeClosure.meta_print()
ATObject	NativeClosure.get(ATTable args, int n) Auxiliary method to more easily extract arguments from an ATTable
int	NativeClosure.getNbr(ATTable args, int n)
double	NativeClosure.getFrc(ATTable args, int n)
java.lang.String	NativeClosure.getTxt(ATTable args, int n)
boolean	NativeClosure.getBln(ATTable args, int n)
java.lang.Object[]	NativeClosure.getTab(ATTable args, int n)
void	NativeClosure.checkArity(ATTable args, int required)
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)
NATText	NativeAnonymousMethod.meta_print()
ATTable	NativeAnonymousMethod.meta_getStripes()
ATObject	NATIntrospectiveMirror.meta_invoke(ATObject receiver, ATSymbol atSelector, ATTable arguments) The effect of invoking methods on a mirror (through meta_invoke) consists of checking whether the requested functionality is provided as a meta-operation by the principal that is wrapped by this mirror.
ATObject	NATIntrospectiveMirror.meta_select(ATObject receiver, ATSymbol atSelector) The effect of selecting fields or methods on a mirror (through meta_select) consists of checking whether the requested selector matches a field of the principal wrapped by this mirror.
ATBoolean	NATIntrospectiveMirror.meta_respondsTo(ATSymbol atSelector) A mirror responds to a message m if and only if: - either its principal has a method named meta_m - or the mirror itself implements a method named base_m
ATNil	NATIntrospectiveMirror.meta_assignField(ATObject receiver, ATSymbol name, ATObject value) The effect of assigning a field on a mirror can be twofold.
ATField	NATIntrospectiveMirror.meta_grabField(ATSymbol fieldName)
ATMethod	NATIntrospectiveMirror.meta_grabMethod(ATSymbol methodName)
ATTable	NATIntrospectiveMirror.meta_listFields() Listing the fields of a mirror requires us to list all of the meta_get methods of the principal + all of the base_get methods of the mirror itself
ATTable	NATIntrospectiveMirror.meta_listMethods() Listing the methods of a mirror requires us to list all of the meta_ methods of the principal (excluding meta_get/set methods) + all of the base_ methods (excluding base_get/set methods) of the mirror itself
ATObject	NATIntrospectiveMirror.meta_clone() We enforce the restriction that any object has but a single IntrospectiveMirror by returning the mirror itself when asked to clone.
NATText	NATIntrospectiveMirror.meta_print()
ATTable	NATIntrospectiveMirror.meta_getStripes()
ATObject	NATIntercessiveMirror.meta_clone()
NATIntercessiveMirror	NATIntercessiveMirror.magic_clone()
protected NATObject	NATIntercessiveMirror.createClone(FieldMap map, java.util.Vector state, java.util.LinkedList customFields, MethodDictionary methodDict, ATObject dynamicParent, ATObject lexicalParent, byte flags, ATStripe[] stripes)
protected ATObject	NATIntercessiveMirror.createChild(ATClosure code, boolean parentPointerType)
NATText	NATIntercessiveMirror.meta_print()
ATTable	NATIntercessiveMirror.meta_getStripes()
static ATObject	JavaInterfaceAdaptor.invokeNativeATMethod(java.lang.Class jClass, ATObject natReceiver, java.lang.String jSelector, ATObject[] jArguments) Invokes a method on a Java object identified by a selector.
static ATObject	JavaInterfaceAdaptor.invokeNativeATMethod(java.lang.reflect.Method javaMethod, ATObject jReceiver, ATObject[] jArguments) Invokes a method on a native AmbientTalk object identified by a java.lang.reflect.Method object.
static ATObject	JavaInterfaceAdaptor.createNativeATObject(java.lang.Class jClass, ATObject[] jInitArgs) Try to create a new instance of a Java class given an array of initialization arguments.
static java.lang.reflect.Method	JavaInterfaceAdaptor.getNativeATMethod(java.lang.Class baseInterface, ATObject receiver, java.lang.String methodName)
static java.lang.Object	JavaInterfaceAdaptor.atObjectToPrimitiveJava(ATObject atObj, java.lang.Class type)

Constructors in edu.vub.at.objects.mirrors that throw InterpreterException

NATMirage(FieldMap map, java.util.Vector state, java.util.LinkedList customFields, MethodDictionary methodDict, ATObject dynamicParent, ATObject lexicalParent, byte flags, ATStripe[] stripes, NATIntercessiveMirror mirror)
Constructs a new ambienttalk mirage as a clone of an existing one.

NATIntercessiveMirror(FieldMap map, java.util.Vector state, java.util.LinkedList customFields, MethodDictionary methodDict, ATObject dynamicParent, ATObject lexicalParent, byte flags, ATStripe[] stripes, NATMirage base)
Constructs a new ambienttalk mirage as a clone of an existing one.

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

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

private InterpreterException

NATException.wrappedException_

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

InterpreterException

NATException.getWrappedException()

Methods in edu.vub.at.objects.natives that throw InterpreterException

ATObject	SAFWorkingDirectory.initialize()
ATObject	SAFSystem.initialize()
ATObject	SAFLobby.initialize()
NATText	OBJSystem.meta_print()
ATNil	OBJSystem.base_print(ATObject[] objs) def print(@obj) { print obj to standard output }
ATNil	OBJSystem.base_println(ATObject[] objs) def println(@obj) { self.print(#[@obj, '\n']) }
void	StripesTest.testParentlessStripe()
void	StripesTest.testPositiveSubstriping()
void	StripesTest.testNegativeSubstriping()
void	StripesTest.testObjectStripes()
private static java.util.Hashtable	OBJLexicalRoot.preprocessAliases(ATTable aliases) Given a table of tables, of the form [ [oldname, newname], ... ], returns a hashtable mapping the old names to the new names.
private static java.util.HashSet	OBJLexicalRoot.preprocessExcludes(ATTable exclusions) Given a table of symbols, returns a hashset containing all the names.
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	OBJLexicalRoot.base_if_then_(ATBoolean cond, ATClosure consequent) The if:then: primitive, which calls back on the boolean using ifTrue: usage: if: booleanCondition then: { consequent }
ATObject	OBJLexicalRoot.base_if_then_else_(ATBoolean cond, ATClosure consequent, ATClosure alternative) The if:then:else primitive, which calls back on the boolean using ifTrue:ifFalse: usage: if: booleanCondition then: { consequent } else: { alternative } pseudo-implementation: booleanCondition.ifTrue: { consequent } ifFalse: { alternative }
ATObject	OBJLexicalRoot.base_while_do_(ATClosure condition, ATClosure body) The while:do: primitive, which calls back on the closure using whileTrue: usage: while: { condition } do: { body } pseudo-implementation: { condition }.whileTrue: { body }
ATObject	OBJLexicalRoot.base_foreach_in_(ATClosure body, ATTable tab) The foreach:in: primitive, which calls back on the table using each: usage: foreach: { |v| body } in: [ table ] pseudo-implementation: [ table ].each: { |v| body }
ATObject	OBJLexicalRoot.base_do_if_(ATClosure body, ATBoolean condition) The do:if: primitive, which in Ruby terminology is a 'statement modifier' usage: do: { body } if: condition pseudo-implementation: condition.ifTrue: { body }
ATObject	OBJLexicalRoot.base_do_unless_(ATClosure body, ATBoolean condition) The do:unless: primitive, which in Ruby terminology is a 'statement modifier' usage: do: { body } unless: condition pseudo-implementation: condition.ifFalse: { body }
ATObject	OBJLexicalRoot.base_let_(ATClosure body) The let: primitive, which allows for the easy creation of temporary local variables.
ATObject	OBJLexicalRoot.base_actor_(ATClosure code) actor: { code } == actor: { code } mirroredBy: The semantics of actor creation is as follows: - Mandatory parameters to the block of initialization code are treated as lexically visible variables that have to remain available in the new actor behaviour.
ATActorMirror	OBJLexicalRoot.base_getActor() actor => a reference to a mirror on the current actor
ATObject	OBJLexicalRoot.base_export_as_(ATObject object, ATStripe topic) export: object as: topic => object becomes discoverable by objects in other actors via topic returns a publication object that can be used to cancel the export
ATObject	OBJLexicalRoot.base_when_discovered_(ATStripe topic, ATClosure handler) when: topic discovered: { code } => when an object is exported by another actor under topic, trigger the code returns a subscription object that can be used to cancel the handler Once the code block has run once, it will not be triggered again.
ATObject	OBJLexicalRoot.base_whenever_discovered_(ATStripe topic, ATClosure handler) whenever: topic discovered: { code } => when an object is exported by another actor under topic, trigger the code returns a subscription object that can be used to cancel the handler The code block can be fired multiple times.
ATObject	OBJLexicalRoot.base_when_disconnected_(ATFarReference farReference, ATClosure listener) when: farReference disconnected: { code } => when the remote reference is broken due to network disconnections, trigger the code returns a subscription object that can be used to cancel the listener
ATObject	OBJLexicalRoot.base_when_reconnected_(ATFarReference farReference, ATClosure listener) when: farReference reconnected: { code } => when the remote reference is reinstated after a network disconnection, trigger the code returns a subscription object that can be used to cancel the listener
ATTable	OBJLexicalRoot.base_retract_(ATFarReference farReference) retract: farReference => retract all currently unsent messages from the far reference's outbox This has the side effect that the returned messages will *not* be sent automatically anymore, the programmer is responsible to resend all messages that still need to be sent by hand.
ATObject	OBJLexicalRoot.base_extend_with_(ATObject parent, ATClosure code) The extend:with: primitive, which delegates to the extend meta operation on the parent object.
ATObject	OBJLexicalRoot.base_object_(ATClosure code) The object: primitive, implemented as base-level code.
ATObject	OBJLexicalRoot.base_isolate_(ATClosure code) isolate: { code } => create an isolate object Equivalent to: object: { code } stripedWith: [ at.stripes.Isolate ]
ATObject	OBJLexicalRoot.base_share_with_(ATObject parent, ATClosure code) The share:with: primitive, which delegates to the share meta operation on the parent object.
ATObject	OBJLexicalRoot.base_reflect_(ATObject reflectee) The reflect: primitive, which returns a mirror on an object.
ATObject	OBJLexicalRoot.base_clone_(ATObject original) The clone: primitive, which returns a clone of an object.
ATObject	OBJLexicalRoot.base_mirror_(ATClosure code) The mirror: primitive, which allows creating custom mirrors which can be used to allow intercessive reflection on objects created from this mirror.
ATObject	OBJLexicalRoot.base_object_mirroredBy_(ATClosure code, NATIntercessiveMirror mirror) object: { code } mirroredBy: mirror => return an object mirage initialized with code
ATObject	OBJLexicalRoot.base_extend_with_mirroredBy_(ATObject parent, ATClosure code, NATIntercessiveMirror mirror)
ATObject	OBJLexicalRoot.base_share_with_mirroredBy_(ATObject parent, ATClosure code, NATIntercessiveMirror mirror)
ATBoolean	OBJLexicalRoot.base_is_stripedWith_(ATObject object, ATStripe stripe) is: object stripedWith: stripe => returns true if the given object is striped with the given stripe
ATTable	OBJLexicalRoot.base_stripesOf_(ATObject object) stripesOf: object => returns all of the stripes of an object
ATObject	OBJLexicalRoot.base_object_stripedWith_(ATClosure code, ATTable stripes) object: { code } stripedWith: [ s1, s2, ... ] => creates a new object tagged with the given stripes
ATObject	OBJLexicalRoot.base_try_usingHandlers_(ATClosure tryBlock, ATTable exceptionHandlers) try: { tryBlock } usingHandlers: [ handler1, handler2, ... ] Applies the given closure (to []) and handles exceptions using the given exception handlers.
ATObject	OBJLexicalRoot.base_try_using_(ATClosure tryBlock, ATHandler handler) try: { tryBlock} using: handler Ad-hoc code for one exception handler
ATObject	OBJLexicalRoot.base_try_using_using_(ATClosure tryBlock, ATHandler hdl1, ATHandler hdl2) try: { tryBlock} using: handler1 using: handler2 Ad-hoc code for two exception handlers
ATObject	OBJLexicalRoot.base_try_using_using_using_(ATClosure tryBlock, ATHandler hdl1, ATHandler hdl2, ATHandler hdl3) try: { tryBlock} using: hdl1 using: hdl2 using: hdl3 Ad-hoc code for three exception handlers
ATObject	OBJLexicalRoot.base_try_catch_using_(ATClosure tryBlock, ATStripe filter, ATClosure replacementCode) try: { tryBlock} catch: stripe using: { |e| replacementCode } 'Syntactic sugar' for one in-line handler
ATObject	OBJLexicalRoot.base_try_catch_using_catch_using_(ATClosure tryBlock, ATStripe filter1, ATClosure hdl1, ATStripe filter2, ATClosure hdl2) try: { tryBlock } catch: stripe using: { |e| replacementCode } catch: stripe2 using: { |e| replacementCode2 } 'Syntactic sugar' for two in-line handlers
ATObject	OBJLexicalRoot.base_try_catch_using_catch_using_catch_using_(ATClosure tryBlock, ATStripe filter1, ATClosure hdl1, ATStripe filter2, ATClosure hdl2, ATStripe filter3, ATClosure hdl3) try: { tryBlock } catch: stripe using: { |e| replacementCode } catch: stripe2 using: { |e| replacementCode2 } catch: stripe3 using: { |e| replacementCode3 } 'Syntactic sugar' for three in-line handlers
ATNil	OBJLexicalRoot.base_raise_(ATObject anExceptionObject) raise: exception Raises an exception which can be caught by dynamically installed try-catch-using blocks.
ATBoolean	OBJLexicalRoot.base__opnot_(ATBoolean b) The unary !
ATNumber	OBJLexicalRoot.base__opmns_(ATNumber n) The unary - primitive: -NBR(n) == NBR(-n)
ATNumber	OBJLexicalRoot.base__oppls_(ATNumber n) The unary + primitive: +NBR(n) == NBR(n)
ATAbstractGrammar	OBJLexicalRoot.base_read_(ATText source) read: "text" => parses the given string into an AST
ATObject	OBJLexicalRoot.base_eval_in_(ATAbstractGrammar ast, ATObject obj) eval: ast in: obj => evaluates the given AST in the context of the given object, returning its value
ATText	OBJLexicalRoot.base_print_(ATObject obj) print: expression => string representing the expression
ATObject	OBJLexicalRoot.base_new(ATObject[] initargs) Invoking root.new(args) results in an exception for reasons of safety.
ATObject	OBJLexicalRoot.meta_resolve() After deserialization, ensure that the lexical root remains unique.
NATText	NATText.meta_print()
ATTable	NATText.meta_getStripes()
ATTable	NATText.base_explode() Explodes a text string into a table of constinuent characters
ATTable	NATText.base_split(ATText regexp) Split the string according to the given regular expression.
ATNil	NATText.base_find_do_(ATText regexp, ATClosure consumer)
ATText	NATText.base_replace_by_(ATText regexp, ATClosure transformer)
ATText	NATText.base__oppls_(ATObject other)
ATNumber	NATText.base__opltx__opeql__opgtx_(ATText other)
ATBoolean	NATText.base__optil__opeql_(ATText other)
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.
NATText	NATTable.meta_print()
ATTable	NATTable.meta_getStripes()
ATObject	NATTable.base_at(ATNumber index)
ATObject	NATTable.base_atPut(ATNumber index, ATObject value)
ATNil	NATTable.base_each_(ATClosure clo)
ATTable	NATTable.base_map_(ATClosure clo)
ATObject	NATTable.base_with_collect_(ATObject init, ATClosure clo)
ATTable	NATTable.base_filter_(ATClosure clo)
ATObject	NATTable.base_find_(ATClosure clo)
ATText	NATTable.base_implode()
ATText	NATTable.base_join(ATText sep)
ATTable	NATTable.base_select(ATNumber first, ATNumber last) tab.select(start, stop) == els = [ ] ; start.to: stop do: { |i| els << tab[i] } ; els
ATTable	NATTable.base__oppls_(ATTable other)
protected int	NATTable.extractIndex(ATNumber atIndex)
ATObject	NATTable.meta_resolve()
ATSymbol	NATStripe.base_getStripeName()
ATTable	NATStripe.base_getParentStripes()
ATBoolean	NATStripe.base_isSubstripeOf(ATStripe superstripe) Native implementation of: def isSubstripeOf(superstripe) { (superstripe.name() == name).or: { (superstripes.find: { |sstripe| sstripe.isSubstripeOf(superstripe) }) !
NATText	NATStripe.meta_print()
ATTable	NATStripe.meta_getStripes()
ATBoolean	NATStripe.OBJRootStripe.base_isSubstripeOf(ATStripe superstripe) The root stripe is only a substripe of the root stripe itself
void	NATObjectClosureTest.testExternalMethodBindings() NATIVE TEST: Tests whether the definition of an external method refers to the correct bindings for: - lexically accessed variables - the value of 'self' - the value of 'super'
ATObject	NATObjectClosureTest.AGScopeTest.meta_eval(ATContext ctx)
ATMethod	NATObjectClosureTest.AGScopeTest.transformToMethodNamed(ATSymbol name)
ATObject	NATObject.meta_invoke(ATObject receiver, ATSymbol selector, ATTable arguments) Invocations on an object ( o.m( args ) ) are handled by looking up the requested selector in the dynamic parent chain of the receiver.
ATBoolean	NATObject.meta_respondsTo(ATSymbol selector) An ambienttalk object can respond to a message if a corresponding field or method exists either in the receiver object locally, or in one of its dynamic parents.
ATObject	NATObject.meta_select(ATObject receiver, ATSymbol selector) meta_select is used to evaluate code of the form o.m.
ATObject	NATObject.meta_lookup(ATSymbol selector) This method is used to evaluate code of the form selector within the scope of this object.
ATNil	NATObject.meta_defineField(ATSymbol name, ATObject value) When a new field is defined in an object, it is important to check whether or not the field map is shared between clones or not.
ATNil	NATObject.meta_assignField(ATObject receiver, ATSymbol selector, ATObject value) meta_assignField is used to evaluate code of the form o.m := v.
ATObject	NATObject.meta_clone() When cloning an object, it is first determined whether the parent has to be shared by the clone, or whether the parent must also be cloned.
ATObject	NATObject.meta_newInstance(ATTable initargs) When new is invoked on an object's mirror, the object is first cloned by the mirror, after which the method named 'init' is invoked on it.
ATObject	NATObject.meta_extend(ATClosure code)
ATObject	NATObject.meta_share(ATClosure code)
ATNil	NATObject.meta_addMethod(ATMethod method) When a method is added to an object, it is first checked whether the method does not already exist.
ATMethod	NATObject.meta_grabMethod(ATSymbol selector)
ATTable	NATObject.meta_listMethods()
NATText	NATObject.meta_print()
protected NATObject	NATObject.createClone(FieldMap map, java.util.Vector state, java.util.LinkedList originalCustomFields, MethodDictionary methodDict, ATObject dynamicParent, ATObject lexicalParent, byte flags, ATStripe[] stripes)
protected ATObject	NATObject.createChild(ATClosure code, boolean parentPointerType) When creating children of objects, care must be taken that an extension of an isolate itself remains an isolate.
ATBoolean	NATObject.meta_isCloneOf(ATObject original)
ATBoolean	NATObject.meta_isRelatedTo(ATObject object)
ATBoolean	NATObject.meta_isStripedWith(ATStripe stripe) Check whether one of the stripes of this object is a substripe of the given stripe.
ATTable	NATObject.meta_getStripes() Return the stripes that were directly attached to this object.
ATObject	NATObject.meta_pass() An isolate object does not return a proxy representation of itself during serialization, hence it is serialized itself.
ATObject	NATObject.meta_resolve() An isolate object represents itself upon deserialization.
private java.lang.Object	NATObject.coerce(ATStripe requiredStripe, java.lang.Class providedInterface) ALL asXXX methods return a coercer object which returns a proxy of the correct interface that will 'down' subsequent Java base-level invocations to the AmbientTalk level.
ATBoolean	NATObject.base_asBoolean()
ATClosure	NATObject.base_asClosure()
ATExpression	NATObject.base_asExpression()
ATField	NATObject.base_asField()
ATMessage	NATObject.base_asMessage()
ATMethod	NATObject.base_asMethod()
ATMirror	NATObject.base_asMirror()
ATHandler	NATObject.base_asHandler()
ATNumber	NATObject.base_asNumber()
ATTable	NATObject.base_asTable()
ATAsyncMessage	NATObject.base_asAsyncMessage()
ATActorMirror	NATObject.base_asActorMirror()
ATStripe	NATObject.base_asStripe()
ATBegin	NATObject.base_asBegin()
ATStatement	NATObject.base_asStatement()
ATUnquoteSplice	NATObject.base_asUnquoteSplice()
ATSymbol	NATObject.base_asSymbol()
ATSplice	NATObject.base_asSplice()
ATDefinition	NATObject.base_asDefinition()
ATMessageCreation	NATObject.base_asMessageCreation()
boolean	NATObject.base_isMirror()
boolean	NATObject.base_isBoolean()
boolean	NATObject.base_isClosure()
boolean	NATObject.base_isMethod()
boolean	NATObject.base_isSplice()
boolean	NATObject.base_isSymbol()
boolean	NATObject.base_isTable()
boolean	NATObject.base_isUnquoteSplice()
boolean	NATObject.base_isStripe()
private ATMethod	NATObject.getLocalMethod(ATSymbol selector)
private boolean	NATObject.isLocallyStripedWith(ATStripe stripe) Performs a stripe test for this object locally.
static ATField[]	NATObject.listTransitiveFields(ATObject obj) Auxiliary method to access the fields of an object and all of its super-objects up to (but excluding) nil.
static ATMethod[]	NATObject.listTransitiveMethods(ATObject obj) Auxiliary method to access the methods of an object and all of its super-objects up to (but excluding) nil.
ATTable	NATNumeric.meta_getStripes()
ATFraction	NATNumeric.base_expt(ATNumeric pow) NUM(n).expt(NUM(e)) => FRC(Math.pow(n,e))
ATBoolean	NATNumeric.base__opltx_(ATNumeric other) a < b iff (a <=> b) == -1
ATBoolean	NATNumeric.base__opgtx_(ATNumeric other) a > b iff (a <=> b) == +1
ATBoolean	NATNumeric.base__opltx__opeql_(ATNumeric other) a <= b iff (a <=> b) !
ATBoolean	NATNumeric.base__opgtx__opeql_(ATNumeric other) a >= b iff (a <=> b) !
ATBoolean	NATNumeric.base__opeql_(ATNumeric other) a = b iff (a <=> b) == 0
ATBoolean	NATNumeric.base__opnot__opeql_(ATNumeric other) a !
NATText	NATNumber.meta_print()
ATTable	NATNumber.meta_getStripes()
ATNil	NATNumber.base_doTimes_(ATClosure code) NBR(n).doTimes: { |i| code } => for i = 1 to n do code.eval(i) ; nil
ATNil	NATNumber.base_to_do_(ATNumber end, ATClosure code) NBR(start).to: NBR(stop) do: { |i| code } => for i = start to stop do code.eval(i) ; nil Also works if stop > start, in which case it becomes a downTo.
ATNil	NATNumber.base_to_step_do_(ATNumber end, ATNumber inc, ATClosure code) NBR(start).to: NBR(stop) step: NBR(inc) do: { |i| code } => for i = start; i < stop; i++ do code.eval(i) ; nil Also works if stop > start, in which case it becomes a downTo.
ATTable	NATNumber.base__optms__optms_(ATNumber end) NBR(start) ** NBR(stop) => [ start, ..., stop [ Example: 2 ** 5 => [ 2, 3, 4 ] 5 ** 2 => [ 5, 4, 3 ]
ATTable	NATNumber.base__optms__optms__optms_(ATNumber end) NBR(start) *** NBR(stop) => [ start, ..., stop ] Example: 2 *** 5 => [ 2, 3, 4, 5 ] 5 *** 2 => [ 5, 4, 3, 2 ]
ATFraction	NATNumber.base__opque__opque_(ATNumber nbr) NBR(start) ??
ATNumber	NATNumber.base__oprem_(ATNumber n) NBR(n) % NBR(r) => NBR(n % r)
ATNumber	NATNumber.base__opdiv__opmns_(ATNumber n) NBR(n) /- NBR(d) => NBR(n / d)
ATNumeric	NATNumber.base__oppls_(ATNumeric other)
ATNumeric	NATNumber.base_addNumber(ATNumber other)
ATNumeric	NATNumber.base_addFraction(ATFraction other)
ATNumeric	NATNumber.base__opmns_(ATNumeric other)
ATNumeric	NATNumber.base_subtractNumber(ATNumber other)
ATNumeric	NATNumber.base_subtractFraction(ATFraction other)
ATNumeric	NATNumber.base__optms_(ATNumeric other)
ATNumeric	NATNumber.base_timesNumber(ATNumber other)
ATNumeric	NATNumber.base_timesFraction(ATFraction other)
ATNumeric	NATNumber.base__opdiv_(ATNumeric other)
ATNumeric	NATNumber.base_divideNumber(ATNumber other)
ATNumeric	NATNumber.base_divideFraction(ATFraction other)
ATNumeric	NATNumber.base__opltx__opeql__opgtx_(ATNumeric other)
ATNumeric	NATNumber.base_gequalsNumber(ATNumber other)
ATNumeric	NATNumber.base_gequalsFraction(ATFraction other)
ATObject	NATNil.meta_send(ATAsyncMessage message) Asynchronous messages ( o<-m( args )) sent in the context of an object o (i.e.
ATObject	NATNil.meta_receive(ATAsyncMessage message)
ATObject	NATNil.meta_invoke(ATObject receiver, ATSymbol atSelector, ATTable arguments) The default behaviour of 'delegate' for primitive non-object ambienttalk language values is to check whether the requested functionality is provided by a native Java method with the same selector, but prefixed with 'base_'.
ATBoolean	NATNil.meta_respondsTo(ATSymbol atSelector) An ambienttalk language value can respond to a message if it implements a native Java method corresponding to the selector prefixed by 'base_'.
ATObject	NATNil.meta_doesNotUnderstand(ATSymbol selector) By default, when a selection is not understood by a primitive object, an error is raised.
ATObject	NATNil.meta_select(ATObject receiver, ATSymbol selector) It is possible to select a method from any ambienttalk value provided that it offers the method in its provided interface.
ATObject	NATNil.meta_lookup(ATSymbol selector) A lookup can only be issued at the base level by writing selector inside the scope of a particular object.
ATNil	NATNil.meta_defineField(ATSymbol name, ATObject value)
ATNil	NATNil.meta_assignVariable(ATSymbol name, ATObject value) Normally, a variable assignment cannot be performed on a native AmbientTalk object.
ATNil	NATNil.meta_assignField(ATObject receiver, ATSymbol name, ATObject value)
ATObject	NATNil.meta_clone()
ATObject	NATNil.meta_newInstance(ATTable initargs)
protected ATObject	NATNil.createChild(ATClosure code, boolean parentPointerType)
ATObject	NATNil.meta_extend(ATClosure code)
ATObject	NATNil.meta_share(ATClosure code)
ATNil	NATNil.meta_addField(ATField field)
ATNil	NATNil.meta_addMethod(ATMethod method)
ATField	NATNil.meta_grabField(ATSymbol fieldName)
ATMethod	NATNil.meta_grabMethod(ATSymbol methodName)
ATTable	NATNil.meta_listFields()
ATTable	NATNil.meta_listMethods()
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.
NATText	NATNil.meta_print()
ATObject	NATNil.meta_getDynamicParent() Only true extending objects have a dynamic pointer, others return nil
ATObject	NATNil.meta_getLexicalParent() By default numbers, tables and so on do not have lexical parents,
boolean	NATNil.base_isClosure()
boolean	NATNil.base_isSymbol()
boolean	NATNil.base_isBoolean()
boolean	NATNil.base_isTable()
boolean	NATNil.base_isCallFrame()
boolean	NATNil.base_isUnquoteSplice()
boolean	NATNil.base_isVariableAssignment()
boolean	NATNil.base_isSplice()
boolean	NATNil.base_isMethod()
boolean	NATNil.base_isMessageCreation()
boolean	NATNil.base_isMirror()
boolean	NATNil.base_isStripe()
ATClosure	NATNil.base_asClosure()
ATSymbol	NATNil.base_asSymbol()
ATTable	NATNil.base_asTable()
ATBoolean	NATNil.base_asBoolean()
ATNumber	NATNil.base_asNumber()
ATMessage	NATNil.base_asMessage()
ATField	NATNil.base_asField()
ATMethod	NATNil.base_asMethod()
ATMirror	NATNil.base_asMirror()
ATHandler	NATNil.base_asHandler()
ATStripe	NATNil.base_asStripe()
ATFarReference	NATNil.base_asFarReference()
ATAsyncMessage	NATNil.base_asAsyncMessage()
ATActorMirror	NATNil.base_asActorMirror()
ATStatement	NATNil.base_asStatement()
ATDefinition	NATNil.base_asDefinition()
ATExpression	NATNil.base_asExpression()
ATBegin	NATNil.base_asBegin()
ATMessageCreation	NATNil.base_asMessageCreation()
ATUnquoteSplice	NATNil.base_asUnquoteSplice()
ATAssignVariable	NATNil.base_asVariableAssignment()
ATSplice	NATNil.base_asSplice()
ATObject	NATNil.base_new(ATObject[] initargs)
ATObject	NATNil.base_init(ATObject[] initargs)
ATBoolean	NATNil.meta_isCloneOf(ATObject original)
ATBoolean	NATNil.meta_isRelatedTo(ATObject object)
ATBoolean	NATNil.meta_isStripedWith(ATStripe stripe) Native objects implement the stripe test non-recursively: only the stripes returned by meta_getStripes are tested against.
ATTable	NATNil.meta_getStripes() By default, a native object (and also nil) has no stripes.
ATObject	NATNil.meta_pass() This method allows objects to decide which object should be serialized in their stead when they are passed as argument in an asynchronous message send that crosses actor boundaries.
ATObject	NATNil.meta_resolve() After deserialization, ensure that nil remains unique.
ATObject	NATNamespace.meta_doesNotUnderstand(ATSymbol selector) For a namespace object, doesNotUnderstand triggers the querying of the local file system to load files corresponding to the missing selector.
NATText	NATNamespace.meta_print()
protected NATObject	NATNamespace.createClone(FieldMap map, java.util.Vector state, java.util.LinkedList customFields, MethodDictionary methodDict, ATObject dynamicParent, ATObject lexicalParent, byte flags, ATStripe[] stripes)
ATObject	NATMethodInvocation.base_sendTo(ATObject receiver, ATObject sender) To evaluate a method invocation, invoke the method corresponding to the encapsulated selector to the given receiver with the encapsulated arguments.
NATText	NATMethodInvocation.meta_print()
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.
NATText	NATMethod.meta_print()
ATTable	NATMethod.meta_getStripes()
ATSymbol	NATMessage.base_getSelector()
ATTable	NATMessage.base_getArguments()
ATNil	NATMessage.base_setArguments(ATTable arguments)
ATBoolean	NATHandler.base_canHandle(ATObject anException)
ATObject	NATHandler.base_handle(ATObject anException)
ATTable	NATHandler.meta_getStripes()
NATText	NATFraction.meta_print()
ATTable	NATFraction.meta_getStripes()
ATNumeric	NATFraction.base__oppls_(ATNumeric other)
ATNumeric	NATFraction.base_addNumber(ATNumber other)
ATNumeric	NATFraction.base_addFraction(ATFraction other)
ATNumeric	NATFraction.base__opmns_(ATNumeric other)
ATNumeric	NATFraction.base_subtractNumber(ATNumber other)
ATNumeric	NATFraction.base_subtractFraction(ATFraction other)
ATNumeric	NATFraction.base__optms_(ATNumeric other)
ATNumeric	NATFraction.base_timesNumber(ATNumber other)
ATNumeric	NATFraction.base_timesFraction(ATFraction other)
ATNumeric	NATFraction.base__opdiv_(ATNumeric other)
ATNumeric	NATFraction.base_divideNumber(ATNumber other)
ATNumeric	NATFraction.base_divideFraction(ATFraction other)
ATNumeric	NATFraction.base__opltx__opeql__opgtx_(ATNumeric other)
ATNumeric	NATFraction.base_gequalsNumber(ATNumber other)
ATNumeric	NATFraction.base_gequalsFraction(ATFraction other)
ATObject	NATField.base_readField()
ATNil	NATField.base_writeField(ATObject newValue)
NATText	NATField.meta_print()
ATObject	NATField.meta_newInstance(ATTable initargs) Fields can be re-initialized when installed in an object that is being cloned.
ATTable	NATField.meta_getStripes()
ATObject	NATException.meta_newInstance(ATTable initargs)
ATBoolean	NATException.meta_isRelatedTo(ATObject object)
ATTable	NATException.meta_getStripes()
ATObject	NATDelegation.base_sendTo(ATObject receiver, ATObject sender) To evaluate a delegating message send, invoke the method corresponding to the encapsulated selector with the encapsulated arguments.
NATText	NATDelegation.meta_print()
NATText	NATContext.meta_print()
ATTable	NATContext.meta_getStripes()
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)
ATBegin	NATClosureMethod.base_getBodyExpression()
ATSymbol	NATClosureMethod.base_getName()
ATTable	NATClosureMethod.base_getParameters()
NATText	NATClosureMethod.meta_print()
ATTable	NATClosureMethod.meta_getStripes()
ATObject	NATClosure.base_apply(ATTable arguments) To apply a closure, apply its underlying method with the context of the closure, rather than the runtime context of the invoker.
ATObject	NATClosure.base_applyInScope(ATTable args, ATObject scope) To apply a closure in a given scope, apply its underlying method with a new context constructed from the scope object.
ATObject	NATClosure.base_whileTrue_(ATClosure body) receiver is a zero-argument block closure returning a boolean
ATObject	NATClosure.base_escape() The following is a pseudo-code implementation of escape.
ATContext	NATClosure.base_getContext()
NATText	NATClosure.meta_print()
ATTable	NATClosure.meta_getStripes()
ATObject	NATCallframe.meta_invoke(ATObject receiver, ATSymbol selector, ATTable arguments) Normally, call frames are not used in receiverful method invocation expressions.
ATBoolean	NATCallframe.meta_respondsTo(ATSymbol selector) respondsTo is a mechanism to ask any object o whether it would respond to the selection o.selector.
ATObject	NATCallframe.meta_doesNotUnderstand(ATSymbol selector) By default, when a selection is not understood by an AmbientTalk object or call frame, an error is raised.
ATObject	NATCallframe.meta_select(ATObject receiver, ATSymbol selector) This method is used in the evaluation of the code o.m.
ATObject	NATCallframe.meta_lookup(ATSymbol selector) This method is used to evaluate code of the form selector within the scope of this call frame.
ATNil	NATCallframe.meta_defineField(ATSymbol name, ATObject value) A field can be added to either a call frame or an object.
ATNil	NATCallframe.meta_assignVariable(ATSymbol name, ATObject value) A field can be assigned in either a call frame or an object.
ATNil	NATCallframe.meta_assignField(ATObject receiver, ATSymbol name, ATObject value) Assigning a call frame's field externally is possible and is treated as if it were a variable assignment.
ATObject	NATCallframe.meta_clone()
ATObject	NATCallframe.meta_newInstance(ATTable initargs)
ATObject	NATCallframe.meta_extend(ATClosure code)
ATObject	NATCallframe.meta_share(ATClosure code)
ATNil	NATCallframe.meta_addField(ATField field)
ATNil	NATCallframe.meta_addMethod(ATMethod method)
ATField	NATCallframe.meta_grabField(ATSymbol selector)
ATMethod	NATCallframe.meta_grabMethod(ATSymbol selector)
ATTable	NATCallframe.meta_listFields()
ATTable	NATCallframe.meta_listMethods()
NATText	NATCallframe.meta_print()
ATObject	NATCallframe.meta_getDynamicParent()
ATObject	NATCallframe.meta_getLexicalParent()
ATBoolean	NATCallframe.meta_isCloneOf(ATObject original)
ATBoolean	NATCallframe.meta_isRelatedTo(ATObject object)
protected boolean	NATCallframe.hasLocalField(ATSymbol selector)
protected boolean	NATCallframe.hasLocalCustomField(ATSymbol selector)
protected ATObject	NATCallframe.getLocalField(ATSymbol selector) Reads out the value of either a native or a custom field.
protected ATField	NATCallframe.getLocalCustomField(ATSymbol selector)
protected boolean	NATCallframe.setLocalField(ATSymbol selector, ATObject value) Set a given field if it exists.
ATObject	NATByRef.meta_pass() By reference objects serialize to a proxy representation.
ATObject	NATByRef.meta_resolve() By reference objects cannot be deserialized, by definition.
ATObject	NATByCopy.meta_pass() When a by-copy object is asked which object to serialize in its stead, the by-copy object returns itself, so that it itself will be serialized.
ATObject	NATByCopy.meta_resolve() When a by-copy object is asked which object it represents when it is deserialized, the object returns itself.
ATTable	NATBoolean.meta_getStripes()
NATText	NATBoolean.NATTrue.meta_print()
ATObject	NATBoolean.NATTrue.base_ifTrue_(ATClosure clo)
ATObject	NATBoolean.NATTrue.base_ifFalse_(ATClosure clo)
ATObject	NATBoolean.NATTrue.base_ifTrue_ifFalse_(ATClosure consequent, ATClosure alternative)
ATBoolean	NATBoolean.NATTrue.base__opamp_(ATBoolean other)
ATBoolean	NATBoolean.NATTrue.base__oppls_(ATBoolean other)
ATBoolean	NATBoolean.NATTrue.base_and_(ATClosure other)
ATBoolean	NATBoolean.NATTrue.base_or_(ATClosure other)
NATText	NATBoolean.NATFalse.meta_print()
ATObject	NATBoolean.NATFalse.base_ifTrue_(ATClosure clo)
ATObject	NATBoolean.NATFalse.base_ifFalse_(ATClosure clo)
ATObject	NATBoolean.NATFalse.base_ifTrue_ifFalse_(ATClosure consequent, ATClosure alternative)
ATBoolean	NATBoolean.NATFalse.base__opamp_(ATBoolean other)
ATBoolean	NATBoolean.NATFalse.base__oppls_(ATBoolean other)
ATBoolean	NATBoolean.NATFalse.base_and_(ATClosure other)
ATBoolean	NATBoolean.NATFalse.base_or_(ATClosure other)
void	LexicalRootTest.testBasicImport() Tests whether a basic import of fields and methods from a 'trait' object into a 'host' object works properly.
void	LexicalRootTest.testConflictingImport() Tests whether conflicts are successfully detected.
void	LexicalRootTest.testTransitiveImport() Tests whether traits can be transitively imported into objects.
void	LexicalRootTest.testImportAndAliasing() Tests whether aliasing works properly.
void	LexicalRootTest.testImportAndExclusion() Tests whether exclusion works properly.
void	LexicalRootTest.testImportAndAliasingAndExclusion() Tests whether aliasing and exclusion work properly together.
void	CustomFieldsTest.setUp()

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

NATException(InterpreterException wrappedException)

Constructors in edu.vub.at.objects.natives that throw InterpreterException

NATObject(FieldMap map, java.util.Vector state, java.util.LinkedList originalCustomFields, MethodDictionary methodDict, ATObject dynamicParent, ATObject lexicalParent, byte flags, ATStripe[] stripes)
Constructs a new ambienttalk object as a clone of an existing object.

NATNamespace(FieldMap map, java.util.Vector state, java.util.LinkedList customFields, MethodDictionary methodDict, ATObject dynamicParent, ATObject lexicalParent, byte flags, ATStripe[] stripes, java.io.File path, java.lang.String name)
Private constructor used only for cloning

NATMethodInvocation(ATSymbol sel, ATTable arg)

NATMethod(ATSymbol name, ATTable parameters, ATBegin body)

NATMessage(ATSymbol sel, ATTable arg, ATStripe stripe)

NATDelegation(ATObject delegator, ATSymbol sel, ATTable arg)

NATClosureMethod(ATObject scope, ATMethod method)

NATClosure(ATMethod method, ATObject implementor, ATObject receiver)
This constructor creates a closure with a bound dynamic receiver, and it is called after the succesful lookup of a receiverful message.

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

Methods in edu.vub.at.objects.natives.grammar that throw InterpreterException

private void	TestParameterBinding.ensureBound(ATSymbol var, ATObject value)
private void	TestParameterBinding.ensureBoundToTable(ATSymbol var, ATObject[] expected)
void	TestParameterBinding.setUp()
void	TestParameterBinding.testZeroArity() Tests parameter binding for 0-arity methods
void	TestParameterBinding.testMandatory() Tests parameter binding for methods with mandatory arguments only.
void	TestParameterBinding.testTooFewMandatory() Tests for too few mandatory arguments
void	TestParameterBinding.testTooManyMandatory() Tests for too many mandatory arguments
void	TestParameterBinding.testMandatoryAndOptional() Tests parameter binding for methods with mandatory arguments and optional arguments.
void	TestParameterBinding.testMandatoryAndDefaultOptional() Tests parameter binding for methods with mandatory arguments and an optional argument that is not given.
void	TestParameterBinding.testMandatoryAndTooManyOptional() Tests whether parameter binding fails if given too many optional arguments.
void	TestParameterBinding.testMandOptAndRest() Tests application with both mandatory, optional and rest arguments
void	TestParameterBinding.testMandOptAndNoRest() Tests application with mandatory and optional arguments.
void	TestParameterBinding.testMandNoOptAndNoRest() Tests application with mandatory arguments.
void	TestParameterBinding.testOnlyOptionalArguments() Tests application with only optional arguments, all of which are given at call time.
void	TestParameterBinding.testOnlyOptArgsWithOneFilledIn() Tests application with only optional arguments, only one of which is given at call time.
void	TestParameterBinding.testOnlyOptArgsWithNoneFilledIn() Tests application with only optional arguments, none of which are given at call time.
void	TestParameterBinding.testOneMandatoryAndNoRestArgs() Tests application with one mandatory argument and zero rest arguments.
void	TestParameterBinding.testOneMandatoryAndTwoRestArgs() Tests application with one mandatory argument and two rest arguments.
void	TestParameterBinding.testZeroRestArgs() Tests only rest arguments, with none given.
void	TestParameterBinding.testOneRestArg() Tests only rest arguments, with one given.
void	TestParameterBinding.testIllegalMandatoryAfterOptional() Tests whether mandatory arguments specified after optional arguments results in a proper XIllegalParameter exception.
void	TestParameterBinding.testIllegalMandatoryAfterRest() Tests whether mandatory arguments specified after the rest parameter results in a proper XIllegalParameter exception.
void	TestParameterBinding.testIllegalOptionalAfterRest() Tests whether optional arguments specified after the rest parameter results in a proper XIllegalParameter exception.
void	TestParameterBinding.testMultiAssignmentWithOptionalAndRestParameters() Tests whether optional and rest parameters also work using multiple-definition
void	TestEval.testDefField()
void	TestEval.testDefFunction()
void	TestEval.testDefTable()
void	TestEval.testDefExternalMethod()
void	TestEval.testDefExternalField()
void	TestEval.testAssignVariable()
void	TestEval.testAssignTable()
void	TestEval.testAssignField()
void	TestEval.testMultiAssignment()
void	TestEval.testSymbolReference()
void	TestEval.testTabulation()
void	TestEval.testClosureLiteral()
void	TestEval.testSelfReference()
void	TestEval.testSuperReference()
void	TestEval.testSelection()
void	TestEval.testFirstClassMessage()
void	TestEval.testMethodApplication()
void	TestEval.testClosureApplication()
void	TestEval.testMethodInvocation()
void	TestEval.testDelegation()
void	TestEval.testQuotation()
void	TestEval.testArgumentSplicing()
void	TestEval.testVariableArguments()
void	TestEval.testVariableKeywordArguments()
void	TestEval.testVariableMultiDefinition()
ATTable	NATAbstractGrammar.meta_getStripes()
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.
NATText	AGUnquoteSplice.meta_print()
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.
NATText	AGUnquote.meta_print()
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))
NATText	AGTabulation.meta_print()
ATTable	AGSymbol.base__opmns__opgtx_(ATObject obj)
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.
NATText	AGSymbol.meta_print()
ATObject	AGSymbol.meta_resolve() After deserialization, ensure that the symbol remains unique.
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.
NATText	AGSplice.meta_print()
ATObject	AGSelf.meta_eval(ATContext ctx) To evaluate a self reference, simply select the current self from the current evaluation context.
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.
NATText	AGSelection.meta_print()
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.
NATText	AGQuote.meta_print()
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))
NATText	AGMultiDefinition.meta_print()
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))
NATText	AGMultiAssignment.meta_print()
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.
NATText	AGMessageSend.meta_print()
ATObject	AGMessageCreation.meta_quote(ATContext ctx) Quoting a message creation element returns a new quoted message creation element.
NATText	AGMessageCreation.meta_print()
ATTable	AGExpression.meta_getStripes()
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.
NATText	AGDefTable.meta_print()
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.
NATText	AGDefStripe.meta_print()
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.
NATText	AGDefFunction.meta_print()
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.
NATText	AGDefField.meta_print()
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.
NATText	AGDefExternalMethod.meta_print()
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.
NATText	AGDefExternalField.meta_print()
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.
NATText	AGClosureLiteral.meta_print()
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))
NATText	AGBegin.meta_print()
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))
NATText	AGAssignVariable.meta_print()
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.
NATText	AGAssignTable.meta_print()
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))
NATText	AGAssignField.meta_print()
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.
NATText	AGApplication.meta_print()

Constructors in edu.vub.at.objects.natives.grammar that throw InterpreterException

AGMultiDefinition(ATTable par, ATExpression val)

AGMultiAssignment(ATTable par, ATExpression val)

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

Subclasses of InterpreterException in edu.vub.at.objects.symbiosis

class

XJavaException An XJavaException AmbientTalk native exception wraps a Java exception.

Methods in edu.vub.at.objects.symbiosis that throw InterpreterException

void	SymbiosisTest.testJLobbyPackageLoading() Tests whether jlobby.java results in a new JavaPackage.
void	SymbiosisTest.testJLobbyExplicitClassLoading() Tests whether lowercase classes can be loaded via the class method of a JavaPackage.
void	SymbiosisTest.testJLobbyNonexistentClassLoading() Tests whether access to a nonexistent class gives rise to a selector not found exception.
void	SymbiosisTest.testJLobbyExplicitPackageLoading() Tests whether the uppercase package 'foo.Bar' can be loaded via the package method of a JavaPackage.
void	SymbiosisTest.testBugfixOverloadedConstructor() BUGFIX TEST: jlobby.java.lang.StringBuffer.new(10) failed to discriminate between constructors StringBuffer(String) and StringBuffer(int), reason was that anything native was convertible to NATText and also to String.
void	SymbiosisTest.testInterfacesAndStripes() Tests whether Java interface types are correctly treated as AT/2 stripes.
void	SymbiosisTest.testStripedJavaObject() Test whether JavaObject wrappers are correctly striped with all of the interfaces of the wrapped instance's class.
static ATObject	Symbiosis.symbioticInvocation(ATObject wrapper, java.lang.Object symbiont, java.lang.Class ofClass, java.lang.String selector, ATObject[] atArgs)
static ATObject	Symbiosis.symbioticInvocation(ATObject wrapper, java.lang.Object symbiont, java.lang.String selector, JavaMethod jMethod, ATObject[] atArgs) The Java method invocation algorithm is as follows: case of # of methods matching selector: 0 => XSelectorNotFound 1 => invoke the method OR XIllegalArgument, XArityMismatch, XReflectionFailure * => (case of # of methods with matching arity OR taking varargs: 0 => XSymbiosisFailure 1 => invoke the method OR XIllegalArgument, XReflectionFailure * => (case of # of methods matching 'default type' of the actual arguments: 0 => XSymbiosisFailure 1 => invoke OR XReflectionFailure * => XSymbiosisFailure)) A Java method takes a variable number of AT arguments <=> it has one formal parameter of type ATObject[]
static ATObject	Symbiosis.symbioticInstanceCreation(java.lang.Class ofClass, ATObject[] atArgs) Creates a new instance of a Java class.
static ATObject	Symbiosis.readField(java.lang.Object fromObject, java.lang.Class ofClass, java.lang.String fieldName) Read a field from the given Java object reflectively.
static ATObject	Symbiosis.readField(java.lang.Object fromObject, java.lang.reflect.Field f) Read a field from the given Java object reflectively.
static void	Symbiosis.writeField(java.lang.Object toObject, java.lang.Class ofClass, java.lang.String fieldName, ATObject value) Write a field in the given Java object reflectively.
static void	Symbiosis.writeField(java.lang.Object toObject, java.lang.reflect.Field f, ATObject value) Write a field in the given Java object reflectively.
static ATObject	Symbiosis.javaToAmbientTalk(java.lang.Object jObj) Convert a Java object into an AmbientTalk object.
static java.lang.Object	Symbiosis.ambientTalkToJava(ATObject atObj, java.lang.Class targetType) Convert an AmbientTalk object into an equivalent Java object.
private static ATObject	Symbiosis.invokeUniqueSymbioticMethod(java.lang.Object symbiont, java.lang.reflect.Method javaMethod, java.lang.Object[] jArgs)
private static ATObject	Symbiosis.invokeUniqueSymbioticConstructor(java.lang.reflect.Constructor ctor, java.lang.Object[] jArgs)
private static java.lang.Object[]	Symbiosis.atArgsToJavaArgs(ATObject[] args, java.lang.Class[] types)
ATObject	JavaPackage.meta_doesNotUnderstand(ATSymbol selector) For a JavaPackage object, doesNotUnderstand triggers the querying of the Java classpath to load classes corresponding to the missing selector.
NATText	JavaPackage.meta_print()
protected NATObject	JavaPackage.createClone(FieldMap map, java.util.Vector state, java.util.LinkedList customFields, MethodDictionary methodDict, ATObject dynamicParent, ATObject lexicalParent, byte flags, ATStripe[] stripes)
ATObject	JavaPackage.base_class(ATSymbol selector) Allows the AT programmer to explicitly load a class.
ATObject	JavaPackage.base_package(ATSymbol selector) Allows the AT programmer to explicitly load a package.
ATObject	JavaObject.meta_invoke(ATObject receiver, ATSymbol atSelector, ATTable arguments) When a method is invoked upon a symbiotic Java object, an underlying Java method with the same name as the AmbientTalk selector is invoked.
ATBoolean	JavaObject.meta_respondsTo(ATSymbol atSelector) A symbiotic Java object responds to all of the public non-static selectors of its Java class plus all of the per-instance selectors added to its AmbientTalk symbiont.
ATObject	JavaObject.meta_select(ATObject receiver, ATSymbol selector) When selecting a field from a symbiotic Java object, if the Java symbiont object's class has a non-static field with a matching selector, it is automatically read; if it has a corresponding method, the method is returned in a closure.
ATObject	JavaObject.meta_lookup(ATSymbol selector) A variable lookup is resolved by first checking whether the Java object has a field with a matching name.
ATNil	JavaObject.meta_defineField(ATSymbol name, ATObject value) Fields can be defined within a symbiotic Java object.
ATNil	JavaObject.meta_assignVariable(ATSymbol name, ATObject value) Variables can be assigned within a symbiotic Java object if that object's class has a mutable field with a matching name.
ATNil	JavaObject.meta_assignField(ATObject receiver, ATSymbol name, ATObject value) Fields can be assigned within a symbiotic Java object if that object's class has a mutable field with a matching name.
ATObject	JavaObject.meta_clone() Cloning a symbiotic object is not always possible as Java has no uniform cloning semantics.
ATObject	JavaObject.meta_newInstance(ATTable initargs) Invoking new on a JavaObject will exhibit the same behaviour as if new was invoked on the parent class.
ATNil	JavaObject.meta_addMethod(ATMethod method) Methods can be added to a symbiotic Java object provided they do not already exist in the Java object's class.
ATField	JavaObject.meta_grabField(ATSymbol fieldName) Fields can be grabbed from a symbiotic Java object.
ATMethod	JavaObject.meta_grabMethod(ATSymbol methodName) Methods can be grabbed from a symbiotic Java object.
ATTable	JavaObject.meta_listFields() Querying a symbiotic Java object for its fields results in a table containing both the 'native' Java fields and the fields of its AT symbiont
ATTable	JavaObject.meta_listMethods() Querying a symbiotic Java object for its methods results in a table containing both all 'native' Java instance methods and the methods of its AT symbiont
ATBoolean	JavaObject.meta_isCloneOf(ATObject original)
NATText	JavaObject.meta_print()
ATObject	JavaObject.meta_pass() Passing a Java Object wrapper to another actor has the following effect: - if the wrapped Java object is serializable, the symbiotic AmbientTalk object is treated as by copy (i.e. as an isolate)
ATObject	JavaObject.meta_resolve() If the wrapped object was serializable, we may be asked to resolve ourselves.
ATObject	JavaMethod.base_apply(ATTable arguments, ATContext ctx)
ATObject	JavaMethod.base_applyInScope(ATTable arguments, ATContext ctx)
ATBegin	JavaMethod.base_getBodyExpression()
ATSymbol	JavaMethod.base_getName()
ATTable	JavaMethod.base_getParameters()
NATText	JavaMethod.meta_print()
ATTable	JavaMethod.meta_getStripes()
ATObject	JavaField.base_readField()
ATNil	JavaField.base_writeField(ATObject newValue)
NATText	JavaField.meta_print()
ATObject	JavaField.meta_newInstance(ATTable initargs) Fields can be re-initialized when installed in an object that is being cloned.
ATTable	JavaField.meta_getStripes()
ATContext	JavaClosure.base_getContext() Overridden to allow for lazy instantiation of the context.
NATText	JavaClosure.meta_print()
ATClosure	JavaClosure.base_cast(ATObject[] types) For each Method in the wrapped JavaMethod's choices_, check whether it is compatible with the given types.
ATObject	JavaClass.meta_invoke(ATObject receiver, ATSymbol atSelector, ATTable arguments) When a method is invoked upon a symbiotic Java class object, the underlying static Java method with the same name as the AmbientTalk selector is invoked.
ATBoolean	JavaClass.meta_respondsTo(ATSymbol atSelector) A symbiotic Java class object responds to all of the public static selectors of its Java class plus all of the per-instance selectors added to its AmbientTalk symbiont.
ATObject	JavaClass.meta_select(ATObject receiver, ATSymbol selector) When selecting a field from a symbiotic Java class object, if the object's class has a static field with a matching selector, it is automatically read; if it has methods corresponding to the selector, they are returned in a JavaMethod wrapper, otherwise, the fields of its AT symbiont are checked.
ATObject	JavaClass.meta_lookup(ATSymbol selector) A variable lookup is resolved by first checking whether the Java object has an appropriate static field with a matching name.
ATNil	JavaClass.meta_defineField(ATSymbol name, ATObject value) Fields can be defined within a symbiotic Java class object.
ATNil	JavaClass.meta_assignVariable(ATSymbol name, ATObject value) Variables can be assigned within a symbiotic Java class object if that class object has a mutable static field with a matching name.
ATNil	JavaClass.meta_assignField(ATObject receiver, ATSymbol name, ATObject value) Fields can be assigned within a symbiotic Java class object if that class has a mutable field with a matching name.
ATObject	JavaClass.meta_clone() Symbiotic Java class objects are singletons.
ATObject	JavaClass.meta_newInstance(ATTable initargs) aJavaClass.new(@args) == invoke a Java constructor AmbientTalk objects can add a custom new method to the class in order to intercept instance creation.
ATNil	JavaClass.meta_addMethod(ATMethod method) Methods can be added to a symbiotic Java class object provided they do not already exist in the Java class.
ATField	JavaClass.meta_grabField(ATSymbol fieldName) Fields can be grabbed from a symbiotic Java class object.
ATMethod	JavaClass.meta_grabMethod(ATSymbol methodName) Methods can be grabbed from a symbiotic Java class object.
ATTable	JavaClass.meta_listFields() Querying a symbiotic Java class object for its fields results in a table containing both 'native' static Java fields and the fields of its AT symbiont
ATTable	JavaClass.meta_listMethods() Querying a symbiotic Java class object for its methods results in a table containing both 'native' static Java methods and the methods of its AT symbiont
ATBoolean	JavaClass.meta_isCloneOf(ATObject original)
NATText	JavaClass.meta_print()
ATObject	JavaClass.meta_resolve() A Java Class object remains unique within an actor.
ATTable	JavaClass.base_getParentStripes() If this class represents an interface type, parentStripes are wrappers for all interfaces extended by this Java interface type
ATSymbol	JavaClass.base_getStripeName()
ATBoolean	JavaClass.base_isSubstripeOf(ATStripe other) A Java interface type used as a stripe can only be a substripe of another Java interface type used as a stripe, and only if this type is assignable to the other type.
ATClosure	ATJavaClosure.base_cast(ATObject[] types) Using this method, AmbientTalk symbiotic code is able to perform manual overloaded method disambiguation.

Constructors in edu.vub.at.objects.symbiosis that throw InterpreterException

JavaPackage(FieldMap map, java.util.Vector state, java.util.LinkedList customFields, MethodDictionary methodDict, ATObject dynamicParent, ATObject lexicalParent, byte flags, ATStripe[] stripes, java.lang.String path)
Private constructor used only for cloning

Uses of InterpreterException in edu.vub.at.parser

Methods in edu.vub.at.parser that throw InterpreterException

static NATAbstractGrammar	ATParserTest.parseProgram(java.lang.String parserInput)
ATAbstractGrammar	NATParser.base_parse(ATText source)
static ATAbstractGrammar	NATParser.parse(java.lang.String filename, java.io.InputStream source)
static ATAbstractGrammar	NATParser.parse(java.lang.String filename, java.lang.String source)
NATText	NATParser.meta_print()
ATObject	NATParser.meta_resolve() After deserialization, ensure that the parser remains unique.

Uses of InterpreterException in edu.vub.at.tutorial

Methods in edu.vub.at.tutorial that throw InterpreterException

void	TutorialTest.testBasicProgramming()