// The primitive handles PositionableStream>>atEnd, but only for arrays/strings
// Does not use successFlag. Unary, so does not modify the stack pointer
BOOL __fastcall Interpreter::primitiveAtEnd()
{
PosStreamOTE* streamPointer = reinterpret_cast<PosStreamOTE*>(stackTop()); // Access receiver
//ASSERT(!ObjectMemoryIsIntegerObject(streamPointer) && ObjectMemory::isKindOf(streamPointer, Pointers.ClassPositionableStream));
PositionableStream* readStream = streamPointer->m_location;
// Ensure valid stream (see BBB p632)
if (!ObjectMemoryIsIntegerObject(readStream->m_index) ||
!ObjectMemoryIsIntegerObject(readStream->m_readLimit))
return primitiveFailure(0);
SMALLINTEGER index = ObjectMemoryIntegerValueOf(readStream->m_index);
SMALLINTEGER limit = ObjectMemoryIntegerValueOf(readStream->m_readLimit);
BehaviorOTE* bufClass = readStream->m_array->m_oteClass;
OTE* boolResult;
if (bufClass == Pointers.ClassString || bufClass == Pointers.ClassByteArray)
boolResult = index >= limit || (MWORD(index) >= readStream->m_array->bytesSize()) ?
Pointers.True : Pointers.False;
else if (bufClass == Pointers.ClassArray)
boolResult = index >= limit || (MWORD(index) >= readStream->m_array->pointersSize()) ?
Pointers.True : Pointers.False;
else
return primitiveFailure(1); // Doesn't work for non-Strings/ByteArrays/Arrays, or if out of bounds
stackTop() = reinterpret_cast<Oop>(boolResult);
return primitiveSuccess();
}
Oop* Interpreter::primitiveCopyFromTo(Oop* const sp, unsigned)
{
Oop oopToArg = *sp;
Oop oopFromArg = *(sp - 1);
OTE* oteReceiver = reinterpret_cast<OTE*>(*(sp - 2));
if (ObjectMemoryIsIntegerObject(oopToArg) && ObjectMemoryIsIntegerObject(oopFromArg))
{
SMALLINTEGER from = ObjectMemoryIntegerValueOf(oopFromArg);
SMALLINTEGER to = ObjectMemoryIntegerValueOf(oopToArg);
if (from > 0)
{
SMALLINTEGER count = to - from + 1;
if (count >= 0)
{
OTE* oteAnswer = ObjectMemory::CopyElements(oteReceiver, from - 1, count);
if (oteAnswer != nullptr)
{
*(sp - 2) = (Oop)oteAnswer;
ObjectMemory::AddToZct(oteAnswer);
return sp - 2;
}
}
}
// Bounds error
return primitiveFailure(1);
}
else
{
// Non-SmallInteger from and/or to
return primitiveFailure(0);
}
}
// Locate the next occurrence of the given character in the receiver between the specified indices.
BOOL __fastcall Interpreter::primitiveStringNextIndexOfFromTo()
{
Oop integerPointer = stackTop();
if (!ObjectMemoryIsIntegerObject(integerPointer))
return primitiveFailure(0); // to not an integer
const SMALLINTEGER to = ObjectMemoryIntegerValueOf(integerPointer);
integerPointer = stackValue(1);
if (!ObjectMemoryIsIntegerObject(integerPointer))
return primitiveFailure(1); // from not an integer
SMALLINTEGER from = ObjectMemoryIntegerValueOf(integerPointer);
Oop valuePointer = stackValue(2);
StringOTE* receiverPointer = reinterpret_cast<StringOTE*>(stackValue(3));
Oop answer = ZeroPointer;
if ((ObjectMemory::fetchClassOf(valuePointer) == Pointers.ClassCharacter) && to >= from)
{
ASSERT(!receiverPointer->isPointers());
// Search a byte object
const SMALLINTEGER length = receiverPointer->bytesSize();
// We can only be in here if to>=from, so if to>=1, then => from >= 1
// furthermore if to <= length then => from <= length
if (from < 1 || to > length)
return primitiveFailure(2);
// Search is in bounds, lets do it
CharOTE* oteChar = reinterpret_cast<CharOTE*>(valuePointer);
Character* charObj = oteChar->m_location;
const char charValue = static_cast<char>(ObjectMemoryIntegerValueOf(charObj->m_asciiValue));
String* chars = receiverPointer->m_location;
from--;
while (from < to)
{
if (chars->m_characters[from++] == charValue)
{
answer = ObjectMemoryIntegerObjectOf(from);
break;
}
}
}
stackValue(3) = answer;
pop(3);
return primitiveSuccess();
}
VariantObject* ObjectMemory::resize(PointersOTE* ote, MWORD newPointers, bool bRefCount)
{
ASSERT(!ObjectMemoryIsIntegerObject(ote) && ote->isPointers());
VariantObject* pObj = ote->m_location;
const MWORD oldPointers = ote->pointersSize();
// If resizing the active process, then we don't do any ref. counting as refs from
// the current stack are not counted (we used deferred ref. counting)
if (bRefCount)
{
for (MWORD i=newPointers;i<oldPointers;i++)
countDown(pObj->m_fields[i]);
}
// Reallocate the object to the new size (bigger or smaller)
pObj = reinterpret_cast<VariantObject*>(basicResize(reinterpret_cast<POTE>(ote), SizeOfPointers(newPointers), 0));
if (pObj)
{
ASSERT(newPointers == ote->pointersSize());
newPointers = ote->pointersSize();
// Initialize any new pointers to Nil (indices must fit in a SmallInteger)
const Oop nil = Oop(Pointers.Nil);
for (MWORD i=oldPointers; i<newPointers; i++)
pObj->m_fields[i] = nil;
}
return pObj;
}
// Uses object identity to locate the next occurrence of the argument in the receiver from
// the specified index to the specified index
Oop* __fastcall Interpreter::primitiveStringSearch()
{
Oop* const sp = m_registers.m_stackPointer;
Oop integerPointer = *sp;
if (!ObjectMemoryIsIntegerObject(integerPointer))
return primitiveFailure(0); // startingAt not an integer
const SMALLINTEGER startingAt = ObjectMemoryIntegerValueOf(integerPointer);
Oop oopSubString = *(sp-1);
BytesOTE* oteReceiver = reinterpret_cast<BytesOTE*>(*(sp-2));
if (ObjectMemory::fetchClassOf(oopSubString) != oteReceiver->m_oteClass)
return primitiveFailure(2);
// We know it can't be a SmallInteger because it has the same class as the receiver
BytesOTE* oteSubString = reinterpret_cast<BytesOTE*>(oopSubString);
VariantByteObject* bytesPattern = oteSubString->m_location;
VariantByteObject* bytesReceiver = oteReceiver->m_location;
const int M = oteSubString->bytesSize();
const int N = oteReceiver->bytesSize();
// Check 'startingAt' is in range
if (startingAt < 1 || startingAt > N)
return primitiveFailure(1); // out of bounds
int nOffset = M == 0 || ((startingAt + M) - 1 > N)
? -1
: stringSearch(bytesReceiver->m_fields, N, bytesPattern->m_fields, M, startingAt - 1);
*(sp-2) = ObjectMemoryIntegerObjectOf(nOffset+1);
return sp-2;
}
// Callback proc for MM timers
// N.B. This routine is called from a separate thread (in Win32), rather than in
// interrupt time, but careful coding is still important. The recommended
// list of routines is limited to:
// EnterCriticalSection ReleaseSemaphore
// LeaveCriticalSection SetEvent
// timeGetSystemTime timeGetTime
// OutputDebugString timeKillEvent
// PostMessage timeSetEvent
//
// "If a Win32 low-level audio callback [we are using mm timers here] shares data
// with other code, a Critical Section or similar mutual exclusion mechanism should
// be used to protect the integrity of the data".
// Access to the asynchronous semaphore array is protected by a critical section
// in the asynchronousSignal and CheckProcessSwitch routines. We don't really care
// that much about the timerID
void CALLBACK Interpreter::TimeProc(UINT uID, UINT /*uMsg*/, DWORD /*dwUser*/, DWORD /*dw1*/, DWORD /*dw2*/)
{
// Avoid firing a timer which has been cancelled (or is about to be cancelled!)
// We use an InterlockedExchange() to set the value to 0 so that the main thread
// can recognise that the timer has fired without race conditions
if (_InterlockedExchange(reinterpret_cast<SHAREDLONG*>(&timerID), 0) != 0)
{
// If not previously killed (which is very unlikely except in certain exceptional
// circumstances where the timer is killed at the exact moment it is about to fire)
// then go ahead and signal the semaphore and the wakeup event
// We mustn't access Pointers from an async thread when object memory is compacting
// as the Pointer will be wrong
GrabAsyncProtect();
SemaphoreOTE* timerSemaphore = Pointers.TimingSemaphore;
HARDASSERT(!ObjectMemoryIsIntegerObject(timerSemaphore));
HARDASSERT(!timerSemaphore->isFree());
HARDASSERT(timerSemaphore->m_oteClass == Pointers.ClassSemaphore);
// Asynchronously signal the required semaphore asynchronously, which will be detected
// in sync. with the dispatching of byte codes, and properly signalled
asynchronousSignalNoProtect(timerSemaphore);
// Signal the timing Event, in case the idle process has put the VM to sleep
SetWakeupEvent();
RelinquishAsyncProtect();
}
else
// An old timer (which should have been cancelled) has fired
trace("Old timer %d fired, current %d\n", uID, timerID);
}
VariantByteObject* ObjectMemory::resize(BytesOTE* ote, MWORD newByteSize)
{
ASSERT(!ObjectMemoryIsIntegerObject(ote) && ote->isBytes());
MWORD totalByteSize = newByteSize + SizeOfPointers(0); // Add header size
VariantByteObject* pByteObj = ote->m_location;
MWORD oldByteSize = ote->getSize();
if (ote->isNullTerminated())
{
pByteObj = reinterpret_cast<VariantByteObject*>(ObjectMemory::basicResize(reinterpret_cast<POTE>(ote), totalByteSize, 1));
ASSERT(pByteObj); // Null-terminated objects should always be resizeable
// Ensure we have a null-terminator
reinterpret_cast<BYTE*>(pByteObj)[totalByteSize] = 0;
}
else
pByteObj = reinterpret_cast<VariantByteObject*>(ObjectMemory::basicResize(reinterpret_cast<POTE>(ote), totalByteSize, 0));
if (pByteObj && totalByteSize > oldByteSize)
{
// The object grew, so ensure it is properly initialized
memset(reinterpret_cast<BYTE*>(pByteObj)+oldByteSize, 0, totalByteSize-oldByteSize);
}
return pByteObj;
}
// This primitive handles PositionableStream>>nextSDWORD, but only for byte-arrays
// Unary message, so does not modify stack pointer
BOOL __fastcall Interpreter::primitiveNextSDWORD()
{
PosStreamOTE* streamPointer = reinterpret_cast<PosStreamOTE*>(stackTop()); // Access receiver
PositionableStream* readStream = streamPointer->m_location;
// Ensure valid stream - unusually this validity check is included in the Blue Book spec
// and appears to be implemented in most Smalltalks, so we implement here too.
if (!ObjectMemoryIsIntegerObject(readStream->m_index) ||
!ObjectMemoryIsIntegerObject(readStream->m_readLimit))
return primitiveFailure(0); // Receiver fails invariant check
SMALLINTEGER index = ObjectMemoryIntegerValueOf(readStream->m_index);
SMALLINTEGER limit = ObjectMemoryIntegerValueOf(readStream->m_readLimit);
// Is the current index within the limits of the collection?
// Remember that the index is 1 based (it's a Smalltalk index), and we're 0 based,
// so we don't need to increment it until after we've got the next object
if (index < 0 || index >= limit)
return primitiveFailure(2); // No, fail it
OTE* oteBuf = readStream->m_array;
BehaviorOTE* bufClass = oteBuf->m_oteClass;
if (bufClass != Pointers.ClassByteArray)
return primitiveFailure(1); // Collection cannot be handled by primitive, rely on Smalltalk code
ByteArrayOTE* oteBytes = reinterpret_cast<ByteArrayOTE*>(oteBuf);
const int newIndex = index + sizeof(SDWORD);
if (MWORD(newIndex) > oteBytes->bytesSize())
return primitiveFailure(3);
const Oop oopNewIndex = ObjectMemoryIntegerObjectOf(newIndex);
if (int(oopNewIndex) < 0)
return primitiveFailure(4); // index overflowed SmallInteger range
// When incrementing the index we must allow for it overflowing a SmallInteger, even though
// this is extremely unlikely in practice
readStream->m_index = oopNewIndex;
// Receiver is overwritten
ByteArray* byteArray = oteBytes->m_location;
replaceStackTopWithNew(Integer::NewSigned32(*reinterpret_cast<SDWORD*>(byteArray->m_elements+index)));
return primitiveSuccess(); // Succeed
}
Oop* __fastcall Interpreter::primitivePerform(CompiledMethod& , unsigned argCount)
{
SymbolOTE* performSelector = m_oopMessageSelector; // Save in case we need to restore
SymbolOTE* selectorToPerform = reinterpret_cast<SymbolOTE*>(stackValue(argCount-1));
if (ObjectMemoryIsIntegerObject(selectorToPerform))
return primitiveFailure(1);
m_oopMessageSelector = selectorToPerform;
Oop newReceiver = stackValue(argCount);
// lookupMethodInClass returns the Oop of the new CompiledMethod
// if the selector is found, or Pointers.DoesNotUnderstand if the class
// does not understand the selector. We succeed if either the argument
// count of the returned method matches that passed to this primitive,
// or if the selector is not understood, because by this time the
// detection of the 'does not understand' will have triggered
// the create of a Message object (see createActualMessage) into
// which all the arguments will have been moved, and which then replaces
// those arguments on the Smalltalk context stack. i.e. the primitive
// will succeed if the message is not understood, but will result in
// the execution of doesNotUnderstand: rather than the selector we've
// been asked to perform. This works because
// after a doesNotUnderstand detection, the stack has a Message at stack
// top, the selector is still there, and argCount is now 1. Consequently
// the Message gets shuffled over the selector, and doesNotUnderstand is
// sent
MethodOTE* methodPointer = findNewMethodInClass(ObjectMemory::fetchClassOf(newReceiver), (argCount-1));
CompiledMethod* method = methodPointer->m_location;
if (method->m_header.argumentCount == (argCount-1) ||
m_oopMessageSelector == Pointers.DoesNotUnderstandSelector)
{
// Shuffle arguments down over the selector (use argumentCount of
// method found which may not equal argCount)
const unsigned methodArgCount = method->m_header.argumentCount;
// #pragma message("primitivePerform: Instead of shuffling args down 1, why not just deduct 1 from calling frames suspended SP after exec?")
Oop* const sp = m_registers.m_stackPointer - methodArgCount;
// We don't need to count down the overwritten oop anymore, since we don't ref. count stack ops
// Not worth overhead of calling memmove here since argumentCount
// normally small
for (unsigned i=0;i<methodArgCount;i++)
sp[i] = sp[i+1];
popStack();
executeNewMethod(methodPointer, methodArgCount);
return primitiveSuccess(0);
}
else
{
// The argument count did not match, so drop out into the Smalltalk
// having restored the selector
ASSERT(m_oopMessageSelector!=Pointers.DoesNotUnderstandSelector);
m_oopMessageSelector = performSelector;
return primitiveFailure(0);
}
}
// Answer a new process with an initial stack size specified by the first argument, and a maximum
// stack size specified by the second argument.
Oop* __fastcall Interpreter::primitiveNewVirtual(Oop* const sp, unsigned)
{
Oop maxArg = *sp;
SMALLINTEGER maxSize;
if (ObjectMemoryIsIntegerObject(maxArg) && (maxSize = ObjectMemoryIntegerValueOf(maxArg)) >= 0)
{
Oop initArg = *(sp - 1);
SMALLINTEGER initialSize;
if (ObjectMemoryIsIntegerObject(initArg) && (initialSize = ObjectMemoryIntegerValueOf(initArg)) >= 0)
{
BehaviorOTE* receiverClass = reinterpret_cast<BehaviorOTE*>(*(sp - 2));
InstanceSpecification instSpec = receiverClass->m_location->m_instanceSpec;
if (instSpec.m_indexable && !instSpec.m_nonInstantiable)
{
unsigned fixedFields = instSpec.m_fixedFields;
VirtualOTE* newObject = ObjectMemory::newVirtualObject(receiverClass, initialSize + fixedFields, maxSize);
if (newObject)
{
*(sp - 2) = reinterpret_cast<Oop>(newObject);
// No point saving down SP before potential Zct reconcile as the init & max args must be SmallIntegers
ObjectMemory::AddToZct((OTE*)newObject);
return sp - 2;
}
else
return primitiveFailure(4); // OOM
}
else
{
return primitiveFailure(instSpec.m_nonInstantiable ? 3 : 2); // Non-indexable or abstract class
}
}
else
{
return primitiveFailure(1); // initialSize arg not a SmallInteger
}
}
else
{
return primitiveFailure(0); // maxsize arg not a SmallInteger
}
}
inline void Interpreter::subclassWindow(OTE* window, HWND hWnd)
{
ASSERT(!ObjectMemoryIsIntegerObject(window));
// As this is called from an external entry point, we must ensure that OT/stack overflows
// are handled, and also that we catch the SE_VMCALLBACKUNWIND exceptions
__try
{
bool bDisabled = disableInterrupts(true);
Oop retVal = performWith(Oop(window), Pointers.subclassWindowSymbol, Oop(ExternalHandle::New(hWnd)));
ObjectMemory::countDown(retVal);
ASSERT(m_bInterruptsDisabled);
disableInterrupts(bDisabled);
}
__except (callbackExceptionFilter(GetExceptionInformation()))
{
trace("WARNING: Unwinding Interpreter::subclassWindow(%#x, %#x)\n", window, hWnd);
}
}
BOOL __fastcall Interpreter::primitiveSnapshot(CompiledMethod&, unsigned argCount)
{
Oop arg = stackValue(argCount - 1);
char* szFileName;
if (arg == Oop(Pointers.Nil))
szFileName = 0;
else if (ObjectMemory::fetchClassOf(arg) == Pointers.ClassString)
{
StringOTE* oteString = reinterpret_cast<StringOTE*>(arg);
String* fileName = oteString->m_location;
szFileName = fileName->m_characters;
}
else
return primitiveFailure(0);
bool bBackup;
if (argCount >= 2)
bBackup = reinterpret_cast<OTE*>(stackValue(argCount - 2)) == Pointers.True;
else
bBackup = false;
SMALLINTEGER nCompressionLevel;
if (argCount >= 3)
{
Oop oopCompressionLevel = stackValue(argCount - 3);
nCompressionLevel = ObjectMemoryIsIntegerObject(oopCompressionLevel) ? ObjectMemoryIntegerValueOf(oopCompressionLevel) : 0;
}
else
nCompressionLevel = 0;
SMALLUNSIGNED nMaxObjects = 0;
if (argCount >= 4)
{
Oop oopMaxObjects = stackValue(argCount - 4);
if (ObjectMemoryIsIntegerObject(oopMaxObjects))
{
nMaxObjects = ObjectMemoryIntegerValueOf(oopMaxObjects);
}
}
// N.B. It is not necessary to clear down the memory pools as the free list is rebuild on every image
// load and the pool members, though not on the free list at present, are marked as free entries
// in the object table
// ZCT is reconciled, so objects may be deleted
flushAtCaches();
// Store the active frame of the active process before saving so available on image reload
// We're not actually suspending the process now, but it appears like that to the snapshotted
// image on restarting
m_registers.PrepareToSuspendProcess();
#ifdef OAD
DWORD timeStart = timeGetTime();
#endif
int saveResult = ObjectMemory::SaveImageFile(szFileName, bBackup, nCompressionLevel, nMaxObjects);
#ifdef OAD
DWORD timeEnd = timeGetTime();
TRACESTREAM << "Time to save image: " << (timeEnd - timeStart) << " mS" << endl;
#endif
if (!saveResult)
{
// Success
popStack();
return primitiveSuccess();
}
else
{
// Failure
return primitiveFailure(saveResult);
}
}
Oop* __fastcall Interpreter::primitivePerformWithArgs()
{
Oop* const sp = m_registers.m_stackPointer;
ArrayOTE* argumentArray = reinterpret_cast<ArrayOTE*>(*(sp));
BehaviorOTE* arrayClass = ObjectMemory::fetchClassOf(Oop(argumentArray));
if (arrayClass != Pointers.ClassArray)
return primitiveFailure(0);
// N.B. We're using a large stack, so don't bother checking for overflow
// (standard stack overflow mechanism should catch it)
// We must not get the length outside, in case small integer arg
const unsigned argCount = argumentArray->pointersSize();
// Save old message selector in case of prim failure (need to reinstate)
SymbolOTE* performSelector = m_oopMessageSelector;
// To ensure the argumentArray doesn't go away when we push its contents
// onto the stack, in case we need it for recovery from an argument
// count mismatch we leave its ref. count elevated
SymbolOTE* selectorToPerform = reinterpret_cast<SymbolOTE*>(*(sp-1));
if (ObjectMemoryIsIntegerObject(selectorToPerform))
return primitiveFailure(1);
m_oopMessageSelector = selectorToPerform; // Get selector from stack
// Don't need to count down the stack ref.
ASSERT(!selectorToPerform->isFree());
Oop newReceiver = *(sp-2); // receiver is under selector and arg array
// Push the args from the array onto the stack. We must do this before
// looking up the method, because if the receiver does not understand
// the method then the lookup routines copy the arguments off the stack
// into a Message object
Array* args = argumentArray->m_location;
for (MWORD i=0; i<argCount; i++)
{
Oop pushee = args->m_elements[i];
// Note no need to inc the ref. count when pushing on the stack
sp[i-1] = pushee;
}
// Args written over top of selector and argument array (hence -2)
m_registers.m_stackPointer = sp+argCount-2;
// There is a subtle complication here when the receiver does not
// understand the message, by which lookupMethodInClass() converts
// the message we're trying to perform to a #doesNotUnderstand: with
// all arguments moved to a Message. We still want to execute this
// does not understand, so we also execute the method if the argument
// counts do not match, but it was not understood. Note that it is
// possible for a doesNotUnderstand: to be executed thru the first
// test if the argumentArray contained only one argument. We allow
// this to happen to avoid testing for not understood in the normal
// case - just be aware of this anomaly.
MethodOTE* methodPointer = findNewMethodInClass(ObjectMemory::fetchClassOf(newReceiver), argCount);
CompiledMethod& method = *methodPointer->m_location;
const unsigned methodArgCount = method.m_header.argumentCount;
if (methodArgCount == argCount ||
m_oopMessageSelector == Pointers.DoesNotUnderstandSelector)
{
// WE no longer need the argument array, but don't count it down since we only have a stack ref.
executeNewMethod(methodPointer, methodArgCount);
return primitiveSuccess(0);
}
else
{
// Receiver must have understood the message, but we had wrong
// number of arguments, so reinstate the stack and fail the primitive
pop(argCount);
pushObject((OTE*)m_oopMessageSelector);
// Argument array already has artificially increased ref. count
push(Oop(argumentArray));
m_oopMessageSelector = performSelector;
return primitiveFailure(1);
}
}
// Uses object identity to locate the next occurrence of the argument in the receiver from
// the specified index to the specified index
Oop* __fastcall Interpreter::primitiveNextIndexOfFromTo()
{
Oop integerPointer = stackTop();
if (!ObjectMemoryIsIntegerObject(integerPointer))
return primitiveFailure(0); // to not an integer
const SMALLINTEGER to = ObjectMemoryIntegerValueOf(integerPointer);
integerPointer = stackValue(1);
if (!ObjectMemoryIsIntegerObject(integerPointer))
return primitiveFailure(1); // from not an integer
SMALLINTEGER from = ObjectMemoryIntegerValueOf(integerPointer);
Oop valuePointer = stackValue(2);
OTE* receiverPointer = reinterpret_cast<OTE*>(stackValue(3));
// #ifdef _DEBUG
if (ObjectMemoryIsIntegerObject(receiverPointer))
return primitiveFailure(2); // Not valid for SmallIntegers
// #endif
Oop answer = ZeroPointer;
if (to >= from)
{
if (!receiverPointer->isPointers())
{
// Search a byte object
BytesOTE* oteBytes = reinterpret_cast<BytesOTE*>(receiverPointer);
if (ObjectMemoryIsIntegerObject(valuePointer))// Arg MUST be an Integer to be a member
{
const MWORD byteValue = ObjectMemoryIntegerValueOf(valuePointer);
if (byteValue < 256) // Only worth looking for 0..255
{
const SMALLINTEGER length = oteBytes->bytesSize();
// We can only be in here if to>=from, so if to>=1, then => from >= 1
// furthermore if to <= length then => from <= length
if (from < 1 || to > length)
return primitiveFailure(2);
// Search is in bounds, lets do it
VariantByteObject* bytes = oteBytes->m_location;
from--;
while (from < to)
if (bytes->m_fields[from++] == byteValue)
{
answer = ObjectMemoryIntegerObjectOf(from);
break;
}
}
}
}
else
{
// Search a pointer object - but only the indexable vars
PointersOTE* oteReceiver = reinterpret_cast<PointersOTE*>(receiverPointer);
VariantObject* receiver = oteReceiver->m_location;
Behavior* behavior = receiverPointer->m_oteClass->m_location;
const MWORD length = oteReceiver->pointersSize();
const MWORD fixedFields = behavior->m_instanceSpec.m_fixedFields;
// Similar reasoning with to/from as for byte objects, but here we need to
// take account of the fixed fields.
if (from < 1 || (to + fixedFields > length))
return primitiveFailure(2); // Out of bounds
Oop* indexedFields = receiver->m_fields + fixedFields;
from--;
while (from < to)
if (indexedFields[from++] == valuePointer)
{
answer = ObjectMemoryIntegerObjectOf(from);
break;
}
}
}
else
answer = ZeroPointer; // Range is non-inclusive, cannot be there
stackValue(3) = answer;
return primitiveSuccess(3);
}
/*
Implements
String>>replaceFrom: start
to: stop
with: aString
startingAt: startAt
But is also used for ByteArray
Does not use successFlag, and nils out argument (if successful)
to leave a clean stack
*/
BOOL __fastcall Interpreter::primitiveStringReplace()
{
Oop integerPointer = stackTop();
if (!ObjectMemoryIsIntegerObject(integerPointer))
return primitiveFailure(0);
SMALLINTEGER startAt = ObjectMemoryIntegerValueOf(integerPointer);
OTE* argPointer = reinterpret_cast<OTE*>(stackValue(1));
integerPointer = stackValue(2);
if (!ObjectMemoryIsIntegerObject(integerPointer))
return primitiveFailure(1);
SMALLINTEGER stop = ObjectMemoryIntegerValueOf(integerPointer);
integerPointer = stackValue(3);
if (!ObjectMemoryIsIntegerObject(integerPointer))
return primitiveFailure(2);
SMALLINTEGER start = ObjectMemoryIntegerValueOf(integerPointer);
OTE* receiverPointer = reinterpret_cast<OTE*>(stackValue(4));
// Validity checks
TODO("Try to do cleverer faster check here - too many (reproducing V behaviour)")
// Only works for byte objects
#ifdef _DEBUG
if (!receiverPointer->isBytes())
return primitiveFailure(0);
#else
// Assume primitive used correctly - i.e. only in byte objects
#endif
if (ObjectMemoryIsIntegerObject(argPointer) || !argPointer->isBytes())
return primitiveFailure(3);
// Empty move if stop before start, is considered valid regardless (strange but true)
TODO("Change this so that does fail if stop or start < 1, only like this for V compatibility")
if (stop >= start)
{
POBJECT receiverBytes = receiverPointer->m_location;
// The receiver can be an indirect pointer (e.g. an instance of ExternalAddress)
BYTE* pTo;
Behavior* byteClass = receiverPointer->m_oteClass->m_location;
if (byteClass->isIndirect())
pTo = static_cast<BYTE*>(static_cast<ExternalAddress*>(receiverBytes)->m_pointer);
else
{
int length = receiverPointer->bytesSize();
// We can only be in here if stop>=start, so if start>=1, then => stop >= 1
// furthermore if stop <= length then => start <= length
if (start < 1 || stop > length)
return primitiveFailure(4);
pTo = static_cast<ByteArray*>(receiverBytes)->m_elements;
}
POBJECT argBytes = argPointer->m_location;
// The argument can also be an indirect pointer (e.g. an instance of ExternalAddress)
BYTE* pFrom;
Behavior* argClass = argPointer->m_oteClass->m_location;
if (argClass->isIndirect())
pFrom = static_cast<BYTE*>(static_cast<ExternalAddress*>(argBytes)->m_pointer);
else
{
int length = argPointer->bytesSize();
// We can only be in here if stop>=start, so => stop-start >= 0
// therefore if startAt >= 1 then => stopAt >= 1, for similar
// reasons (since stopAt >= startAt) we don't need to test
// that startAt <= length
int stopAt = startAt+stop-start;
if (startAt < 1 || stopAt > length)
return primitiveFailure(4);
pFrom = static_cast<ByteArray*>(argBytes)->m_elements;
}
// Remember that Smalltalk indices are 1 based
// Might be overlapping
memmove(pTo+start-1, pFrom+startAt-1, stop-start+1);
}
pop(4);
return TRUE;
}
// This is a double dispatched primitive which knows that the argument is a byte object (though
// we still check this to avoid GPFs), and the receiver is guaranteed to be a byte object. e.g.
//
// aByteObject replaceBytesOf: anOtherByteObject from: start to: stop startingAt: startAt
//
BOOL __fastcall Interpreter::primitiveReplaceBytes()
{
Oop integerPointer = stackTop();
if (!ObjectMemoryIsIntegerObject(integerPointer))
return primitiveFailure(0); // startAt is not an integer
SMALLINTEGER startAt = ObjectMemoryIntegerValueOf(integerPointer);
integerPointer = stackValue(1);
if (!ObjectMemoryIsIntegerObject(integerPointer))
return primitiveFailure(1); // stop is not an integer
SMALLINTEGER stop = ObjectMemoryIntegerValueOf(integerPointer);
integerPointer = stackValue(2);
if (!ObjectMemoryIsIntegerObject(integerPointer))
return primitiveFailure(2); // start is not an integer
SMALLINTEGER start = ObjectMemoryIntegerValueOf(integerPointer);
OTE* argPointer = reinterpret_cast<OTE*>(stackValue(3));
if (ObjectMemoryIsIntegerObject(argPointer) || !argPointer->isBytes())
return primitiveFailure(3); // Argument MUST be a byte object
// Empty move if stop before start, is considered valid regardless (strange but true)
// this is the convention adopted by most implementations.
if (stop >= start)
{
if (startAt < 1 || start < 1)
return primitiveFailure(4); // Out-of-bounds
// We still permit the argument to be an address to cut down on the number of primitives
// and double dispatch methods we must implement (2 rather than 4)
BYTE* pTo;
Behavior* behavior = argPointer->m_oteClass->m_location;
if (behavior->isIndirect())
{
AddressOTE* oteBytes = reinterpret_cast<AddressOTE*>(argPointer);
// We don't know how big the object is the argument points at, so cannot check length
// against stop point
pTo = static_cast<BYTE*>(oteBytes->m_location->m_pointer);
}
else
{
// We can test that we're not going to write off the end of the argument
int length = argPointer->bytesSize();
// We can only be in here if stop>=start, so => stop-start >= 0
// therefore if startAt >= 1 then => stopAt >= 1, for similar
// reasons (since stopAt >= startAt) we don't need to test
// that startAt <= length
if (stop > length)
return primitiveFailure(4); // Bounds error
VariantByteObject* argBytes = reinterpret_cast<BytesOTE*>(argPointer)->m_location;
pTo = argBytes->m_fields;
}
BytesOTE* receiverPointer = reinterpret_cast<BytesOTE*>(stackValue(4));
// Now validate that the interval specified for copying from the receiver
// is within the bounds of the receiver (we've already tested startAt)
{
int length = receiverPointer->bytesSize();
// We can only be in here if stop>=start, so if start>=1, then => stop >= 1
// furthermore if stop <= length then => start <= length
int stopAt = startAt+stop-start;
if (stopAt > length)
return primitiveFailure(4);
}
// Only works for byte objects
ASSERT(receiverPointer->isBytes());
VariantByteObject* receiverBytes = receiverPointer->m_location;
#ifdef _DEBUG
{
Behavior* behavior = receiverPointer->m_oteClass->m_location;
ASSERT(!behavior->isIndirect());
}
#endif
BYTE* pFrom = receiverBytes->m_fields;
memmove(pTo+start-1, pFrom+startAt-1, stop-start+1);
}
// Answers the argument by moving it down over the receiver
stackValue(4) = reinterpret_cast<Oop>(argPointer);
pop(4);
return TRUE;
}
// This primitive handles WriteStream>>NextPut:, but only for Arrays, Strings & ByteArrays
// Uses but does not modify stack pointer, instead returns the number of bytes to
// pop from the Smalltalk stack.
BOOL __fastcall Interpreter::primitiveNextPut()
{
Oop* sp = m_registers.m_stackPointer;
WriteStreamOTE* streamPointer = reinterpret_cast<WriteStreamOTE*>(*(sp-1)); // Access receiver under argument
//ASSERT(!ObjectMemoryIsIntegerObject(streamPointer) && ObjectMemory::isKindOf(streamPointer, Pointers.ClassPositionableStream));
WriteStream* writeStream = streamPointer->m_location;
// Ensure valid stream - checks from Blue Book
if (!ObjectMemoryIsIntegerObject(writeStream->m_index) ||
!ObjectMemoryIsIntegerObject(writeStream->m_writeLimit))
return primitiveFailure(0); // Fails invariant check
SMALLINTEGER index = ObjectMemoryIntegerValueOf(writeStream->m_index);
SMALLINTEGER limit = ObjectMemoryIntegerValueOf(writeStream->m_writeLimit);
// Within the bounds of the limit
if (index < 0 || index >= limit)
return primitiveFailure(2);
Oop value = *(sp);
OTE* oteBuf = writeStream->m_array;
BehaviorOTE* bufClass = oteBuf->m_oteClass;
if (bufClass == Pointers.ClassString)
{
if (ObjectMemory::fetchClassOf(value) != Pointers.ClassCharacter)
return primitiveFailure(4); // Attempt to put non-character
StringOTE* oteString = reinterpret_cast<StringOTE*>(oteBuf);
if (index >= oteString->bytesSizeForUpdate())
return primitiveFailure(3); // Attempt to put non-character or off end of String
String* buf = oteString->m_location;
CharOTE* oteChar = reinterpret_cast<CharOTE*>(value);
buf->m_characters[index] = static_cast<char>(oteChar->getIndex() - ObjectMemory::FirstCharacterIdx);
}
else if (bufClass == Pointers.ClassArray)
{
ArrayOTE* oteArray = reinterpret_cast<ArrayOTE*>(oteBuf);
// In bounds of Array?
if (index >= oteArray->pointersSizeForUpdate())
return primitiveFailure(3);
Array* buf = oteArray->m_location;
// We must ref. count value here as we're storing into a heap object slot
ObjectMemory::storePointerWithValue(buf->m_elements[index], value);
}
else if (bufClass == Pointers.ClassByteArray)
{
if (!ObjectMemoryIsIntegerObject(value))
return primitiveFailure(4); // Attempt to put non-SmallInteger
SMALLINTEGER intValue = ObjectMemoryIntegerValueOf(value);
if (intValue < 0 || intValue > 255)
return primitiveFailure(4); // Can only store 0..255
ByteArrayOTE* oteByteArray = reinterpret_cast<ByteArrayOTE*>(oteBuf);
if (index >= oteByteArray->bytesSizeForUpdate())
return primitiveFailure(3); // Attempt to put non-character or off end of String
oteByteArray->m_location->m_elements[index] = static_cast<BYTE>(intValue);
}
else
return primitiveFailure(1);
writeStream->m_index = Integer::NewSigned32WithRef(index + 1); // Increment the stream index
// As we no longer pop stack here, the receiver is still under the argument
*(sp-1) = value;
return sizeof(Oop); // Pop 4 bytes
}
void Process::PostLoadFix(ProcessOTE* oteThis)
{
// Any overlapped call running when the image was saved is no longer valid, so
// we must clear down the "pointer" and remove the back reference
if (m_thread != reinterpret_cast<Oop>(Pointers.Nil))
{
m_thread = reinterpret_cast<Oop>(Pointers.Nil);
oteThis->countDown();
}
// Patch any badly created or corrupted processes
if (!ObjectMemoryIsIntegerObject(m_fpControl))
{
m_fpControl = ObjectMemoryIntegerObjectOf(_DN_SAVE | _RC_NEAR | _PC_64 | _EM_INEXACT | _EM_UNDERFLOW | _EM_OVERFLOW | _EM_DENORMAL);
}
Oop* pFramePointer = &m_suspendedFrame;
Oop framePointer = *pFramePointer;
const void* stackBase = m_stack;
const void* stackEnd = reinterpret_cast<BYTE*>(this) + oteThis->getSize() - 1;
// Wind down the stack adjusting references to self as we go
// Start with the suspended context
const int delta = m_callbackDepth - 1;
while (isIntegerObject(framePointer) && framePointer != ZeroPointer)
{
framePointer += delta;
if (framePointer < Oop(stackBase) || framePointer > Oop(stackEnd))
{
trace(L"Warning: Process at %#x has corrupt frame pointer at %#x which will be nilled\n", this, pFramePointer);
*pFramePointer = Oop(Pointers.Nil);
break;
}
else
*pFramePointer += delta;
StackFrame* pFrame = StackFrame::FromFrameOop(*pFramePointer);
if (isIntegerObject(pFrame->m_bp))
{
pFrame->m_bp += delta;
}
ASSERT(reinterpret_cast<void*>(pFrame->m_bp) > stackBase && reinterpret_cast<void*>(pFrame->m_bp) < stackEnd);
// If a stack only frame, then adjust the BP
if (!isIntegerObject(pFrame->m_environment))
{
// The frame has an object context, we need to adjust
// its back pointer to the frame if it is a MethodContext
// The context objects contain no other addresses any more
OTE* oteContext = reinterpret_cast<OTE*>(pFrame->m_environment);
if (ObjectMemory::isAContext(oteContext))
{
Context* ctx = static_cast<Context*>(oteContext->m_location);
if (isIntegerObject(ctx->m_frame) && ctx->m_frame != ZeroPointer)
{
ctx->m_frame += delta;
ASSERT(reinterpret_cast<void*>(ctx->m_frame) > stackBase && reinterpret_cast<void*>(ctx->m_frame) < stackEnd);
}
}
}
// Adjust the contexts SP
if (isIntegerObject(pFrame->m_sp))
{
pFrame->m_sp += delta;
ASSERT(reinterpret_cast<void*>(pFrame->m_sp) >= stackBase && reinterpret_cast<void*>(pFrame->m_sp) <= stackEnd);
}
pFramePointer = &pFrame->m_caller;
framePointer = *pFramePointer;
}
framePointer = SuspendedFrame();
if (isIntegerObject(framePointer) && framePointer != ZeroPointer)
{
// The size of the process should exactly correspond with that required to
// hold up to the SP of the suspended frame
StackFrame* pFrame = StackFrame::FromFrameOop(framePointer);
int size = (pFrame->m_sp - 1) - reinterpret_cast<DWORD>(this) + sizeof(Oop);
if (size > 0 && unsigned(size) < oteThis->getSize())
{
TRACE(L"WARNING: Resizing process %p from %u to %u\n", oteThis, oteThis->getSize(), size);
oteThis->setSize(size);
}
}
// else its dead or not started yet
// Later we'll use this slot to count the callback depth
m_callbackDepth = ZeroPointer;
}
// Signal a specified semaphore after the specified milliseconds duration (the argument).
// NOTE: NOT ABSOLUTE VALUE!
// If the specified time has already passed, then the TimingSemaphore is signalled immediately.
Oop* __fastcall Interpreter::primitiveSignalAtTick(CompiledMethod&, unsigned argumentCount)
{
Oop tickPointer = stackTop();
SMALLINTEGER nDelay;
if (ObjectMemoryIsIntegerObject(tickPointer))
nDelay = ObjectMemoryIntegerValueOf(tickPointer);
else
{
OTE* oteArg = reinterpret_cast<OTE*>(tickPointer);
return primitiveFailureWith(PrimitiveFailureNonInteger, oteArg); // ticks must be SmallInteger
}
// To avoid any race conditions against the global timerID value (it is quite
// common for the timer to fire, for example, before the timeSetEvent() call
// has actually returned in the duration is very short because the timer thread
// is operating at a very high priority), we use an interlocked operation
UINT outstandingID = InterlockedExchange(reinterpret_cast<SHAREDLONG*>(&timerID), 0);
// If outstanding timer now fires, it will do nothing. We'll end up killing something which is already
// dead of course, but that should be OK
if (outstandingID)
{
#ifdef OAD
TRACESTREAM << "Killing existing timer with id " << outstandingID << endl;
#endif
UINT kill = ::timeKillEvent(outstandingID);
if (kill != TIMERR_NOERROR)
trace("Failed to kill timer %u (%d,%d)!\n\r", outstandingID, kill, GetLastError());
}
if (nDelay > 0)
{
// Temporarily handle old image code that passes timer semaphore as an argument
if (argumentCount > 1 && (POTE)Pointers.TimingSemaphore == Pointers.Nil)
{
ObjectMemory::ProtectConstSpace(PAGE_READWRITE);
_Pointers.TimingSemaphore = (SemaphoreOTE*)stackValue(1);
ObjectMemory::ProtectConstSpace(PAGE_READONLY);
}
// Clamp the requested delay to the maximum if it is too large. This simplifies the Delay code in the image a little.
if (nDelay > SMALLINTEGER(wTimerMax))
{
nDelay = wTimerMax;
}
// Set the timerID to a non-zero value just in case the timer fires before timeSetEvent() returns.
// This allows the TimerProc to recognise the timer as valid (it doesn't really care about the
// timerID anyway, just that we're interested in it).
// N.B. We shouldn't need an interlocked operation here because, assuming no bugs in the Win32 MM
// timers, we've killed any outstanding timer, and the timer thread should be dormant
timerID = UINT(-1); // -1 is not used as a timer ID.
UINT newTimerID = ::timeSetEvent(nDelay, 0, TimeProc, 0, TIME_ONESHOT);
if (newTimerID && newTimerID != UINT(-1))
{
// Unless timer has already fired, record the timer id so can cancel if necessary
_InterlockedCompareExchange(reinterpret_cast<SHAREDLONG*>(&timerID), newTimerID, -1);
pop(argumentCount); // No ref. counting required
}
else
{
// System refused to set timer for some reason
DWORD error = GetLastError();
trace("Oh no, failed to set a timer for %d mS (%d)!\n\r", nDelay, error);
return primitiveFailureWithInt(PrimitiveFailureSystemError, error);
}
}
else if (nDelay == 0)
{
#ifdef _DEBUG
TRACESTREAM << "Requested delay " << dec << nDelay << " passed, signalling immediately" << endl;
#endif
// The request time has already passed, or does not fall within the
// available timer resolution (i.e. it will happen too soon), so signal
// it immediately
// We must adjust stack before signalling, as may change Process (and therefore stack!)
pop(argumentCount);
// N.B. Signalling may detect a process switch, but does not actually perform it
signalSemaphore(Pointers.TimingSemaphore);
}
// else requested delay was negative - we allow this to clear down the existing timer
#ifdef _DEBUG
if (newProcessWaiting())
{
ASSERT(m_oteNewProcess->m_oteClass == Pointers.ClassProcess);
ProcessOTE* activeProcess = scheduler()->m_activeProcess;
TRACESTREAM << "signalAtTick: Caused process switch to " << m_oteNewProcess
<< endl << "\t\tfrom " << activeProcess << endl
<< "\tasync signals " << m_qAsyncSignals.isEmpty() << ')' << endl;
}
#endif
// Delay could already have fired
CheckProcessSwitch();
return primitiveSuccess(0);
}
// This primitive handles PositionableStream>>next, but only for Arrays, Strings and ByteArrays
// Unary message, so does not modify stack pointer, and is therefore called directly from the ASM
// primitive table without indirection through an ASM thunk.
BOOL __fastcall Interpreter::primitiveNext()
{
PosStreamOTE* streamPointer = reinterpret_cast<PosStreamOTE*>(stackTop()); // Access receiver
// Only works for subclasses of PositionableStream (or look alikes)
//ASSERT(!ObjectMemoryIsIntegerObject(streamPointer) && ObjectMemory::isKindOf(streamPointer, Pointers.ClassPositionableStream));
PositionableStream* readStream = streamPointer->m_location;
// Ensure valid stream - unusually this validity check is included in the Blue Book spec
// and appears to be implemented in most Smalltalks, so we implement here too.
if (!ObjectMemoryIsIntegerObject(readStream->m_index) ||
!ObjectMemoryIsIntegerObject(readStream->m_readLimit))
return primitiveFailure(0); // Receiver fails invariant check
SMALLINTEGER index = ObjectMemoryIntegerValueOf(readStream->m_index);
SMALLINTEGER limit = ObjectMemoryIntegerValueOf(readStream->m_readLimit);
// Is the current index within the limits of the collection?
// Remember that the index is 1 based (it's a Smalltalk index), and we're 0 based,
// so we don't need to increment it until after we've got the next object
if (index < 0 || index >= limit)
return primitiveFailure(2); // No, fail it
OTE* oteBuf = readStream->m_array;
BehaviorOTE* bufClass = oteBuf->m_oteClass;
if (bufClass == Pointers.ClassString)
{
StringOTE* oteString = reinterpret_cast<StringOTE*>(oteBuf);
// A sanity check - ensure within bounds of object too (again in Blue Book spec)
if (MWORD(index) >= oteString->bytesSize())
return primitiveFailure(3);
String* buf = oteString->m_location;
stackTop() = reinterpret_cast<Oop>(Character::New(buf->m_characters[index]));
}
// We also support ByteArrays in our primitiveNext (unlike BB).
else if (bufClass == Pointers.ClassByteArray)
{
ByteArrayOTE* oteBytes = reinterpret_cast<ByteArrayOTE*>(oteBuf);
if (MWORD(index) >= oteBytes->bytesSize())
return primitiveFailure(3);
ByteArray* buf = oteBytes->m_location;
stackTop() = ObjectMemoryIntegerObjectOf(buf->m_elements[index]);
}
else if (bufClass == Pointers.ClassArray)
{
ArrayOTE* oteArray = reinterpret_cast<ArrayOTE*>(oteBuf);
if (MWORD(index) >= oteArray->pointersSize())
return primitiveFailure(3);
Array* buf = oteArray->m_location;
stackTop() = buf->m_elements[index];
}
else
return primitiveFailure(1); // Collection cannot be handled by primitive, rely on Smalltalk code
// When incrementing the index we must allow for it overflowing a SmallInteger, even though
// this is extremely unlikely in practice
readStream->m_index = Integer::NewSigned32WithRef(index+1);
return primitiveSuccess(); // Succeed
}
// Non-standard, but has very beneficial effect on performance
BOOL __fastcall Interpreter::primitiveNextPutAll()
{
Oop* sp = m_registers.m_stackPointer;
WriteStreamOTE* streamPointer = reinterpret_cast<WriteStreamOTE*>(*(sp-1)); // Access receiver under argument
WriteStream* writeStream = streamPointer->m_location;
// Ensure valid stream - checks from Blue Book
if (!ObjectMemoryIsIntegerObject(writeStream->m_index) ||
!ObjectMemoryIsIntegerObject(writeStream->m_writeLimit))
return primitiveFailure(0); // Fails invariant check
SMALLINTEGER index = ObjectMemoryIntegerValueOf(writeStream->m_index);
SMALLINTEGER limit = ObjectMemoryIntegerValueOf(writeStream->m_writeLimit);
if (index < 0)
return primitiveFailure(2);
Oop value = *(sp);
OTE* oteBuf = writeStream->m_array;
BehaviorOTE* bufClass = oteBuf->m_oteClass;
MWORD newIndex;
if (bufClass == Pointers.ClassString)
{
BehaviorOTE* oteClass = ObjectMemory::fetchClassOf(value);
if (oteClass != Pointers.ClassString && oteClass != Pointers.ClassSymbol)
return primitiveFailure(4); // Attempt to put non-string
StringOTE* oteString = reinterpret_cast<StringOTE*>(value);
String* str = oteString->m_location;
MWORD valueSize = oteString->bytesSize();
newIndex = MWORD(index)+valueSize;
if (newIndex >= static_cast<MWORD>(limit)) // Beyond write limit
return primitiveFailure(2);
if (static_cast<int>(newIndex) >= oteBuf->bytesSizeForUpdate())
return primitiveFailure(3); // Attempt to write off end of buffer
String* buf = static_cast<String*>(oteBuf->m_location);
memcpy(buf->m_characters+index, str->m_characters, valueSize);
}
else if (bufClass == Pointers.ClassByteArray)
{
if (ObjectMemory::fetchClassOf(value) != bufClass)
return primitiveFailure(4); // Attempt to put non-ByteArray
ByteArrayOTE* oteBytes = reinterpret_cast<ByteArrayOTE*>(value);
ByteArray* bytes = oteBytes->m_location;
MWORD valueSize = oteBytes->bytesSize();
newIndex = MWORD(index)+valueSize;
if (newIndex >= (MWORD)limit) // Beyond write limit
return primitiveFailure(2);
if (static_cast<int>(newIndex) >= oteBuf->bytesSizeForUpdate())
return primitiveFailure(3); // Attempt to write off end of buffer
ByteArray* buf = static_cast<ByteArray*>(oteBuf->m_location);
memcpy(buf->m_elements+index, bytes->m_elements, valueSize);
}
else if (bufClass == Pointers.ClassArray)
{
if (ObjectMemory::fetchClassOf(value) != Pointers.ClassArray)
return primitiveFailure(4); // Attempt to put non-Array
ArrayOTE* oteArray = reinterpret_cast<ArrayOTE*>(value);
Array* array = oteArray->m_location;
MWORD valueSize = oteArray->pointersSize();
newIndex = MWORD(index) + valueSize;
if (newIndex >= (MWORD)limit) // Beyond write limit
return primitiveFailure(2);
if (static_cast<int>(newIndex) >= oteBuf->pointersSizeForUpdate())
return primitiveFailure(3); // Attempt to write off end of buffer
Array* buf = static_cast<Array*>(oteBuf->m_location);
for (MWORD i = 0; i < valueSize; i++)
{
ObjectMemory::storePointerWithValue(buf->m_elements[index + i], array->m_elements[i]);
}
}
else
return primitiveFailure(1);
writeStream->m_index = Integer::NewUnsigned32WithRef(newIndex); // Increment the stream index
// As we no longer pop stack here, the receiver is still under the argument
*(sp-1) = value;
return sizeof(Oop); // Pop 4 bytes
}
// This is a double dispatched primitive which knows that the argument is a byte object (though
// we still check this to avoid GPFs), and the receiver is guaranteed to be an address object. e.g.
//
// anExternalAddress replaceBytesOf: anOtherByteObject from: start to: stop startingAt: startAt
//
BOOL __fastcall Interpreter::primitiveIndirectReplaceBytes()
{
Oop integerPointer = stackTop();
if (!ObjectMemoryIsIntegerObject(integerPointer))
return primitiveFailure(0); // startAt is not an integer
SMALLINTEGER startAt = ObjectMemoryIntegerValueOf(integerPointer);
integerPointer = stackValue(1);
if (!ObjectMemoryIsIntegerObject(integerPointer))
return primitiveFailure(1); // stop is not an integer
SMALLINTEGER stop = ObjectMemoryIntegerValueOf(integerPointer);
integerPointer = stackValue(2);
if (!ObjectMemoryIsIntegerObject(integerPointer))
return primitiveFailure(2); // start is not an integer
SMALLINTEGER start = ObjectMemoryIntegerValueOf(integerPointer);
OTE* argPointer = reinterpret_cast<OTE*>(stackValue(3));
if (ObjectMemoryIsIntegerObject(argPointer) || !argPointer->isBytes())
return primitiveFailure(3); // Argument MUST be a byte object
// Empty move if stop before start, is considered valid regardless (strange but true)
if (stop >= start)
{
if (start < 1 || startAt < 1)
return primitiveFailure(4); // out-of-bounds
AddressOTE* receiverPointer = reinterpret_cast<AddressOTE*>(stackValue(4));
// Only works for byte objects
ASSERT(receiverPointer->isBytes());
ExternalAddress* receiverBytes = receiverPointer->m_location;
#ifdef _DEBUG
{
Behavior* behavior = receiverPointer->m_oteClass->m_location;
ASSERT(behavior->isIndirect());
}
#endif
// Because the receiver is an address, we do not know the size of the object
// it points at, and so cannot perform any bounds checks - BEWARE
BYTE* pFrom = static_cast<BYTE*>(receiverBytes->m_pointer);
// We still permit the argument to be an address to cut down on the double dispatching
// required.
BYTE* pTo;
Behavior* behavior = argPointer->m_oteClass->m_location;
if (behavior->isIndirect())
{
AddressOTE* oteBytes = reinterpret_cast<AddressOTE*>(argPointer);
// Cannot check length
pTo = static_cast<BYTE*>(oteBytes->m_location->m_pointer);
}
else
{
// Can check that not writing off the end of the argument
int length = argPointer->bytesSize();
// We can only be in here if stop>=start, so => stop-start >= 0
// therefore if startAt >= 1 then => stopAt >= 1, for similar
// reasons (since stopAt >= startAt) we don't need to test
// that startAt <= length
if (stop > length)
return primitiveFailure(4); // Bounds error
VariantByteObject* argBytes = reinterpret_cast<BytesOTE*>(argPointer)->m_location;
pTo = argBytes->m_fields;
}
memmove(pTo+start-1, pFrom+startAt-1, stop-start+1);
}
// Answers the argument by moving it down over the receiver
stackValue(4) = reinterpret_cast<Oop>(argPointer);
pop(4);
return TRUE;
}
