// returns 0 on success and a (negative) error number on failure
int socketSendData(JsNetwork *net, JsVar *connection, int sckt, JsVar **sendData) {
char *buf = alloca(net->chunkSize); // allocate on stack
assert(!jsvIsEmptyString(*sendData));
size_t bufLen = httpStringGet(*sendData, buf, net->chunkSize);
int num = netSend(net, sckt, buf, bufLen);
if (num < 0) return num; // an error occurred
// Now cut what we managed to send off the beginning of sendData
if (num > 0) {
JsVar *newSendData = 0;
if (num < (int)jsvGetStringLength(*sendData)) {
// we didn't send all of it... cut out what we did send
newSendData = jsvNewFromStringVar(*sendData, (size_t)num, JSVAPPENDSTRINGVAR_MAXLENGTH);
} else {
// we sent all of it! Issue a drain event, unless we want to close, then we shouldn't
// callback for more data
bool wantClose = jsvGetBoolAndUnLock(jsvObjectGetChild(connection,HTTP_NAME_CLOSE,0));
if (!wantClose) {
jsiQueueObjectCallbacks(connection, HTTP_NAME_ON_DRAIN, &connection, 1);
}
newSendData = jsvNewFromEmptyString();
}
jsvUnLock(*sendData);
*sendData = newSendData;
}
return 0;
}
/*JSON{
"type" : "method",
"class" : "String",
"name" : "split",
"generate" : "jswrap_string_split",
"params" : [
["separator","JsVar","The start character index"]
],
"return" : ["JsVar","Part of this string from start for len characters"]
}
Return an array made by splitting this string up by the separator. eg. ```'1,2,3'.split(',')==[1,2,3]```
*/
JsVar *jswrap_string_split(JsVar *parent, JsVar *split) {
JsVar *array = jsvNewWithFlags(JSV_ARRAY);
if (!array) return 0; // out of memory
if (jsvIsUndefined(split)) {
jsvArrayPush(array, parent);
return array;
}
split = jsvAsString(split, false);
int idx, last = 0;
int splitlen = jsvIsUndefined(split) ? 0 : (int)jsvGetStringLength(split);
int l = (int)jsvGetStringLength(parent) + 1 - splitlen;
for (idx=0;idx<=l;idx++) {
if (splitlen==0 && idx==0) continue; // special case for where split string is ""
if (idx==l || splitlen==0 || jsvCompareString(parent, split, (size_t)idx, 0, true)==0) {
if (idx==l) {
idx=l+splitlen; // if the last element, do to the end of the string
if (splitlen==0) break;
}
JsVar *part = jsvNewFromStringVar(parent, (size_t)last, (size_t)(idx-last));
if (!part) break; // out of memory
jsvArrayPush(array, part);
jsvUnLock(part);
last = idx+splitlen;
}
}
jsvUnLock(split);
return array;
}
/*JSON{
"type" : "method",
"class" : "String",
"name" : "trim",
"generate" : "jswrap_string_trim",
"return" : ["JsVar","A String with Whitespace removed from the beginning and end"],
"return_object" : "String"
}
Return a new string with any whitespace (tabs, space, form feed, newline,
carriage return, etc) removed from the beginning and end.
*/
JsVar *jswrap_string_trim(JsVar *parent) {
JsVar *s = jsvAsString(parent);
if (!s) return s;
unsigned int start = 0;
int end = -1;
// work out beginning and end
JsvStringIterator it;
jsvStringIteratorNew(&it, s, 0);
while (jsvStringIteratorHasChar(&it)) {
bool ws = isWhitespace(jsvStringIteratorGetChar(&it));
if (!ws) {
if (end<0) start = (unsigned int)jsvStringIteratorGetIndex(&it);
end = (int)jsvStringIteratorGetIndex(&it); // last
}
jsvStringIteratorNext(&it);
}
jsvStringIteratorFree(&it);
// work out length
unsigned int len = 0;
if (end>=(int)start) len = 1+(unsigned int)end-start;
JsVar *res = jsvNewFromStringVar(s, start, len);
jsvUnLock(s);
return res;
}
bool socketSendData(JsNetwork *net, JsVar *connection, int sckt, JsVar **sendData) {
char buf[64];
int a=1;
if (!jsvIsEmptyString(*sendData)) {
size_t bufLen = httpStringGet(*sendData, buf, sizeof(buf));
a = net->send(net, sckt, buf, bufLen);
// Now cut what we managed to send off the beginning of sendData
if (a>0) {
JsVar *newSendData = 0;
if (a < (int)jsvGetStringLength(*sendData)) {
// we didn't send all of it... cut out what we did send
newSendData = jsvNewFromStringVar(*sendData, (size_t)a, JSVAPPENDSTRINGVAR_MAXLENGTH);
} else {
// we sent all of it! Issue a drain event
jsiQueueObjectCallbacks(connection, "#ondrain", &connection, 1);
}
jsvUnLock(*sendData);
*sendData = newSendData;
}
}
if (a<0) { // could just be busy which is ok
jsError("Socket error %d while sending", a);
return false;
}
return true;
}
static JsVar *matchfound(JsvStringIterator *txtIt, matchInfo info) {
JsVar *rmatch = jsvNewEmptyArray();
size_t endIndex = jsvStringIteratorGetIndex(txtIt);
JsVar *matchStr = jsvNewFromStringVar(info.sourceStr, info.startIndex, endIndex-info.startIndex);
jsvSetArrayItem(rmatch, 0, matchStr);
jsvUnLock(matchStr);
int i;
for (i=0;i<info.groups;i++) {
matchStr = jsvNewFromStringVar(info.sourceStr, info.groupStart[i], info.groupEnd[i]-info.groupStart[i]);
jsvSetArrayItem(rmatch, i+1, matchStr);
jsvUnLock(matchStr);
}
jsvObjectSetChildAndUnLock(rmatch, "index", jsvNewFromInteger((JsVarInt)info.startIndex));
jsvObjectSetChild(rmatch, "input", info.sourceStr);
return rmatch;
}
// Return a string containing 'chars' bytes. If chars<=0 the string will be all available data
JsVar *jswrap_stream_read(JsVar *parent, JsVarInt chars) {
if (!jsvIsObject(parent)) return 0;
JsVar *buf = jsvObjectGetChild(parent, STREAM_BUFFER_NAME, 0);
JsVar *data = 0;
if (jsvIsString(buf)) {
size_t len = jsvGetStringLength(buf);
if (chars <= 0 || (size_t)chars>=len) {
// return the whole buffer and remove it
data = buf;
buf = 0;
jsvRemoveNamedChild(parent, STREAM_BUFFER_NAME);
} else {
// return just part of the buffer, and shorten it accordingly
data = jsvNewFromStringVar(buf, 0, (size_t)chars);
JsVar *newBuf = jsvNewFromStringVar(buf, (size_t)chars, JSVAPPENDSTRINGVAR_MAXLENGTH);
jsvUnLock(jsvObjectSetChild(parent, STREAM_BUFFER_NAME, newBuf));
}
} else
data = jsvNewFromEmptyString();
jsvUnLock(buf);
return data;
}
/*JSON{
"type" : "method",
"class" : "String",
"name" : "replace",
"generate" : "jswrap_string_replace",
"params" : [
["subStr","JsVar","The string to search for"],
["newSubStr","JsVar","The string to replace it with"]
],
"return" : ["JsVar","This string with `subStr` replaced"]
}
Search and replace ONE occurrance of `subStr` with `newSubStr` and return the result. This doesn't alter the original string. Regular expressions not supported.
*/
JsVar *jswrap_string_replace(JsVar *parent, JsVar *subStr, JsVar *newSubStr) {
JsVar *str = jsvAsString(parent, false);
subStr = jsvAsString(subStr, false);
newSubStr = jsvAsString(newSubStr, false);
int idx = jswrap_string_indexOf(parent, subStr, 0, false);
if (idx>=0) {
JsVar *newStr = jsvNewFromStringVar(str, 0, (size_t)idx);
jsvAppendStringVar(newStr, newSubStr, 0, JSVAPPENDSTRINGVAR_MAXLENGTH);
jsvAppendStringVar(newStr, str, (size_t)idx+jsvGetStringLength(subStr), JSVAPPENDSTRINGVAR_MAXLENGTH);
jsvUnLock(str);
str = newStr;
}
jsvUnLock2(subStr, newSubStr);
return str;
}
bool bleRemoveChild(JsVar *parent, JsVar *blevar){
bool ret = false;
JsvObjectIterator it;
jsvObjectIteratorNew(&it, parent);
while (jsvObjectIteratorHasValue(&it)) {
JsVar *child = jsvObjectIteratorGetKey(&it);
JsVar *name = jsvNewFromStringVar(child, 0, 10);
if(jsvIsEqual(name,blevar)){
jsvRemoveChild(parent,child);
ret = true;
}
jsvUnLock(child);
jsvUnLock(name);
jsvObjectIteratorNext(&it);
}
jsvObjectIteratorFree(&it);
return ret;
}
void jsfGetJSONWithCallback(JsVar *var, JSONFlags flags, const char *whitespace, vcbprintf_callback user_callback, void *user_data) {
JSONFlags nflags = flags + JSON_INDENT; // if we add a newline, make sure we indent any subsequent JSON more
if (!whitespace) whitespace=" ";
if (jsvIsUndefined(var)) {
cbprintf(user_callback, user_data, "undefined");
} else {
// Use IS_RECURSING flag to stop recursion
if (var->flags & JSV_IS_RECURSING) {
cbprintf(user_callback, user_data, " ... ");
return;
}
var->flags |= JSV_IS_RECURSING;
if (jsvIsArray(var)) {
JsVarInt length = jsvGetArrayLength(var);
bool limited = (flags&JSON_LIMIT) && (length>(JsVarInt)JSON_LIMIT_AMOUNT);
bool needNewLine = false;
cbprintf(user_callback, user_data, (flags&JSON_PRETTY)?"[ ":"[");
JsVarInt lastIndex = -1;
bool numeric = true;
bool first = true;
JsvObjectIterator it;
jsvObjectIteratorNew(&it, var);
while (lastIndex+1<length && numeric && !jspIsInterrupted()) {
JsVar *key = jsvObjectIteratorGetKey(&it);
if (!jsvObjectIteratorHasValue(&it) || jsvIsNumeric(key)) {
JsVarInt index = jsvObjectIteratorHasValue(&it) ? jsvGetInteger(key) : length-1;
JsVar *item = jsvObjectIteratorGetValue(&it);
while (lastIndex < index) {
lastIndex++;
if (!limited || lastIndex<(JsVarInt)JSON_LIMITED_AMOUNT || lastIndex>=length-(JsVarInt)JSON_LIMITED_AMOUNT) {
if (!first) cbprintf(user_callback, user_data, (flags&JSON_PRETTY)?", ":",");
first = false;
if (limited && lastIndex==length-(JsVarInt)JSON_LIMITED_AMOUNT) cbprintf(user_callback, user_data, JSON_LIMIT_TEXT);
bool newNeedsNewLine = ((flags&JSON_SOME_NEWLINES) && jsonNeedsNewLine(item));
if (flags&JSON_ALL_NEWLINES) {
needNewLine = true;
newNeedsNewLine = true;
}
if (needNewLine || newNeedsNewLine) {
jsonNewLine(nflags, whitespace, user_callback, user_data);
needNewLine = false;
}
if (lastIndex == index)
jsfGetJSONWithCallback(item, nflags, whitespace, user_callback, user_data);
else
cbprintf(user_callback, user_data, (flags&JSON_NO_UNDEFINED)?"null":"undefined");
needNewLine = newNeedsNewLine;
}
}
jsvUnLock(item);
jsvObjectIteratorNext(&it);
} else {
numeric = false;
}
jsvUnLock(key);
}
// non-numeric - but NOT for standard JSON
if ((flags&JSON_PRETTY))
jsfGetJSONForObjectItWithCallback(&it, flags, whitespace, nflags, user_callback, user_data, first);
jsvObjectIteratorFree(&it);
if (needNewLine) jsonNewLine(flags, whitespace, user_callback, user_data);
cbprintf(user_callback, user_data, (flags&JSON_PRETTY)?" ]":"]");
} else if (jsvIsArrayBuffer(var)) {
JsvArrayBufferIterator it;
bool allZero = true;
jsvArrayBufferIteratorNew(&it, var, 0);
while (jsvArrayBufferIteratorHasElement(&it)) {
if (jsvArrayBufferIteratorGetFloatValue(&it)!=0)
allZero = false;
jsvArrayBufferIteratorNext(&it);
}
jsvArrayBufferIteratorFree(&it);
bool asArray = flags&JSON_ARRAYBUFFER_AS_ARRAY;
if (allZero && !asArray) {
cbprintf(user_callback, user_data, "new %s(%d)", jswGetBasicObjectName(var), jsvGetArrayBufferLength(var));
} else {
const char *aname = jswGetBasicObjectName(var);
/* You can't do `new ArrayBuffer([1,2,3])` so we have to output
* `new Uint8Array([1,2,3]).buffer`! */
bool isBasicArrayBuffer = strcmp(aname,"ArrayBuffer")==0;
if (isBasicArrayBuffer) {
aname="Uint8Array";
}
cbprintf(user_callback, user_data, asArray?"[":"new %s([", aname);
if (flags&JSON_ALL_NEWLINES) jsonNewLine(nflags, whitespace, user_callback, user_data);
size_t length = jsvGetArrayBufferLength(var);
bool limited = (flags&JSON_LIMIT) && (length>JSON_LIMIT_AMOUNT);
// no newlines needed for array buffers as they only contain simple stuff
jsvArrayBufferIteratorNew(&it, var, 0);
while (jsvArrayBufferIteratorHasElement(&it) && !jspIsInterrupted()) {
if (!limited || it.index<JSON_LIMITED_AMOUNT || it.index>=length-JSON_LIMITED_AMOUNT) {
if (it.index>0) cbprintf(user_callback, user_data, (flags&JSON_PRETTY)?", ":",");
if (flags&JSON_ALL_NEWLINES) jsonNewLine(nflags, whitespace, user_callback, user_data);
if (limited && it.index==length-JSON_LIMITED_AMOUNT) cbprintf(user_callback, user_data, JSON_LIMIT_TEXT);
JsVar *item = jsvArrayBufferIteratorGetValue(&it);
jsfGetJSONWithCallback(item, nflags, whitespace, user_callback, user_data);
jsvUnLock(item);
}
jsvArrayBufferIteratorNext(&it);
}
if (flags&JSON_ALL_NEWLINES) jsonNewLine(flags, whitespace, user_callback, user_data);
jsvArrayBufferIteratorFree(&it);
cbprintf(user_callback, user_data, asArray?"]":"])");
if (isBasicArrayBuffer && !asArray) cbprintf(user_callback, user_data, ".buffer");
}
} else if (jsvIsObject(var)) {
IOEventFlags device = (flags & JSON_SHOW_DEVICES) ? jsiGetDeviceFromClass(var) : EV_NONE;
if (device!=EV_NONE) {
cbprintf(user_callback, user_data, "%s", jshGetDeviceString(device));
} else {
bool showContents = true;
if (flags & JSON_SHOW_OBJECT_NAMES) {
JsVar *proto = jsvObjectGetChild(var, JSPARSE_INHERITS_VAR, 0);
if (jsvHasChildren(proto)) {
JsVar *constr = jsvObjectGetChild(proto, JSPARSE_CONSTRUCTOR_VAR, 0);
if (constr) {
JsVar *p = jsvGetIndexOf(execInfo.root, constr, true);
if (p) cbprintf(user_callback, user_data, "%v: ", p);
jsvUnLock2(p,constr);
/* We had the constructor - now if there was a non-default toString function
* we'll execute it and print the result */
JsVar *toStringFn = jspGetNamedField(var, "toString", false);
if (toStringFn && toStringFn->varData.native.ptr != (void (*)(void))jswrap_object_toString) {
// Function found and it's not the default one - execute it
JsVar *result = jspExecuteFunction(toStringFn,var,0,0);
cbprintf(user_callback, user_data, "%v", result);
jsvUnLock(result);
showContents = false; // we already printed something
}
jsvUnLock(toStringFn);
}
}
jsvUnLock(proto);
}
if (showContents) {
JsvObjectIterator it;
jsvObjectIteratorNew(&it, var);
cbprintf(user_callback, user_data, (flags&JSON_PRETTY)?"{ ":"{");
bool needNewLine = jsfGetJSONForObjectItWithCallback(&it, flags, whitespace, nflags, user_callback, user_data, true);
jsvObjectIteratorFree(&it);
if (needNewLine) jsonNewLine(flags, whitespace, user_callback, user_data);
cbprintf(user_callback, user_data, (flags&JSON_PRETTY)?" }":"}");
}
}
} else if (jsvIsFunction(var)) {
if (flags & JSON_IGNORE_FUNCTIONS) {
cbprintf(user_callback, user_data, "undefined");
} else {
cbprintf(user_callback, user_data, "function ");
jsfGetJSONForFunctionWithCallback(var, nflags, user_callback, user_data);
}
} else if (jsvIsString(var) && !jsvIsName(var)) {
if ((flags&JSON_LIMIT) && jsvGetStringLength(var)>JSON_LIMIT_STRING_AMOUNT) {
// if the string is too big, split it and put dots in the middle
JsVar *var1 = jsvNewFromStringVar(var, 0, JSON_LIMITED_STRING_AMOUNT);
JsVar *var2 = jsvNewFromStringVar(var, jsvGetStringLength(var)-JSON_LIMITED_STRING_AMOUNT, JSON_LIMITED_STRING_AMOUNT);
cbprintf(user_callback, user_data, "%q%s%q", var1, JSON_LIMIT_TEXT, var2);
jsvUnLock2(var1, var2);
} else {
cbprintf(user_callback, user_data, "%q", var);
}
} else {
cbprintf(user_callback, user_data, "%v", var);
}
var->flags &= ~JSV_IS_RECURSING;
}
}
/* This is like jsfGetJSONWithCallback, but handles ONLY functions (and does not print the initial 'function' text) */
void jsfGetJSONForFunctionWithCallback(JsVar *var, JSONFlags flags, vcbprintf_callback user_callback, void *user_data) {
assert(jsvIsFunction(var));
JsVar *codeVar = 0; // TODO: this should really be in jsvAsString
JsvObjectIterator it;
jsvObjectIteratorNew(&it, var);
bool firstParm = true;
cbprintf(user_callback, user_data, "(");
while (jsvObjectIteratorHasValue(&it)) {
JsVar *child = jsvObjectIteratorGetKey(&it);
if (jsvIsFunctionParameter(child)) {
if (firstParm)
firstParm=false;
else
cbprintf(user_callback, user_data, ",");
JsVar *name = jsvNewFromStringVar(child, 1, JSVAPPENDSTRINGVAR_MAXLENGTH);
cbprintf(user_callback, user_data, "%v", name);
jsvUnLock(name);
} else if (jsvIsString(child) && jsvIsStringEqual(child, JSPARSE_FUNCTION_CODE_NAME)) {
codeVar = jsvObjectIteratorGetValue(&it);
}
jsvUnLock(child);
jsvObjectIteratorNext(&it);
}
jsvObjectIteratorFree(&it);
cbprintf(user_callback, user_data, ") ");
if (jsvIsNative(var)) {
cbprintf(user_callback, user_data, "{ [native code] }");
} else {
if (codeVar) {
if (flags & JSON_LIMIT) {
cbprintf(user_callback, user_data, "{%s}", JSON_LIMIT_TEXT);
} else {
bool hasNewLine = jsvGetStringIndexOf(codeVar,'\n')>=0;
user_callback(hasNewLine?"{\n ":"{", user_data);
if (jsvIsFunctionReturn(var))
user_callback("return ", user_data);
// reconstruct the tokenised output into something more readable
char buf[32];
unsigned char lastch = 0;
JsvStringIterator it;
jsvStringIteratorNew(&it, codeVar, 0);
while (jsvStringIteratorHasChar(&it)) {
unsigned char ch = (unsigned char)jsvStringIteratorGetChar(&it);
if (jslNeedSpaceBetween(lastch, ch))
user_callback(" ", user_data);
jslFunctionCharAsString(ch, buf, sizeof(buf));
user_callback(buf, user_data);
jsvStringIteratorNext(&it);
lastch = ch;
}
jsvStringIteratorFree(&it);
user_callback(hasNewLine?"\n}":"}", user_data);
}
} else cbprintf(user_callback, user_data, "{}");
}
jsvUnLock(codeVar);
}
void jsfGetJSONWithCallback(JsVar *var, JSONFlags flags, vcbprintf_callback user_callback, void *user_data) {
JSONFlags nflags = flags + JSON_INDENT; // if we add a newline, make sure we indent any subsequent JSON more
if (jsvIsUndefined(var)) {
cbprintf(user_callback, user_data, "undefined");
} else {
// Use IS_RECURSING flag to stop recursion
if (var->flags & JSV_IS_RECURSING) {
cbprintf(user_callback, user_data, " ... ");
return;
}
var->flags |= JSV_IS_RECURSING;
if (jsvIsArray(var)) {
size_t length = (size_t)jsvGetArrayLength(var);
bool limited = (flags&JSON_LIMIT) && (length>JSON_LIMIT_AMOUNT);
bool needNewLine = false;
size_t i;
cbprintf(user_callback, user_data, (flags&JSON_PRETTY)?"[ ":"[");
for (i=0;i<length && !jspIsInterrupted();i++) {
if (!limited || i<JSON_LIMITED_AMOUNT || i>=length-JSON_LIMITED_AMOUNT) {
if (i>0) cbprintf(user_callback, user_data, (flags&JSON_PRETTY)?", ":",");
if (limited && i==length-JSON_LIMITED_AMOUNT) {
if (needNewLine) jsonNewLine(nflags, user_callback, user_data);
cbprintf(user_callback, user_data, JSON_LIMIT_TEXT);
}
JsVar *item = jsvGetArrayItem(var, (JsVarInt)i);
if (jsvIsUndefined(item) && (flags&JSON_NO_UNDEFINED))
item = jsvNewWithFlags(JSV_NULL);
bool newNeedsNewLine = (flags&JSON_NEWLINES) && jsonNeedsNewLine(item);
if (needNewLine || newNeedsNewLine) {
jsonNewLine(nflags, user_callback, user_data);
needNewLine = false;
}
jsfGetJSONWithCallback(item, nflags, user_callback, user_data);
needNewLine = newNeedsNewLine;
jsvUnLock(item);
}
}
if (needNewLine) jsonNewLine(flags, user_callback, user_data);
cbprintf(user_callback, user_data, (flags&JSON_PRETTY)?" ]":"]");
} else if (jsvIsArrayBuffer(var)) {
JsvArrayBufferIterator it;
bool allZero = true;
jsvArrayBufferIteratorNew(&it, var, 0);
while (jsvArrayBufferIteratorHasElement(&it)) {
if (jsvArrayBufferIteratorGetFloatValue(&it)!=0)
allZero = false;
jsvArrayBufferIteratorNext(&it);
}
jsvArrayBufferIteratorFree(&it);
if (allZero) {
cbprintf(user_callback, user_data, "new %s(%d)", jswGetBasicObjectName(var), jsvGetArrayBufferLength(var));
} else {
cbprintf(user_callback, user_data, "new %s([", jswGetBasicObjectName(var));
size_t length = jsvGetArrayBufferLength(var);
bool limited = (flags&JSON_LIMIT) && (length>JSON_LIMIT_AMOUNT);
// no newlines needed for array buffers as they only contain simple stuff
jsvArrayBufferIteratorNew(&it, var, 0);
while (jsvArrayBufferIteratorHasElement(&it) && !jspIsInterrupted()) {
if (!limited || it.index<JSON_LIMITED_AMOUNT || it.index>=length-JSON_LIMITED_AMOUNT) {
if (it.index>0) cbprintf(user_callback, user_data, (flags&JSON_PRETTY)?", ":",");
if (limited && it.index==length-JSON_LIMITED_AMOUNT) cbprintf(user_callback, user_data, JSON_LIMIT_TEXT);
JsVar *item = jsvArrayBufferIteratorGetValue(&it);
jsfGetJSONWithCallback(item, nflags, user_callback, user_data);
jsvUnLock(item);
}
jsvArrayBufferIteratorNext(&it);
}
jsvArrayBufferIteratorFree(&it);
cbprintf(user_callback, user_data, "])");
}
} else if (jsvIsObject(var)) {
IOEventFlags device = (flags & JSON_SHOW_DEVICES) ? jsiGetDeviceFromClass(var) : EV_NONE;
if (device!=EV_NONE) {
cbprintf(user_callback, user_data, "%s", jshGetDeviceString(device));
} else {
bool first = true;
bool needNewLine = false;
size_t sinceNewLine = 0;
JsvObjectIterator it;
jsvObjectIteratorNew(&it, var);
cbprintf(user_callback, user_data, (flags&JSON_PRETTY)?"{ ":"{");
while (jsvObjectIteratorHasValue(&it) && !jspIsInterrupted()) {
JsVar *index = jsvObjectIteratorGetKey(&it);
JsVar *item = jsvObjectIteratorGetValue(&it);
bool hidden = jsvIsInternalObjectKey(index) ||
((flags & JSON_IGNORE_FUNCTIONS) && jsvIsFunction(item)) ||
((flags&JSON_NO_UNDEFINED) && jsvIsUndefined(item));
if (!hidden) {
sinceNewLine++;
if (!first) cbprintf(user_callback, user_data, (flags&JSON_PRETTY)?", ":",");
bool newNeedsNewLine = (flags&JSON_NEWLINES) && jsonNeedsNewLine(item);
if ((flags&JSON_NEWLINES) && sinceNewLine>JSON_ITEMS_ON_LINE_OBJECT)
needNewLine = true;
if (needNewLine || newNeedsNewLine) {
jsonNewLine(nflags, user_callback, user_data);
needNewLine = false;
sinceNewLine = 0;
}
cbprintf(user_callback, user_data, (flags&JSON_PRETTY)?"%q: ":"%q:", index);
if (first)
first = false;
jsfGetJSONWithCallback(item, nflags, user_callback, user_data);
needNewLine = newNeedsNewLine;
}
jsvUnLock(index);
jsvUnLock(item);
jsvObjectIteratorNext(&it);
}
jsvObjectIteratorFree(&it);
if (needNewLine) jsonNewLine(flags, user_callback, user_data);
cbprintf(user_callback, user_data, (flags&JSON_PRETTY)?" }":"}");
}
} else if (jsvIsFunction(var)) {
if (flags & JSON_IGNORE_FUNCTIONS) {
cbprintf(user_callback, user_data, "undefined");
} else {
cbprintf(user_callback, user_data, "function ");
jsfGetJSONForFunctionWithCallback(var, nflags, user_callback, user_data);
}
} else if (jsvIsString(var) && !jsvIsName(var)) {
if ((flags&JSON_LIMIT) && jsvGetStringLength(var)>JSON_LIMIT_STRING_AMOUNT) {
// if the string is too big, split it and put dots in the middle
JsVar *var1 = jsvNewFromStringVar(var, 0, JSON_LIMITED_STRING_AMOUNT);
JsVar *var2 = jsvNewFromStringVar(var, jsvGetStringLength(var)-JSON_LIMITED_STRING_AMOUNT, JSON_LIMITED_STRING_AMOUNT);
cbprintf(user_callback, user_data, "%q%s%q", var1, JSON_LIMIT_TEXT, var2);
jsvUnLock(var1);
jsvUnLock(var2);
} else {
cbprintf(user_callback, user_data, "%q", var);
}
} else {
cbprintf(user_callback, user_data, "%v", var);
}
var->flags &= ~JSV_IS_RECURSING;
}
}
/*JSON{
"type" : "staticmethod",
"class" : "url",
"name" : "parse",
"generate" : "jswrap_url_parse",
"params" : [
["urlStr","JsVar","A URL to be parsed"],
["parseQuery","bool","Whether to parse the query string into an object not (default = false)"]
],
"return" : ["JsVar","An object containing options for ```http.request``` or ```http.get```. Contains `method`, `host`, `path`, `pathname`, `search`, `port` and `query`"]
}
A utility function to split a URL into parts
This is useful in web servers for instance when handling a request.
For instance `url.parse("/a?b=c&d=e",true)` returns `{"method":"GET","host":"","path":"/a?b=c&d=e","pathname":"/a","search":"?b=c&d=e","port":80,"query":{"b":"c","d":"e"}}`
*/
JsVar *jswrap_url_parse(JsVar *url, bool parseQuery) {
if (!jsvIsString(url)) return 0;
JsVar *obj = jsvNewWithFlags(JSV_OBJECT);
if (!obj) return 0; // out of memory
// scan string to try and pick stuff out
JsvStringIterator it;
jsvStringIteratorNew(&it, url, 0);
int slashes = 0;
int colons = 0;
int addrStart = -1;
int portStart = -1;
int pathStart = -1;
int searchStart = -1;
int charIdx = 0;
int portNumber = 0;
while (jsvStringIteratorHasChar(&it)) {
char ch = jsvStringIteratorGetChar(&it);
if (ch == '/') {
slashes++;
if (pathStart<0) pathStart = charIdx;
if (colons==1 && slashes==2 && addrStart<0) {
addrStart = charIdx;
pathStart = -1;
searchStart = -1;
}
}
if (ch == ':') {
colons++;
if (addrStart>=0 && pathStart<0)
portStart = charIdx;
}
if (portStart>=0 && charIdx>portStart && pathStart<0 && ch >= '0' && ch <= '9') {
portNumber = portNumber*10 + (ch-'0');
}
if (ch == '?' && pathStart>=0) {
searchStart = charIdx;
}
jsvStringIteratorNext(&it);
charIdx++;
}
jsvStringIteratorFree(&it);
// try and sort stuff out
if (pathStart<0) pathStart = charIdx;
if (pathStart<0) pathStart = charIdx;
int addrEnd = (portStart>=0) ? portStart : pathStart;
// pull out details
if (addrStart>0)
jsvObjectSetChildAndUnLock(obj, "protocol", jsvNewFromStringVar(url, 0, (size_t)addrStart-1));
jsvObjectSetChildAndUnLock(obj, "method", jsvNewFromString("GET"));
jsvObjectSetChildAndUnLock(obj, "host", jsvNewFromStringVar(url, (size_t)(addrStart+1), (size_t)(addrEnd-(addrStart+1))));
JsVar *v;
v = jsvNewFromStringVar(url, (size_t)pathStart, JSVAPPENDSTRINGVAR_MAXLENGTH);
if (jsvGetStringLength(v)==0) jsvAppendString(v, "/");
jsvObjectSetChildAndUnLock(obj, "path", v);
v = jsvNewFromStringVar(url, (size_t)pathStart, (size_t)((searchStart>=0)?(searchStart-pathStart):JSVAPPENDSTRINGVAR_MAXLENGTH));
if (jsvGetStringLength(v)==0) jsvAppendString(v, "/");
jsvObjectSetChildAndUnLock(obj, "pathname", v);
jsvObjectSetChildAndUnLock(obj, "search", (searchStart>=0)?jsvNewFromStringVar(url, (size_t)searchStart, JSVAPPENDSTRINGVAR_MAXLENGTH):jsvNewNull());
jsvObjectSetChildAndUnLock(obj, "port", (portNumber<=0 || portNumber>65535) ? jsvNewWithFlags(JSV_NULL) : jsvNewFromInteger(portNumber));
JsVar *query = (searchStart>=0)?jsvNewFromStringVar(url, (size_t)(searchStart+1), JSVAPPENDSTRINGVAR_MAXLENGTH):jsvNewNull();
if (parseQuery && !jsvIsNull(query)) {
JsVar *queryStr = query;
jsvStringIteratorNew(&it, query, 0);
query = jsvNewWithFlags(JSV_OBJECT);
JsVar *key = jsvNewFromEmptyString();
JsVar *val = jsvNewFromEmptyString();
bool hadEquals = false;
while (jsvStringIteratorHasChar(&it)) {
char ch = jsvStringIteratorGetChar(&it);
if (ch=='&') {
if (jsvGetStringLength(key)>0 || jsvGetStringLength(val)>0) {
key = jsvAsArrayIndexAndUnLock(key); // make sure "0" gets made into 0
jsvMakeIntoVariableName(key, val);
jsvAddName(query, key);
jsvUnLock2(key, val);
key = jsvNewFromEmptyString();
val = jsvNewFromEmptyString();
hadEquals = false;
}
} else if (!hadEquals && ch=='=') {
hadEquals = true;
} else {
// decode percent escape chars
if (ch=='%') {
jsvStringIteratorNext(&it);
ch = jsvStringIteratorGetChar(&it);
jsvStringIteratorNext(&it);
ch = (char)((chtod(ch)<<4) | chtod(jsvStringIteratorGetChar(&it)));
}
if (hadEquals) jsvAppendCharacter(val, ch);
else jsvAppendCharacter(key, ch);
}
jsvStringIteratorNext(&it);
charIdx++;
}
jsvStringIteratorFree(&it);
jsvUnLock(queryStr);
if (jsvGetStringLength(key)>0 || jsvGetStringLength(val)>0) {
key = jsvAsArrayIndexAndUnLock(key); // make sure "0" gets made into 0
jsvMakeIntoVariableName(key, val);
jsvAddName(query, key);
}
jsvUnLock2(key, val);
}
jsvObjectSetChildAndUnLock(obj, "query", query);
return obj;
}
// httpParseHeaders(&receiveData, reqVar, true) // server
// httpParseHeaders(&receiveData, resVar, false) // client
bool httpParseHeaders(JsVar **receiveData, JsVar *objectForData, bool isServer) {
// find /r/n/r/n
int newlineIdx = 0;
int strIdx = 0;
int headerEnd = -1;
JsvStringIterator it;
jsvStringIteratorNew(&it, *receiveData, 0);
while (jsvStringIteratorHasChar(&it)) {
char ch = jsvStringIteratorGetChar(&it);
if (ch == '\r') {
if (newlineIdx==0) newlineIdx=1;
else if (newlineIdx==2) newlineIdx=3;
} else if (ch == '\n') {
if (newlineIdx==1) newlineIdx=2;
else if (newlineIdx==3) {
headerEnd = strIdx+1;
break;
}
} else newlineIdx=0;
jsvStringIteratorNext(&it);
strIdx++;
}
jsvStringIteratorFree(&it);
// skip if we have no header
if (headerEnd<0) return false;
// Now parse the header
JsVar *vHeaders = jsvNewObject();
if (!vHeaders) return true;
jsvUnLock(jsvAddNamedChild(objectForData, vHeaders, "headers"));
strIdx = 0;
int firstSpace = -1;
int secondSpace = -1;
int firstEOL = -1;
int lineNumber = 0;
int lastLineStart = 0;
int colonPos = 0;
//jsiConsolePrintStringVar(receiveData);
jsvStringIteratorNew(&it, *receiveData, 0);
while (jsvStringIteratorHasChar(&it)) {
char ch = jsvStringIteratorGetChar(&it);
if (ch==' ' || ch=='\r') {
if (firstSpace<0) firstSpace = strIdx;
else if (secondSpace<0) secondSpace = strIdx;
}
if (ch == ':' && colonPos<0) colonPos = strIdx;
if (ch == '\r') {
if (firstEOL<0) firstEOL=strIdx;
if (lineNumber>0 && colonPos>lastLineStart && lastLineStart<strIdx) {
JsVar *hVal = jsvNewFromEmptyString();
if (hVal)
jsvAppendStringVar(hVal, *receiveData, (size_t)colonPos+2, (size_t)(strIdx-(colonPos+2)));
JsVar *hKey = jsvNewFromEmptyString();
if (hKey) {
jsvMakeIntoVariableName(hKey, hVal);
jsvAppendStringVar(hKey, *receiveData, (size_t)lastLineStart, (size_t)(colonPos-lastLineStart));
jsvAddName(vHeaders, hKey);
jsvUnLock(hKey);
}
jsvUnLock(hVal);
}
lineNumber++;
colonPos=-1;
}
if (ch == '\r' || ch == '\n') {
lastLineStart = strIdx+1;
}
jsvStringIteratorNext(&it);
strIdx++;
}
jsvStringIteratorFree(&it);
jsvUnLock(vHeaders);
// try and pull out methods/etc
if (isServer) {
jsvObjectSetChildAndUnLock(objectForData, "method", jsvNewFromStringVar(*receiveData, 0, (size_t)firstSpace));
jsvObjectSetChildAndUnLock(objectForData, "url", jsvNewFromStringVar(*receiveData, (size_t)(firstSpace+1), (size_t)(secondSpace-(firstSpace+1))));
} else {
jsvObjectSetChildAndUnLock(objectForData, "httpVersion", jsvNewFromStringVar(*receiveData, 5, (size_t)firstSpace-5));
jsvObjectSetChildAndUnLock(objectForData, "statusCode", jsvNewFromStringVar(*receiveData, (size_t)(firstSpace+1), (size_t)(secondSpace-(firstSpace+1))));
jsvObjectSetChildAndUnLock(objectForData, "statusMessage", jsvNewFromStringVar(*receiveData, (size_t)(secondSpace+1), (size_t)(firstEOL-(secondSpace+1))));
}
// strip out the header
JsVar *afterHeaders = jsvNewFromStringVar(*receiveData, (size_t)headerEnd, JSVAPPENDSTRINGVAR_MAXLENGTH);
jsvUnLock(*receiveData);
*receiveData = afterHeaders;
return true;
}
/*JSON{
"type" : "method",
"class" : "String",
"name" : "split",
"generate" : "jswrap_string_split",
"params" : [
["separator","JsVar","The separator `String` or `RegExp` to use"]
],
"return" : ["JsVar","Part of this string from start for len characters"]
}
Return an array made by splitting this string up by the separator. eg. ```'1,2,3'.split(',')==['1', '2', '3']```
Regular Expressions can also be used to split strings, eg. `'1a2b3 4'.split(/[^0-9]/)==['1', '2', '3', '4']`.
*/
JsVar *jswrap_string_split(JsVar *parent, JsVar *split) {
if (!jsvIsString(parent)) return 0;
JsVar *array = jsvNewEmptyArray();
if (!array) return 0; // out of memory
if (jsvIsUndefined(split)) {
jsvArrayPush(array, parent);
return array;
}
#ifndef SAVE_ON_FLASH
// Use RegExp if one is passed in
if (jsvIsInstanceOf(split, "RegExp")) {
unsigned int last = 0;
JsVar *match;
jsvObjectSetChildAndUnLock(split, "lastIndex", jsvNewFromInteger(0));
match = jswrap_regexp_exec(split, parent);
while (match && !jsvIsNull(match)) {
// get info about match
JsVar *matchStr = jsvGetArrayItem(match,0);
JsVarInt idx = jsvGetIntegerAndUnLock(jsvObjectGetChild(match,"index",0));
JsVarInt len = (JsVarInt)jsvGetStringLength(matchStr);
jsvUnLock(matchStr);
// do the replacement
jsvArrayPushAndUnLock(array, jsvNewFromStringVar(parent, (size_t)last, (size_t)(idx-last)));
last = idx+len;
// search again
jsvUnLock(match);
jsvObjectSetChildAndUnLock(split, "lastIndex", jsvNewFromInteger(last));
match = jswrap_regexp_exec(split, parent);
}
jsvUnLock(match);
jsvObjectSetChildAndUnLock(split, "lastIndex", jsvNewFromInteger(0));
// add remaining string after last match
if (last<=jsvGetStringLength(parent))
jsvArrayPushAndUnLock(array, jsvNewFromStringVar(parent, (size_t)last, JSVAPPENDSTRINGVAR_MAXLENGTH));
return array;
}
#endif
split = jsvAsString(split);
int idx, last = 0;
int splitlen = jsvIsUndefined(split) ? 0 : (int)jsvGetStringLength(split);
int l = (int)jsvGetStringLength(parent) + 1 - splitlen;
for (idx=0;idx<=l;idx++) {
if (splitlen==0 && idx==0) continue; // special case for where split string is ""
if (idx==l || splitlen==0 || jsvCompareString(parent, split, (size_t)idx, 0, true)==0) {
if (idx==l) {
idx=l+splitlen; // if the last element, do to the end of the string
if (splitlen==0) break;
}
JsVar *part = jsvNewFromStringVar(parent, (size_t)last, (size_t)(idx-last));
if (!part) break; // out of memory
jsvArrayPush(array, part);
jsvUnLock(part);
last = idx+splitlen;
}
}
jsvUnLock(split);
return array;
}
/*JSON{
"type" : "method",
"class" : "String",
"name" : "replace",
"generate" : "jswrap_string_replace",
"params" : [
["subStr","JsVar","The string to search for"],
["newSubStr","JsVar","The string to replace it with"]
],
"return" : ["JsVar","This string with `subStr` replaced"]
}
Search and replace ONE occurrance of `subStr` with `newSubStr` and return the result. This doesn't alter the original string. Regular expressions not supported.
*/
JsVar *jswrap_string_replace(JsVar *parent, JsVar *subStr, JsVar *newSubStr) {
JsVar *str = jsvAsString(parent);
#ifndef SAVE_ON_FLASH
// Use RegExp if one is passed in
if (jsvIsInstanceOf(subStr, "RegExp")) {
JsVar *replace;
if (jsvIsFunction(newSubStr) || jsvIsString(newSubStr))
replace = jsvLockAgain(newSubStr);
else
replace = jsvAsString(newSubStr);
jsvObjectSetChildAndUnLock(subStr, "lastIndex", jsvNewFromInteger(0));
bool global = jswrap_regexp_hasFlag(subStr,'g');
JsVar *match;
match = jswrap_regexp_exec(subStr, str);
while (match && !jsvIsNull(match) && !jspIsInterrupted()) {
// get info about match
JsVar *matchStr = jsvGetArrayItem(match,0);
JsVarInt idx = jsvGetIntegerAndUnLock(jsvObjectGetChild(match,"index",0));
JsVarInt len = (JsVarInt)jsvGetStringLength(matchStr);
// do the replacement
JsVar *newStr = jsvNewFromStringVar(str, 0, (size_t)idx);
JsvStringIterator dst;
jsvStringIteratorNew(&dst, newStr, 0);
jsvStringIteratorGotoEnd(&dst);
if (jsvIsFunction(replace)) {
unsigned int argCount = 0;
JsVar *args[13];
args[argCount++] = jsvLockAgain(matchStr);
JsVar *v;
while ((v = jsvGetArrayItem(match, (JsVarInt)argCount)))
args[argCount++] = v;
args[argCount++] = jsvObjectGetChild(match,"index",0);
args[argCount++] = jsvObjectGetChild(match,"input",0);
JsVar *result = jsvAsStringAndUnLock(jspeFunctionCall(replace, 0, 0, false, (JsVarInt)argCount, args));
jsvUnLockMany(argCount, args);
jsvStringIteratorAppendString(&dst, result, 0);
jsvUnLock(result);
} else {
JsvStringIterator src;
jsvStringIteratorNew(&src, replace, 0);
while (jsvStringIteratorHasChar(&src)) {
char ch = jsvStringIteratorGetChar(&src);
if (ch=='$') {
jsvStringIteratorNext(&src);
ch = jsvStringIteratorGetChar(&src);
JsVar *group = 0;
if (ch>'0' && ch<='9')
group = jsvGetArrayItem(match, ch-'0');
if (group) {
jsvStringIteratorAppendString(&dst, group, 0);
jsvUnLock(group);
} else {
jsvStringIteratorAppend(&dst, '$');
jsvStringIteratorAppend(&dst, ch);
}
} else {
jsvStringIteratorAppend(&dst, ch);
}
jsvStringIteratorNext(&src);
}
jsvStringIteratorFree(&src);
}
JsVarInt lastIndex = 1+(JsVarInt)jsvStringIteratorGetIndex(&dst);
jsvStringIteratorAppendString(&dst, str, (size_t)(idx+len));
jsvStringIteratorFree(&dst);
jsvUnLock2(str,matchStr);
str = newStr;
// search again if global
jsvUnLock(match);
match = 0;
if (global) {
jsvObjectSetChildAndUnLock(subStr, "lastIndex", jsvNewFromInteger(lastIndex));
match = jswrap_regexp_exec(subStr, str);
}
}
jsvUnLock(match);
jsvUnLock(replace);
// reset lastIndex if global
if (global)
jsvObjectSetChildAndUnLock(subStr, "lastIndex", jsvNewFromInteger(0));
return str;
}
#endif
newSubStr = jsvAsString(newSubStr);
subStr = jsvAsString(subStr);
int idx = jswrap_string_indexOf(parent, subStr, 0, false);
if (idx>=0) {
JsVar *newStr = jsvNewFromStringVar(str, 0, (size_t)idx);
jsvAppendStringVar(newStr, newSubStr, 0, JSVAPPENDSTRINGVAR_MAXLENGTH);
jsvAppendStringVar(newStr, str, (size_t)idx+jsvGetStringLength(subStr), JSVAPPENDSTRINGVAR_MAXLENGTH);
jsvUnLock(str);
str = newStr;
}
jsvUnLock2(subStr, newSubStr);
return str;
}
