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;
}
primitiveSingleStepInMemoryMinAddressMaxAddressReadWrite(void)
{
void *cpu;
sqInt cpuAlien;
usqIntptr_t maxAddress;
sqInt maybeErr;
char *memory;
sqInt memorySize;
usqIntptr_t minAddress;
usqIntptr_t minWriteMaxExecAddress;
success(isWordsOrBytes(stackValue(3)));
memory = ((char *) (firstIndexableField(stackValue(3))));
minAddress = (BytesPerOop == 4
? positive32BitValueOf(stackValue(2))
: positive64BitValueOf(stackValue(2)));
maxAddress = (BytesPerOop == 4
? positive32BitValueOf(stackValue(1))
: positive64BitValueOf(stackValue(1)));
minWriteMaxExecAddress = (BytesPerOop == 4
? positive32BitValueOf(stackValue(0))
: positive64BitValueOf(stackValue(0)));
cpuAlien = stackValue(4);
if (failed()) {
return null;
}
if (((cpu = ((longAt(cpuAlien + BaseHeaderSize)) > 0
? (cpuAlien + BaseHeaderSize) + BytesPerOop
: longAt((cpuAlien + BaseHeaderSize) + BytesPerOop)))) == 0) {
primitiveFailFor(PrimErrBadReceiver);
return null;
}
prevInterruptCheckChain = setInterruptCheckChain(forceStopOnInterrupt);
if (prevInterruptCheckChain == (forceStopOnInterrupt)) {
prevInterruptCheckChain == 0;
}
memorySize = byteSizeOf(((sqInt)(sqIntptr_t)(memory) - BaseHeaderSize));
maybeErr = singleStepCPUInSizeMinAddressReadWrite(cpu, memory, ((memorySize < maxAddress) ? memorySize : maxAddress), minAddress, minWriteMaxExecAddress);
setInterruptCheckChain(prevInterruptCheckChain);
if (maybeErr != 0) {
primitiveFailFor(PrimErrInappropriate);
return null;
}
if (failed()) {
return null;
}
popthenPush(5, cpuAlien);
return null;
}
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));
}
}
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);
}
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;
}
primitiveFileWrite(void)
{
// FilePlugin>>#primitiveFileWrite
sqInt array;
sqInt bytesWritten;
size_t count;
size_t elementSize;
SQFile *file;
sqInt objectPointer;
size_t startIndex;
count = positive32BitValueOf(stackValue(0));
startIndex = positive32BitValueOf(stackValue(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);
}
bytesWritten = sqFileWriteFromAt(file, count * elementSize, ((char *) (firstIndexableField(array))), (startIndex - 1) * elementSize);
if (!(failed())) {
popthenPush(5, integerObjectOf(bytesWritten / elementSize));
}
}
primitiveSingleStepInMemoryMinimumAddressReadWrite(void)
{
void *cpu;
sqInt cpuAlien;
sqInt maybeErr;
char *memory;
usqIntptr_t minAddress;
usqIntptr_t minWriteMaxExecAddress;
success(isWordsOrBytes(stackValue(2)));
memory = ((char *) (firstIndexableField(stackValue(2))));
minAddress = (BytesPerOop == 4
? positive32BitValueOf(stackValue(1))
: positive64BitValueOf(stackValue(1)));
minWriteMaxExecAddress = (BytesPerOop == 4
? positive32BitValueOf(stackValue(0))
: positive64BitValueOf(stackValue(0)));
cpuAlien = stackValue(3);
if (failed()) {
return null;
}
if (((cpu = ((longAt(cpuAlien + BaseHeaderSize)) > 0
? (cpuAlien + BaseHeaderSize) + BytesPerOop
: longAt((cpuAlien + BaseHeaderSize) + BytesPerOop)))) == 0) {
primitiveFailFor(PrimErrBadReceiver);
return null;
}
maybeErr = singleStepCPUInSizeMinAddressReadWrite(cpu, memory, byteSizeOf(((sqInt)(sqIntptr_t)(memory) - BaseHeaderSize)), minAddress, minWriteMaxExecAddress);
if (maybeErr != 0) {
primitiveFailFor(PrimErrInappropriate);
return null;
}
if (failed()) {
return null;
}
popthenPush(4, cpuAlien);
return null;
}
primitiveClearViewport(void)
{
// B3DAcceleratorPlugin>>#primitiveClearViewport
sqInt handle;
sqInt pv;
sqInt result;
sqInt rgba;
if (!((methodArgumentCount()) == 3)) {
return primitiveFail();
}
pv = positive32BitValueOf(stackValue(0));
rgba = positive32BitValueOf(stackValue(1));
handle = stackIntegerValue(2);
if (failed()) {
return null;
}
result = b3dxClearViewport(handle, rgba, pv);
if (!result) {
return primitiveFail();
}
return pop(3);
}
