static str
do_batstr_int(bat *ret, const bat *l, const char *name, str (*func)(int *, const str *))
{
BATiter bi;
BAT *bn, *b;
BUN p, q;
str x;
int y;
str msg = MAL_SUCCEED;
prepareOperand(b, l, name);
prepareResult(bn, b, TYPE_int, name);
bi = bat_iterator(b);
BATloop(b, p, q) {
x = (str) BUNtail(bi, p);
if (x == 0 || strcmp(x, str_nil) == 0) {
y = int_nil;
bn->tnonil = 0;
bn->tnil = 1;
} else if ((msg = (*func)(&y, &x)) != MAL_SUCCEED) {
goto bunins_failed;
}
bunfastapp(bn, &y);
}
str
BATXMLxml2str(bat *ret, const bat *bid)
{
BAT *b, *bn;
BUN p, q;
BATiter bi;
if ((b = BATdescriptor(*bid)) == NULL)
throw(MAL, "xml.str", INTERNAL_BAT_ACCESS);
prepareResult(bn, b, TYPE_str, "str", (void) 0);
bi = bat_iterator(b);
BATloop(b, p, q) {
const char *t = (const char *) BUNtail(bi, p);
if (strNil(t)) {
bunfastapp(bn, t);
bn->T->nonil = 0;
} else {
assert(*t == 'A' || *t == 'C' || *t == 'D');
bunfastapp(bn, t + 1);
}
}
finalizeResult(ret, bn, b);
return MAL_SUCCEED;
bunins_failed:
BBPunfix(b->batCacheid);
BBPunfix(bn->batCacheid);
throw(MAL, "xml.str", OPERATION_FAILED " during bulk coercion");
}
str
BATXMLdocument(bat *ret, const bat *bid)
{
BAT *b, *bn;
BUN p, q;
BATiter bi;
size_t size = BUFSIZ;
str buf = GDKmalloc(size);
const char *err = OPERATION_FAILED;
if (buf == NULL)
throw(MAL,"xml.document",MAL_MALLOC_FAIL);
if ((b = BATdescriptor(*bid)) == NULL) {
GDKfree(buf);
throw(MAL, "xml.document", INTERNAL_BAT_ACCESS);
}
prepareResult(bn, b, TYPE_xml, "document", GDKfree(buf));
bi = bat_iterator(b);
BATloop(b, p, q) {
const char *t = (const char *) BUNtail(bi, p);
xmlDocPtr doc;
int len;
xmlChar *s;
if (strNil(t)) {
bunfastapp(bn, str_nil);
bn->T->nonil = 0;
continue;
}
len = (int) strlen(t);
doc = xmlParseMemory(t, len);
if (doc == NULL) {
err = OPERATION_FAILED XML_PARSE_ERROR;
goto bunins_failed;
}
xmlDocDumpMemory(doc, &s, &len);
xmlFreeDoc(doc);
if ((size_t) len + 2 >= size) {
GDKfree(buf);
size = (size_t) len + 128;
buf = GDKmalloc(size);
if (buf == NULL) {
err= MAL_MALLOC_FAIL;
goto bunins_failed;
}
}
buf[0] = 'D';
strcpy(buf + 1, (char *) s);
bunfastapp(bn, buf);
}
GDKfree(buf);
finalizeResult(ret, bn, b);
return MAL_SUCCEED;
bunins_failed:
GDKfree(buf);
BBPunfix(b->batCacheid);
BBPunfix(bn->batCacheid);
throw(MAL, "xml.document", "%s", err);
}
str
BATXMLcomment(bat *ret, const bat *bid)
{
BAT *b, *bn;
BUN p, q;
size_t size = BUFSIZ;
str buf = GDKmalloc(size);
BATiter bi;
const char *err= OPERATION_FAILED;
if (buf == NULL)
throw(MAL, "xml.comment", MAL_MALLOC_FAIL);
if ((b = BATdescriptor(*bid)) == NULL) {
GDKfree(buf);
throw(MAL, "xml.comment", INTERNAL_BAT_ACCESS);
}
prepareResult(bn, b, TYPE_xml, "comment", GDKfree(buf));
bi = bat_iterator(b);
BATloop(b, p, q) {
const char *t = (const char *) BUNtail(bi, p);
size_t len;
if (strNil(t)) {
bunfastapp(bn, str_nil);
bn->T->nonil = 0;
continue;
}
if (strstr(t, "--") != NULL) {
err = XML_COMMENT_ERROR;
goto bunins_failed;
}
len = strlen(t);
if (len + 9 >= size) {
/* make sure there is enough space */
size = len + 128;
/* free/malloc so we don't copy */
GDKfree(buf);
buf = GDKmalloc(size);
if (buf == NULL) {
err = MAL_MALLOC_FAIL;
goto bunins_failed;
}
}
snprintf(buf, size, "C<!--%s-->", t);
bunfastapp(bn, buf);
}
GDKfree(buf);
finalizeResult(ret, bn, b);
return MAL_SUCCEED;
bunins_failed:
BBPunfix(b->batCacheid);
BBPunfix(bn->batCacheid);
if (buf != NULL)
GDKfree(buf);
throw(MAL, "xml.comment", "%s", err);
}
/* public */
auto_ptr<Geometry>
SnapOverlayOp::getResultGeometry(OverlayOp::OpCode opCode)
{
geom::GeomPtrPair prepGeom;
snap(prepGeom);
GeomPtr result ( OverlayOp::overlayOp(prepGeom.first.get(),
prepGeom.second.get(), opCode) );
prepareResult(*result);
return result;
}
void Requester::processResponse(bool ok, QString const &msg)
{
disconnect(m_networkManager, SIGNAL(response(bool, QString const &)),
this, SLOT(processResponse(bool, QString const &)));
if (ok) {
emit result(prepareResult(msg));
} else {
emit error(prepareError(msg));
}
}
/*
* The core of the activity is str2xml, where the actual strings
* are constructed.
* To avoid repetitive copying we make sure that the garbage
* collector does not remove the xml intermediates.
* This way, we know that as long as the xml-variables are not
* reused, the complete structure of the xml document(s) are available.
* We merely have to collect the pieces.
* [FOR LATER, FIRST GO FOR THE EASY IMPLEMENTATION]
* XML values are represented by strings already.
*/
str
BATXMLstr2xml(bat *ret, const bat *bid)
{
BAT *b, *bn;
BUN p, q;
size_t size = BUFSIZ;
str buf;
const char *err= OPERATION_FAILED;
BATiter bi;
buf = GDKmalloc(size);
if (buf == NULL)
throw(MAL,"xml.str2xml",MAL_MALLOC_FAIL);
if ((b = BATdescriptor(*bid)) == NULL) {
GDKfree(buf);
throw(MAL, "xml.xml", INTERNAL_BAT_ACCESS);
}
prepareResult(bn, b, TYPE_xml, "xml", GDKfree(buf));
bi = bat_iterator(b);
BATloop(b, p, q) {
const char *t = (const char *) BUNtail(bi, p);
size_t len;
if (strNil(t)) {
bunfastapp(bn, str_nil);
bn->T->nonil = 0;
continue;
}
len = strlen(t) * 6 + 1;
if (size < len) {
size = len + 128;
GDKfree(buf);
buf = GDKmalloc(size);
if (buf == NULL) {
err = MAL_MALLOC_FAIL;
goto bunins_failed;
}
}
buf[0] = 'C';
XMLquotestring(t, buf + 1, size - 1);
bunfastapp(bn, buf);
}
GDKfree(buf);
finalizeResult(ret, bn, b);
return MAL_SUCCEED;
bunins_failed:
BBPunfix(b->batCacheid);
BBPunfix(bn->batCacheid);
if (buf != NULL)
GDKfree(buf);
throw(MAL, "xml.xml", "%s", err);
}
//-----------------------------------------------------------------------------
DataOpenDialog::DataOpenDialog(QWidget *parent) : QDialog(parent)
{
setWindowTitle(tr("UDAV - Open data file"));
QHBoxLayout *a;
QLabel *l;
QPushButton *b;
QVBoxLayout *o=new QVBoxLayout(this);
a = new QHBoxLayout; o->addLayout(a);
l = new QLabel(tr("Data name")); a->addWidget(l);
char buf[32]; snprintf(buf,32,"mgl_%d",numDataOpened); buf[31]=0;
name = new QLineEdit(buf,this); a->addWidget(name);
rA = new QRadioButton(tr("Auto detect data sizes"), this);
rA->setChecked(true); o->addWidget(rA);
rM = new QRadioButton(tr("Set data sizes manually"), this);
o->addWidget(rM); a = new QHBoxLayout; o->addLayout(a);
l = new QLabel(tr("Nx")); a->addWidget(l);
nx = new QLineEdit("1",this); a->addWidget(nx);
l = new QLabel(tr("Ny")); a->addWidget(l);
ny = new QLineEdit("1",this); a->addWidget(ny);
l = new QLabel(tr("Nz")); a->addWidget(l);
nz = new QLineEdit("1",this); a->addWidget(nz);
r2 = new QRadioButton(tr("Matrix with sizes from file"), this); o->addWidget(r2);
r3 = new QRadioButton(tr("3D data with sizes from file"), this);o->addWidget(r3);
QSettings settings("udav","UDAV");
settings.setPath(QSettings::IniFormat, QSettings::UserScope, "UDAV");
settings.beginGroup("/UDAV");
dataScr = settings.value("/dataScr").toStringList().mid(0,10);
dataScr.removeDuplicates();
settings.endGroup();
a = new QHBoxLayout; o->addLayout(a);
l = new QLabel(tr("Template")); a->addWidget(l,0);
scr = new QComboBox(this); a->addWidget(scr,1);
scr->setEditable(true); scr->lineEdit()->setText("");
scr->addItem(tr("default")); scr->addItems(dataScr);
b = new QPushButton("...", this); a->addWidget(b,0);
connect(b, SIGNAL(clicked()),this, SLOT(selectScr()));
a = new QHBoxLayout; o->addLayout(a); a->addStretch(1);
b = new QPushButton(tr("Cancel"),this); a->addWidget(b);
connect(b,SIGNAL(clicked()),this,SLOT(reject()));
b = new QPushButton(tr("OK"), this); a->addWidget(b);
connect(b, SIGNAL(clicked()),this, SLOT(prepareResult()));
b->setDefault(true);
}
str
BATXMLisdocument(bat *ret, const bat *bid)
{
BAT *b, *bn;
BUN p, q;
BATiter bi;
if ((b = BATdescriptor(*bid)) == NULL)
throw(MAL, "xml.isdocument", INTERNAL_BAT_ACCESS);
prepareResult(bn, b, TYPE_bit, "isdocument", (void) 0);
bi = bat_iterator(b);
BATloop(b, p, q) {
const char *t = (const char *) BUNtail(bi, p);
xmlDocPtr doc;
bit val;
if (strNil(t)) {
val = bit_nil;
bn->T->nonil = 0;
} else {
doc = xmlParseMemory(t, (int) strlen(t));
if (doc == NULL) {
val = 0;
} else {
xmlFreeDoc(doc);
val = 1;
}
}
bunfastapp(bn, &val);
}
finalizeResult(ret, bn, b);
return MAL_SUCCEED;
bunins_failed:
BBPunfix(b->batCacheid);
BBPunfix(bn->batCacheid);
throw(MAL, "xml.isdocument", OPERATION_FAILED " During bulk processing");
}
str
BATXMLelement(bat *ret, const char * const *name, xml *nspace, xml *attr, const bat *bid)
{
BAT *b, *bn;
BUN p, q;
size_t size = BUFSIZ;
str buf;
BATiter bi;
size_t elemlen, namelen;
const char *err = OPERATION_FAILED;
if (strNil(*name))
throw(MAL, "xml.element", XML_NO_ELEMENT);
if (xmlValidateName((xmlChar *) *name, 0) != 0)
throw(MAL, "xml.element", XML_ATTRIBUTE_INVALID);
if (nspace && !strNil(*nspace) && **nspace)
throw(MAL, "xml.element", XML_NO_NAMESPACE);
namelen = strlen(*name);
elemlen = namelen + 5;
if (nspace && !strNil(*nspace)) {
if (**nspace != 'A')
throw(MAL, "xml.element", XML_ILLEGAL_NAMESPACE);
elemlen += strlen(*nspace); /* " " + nspace (nspace contains initial 'A' which is replaced by space) */
}
if (attr && !strNil(*attr)) {
if (**attr != 'A')
throw(MAL, "xml.element", XML_ILLEGAL_ATTRIBUTE);
elemlen += strlen(*attr); /* " " + attr (attr contains initial 'A' which is replaced by space) */
}
buf = GDKmalloc(size);
if (buf == NULL)
throw(MAL, "xml.attribute", MAL_MALLOC_FAIL);
if ((b = BATdescriptor(*bid)) == NULL) {
GDKfree(buf);
throw(MAL, "xml.element", INTERNAL_BAT_ACCESS);
}
prepareResult(bn, b, TYPE_xml, "element", GDKfree(buf));
bi = bat_iterator(b);
BATloop(b, p, q) {
const char *t = (const char *) BUNtail(bi, p);
size_t len;
len = elemlen;
if (!strNil(t)) {
if (*t != 'C') {
err = XML_ILLEGAL_CONTENT;
goto bunins_failed;
}
len += strlen(t + 1) + namelen + 2; /* extra "<", ">", and name ("/" already counted) */
}
if (len >= size) {
/* make sure there is enough space */
size = len + 128;
/* free/malloc so we don't copy */
GDKfree(buf);
buf = GDKmalloc(size);
if (buf == NULL) {
err = MAL_MALLOC_FAIL;
goto bunins_failed;
}
}
if (strNil(t) && (!attr || strNil(*attr))) {
strcpy(buf, str_nil);
bn->T->nonil = 0;
} else {
int i = snprintf(buf, size, "C<%s", *name);
if (nspace && !strNil(*nspace))
i += snprintf(buf + i, size - i, " %s", *nspace + 1);
if (attr && !strNil(*attr))
i += snprintf(buf + i, size - i, " %s", *attr + 1);
if (!strNil(t))
i += snprintf(buf + i, size - i, ">%s</%s>", t + 1, *name);
else
i += snprintf(buf + i, size - i, "/>");
}
bunfastapp(bn, buf);
}
GDKfree(buf);
finalizeResult(ret, bn, b);
return MAL_SUCCEED;
bunins_failed:
BBPunfix(b->batCacheid);
BBPunfix(bn->batCacheid);
if (buf != NULL)
GDKfree(buf);
throw(MAL, "xml.element", "%s", err);
}
str
BATXMLattribute(bat *ret, const char * const *name, const bat *bid)
{
BAT *b, *bn;
BUN p, q;
size_t size = BUFSIZ;
str buf;
BATiter bi;
size_t attrlen;
const char *err = OPERATION_FAILED;
if (strNil(*name))
throw(MAL, "xml.attribute", XML_ATTRIBUTE_ERROR);
if (xmlValidateName((xmlChar *) *name, 0) != 0)
throw(MAL, "xml.attribute", XML_ATTRIBUTE_INVALID);
attrlen = strlen(*name) + 5;
buf = GDKmalloc(size);
if (buf == NULL)
throw(MAL, "xml.attribute", MAL_MALLOC_FAIL);
if ((b = BATdescriptor(*bid)) == NULL) {
GDKfree(buf);
throw(MAL, "xml.attribute", INTERNAL_BAT_ACCESS);
}
prepareResult(bn, b, TYPE_xml, "attribute", GDKfree(buf));
bi = bat_iterator(b);
BATloop(b, p, q) {
const char *t = (const char *) BUNtail(bi, p);
size_t len;
len = attrlen;
if (!strNil(t))
len += strlen(t) * 6 + 1;
if (len >= size) {
/* make sure there is enough space */
size = len + 128;
/* free/malloc so we don't copy */
GDKfree(buf);
buf = GDKmalloc(size);
if (buf == NULL) {
err = MAL_MALLOC_FAIL;
goto bunins_failed;
}
}
if (strNil(t)) {
strcpy(buf, str_nil);
bn->T->nonil = 0;
} else {
int n = snprintf(buf, size, "A%s = \"", *name);
size_t m = XMLquotestring(t, buf + n, size - n);
strcpy(buf + n + m, "\"");
}
bunfastapp(bn, buf);
}
GDKfree(buf);
finalizeResult(ret, bn, b);
return MAL_SUCCEED;
bunins_failed:
BBPunfix(b->batCacheid);
BBPunfix(bn->batCacheid);
if (buf != NULL)
GDKfree(buf);
throw(MAL, "xml.attribute", "%s", err);
}
str
BATXMLroot(bat *ret, const bat *bid, const char * const *version, const char * const *standalone)
{
BAT *b, *bn;
BUN p, q;
size_t size = BUFSIZ;
str buf;
BATiter bi;
size_t hdrlen;
const char *err = OPERATION_FAILED;
hdrlen = 8;
if (!strNil(*version) && **version) {
if (strcmp(*version, "1.0") != 0 && strcmp(*version, "1.1") != 0)
throw(MAL, "xml.root", XML_VERSION_ERROR);
hdrlen += 11 + strlen(*version); /* strlen(" version=\"\"") */
}
if (!strNil(*standalone) && **standalone) {
if (strcmp(*standalone, "yes") != 0 && strcmp(*standalone, "no") != 0)
throw(MAL, "xml.root", XML_STANDALONE_ERROR "illegal XML standalone value");
hdrlen += 14 + strlen(*standalone); /* strlen(" standalone=\"\"") */
}
buf = GDKmalloc(size);
if (buf == NULL)
throw(MAL, "xml.root", MAL_MALLOC_FAIL);
if ((b = BATdescriptor(*bid)) == NULL) {
GDKfree(buf);
throw(MAL, "xml.pi", INTERNAL_BAT_ACCESS);
}
prepareResult(bn, b, TYPE_xml, "pi", GDKfree(buf));
bi = bat_iterator(b);
BATloop(b, p, q) {
const char *t = (const char *) BUNtail(bi, p);
size_t len, i;
bit isdoc;
len = hdrlen;
if (!strNil(t))
len += strlen(t);
if (len >= size) {
/* make sure there is enough space */
size = len + 128;
/* free/malloc so we don't copy */
GDKfree(buf);
buf = GDKmalloc(size);
if (buf == NULL) {
err = MAL_MALLOC_FAIL;
goto bunins_failed;
}
}
if (strNil(t)) {
strcpy(buf, str_nil);
bn->T->nonil = 0;
} else {
strcpy(buf, "D<?xml");
i = strlen(buf);
if (!strNil(*version) && **version)
i += snprintf(buf + i, len - i, " version=\"%s\"", *version);
if (!strNil(*standalone) && **standalone)
i += snprintf(buf + i, len - i, " standalone=\"%s\"", *standalone);
snprintf(buf + i, len - i, "?>%s", t + 1);
buf++;
XMLisdocument(&isdoc, &buf); /* check well-formedness */
buf--;
if (!isdoc) {
err = XML_NOT_WELL_FORMED;
goto bunins_failed;
}
}
bunfastapp(bn, buf);
}
GDKfree(buf);
finalizeResult(ret, bn, b);
return MAL_SUCCEED;
bunins_failed:
BBPunfix(b->batCacheid);
BBPunfix(bn->batCacheid);
if (buf != NULL)
GDKfree(buf);
throw(MAL, "xml.root", "%s", err);
}
str
BATXMLpi(bat *ret, const char * const *target, const bat *bid)
{
BAT *b, *bn;
BUN p, q;
size_t size = BUFSIZ;
str buf;
BATiter bi;
size_t tgtlen;
const char *err = OPERATION_FAILED;
if (strNil(*target))
throw(MAL, "xml.pi", XML_PI_ERROR);
buf = GDKmalloc(size);
if (buf == NULL)
throw(MAL, "xml.pi", MAL_MALLOC_FAIL);
tgtlen = strlen(*target) + 6;
if ((b = BATdescriptor(*bid)) == NULL) {
GDKfree(buf);
throw(MAL, "xml.pi", INTERNAL_BAT_ACCESS);
}
prepareResult(bn, b, TYPE_xml, "pi", GDKfree(buf));
bi = bat_iterator(b);
BATloop(b, p, q) {
const char *t = (const char *) BUNtail(bi, p);
size_t len;
len = tgtlen;
if (!strNil(t))
len += strlen(t) * 6 + 1;
if (len >= size) {
/* make sure there is enough space */
size = len + 128;
/* free/malloc so we don't copy */
GDKfree(buf);
buf = GDKmalloc(size);
if (buf == NULL) {
err = MAL_MALLOC_FAIL;
goto bunins_failed;
}
}
if (strNil(t))
snprintf(buf, size, "C<?%s?>", *target);
else {
int n = snprintf(buf, size, "C<?%s ", *target);
size_t m = XMLquotestring(t, buf + n, size - n);
strcpy(buf + n + m, "?>");
}
bunfastapp(bn, buf);
}
GDKfree(buf);
finalizeResult(ret, bn, b);
return MAL_SUCCEED;
bunins_failed:
BBPunfix(b->batCacheid);
BBPunfix(bn->batCacheid);
if (buf != NULL)
GDKfree(buf);
throw(MAL, "xml.pi", "%s", err);
}
str
BATXMLcontent(bat *ret, const bat *bid)
{
BAT *b, *bn;
BUN p, q;
BATiter bi;
xmlDocPtr doc;
xmlNodePtr root;
size_t size = BUFSIZ;
str buf = GDKmalloc(size);
const char *err = OPERATION_FAILED;
xmlBufferPtr xbuf;
if (buf == NULL)
throw(MAL,"xml.content",MAL_MALLOC_FAIL);
if ((b = BATdescriptor(*bid)) == NULL) {
GDKfree(buf);
throw(MAL, "xml.content", INTERNAL_BAT_ACCESS);
}
doc = xmlParseMemory("<doc/>", 6);
root = xmlDocGetRootElement(doc);
prepareResult(bn, b, TYPE_xml, "content", GDKfree(buf));
bi = bat_iterator(b);
xbuf = xmlBufferCreate();
BATloop(b, p, q) {
const char *t = (const char *) BUNtail(bi, p);
size_t len;
xmlNodePtr elem;
xmlParserErrors xerr;
const xmlChar *s;
if (strNil(t)) {
bunfastapp(bn, str_nil);
bn->T->nonil = 0;
continue;
}
len = strlen(t);
xerr = xmlParseInNodeContext(root, t, (int) len, 0, &elem);
if (xerr != XML_ERR_OK) {
err = XML_PARSE_ERROR;
goto bunins_failed;
}
xmlNodeDump(xbuf, doc, elem, 0, 0);
s = xmlBufferContent(xbuf);
len = strlen((const char *) s);
if (len + 2 >= size) {
GDKfree(buf);
size = len + 128;
buf = GDKmalloc(size);
if (buf == NULL) {
err = MAL_MALLOC_FAIL;
goto bunins_failed;
}
}
buf[0] = 'C';
strcpy(buf + 1, (const char *) s);
bunfastapp(bn, buf);
xmlBufferEmpty(xbuf);
xmlFreeNodeList(elem);
}
xmlBufferFree(xbuf);
xmlFreeDoc(doc);
GDKfree(buf);
finalizeResult(ret, bn, b);
return MAL_SUCCEED;
bunins_failed:
xmlBufferFree(xbuf);
xmlFreeDoc(doc);
if (buf != NULL)
GDKfree(buf);
BBPunfix(b->batCacheid);
BBPunfix(bn->batCacheid);
throw(MAL, "xml.document", "%s", err);
}
str
BATXMLxmltext(bat *ret, const bat *bid)
{
BAT *b, *bn;
BUN p, q;
BATiter bi;
size_t size = 0;
str buf = NULL;
xmlDocPtr doc = NULL;
xmlNodePtr elem;
str content = NULL;
const char *err = OPERATION_FAILED;
if ((b = BATdescriptor(*bid)) == NULL)
throw(MAL, "xml.text", INTERNAL_BAT_ACCESS);
prepareResult(bn, b, TYPE_str, "text", (void) 0);
bi = bat_iterator(b);
BATloop(b, p, q) {
const char *t = (const char *) BUNtail(bi, p);
size_t len;
if (strNil(t)) {
bunfastapp(bn, t);
bn->T->nonil = 0;
continue;
}
len = strlen(t);
switch (*t) {
case 'D': {
xmlDocPtr d = xmlParseMemory(t + 1, (int) (len - 1));
elem = xmlDocGetRootElement(d);
content = (str) xmlNodeGetContent(elem);
xmlFreeDoc(d);
if (content == NULL) {
err = MAL_MALLOC_FAIL;
goto bunins_failed;
}
break;
}
case 'C':
if (doc == NULL)
doc = xmlParseMemory("<doc/>", 6);
xmlParseInNodeContext(xmlDocGetRootElement(doc), t + 1, (int) (len - 1), 0, &elem);
content = (str) xmlNodeGetContent(elem);
xmlFreeNodeList(elem);
if (content == NULL) {
err = MAL_MALLOC_FAIL;
goto bunins_failed;
}
break;
case 'A': {
str s;
if (buf == NULL || size < len) {
size = len + 128;
if (buf != NULL)
GDKfree(buf);
buf = GDKmalloc(size);
if (buf == NULL) {
err = MAL_MALLOC_FAIL;
goto bunins_failed;
}
}
s = buf;
t++;
while (*t) {
if (*t == '"' || *t == '\'') {
char q = *t++;
s += XMLunquotestring(&t, q, s);
}
t++;
}
*s = 0;
break;
}
default:
assert(*t == 'A' || *t == 'C' || *t == 'D');
bunfastapp(bn, str_nil);
bn->T->nonil = 0;
continue;
}
assert(content != NULL || buf != NULL);
bunfastapp(bn, content != NULL ? content : buf);
if (content != NULL)
GDKfree(content);
content = NULL;
}
finalizeResult(ret, bn, b);
if (buf != NULL)
GDKfree(buf);
if (doc != NULL)
xmlFreeDoc(doc);
return MAL_SUCCEED;
bunins_failed:
BBPunfix(b->batCacheid);
BBPunfix(bn->batCacheid);
if (buf != NULL)
GDKfree(buf);
if (doc != NULL)
xmlFreeDoc(doc);
if (content != NULL)
GDKfree(content);
throw(MAL, "xml.text", "%s", err);
}
MongoShellExecResult ScriptEngine::exec(const std::string &originalScript, const std::string &dbName,
AggrInfo aggrInfo /* = AggrInfo() */)
{
QMutexLocker lock(&_mutex);
if (!_scope) {
_failedScope = true;
return MongoShellExecResult(true, "Connection error. Uninitialized mongo scope.");
}
// robomongo shell timeout
bool timeoutReached = false;
/*
* Replace all commands ('show dbs', 'use db' etc.) with call
* to shellHelper('show', 'dbs') and so on.
*/
std::string stdstr(originalScript);
pcrecpp::RE re("^(show|use|set) (\\w+)$",
pcrecpp::RE_Options(PCRE_CASELESS|PCRE_MULTILINE|PCRE_NEWLINE_ANYCRLF));
re.GlobalReplace("shellHelper('\\1', '\\2');", &stdstr);
/*
* Statementize (i.e. extract all JavaScript statements from script) and
* execute each statement one by one
*/
std::vector<std::string> statements;
std::string error;
bool result = statementize(stdstr, statements, error);
if (!result && statements.size() == 0) {
statements.push_back("print(__robomongoResult.error)");
}
std::vector<MongoShellResult> results;
use(dbName);
for (std::vector<std::string>::const_iterator it = statements.begin(); it != statements.end(); ++it)
{
std::string statement = *it;
// clear global objects
__objects.clear();
__type = "";
__finished = false;
__logs.str("");
if (true /* ! wascmd */) {
try {
bool failed = false;
QElapsedTimer timer;
timer.start();
if ( _scope->exec( statement , "(shell)" , false , true , false, _timeoutSec * 1000) ) {
_scope->exec( "__robomongoLastRes = __lastres__; shellPrintHelper( __lastres__ );",
"(shell2)" , true , true , false, _timeoutSec * 1000);
}
else // failed to run script
failed = true;
qint64 elapsed = timer.elapsed(); // milliseconds
if (elapsed > _timeoutSec * 1000)
timeoutReached = true;
std::string logs = __logs.str();
std::string answer = logs.c_str();
std::string type = __type.c_str();
if (failed && !timeoutReached)
return MongoShellExecResult(true, answer);
std::vector<MongoDocumentPtr> docs = MongoDocument::fromBsonObj(__objects);
if (!answer.empty() || docs.size() > 0)
results.push_back(
prepareResult(type, answer, docs, elapsed, statement, aggrInfo)
);
}
catch (const std::exception &e) {
std::cout << "error:" << e.what() << std::endl;
}
}
}
return prepareExecResult(results, timeoutReached);
}
