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 KPR_canvasPattern_setStyle(xsMachine *the)
{
FskCanvas2dContext ctx = xsGetHostData(xsArg(0));
UInt32 repetition = kFskCanvas2dPatternRepeat;
FskConstBitmap bitmap = NULL;
Boolean owned = false;
xsVars(1);
xsVar(0) = xsGet(xsThis, xsID("repetition"));
if (xsTest(xsVar(0))) {
xsStringValue it = xsToString(xsVar(0));
if (!FskStrCompare(it, "no-repeat")) repetition = kFskCanvas2dPatternRepeatNone;
else if (!FskStrCompare(it, "repeat-x")) repetition = kFskCanvas2dPatternRepeatX;
else if (!FskStrCompare(it, "repeat-y")) repetition = kFskCanvas2dPatternRepeatY;
else if (!FskStrCompare(it, "repeat")) repetition = kFskCanvas2dPatternRepeat;
else xsError(kFskErrInvalidParameter);
}
xsVar(0) = xsGet(xsThis, xsID("image"));
if (xsIsInstanceOf(xsVar(0), xsGet(xsGet(xsGlobal, xsID_KPR), xsID_texture))) {
KprTexture texture = xsGetHostData(xsVar(0));
bitmap = KprTextureGetBitmap(texture, NULL, &owned);
}
else {
KprContent content = xsGetHostData(xsVar(0));
bitmap = (*content->dispatch->getBitmap)(content, NULL, &owned);
}
if (!bitmap)
xsError(kFskErrInvalidParameter);
if (xsTest(xsArg(1)))
FskCanvas2dSetStrokeStylePattern(ctx, repetition, bitmap);
else
FskCanvas2dSetFillStylePattern(ctx, repetition, bitmap);
if (!owned)
FskBitmapDispose((FskBitmap)bitmap);
}
void
xs_system_init_rng(xsMachine *the)
{
size_t sz;
void *data;
switch (xsTypeOf(xsArg(0))) {
case xsIntegerType:
case xsNumberType: {
unsigned long n = xsToNumber(xsArg(0));
data = &n;
sz = sizeof(long);
break;
}
case xsStringType: {
char *s = xsToString(xsArg(0));
data = s;
sz = strlen(s);
break;
}
default:
if (xsIsInstanceOf(xsArg(0), xsArrayBufferPrototype)) {
data = xsToArrayBuffer(xsArg(0));
sz = xsGetArrayBufferLength(xsArg(0));
}
else {
data = NULL;
sz = 0;
}
break;
}
mc_rng_init(data, sz);
}
void KPR_message_setRequestCertificate(xsMachine* the)
{
KprMessage self = xsGetHostData(xsThis);
FskSocketCertificateRecord* certs = NULL;
FskSocketCertificateRecord certsRecord = {
NULL, 0,
NULL,
NULL,
NULL, 0,
};
if (xsIsInstanceOf(xsArg(0), xsObjectPrototype)) {
certs = &certsRecord;
if (xsHas(xsArg(0), xsID("certificates"))) {
certs->certificates = (void*)xsToString(xsGet(xsArg(0), xsID("certificates")));
certs->certificatesSize = FskStrLen(certs->certificates);
}
if (xsHas(xsArg(0), xsID("policies"))) {
certs->policies = xsToString(xsGet(xsArg(0), xsID("policies")));
}
if (xsHas(xsArg(0), xsID("key"))) {
certs->key = (void*)xsToString(xsGet(xsArg(0), xsID("key")));
certs->keySize = FskStrLen(certs->key);
}
}
else { // compatibility
certs = &certsRecord;
if (xsTest(xsArg(0))) {
certs->certificates = xsGetHostData(xsArg(0));
certs->certificatesSize = xsToInteger(xsGet(xsArg(0), xsID_length));
}
if (xsTest(xsArg(1)))
certs->policies = xsToString(xsArg(1));
}
xsThrowIfFskErr(KprMessageSetRequestCertificate(self, certs));
}
static kcl_ecp_t *
__arith_get_ecp(xsMachine *the, xsSlot *slot, xsSlot *proto)
{
if (!xsIsInstanceOf(*slot, *proto))
kcl_throw_error(the, KCL_ERR_NAN);
return xsGetHostData(*slot);
}
void
getChunkData(xsMachine *the, xsSlot *chunk, void **datap, xsIntegerValue *sizep)
{
if (!xsIsInstanceOf(*chunk, xsChunkPrototype))
cryptThrow("kCryptTypeError");
*datap = xsGetHostData(*chunk);
*sizep = xsToInteger(xsGet(*chunk, xsID("length")));
}
// drawing images
void KPR_canvasRenderingContext2D_drawImage(xsMachine *the)
{
FskCanvas2dContext ctx = xsGetHostData(xsThis);
xsIntegerValue c = xsToInteger(xsArgc);
FskConstCanvas cnv = NULL;
FskBitmap bitmap = NULL;
Boolean owned = false;
xsVars(1);
if (xsIsInstanceOf(xsArg(0), xsGet(xsGet(xsGlobal, xsID_KPR), xsID_texture))) {
KprTexture texture = xsGetHostData(xsArg(0));
bitmap = KprTextureGetBitmap(texture, NULL, &owned);
}
else {
KprContent content = xsGetHostData(xsArg(0));
if (content->dispatch == &KprCanvasDispatchRecord)
cnv = ((KprCanvas)content)->cnv;
else
bitmap = (*content->dispatch->getBitmap)(content, NULL, &owned);
}
if (!cnv && !bitmap)
xsError(kFskErrInvalidParameter);
if (c > 8) {
xsNumberValue sx = xsToNumber(xsArg(1));
xsNumberValue sy = xsToNumber(xsArg(2));
xsNumberValue sw = xsToNumber(xsArg(3));
xsNumberValue sh = xsToNumber(xsArg(4));
xsNumberValue dx = xsToNumber(xsArg(5));
xsNumberValue dy = xsToNumber(xsArg(6));
xsNumberValue dw = xsToNumber(xsArg(7));
xsNumberValue dh = xsToNumber(xsArg(8));
if (cnv)
FskCanvas2dDrawSubScaledCanvas2d(ctx, cnv, sx, sy, sw, sh, dx, dy, dw, dh);
else
FskCanvas2dDrawSubScaledBitmap(ctx, bitmap, sx, sy, sw, sh, dx, dy, dw, dh);
}
else if (c > 4) {
xsNumberValue dx = xsToNumber(xsArg(1));
xsNumberValue dy = xsToNumber(xsArg(2));
xsNumberValue dw = xsToNumber(xsArg(3));
xsNumberValue dh = xsToNumber(xsArg(4));
if (cnv)
FskCanvas2dDrawScaledCanvas2d(ctx, cnv, dx, dy, dw, dh);
else
FskCanvas2dDrawScaledBitmap(ctx, bitmap, dx, dy, dw, dh);
}
else {
xsNumberValue dx = xsToNumber(xsArg(1));
xsNumberValue dy = xsToNumber(xsArg(2));
if (cnv)
FskCanvas2dDrawCanvas2d(ctx, cnv, dx, dy);
else
FskCanvas2dDrawBitmap(ctx, bitmap, dx, dy);
}
if (!owned)
FskBitmapDispose(bitmap);
}
void KPR_debug_set_behavior(xsMachine *the)
{
KprDebug self = xsGetHostData(xsThis);
xsForget(self->behavior);
if (xsTest(xsArg(0))) {
if (xsIsInstanceOf(xsArg(0), xsObjectPrototype)) {
self->behavior = xsArg(0);
xsRemember(self->behavior);
}
}
}
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 Zeroconf_set_behavior(xsMachine *the)
{
KprZeroconfCommon self = xsGetHostData(xsThis);
xsForget(self->behavior);
self->behavior = xsUndefined;
if (xsTest(xsArg(0))) {
if (xsIsInstanceOf(xsArg(0), xsObjectPrototype)) {
self->behavior = xsArg(0);
xsRemember(self->behavior);
}
}
}
void
getInputData(xsMachine *the, xsSlot *input, void **datap, xsIntegerValue *sizep)
{
if (xsIsInstanceOf(*input, xsChunkPrototype)) {
*datap = xsGetHostData(*input);
*sizep = xsToInteger(xsGet(*input, xsID("length")));
}
else if (xsTypeOf(*input) == xsStringType) {
*datap = xsToString(*input);
*sizep = FskStrLen(*datap);
}
else
cryptThrow("kCryptTypeError");
}
void xs_infoset_parse(xsMachine* the)
{
xsVars(COUNT);
xsVar(ATTRIBUTE_PROTOTYPE) = xsGet(xsThis, xsID_attribute);
xsVar(CDATA_PROTOTYPE) = xsGet(xsThis, xsID_cdata);
xsVar(COMMENT_PROTOTYPE) = xsGet(xsThis, xsID_comment);
xsVar(DOCUMENT_PROTOTYPE) = xsGet(xsThis, xsID_document);
xsVar(ELEMENT_PROTOTYPE) = xsGet(xsThis, xsID_element);
if ((xsToInteger(xsArgc) < 1) || (!xsIsInstanceOf(xsArg(0), xsVar(DOCUMENT_PROTOTYPE))))
xsTypeError("document is no infoset.document");
xsVar(RULE_SET) = xsGet(xsGet(xsGlobal, xsID_Grammar), xsID_ruleSet);
xsVar(CHILD) = xsGet(xsArg(0), xsID_element);
parseElement(the);
}
void Zeroconf_Advertisement(xsMachine *the)
{
KprZeroconfAdvertisement self = NULL;
char* serviceType = xsToString(xsArg(0));
char* servicName = xsToString(xsArg(1));
int servicPort = xsToInteger(xsArg(2));
xsIntegerValue c = xsToInteger(xsArgc);
FskAssociativeArray txt = NULL;
if ((c > 3) && xsIsInstanceOf(xsArg(3), xsObjectPrototype)) {
xsVars(2);
xsEnterSandbox();
fxPush(xsArg(3));
fxRunForIn(the);
txt = FskAssociativeArrayNew();
for (xsVar(0) = fxPop(); xsTypeOf(xsVar(0)) != xsNullType; xsVar(0) = fxPop()) {
if (xsTypeOf(xsVar(0)) == xsStringType) {
xsVar(1) = xsGetAt(xsArg(3), xsVar(0));
if (!xsIsInstanceOf(xsVar(1), xsObjectPrototype)) {
char* name = xsToString(xsVar(0));
char* value = xsToString(xsVar(1));
FskAssociativeArrayElementSetString(txt, name, value);
}
}
}
xsLeaveSandbox();
}
xsThrowIfFskErr(KprZeroconfAdvertisementNew(&self, serviceType, servicName, servicPort, txt));
xsSetHostData(xsResult, self);
self->registeredCallback = Zeroconf_advertisement_registeredCallback;
self->unregisteredCallback = Zeroconf_advertisement_unregisteredCallback;
self->the = the;
self->slot = xsResult;
self->code = the->code;
self->behavior = xsUndefined;
xsRemember(self->slot);
}
void KPR_canvasRenderingContext2D_isPointInPathStroke(xsMachine *the)
{
FskCanvas2dContext ctx = xsGetHostData(xsThis);
FskCanvas2dPath path = NULL;
xsNumberValue x, y;
if (xsIsInstanceOf(xsArg(0), xsGet(xsGet(xsGlobal, xsID_KPR), xsID("path2D")))) { /* ctx.isPointInPathStroke(path, x, y) */
path = xsGetHostData(xsArg(0));
x = xsToNumber(xsArg(1));
y = xsToNumber(xsArg(2));
} else { /* ctx.isPointInPathStroke(x, y) */
x = xsToNumber(xsArg(0));
y = xsToNumber(xsArg(1));
}
xsResult = xsBoolean(FskCanvas2dIsPointInPathStroke(ctx, path, x, y));
}
void KPR_canvasRenderingContext2D_clip(xsMachine *the)
{
FskCanvas2dContext ctx = xsGetHostData(xsThis);
FskCanvas2dPath path = NULL;
SInt32 fillRule = kFskCanvas2dFillRuleNonZero;
int numArgs = xsToInteger(xsArgc);
if (numArgs > 0) { /* ctx.clip(), when numArgs==0 */
if (xsIsInstanceOf(xsArg(0), xsGet(xsGet(xsGlobal, xsID_KPR), xsID("path2D")))) { /* ctx.clip(path) */
path = xsGetHostData(xsArg(0));
if (numArgs > 1) fillRule = GetFillRule(xsToString(xsArg(1))); /* ctx.clip(path, fillRule) */
} else { fillRule = GetFillRule(xsToString(xsArg(0))); /* ctx.clip(fillRule) */
}
}
FskCanvas2dPathClip(ctx, path, fillRule);
}
void KPR_Debug(xsMachine *the)
{
KprDebug self = NULL;
UInt32 port = 0;
xsEnterSandbox();
if (xsIsInstanceOf(xsArg(0), xsObjectPrototype)) {
(void)(xsFindInteger(xsArg(0), xsID_port, &port));
// add behavior?
}
xsLeaveSandbox();
xsThrowIfFskErr(KprDebugNew(&self, port));
xsSetHostData(xsResult, self);
self->the = the;
self->slot = xsResult;
self->code = the->code;
self->behavior = xsUndefined;
xsRemember(self->slot);
return;
}
void KPR_canvasRenderingContext2D_isPointInPath(xsMachine *the)
{
FskCanvas2dContext ctx = xsGetHostData(xsThis);
FskCanvas2dPath path = NULL;
SInt32 fillRule = kFskCanvas2dFillRuleNonZero;
int numArgs = xsToInteger(xsArgc);
xsNumberValue x, y;
if (xsIsInstanceOf(xsArg(0), xsGet(xsGet(xsGlobal, xsID_KPR), xsID("path2D")))) { /* ctx.isPointInPath(path, x, y) */
path = xsGetHostData(xsArg(0));
x = xsToNumber(xsArg(1));
y = xsToNumber(xsArg(2));
if (numArgs > 3) fillRule = GetFillRule(xsToString(xsArg(3))); /* ctx.isPointInPath(path, x, y, fillRule) */
} else { /* ctx.isPointInPath(x, y) */
x = xsToNumber(xsArg(0));
y = xsToNumber(xsArg(1));
if (numArgs > 2) fillRule = GetFillRule(xsToString(xsArg(2))); /* ctx.isPointInPath(x, y, fillRule) */
}
xsResult = xsBoolean(FskCanvas2dIsPointInPathFill(ctx, path, x, y, fillRule));
}
void KPR_Path2D(xsMachine *the)
{
FskCanvas2dPath path = NULL;
FskErr err;
bailIfError(FskCanvas2dPathNew(&path));
if (xsToInteger(xsArgc) > 0) {
if (xsIsInstanceOf(xsArg(0), xsGet(xsGet(xsGlobal, xsID_KPR), xsID("path2D")))) {
FskCanvas2dPath fromPath = xsGetHostData(xsArg(0));
BAIL_IF_NULL(fromPath, err, kFskErrNotFound);
bailIfError(FskCanvas2dPathAppendPath(NULL, path, fromPath, NULL));
}
else {
xsStringValue str = xsToString(xsArg(0));
(void)FskCanvas2dPathAppendPathString(NULL, path, str);
}
}
xsSetHostData(xsResult, path);
bail:
if (err) FskCanvas2dPathDispose(path);
return;
}
unsigned char *writeOne(xsMachine *the, xsI2C i2c, xsSlot *slot, unsigned char *bufPtr, unsigned char *bufEnd)
{
xsType argType = xsTypeOf(*slot);
switch (argType) {
case xsIntegerType:
case xsNumberType: {
SInt32 value = xsToInteger(*slot);
if ((value < 0) || (value > 255))
xsThrowDiagnosticIfFskErr(kFskErrInvalidParameter, "I2C write invalid character value %s.", i2c->diagnosticID);
if ((bufEnd - bufPtr) < 1)
xsThrowDiagnosticIfFskErr(kFskErrInvalidParameter, "I2C write 32 byte write max %s.", i2c->diagnosticID);
*bufPtr++ = (char)value;
}
break;
case xsStringType: {
char *text = xsToString(*slot);
SInt32 dataSize = FskStrLen(text);
if ((bufEnd - bufPtr) < dataSize)
xsThrowDiagnosticIfFskErr(kFskErrInvalidParameter, "I2C write 32 byte write max %s.", i2c->diagnosticID);
FskMemMove(bufPtr, text, dataSize);
bufPtr += dataSize;
}
break;
case xsReferenceType:
if (xsIsInstanceOf(*slot, xsArrayBufferPrototype)) {
char *data = xsToArrayBuffer(*slot);
SInt32 dataSize = xsGetArrayBufferLength(*slot);
if ((bufEnd - bufPtr) < dataSize)
xsThrowDiagnosticIfFskErr(kFskErrInvalidParameter, "I2C write 32 byte write max %s.", i2c->diagnosticID);
FskMemMove(bufPtr, data, dataSize);
bufPtr += dataSize;
}
else if (xsIsInstanceOf(*slot, xsChunkPrototype)) {
char *data = xsGetHostData(*slot);
SInt32 dataSize = xsToInteger(xsGet(*slot, xsID("length")));
if ((bufEnd - bufPtr) < dataSize)
xsThrowDiagnosticIfFskErr(kFskErrInvalidParameter, "I2C write 32 byte write max %s.", i2c->diagnosticID);
FskMemMove(bufPtr, data, dataSize);
bufPtr += dataSize;
}
else if (xsIsInstanceOf(*slot, xsArrayPrototype)) {
SInt32 length = xsToInteger(xsGet(*slot, xsID("length"))), j;
if ((bufEnd - bufPtr) < length)
xsThrowDiagnosticIfFskErr(kFskErrInvalidParameter, "I2C write 32 byte write max %s.", i2c->diagnosticID);
for (j = 0; j < length; j++) {
xsSlot item = xsGet(*slot, j);
bufPtr = writeOne(the, i2c, &item, bufPtr, bufEnd);
}
}
else
xsThrowDiagnosticIfFskErr(kFskErrInvalidParameter, "I2C unsupported argument type passed to write %s.", i2c->diagnosticID);
break;
default:
xsThrowDiagnosticIfFskErr(kFskErrInvalidParameter, "I2C unsupported argument type passed to write %s.", i2c->diagnosticID);
break;
}
return bufPtr;
}
void
xs_console_log(xsMachine* the)
{
xsIntegerValue c = xsToInteger(xsArgc), i;
xsBooleanValue space = 0;
xsBooleanValue comma = 0;
xsBooleanValue nonl = 0;
int options = 0;
FILE *console_out = stdout;
xsVars(4);
console_log_depth++;
for (i = 0; i < c; i++) {
if (space && !nonl)
CONSOLE_OUT("\n");
else
space = 1;
switch (xsTypeOf(xsArg(i))) {
case xsUndefinedType:
case xsNullType:
case xsBooleanType:
case xsIntegerType:
case xsNumberType:
CONSOLE_OUT("%s", xsToString(xsArg(i)));
break;
case xsSymbolType:
xsResult = xsCall1(xsGlobal, xsID("String"), xsArg(i));
CONSOLE_OUT("%s", xsToString(xsResult));
break;
case xsStringType:
case xsStringXType:
if (i == 0 || options) {
const char *opt = xsToString(xsArg(i));
options = 0;
if (strcmp(opt, "-n") == 0) {
nonl++;
options++;
}
else if (strcmp(opt, "-stderr") == 0) {
console_out = stderr;
options++;
}
else if (strcmp(opt, "-stdout") == 0) {
console_out = stdout;
options++;
}
else if (strncmp(opt, "-", 1) == 0) /* end of the option args */
break;
if (options) {
space = 0;
break;
}
}
if (console_log_depth == 1)
CONSOLE_OUT("%s", xsToString(xsArg(i)));
else
CONSOLE_OUT("\"%s\"", xsToString(xsArg(i)));
break;
case xsReferenceType:
if (xsIsInstanceOf(xsArg(i), xsFunctionPrototype)) {
CONSOLE_OUT("function(...) { ... }");
}
else if (xsIsInstanceOf(xsArg(i), xsArrayPrototype)) {
xsGet(xsVar(0), xsArg(i), xsID("length"));
xsIntegerValue length = xsToInteger(xsVar(0)), index;
CONSOLE_OUT("[\n");
for (index = 0; index < length; index++) {
xsGet(xsVar(1), xsArg(i), (xsIndex)index);
if (comma)
CONSOLE_OUT(",\n");
else
comma = 1;
indent(the, console_out, 0);
fxPush(xsVar(1));
fxPushCount(the, 1);
fxPush(xsThis);
fxPush(xsFunction);
fxCall(the);
}
CONSOLE_OUT("\n"); indent(the, console_out, -1); CONSOLE_OUT("]");
}
else {
CONSOLE_OUT( "{\n");
xsVar(0) = xsEnumerate(xsArg(i));
for (;;) {
xsVar(1) = xsCall0(xsVar(0), xsID("next"));
xsGet(xsVar(2), xsVar(1), xsID("done"));
if (xsTest(xsVar(2)))
break;
xsGet(xsVar(2), xsVar(1), xsID("value"));
xsGetAt(xsVar(3), xsArg(i), xsVar(2));
if (comma)
CONSOLE_OUT( ",\n");
else
comma = 1;
indent(the, console_out, 0); CONSOLE_OUT("%s: ", xsToString(xsVar(2)));
fxPush(xsVar(3));
fxPushCount(the, 1);
fxPush(xsThis);
fxPush(xsFunction);
fxCall(the);
}
CONSOLE_OUT("\n"); indent(the, console_out, -1); CONSOLE_OUT("}");
}
break;
}
}
console_log_depth--;
if (!console_log_depth && !nonl)
CONSOLE_OUT("\n");
}
void
xs_i2c_write(xsMachine *the)
{
wm_i2c *i2c = xsGetHostData(xsThis);
int ac = xsToInteger(xsArgc);
int reg;
uint8_t *data;
int datasize;
uint8_t num;
uint8_t *allocated = NULL;
if (ac < 2)
return;
#if I2C_SUPPORT_CONCURRENCY
if (i2c->slave_addr != i2c_current_slave_addr)
i2c_config(i2c);
#endif
switch (xsTypeOf(xsArg(0))) {
case xsNumberType:
case xsIntegerType:
reg = xsToInteger(xsArg(0));
break;
default:
reg = -1;
break;
}
switch (xsTypeOf(xsArg(1))) {
case xsIntegerType:
case xsNumberType:
num = (uint8_t)xsToInteger(xsArg(1));
data = #
datasize = 1;
break;
case xsReferenceType:
if (xsIsInstanceOf(xsArg(1), xsArrayPrototype)) {
int i;
xsVars(1);
xsGet(xsVar(0), xsArg(1), xsID("length"));
datasize = xsToInteger(xsVar(0));
if ((allocated = mc_malloc(datasize)) == NULL)
mc_xs_throw(the, "no mem");
for (i = 0; i < datasize; i++) {
xsGet(xsVar(0), xsArg(1), (xsIndex)i);
allocated[i] = (uint8_t)xsToInteger(xsVar(0));
}
data = allocated;
}
else {
datasize = xsGetArrayBufferLength(xsArg(1));
data = xsToArrayBuffer(xsArg(1));
}
break;
default:
mc_xs_throw(the, "args");
return; /* NOT REACHED */
}
if (ac > 2) {
int n = xsToInteger(xsArg(2));
if (datasize > n)
datasize = n;
}
if (!i2c_wait_for_ack(i2c, i2c->txtout))
mc_log_debug("I2C: write: no ack!\n");
if (!i2c_write_bytes(i2c, reg, data, datasize))
goto bail;
(void)i2c_wait_tx_fifo(i2c); /* send the stop sequence */
if (allocated != NULL)
mc_free(allocated);
xsSetTrue(xsResult);
bail:
return;
}
void xs_infoset_scan(xsMachine* the)
{
int c = xsToInteger(xsArgc);
Scanner scanner;
Scanner* self;
xsVars(COUNT);
xsTry {
self = &scanner;
c_memset(self, 0, sizeof(Scanner));
if (c < 1)
xsSyntaxError("no buffer");
self->expat = XML_ParserCreate(NULL);
xsThrowIfNULL(self->expat);
XML_SetUserData(self->expat, self);
XML_SetElementHandler(self->expat, scanStartTag, scanStopTag);
XML_SetCdataSectionHandler(self->expat, scanStartCdata, scanStopCdata);
XML_SetCharacterDataHandler(self->expat, scanCharacter);
XML_SetCommentHandler(self->expat, scanComment);
XML_SetProcessingInstructionHandler(self->expat, scanProcessingInstruction);
XML_SetUnknownEncodingHandler(self->expat, scanUnknownEncoding, NULL);
XML_SetSkippedEntityHandler(self->expat, scanEntity);
self->result = 1;
self->textBuffer = c_malloc(8192);
xsThrowIfNULL(self->textBuffer);
self->textSize = 8192;
self->the = the;
xsVar(ATTRIBUTE_PROTOTYPE) = xsGet(xsThis, xsID_attribute);
xsVar(CDATA_PROTOTYPE) = xsGet(xsThis, xsID_cdata);
xsVar(COMMENT_PROTOTYPE) = xsGet(xsThis, xsID_comment);
xsVar(DOCUMENT_PROTOTYPE) = xsGet(xsThis, xsID_document);
xsVar(ELEMENT_PROTOTYPE) = xsGet(xsThis, xsID_element);
xsVar(NO_NAMESPACE) = xsString("");
xsVar(NO_PREFIX) = xsString("");
xsVar(PATH) = (c > 1) ? xsArg(1) : xsUndefined;
xsVar(PI_PROTOTYPE) = xsGet(xsThis, xsID_pi);
xsVar(XML_NAMESPACE) = xsGet(xsThis, xsID_xmlnsNamespace);
xsVar(XML_PREFIX) = xsGet(xsThis, xsID_xmlnsPrefix);
xsResult = xsNewInstanceOf(xsVar(DOCUMENT_PROTOTYPE));
xsSet(xsResult, xsID_encoding, xsString("UTF-8"));
xsSet(xsResult, xsID_version, xsString("1.0"));
xsVar(CHILDREN) = xsNewInstanceOf(xsArrayPrototype);
xsArrayCacheBegin(xsVar(CHILDREN));
xsSet(xsResult, xsID_children, xsVar(CHILDREN));
xsSet(xsResult, xsID_parent, xsNull);
xsSet(xsResult, xsID_xmlnsAttributes, xsNull);
if (xsIsInstanceOf(xsArg(0), xsChunkPrototype)) {
xsStringValue buffer = xsGetHostData(xsArg(0));
xsIntegerValue size = xsToInteger(xsGet(xsArg(0), xsID_length));
self->result = XML_Parse(self->expat, (const char *)buffer, size, 1);
}
else if (xsTypeOf(xsArg(0)) == xsStringType) {
xsStringValue string = xsToString(xsArg(0));
xsIntegerValue stringOffset = 0;
xsIntegerValue stringSize = c_strlen(string);
while (self->result && (stringOffset < stringSize)) {
xsIntegerValue size = stringSize - stringOffset;
xsStringValue buffer = (char *)XML_GetBuffer(self->expat, 1024);
xsThrowIfNULL(buffer);
if (size > 1024)
size = 1024;
c_memcpy(buffer, string + stringOffset, size);
self->result = XML_ParseBuffer(self->expat, size, (size < 1024) ? 1 : 0);
stringOffset += size;
string = xsToString(xsArg(0)); // @@ gc
}
}
else {
xsStreamGetter* streamGetter = xsGetHostData(xsArg(0));
while (self->result) {
xsIntegerValue i;
xsStringValue p, buffer = (char *)XML_GetBuffer(self->expat, 1024);
xsThrowIfNULL(buffer);
for (i = 0, p = buffer; i < 1024; i++, p++) {
int c = (*(streamGetter->getter))(streamGetter->stream);
if (c == C_EOF)
break;
*p = (char)c;
}
self->result = XML_ParseBuffer(self->expat, i, (i < 1024) ? 1 : 0);
if (i < 1024)
break;
}
}
xsDelete(xsResult, xsID_xmlnsAttributes);
xsDelete(xsResult, xsID_parent);
xsArrayCacheEnd(xsVar(CHILDREN));
if (!self->result) {
xsVar(LINE) = xsInteger(XML_GetCurrentLineNumber(self->expat));
xsVar(VALUE) = xsString((char*)XML_ErrorString(XML_GetErrorCode(self->expat)));
if (xsHas(xsThis, xsID_reportError))
xsCall3_noResult(xsThis, xsID_reportError, xsVar(PATH), xsVar(LINE), xsVar(VALUE));
xsThrow(xsNewInstanceOf(xsSyntaxErrorPrototype));
}
c_free(self->textBuffer);
self->textBuffer = NULL;
XML_ParserFree(self->expat);
self->expat = NULL;
}
xsCatch {
if (self->textBuffer)
c_free(self->textBuffer);
if (self->expat)
XML_ParserFree(self->expat);
}
}
