Hi I'm rethinking about my objvlisp lecture. In this lecture I'm talking about building the objVlisp kernel in Smalltalk. Now everything is working well except the error handling when a method is not found with different arguments than the original. Methods are represented with blocks having different number of arguments. I have several send messages (I should simplify this in the future) ------------------------------------------ binarySend: selector with: argument "send the message whose selector is <selector> to the receiver. The arguments of the messages are an <argument>. The method is lookep up in the class of the receiver. self is an objObject or a objClass." | ans | ans := (self objClass lookup: selector for: self) value: self value: argument. ^ ans send: selector withArguments: arguments "send the message whose selector is <selector> to the receiver. The arguments of the messages are an array <arguments>. The method is lookep up in the class of the receiver. self is an objObject or a objClass." | ans | ans := (self objClass lookup: selector for: self) valueWithArguments: (Array with: self) , arguments. ^ ans lookup is as simple as ------------------------------ lookup: selector for: anObjObject "look for the method named <selector> starting in the receiver. The lookup is done for a message sent to <anObjObject>. self is an objClass" ^(self doesUnderstand: selector) ifTrue: [ self bodyOfMethod: selector] ifFalse: [self objName = #ObjObject ifFalse: [ (Obj giveClassNamed: self objSuperclassId) lookup: selector for: anObjObject.] ifTrue: [ anObjObject objClass lookup: #error for: anObjObject]] Now the problem is that error redefinition only works if the same number of arguments are used and this is not nice. For example error redefinition works: --------------------------------------------------- testErrorRedefinition "(self run: #testErrorRedefinition)" self should: [aPoint unarySend: #zork] raise: Error. (pointClass at: pointClass offsetForMethodDict) at: #error put: ([ :superClassOfClassDefiningTheMethod | [:objself | 33]] value: objectClass). self assert: (aPoint unarySend: #zork) = 33. I could use cull: or something like that to be able to execute the block representing the error message But I have the impression that I need a way to say that the lookup failed and that the arguments should be packed in a message object. I looked in the StackVM to see how the arguments were handled: how do we go some lookupMethodInClass: class | currentClass dictionary found | ... currentClass := class. [currentClass ~= objectMemory nilObject] whileTrue: [dictionary := objectMemory fetchPointer: MethodDictionaryIndex ofObject: currentClass. ... found := self lookupMethodInDictionary: dictionary. found ifTrue: [^currentClass]. currentClass := self superclassOf: currentClass]. ... "Cound not find a normal message -- raise exception #doesNotUnderstand:" self createActualMessageTo: class. messageSelector := objectMemory splObj: SelectorDoesNotUnderstand. ^self lookupMethodInClass: class Am I correct to believe that createActualMessageTo: eats up the call args and does basically what I would like to do Stef