Revision: 3013 Author: lewis Date: 2014-06-23 16:03:59 -0700 (Mon, 23 Jun 2014) Log Message: ----------- Check in KedamaPlugin2 (from http://www.squeaksource.com/KedamaPlugins). Change plugins.ext to include KedamaPlugin2 only (remove KedamaPlugin).
Modified Paths: -------------- trunk/src/plugins.ext
Added Paths: ----------- trunk/src/plugins/KedamaPlugin2/ trunk/src/plugins/KedamaPlugin2/KedamaPlugin2.c
Added: trunk/src/plugins/KedamaPlugin2/KedamaPlugin2.c =================================================================== --- trunk/src/plugins/KedamaPlugin2/KedamaPlugin2.c (rev 0) +++ trunk/src/plugins/KedamaPlugin2/KedamaPlugin2.c 2014-06-23 23:03:59 UTC (rev 3013) @@ -0,0 +1,4563 @@ +/* Smalltalk from Squeak4.5 with VMMaker 4.13.5 translated as C source on 23 June 2014 6:57:27 pm */ +/* Automatically generated by + VMPluginCodeGenerator VMMaker-dtl.347 uuid: 0e985655-74a3-4561-8daf-4a4740c19a3b + from + KedamaPlugin2 Kedama-Plugins-yo.1 uuid: 3fc7d691-0149-ba4d-a339-5d27cd44a2f8 + */ +static char __buildInfo[] = "KedamaPlugin2 Kedama-Plugins-yo.1 uuid: 3fc7d691-0149-ba4d-a339-5d27cd44a2f8 " __DATE__ ; + + + + +#include <math.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <time.h> + +/* Default EXPORT macro that does nothing (see comment in sq.h): */ +#define EXPORT(returnType) returnType + +/* Do not include the entire sq.h file but just those parts needed. */ +/* The virtual machine proxy definition */ +#include "sqVirtualMachine.h" +/* Configuration options */ +#include "sqConfig.h" +/* Platform specific definitions */ +#include "sqPlatformSpecific.h" + +#define true 1 +#define false 0 +#define null 0 /* using 'null' because nil is predefined in Think C */ +#ifdef SQUEAK_BUILTIN_PLUGIN +#undef EXPORT +// was #undef EXPORT(returnType) but screws NorCroft cc +#define EXPORT(returnType) static returnType +#endif + +#include "sqMemoryAccess.h" + + +/*** Constants ***/ + +/*** Function Prototypes ***/ +static double degreesFromXy(double x, double y); +static double degreesToRadians(double degrees); +#pragma export on +EXPORT(sqInt) drawTurtlesInArray(void); +EXPORT(sqInt) getHeadingArrayInto(void); +EXPORT(const char*) getModuleName(void); +EXPORT(sqInt) getScalarHeading(void); +#pragma export off +static sqInt halt(void); +#pragma export on +EXPORT(sqInt) initialiseModule(void); +#pragma export off +static sqInt kedamaRandom2(sqInt range); +#pragma export on +EXPORT(sqInt) kedamaSetRandomSeed(void); +EXPORT(sqInt) makeMask(void); +EXPORT(sqInt) makeMaskLog(void); +EXPORT(sqInt) makeTurtlesMap(void); +EXPORT(sqInt) primPixelAtXY(void); +EXPORT(sqInt) primPixelAtXYPut(void); +EXPORT(sqInt) primPixelsAtXY(void); +EXPORT(sqInt) primScalarForward(void); +EXPORT(sqInt) primSetPixelsAtXY(void); +EXPORT(sqInt) primTurtlesForward(void); +EXPORT(sqInt) primUpHill(void); +EXPORT(sqInt) primitiveAddArrays(void); +EXPORT(sqInt) primitiveAddScalar(void); +EXPORT(sqInt) primitiveAndByteArray(void); +EXPORT(sqInt) primitiveDivArrays(void); +EXPORT(sqInt) primitiveDivScalar(void); +EXPORT(sqInt) primitiveEQArrays(void); +EXPORT(sqInt) primitiveEQScalar(void); +EXPORT(sqInt) primitiveGEArrays(void); +EXPORT(sqInt) primitiveGEScalar(void); +EXPORT(sqInt) primitiveGTArrays(void); +EXPORT(sqInt) primitiveGTScalar(void); +EXPORT(sqInt) primitiveLEArrays(void); +EXPORT(sqInt) primitiveLEScalar(void); +EXPORT(sqInt) primitiveLTArrays(void); +EXPORT(sqInt) primitiveLTScalar(void); +EXPORT(sqInt) primitiveMulArrays(void); +EXPORT(sqInt) primitiveMulScalar(void); +EXPORT(sqInt) primitiveNEArrays(void); +EXPORT(sqInt) primitiveNEScalar(void); +EXPORT(sqInt) primitiveNotByteArray(void); +EXPORT(sqInt) primitiveOrByteArray(void); +EXPORT(sqInt) primitivePredicateAtAllPutBoolean(void); +EXPORT(sqInt) primitivePredicateAtAllPutColor(void); +EXPORT(sqInt) primitivePredicateAtAllPutNumber(void); +EXPORT(sqInt) primitivePredicateAtAllPutObject(void); +EXPORT(sqInt) primitivePredicateReplaceBytes(void); +EXPORT(sqInt) primitivePredicateReplaceWords(void); +EXPORT(sqInt) primitiveRemArrays(void); +EXPORT(sqInt) primitiveRemScalar(void); +EXPORT(sqInt) primitiveSubArrays(void); +EXPORT(sqInt) primitiveSubScalar(void); +EXPORT(sqInt) randomIntoFloatArray(void); +EXPORT(sqInt) randomIntoIntegerArray(void); +EXPORT(sqInt) randomRange(void); +EXPORT(sqInt) scalarGetAngleTo(void); +EXPORT(sqInt) scalarGetDistanceTo(void); +EXPORT(sqInt) setHeadingArrayFrom(void); +EXPORT(sqInt) setInterpreter(struct VirtualMachine*anInterpreter); +EXPORT(sqInt) setScalarHeading(void); +EXPORT(sqInt) shutdownModule(void); +EXPORT(sqInt) turtleScalarSetX(void); +EXPORT(sqInt) turtleScalarSetY(void); +EXPORT(sqInt) turtlesSetX(void); +EXPORT(sqInt) turtlesSetY(void); +EXPORT(sqInt) vectorGetAngleTo(void); +EXPORT(sqInt) vectorGetDistanceTo(void); +EXPORT(sqInt) zoomBitmap(void); +#pragma export off +/*** Variables ***/ + +#ifdef SQUEAK_BUILTIN_PLUGIN +extern +#endif +struct VirtualMachine* interpreterProxy; +static unsigned int kedamaRandomSeed; +static const char *moduleName = +#ifdef SQUEAK_BUILTIN_PLUGIN + "KedamaPlugin2 23 June 2014 (i)" +#else + "KedamaPlugin2 23 June 2014 (e)" +#endif +; +static unsigned int randA; +static unsigned int randM; +static unsigned int randQ; +static unsigned int randR; + + +static double degreesFromXy(double x, double y) { + double tanVal; + double theta; + + if (x == 0.0) { + if (y >= 0.0) { + return 90.0; + } else { + return 270.0; + } + } else { + tanVal = y / x; + theta = atan(tanVal); + if (x >= 0.0) { + if (y >= 0.0) { + return theta / 0.0174532925199433; + } else { + return 360.0 + (theta / 0.0174532925199433); + } + } else { + return 180.0 + (theta / 0.0174532925199433); + } + } + return 0.0; +} + +static double degreesToRadians(double degrees) { + double deg; + double headingRadians; + int q; + + deg = 90.0 - degrees; + q = deg / 360.0; + if (deg < 0.0) { + q -= 1; + } + headingRadians = (deg - (q * 360.0)) * 0.0174532925199433; + return headingRadians; +} + +EXPORT(sqInt) drawTurtlesInArray(void) { + sqInt bitsIndex; + unsigned int *colorArray; + sqInt colorOop; + unsigned int *destBits; + sqInt destHeight; + sqInt destOop; + sqInt destWidth; + sqInt i; + sqInt size; + sqInt visible; + unsigned char *visibleArray; + sqInt visibleOop; + sqInt x; + float *xArray; + sqInt xOop; + sqInt y; + float *yArray; + sqInt yOop; + + visibleOop = interpreterProxy->stackValue(0); + colorOop = interpreterProxy->stackValue(1); + yOop = interpreterProxy->stackValue(2); + xOop = interpreterProxy->stackValue(3); + destHeight = interpreterProxy->stackIntegerValue(4); + destWidth = interpreterProxy->stackIntegerValue(5); + destOop = interpreterProxy->stackValue(6); + if (interpreterProxy->failed()) { + return null; + } + if (!(interpreterProxy->isWords(destOop))) { + interpreterProxy->primitiveFail(); + return null; + } + if (!(interpreterProxy->isWords(xOop))) { + interpreterProxy->primitiveFail(); + return null; + } + if (!(interpreterProxy->isWords(yOop))) { + interpreterProxy->primitiveFail(); + return null; + } + if (!(interpreterProxy->isWords(colorOop))) { + interpreterProxy->primitiveFail(); + return null; + } + if (!(interpreterProxy->isBytes(visibleOop))) { + interpreterProxy->primitiveFail(); + return null; + } + if ((destHeight * destWidth) != (interpreterProxy->slotSizeOf(destOop))) { + interpreterProxy->primitiveFail(); + return null; + } + size = interpreterProxy->slotSizeOf(xOop); + if ((interpreterProxy->slotSizeOf(yOop)) != size) { + interpreterProxy->primitiveFail(); + return null; + } + if ((interpreterProxy->slotSizeOf(colorOop)) != size) { + interpreterProxy->primitiveFail(); + return null; + } + if ((interpreterProxy->slotSizeOf(visibleOop)) != size) { + interpreterProxy->primitiveFail(); + return null; + } + xArray = interpreterProxy->firstIndexableField(xOop); + yArray = interpreterProxy->firstIndexableField(yOop); + colorArray = interpreterProxy->firstIndexableField(colorOop); + visibleArray = interpreterProxy->firstIndexableField(visibleOop); + destBits = interpreterProxy->firstIndexableField(destOop); + for (i = 0; i <= (size - 1); i += 1) { + x = ((int) (xArray[i])); + ; + y = ((int) (yArray[i])); + ; + visible = visibleArray[i]; + if ((visible != 0) && (((x >= 0) && (y >= 0)) && ((x < destWidth) && (y < destHeight)))) { + bitsIndex = (y * destWidth) + x; + destBits[bitsIndex] = (colorArray[i]); + } + } + if (interpreterProxy->failed()) { + return null; + } + interpreterProxy->pop(7); +} + +EXPORT(sqInt) getHeadingArrayInto(void) { + double heading; + float *headingArray; + sqInt headingOop; + sqInt i; + float *resultArray; + sqInt resultOop; + sqInt size; + + resultOop = interpreterProxy->stackValue(0); + headingOop = interpreterProxy->stackValue(1); + if (interpreterProxy->failed()) { + return null; + } + if (!(interpreterProxy->isWords(headingOop))) { + interpreterProxy->primitiveFail(); + return null; + } + if (!(interpreterProxy->isWords(resultOop))) { + interpreterProxy->primitiveFail(); + return null; + } + size = interpreterProxy->slotSizeOf(headingOop); + if ((interpreterProxy->slotSizeOf(resultOop)) != size) { + interpreterProxy->primitiveFail(); + return null; + } + headingArray = interpreterProxy->firstIndexableField(headingOop); + resultArray = interpreterProxy->firstIndexableField(resultOop); + for (i = 0; i <= (size - 1); i += 1) { + heading = headingArray[i]; + heading = heading / 0.0174532925199433; + heading = 90.0 - heading; + if (!(heading > 0.0)) { + heading += 360.0; + } + resultArray[i] = heading; + } + if (interpreterProxy->failed()) { + return null; + } + interpreterProxy->pop(2); +} + + +/* Note: This is hardcoded so it can be run from Squeak. + The module name is used for validating a module *after* + it is loaded to check if it does really contain the module + we're thinking it contains. This is important! */ + +EXPORT(const char*) getModuleName(void) { + return moduleName; +} + +EXPORT(sqInt) getScalarHeading(void) { + double heading; + float *headingArray; + sqInt headingOop; + sqInt index; + double deg; + double degrees; + + headingOop = interpreterProxy->stackValue(0); + index = interpreterProxy->stackIntegerValue(1); + if (interpreterProxy->failed()) { + return null; + } + if (!(interpreterProxy->isWords(headingOop))) { + interpreterProxy->primitiveFail(); + return null; + } + if ((interpreterProxy->slotSizeOf(headingOop)) < index) { + interpreterProxy->primitiveFail(); + return null; + } + headingArray = interpreterProxy->firstIndexableField(headingOop); + heading = headingArray[index - 1]; + /* begin radiansToDegrees: */ + degrees = heading / 0.0174532925199433; + deg = 90.0 - degrees; + if (!(deg > 0.0)) { + deg += 360.0; + } + heading = deg; + if (interpreterProxy->failed()) { + return null; + } + interpreterProxy->pop(3); + interpreterProxy->pushFloat(heading); +} + +static sqInt halt(void) { + ; +} + +EXPORT(sqInt) initialiseModule(void) { + kedamaRandomSeed = 17; + + /* magic constant = 16807 */ + + randA = 16807; + + /* magic constant = 2147483647 */ + + randM = 2147483647U; + randQ = randM / randA; + randR = randM % randA; +} + +static sqInt kedamaRandom2(sqInt range) { + sqInt hi; + sqInt lo; + sqInt r; + sqInt v; + sqInt val; + + if (range < 0) { + r = 0 - range; + } else { + r = range; + } + hi = kedamaRandomSeed / randQ; + lo = kedamaRandomSeed % randQ; + kedamaRandomSeed = (randA * lo) - (randR * hi); + v = kedamaRandomSeed & 65535; + val = ((usqInt) (v * (r + 1))) >> 16; + if (range < 0) { + return 0 - val; + } else { + return val; + } +} + +EXPORT(sqInt) kedamaSetRandomSeed(void) { + sqInt seed; + + seed = interpreterProxy->stackIntegerValue(0); + if (interpreterProxy->failed()) { + return null; + } + kedamaRandomSeed = seed & 65536; + interpreterProxy->pop(1); +} + +EXPORT(sqInt) makeMask(void) { + unsigned int alpha; + unsigned int* dOrigin; + sqInt data; + sqInt dataBits; + sqInt dataSize; + unsigned int highMask; + sqInt i; + unsigned int* mOrigin; + sqInt maskBits; + sqInt maskSize; + unsigned int pixel; + sqInt shiftAmount; + + shiftAmount = interpreterProxy->stackIntegerValue(0); + pixel = interpreterProxy->stackIntegerValue(1); + maskBits = interpreterProxy->stackValue(2); + dataBits = interpreterProxy->stackValue(3); + if (interpreterProxy->failed()) { + return null; + } + dataSize = interpreterProxy->slotSizeOf(dataBits); + maskSize = interpreterProxy->slotSizeOf(maskBits); + if (!(dataSize == maskSize)) { + interpreterProxy->primitiveFail(); + return null; + } + if (shiftAmount < -32) { + interpreterProxy->primitiveFail(); + return null; + } + if (shiftAmount > 8) { + interpreterProxy->primitiveFail(); + return null; + } + dOrigin = interpreterProxy->firstIndexableField(dataBits); + mOrigin = interpreterProxy->firstIndexableField(maskBits); + highMask = 4278190080U; + for (i = 0; i <= (dataSize - 1); i += 1) { + data = dOrigin[i]; + alpha = ((shiftAmount < 0) ? ((usqInt) data >> -shiftAmount) : ((usqInt) data << shiftAmount)); + if (alpha > 255) { + alpha = 255; + } + if (alpha < 0) { + alpha = 0; + } + mOrigin[i] = (((alpha << 24) & highMask) | pixel); + } + interpreterProxy->pop(4); +} + +EXPORT(sqInt) makeMaskLog(void) { + unsigned int alpha; + unsigned int* dOrigin; + sqInt data; + sqInt dataBits; + sqInt dataSize; + unsigned int highMask; + sqInt i; + unsigned int* mOrigin; + sqInt maskBits; + sqInt maskSize; + unsigned int max; + unsigned int* maxFirst; + double maxLog; + sqInt maxOop; + unsigned int pixel; + + maxOop = interpreterProxy->stackValue(0); + pixel = interpreterProxy->stackIntegerValue(1); + maskBits = interpreterProxy->stackValue(2); + dataBits = interpreterProxy->stackValue(3); + if (interpreterProxy->failed()) { + return null; + } + maxFirst = interpreterProxy->firstIndexableField(maxOop); + max = maxFirst[0]; + if (interpreterProxy->failed()) { + return null; + } + maxLog = log(max); + dataSize = interpreterProxy->slotSizeOf(dataBits); + maskSize = interpreterProxy->slotSizeOf(maskBits); + if (!(dataSize == maskSize)) { + interpreterProxy->primitiveFail(); + return null; + } + dOrigin = interpreterProxy->firstIndexableField(dataBits); + mOrigin = interpreterProxy->firstIndexableField(maskBits); + highMask = 4278190080U; + for (i = 0; i <= (dataSize - 1); i += 1) { + data = dOrigin[i]; + if (data == 0) { + alpha = 0; + } else { + alpha = ((sqInt)((255.0 / maxLog) * (log(data)))); + } + if (alpha > 255) { + alpha = 255; + } + mOrigin[i] = (((alpha << 24) & highMask) | pixel); + } + interpreterProxy->pop(4); +} + +EXPORT(sqInt) makeTurtlesMap(void) { + sqInt height; + sqInt index; + unsigned int *map; + sqInt mapIndex; + sqInt mapOop; + sqInt size; + unsigned int *whoArray; + sqInt whoOop; + sqInt width; + sqInt x; + float *xArray; + sqInt xOop; + sqInt y; + float *yArray; + sqInt yOop; + + height = interpreterProxy->stackIntegerValue(0); + width = interpreterProxy->stackIntegerValue(1); + yOop = interpreterProxy->stackValue(2); + xOop = interpreterProxy->stackValue(3); + whoOop = interpreterProxy->stackValue(4); + mapOop = interpreterProxy->stackValue(5); + if (!(interpreterProxy->isWords(yOop))) { + interpreterProxy->primitiveFail(); + return null; + } + if (!(interpreterProxy->isWords(xOop))) { + interpreterProxy->primitiveFail(); + return null; + } + if (!(interpreterProxy->isWords(whoOop))) { + interpreterProxy->primitiveFail(); + return null; + } + if (!(interpreterProxy->isWords(mapOop))) { + interpreterProxy->primitiveFail(); + return null; + } + size = interpreterProxy->slotSizeOf(whoOop); + if ((interpreterProxy->slotSizeOf(xOop)) != size) { + interpreterProxy->primitiveFail(); + return null; + } + if ((interpreterProxy->slotSizeOf(yOop)) != size) { + interpreterProxy->primitiveFail(); + return null; + } + if ((interpreterProxy->slotSizeOf(mapOop)) != (height * width)) { + interpreterProxy->primitiveFail(); + return null; + } + xArray = interpreterProxy->firstIndexableField(xOop); + yArray = interpreterProxy->firstIndexableField(yOop); + whoArray = interpreterProxy->firstIndexableField(whoOop); + map = interpreterProxy->firstIndexableField(mapOop); + for (index = 0; index <= ((height * width) - 1); index += 1) { + map[index] = 0; + } + for (index = 0; index <= (size - 1); index += 1) { + x = xArray[index]; + y = yArray[index]; + mapIndex = (width * y) + x; + if ((mapIndex >= 0) && (mapIndex < (height * width))) { + map[mapIndex] = (whoArray[index]); + } + } + if (interpreterProxy->failed()) { + return null; + } + interpreterProxy->pop(6); +} + +EXPORT(sqInt) primPixelAtXY(void) { + unsigned int *bits; + sqInt bitsOop; + sqInt height; + sqInt index; + sqInt ret; + sqInt width; + sqInt x; + double xPos; + sqInt y; + double yPos; + + height = interpreterProxy->stackIntegerValue(0); + width = interpreterProxy->stackIntegerValue(1); + yPos = interpreterProxy->stackFloatValue(2); + xPos = interpreterProxy->stackFloatValue(3); + bitsOop = interpreterProxy->stackValue(4); + if (interpreterProxy->failed()) { + return null; + } + if (!(interpreterProxy->isWords(bitsOop))) { + interpreterProxy->primitiveFail(); + return null; + } + if ((interpreterProxy->slotSizeOf(bitsOop)) != (height * width)) { + interpreterProxy->primitiveFail(); + return null; + } + x = xPos; + y = yPos; + bits = interpreterProxy->firstIndexableField(bitsOop); + if ((((x >= 0) && (x < width)) && (y >= 0)) && (y < height)) { + index = (y * width) + x; + ret = bits[index]; + } else { + ret = 0; + } + if (interpreterProxy->failed()) { + return null; + } + interpreterProxy->pop(6); + interpreterProxy->pushInteger(ret); +} + +EXPORT(sqInt) primPixelAtXYPut(void) { + unsigned int *bits; + sqInt bitsOop; + sqInt height; + sqInt index; + sqInt v; + sqInt value; + sqInt width; + sqInt x; + double xPos; + sqInt y; + double yPos; + + height = interpreterProxy->stackIntegerValue(0); + width = interpreterProxy->stackIntegerValue(1); + value = interpreterProxy->stackIntegerValue(2); + yPos = interpreterProxy->stackFloatValue(3); + xPos = interpreterProxy->stackFloatValue(4); + bitsOop = interpreterProxy->stackValue(5); + if (interpreterProxy->failed()) { + return null; + } + if (!(interpreterProxy->isWords(bitsOop))) { + interpreterProxy->primitiveFail(); + return null; + } + if ((interpreterProxy->slotSizeOf(bitsOop)) != (height * width)) { + interpreterProxy->primitiveFail(); + return null; + } + x = xPos; + y = yPos; + v = value; + if (v > 1073741823) { + v = 1073741823; + } + if (v < 0) { + v = 0; + } + bits = interpreterProxy->firstIndexableField(bitsOop); + if ((((x >= 0) && (x < width)) && (y >= 0)) && (y < height)) { + index = (y * width) + x; + bits[index] = v; + } + if (interpreterProxy->failed()) { + return null; + } + interpreterProxy->pop(6); +} + +EXPORT(sqInt) primPixelsAtXY(void) { + unsigned int *bits; + sqInt bitsHeight; + sqInt bitsIndex; + sqInt bitsOop; + sqInt bitsWidth; + unsigned int *destWords; + sqInt destWordsOop; + sqInt i; + sqInt size; + sqInt x; + float *xArray; + sqInt xArrayOop; + sqInt y; + float *yArray; + sqInt yArrayOop; + + destWordsOop = interpreterProxy->stackValue(0); + bitsHeight = interpreterProxy->stackIntegerValue(1); + bitsWidth = interpreterProxy->stackIntegerValue(2); + bitsOop = interpreterProxy->stackValue(3); + yArrayOop = interpreterProxy->stackValue(4); + xArrayOop = interpreterProxy->stackValue(5); + if (interpreterProxy->failed()) { + return null; + } + if (!(interpreterProxy->isWords(destWordsOop))) { + interpreterProxy->primitiveFail(); + return null; + } + if (!(interpreterProxy->isWords(xArrayOop))) { + interpreterProxy->primitiveFail(); + return null; + } + if (!(interpreterProxy->isWords(yArrayOop))) { + interpreterProxy->primitiveFail(); + return null; + } + if (!(interpreterProxy->isWords(bitsOop))) { + interpreterProxy->primitiveFail(); + return null; + } + if ((bitsHeight * bitsWidth) != (interpreterProxy->slotSizeOf(bitsOop))) { + interpreterProxy->primitiveFail(); + return null; + } + size = interpreterProxy->slotSizeOf(xArrayOop); + if ((interpreterProxy->slotSizeOf(yArrayOop)) != size) { + interpreterProxy->primitiveFail(); + return null; + } + if ((interpreterProxy->slotSizeOf(destWordsOop)) != size) { + interpreterProxy->primitiveFail(); + return null; + } + xArray = interpreterProxy->firstIndexableField(xArrayOop); + yArray = interpreterProxy->firstIndexableField(yArrayOop); + destWords = interpreterProxy->firstIndexableField(destWordsOop); + bits = interpreterProxy->firstIndexableField(bitsOop); + for (i = 0; i <= (size - 1); i += 1) { + x = ((int) (xArray[i])); + ; + y = ((int) (yArray[i])); + ; + if (((x >= 0) && (y >= 0)) && ((x < bitsWidth) && (y < bitsHeight))) { + bitsIndex = (y * bitsWidth) + x; + destWords[i] = (bits[bitsIndex]); + } + } + if (interpreterProxy->failed()) { + return null; + } + interpreterProxy->pop(6); +} + +EXPORT(sqInt) primScalarForward(void) { + sqInt bottomEdgeMode; + double destHeight; + double destWidth; + double dist; + float *headingArray; + sqInt headingOop; + sqInt i; + sqInt index; + sqInt leftEdgeMode; + double newX; + double newY; + sqInt rightEdgeMode; + sqInt size; + sqInt topEdgeMode; + double val; + float *xArray; + sqInt xOop; + float *yArray; + sqInt yOop; + double headingRadians; + double newX1; + double newY1; + + bottomEdgeMode = interpreterProxy->stackIntegerValue(0); + topEdgeMode = interpreterProxy->stackIntegerValue(1); + rightEdgeMode = interpreterProxy->stackIntegerValue(2); + leftEdgeMode = interpreterProxy->stackIntegerValue(3); + destHeight = interpreterProxy->stackFloatValue(4); + destWidth = interpreterProxy->stackFloatValue(5); + val = interpreterProxy->stackFloatValue(6); + headingOop = interpreterProxy->stackValue(7); + yOop = interpreterProxy->stackValue(8); + xOop = interpreterProxy->stackValue(9); + index = interpreterProxy->stackIntegerValue(10); + if (interpreterProxy->failed()) { + return null; + } + if (!(interpreterProxy->isWords(xOop))) { + interpreterProxy->primitiveFail(); + return null; + } + if (!(interpreterProxy->isWords(yOop))) { + interpreterProxy->primitiveFail(); + return null; + } + if (!(interpreterProxy->isWords(headingOop))) { + interpreterProxy->primitiveFail(); + return null; + } + size = interpreterProxy->slotSizeOf(xOop); + if ((interpreterProxy->slotSizeOf(yOop)) != size) { + interpreterProxy->primitiveFail(); + return null; + } + if ((interpreterProxy->slotSizeOf(headingOop)) != size) { + interpreterProxy->primitiveFail(); + return null; + } + xArray = interpreterProxy->firstIndexableField(xOop); + yArray = interpreterProxy->firstIndexableField(yOop); + headingArray = interpreterProxy->firstIndexableField(headingOop); + dist = val; + i = index - 1; + newX = (xArray[i]) + (dist * (cos(headingArray[i]))); + newY = (yArray[i]) - (dist * (sin(headingArray[i]))); + /* begin scalarXAt:xArray:headingArray:value:destWidth:leftEdgeMode:rightEdgeMode: */ + newX1 = newX; + if (newX1 < 0.0) { + if (leftEdgeMode == 1) { + newX1 += destWidth; + } + if (leftEdgeMode == 2) { + newX1 = 0.0; + } + if (leftEdgeMode == 3) { + newX1 = 0.0 - newX1; + headingRadians = headingArray[i]; + if (headingRadians < 3.141592653589793) { + headingArray[i] = (3.141592653589793 - headingRadians); + } else { + headingArray[i] = (9.42477796076938 - headingRadians); + } + } + } + if (newX1 >= destWidth) { + if (rightEdgeMode == 1) { + newX1 -= destWidth; + } + if (rightEdgeMode == 2) { + newX1 = destWidth - 1.0e-6; + } + if (rightEdgeMode == 3) { + newX1 = (destWidth - 1.0e-6) - (newX1 - destWidth); + headingRadians = headingArray[i]; + if (headingRadians < 3.141592653589793) { + headingArray[i] = (3.141592653589793 - headingRadians); + } else { + headingArray[i] = (9.42477796076938 - headingRadians); + } + } + } + xArray[i] = newX1; + /* begin scalarYAt:yArray:headingArray:value:destHeight:topEdgeMode:bottomEdgeMode: */ + newY1 = newY; + if (newY1 < 0.0) { + if (topEdgeMode == 1) { + newY1 += destHeight; + } + if (topEdgeMode == 2) { + newY1 = 0.0; + } + if (topEdgeMode == 3) { + newY1 = 0.0 - newY1; + headingArray[i] = (6.283185307179586 - (headingArray[i])); + } + } + if (newY1 >= destHeight) { + if (bottomEdgeMode == 1) { + newY1 -= destHeight; + } + if (bottomEdgeMode == 2) { + newY1 = destHeight - 1.0e-6; + } + if (bottomEdgeMode == 3) { + newY1 = (destHeight - 1.0e-6) - (newY1 - destHeight); + headingArray[i] = (6.283185307179586 - (headingArray[i])); + } + } + yArray[i] = newY1; + if (interpreterProxy->failed()) { + return null; + } + interpreterProxy->pop(11); +} + +EXPORT(sqInt) primSetPixelsAtXY(void) { + unsigned int *bits; + sqInt bitsHeight; + sqInt bitsIndex; + sqInt bitsOop; + sqInt bitsWidth; + float *floatsValue; + sqInt fv; + sqInt i; + unsigned int intValue; + sqInt isValueInt; + sqInt isValueWordArray; + unsigned char *pArray; + sqInt pArrayOop; + sqInt size; + unsigned int value; + sqInt valueOop; + unsigned int *wordsValue; + sqInt x; + float *xArray; + sqInt xArrayOop; + sqInt y; + float *yArray; + sqInt yArrayOop; + + valueOop = interpreterProxy->stackValue(0); + bitsHeight = interpreterProxy->stackIntegerValue(1); + bitsWidth = interpreterProxy->stackIntegerValue(2); + bitsOop = interpreterProxy->stackValue(3); + yArrayOop = interpreterProxy->stackValue(4); + xArrayOop = interpreterProxy->stackValue(5); + pArrayOop = interpreterProxy->stackValue(6); + if (interpreterProxy->failed()) { + return null; + } + if (!(interpreterProxy->isBytes(pArrayOop))) { + interpreterProxy->primitiveFail(); + return null; + } + if (!(interpreterProxy->isWords(xArrayOop))) { + interpreterProxy->primitiveFail(); + return null; + } + if (!(interpreterProxy->isWords(yArrayOop))) { + interpreterProxy->primitiveFail(); + return null; + } + if (!(interpreterProxy->isWords(bitsOop))) { + interpreterProxy->primitiveFail(); + return null; + } + if ((bitsHeight * bitsWidth) != (interpreterProxy->slotSizeOf(bitsOop))) { + interpreterProxy->primitiveFail(); + return null; + } + size = interpreterProxy->slotSizeOf(xArrayOop); + if ((interpreterProxy->slotSizeOf(pArrayOop)) != size) { + interpreterProxy->primitiveFail(); + return null; + } + if ((interpreterProxy->slotSizeOf(yArrayOop)) != size) { + interpreterProxy->primitiveFail(); + return null; + } + pArray = interpreterProxy->firstIndexableField(pArrayOop); + xArray = interpreterProxy->firstIndexableField(xArrayOop); + yArray = interpreterProxy->firstIndexableField(yArrayOop); + isValueInt = (valueOop & 1); + if (isValueInt) { + intValue = (valueOop >> 1); + value = intValue; + } else { + if ((interpreterProxy->slotSizeOf(valueOop)) != size) { + interpreterProxy->primitiveFail(); + return null; + } + isValueWordArray = interpreterProxy->isMemberOf(valueOop, "WordArray"); + if (isValueWordArray) { + wordsValue = interpreterProxy->firstIndexableField(valueOop); + } else { + floatsValue = interpreterProxy->firstIndexableField(valueOop); + } + } + bits = interpreterProxy->firstIndexableField(bitsOop); + for (i = 0; i <= (size - 1); i += 1) { + if ((pArray[i]) == 1) { + x = ((int) (xArray[i])); + ; + y = ((int) (yArray[i])); + ; + if (((x >= 0) && (y >= 0)) && ((x < bitsWidth) && (y < bitsHeight))) { + bitsIndex = (y * bitsWidth) + x; + if (isValueInt) { + bits[bitsIndex] = value; + } else { + if (isValueWordArray) { + bits[bitsIndex] = (wordsValue[i]); + } else { + fv = floatsValue[i]; + ; + bits[bitsIndex] = fv; + } + } + } + } + } + if (interpreterProxy->failed()) { + return null; + } + interpreterProxy->pop(7); +} + +EXPORT(sqInt) primTurtlesForward(void) { + sqInt bottomEdgeMode; + double destHeight; + double destWidth; + double dist; + float *headingArray; + sqInt headingOop; + sqInt i; + sqInt isValVector; + sqInt leftEdgeMode; + double newX; + double newY; + unsigned char *pArray; + sqInt pOop; + sqInt rightEdgeMode; + sqInt size; + sqInt topEdgeMode; + double val; + float *valArray; + sqInt valOop; + float *xArray; + sqInt xOop; + float *yArray; + sqInt yOop; + double headingRadians; + double newX1; + double newY1; + + bottomEdgeMode = interpreterProxy->stackIntegerValue(0); + topEdgeMode = interpreterProxy->stackIntegerValue(1); + rightEdgeMode = interpreterProxy->stackIntegerValue(2); + leftEdgeMode = interpreterProxy->stackIntegerValue(3); + destHeight = interpreterProxy->stackFloatValue(4); + destWidth = interpreterProxy->stackFloatValue(5); + valOop = interpreterProxy->stackValue(6); + headingOop = interpreterProxy->stackValue(7); + yOop = interpreterProxy->stackValue(8); + xOop = interpreterProxy->stackValue(9); + pOop = interpreterProxy->stackValue(10); + if (interpreterProxy->failed()) { + return null; + } + if (!(interpreterProxy->isBytes(pOop))) { + interpreterProxy->primitiveFail(); + return null; + } + if (!(interpreterProxy->isWords(xOop))) { + interpreterProxy->primitiveFail(); + return null; + } + if (!(interpreterProxy->isWords(yOop))) { + interpreterProxy->primitiveFail(); + return null; + } + if (!(interpreterProxy->isWords(headingOop))) { + interpreterProxy->primitiveFail(); + return null; + } + if (interpreterProxy->isFloatObject(valOop)) { + isValVector = 0; + } else { + if (interpreterProxy->isWords(valOop)) { + isValVector = 1; + } else { + interpreterProxy->primitiveFail(); + return null; + } + } + size = interpreterProxy->slotSizeOf(xOop); + if ((interpreterProxy->slotSizeOf(yOop)) != size) { + interpreterProxy->primitiveFail(); + return null; + } + if ((interpreterProxy->slotSizeOf(headingOop)) != size) { + interpreterProxy->primitiveFail(); + return null; + } + if ((interpreterProxy->slotSizeOf(pOop)) != size) { + interpreterProxy->primitiveFail(); + return null; + } + if (isValVector) { + if ((interpreterProxy->slotSizeOf(valOop)) != size) { + interpreterProxy->primitiveFail(); + return null; + } + } + pArray = interpreterProxy->firstIndexableField(pOop); + xArray = interpreterProxy->firstIndexableField(xOop); + yArray = interpreterProxy->firstIndexableField(yOop); + headingArray = interpreterProxy->firstIndexableField(headingOop); + if (isValVector) { + valArray = interpreterProxy->firstIndexableField(valOop); + } else { + val = interpreterProxy->floatValueOf(valOop); + } + for (i = 0; i <= (size - 1); i += 1) { + if ((pArray[i]) == 1) { + if (isValVector) { + dist = valArray[i]; + } else { + dist = val; + } + newX = (xArray[i]) + (dist * (cos(headingArray[i]))); + newY = (yArray[i]) - (dist * (sin(headingArray[i]))); + /* begin scalarXAt:xArray:headingArray:value:destWidth:leftEdgeMode:rightEdgeMode: */ + newX1 = newX; + if (newX1 < 0.0) { + if (leftEdgeMode == 1) { + newX1 += destWidth; + } + if (leftEdgeMode == 2) { + newX1 = 0.0; + } + if (leftEdgeMode == 3) { + newX1 = 0.0 - newX1; + headingRadians = headingArray[i]; + if (headingRadians < 3.141592653589793) { + headingArray[i] = (3.141592653589793 - headingRadians); + } else { + headingArray[i] = (9.42477796076938 - headingRadians); + } + } + } + if (newX1 >= destWidth) { + if (rightEdgeMode == 1) { + newX1 -= destWidth; + } + if (rightEdgeMode == 2) { + newX1 = destWidth - 1.0e-6; + } + if (rightEdgeMode == 3) { + newX1 = (destWidth - 1.0e-6) - (newX1 - destWidth); + headingRadians = headingArray[i]; + if (headingRadians < 3.141592653589793) { + headingArray[i] = (3.141592653589793 - headingRadians); + } else { + headingArray[i] = (9.42477796076938 - headingRadians); + } + } + } + xArray[i] = newX1; + /* begin scalarYAt:yArray:headingArray:value:destHeight:topEdgeMode:bottomEdgeMode: */ + newY1 = newY; + if (newY1 < 0.0) { + if (topEdgeMode == 1) { + newY1 += destHeight; + } + if (topEdgeMode == 2) { + newY1 = 0.0; + } + if (topEdgeMode == 3) { + newY1 = 0.0 - newY1; + headingArray[i] = (6.283185307179586 - (headingArray[i])); + } + } + if (newY1 >= destHeight) { + if (bottomEdgeMode == 1) { + newY1 -= destHeight; + } + if (bottomEdgeMode == 2) { + newY1 = destHeight - 1.0e-6; + } + if (bottomEdgeMode == 3) { + newY1 = (destHeight - 1.0e-6) - (newY1 - destHeight); + headingArray[i] = (6.283185307179586 - (headingArray[i])); + } + } + yArray[i] = newY1; + } + } + if (interpreterProxy->failed()) { + return null; + } + interpreterProxy->pop(11); +} + +EXPORT(sqInt) primUpHill(void) { + unsigned int *bits; + sqInt bitsOop; + sqInt endX; + sqInt endY; + sqInt height; + sqInt maxVal; + sqInt maxValX; + sqInt maxValY; + double ret; + sqInt rowOffset; + sqInt sniffRange; + sqInt startX; + sqInt startY; + double tH; + double tX; + double tY; + sqInt thisVal; + sqInt turtleX; + sqInt turtleY; + sqInt width; + sqInt x; + sqInt y; + double deg; + double degrees; + + sniffRange = interpreterProxy->stackIntegerValue(0); + height = interpreterProxy->stackIntegerValue(1); + width = interpreterProxy->stackIntegerValue(2); + bitsOop = interpreterProxy->stackValue(3); + tH = interpreterProxy->stackFloatValue(4); + tY = interpreterProxy->stackFloatValue(5); + tX = interpreterProxy->stackFloatValue(6); + if (interpreterProxy->failed()) { + return null; + } + if (!(interpreterProxy->isWords(bitsOop))) { + interpreterProxy->primitiveFail(); + return null; + } + if ((interpreterProxy->slotSizeOf(bitsOop)) != (height * width)) { + interpreterProxy->primitiveFail(); + return null; + } + bits = interpreterProxy->firstIndexableField(bitsOop); + turtleX = tX; + turtleY = tY; + turtleX = ((turtleX < 0) ? 0 : turtleX); + turtleY = ((turtleY < 0) ? 0 : turtleY); + turtleX = ((turtleX < (width - 1)) ? turtleX : (width - 1)); + turtleY = ((turtleY < (height - 1)) ? turtleY : (height - 1)); + startX = (((turtleX - sniffRange) < 0) ? 0 : (turtleX - sniffRange)); + endX = (((turtleX + sniffRange) < (width - 1)) ? (turtleX + sniffRange) : (width - 1)); + startY = (((turtleY - sniffRange) < 0) ? 0 : (turtleY - sniffRange)); + endY = (((turtleY + sniffRange) < (height - 1)) ? (turtleY + sniffRange) : (height - 1)); + maxVal = bits[(turtleY * width) + turtleX]; + maxValX = -1; + for (y = startY; y <= endY; y += 1) { + rowOffset = y * width; + for (x = startX; x <= endX; x += 1) { + thisVal = bits[rowOffset + x]; + if (thisVal > maxVal) { + maxValX = x; + maxValY = y; + maxVal = thisVal; + } + } + } + if (-1 == maxValX) { + /* begin radiansToDegrees: */ + degrees = tH / 0.0174532925199433; + deg = 90.0 - degrees; + if (!(deg > 0.0)) { + deg += 360.0; + } + ret = deg; + } else { + ret = (degreesFromXy(((double) (maxValX - turtleX)), ((double) (maxValY - turtleY)))) + 90.0; + } + if (interpreterProxy->failed()) { + return null; + } + interpreterProxy->pop(8); + interpreterProxy->pushFloat(ret); +} + +EXPORT(sqInt) primitiveAddArrays(void) { + sqInt argOop; + float *floatsArg; + float *floatsRcvr; + float *floatsResult; + sqInt i; + sqInt isArgWords; + sqInt isRcvrWords; + sqInt length; + sqInt rcvrOop; + sqInt resultOop; + unsigned int *wordsArg; + unsigned int *wordsRcvr; + unsigned int *wordsResult; + + resultOop = interpreterProxy->stackObjectValue(0); + argOop = interpreterProxy->stackObjectValue(1); + rcvrOop = interpreterProxy->stackObjectValue(2); + if (interpreterProxy->failed()) { + return null; + } + interpreterProxy->success(interpreterProxy->isWords(argOop)); + interpreterProxy->success(interpreterProxy->isWords(rcvrOop)); + interpreterProxy->success(interpreterProxy->isWords(resultOop)); + if (interpreterProxy->failed()) { + return null; + } + length = interpreterProxy->stSizeOf(argOop); + interpreterProxy->success(length == (interpreterProxy->stSizeOf(rcvrOop))); + interpreterProxy->success(length == (interpreterProxy->stSizeOf(resultOop))); + if (interpreterProxy->failed()) { + return null; + } + isArgWords = interpreterProxy->isMemberOf(argOop, "WordArray"); + isRcvrWords = interpreterProxy->isMemberOf(rcvrOop, "WordArray"); + if (isArgWords && isRcvrWords) { + if (!(interpreterProxy->isMemberOf(resultOop, "WordArray"))) { + interpreterProxy->primitiveFail(); + return null; + } + } else { + if (!(interpreterProxy->isMemberOf(resultOop, "KedamaFloatArray"))) { + interpreterProxy->primitiveFail(); + return null; + } + } + if (isRcvrWords) { + if (isArgWords) { + wordsRcvr = interpreterProxy->firstIndexableField(rcvrOop); + wordsArg = interpreterProxy->firstIndexableField(argOop); + wordsResult = interpreterProxy->firstIndexableField(resultOop); + for (i = 0; i <= (length - 1); i += 1) { + wordsResult[i] = ((wordsRcvr[i]) + (wordsArg[i])); + } + } else { + wordsRcvr = interpreterProxy->firstIndexableField(rcvrOop); + floatsArg = interpreterProxy->firstIndexableField(argOop); + floatsResult = interpreterProxy->firstIndexableField(resultOop); + for (i = 0; i <= (length - 1); i += 1) { + floatsResult[i] = ((wordsRcvr[i]) + (floatsArg[i])); + } + } + } else { + if (isArgWords) { + floatsRcvr = interpreterProxy->firstIndexableField(rcvrOop); + wordsArg = interpreterProxy->firstIndexableField(argOop); + floatsResult = interpreterProxy->firstIndexableField(resultOop); + for (i = 0; i <= (length - 1); i += 1) { + floatsResult[i] = ((floatsRcvr[i]) + (wordsArg[i])); + } + } else { + floatsRcvr = interpreterProxy->firstIndexableField(rcvrOop); + floatsArg = interpreterProxy->firstIndexableField(argOop); + floatsResult = interpreterProxy->firstIndexableField(resultOop); + for (i = 0; i <= (length - 1); i += 1) { + floatsResult[i] = ((floatsRcvr[i]) + (floatsArg[i])); + } + } + } + interpreterProxy->pop(4); + interpreterProxy->push(resultOop); +} + +EXPORT(sqInt) primitiveAddScalar(void) { + sqInt argOop; + double floatArg; + float *floatsRcvr; + float *floatsResult; + sqInt i; + int intArg; + sqInt isArgInt; + sqInt isRcvrWords; + sqInt length; + sqInt rcvrOop; + sqInt resultOop; + unsigned int *wordsRcvr; + unsigned int *wordsResult; + + resultOop = interpreterProxy->stackObjectValue(0); + argOop = interpreterProxy->stackValue(1); + rcvrOop = interpreterProxy->stackObjectValue(2); + if (interpreterProxy->failed()) { + return null; + } + interpreterProxy->success(interpreterProxy->isWords(rcvrOop)); + interpreterProxy->success(interpreterProxy->isWords(resultOop)); + if (interpreterProxy->failed()) { + return null; + } + length = interpreterProxy->stSizeOf(rcvrOop); + interpreterProxy->success(length == (interpreterProxy->stSizeOf(resultOop))); + if (interpreterProxy->failed()) { + return null; + } + isArgInt = (argOop & 1); + isRcvrWords = interpreterProxy->isMemberOf(rcvrOop, "WordArray"); + if (isArgInt && isRcvrWords) { + if (!(interpreterProxy->isMemberOf(resultOop, "WordArray"))) { + interpreterProxy->primitiveFail(); + return null; + } + } else { + if (!(interpreterProxy->isMemberOf(resultOop, "KedamaFloatArray"))) { + interpreterProxy->primitiveFail(); + return null; + } + } + if (isRcvrWords) { + if (isArgInt) { + wordsRcvr = interpreterProxy->firstIndexableField(rcvrOop); + intArg = (argOop >> 1); + wordsResult = interpreterProxy->firstIndexableField(resultOop); + for (i = 0; i <= (length - 1); i += 1) { + wordsResult[i] = ((wordsRcvr[i]) + intArg); + } + } else { + wordsRcvr = interpreterProxy->firstIndexableField(rcvrOop); + floatArg = interpreterProxy->floatValueOf(argOop); + floatsResult = interpreterProxy->firstIndexableField(resultOop); + for (i = 0; i <= (length - 1); i += 1) { + floatsResult[i] = ((wordsRcvr[i]) + floatArg); + } + } + } else { + if (isArgInt) { + floatsRcvr = interpreterProxy->firstIndexableField(rcvrOop); + intArg = (argOop >> 1); + floatsResult = interpreterProxy->firstIndexableField(resultOop); + for (i = 0; i <= (length - 1); i += 1) { + floatsResult[i] = ((floatsRcvr[i]) + intArg); + } + } else { + floatsRcvr = interpreterProxy->firstIndexableField(rcvrOop); + floatArg = interpreterProxy->floatValueOf(argOop); + floatsResult = interpreterProxy->firstIndexableField(resultOop); + for (i = 0; i <= (length - 1); i += 1) { + floatsResult[i] = ((floatsRcvr[i]) + floatArg); + } + } + } + interpreterProxy->pop(4); + interpreterProxy->push(resultOop); +} + +EXPORT(sqInt) primitiveAndByteArray(void) { + sqInt i; + sqInt length; + sqInt length1; + sqInt length2; + unsigned char *otherArray; + sqInt otherOop; + unsigned char *rcvrArray; + sqInt rcvrOop; + + otherOop = interpreterProxy->stackObjectValue(0); + rcvrOop = interpreterProxy->stackValue(1); + if (interpreterProxy->failed()) { + return null; + } + interpreterProxy->success(interpreterProxy->isBytes(rcvrOop)); + interpreterProxy->success(interpreterProxy->isBytes(otherOop)); + if (interpreterProxy->failed()) { + return null; + } + length1 = interpreterProxy->stSizeOf(rcvrOop); + length2 = interpreterProxy->stSizeOf(otherOop); + if (interpreterProxy->failed()) { + return null; + } + length = length1; + if (length1 > length2) { + length = length2; + } + otherArray = interpreterProxy->firstIndexableField(otherOop); + rcvrArray = interpreterProxy->firstIndexableField(rcvrOop); + for (i = 0; i <= (length - 1); i += 1) { + rcvrArray[i] = (((rcvrArray[i]) + (otherArray[i])) == 2); + } + interpreterProxy->pop(1); +} + +EXPORT(sqInt) primitiveDivArrays(void) { + sqInt argOop; + float *floatsArg; + float *floatsRcvr; + float *floatsResult; + sqInt i; + sqInt isArgWords; + sqInt isRcvrWords; + sqInt length; + sqInt rcvrOop; + sqInt resultOop; + unsigned int *wordsArg; + unsigned int *wordsRcvr; + unsigned int *wordsResult; + + resultOop = interpreterProxy->stackObjectValue(0); + argOop = interpreterProxy->stackObjectValue(1); + rcvrOop = interpreterProxy->stackObjectValue(2); + if (interpreterProxy->failed()) { + return null; + } + interpreterProxy->success(interpreterProxy->isWords(argOop)); + interpreterProxy->success(interpreterProxy->isWords(rcvrOop)); + interpreterProxy->success(interpreterProxy->isWords(resultOop)); + if (interpreterProxy->failed()) { + return null; + } + length = interpreterProxy->stSizeOf(argOop); + interpreterProxy->success(length == (interpreterProxy->stSizeOf(rcvrOop))); + interpreterProxy->success(length == (interpreterProxy->stSizeOf(resultOop))); + if (interpreterProxy->failed()) { + return null; + } + isArgWords = interpreterProxy->isMemberOf(argOop, "WordArray"); + isRcvrWords = interpreterProxy->isMemberOf(rcvrOop, "WordArray"); + if (isArgWords && isRcvrWords) { + if (!(interpreterProxy->isMemberOf(resultOop, "WordArray"))) { + interpreterProxy->primitiveFail(); + return null; + } + } else { + if (!(interpreterProxy->isMemberOf(resultOop, "KedamaFloatArray"))) { + interpreterProxy->primitiveFail(); + return null; + } + } + if (isRcvrWords) { + if (isArgWords) { + wordsRcvr = interpreterProxy->firstIndexableField(rcvrOop); + wordsArg = interpreterProxy->firstIndexableField(argOop); + wordsResult = interpreterProxy->firstIndexableField(resultOop); + for (i = 0; i <= (length - 1); i += 1) { + wordsResult[i] = ((wordsRcvr[i]) / (wordsArg[i])); + } + } else { + wordsRcvr = interpreterProxy->firstIndexableField(rcvrOop); + floatsArg = interpreterProxy->firstIndexableField(argOop); + floatsResult = interpreterProxy->firstIndexableField(resultOop); + for (i = 0; i <= (length - 1); i += 1) { + floatsResult[i] = ((wordsRcvr[i]) / (floatsArg[i])); + } + } + } else { + if (isArgWords) { + floatsRcvr = interpreterProxy->firstIndexableField(rcvrOop); + wordsArg = interpreterProxy->firstIndexableField(argOop); + floatsResult = interpreterProxy->firstIndexableField(resultOop); + for (i = 0; i <= (length - 1); i += 1) { + floatsResult[i] = ((floatsRcvr[i]) / (wordsArg[i])); + } + } else { + floatsRcvr = interpreterProxy->firstIndexableField(rcvrOop); + floatsArg = interpreterProxy->firstIndexableField(argOop); + floatsResult = interpreterProxy->firstIndexableField(resultOop); + for (i = 0; i <= (length - 1); i += 1) { + floatsResult[i] = ((floatsRcvr[i]) / (floatsArg[i])); + } + } + } + interpreterProxy->pop(4); + interpreterProxy->push(resultOop); +} + +EXPORT(sqInt) primitiveDivScalar(void) { + sqInt argOop; + double floatArg; + float *floatsRcvr; + float *floatsResult; + sqInt i; + int intArg; + sqInt isArgInt; + sqInt isRcvrWords; + sqInt length; + sqInt rcvrOop; + sqInt resultOop; + unsigned int *wordsRcvr; + unsigned int *wordsResult; + + resultOop = interpreterProxy->stackObjectValue(0); + argOop = interpreterProxy->stackValue(1); + rcvrOop = interpreterProxy->stackObjectValue(2); + if (interpreterProxy->failed()) { + return null; + } + interpreterProxy->success(interpreterProxy->isWords(rcvrOop)); + interpreterProxy->success(interpreterProxy->isWords(resultOop)); + if (interpreterProxy->failed()) { + return null; + } + length = interpreterProxy->stSizeOf(rcvrOop); + interpreterProxy->success(length == (interpreterProxy->stSizeOf(resultOop))); + if (interpreterProxy->failed()) { + return null; + } + isArgInt = (argOop & 1); + isRcvrWords = interpreterProxy->isMemberOf(rcvrOop, "WordArray"); + if (isArgInt && isRcvrWords) { + if (!(interpreterProxy->isMemberOf(resultOop, "WordArray"))) { + interpreterProxy->primitiveFail(); + return null; + } + } else { + if (!(interpreterProxy->isMemberOf(resultOop, "KedamaFloatArray"))) { + interpreterProxy->primitiveFail(); + return null; + } + } + if (isRcvrWords) { + if (isArgInt) { + wordsRcvr = interpreterProxy->firstIndexableField(rcvrOop); + intArg = (argOop >> 1); + wordsResult = interpreterProxy->firstIndexableField(resultOop); + for (i = 0; i <= (length - 1); i += 1) { + wordsResult[i] = ((wordsRcvr[i]) / intArg); + } + } else { + wordsRcvr = interpreterProxy->firstIndexableField(rcvrOop); + floatArg = interpreterProxy->floatValueOf(argOop); + floatsResult = interpreterProxy->firstIndexableField(resultOop); + for (i = 0; i <= (length - 1); i += 1) { + floatsResult[i] = ((wordsRcvr[i]) / floatArg); + } + } + } else { + if (isArgInt) { + floatsRcvr = interpreterProxy->firstIndexableField(rcvrOop); + intArg = (argOop >> 1); + floatsResult = interpreterProxy->firstIndexableField(resultOop); + for (i = 0; i <= (length - 1); i += 1) { + floatsResult[i] = ((floatsRcvr[i]) / intArg); + } + } else { + floatsRcvr = interpreterProxy->firstIndexableField(rcvrOop); + floatArg = interpreterProxy->floatValueOf(argOop); + floatsResult = interpreterProxy->firstIndexableField(resultOop); + for (i = 0; i <= (length - 1); i += 1) { + floatsResult[i] = ((floatsRcvr[i]) / floatArg); + } + } + } + interpreterProxy->pop(4); + interpreterProxy->push(resultOop); +} + +EXPORT(sqInt) primitiveEQArrays(void) { + sqInt argOop; + unsigned char *bytesResult; + float *floatsArg; + float *floatsRcvr; + sqInt i; + sqInt isArgWords; + sqInt isRcvrWords; + sqInt length; + sqInt rcvrOop; + sqInt resultOop; + unsigned int *wordsArg; + unsigned int *wordsRcvr; + + resultOop = interpreterProxy->stackObjectValue(0); + argOop = interpreterProxy->stackObjectValue(1); + rcvrOop = interpreterProxy->stackObjectValue(2); + if (interpreterProxy->failed()) { + return null; + } + interpreterProxy->success(interpreterProxy->isWords(argOop)); + interpreterProxy->success(interpreterProxy->isWords(rcvrOop)); + interpreterProxy->success(interpreterProxy->isBytes(resultOop)); + if (interpreterProxy->failed()) { + return null; + } + length = interpreterProxy->stSizeOf(argOop); + interpreterProxy->success(length == (interpreterProxy->stSizeOf(rcvrOop))); + interpreterProxy->success(length == (interpreterProxy->stSizeOf(resultOop))); + if (interpreterProxy->failed()) { + return null; + } + isArgWords = interpreterProxy->isMemberOf(argOop, "WordArray"); + isRcvrWords = interpreterProxy->isMemberOf(rcvrOop, "WordArray"); + if (isRcvrWords) { + if (isArgWords) { + wordsRcvr = interpreterProxy->firstIndexableField(rcvrOop); + wordsArg = interpreterProxy->firstIndexableField(argOop); + bytesResult = interpreterProxy->firstIndexableField(resultOop); + for (i = 0; i <= (length - 1); i += 1) { + bytesResult[i] = ((wordsRcvr[i]) == (wordsArg[i])); + } + } else { + wordsRcvr = interpreterProxy->firstIndexableField(rcvrOop); + floatsArg = interpreterProxy->firstIndexableField(argOop); + bytesResult = interpreterProxy->firstIndexableField(resultOop); + for (i = 0; i <= (length - 1); i += 1) { + bytesResult[i] = ((wordsRcvr[i]) == (floatsArg[i])); + } + } + } else { + if (isArgWords) { + floatsRcvr = interpreterProxy->firstIndexableField(rcvrOop); + wordsArg = interpreterProxy->firstIndexableField(argOop); + bytesResult = interpreterProxy->firstIndexableField(resultOop); + for (i = 0; i <= (length - 1); i += 1) { + bytesResult[i] = ((floatsRcvr[i]) == (wordsArg[i])); + } + } else { + floatsRcvr = interpreterProxy->firstIndexableField(rcvrOop); + floatsArg = interpreterProxy->firstIndexableField(argOop); + bytesResult = interpreterProxy->firstIndexableField(resultOop); + for (i = 0; i <= (length - 1); i += 1) { + bytesResult[i] = ((floatsRcvr[i]) == (floatsArg[i])); + } + } + } + interpreterProxy->pop(4); + interpreterProxy->push(resultOop); +} + +EXPORT(sqInt) primitiveEQScalar(void) { + sqInt argOop; + unsigned char *bytesResult; + double floatArg; + float *floatsRcvr; + sqInt i; + int intArg; + sqInt isArgInt; + sqInt isRcvrWords; + sqInt length; + sqInt rcvrOop; + sqInt resultOop; + unsigned int *wordsRcvr; + + resultOop = interpreterProxy->stackObjectValue(0); + argOop = interpreterProxy->stackValue(1); + rcvrOop = interpreterProxy->stackObjectValue(2); + if (interpreterProxy->failed()) { + return null; + } + interpreterProxy->success(interpreterProxy->isWords(rcvrOop)); + interpreterProxy->success(interpreterProxy->isBytes(resultOop)); + if (interpreterProxy->failed()) { + return null; + } + length = interpreterProxy->stSizeOf(rcvrOop); + interpreterProxy->success(length == (interpreterProxy->stSizeOf(resultOop))); + if (interpreterProxy->failed()) { + return null; + } + isArgInt = (argOop & 1); + isRcvrWords = interpreterProxy->isMemberOf(rcvrOop, "WordArray"); + if (isRcvrWords) { + if (isArgInt) { + wordsRcvr = interpreterProxy->firstIndexableField(rcvrOop); + intArg = (argOop >> 1); + bytesResult = interpreterProxy->firstIndexableField(resultOop); + for (i = 0; i <= (length - 1); i += 1) { + bytesResult[i] = ((wordsRcvr[i]) == intArg); + } + } else { + wordsRcvr = interpreterProxy->firstIndexableField(rcvrOop); + floatArg = interpreterProxy->floatValueOf(argOop); + bytesResult = interpreterProxy->firstIndexableField(resultOop); + for (i = 0; i <= (length - 1); i += 1) { + bytesResult[i] = ((wordsRcvr[i]) == floatArg); + } + } + } else { + if (isArgInt) { + floatsRcvr = interpreterProxy->firstIndexableField(rcvrOop); + intArg = (argOop >> 1); + bytesResult = interpreterProxy->firstIndexableField(resultOop);
@@ Diff output truncated at 50000 characters. @@
vm-dev@lists.squeakfoundation.org