void SmalltalkVM::doSendMessage(TVMExecutionContext& ec, TSymbol* selector, TObjectArray* arguments, TClass* receiverClass /*= 0*/ )
{
hptr<TObjectArray> messageArguments = newPointer(arguments);
if (!receiverClass) {
TObject* receiver = messageArguments[0];
assert(receiver != 0);
receiverClass = isSmallInteger(receiver) ? globals.smallIntClass : receiver->getClass();
assert(receiverClass != 0);
}
hptr<TMethod> receiverMethod = newPointer(lookupMethod(selector, receiverClass));
// Checking whether we found a method
if (receiverMethod == 0) {
// Oops. Method was not found. In this case we should send #doesNotUnderstand: message to the receiver
setupVarsForDoesNotUnderstand(receiverMethod, messageArguments, selector, receiverClass);
// Continuing the execution just as if #doesNotUnderstand: was the actual selector that we wanted to call
}
// Save stack and opcode pointers
ec.storePointers();
// Create a new context for the giving method and arguments
hptr<TContext> newContext = newObject<TContext>();
hptr<TObjectArray> newStack = newObject<TObjectArray>(receiverMethod->stackSize);
hptr<TObjectArray> newTemps = newObject<TObjectArray>(receiverMethod->temporarySize);
newContext->stack = newStack;
newContext->temporaries = newTemps;
newContext->arguments = messageArguments;
newContext->method = receiverMethod;
newContext->stackTop = 0;
newContext->bytePointer = 0;
// Suppose that current send message operation is last operation in the current context.
// If it is true then next instruction will be either stackReturn or blockReturn.
//
// VM will switch to the newContext, perform it and then switch back to the current context
// for the single one return instruction. This is pretty dumb to load the whole context
// just to exit it immediately. Therefore, we looking one instruction ahead to see if it is
// a return instruction. If it is, we may skip our context and set our previousContext as
// previousContext for the newContext. In case of blockReturn it will be the previousContext
// of the wrapping method context.
uint8_t nextInstruction = ec.currentContext->method->byteCodes->getByte(ec.bytePointer);
if (nextInstruction == (opcode::doSpecial * 16 + special::stackReturn)) {
// Optimizing stack return
newContext->previousContext = ec.currentContext->previousContext;
} else if (nextInstruction == (opcode::doSpecial * 16 + special::blockReturn) &&
(ec.currentContext->getClass() == globals.blockClass))
{
// Optimizing block return
newContext->previousContext = ec.currentContext.cast<TBlock>()->creatingContext->previousContext;
} else {
newContext->previousContext = ec.currentContext;
}
// Replace current context with the new one. On the next iteration,
// VM will start interpreting instructions from the new context.
ec.currentContext = newContext;
ec.loadPointers();
m_messagesSent++;
}
