void
xs_mod_init(xsMachine *the)
{
mod_t *mod;
UInt32 options = xsToInteger(xsArgc) > 0 && xsTypeOf(xsArg(0)) == xsIntegerType ? xsToInteger(xsArg(0)): 0;
FskErr ferr;
if ((ferr = FskMemPtrNew(sizeof(mod_t), (FskMemPtr *)&mod)) != kFskErrNone)
cryptThrowFSK(ferr);
if ((ferr = FskMemPtrNew(sizeof(bn_mod_t), (FskMemPtr *)&mod->mod_data)) != kFskErrNone) {
FskMemPtrDispose(mod);
cryptThrowFSK(ferr);
}
mod->_mod_code = &modFuncs;
xsResult = xsGet(xsThis, xsID("z")); /* must exist */
if (!xsIsInstanceOf(xsResult, xsGet(xsGet(xsGlobal, xsID("Arith")), xsID("z"))) || (mod->z = xsGetHostData(xsResult)) == NULL)
cryptThrow("kCryptTypeError");
xsResult = xsGet(xsThis, xsID("m")); /* must exist */
if (!xsIsInstanceOf(xsResult, mod->z->z_protoInteger) || (mod->m = xsGetHostData(xsResult)) == NULL)
nanError();
bn_mod_init(mod->mod_data, mod->z->z_data, mod->m->cint_data, options);
xsSetHostData(xsThis, mod);
}
void xs_gpio_init(xsMachine* the)
{
FskErr err;
FskGPIO gpio;
SInt32 pin = 0;
GPIOdirection dir;
char *pinName = NULL;
xsVars(1);
if ((gpio = xsGetHostData(xsThis)))
xsThrowDiagnosticIfFskErr(kFskErrOperationFailed, "Digital pin %d already initialized.", (int)gpio->pinNum);
dir = stringToDirection(the, xsToString(xsGet(xsThis, xsID("_direction"))), gpio);
xsVar(0) = xsGet(xsThis, xsID("_pin"));
if (xsStringType == xsTypeOf(xsVar(0)))
pinName = xsToString(xsVar(0));
else
pin = xsToInteger(xsVar(0));
err = FskGPIONew(&gpio, pin, pinName, dir);
xsThrowDiagnosticIfFskErr(err, "Digital pin %d initialization failed with error %s.", pin, FskInstrumentationGetErrorString(err));
xsSetHostData(xsThis, gpio);
}
void KprMessageScriptTargetTransform(void* it, KprMessage message, xsMachine* machine)
{
KprMessageScriptTarget self = it;
if (message->error) return;
xsBeginHostSandboxCode(machine, NULL);
{
xsVars(2);
{
xsTry {
void* data;
UInt32 size;
KprMessageGetResponseBody(message, &data, &size);
if (data && size) {
xsIndex id = xsID(self->name);
if (xsHas(xsGlobal, id)) {
xsVar(0) = xsGet(xsGlobal, id);
xsVar(1) = xsNewInstanceOf(xsChunkPrototype);
xsSetHostData(xsVar(1), data);
xsSetHostDestructor(xsVar(1) , NULL);
xsSet(xsVar(1), xsID("length"), xsInteger(size));
xsResult = xsCall1(xsVar(0), xsID("parse"), xsVar(1));
self->result = xsMarshall(xsResult);
}
}
}
xsCatch {
}
}
}
xsEndHostSandboxCode();
}
// image data
void KPR_canvasRenderingContext2D_cloneImageData(xsMachine *the)
{
FskCanvas2dContext ctx = xsGetHostData(xsThis);
FskCanvas2dImageData data = xsGetHostData(xsArg(0));
data = FskCanvas2dCloneImageData(ctx, data);
xsResult = xsNewInstanceOf(xsGet(xsGet(xsGlobal, xsID("KPR")), xsID("imageData")));
xsSetHostData(xsResult, data);
}
void
xs_console_load(xsMachine *the)
{
xsVars(1);
xsSetInteger(xsVar(0), CONSOLE_LOG_FILE);
xsSet(xsThis, xsID("LOGFILE"), xsVar(0));
xsSetInteger(xsVar(0), CONSOLE_XSBUG);
xsSet(xsThis, xsID("XSBUG"), xsVar(0));
}
// pixel manipulation
void KPR_canvasRenderingContext2D_createImageData(xsMachine *the)
{
FskCanvas2dContext ctx = xsGetHostData(xsThis);
xsNumberValue sw = xsToNumber(xsArg(0));
xsNumberValue sh = xsToNumber(xsArg(1));
FskCanvas2dImageData data = FskCanvas2dCreateImageData(ctx, sw, sh);
xsResult = xsNewInstanceOf(xsGet(xsGet(xsGlobal, xsID("KPR")), xsID("imageData")));
xsSetHostData(xsResult, data);
}
FskErr
FskSSLNew(void **fsslp, const char *host, int port, Boolean blocking, long flags, int priority)
{
FskSSL *fssl;
FskErr err;
if ((err = FskMemPtrNewClear(sizeof(FskSSL), (FskMemPtr*)(void*)&fssl)) != kFskErrNone)
return err;
if ((err = newSSLVM(&fssl->vm)) != kFskErrNone) {
FskMemPtrDispose(fssl);
return err;
}
xsBeginHost(fssl->vm->the);
xsTry {
const char *prStr;
xsVars(2);
/* construct the options */
xsVar(0) = xsNewInstanceOf(xsObjectPrototype);
if (blocking)
xsSet(xsVar(0), xsID("blocking"), xsTrue);
if (flags & kConnectFlagsSynchronous)
xsSet(xsVar(0), xsID("synchronous"), xsTrue);
switch (priority) {
default:
case kFskNetSocketLowestPriority: prStr = "lowest"; break;
case kFskNetSocketLowPriority: prStr = "low"; break;
case kFskNetSocketMediumPriority: prStr = "medium"; break;
case kFskNetSocketHighPriority: prStr = "high"; break;
case kFskNetSocketHighestPriority: prStr = "highest"; break;
}
(void)xsSet(xsVar(0), xsID("priority"), xsString((xsStringValue)prStr));
(void)xsSet(xsVar(0), xsID("raw"), xsTrue);
xsVar(1) = xsNew3(xsGet(xsGlobal, xsID("Stream")), xsID("Socket"), xsString((xsStringValue)host), xsInteger(port), xsVar(0));
fssl->socket = xsVar(1); xsRemember(fssl->socket);
xsVar(1) = xsNew0(xsGet(xsGlobal, xsID("FskSSL")), xsID("Session"));
fssl->ssl = xsVar(1); xsRemember(fssl->ssl);
} xsCatch {
if (xsHas(xsException, xsID("code")))
err = xsToInteger(xsGet(xsException, xsID("code")));
if (err == kFskErrNone)
err = kFskErrOperationFailed;
}
xsEndHost(fssl->vm->the);
if (err == kFskErrNone) {
if (fsslp != NULL)
*fsslp = fssl;
}
else {
disposeSSLVM(fssl->vm);
FskMemPtrDispose(fssl);
}
return err;
}
void xs_i2c_readBlock(xsMachine *the)
{
FskErr err;
xsI2C i2c = xsGetHostData(xsThis);
int argc = xsToInteger(xsArgc), i;
int format = 2;
SInt32 dataSize = xsToInteger(xsArg(0)), readCount;
UInt8 data[32];
xsThrowIfNULL(i2c);
DBG_I2C("xs_i2c_readBlock\n");
if ((dataSize > 32) || (dataSize <= 0))
xsThrowDiagnosticIfFskErr(kFskErrInvalidParameter, "I2C readBlock invalid size %d. %s", (int)dataSize, i2c->diagnosticID);
FskPinI2CSetAddress(i2c->pin, i2c->address);
err = FskPinI2CReadBytes(i2c->pin, dataSize, &readCount, data);
if (err) {
xsTraceDiagnostic("I2C readBlock failed with error %s %s.", FskInstrumentationGetErrorString(err), i2c->diagnosticID);
goto bail;
}
if (argc > 1) {
int t = xsTypeOf(xsArg(1));
if ((xsNumberType == t) || (t == xsIntegerType))
format = xsToInteger(xsArg(1));
else {
char *formatString = xsToString(xsArg(1));
if (0 == FskStrCompare(formatString, "Buffer"))
format = 2;
else if (0 == FskStrCompare(formatString, "Chunk"))
format = 0;
else if (0 == FskStrCompare(formatString, "Array"))
format = 1;
}
}
if (2 == format) {
xsResult = xsArrayBuffer(data, readCount);
}
else if (0 == format) {
xsResult = xsNew1(xsGlobal, xsID("Chunk"), xsInteger(readCount));
FskMemMove(xsGetHostData(xsResult), data, readCount);
}
else if (1 == format) {
xsResult = xsNew1(xsGlobal, xsID("Array"), xsInteger(readCount));
for (i = 0; i < readCount; i++)
xsSet(xsResult, i, xsInteger(data[i]));
}
bail:
if (err)
xsError(err);
}
void
xs_z_init(xsMachine *the)
{
z_t *z;
char *err;
if ((err = kcl_z_init(the, &z)) != NULL)
cryptThrow(err);
z->z_protoInteger = xsGet(xsGet(xsGlobal, xsID("Arith")), xsID("integer"));
xsSetHostData(xsThis, z);
}
void KPR_canvas_getContext(xsMachine *the)
{
KprCanvas self = xsGetHostData(xsThis);
if (self->cnv) {
FskCanvas2dContext ctx = FskCanvasGet2dContext(self->cnv);
xsResult = xsNewInstanceOf(xsGet(xsGet(xsGlobal, xsID("KPR")), xsID("canvasRenderingContext2D")));
xsSetHostData(xsResult, ctx);
xsSet(xsResult, xsID("canvas"), xsThis);
KprContentInvalidate((KprContent)self);
}
}
void KPR_host_clearAllBreakpoints(xsMachine* the)
{
#ifdef mxDebug
KprHost self = xsGetHostData(xsThis);
KprApplication application = (KprApplication)self->first;
xsBeginHost(application->the);
{
(void)xsCall0(xsGet(xsGet(xsGlobal, xsID("xs")), xsID("debug")), xsID("clearAllBreakpoints"));
}
xsEndHost(application->the);
#endif
}
void KPR_host_get_profiling(xsMachine* the)
{
KprHost self = xsGetHostData(xsThis);
KprApplication application = (KprApplication)self->first;
Boolean result = false;
xsBeginHost(application->the);
{
result = xsTest(xsCall0(xsGet(xsGlobal, xsID("xs")), xsID("isProfiling")));
}
xsEndHost(application->the);
xsResult = xsBoolean(result);
}
void KPR_canvasRenderingContext2D_measureText(xsMachine *the)
{
FskCanvas2dContext ctx = xsGetHostData(xsThis);
xsStringValue text = xsToString(xsArg(0));
UInt16* buffer;
if (kFskErrNone == FskTextUTF8ToUnicode16NE((unsigned char*)text, FskStrLen(text), &buffer, NULL)) {
xsNumberValue width = FskCanvas2dMeasureText(ctx, buffer);
FskMemPtrDispose(buffer);
xsResult = xsNewInstanceOf(xsGet(xsGet(xsGlobal, xsID("KPR")), xsID("textMetrics")));
xsSet(xsResult, xsID("width"), xsNumber(width));
}
}
void KPR_system_alert(xsMachine* the)
{
int argc = xsToInteger(xsArgc);
MSGBOXPARAMSW params;
xsStringValue string;
xsIntegerValue result;
xsVars(1);
params.cbSize = sizeof(params);
params.hwndOwner = NULL;
params.hInstance = FskMainGetHInstance();
params.lpszText = NULL;
params.lpszCaption = xsStringToWideString("Kinoma Code");
params.dwStyle = MB_ICONSTOP;
params.dwContextHelpId = 0;
params.lpfnMsgBoxCallback = NULL;
params.dwLanguageId = MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT);
if ((argc > 0) && xsTest(xsArg(0))) {
if (xsFindString(xsArg(0), xsID_type, &string)) {
if (!FskStrCompare(string, "about"))
params.dwStyle = MB_ICONINFORMATION;
else if (!FskStrCompare(string, "stop"))
params.dwStyle = MB_ICONSTOP;
else if (!FskStrCompare(string, "note"))
params.dwStyle = MB_ICONEXCLAMATION;
}
if (xsFindResult(xsArg(0), xsID_prompt)) {
xsVar(0) = xsResult;
}
if (xsFindResult(xsArg(0), xsID_info)) {
xsVar(0) = xsCall1(xsVar(0), xsID("concat"), xsString("\n\n"));
xsVar(0) = xsCall1(xsVar(0), xsID("concat"), xsResult);
}
params.lpszText = xsStringToWideString(xsToString(xsVar(0)));
if (xsFindResult(xsArg(0), xsID_buttons)) {
if (xsIsInstanceOf(xsResult, xsArrayPrototype)) {
xsIntegerValue c = xsToInteger(xsGet(xsResult, xsID_length));
if (c == 3)
params.dwStyle |= MB_YESNOCANCEL;
else if (c == 2)
params.dwStyle |= MB_OKCANCEL;
else
params.dwStyle |= MB_OK;
}
}
}
result = MessageBoxIndirectW(¶ms);
if (params.lpszText)
CoTaskMemFree((LPVOID *)params.lpszText);
if (params.lpszCaption)
CoTaskMemFree((LPVOID *)params.lpszCaption);
if ((argc > 1) && xsTest(xsArg(1)))
(void)xsCallFunction1(xsArg(1), xsNull, ((result == IDYES) || (result == IDOK)) ? xsTrue : (result == IDNO) ? xsFalse : xsUndefined);
}
void
xs_z_div2(xsMachine *the)
{
z_t *z = xsGetHostData(xsThis);
xsVars(2);
z_call3(the, z, kcl_z_div, &xsVar(1));
xsVar(0) = xsResult;
xsResult = xsNewInstanceOf(xsObjectPrototype);
xsSet(xsResult, xsID("q"), xsVar(0));
xsSet(xsResult, xsID("r"), xsVar(1));
}
void
xs_system_get_timezone(xsMachine *the)
{
struct timezone tz;
xsVars(1);
mc_gettimeofday(NULL, &tz);
xsResult = xsNewInstanceOf(xsObjectPrototype);
xsSetInteger(xsVar(0), tz.tz_minuteswest);
xsSet(xsResult, xsID("timedifference"), xsVar(0));
xsSetInteger(xsVar(0), tz.tz_dsttime);
xsSet(xsResult, xsID("dst"), xsVar(0));
}
void KPR_host_set_debugging(xsMachine* the)
{
#ifdef mxDebug
KprHost self = xsGetHostData(xsThis);
KprApplication application = (KprApplication)self->first;
Boolean flag = xsToBoolean(xsArg(0));
xsBeginHost(application->the);
{
(void)xsCall1(xsGet(xsGet(xsGlobal, xsID("xs")), xsID("debug")), xsID("setConnected"), xsBoolean(flag));
}
xsEndHost(application->the);
#endif
}
static void
usb_callback(xsMachine *the, void *closure)
{
char *buf = closure;
xsBeginHost(the);
xsVars(2);
xsGet(xsVar(0), xsGlobal, xsID("require"));
xsSetString(xsVar(1), "CLI");
xsCall(xsResult, xsVar(0), xsID("weak"), &xsVar(1), NULL);
xsSetString(xsVar(1), buf);
xsCall_noResult(xsResult, xsID("evaluate"), &xsVar(1), NULL);
xsEndHost(the);
}
void KPR_host_set_profiling(xsMachine* the)
{
KprHost self = xsGetHostData(xsThis);
KprApplication application = (KprApplication)self->first;
Boolean flag = xsToBoolean(xsArg(0));
xsBeginHost(application->the);
{
if (flag)
(void)xsCall0(xsGet(xsGlobal, xsID("xs")), xsID("startProfiling"));
else
(void)xsCall0(xsGet(xsGlobal, xsID("xs")), xsID("stopProfiling"));
}
xsEndHost(application->the);
}
void KPR_canvasLinearGradient_setStyle(xsMachine *the)
{
FskCanvas2dContext ctx = xsGetHostData(xsArg(0));
xsNumberValue x0 = xsToNumber(xsGet(xsThis, xsID("x0")));
xsNumberValue y0 = xsToNumber(xsGet(xsThis, xsID("y0")));
xsNumberValue x1 = xsToNumber(xsGet(xsThis, xsID("x1")));
xsNumberValue y1 = xsToNumber(xsGet(xsThis, xsID("y1")));
UInt32 c, i;
FskCanvas2dGradientStop stops[kCanvas2DMaxGradientStops];
xsVars(2);
xsVar(0) = xsGet(xsThis, xsID("stops"));
c = xsToInteger(xsGet(xsVar(0), xsID("length")));
if (c > kCanvas2DMaxGradientStops) c = kCanvas2DMaxGradientStops;
for (i = 0; i < c; i++) {
xsVar(1) = xsGetAt(xsVar(0), xsInteger(i));
stops[i].offset = xsToNumber(xsGet(xsVar(1), xsID("offset")));
xsVar(1) = xsGet(xsVar(1), xsID("color"));
if (!KprParseColor(the, xsToString(xsVar(1)), &(stops[i].color)))
return;
}
if (xsTest(xsArg(1)))
FskCanvas2dSetStrokeStyleLinearGradient(ctx, x0, y0, x1, y1, c, stops);
else
FskCanvas2dSetFillStyleLinearGradient(ctx, x0, y0, x1, y1, c, stops);
}
void KPR_host_setBreakpoint(xsMachine* the)
{
#ifdef mxDebug
KprHost self = xsGetHostData(xsThis);
KprApplication application = (KprApplication)self->first;
xsStringValue file = xsToString(xsArg(0));
xsStringValue line = xsToString(xsArg(1));
xsBeginHost(application->the);
{
(void)xsCall2(xsGet(xsGet(xsGlobal, xsID("xs")), xsID("debug")), xsID("setBreakpoint"), xsString(file), xsString(line));
}
xsEndHost(application->the);
#endif
}
void KPR_host_get_debugging(xsMachine* the)
{
#ifdef mxDebug
KprHost self = xsGetHostData(xsThis);
KprApplication application = (KprApplication)self->first;
Boolean result = false;
xsBeginHost(application->the);
{
result = xsTest(xsCall0(xsGet(xsGet(xsGlobal, xsID("xs")), xsID("debug")), xsID("getConnected")));
}
xsEndHost(application->the);
xsResult = xsBoolean(result);
#endif
}
xsBooleanValue fxFindModuleLoadAsDirectory(xsMachine* the, xsStringValue base, xsStringValue name, xsIndex* id)
{
char node[1024];
UInt32 nodeSize;
xsStringValue slash;
FskErr err;
FskFileMapping map = NULL;
xsBooleanValue result = 0;
xsStringValue path = NULL;
unsigned char* data;
FskInt64 size;
xsSlot slot;
nodeSize = sizeof(node);
FskStrNCopy(node, base, nodeSize);
slash = FskStrRChr(node, '/');
if (slash)
*slash = 0;
FskStrNCat(node, "/", nodeSize);
FskStrNCat(node, name, nodeSize);
if (FskStrTail(node, "/") != 0)
FskStrNCat(node, "/", nodeSize);
FskStrNCat(node, "package.json", nodeSize);
err = KprURLToPath(node, &path);
if (err == kFskErrNone) {
err = FskFileMap(path, &data, &size, 0, &map);
if (err == kFskErrNone) {
xsTry {
slot = xsNewInstanceOf(xsChunkPrototype);
xsSetHostData(slot, data);
xsSetHostDestructor(slot, NULL);
xsSet(slot, xsID("length"), xsInteger(size));
slot = xsCall1(xsGet(xsGlobal, xsID("JSON")), xsID("parse"), slot);
}
xsCatch {
slot = xsUndefined;
}
if (xsTest(slot)) {
slot = xsGet(slot, xsID("main"));
if (xsTest(slot)) {
FskStrNCopy(node, name, nodeSize);
if (FskStrTail(node, "/") != 0)
FskStrNCat(node, "/", nodeSize);
FskStrNCat(node, xsToString(slot), nodeSize);
if (fxFindModuleLoadAsFile(the, base, node, id))
result = 1;
}
}
}
void xs_i2c_init(xsMachine *the)
{
xsI2C i2c = NULL;
FskErr err;
int address;
int sdaPin = 0, clkPin = 0, sdaDev = 0, clkDev = 0;
FskPinI2C pin = NULL;
if (xsGetHostData(xsThis))
xsThrowDiagnosticIfFskErr(kFskErrBadState, "I2C pin already initialized (SDA pin %d).", i2c->sdaPin);
address = xsToInteger(xsGet(xsThis, xsID("address")));
xsResult = xsGet(xsThis, xsID("bus"));
if (xsUndefinedType == xsTypeOf(xsResult)) {
sdaPin = xsToInteger(xsGet(xsThis, xsID("sda")));
clkPin = xsToInteger(xsGet(xsThis, xsID("clock")));
err = FskPinI2CNew(&pin, sdaPin, clkPin, kFskPinI2CNoBus);
}
else {
sdaDev = xsToInteger(xsResult);
err = FskPinI2CNew(&pin, 0, 0, sdaDev);
}
xsThrowDiagnosticIfFskErr(err, "I2C open failed %s (SDA pin %d, CLK pin %d).", FskInstrumentationGetErrorString(err), sdaPin, clkPin);
err = FskMemPtrNewClear(sizeof(xsI2CRecord), &i2c);
if (err) {
FskPinI2CDispose(pin);
xsError(err);
}
xsSetHostData(xsThis, i2c);
i2c->pin = pin;
i2c->sdaPin = sdaPin;
i2c->clkPin = clkPin;
i2c->sdaDev = sdaDev;
i2c->clkDev = clkDev;
i2c->address = (UInt8)address;
i2c->bus = sdaDev;
#if SUPPORT_XS_DEBUG
if (0 != sdaPin)
snprintf(i2c->diagnosticID, sizeof(i2c->diagnosticID), "(Address 0x%x, SDA pin %d, CLK pin %d)", address, sdaPin, clkPin);
else
snprintf(i2c->diagnosticID, sizeof(i2c->diagnosticID), "(Address 0x%x, Bus %d)", address, sdaDev);
#endif
}
int main(int argc, char* argv[])
{
xsAllocation anAllocation = {
2048 * 1024, /* initialChunkSize */
512 * 1024, /* incrementalChunkSize */
1000 * 1000, /* initialHeapCount */
50 * 1000, /* incrementalHeapCount */
1024, /* stackCount */
8192, /* symbolCount */
1993 /* symbolModulo */
};
xsMachine* aMachine;
int argi;
int result = 1;
for (argi = 0; argi < argc; argi++){
result = strncmp(argv[argi], "--help", strlen("--help"));
if(!result) {
printHelp();
exit(0);
}
}
result = 1;
gxProperties = calloc(mxPropertyModulo, sizeof(xsSlot));
if (gxProperties) {
aMachine = xsNewMachine(&anAllocation, &kprconfigGrammar, NULL);
if (aMachine) {
xsBeginHost(aMachine);
{
xsTry {
xsResult = xsNewInstanceOf(xsArrayPrototype);
for (argi = 0; argi < argc; argi++)
xsSet(xsResult, argi, xsString(argv[argi]));
(void)xsCall1(xsGlobal, xsID("main"), xsResult);
result = 0;
}
xsCatch {
char* aMessage = xsToString(xsGet(xsException, xsID("message")));
fprintf(stderr, "### %s\n", aMessage);
}
}
xsEndHost(aMachine);
xsDeleteMachine(aMachine);
}
else
fprintf(stderr, "### Cannot allocate machine!\n");
}
void KPR_Message_patch(xsMachine* the)
{
xsResult = xsGet(xsGlobal, xsID("Message"));
xsNewHostProperty(xsResult, xsID("BUFFER"), xsString("BUFFER"), xsDontDelete | xsDontSet, xsDontScript | xsDontDelete | xsDontSet);
xsNewHostProperty(xsResult, xsID("CHUNK"), xsString("CHUNK"), xsDontDelete | xsDontSet, xsDontScript | xsDontDelete | xsDontSet);
xsNewHostProperty(xsResult, xsID("DOM"), xsString("DOM"), xsDontDelete | xsDontSet, xsDontScript | xsDontDelete | xsDontSet);
xsNewHostProperty(xsResult, xsID("JSON"), xsString("JSON"), xsDontDelete | xsDontSet, xsDontScript | xsDontDelete | xsDontSet);
xsNewHostProperty(xsResult, xsID("TEXT"), xsString("TEXT"), xsDontDelete | xsDontSet, xsDontScript | xsDontDelete | xsDontSet);
xsNewHostProperty(xsResult, xsID("URI"), xsNewHostFunction(KPR_Message_URI, 1), xsDefault, xsDontScript);
xsNewHostProperty(xsResult, xsID("cancelReferrer"), xsNewHostFunction(KPR_Message_cancelReferrer, 1), xsDefault, xsDontScript);
xsNewHostProperty(xsResult, xsID("notify"), xsNewHostFunction(KPR_Message_notify, 1), xsDefault, xsDontScript);
}
void KprPinsInvoke(KprService service, KprMessage message)
{
FskErr err = kFskErrNone;
KprPins self = gPins;
if (KprMessageContinue(message)) {
KprPinsListener listener = NULL;
KprPinsListenerFind(&listener, self, message);
if (listener) listener->useCount++;
if (!FskStrCompareWithLength(message->parts.path, "close", message->parts.pathLength)) {
if (listener) {
xsBeginHostSandboxCode(listener->the, NULL);
{
{
xsTry {
(void)xsCall0(xsAccess(listener->pins), xsID("close"));
}
xsCatch {
err = exceptionToFskErr(the);
}
}
while (listener->pollers)
KprPinsPollerDispose(listener->pollers);
}
xsEndHostSandboxCode();
KprPinsListenerDispose(listener, self);
listener = NULL;
}
else {
err = kFskErrNotFound;
}
}
else if (!FskStrCompareWithLength(message->parts.path, "configure", message->parts.pathLength)) {
void KprDebugMachineLoadView(KprDebugMachine self, int theView, char* thePath, int theLine)
{
FskErr err = kFskErrNone;
KprDebug debug = self->debug;
xsMachine* the = debug->the;
// FskFileInfo info;
// FskFileMapping map = NULL;
// FskDebugStr("%s: %d - %s:%d", __FUNCTION__, theView, thePath, theLine);
if (xsTypeOf(debug->behavior) == xsUndefinedType) goto bail;
xsVar(0) = xsAccess(debug->behavior);
if (xsFindResult(xsVar(0), xsID("onMachineFileChanged"))) {
(void)xsCallFunction5(xsResult, xsVar(0), xsString(self->address), xsInteger(theView), xsNull, thePath ? xsString(thePath) : xsNull, xsInteger(theLine));
}
// if (kFskErrNone == FskFileGetFileInfo(thePath, &info) && (kFskDirectoryItemIsFile == info.filetype)) {
// unsigned char *data;
// FskInt64 size;
// BAIL_IF_ERR(err = FskFileMap(thePath, &data, &size, 0, &map));
// xsVar(0) = xsAccess(debug->behavior);
//
// if (xsFindResult(xsVar(0), xsID("onMachineFileChanged"))) {
// (void)xsCallFunction5(xsResult, xsVar(0), xsString(self->address), xsInteger(theView), xsNull, xsString(thePath), xsInteger(theLine));
// }
// }
bail:
// FskFileDisposeMap(map);
xsThrowIfFskErr(err);
}
void
xs_system_set_timezone(xsMachine *the)
{
struct timezone tz;
xsVars(1);
xsGet(xsVar(0), xsArg(0), xsID("timedifference"));
tz.tz_minuteswest = xsToInteger(xsVar(0));
xsGet(xsVar(0), xsArg(0), xsID("dst"));
tz.tz_dsttime = xsToInteger(xsVar(0));
mc_settimeofday(NULL, &tz);
if (xsHas(xsArg(0), xsID("timezone"))) {
xsGet(xsVar(0), xsArg(0), xsID("timezone"));
mc_env_set_default("TIME_ZONE", xsToString(xsVar(0)));
}
}
// dashes
void KPR_canvasRenderingContext2D_setLineDash(xsMachine *the)
{
FskCanvas2dContext ctx = xsGetHostData(xsThis);
UInt32 len = xsToInteger(xsGet(xsArg(0), xsID("length"))); /* Array of even length */
double dash[kCanvas2DMaxDashCycles*2];
UInt32 i;
if (len) {
if (len > sizeof(dash) / sizeof(dash[0])) { /* If too large, truncate */
kprTraceDiagnostic(the, "dash length %u > %u is too long", (unsigned)len, sizeof(dash) / sizeof(dash[0]));
len = sizeof(dash) / sizeof(dash[0]);
}
i = (len & 1) ? (len * 2) : len; /* If odd, double the length to make it even */
for (i = 0; i < len; ++i)
dash[i] = xsToNumber(xsGetAt(xsArg(0), xsInteger(i))); /* Copy from xs Array to C array to interface to FskCanvas2dSetLineDash() */
if (len & 1) { /* If odd, ... */
for (i = 0; i < len; ++i)
dash[i + len] = dash[i]; /* ... replicate. Now it is even. */
}
else {
len /= 2; /* Len here is the number of cycles */
}
}
(void)FskCanvas2dSetLineDash(ctx, len, dash); /* Set the context line dash state */
return;
}
