QoreHashNode *QoreException::makeExceptionObjectAndDelete(ExceptionSink *xsink) {
QORE_TRACE("makeExceptionObjectAndDelete()");
QoreHashNode *rv = makeExceptionObject();
del(xsink);
return rv;
}
QoreHashNode *QoreException::makeExceptionObject() {
QORE_TRACE("makeExceptionObject()");
QoreHashNode *h = new QoreHashNode;
h->setKeyValue("type", new QoreStringNode(type == ET_USER ? "User" : "System"), 0);
h->setKeyValue("file", new QoreStringNode(file), 0);
h->setKeyValue("line", new QoreBigIntNode(start_line), 0);
h->setKeyValue("endline", new QoreBigIntNode(end_line), 0);
h->setKeyValue("source", new QoreStringNode(source), 0);
h->setKeyValue("offset", new QoreBigIntNode(offset), 0);
h->setKeyValue("callstack", callStack->refSelf(), 0);
if (err)
h->setKeyValue("err", err->refSelf(), 0);
if (desc)
h->setKeyValue("desc", desc->refSelf(), 0);
if (arg)
h->setKeyValue("arg", arg->refSelf(), 0);
// add chained exceptions with this "chain reaction" call
if (next)
h->setKeyValue("next", next->makeExceptionObject(), 0);
return h;
}
static void ssh2_module_ns_init(QoreNamespace *rns, QoreNamespace *qns) {
QORE_TRACE("ssh2_module_ns_init()");
#ifdef LIBSSH2_INIT_NO_CRYPTO
libssh2_init(LIBSSH2_INIT_NO_CRYPTO);
#endif
qns->addInitialNamespace(ssh2ns.copy());
}
void CallStack::push(CallNode *c) {
QORE_TRACE("CallStack::push()");
c->next = 0;
c->prev = tail;
QoreAutoRWReadLocker l(thread_stack_lock);
if (tail)
tail->next = c;
tail = c;
}
void CallStack::pop(ExceptionSink *xsink) {
QORE_TRACE("CallStack::pop()");
{
QoreAutoRWReadLocker l(thread_stack_lock);
tail = tail->prev;
if (tail)
tail->next = 0;
}
}
void StatementBlock::parseInitClosure(UserVariantBase* uvb, const QoreTypeInfo* classTypeInfo, lvar_set_t* vlist) {
QORE_TRACE("StatementBlock::parseInitClosure");
ClosureParseEnvironment cenv(vlist);
UserParamListLocalVarHelper ph(uvb, classTypeInfo);
// initialize code block
parseInitImpl(uvb->getUserSignature()->selfid);
parseCheckReturn();
}
void StatementBlock::parseInitMethod(const QoreTypeInfo* typeInfo, UserVariantBase* uvb) {
QORE_TRACE("StatementBlock::parseInitMethod");
VariableBlockHelper vbh;
UserParamListLocalVarHelper ph(uvb, typeInfo);
// initialize code block
parseInitImpl(uvb->getUserSignature()->selfid);
parseCheckReturn();
}
void CallStack::pop(ExceptionSink *xsink) {
QORE_TRACE("CallStack::pop()");
CallNode *c;
{
QoreAutoRWReadLocker l(thread_stack_lock);
c = tail;
tail = tail->prev;
if (tail)
tail->next = 0;
}
c->objectDeref(xsink);
}
void StatementBlock::parseInit(UserVariantBase* uvb) {
QORE_TRACE("StatementBlock::parseInit");
VariableBlockHelper vbh;
UserParamListLocalVarHelper ph(uvb);
// initialize code block
parseInitImpl(0);
parseCheckReturn();
}
int StatementBlock::parseInitImpl(LocalVar* oflag, int pflag) {
QORE_TRACE("StatementBlock::parseInitImpl");
printd(4, "StatementBlock::parseInitImpl(b=%p, oflag=%p)\n", this, oflag);
BlockStartHelper bsh;
int lvids = parseInitIntern(oflag, pflag & ~PF_TOP_LEVEL, statement_list.end());
// this call will pop all local vars off the stack
setupLVList(lvids);
//printd(5, "StatementBlock::parseInitImpl(this=%p): done (lvars=%p, %d vars, vstack = %p)\n", this, lvars, lvids, getVStack());
return 0;
}
void TopLevelStatementBlock::parseInit(int64 po) {
QORE_TRACE("TopLevelStatementBlock::parseInit");
//printd(5, "TopLevelStatementBlock::parseInit(rns=%p) first=%d\n", &rns, first);
if (!first && lvars) {
// push already-registered local variables on the stack
for (unsigned i = 0; i < lvars->size(); ++i)
push_top_level_local_var(lvars->lv[i], loc);
}
// resolve global variables before initializing the top-level statements
qore_root_ns_private::parseResolveGlobalVars();
int lvids = parseInitIntern(0, PF_TOP_LEVEL, hwm);
//printd(5, "TopLevelStatementBlock::parseInit(rns=%p) first=%d, lvids=%d\n", &rns, first, lvids);
if (!first && lvids) {
parseException("ILLEGAL-TOP-LEVEL-LOCAL-VARIABLE", "local variables declared with 'my' in the top-level block of a Program object can only be declared in the very first code block parsed");
// discard variables immediately
for (int i = 0; i < lvids; ++i)
pop_local_var();
}
// now initialize root namespace and functions before local variables are popped off the stack
qore_root_ns_private::parseInit();
if (first) {
// if parsing a module, then initialize the init function
QoreModuleDefContext* qmd = get_module_def_context();
if (qmd)
qmd->parseInit();
// this call will pop all local vars off the stack
setupLVList(lvids);
first = false;
}
else if (lvars) {
for (unsigned i = 0; i < lvars->size(); ++i)
pop_local_var();
}
assert(!getVStack());
//printd(5, "TopLevelStatementBlock::parseInitTopLevel(this=%p): done (lvars=%p, %d vars, vstack = %p)\n", this, lvars, lvids, getVStack());
return;
}
int ContextStatement::parseInitImpl(LocalVar *oflag, int pflag) {
QORE_TRACE("ContextStatement::parseInitImpl()");
int lvids = 0;
// turn off top-level flag for statement vars
pflag &= (~PF_TOP_LEVEL);
if (!exp && !getCVarStack())
parse_error("subcontext statement out of context");
const QoreTypeInfo *argTypeInfo = 0;
// initialize context expression
if (exp)
exp = exp->parseInit(oflag, pflag, lvids, argTypeInfo);
// need to push something on the stack even if the context is not named
push_cvar(name);
if (where_exp) {
argTypeInfo = 0;
where_exp = where_exp->parseInit(oflag, pflag, lvids, argTypeInfo);
}
if (sort_ascending) {
argTypeInfo = 0;
sort_ascending = sort_ascending->parseInit(oflag, pflag, lvids, argTypeInfo);
}
if (sort_descending) {
argTypeInfo = 0;
sort_descending = sort_descending->parseInit(oflag, pflag, lvids, argTypeInfo);
}
// initialize statement block
if (code)
code->parseInitImpl(oflag, pflag);
// save local variables
if (lvids)
lvars = new LVList(lvids);
pop_cvar();
return 0;
}
int qore_program_private::internParseCommit() {
QORE_TRACE("qore_program_private::internParseCommit()");
printd(5, "qore_program_private::internParseCommit() pgm: %p isEvent: %d\n", pgm, parseSink->isEvent());
// save and restore parse location on exit
// FIXME: remove this when all parseInit code sets the location manually (remove calls to update_parse_location in parseInit code)
SaveParseLocationHelper plh;
// if the first stage of parsing has already failed,
// then don't go forward
if (!parseSink->isEvent()) {
// initialize new statements second (for "our" and "my" declarations)
// also initializes namespaces, constants, etc
sb.parseInit(pwo.parse_options);
printd(5, "QoreProgram::internParseCommit() this: %p RootNS: %p\n", pgm, RootNS);
}
// if a parse exception has occurred, then back out all new
// changes to the QoreProgram atomically
int rc;
if (parseSink->isEvent()) {
internParseRollback();
requires_exception = false;
rc = -1;
}
else { // otherwise commit them
// merge pending namespace additions
qore_root_ns_private::parseCommit(*RootNS);
// commit pending statements
sb.parseCommit();
// commit pending domain
dom |= pend_dom;
pend_dom = 0;
rc = 0;
}
return rc;
}
void StatementBlock::parseInitConstructor(const QoreTypeInfo* typeInfo, UserVariantBase* uvb, BCAList* bcal, BCList* bcl) {
QORE_TRACE("StatementBlock::parseInitConstructor");
VariableBlockHelper vbh;
UserParamListLocalVarHelper ph(uvb, typeInfo);
// if there is a base constructor list, resolve all classes and
// ensure that all classes referenced are base classes of this class
if (bcal) {
// ensure that parse flags are set before initializing
ParseWarnHelper pwh(pwo);
for (bcalist_t::iterator i = bcal->begin(), e = bcal->end(); i != e; ++i) {
assert(typeInfo->getUniqueReturnClass());
(*i)->parseInit(bcl, typeInfo->getUniqueReturnClass()->getName());
}
}
// initialize code block
parseInitImpl(uvb->getUserSignature()->selfid);
}
int StatementBlock::parseInitIntern(LocalVar* oflag, int pflag, statement_list_t::iterator start) {
QORE_TRACE("StatementBlock::parseInitIntern");
int lvids = 0;
AbstractStatement* ret = 0;
if (start != statement_list.end())
++start;
else
start = statement_list.begin();
for (statement_list_t::iterator i = start, l = statement_list.last(), e = statement_list.end(); i != e; ++i) {
lvids += (*i)->parseInit(oflag, pflag);
if (!ret && i != l && (*i)->endsBlock()) {
// unreachable code found
qore_program_private::makeParseWarning(getProgram(), QP_WARN_UNREACHABLE_CODE, "UNREACHABLE-CODE", "code after this statement can never be reached");
ret = *i;
}
}
return lvids;
}
int StatementBlock::execIntern(AbstractQoreNode** return_value, ExceptionSink* xsink) {
QORE_TRACE("StatementBlock::execImpl()");
int rc = 0;
assert(xsink);
//printd(5, "StatementBlock::execImpl() this=%p, lvars=%p, %ld vars\n", this, lvars, lvars->size());
bool obe = !on_block_exit_list.empty();
// push "on block exit" iterator if necessary
if (obe)
pushBlock(on_block_exit_list.end());
// execute block
for (statement_list_t::iterator i = statement_list.begin(), e = statement_list.end(); i != e; ++i)
if ((rc = (*i)->exec(return_value, xsink)) || xsink->isEvent())
break;
// execute "on block exit" code if applicable
if (obe) {
ExceptionSink obe_xsink;
int nrc = 0;
bool error = *xsink;
for (block_list_t::iterator i = popBlock(), e = on_block_exit_list.end(); i != e; ++i) {
enum obe_type_e type = (*i).first;
if (type == OBE_Unconditional || (!error && type == OBE_Success) || (error && type == OBE_Error))
if ((*i).second)
nrc = (*i).second->execImpl(return_value, &obe_xsink);
}
if (obe_xsink)
xsink->assimilate(obe_xsink);
if (nrc)
rc = nrc;
}
return rc;
}
AbstractQoreNode* QoreXmlReader::getXmlData(ExceptionSink* xsink, const QoreEncoding* data_ccsid, int pflags, int min_depth) {
xml_stack xstack;
QORE_TRACE("getXMLData()");
int rc = 1;
while (rc == 1) {
int nt = nodeTypeSkipWhitespace();
// get node name
const char* name = constName();
if (!name)
name = "--";
if (nt == -1) // ERROR
break;
if (nt == XML_READER_TYPE_ELEMENT) {
int depth = QoreXmlReader::depth();
xstack.checkDepth(depth);
AbstractQoreNode* n = xstack.getNode();
// if there is no node pointer, then make a hash
if (!n) {
QoreHashNode* h = new QoreHashNode;
xstack.setNode(h);
xstack.push(h->getKeyValuePtr(name), depth);
}
else { // node ptr already exists
QoreHashNode* h = n->getType() == NT_HASH ? reinterpret_cast<QoreHashNode*>(n) : 0;
if (!h) {
h = new QoreHashNode;
xstack.setNode(h);
h->setKeyValue("^value^", n, 0);
xstack.incValueCount();
xstack.push(h->getKeyValuePtr(name), depth);
}
else {
// see if key already exists
AbstractQoreNode* v;
bool exists;
v = h->getKeyValueExistence(name, exists);
if (!exists)
xstack.push(h->getKeyValuePtr(name), depth);
else {
if (!(pflags & XPF_PRESERVE_ORDER)) {
QoreListNode* vl = get_node_type(v) == NT_LIST ? reinterpret_cast<QoreListNode*>(v) : 0;
// if it's not a list, then make into a list with current value as first entry
if (!vl) {
AbstractQoreNode** vp = h->getKeyValuePtr(name);
vl = new QoreListNode;
vl->push(v);
(*vp) = vl;
}
xstack.push(vl->get_entry_ptr(vl->size()), depth);
}
else {
// see if last key was the same, if so make a list if it's not
const char* lk = h->getLastKey();
bool get_value = false;
if (keys_are_equal(name, lk, get_value)) {
// get actual key value if there was a suffix
if (get_value)
v = h->getKeyValue(lk);
QoreListNode* vl = get_node_type(v) == NT_LIST ? reinterpret_cast<QoreListNode*>(v) : 0;
// if it's not a list, then make into a list with current value as first entry
if (!vl) {
AbstractQoreNode** vp = h->getKeyValuePtr(lk);
vl = new QoreListNode;
vl->push(v);
(*vp) = vl;
}
xstack.push(vl->get_entry_ptr(vl->size()), depth);
}
else {
QoreString ns;
int c = 1;
while (true) {
ns.sprintf("%s^%d", name, c);
if (!h->existsKey(ns.getBuffer()))
break;
c++;
ns.clear();
}
xstack.push(h->getKeyValuePtr(ns.getBuffer()), depth);
}
}
}
}
}
// add attributes to structure if possible
if (hasAttributes()) {
ReferenceHolder<QoreHashNode> h(new QoreHashNode, xsink);
while (moveToNextAttribute(xsink) == 1) {
const char* aname = constName();
QoreStringNode* value = getValue(data_ccsid, xsink);
if (!value)
return 0;
h->setKeyValue(aname, value, xsink);
}
if (*xsink)
return 0;
// make new new a hash and assign "^attributes^" key
QoreHashNode* nv = new QoreHashNode;
nv->setKeyValue("^attributes^", h.release(), xsink);
xstack.setNode(nv);
}
//printd(5, "%s: type: %d, hasValue: %d, empty: %d, depth: %d\n", name, nt, xmlTextReaderHasValue(reader), xmlTextReaderIsEmptyElement(reader), depth);
}
else if (nt == XML_READER_TYPE_TEXT) {
int depth = QoreXmlReader::depth();
xstack.checkDepth(depth);
const char* str = constValue();
if (str) {
QoreStringNodeHolder val(getValue(data_ccsid, xsink));
if (!val)
return 0;
AbstractQoreNode* n = xstack.getNode();
if (n) {
QoreHashNode* h = n->getType() == NT_HASH ? reinterpret_cast<QoreHashNode*>(n) : 0;
if (h) {
if (!xstack.getValueCount())
h->setKeyValue("^value^", val.release(), xsink);
else {
QoreString kstr;
kstr.sprintf("^value%d^", xstack.getValueCount());
h->setKeyValue(kstr.getBuffer(), val.release(), xsink);
}
}
else { // convert value to hash and save value node
h = new QoreHashNode;
xstack.setNode(h);
h->setKeyValue("^value^", n, 0);
xstack.incValueCount();
QoreString kstr;
kstr.sprintf("^value%d^", 1);
h->setKeyValue(kstr.getBuffer(), val.release(), xsink);
}
xstack.incValueCount();
}
else
xstack.setNode(val.release());
}
}
else if (nt == XML_READER_TYPE_CDATA) {
int depth = QoreXmlReader::depth();
xstack.checkDepth(depth);
const char* str = constValue();
if (str) {
QoreStringNode* val = getValue(data_ccsid, xsink);
if (!val)
return 0;
AbstractQoreNode* n = xstack.getNode();
if (n && n->getType() == NT_HASH) {
QoreHashNode* h = reinterpret_cast<QoreHashNode*>(n);
if (!xstack.getCDataCount())
h->setKeyValue("^cdata^", val, xsink);
else {
QoreString kstr;
kstr.sprintf("^cdata%d^", xstack.getCDataCount());
h->setKeyValue(kstr.getBuffer(), val, xsink);
}
}
else { // convert value to hash and save value node
QoreHashNode* h = new QoreHashNode;
xstack.setNode(h);
if (n) {
h->setKeyValue("^value^", n, 0);
xstack.incValueCount();
}
h->setKeyValue("^cdata^", val, xsink);
}
xstack.incCDataCount();
}
}
rc = read();
if (min_depth > 0 && QoreXmlReader::depth() < min_depth) {
rc = 0;
break;
}
}
return rc ? 0 : xstack.getVal();
}
static void ssh2_module_delete() {
QORE_TRACE("ssh2_module_delete()");
}