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;
}
primitiveEqual(void)
{
// FloatArrayPlugin>>#primitiveEqual
sqInt arg;
float *argPtr;
sqInt i;
sqInt length;
sqInt rcvr;
float *rcvrPtr;
arg = stackObjectValue(0);
rcvr = stackObjectValue(1);
if (failed()) {
return null;
}
success(isWords(arg));
success(isWords(rcvr));
if (failed()) {
return null;
}
pop(2);
length = stSizeOf(arg);
if (!(length == (stSizeOf(rcvr)))) {
return pushBool(0);
}
rcvrPtr = ((float *) (firstIndexableField(rcvr)));
argPtr = ((float *) (firstIndexableField(arg)));
for (i = 0; i <= (length - 1); i += 1) {
if (!((rcvrPtr[i]) == (argPtr[i]))) {
return pushBool(0);
}
}
return pushBool(1);
}
primitiveDotProduct(void)
{
// FloatArrayPlugin>>#primitiveDotProduct
sqInt arg;
float *argPtr;
sqInt i;
sqInt length;
sqInt rcvr;
float *rcvrPtr;
double result;
arg = stackObjectValue(0);
rcvr = stackObjectValue(1);
if (failed()) {
return null;
}
success(isWords(arg));
success(isWords(rcvr));
if (failed()) {
return null;
}
length = stSizeOf(arg);
success(length == (stSizeOf(rcvr)));
if (failed()) {
return null;
}
rcvrPtr = ((float *) (firstIndexableField(rcvr)));
argPtr = ((float *) (firstIndexableField(arg)));
result = 0.0;
for (i = 0; i <= (length - 1); i += 1) {
result += (((double) (rcvrPtr[i]))) * (((double) (argPtr[i])));
}
pop(2);
pushFloat(result);
}
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);
}
primitiveSubFloatArray(void)
{
// FloatArrayPlugin>>#primitiveSubFloatArray
sqInt arg;
float *argPtr;
sqInt i;
sqInt length;
sqInt rcvr;
float *rcvrPtr;
arg = stackObjectValue(0);
rcvr = stackObjectValue(1);
if (failed()) {
return null;
}
success(isWords(arg));
success(isWords(rcvr));
if (failed()) {
return null;
}
length = stSizeOf(arg);
success(length == (stSizeOf(rcvr)));
if (failed()) {
return null;
}
rcvrPtr = ((float *) (firstIndexableField(rcvr)));
argPtr = ((float *) (firstIndexableField(arg)));
for (i = 0; i <= (length - 1); i += 1) {
rcvrPtr[i] = ((((double) (rcvrPtr[i]))) - (((double) (argPtr[i]))));
}
pop(1);
}
// _____________________________________________________________________________
void QueryPlanner::getVarTripleMap(
const ParsedQuery& pq,
unordered_map<string, vector<SparqlTriple>>& varToTrip,
unordered_set<string>& contextVars) const {
for (auto& t: pq._whereClauseTriples) {
if (isVariable(t._s)) {
varToTrip[t._s].push_back(t);
}
if (isVariable(t._p)) {
varToTrip[t._p].push_back(t);
}
if (isVariable(t._o)) {
varToTrip[t._o].push_back(t);
}
if (t._p == IN_CONTEXT_RELATION) {
if (isVariable(t._s) || isWords(t._o)) {
contextVars.insert(t._s);
}
if (isVariable(t._o) || isWords(t._s)) {
contextVars.insert(t._o);
}
}
}
}
static sqInt
loadClientStateverticescolorsnormalstexCoords(sqInt handle, sqInt vertices, sqInt colors, sqInt normals, sqInt texCoords)
{
// B3DAcceleratorPlugin>>#loadClientState:vertices:colors:normals:texCoords:
void *colorPtr;
void *normalPtr;
sqInt ok;
sqInt sz;
void *txPtr;
void *vertexPtr;
sqInt vtxSize;
/* Verify vertex data */
colorPtr = (normalPtr = (txPtr = (vertexPtr = null)));
if (!(isWords(vertices))) {
return primitiveFail();
}
/* Verify assumptions of color, normal, texCoords data */
vtxSize = (slotSizeOf(vertices)) / 3;
if (!((colors == (nilObject()))
|| ((isWords(colors))
&& ((slotSizeOf(colors)) == (vtxSize * 4))))) {
return primitiveFail();
}
if (!((normals == (nilObject()))
|| ((isWords(normals))
&& ((slotSizeOf(normals)) == (vtxSize * 3))))) {
return primitiveFail();
}
if (!((texCoords == (nilObject()))
|| (isWords(texCoords)))) {
return primitiveFail();
}
if (!(colors == (nilObject()))) {
colorPtr = firstIndexableField(colors);
}
if (!(normals == (nilObject()))) {
normalPtr = firstIndexableField(normals);
}
if (!(texCoords == (nilObject()))) {
sz = (slotSizeOf(texCoords)) / vtxSize;
txPtr = firstIndexableField(texCoords);
}
vertexPtr = firstIndexableField(vertices);
if (failed()) {
return null;
}
ok = b3dLoadClientState(handle, vertexPtr, 3, colorPtr, 4, normalPtr, 3, txPtr, sz);
if (!ok) {
return primitiveFail();
}
}
/* FFTPlugin>>#loadFFTFrom: */
static sqInt
loadFFTFrom(sqInt fftOop)
{
sqInt oop;
success((slotSizeOf(fftOop)) >= 6);
if (failed()) {
return 0;
}
nu = fetchIntegerofObject(0, fftOop);
fftSize = fetchIntegerofObject(1, fftOop);
oop = fetchPointerofObject(2, fftOop);
sinTableSize = stSizeOf(oop);
/* begin checkedFloatPtrOf: */
success(isWords(oop));
if (failed()) {
sinTable = 0;
goto l1;
}
sinTable = ((float *) (firstIndexableField(oop)));
l1: /* end checkedFloatPtrOf: */;
oop = fetchPointerofObject(3, fftOop);
permTableSize = stSizeOf(oop);
/* begin checkedWordPtrOf: */
success(isWords(oop));
permTable = ((unsigned int *) (firstIndexableField(oop)));
oop = fetchPointerofObject(4, fftOop);
realDataSize = stSizeOf(oop);
/* begin checkedFloatPtrOf: */
success(isWords(oop));
if (failed()) {
realData = 0;
goto l3;
}
realData = ((float *) (firstIndexableField(oop)));
l3: /* end checkedFloatPtrOf: */;
oop = fetchPointerofObject(5, fftOop);
imagDataSize = stSizeOf(oop);
/* begin checkedFloatPtrOf: */
success(isWords(oop));
if (failed()) {
imagData = 0;
goto l4;
}
imagData = ((float *) (firstIndexableField(oop)));
l4: /* end checkedFloatPtrOf: */;
success((((((1L << nu) == fftSize) && (((fftSize / 4) + 1) == sinTableSize)) && (fftSize == realDataSize)) && (fftSize == imagDataSize)) && (realDataSize == imagDataSize));
return (failed()) == 0;
}
primitiveSum(void)
{
// FloatArrayPlugin>>#primitiveSum
sqInt i;
sqInt length;
sqInt rcvr;
float *rcvrPtr;
double sum;
rcvr = stackObjectValue(0);
if (failed()) {
return null;
}
success(isWords(rcvr));
if (failed()) {
return null;
}
length = stSizeOf(rcvr);
rcvrPtr = ((float *) (firstIndexableField(rcvr)));
sum = 0.0;
for (i = 0; i <= (length - 1); i += 1) {
sum += ((double) (rcvrPtr[i]));
}
popthenPush(1, floatObjectOf(sum));
}
primitiveNormalize(void)
{
// FloatArrayPlugin>>#primitiveNormalize
sqInt i;
double len;
sqInt length;
sqInt rcvr;
float *rcvrPtr;
rcvr = stackObjectValue(0);
if (failed()) {
return null;
}
success(isWords(rcvr));
if (failed()) {
return null;
}
length = stSizeOf(rcvr);
success(1);
rcvrPtr = ((float *) (firstIndexableField(rcvr)));
len = 0.0;
for (i = 0; i <= (length - 1); i += 1) {
len += (((double) (rcvrPtr[i]))) * (((double) (rcvrPtr[i])));
}
success(len > 0.0);
if (failed()) {
return null;
}
len = sqrt(len);
for (i = 0; i <= (length - 1); i += 1) {
rcvrPtr[i] = ((((double) (rcvrPtr[i]))) / len);
}
}
primitiveDivScalar(void)
{
sqInt i;
double inverse;
sqInt length;
sqInt rcvr;
float *rcvrPtr;
double value;
value = stackFloatValue(0);
if (failed()) {
return null;
}
rcvr = stackValue(1);
if (!(isWords(rcvr))) {
return primitiveFail();
}
length = stSizeOf(rcvr);
rcvrPtr = ((float *) (firstIndexableField(rcvr)));
inverse = 1.0 / value;
for (i = 0; i < length; i += 1) {
rcvrPtr[i] = ((((double) (rcvrPtr[i]))) * inverse);
}
pop(1);
return 0;
}
primitiveHashArray(void)
{
// FloatArrayPlugin>>#primitiveHashArray
sqInt i;
sqInt length;
sqInt rcvr;
int *rcvrPtr;
sqInt result;
rcvr = stackObjectValue(0);
if (failed()) {
return null;
}
success(isWords(rcvr));
if (failed()) {
return null;
}
length = stSizeOf(rcvr);
rcvrPtr = ((int *) (firstIndexableField(rcvr)));
result = 0;
for (i = 0; i <= (length - 1); i += 1) {
result += rcvrPtr[i];
}
pop(1);
return pushInteger(result & 536870911);
}
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;
}
primitiveLength(void)
{
// FloatArrayPlugin>>#primitiveLength
sqInt i;
sqInt length;
sqInt rcvr;
float *rcvrPtr;
double result;
rcvr = stackObjectValue(0);
if (failed()) {
return null;
}
success(isWords(rcvr));
if (failed()) {
return null;
}
length = stSizeOf(rcvr);
success(1);
rcvrPtr = ((float *) (firstIndexableField(rcvr)));
result = 0.0;
for (i = 0; i <= (length - 1); i += 1) {
result += (((double) (rcvrPtr[i]))) * (((double) (rcvrPtr[i])));
}
result = sqrt(result);
popthenPush(1, floatObjectOf(result));
}
primitiveIsPureTranslation(void)
{
float *matrix;
sqInt matrix1;
/* begin loadArgumentMatrix: */
matrix1 = stackObjectValue(0);
if (failed()) {
matrix = null;
goto l1;
}
if (!((isWords(matrix1))
&& ((slotSizeOf(matrix1)) == 6))) {
primitiveFail();
matrix = null;
goto l1;
}
matrix = ((float *) (firstIndexableField(matrix1)));
l1: /* end loadArgumentMatrix: */;
if (failed()) {
return null;
}
pop(1);
pushBool(((((matrix[0]) == (((float) 1.0))) && ((matrix[1]) == (((float) 0.0)))) && ((matrix[3]) == (((float) 0.0)))) && ((matrix[4]) == (((float) 1.0))));
return 0;
}
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;
}
primitiveSubScalar(void)
{
// FloatArrayPlugin>>#primitiveSubScalar
sqInt i;
sqInt length;
sqInt rcvr;
float *rcvrPtr;
double value;
value = stackFloatValue(0);
rcvr = stackObjectValue(1);
if (failed()) {
return null;
}
success(isWords(rcvr));
if (failed()) {
return null;
}
length = stSizeOf(rcvr);
rcvrPtr = ((float *) (firstIndexableField(rcvr)));
for (i = 0; i <= (length - 1); i += 1) {
rcvrPtr[i] = ((((double) (rcvrPtr[i]))) - value);
}
pop(1);
}
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;
}
primitiveAtPut(void)
{
// FloatArrayPlugin>>#primitiveAtPut
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 = stackObjectValue(2);
if (failed()) {
return null;
}
success(isWords(rcvr));
success((index > 0)
&& (index <= (slotSizeOf(rcvr))));
if (failed()) {
return null;
}
floatPtr = firstIndexableField(rcvr);
floatPtr[index - 1] = (((float) floatValue));
if (!(failed())) {
popthenPush(3, value);
}
}
static void*
stackPrimitiveIndexArrayofSizevalidateforVertexSize(sqInt stackIndex, sqInt nItems, sqInt aBool, sqInt maxIndex)
{
// B3DAcceleratorPlugin>>#stackPrimitiveIndexArray:ofSize:validate:forVertexSize:
sqInt i;
int *idxPtr;
sqInt index;
sqInt oop;
sqInt oopSize;
oop = stackObjectValue(stackIndex);
if (oop == null) {
return null;
}
if (!(isWords(oop))) {
return null;
}
oopSize = slotSizeOf(oop);
if (oopSize < nItems) {
return null;
}
idxPtr = ((int *) (firstIndexableField(oop)));
if (aBool) {
for (i = 0; i <= (nItems - 1); i += 1) {
index = idxPtr[i];
if ((index < 0)
|| (index > maxIndex)) {
return null;
}
}
}
return idxPtr;
}
static sqInt
stackLightArrayValue(sqInt stackIndex)
{
// B3DAcceleratorPlugin>>#stackLightArrayValue:
sqInt array;
sqInt arraySize;
sqInt i;
sqInt oop;
array = stackObjectValue(stackIndex);
if (array == null) {
return null;
}
if (array == (nilObject())) {
return null;
}
if (!((fetchClassOf(array)) == (classArray()))) {
return primitiveFail();
}
arraySize = slotSizeOf(array);
for (i = 0; i <= (arraySize - 1); i += 1) {
oop = fetchPointerofObject(i, array);
if (isIntegerObject(oop)) {
return primitiveFail();
}
if (!((isWords(oop))
&& ((slotSizeOf(oop)) == 32))) {
return primitiveFail();
}
}
return array;
}
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;
}
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;
}
/* FFTPlugin>>#checkedFloatPtrOf: */
static float *
checkedFloatPtrOf(sqInt oop)
{
success(isWords(oop));
if (failed()) {
return 0;
}
return ((float *) (firstIndexableField(oop)));
}
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;
}
primitiveDivFloatArray(void)
{
// FloatArrayPlugin>>#primitiveDivFloatArray
sqInt arg;
float *argPtr;
sqInt i;
sqInt length;
sqInt rcvr;
float *rcvrPtr;
arg = stackObjectValue(0);
rcvr = stackObjectValue(1);
if (failed()) {
return null;
}
success(isWords(arg));
success(isWords(rcvr));
if (failed()) {
return null;
}
length = stSizeOf(arg);
success(length == (stSizeOf(rcvr)));
if (failed()) {
return null;
}
rcvrPtr = ((float *) (firstIndexableField(rcvr)));
/* Check if any of the argument's values is zero */
argPtr = ((float *) (firstIndexableField(arg)));
for (i = 0; i <= (length - 1); i += 1) {
if ((intAtPointer(((char*) (argPtr + i)))) == 0) {
return primitiveFail();
}
}
for (i = 0; i <= (length - 1); i += 1) {
rcvrPtr[i] = ((((double) (rcvrPtr[i]))) / (((double) (argPtr[i]))));
}
pop(1);
}
/* Matrix2x3Plugin>>#loadArgumentMatrix: */
static float *
loadArgumentMatrix(sqInt matrix)
{
if (failed()) {
return null;
}
if (!((isWords(matrix))
&& ((slotSizeOf(matrix)) == 6))) {
primitiveFail();
return null;
}
return ((float *) (firstIndexableField(matrix)));
}
primitiveSubFloatArray(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)));
argPtr = ((float *) (firstIndexableField(arg)));
for (i = 0; i < length; i += 1) {
rcvrPtr[i] = ((((double) (rcvrPtr[i]))) - (((double) (argPtr[i]))));
}
pop(1);
return 0;
}
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));
}
}
