primitiveSerialPortRead(void)
{
// SerialPlugin>>#primitiveSerialPortRead
char *array;
sqInt arrayPtr;
sqInt bytesRead;
sqInt count;
sqInt portNum;
sqInt startIndex;
sqInt _return_value;
portNum = stackIntegerValue(3);
success(isBytes(stackValue(2)));
array = ((char *) (firstIndexableField(stackValue(2))));
startIndex = stackIntegerValue(1);
count = stackIntegerValue(0);
if (failed()) {
return null;
}
success((startIndex >= 1)
&& (((startIndex + count) - 1) <= (byteSizeOf(((sqInt)(long)(array) - 4)))));
arrayPtr = ((((sqInt)array)) + startIndex) - 1;
bytesRead = serialPortReadInto( portNum, count, arrayPtr);
_return_value = integerObjectOf(bytesRead);
if (failed()) {
return null;
}
popthenPush(5, _return_value);
return null;
}
primitiveSoundPlaySamples(void)
{
// SoundPlugin>>#primitiveSoundPlaySamples
unsigned *buf;
sqInt frameCount;
sqInt framesPlayed;
sqInt startIndex;
sqInt _return_value;
frameCount = stackIntegerValue(2);
success(isWords(stackValue(1)));
buf = ((unsigned *) (firstIndexableField(stackValue(1))));
startIndex = stackIntegerValue(0);
if (failed()) {
return null;
}
success((startIndex >= 1)
&& (((startIndex + frameCount) - 1) <= (slotSizeOf(((sqInt)(long)(buf) - BaseHeaderSize)))));
if (!(failed())) {
framesPlayed = snd_PlaySamplesFromAtLength(frameCount, (void *)buf, startIndex - 1);
success(framesPlayed >= 0);
}
_return_value = positive32BitIntegerFor(framesPlayed);
if (failed()) {
return null;
}
popthenPush(4, _return_value);
return null;
}
primitiveSoundInsertSamples(void)
{
// SoundPlugin>>#primitiveSoundInsertSamples
unsigned *buf;
sqInt frameCount;
sqInt framesPlayed;
sqInt leadTime;
sqInt _return_value;
frameCount = stackIntegerValue(2);
success(isWords(stackValue(1)));
buf = ((unsigned *) (firstIndexableField(stackValue(1))));
leadTime = stackIntegerValue(0);
if (failed()) {
return null;
}
success(frameCount <= (slotSizeOf(((sqInt)(long)(buf) - BaseHeaderSize))));
if (!(failed())) {
framesPlayed = snd_InsertSamplesFromLeadTime(frameCount, (void *)buf, leadTime);
success(framesPlayed >= 0);
}
_return_value = positive32BitIntegerFor(framesPlayed);
if (failed()) {
return null;
}
popthenPush(4, _return_value);
return null;
}
primitiveCreateRenderer(void)
{
// B3DAcceleratorPlugin>>#primitiveCreateRenderer
sqInt allowHardware;
sqInt allowSoftware;
sqInt h;
sqInt result;
sqInt w;
sqInt x;
sqInt y;
if (!((methodArgumentCount()) == 6)) {
return primitiveFail();
}
h = stackIntegerValue(0);
w = stackIntegerValue(1);
y = stackIntegerValue(2);
x = stackIntegerValue(3);
allowHardware = booleanValueOf(stackValue(4));
allowSoftware = booleanValueOf(stackValue(5));
if (failed()) {
return null;
}
result = b3dxCreateRenderer(allowSoftware, allowHardware, x, y, w, h);
if (result < 0) {
return primitiveFail();
}
pop(7);
return pushInteger(result);
}
primitiveSerialPortWrite(void)
{
char *array;
char * arrayPtr;
sqInt bytesWritten;
sqInt count;
sqInt portNum;
sqInt startIndex;
sqInt _return_value;
bytesWritten = 0;
portNum = stackIntegerValue(3);
success(isBytes(stackValue(2)));
array = ((char *) (firstIndexableField(stackValue(2))));
startIndex = stackIntegerValue(1);
count = stackIntegerValue(0);
if (failed()) {
return null;
}
success((startIndex >= 1)
&& (((startIndex + count) - 1) <= (byteSizeOf(((sqInt)(sqIntptr_t)(array) - BaseHeaderSize)))));
if (!(failed())) {
arrayPtr = (array + startIndex) - 1;
bytesWritten = serialPortWriteFrom(portNum, count, arrayPtr);
}
if (failed()) {
return null;
}
_return_value = integerObjectOf(bytesWritten);
popthenPush(5, _return_value);
return null;
}
primitiveAtPut(void)
{
float *floatPtr;
double floatValue;
sqInt index;
sqInt rcvr;
sqInt value;
value = stackValue(0);
if (isIntegerObject(value)) {
floatValue = ((double) (integerValueOf(value)) );
}
else {
floatValue = floatValueOf(value);
}
index = stackIntegerValue(1);
rcvr = stackValue(2);
if (!((!(failed()))
&& ((isWords(rcvr))
&& ((index > 0)
&& (index <= (slotSizeOf(rcvr))))))) {
return primitiveFail();
}
floatPtr = firstIndexableField(rcvr);
floatPtr[index - 1] = (((float) floatValue));
popthenPush(3, value);
return 0;
}
primitiveFileCopyNamedTo(void)
{
// FileCopyPlugin>>#primitiveFileCopyNamedTo
char *dstName;
sqInt dstSz;
sqInt ok;
char *srcName;
sqInt srcSz;
success(isBytes(stackValue(1)));
srcName = ((char *) (firstIndexableField(stackValue(1))));
success(isBytes(stackValue(0)));
dstName = ((char *) (firstIndexableField(stackValue(0))));
if (failed()) {
return null;
}
srcSz = slotSizeOf(((sqInt)(long)(srcName) - 4));
dstSz = slotSizeOf(((sqInt)(long)(dstName) - 4));
ok = sqCopyFilesizetosize(srcName, srcSz, dstName, dstSz);
if (!ok) {
primitiveFail();
}
if (failed()) {
return null;
}
pop(2);
return null;
}
primitiveFlushICacheFromTo(void)
{
void *cpu;
sqInt cpuAlien;
usqIntptr_t endAddress;
usqIntptr_t startAddress;
startAddress = (BytesPerOop == 4
? positive32BitValueOf(stackValue(1))
: positive64BitValueOf(stackValue(1)));
endAddress = (BytesPerOop == 4
? positive32BitValueOf(stackValue(0))
: positive64BitValueOf(stackValue(0)));
cpuAlien = stackValue(2);
if (failed()) {
return null;
}
if (((cpu = ((longAt(cpuAlien + BaseHeaderSize)) > 0
? (cpuAlien + BaseHeaderSize) + BytesPerOop
: longAt((cpuAlien + BaseHeaderSize) + BytesPerOop)))) == 0) {
primitiveFailFor(PrimErrBadReceiver);
return null;
}
flushICacheFromTo(cpu, startAddress, endAddress);
if (failed()) {
return null;
}
pop(2);
return null;
}
primitiveGetStringKeyedBy(void)
{
char *aKey;
char aString[1025];
sqInt i;
sqInt keyLength;
sqInt oop;
char *ptr;
sqInt size;
success(isBytes(stackValue(0)));
aKey = ((char *) (firstIndexableField(stackValue(0))));
if (failed()) {
return null;
}
keyLength = byteSizeOf(((sqInt)(sqIntptr_t)(aKey) - BaseHeaderSize));
size = sqInternetConfigurationGetStringKeyedBykeySizeinto(aKey, keyLength, aString);
oop = instantiateClassindexableSize(classString(), size);
ptr = firstIndexableField(oop);
for (i = 0; i < size; i += 1) {
ptr[i] = (aString[i]);
}
if (failed()) {
return null;
}
popthenPush(2, oop);
return null;
}
primitiveEqual(void)
{
sqInt arg;
float *argPtr;
sqInt i;
sqInt length;
sqInt rcvr;
float *rcvrPtr;
arg = stackValue(0);
rcvr = stackValue(1);
if (!((isWords(arg))
&& (isWords(rcvr)))) {
return primitiveFail();
}
pop(2);
if (!(((length = stSizeOf(arg))) == (stSizeOf(rcvr)))) {
return pushBool(0);
}
rcvrPtr = ((float *) (firstIndexableField(rcvr)));
argPtr = ((float *) (firstIndexableField(arg)));
for (i = 0; i < length; i += 1) {
if (!((rcvrPtr[i]) == (argPtr[i]))) {
return pushBool(0);
}
}
return pushBool(1);
}
primitiveSetFog(void)
{
// B3DAcceleratorPlugin>>#primitiveSetFog
double density;
sqInt fogType;
sqInt handle;
sqInt result;
sqInt rgba;
double start;
double stop;
if (!((methodArgumentCount()) == 6)) {
return primitiveFail();
}
rgba = positive32BitValueOf(stackValue(0));
stop = floatValueOf(stackValue(1));
start = floatValueOf(stackValue(2));
density = floatValueOf(stackValue(3));
fogType = stackIntegerValue(4);
handle = stackIntegerValue(5);
if (failed()) {
return null;
}
result = b3dxSetFog(handle, fogType, density, start, stop, rgba);
if (!result) {
return primitiveFail();
}
return pop(6);
}
primitiveFileTruncate(void)
{
// FilePlugin>>#primitiveFileTruncate
SQFile *file;
sqInt objectPointer;
sqInt sz;
squeakFileOffsetType truncatePosition;
if (!(isIntegerObject(stackValue(0)))) {
sz = sizeof(squeakFileOffsetType);
if ((byteSizeOf(stackValue(0))) > sz) {
return primitiveFail();
}
}
truncatePosition = positive64BitValueOf(stackValue(0));
/* begin fileValueOf: */
objectPointer = stackValue(1);
if (!((isBytes(objectPointer))
&& ((byteSizeOf(objectPointer)) == (sizeof(SQFile))))) {
primitiveFail();
file = null;
goto l1;
}
file = firstIndexableField(objectPointer);
l1: /* end fileValueOf: */;
if (!(failed())) {
sqFileTruncate(file, truncatePosition);
}
if (!(failed())) {
pop(2);
}
}
primitiveDotProduct(void)
{
sqInt arg;
float *argPtr;
sqInt i;
sqInt length;
sqInt rcvr;
float *rcvrPtr;
double result;
arg = stackValue(0);
rcvr = stackValue(1);
if (!((isWords(arg))
&& ((isWords(rcvr))
&& (((length = stSizeOf(arg))) == (stSizeOf(rcvr)))))) {
return primitiveFail();
}
rcvrPtr = ((float *) (firstIndexableField(rcvr)));
argPtr = ((float *) (firstIndexableField(arg)));
result = 0.0;
for (i = 0; i < length; i += 1) {
result += (((double) (rcvrPtr[i]))) * (((double) (argPtr[i])));
}
pop(2);
pushFloat(result);
return 0;
}
primitiveDivFloatArray(void)
{
sqInt arg;
float *argPtr;
sqInt i;
sqInt length;
sqInt rcvr;
float *rcvrPtr;
arg = stackValue(0);
rcvr = stackValue(1);
if (!((isWords(arg))
&& ((isWords(rcvr))
&& (((length = stSizeOf(arg))) == (stSizeOf(rcvr)))))) {
return primitiveFail();
}
rcvrPtr = ((float *) (firstIndexableField(rcvr)));
/* Check if any of the argument's values is zero */
argPtr = ((float *) (firstIndexableField(arg)));
for (i = 0; i < length; i += 1) {
if ((intAtPointer(((char*) (argPtr + i)))) == 0) {
return primitiveFail();
}
}
for (i = 0; i < length; i += 1) {
rcvrPtr[i] = ((((double) (rcvrPtr[i]))) / (((double) (argPtr[i]))));
}
pop(1);
return 0;
}
primitiveGetMacintoshFileTypeAndCreatorFrom(void)
{
char *aFileName;
char creator[8];
sqInt i;
sqInt keyLength;
sqInt oop;
char *ptr;
success(isBytes(stackValue(0)));
aFileName = ((char *) (firstIndexableField(stackValue(0))));
if (failed()) {
return null;
}
keyLength = byteSizeOf(((sqInt)(sqIntptr_t)(aFileName) - BaseHeaderSize));
sqInternetGetMacintoshFileTypeAndCreatorFromkeySizeinto(aFileName, keyLength, creator);
oop = instantiateClassindexableSize(classString(), 8);
ptr = firstIndexableField(oop);
for (i = 0; i <= 7; i += 1) {
ptr[i] = (creator[i]);
}
if (failed()) {
return null;
}
popthenPush(2, oop);
return null;
}
primitiveDisassembleAtInMemory(void)
{
usqIntptr_t address;
void *cpu;
sqInt cpuAlien;
sqInt instrLenOrErr;
sqInt log;
sqInt logLen;
sqInt logObj;
sqInt logObjData;
char *memory;
sqInt resultObj;
logLen = 0;
address = (BytesPerOop == 4
? positive32BitValueOf(stackValue(1))
: positive64BitValueOf(stackValue(1)));
success(isWordsOrBytes(stackValue(0)));
memory = ((char *) (firstIndexableField(stackValue(0))));
cpuAlien = stackValue(2);
if (failed()) {
return null;
}
if (((cpu = ((longAt(cpuAlien + BaseHeaderSize)) > 0
? (cpuAlien + BaseHeaderSize) + BytesPerOop
: longAt((cpuAlien + BaseHeaderSize) + BytesPerOop)))) == 0) {
primitiveFailFor(PrimErrBadReceiver);
return null;
}
instrLenOrErr = disassembleForAtInSize(cpu, address, memory, byteSizeOf(((sqInt)(sqIntptr_t)(memory) - BaseHeaderSize)));
if (instrLenOrErr < 0) {
primitiveFailFor(PrimErrInappropriate);
return null;
}
log = getlog((&logLen));
resultObj = instantiateClassindexableSize(classArray(), 2);
if (resultObj == 0) {
primitiveFailFor(PrimErrNoMemory);
return null;
}
pushRemappableOop(resultObj);
logObj = instantiateClassindexableSize(classString(), logLen);
if (failed()) {
popRemappableOop();
primitiveFailFor(PrimErrNoMemory);
return null;
}
logObjData = arrayValueOf(logObj);
memcpy(logObjData, log, logLen);
resultObj = popRemappableOop();
storePointerofObjectwithValue(0, resultObj, integerObjectOf(instrLenOrErr));
storePointerofObjectwithValue(1, resultObj, logObj);
if (failed()) {
return null;
}
popthenPush(3, resultObj);
return null;
}
primitiveAsyncFileWriteStart(void)
{
// AsynchFilePlugin>>#primitiveAsyncFileWriteStart
sqInt buffer;
sqInt bufferPtr;
sqInt bufferSize;
sqInt count;
AsyncFile *f;
sqInt fHandle;
sqInt fPosition;
sqInt num;
sqInt start;
sqInt startIndex;
fHandle = stackValue(4);
fPosition = stackIntegerValue(3);
buffer = stackValue(2);
start = stackIntegerValue(1);
num = stackIntegerValue(0);
if (failed()) {
return null;
}
f = asyncFileValueOf(fHandle);
if (failed()) {
return null;
}
count = num;
startIndex = start;
/* in bytes or words */
bufferSize = slotSizeOf(buffer);
if (isWords(buffer)) {
/* covert word counts to byte counts */
/* covert word counts to byte counts */
count = count * 4;
startIndex = ((startIndex - 1) * 4) + 1;
bufferSize = bufferSize * 4;
}
success((startIndex >= 1)
&& (((startIndex + count) - 1) <= bufferSize));
/* adjust for zero-origin indexing */
bufferPtr = ((((int) (firstIndexableField(buffer)))) + startIndex) - 1;
if (!(failed())) {
asyncFileWriteStart(f, fPosition, bufferPtr, count);
}
if (failed()) {
return null;
}
pop(5);
return null;
}
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);
}
}
primitiveAsyncFileReadResult(void)
{
// AsynchFilePlugin>>#primitiveAsyncFileReadResult
sqInt buffer;
sqInt bufferPtr;
sqInt bufferSize;
sqInt count;
AsyncFile *f;
sqInt fhandle;
sqInt num;
sqInt r;
sqInt start;
sqInt startIndex;
sqInt _return_value;
fhandle = stackValue(3);
buffer = stackValue(2);
start = stackIntegerValue(1);
num = stackIntegerValue(0);
if (failed()) {
return null;
}
f = asyncFileValueOf(fhandle);
count = num;
startIndex = start;
/* in bytes or words */
bufferSize = slotSizeOf(buffer);
if (isWords(buffer)) {
/* covert word counts to byte counts */
/* covert word counts to byte counts */
count = count * 4;
startIndex = ((startIndex - 1) * 4) + 1;
bufferSize = bufferSize * 4;
}
success((startIndex >= 1)
&& (((startIndex + count) - 1) <= bufferSize));
/* adjust for zero-origin indexing */
bufferPtr = ((((int) (firstIndexableField(buffer)))) + startIndex) - 1;
if (!(failed())) {
r = asyncFileReadResult(f, bufferPtr, count);
}
_return_value = integerObjectOf(r);
if (failed()) {
return null;
}
popthenPush(5, _return_value);
return null;
}
// 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();
}
primitiveFileRead(void)
{
// FilePlugin>>#primitiveFileRead
sqInt array;
sqInt bytesRead;
size_t count;
size_t elementSize;
SQFile *file;
sqInt objectPointer;
sqInt retryCount;
size_t startIndex;
retryCount = 0;
count = positive32BitValueOf(stackValue(0));
startIndex = positive32BitValueOf(stackValue(1));
while (1) {
array = stackValue(2);
/* begin fileValueOf: */
objectPointer = stackValue(3);
if (!((isBytes(objectPointer))
&& ((byteSizeOf(objectPointer)) == (sizeof(SQFile))))) {
primitiveFail();
file = null;
goto l1;
}
file = firstIndexableField(objectPointer);
l1: /* end fileValueOf: */;
if ((failed())
|| (!(isWordsOrBytes(array)))) {
return primitiveFailFor(PrimErrBadArgument);
}
elementSize = (isWords(array)
? 4
: 1);
if (!((startIndex >= 1)
&& (((startIndex + count) - 1) <= (slotSizeOf(array))))) {
return primitiveFailFor(PrimErrBadIndex);
}
bytesRead = sqFileReadIntoAt(file, count * elementSize, ((char *) (firstIndexableField(array))), (startIndex - 1) * elementSize);
if (!(((primitiveFailureCode()) == PrimErrObjectMayMove)
&& (((retryCount += 1)) <= 2))) break;
tenuringIncrementalGC();
primitiveFailFor(PrimNoErr);
}
if (!(failed())) {
popthenPush(5, integerObjectOf(bytesRead / elementSize));
}
}
primitiveSetIntProperty(void)
{
sqInt handle;
sqInt propID;
sqInt result;
sqInt value;
if (!((methodArgumentCount()) == 3)) {
return primitiveFail();
}
value = signed32BitValueOf(stackValue(0));
propID = stackIntegerValue(1);
handle = stackIntegerValue(2);
if (failed()) {
return null;
}
result = sqSetIntPropertySSL(handle, propID, value);
if (!result) {
return primitiveFail();
}
if (failed()) {
return null;
}
pop(methodArgumentCount());
return 0;
}
primitiveOSFileHandle(void)
{
sqInt fileNo;
sqInt sqFileOop;
sqFileOop = stackValue(0);
if (!((((isBytes(sqFileOop))
&& ((byteSizeOf(sqFileOop)) == (sizeof(SQFile))))
&& ((getThisSessionID()) == (sessionIdentifierFromSqFile(arrayValueOf(sqFileOop)))))
&& (isNonNullSQFile(sqFileOop)))) {
return primitiveFail();
}
/* begin fileDescriptorFrom: */
if (!((((isBytes(sqFileOop))
&& ((byteSizeOf(sqFileOop)) == (sizeof(SQFile))))
&& ((getThisSessionID()) == (sessionIdentifierFromSqFile(arrayValueOf(sqFileOop)))))
&& (isNonNullSQFile(sqFileOop)))) {
fileNo = -1;
goto l1;
}
fileNo = fileno(fileHandleFrom(sqFileOop));
l1: /* end fileDescriptorFrom: */;
pop(2);
pushInteger(fileNo);
return 0;
}
primitiveAioSuspend(void)
{
sqInt exceptionWatch;
sqInt fd;
sqInt flags;
sqInt readWatch;
sqInt writeWatch;
if ((nilObject()) == (stackValue(3))) {
return primitiveFail();
}
fd = stackIntegerValue(3);
if (fd < 0) {
return primitiveFail();
}
exceptionWatch = stackObjectValue(2);
readWatch = stackObjectValue(1);
writeWatch = stackObjectValue(0);
flags = 0;
if (exceptionWatch == (trueObject())) {
flags = flags | (AIO_X);
}
if (readWatch == (trueObject())) {
flags = flags | (AIO_R);
}
if (writeWatch == (trueObject())) {
flags = flags | (AIO_W);
}
aioSuspend(fd, flags);
pop(5);
pushInteger(flags);
return 0;
}
primitiveAioEnable(void)
{
static int eventSemaphoreIndices[FD_SETSIZE];
sqInt externalObject;
sqInt fd;
sqInt flags;
sqInt semaIndex;
if ((nilObject()) == (stackValue(2))) {
return primitiveFail();
}
fd = stackIntegerValue(2);
if (fd < 0) {
return primitiveFail();
}
semaIndex = stackIntegerValue(1);
eventSemaphoreIndices[semaIndex] = semaIndex;
externalObject = stackObjectValue(0);
if (externalObject == (trueObject())) {
flags = AIO_EXT;
}
else {
flags = 0;
}
aioEnable(fd, &(eventSemaphoreIndices[semaIndex]), flags);
pop(4);
pushInteger(semaIndex);
return 0;
}
primitiveFileDelete(void)
{
// FilePlugin>>#primitiveFileDelete
char *nameIndex;
sqInt namePointer;
sqInt nameSize;
sqInt okToDelete;
namePointer = stackValue(0);
if (!(isBytes(namePointer))) {
return primitiveFail();
}
nameIndex = firstIndexableField(namePointer);
/* If the security plugin can be loaded, use it to check for permission.
If not, assume it's ok */
nameSize = byteSizeOf(namePointer);
if (sCDFfn != 0) {
okToDelete = ((sqInt (*)(char *, sqInt))sCDFfn)(nameIndex, nameSize);
if (!okToDelete) {
return primitiveFail();
}
}
sqFileDeleteNameSize(nameIndex, nameSize);
if (!(failed())) {
pop(1);
}
}
primitiveFileAtEnd(void)
{
// FilePlugin>>#primitiveFileAtEnd
sqInt atEnd;
SQFile *file;
sqInt objectPointer;
/* begin fileValueOf: */
objectPointer = stackValue(0);
if (!((isBytes(objectPointer))
&& ((byteSizeOf(objectPointer)) == (sizeof(SQFile))))) {
primitiveFail();
file = null;
goto l1;
}
file = firstIndexableField(objectPointer);
l1: /* end fileValueOf: */;
if (!(failed())) {
atEnd = sqFileAtEnd(file);
}
if (!(failed())) {
pop(2);
pushBool(atEnd);
}
}
primitiveDirectoryDelete(void)
{
// FilePlugin>>#primitiveDirectoryDelete
sqInt dirName;
char *dirNameIndex;
sqInt dirNameSize;
sqInt okToDelete;
dirName = stackValue(0);
if (!(isBytes(dirName))) {
return primitiveFail();
}
dirNameIndex = firstIndexableField(dirName);
/* If the security plugin can be loaded, use it to check for permission.
If not, assume it's ok */
dirNameSize = byteSizeOf(dirName);
if (sCDPfn != 0) {
okToDelete = ((sqInt (*)(char *, sqInt))sCDPfn)(dirNameIndex, dirNameSize);
if (!okToDelete) {
return primitiveFail();
}
}
if (!(dir_Delete(dirNameIndex, dirNameSize))) {
return primitiveFail();
}
pop(1);
}
primitiveNormalize(void)
{
sqInt i;
double len;
sqInt length;
sqInt rcvr;
float *rcvrPtr;
rcvr = stackValue(0);
if (!(isWords(rcvr))) {
primitiveFailFor(PrimErrBadReceiver);
}
length = stSizeOf(rcvr);
rcvrPtr = ((float *) (firstIndexableField(rcvr)));
len = 0.0;
for (i = 0; i < length; i += 1) {
len += (((double) (rcvrPtr[i]))) * (((double) (rcvrPtr[i])));
}
if (!(len > 0.0)) {
primitiveFailFor(PrimErrBadReceiver);
}
len = sqrt(len);
for (i = 0; i < length; i += 1) {
rcvrPtr[i] = ((((double) (rcvrPtr[i]))) / len);
}
return 0;
}
primitiveResetCPU(void)
{
void *cpu;
sqInt cpuAlien;
sqInt maybeErr;
cpuAlien = stackValue(0);
if (failed()) {
return null;
}
if (((cpu = ((longAt(cpuAlien + BaseHeaderSize)) > 0
? (cpuAlien + BaseHeaderSize) + BytesPerOop
: longAt((cpuAlien + BaseHeaderSize) + BytesPerOop)))) == 0) {
primitiveFailFor(PrimErrBadReceiver);
return null;
}
maybeErr = resetCPU(cpu);
if (maybeErr != 0) {
primitiveFailFor(PrimErrInappropriate);
return null;
}
if (failed()) {
return null;
}
popthenPush(1, cpuAlien);
return null;
}
