static const QoreStringNode* get_string_header_node(ExceptionSink* xsink, QoreHashNode& h, const char* header, bool allow_multiple = false) { AbstractQoreNode* n = h.getKeyValue(header); if (!n) return 0; qore_type_t t = get_node_type(n); if (t == NT_STRING) return reinterpret_cast<const QoreStringNode*>(n); assert(t == NT_LIST); if (!allow_multiple) { xsink->raiseException("HTTP-HEADER-ERROR", "multiple \"%s\" headers received in HTTP message", header); return 0; } // convert list to a comma-separated string QoreListNode* l = reinterpret_cast<QoreListNode*>(n); // get first list entry n = l->retrieve_entry(0); assert(get_node_type(n) == NT_STRING); QoreStringNode* rv = reinterpret_cast<QoreStringNode*>(n)->copy(); for (size_t i = 1; i < l->size(); ++i) { n = l->retrieve_entry(i); assert(get_node_type(n) == NT_STRING); rv->concat(','); rv->concat(reinterpret_cast<QoreStringNode*>(n)); } // dereference old list and save reference to return value in header hash h.setKeyValue(header, rv, xsink); return rv; }
QoreNumberNode::QoreNumberNode(const AbstractQoreNode* n) : SimpleValueQoreNode(NT_NUMBER), priv(0) { qore_type_t t = get_node_type(n); if (t == NT_NUMBER) { priv = new qore_number_private(*reinterpret_cast<const QoreNumberNode*>(n)->priv); return; } if (t == NT_FLOAT) { priv = new qore_number_private(reinterpret_cast<const QoreFloatNode*>(n)->f); return; } if (t == NT_STRING) { priv = new qore_number_private(reinterpret_cast<const QoreStringNode*>(n)->getBuffer()); return; } if (t == NT_INT || (t > QORE_NUM_TYPES && dynamic_cast<const QoreBigIntNode*>(n))) { priv = new qore_number_private(reinterpret_cast<const QoreBigIntNode*>(n)->val); return; } if (t != NT_BOOLEAN && t != NT_DATE && t != NT_NULL) { priv = new qore_number_private(0ll); return; } priv = new qore_number_private(n->getAsFloat()); }
int ConstantEntry::scanValue(const AbstractQoreNode* n) const { switch (get_node_type(n)) { case NT_LIST: { ConstListIterator i(reinterpret_cast<const QoreListNode*>(n)); while (i.next()) if (scanValue(i.getValue())) return -1; return 0; } case NT_HASH: { ConstHashIterator i(reinterpret_cast<const QoreHashNode*>(n)); while (i.next()) if (scanValue(i.getValue())) return -1; return 0; } // could have any value and could change at runtime case NT_OBJECT: case NT_FUNCREF: return -1; } return 0; }
AbstractQoreNode* QoreValue::assignAndSanitize(const AbstractQoreNode* n) { AbstractQoreNode* rv = takeIfNode(); switch (get_node_type(n)) { case NT_NOTHING: type = QV_Node; v.n = 0; break; case NT_INT: type = QV_Int; v.i = reinterpret_cast<const QoreBigIntNode*>(n)->val; break; case NT_FLOAT: type = QV_Float; v.f = reinterpret_cast<const QoreFloatNode*>(n)->f; break; case NT_BOOLEAN: type = QV_Bool; v.b = reinterpret_cast<const QoreBoolNode*>(n)->getValue(); break; default: type = QV_Node; v.n = n->refSelf(); break; } return rv; }
static void check_constant_cycle(QoreProgram* pgm, AbstractQoreNode* n) { qore_type_t t = get_node_type(n); if (t == NT_LIST) check_constant_cycle_list(pgm, reinterpret_cast<QoreListNode*>(n)); else if (t == NT_HASH) check_constant_cycle_hash(pgm, reinterpret_cast<QoreHashNode*>(n)); }
void fill_node_data_structures( int tr, int type) {/* Init fill_node_data_structures */ Node_p list = NULL; Node_p node_ptr = NULL; list = node_ptr = get_place_list(tr,type); for( ; node_ptr != NULL ; node_ptr = NEXT_NODE(node_ptr)) {/* Per ogni nodo della lista */ #ifdef SWN node_ptr->type = get_node_type(node_ptr,tr); node_ptr->fun_card = get_node_cardinality(node_ptr,tr); node_ptr->skip = is_independent_from_instance(node_ptr); #endif if(type==INPUT || type==OUTPUT) node_ptr->test_arc = is_test_arc(node_ptr,type,tr); #ifdef SWN if(!node_ptr->skip && type == INHIBITOR) node_ptr->type = COMPLEX; #endif }/* Per ogni nodo della lista */ #ifdef SWN order_nodes(list,type); #endif }/* End fill_node_data_structures */
static void build_trap145(ib_mad_notice_attr_t * n, ib_portid_t * port) { n->generic_type = 0x80 | IB_NOTICE_TYPE_INFO; n->g_or_v.generic.prod_type_lsb = cl_hton16(get_node_type(port)); n->g_or_v.generic.trap_num = cl_hton16(145); n->issuer_lid = cl_hton16((uint16_t) port->lid); n->data_details.ntc_145.new_sys_guid = cl_hton64(0x1234567812345678); }
bool is_container(const AbstractQoreNode* n) { switch (get_node_type(n)) { case NT_OBJECT: case NT_LIST: case NT_HASH: return true; } return false; }
void qore_relative_time::set(const QoreValue v) { switch (v.type) { case QV_Bool: { set(0, 0, 0, 0, 0, (int)v.v.b, 0); break; } case QV_Int: { zero(); addSecondsTo(v.v.i); break; } case QV_Float: { zero(); addSecondsTo(v.v.f); break; } case QV_Node: switch (get_node_type(v.v.n)) { case NT_BOOLEAN: { set(0, 0, 0, 0, 0, (int)reinterpret_cast<const QoreBoolNode*>(v.v.n)->getValue(), 0); break; } case NT_INT: { addSecondsTo(reinterpret_cast<const QoreBigIntNode*>(v.v.n)->val, 0); break; } case NT_FLOAT: { double f = reinterpret_cast<const QoreFloatNode*>(v.v.n)->f; zero(); addSecondsTo(f); break; } case NT_STRING: { const char* str = reinterpret_cast<const QoreStringNode*>(v.v.n)->getBuffer(); set(str); break; } case NT_DATE: { const DateTimeNode* d = reinterpret_cast<const DateTimeNode*>(v.v.n); if (d->priv->relative) set(d->priv->d.rel); else { zero(); addSecondsTo(d->priv->d.abs.epoch, d->priv->d.abs.us); } break; } default: double f = v.v.n ? v.v.n->getAsFloat() : 0.0; zero(); addSecondsTo(f); break; } break; } }
static void build_trap129(ib_mad_notice_attr_t * n, ib_portid_t * port) { n->generic_type = 0x80 | IB_NOTICE_TYPE_URGENT; n->g_or_v.generic.prod_type_lsb = cl_hton16(get_node_type(port)); n->g_or_v.generic.trap_num = cl_hton16(129); n->issuer_lid = cl_hton16((uint16_t) port->lid); n->data_details.ntc_129_131.lid = n->issuer_lid; n->data_details.ntc_129_131.pad = 0; n->data_details.ntc_129_131.port_num = (uint8_t) error_port; }
static void build_trap144_local(ib_mad_notice_attr_t * n, ib_portid_t * port) { n->generic_type = 0x80 | IB_NOTICE_TYPE_INFO; n->g_or_v.generic.prod_type_lsb = cl_hton16(get_node_type(port)); n->g_or_v.generic.trap_num = cl_hton16(144); n->issuer_lid = cl_hton16((uint16_t) port->lid); n->data_details.ntc_144.lid = n->issuer_lid; n->data_details.ntc_144.new_cap_mask = cl_hton32(get_cap_mask(port)); n->data_details.ntc_144.local_changes = TRAP_144_MASK_OTHER_LOCAL_CHANGES; }
/******************************************************************************* * This function takes the base address of the CCN's programmer's view (PV) and * the node ID of a Request Node (RN-D or RN-I). It returns the maximum number * of master interfaces resident on that node. This number is equal to the least * significant two bits of the node type ID + 1. ******************************************************************************/ static unsigned int ccn_get_rni_mcount(uintptr_t periphbase, unsigned int rn_id) { unsigned int rn_type_id; /* Use the node id to find the type of RN-I/D node */ rn_type_id = get_node_type(ccn_reg_read(periphbase, rn_id + RNI_REGION_ID_START, REGION_ID_OFFSET)); /* Return the number master interfaces based on node type */ return rn_type_id_to_master_cnt(rn_type_id); }
QoreNumberNode* QoreNumberNode::toNumber(const AbstractQoreNode* n) { qore_type_t t = get_node_type(n); if (t == NT_NUMBER) return reinterpret_cast<const QoreNumberNode*>(n)->numberRefSelf(); if (t == NT_FLOAT) return new QoreNumberNode(reinterpret_cast<const QoreFloatNode*>(n)->f); if (t == NT_STRING) return new QoreNumberNode(reinterpret_cast<const QoreStringNode*>(n)->getBuffer()); if (t == NT_INT || (t > QORE_NUM_TYPES && dynamic_cast<const QoreBigIntNode*>(n))) return new QoreNumberNode(reinterpret_cast<const QoreBigIntNode*>(n)->val); return new QoreNumberNode(n ? n->getAsFloat() : 0.0); }
static void xcss_parse(syntree_t res) { xcss_node_type_t nd_type; str_it_t e = str_end(syntree_str(res)); if(nd_type = get_node_type(syntree_position(res), e)) { syntree_named_start(res, nd_type); if(err()) return; switch(nd_type) { case XCSS_NODE_RULE: parse_node_rule(res); break; case XCSS_NODE_NAMESPACE: parse_node_namespace(res); break; case XCSS_NODE_CLASS: parse_node_class(res); break; case XCSS_NODE_COMMENT: parse_node_comment(res); break; case XCSS_NODE_INCLUDE: parse_node_include(res); break; default: { assert(0); /* Invalid node type*/ } } if(err()) return; syntree_named_end(res); } else { str_it_t i = syntree_position(res); str_it_t e = str_end(syntree_str(res)); p_skip_spaces(i, e); syntree_seek(res, i); if(i!=e) { err_set(e_xcss_syntax); return; } } return; }
void ConstantEntry::del(ExceptionSink* xsink) { if (saved_node) { node->deref(xsink); saved_node->deref(xsink); #ifdef DEBUG node = 0; saved_node = 0; #endif } else if (node) { // abort if an object is present and we are calling deref without an ExceptionSink object assert(get_node_type(node) != NT_OBJECT || xsink); node->deref(xsink); #ifdef DEBUG node = 0; #endif } deref(); }
int ForEachStatement::parseInitImpl(LocalVar *oflag, int pflag) { int lvids = 0; // turn off top-level flag for statement vars pflag &= (~PF_TOP_LEVEL); const QoreTypeInfo *argTypeInfo = 0; if (var) var = var->parseInit(oflag, pflag, lvids, argTypeInfo); qore_type_t t = get_node_type(var); if (t != NT_VARREF && t != NT_SELF_VARREF) parse_error("foreach variable expression is not a variable reference (got type '%s' instead)", get_type_name(var)); if (list) { argTypeInfo = 0; list = list->parseInit(oflag, pflag, lvids, argTypeInfo); } if (code) code->parseInitImpl(oflag, pflag); // save local variables if (lvids) lvars = new LVList(lvids); qore_type_t typ = list->getType(); is_ref = (typ == NT_PARSEREFERENCE); // check for "keys <hash>" specialization if (!is_ref && typ == NT_TREE) { QoreTreeNode* t = reinterpret_cast<QoreTreeNode*>(list); if (t->getOp() == OP_KEYS) is_keys = true; } return 0; }
QoreValue::QoreValue(const AbstractQoreNode* n) { switch (get_node_type(n)) { case NT_NOTHING: type = QV_Node; v.n = 0; return; case NT_INT: type = QV_Int; v.i = reinterpret_cast<const QoreBigIntNode*>(n)->val; return; case NT_FLOAT: type = QV_Float; v.f = reinterpret_cast<const QoreFloatNode*>(n)->f; return; case NT_BOOLEAN: type = QV_Bool; v.b = reinterpret_cast<const QoreBoolNode*>(n)->getValue(); return; } type = QV_Node; // n cannot be 0 here because we covered the NT_NOTHING case above v.n = n->refSelf(); }
static int print_node_value(spinNodeHandle hNode ) { char displayName[MAX_BUFF_LEN]; size_t displayNameLength = MAX_BUFF_LEN; char value[MAX_BUFF_LEN]; size_t valueLength = MAX_BUFF_LEN; spinNodeType type; char out_string[256]; if( get_node_type(&type,hNode) < 0 ) return -1; if( get_display_name(displayName,&displayNameLength,hNode) < 0 ) return -1; if( type == CategoryNode ){ sprintf(out_string,"%s", displayName); } else { if( get_node_value_string(value,&valueLength,hNode) < 0 ) return -1; sprintf(out_string,"%s: %s", displayName,value); } printf("%s\n",out_string); return 0; }
// return the pseudo class for the given node static QoreClass* pseudo_get_class(const AbstractQoreNode *n) { return pseudo_get_class(get_node_type(n)); }
bool DomNode::is_comment() const { return get_node_type() == COMMENT_NODE; }
/**************************************************************************** Name : avnd_cb_create Description : This routine creates & initializes AvND control block. Arguments : None. Return Values : if successfull, ptr to AvND control block else, 0 Notes : None ******************************************************************************/ AVND_CB *avnd_cb_create() { AVND_CB *cb = avnd_cb; uns32 rc = NCSCC_RC_SUCCESS; SaVersionT ntfVersion = { 'A', 0x01, 0x01 }; SaNtfCallbacksT ntfCallbacks = { NULL, NULL }; SaVersionT immVersion = { 'A', 2, 1 }; char *val; TRACE_ENTER(); /* assign the AvND pool-id (used by hdl-mngr) */ cb->pool_id = NCS_HM_POOL_ID_COMMON; /* assign the default states */ cb->admin_state = SA_AMF_ADMIN_UNLOCKED; cb->oper_state = SA_AMF_OPERATIONAL_ENABLED; cb->term_state = AVND_TERM_STATE_UP; cb->led_state = AVND_LED_STATE_RED; cb->stby_sync_state = AVND_STBY_IN_SYNC; /* assign the default timeout values (in nsec) */ cb->msg_resp_intv = AVND_AVD_MSG_RESP_TIME * 1000000; cb->hb_duration_tmr.is_active = FALSE; cb->hb_duration_tmr.type = AVND_TMR_HB_DURATION; cb->hb_duration = AVSV_DEF_HB_DURATION; if ((val = getenv("AVSV_HB_DURATION")) != NULL) { cb->hb_duration = strtoll(val, NULL, 0); if (cb->hb_duration == 0) { /* no value or non convertable value, revert to default */ cb->hb_duration = AVSV_DEF_HB_DURATION; } } /* initialize the AvND cb lock */ m_NCS_LOCK_INIT(&cb->lock); TRACE_1("Initialized the AvND lock"); /* initialize the PID monitor lock */ m_NCS_LOCK_INIT(&cb->mon_lock); /* iniialize the error escaltion paramaets */ cb->node_err_esc_level = AVND_ERR_ESC_LEVEL_0; immutil_saImmOmInitialize(&cb->immOmHandle, NULL, &immVersion); /*** initialize avnd dbs ***/ /* initialize su db */ if (NCSCC_RC_SUCCESS != avnd_sudb_init(cb)) goto err; /* initialize comp db */ if (NCSCC_RC_SUCCESS != avnd_compdb_init(cb)) goto err; /* initialize healthcheck db */ avnd_hcdb_init(cb); avnd_cb->type = get_node_type(); /* initialize pg db */ if (NCSCC_RC_SUCCESS != avnd_pgdb_init(cb)) goto err; /* initialize pid_mon list */ avnd_pid_mon_list_init(cb); /* initialize nodeid to mdsdest mapping db */ if (NCSCC_RC_SUCCESS != avnd_nodeid_to_mdsdest_map_db_init(cb)) goto err; /* initialize available internode components db */ if (NCSCC_RC_SUCCESS != avnd_internode_avail_comp_db_init(cb)) goto err; /* NTFA Initialization */ rc = saNtfInitialize(&cb->ntfHandle, &ntfCallbacks, &ntfVersion); if (rc != SA_AIS_OK) { /* log the error code here */ LOG_ER("saNtfInitialize Failed (%u)", rc); goto err; } immutil_saImmOmInitialize(&cb->immOmHandle, NULL, &immVersion); TRACE_LEAVE(); return cb; err: if (cb) avnd_cb_destroy(cb); TRACE_LEAVE(); return 0; }
bool DomNode::is_document_type() const { return get_node_type() == DOCUMENT_TYPE_NODE; }
void qore_absolute_time::set(const AbstractQoreZoneInfo* n_zone, const QoreValue v) { switch (v.type) { case QV_Bool: { zone = n_zone; epoch = v.v.b ? 1 : 0; us = 0; break; } case QV_Int: { set(n_zone, v.v.i, 0); break; } case QV_Float: { set(v.v.f, n_zone); break; } case QV_Node: switch (get_node_type(v.v.n)) { case NT_BOOLEAN: { zone = n_zone; epoch = reinterpret_cast<const QoreBoolNode*>(v.v.n)->getValue(); us = 0; break; } case NT_INT: { set(n_zone, reinterpret_cast<const QoreBigIntNode*>(v.v.n)->val, 0); break; } case NT_FLOAT: { double f = reinterpret_cast<const QoreFloatNode*>(v.v.n)->f; set(f, n_zone); break; } case NT_STRING: { const char* str = reinterpret_cast<const QoreStringNode*>(v.v.n)->getBuffer(); set(str, n_zone); break; } case NT_DATE: { const DateTimeNode* d = reinterpret_cast<const DateTimeNode*>(v.v.n); if (d->priv->relative) { int64 us = d->priv->d.rel.getRelativeMicroseconds(); int64 s = us / 1000000; us -= s * 1000000; set(n_zone, s, us); } else set(d->priv->d.abs); break; } default: { double f = v.v.n ? v.v.n->getAsFloat() : 0.0; set(f, n_zone); break; } } break; default: assert(false); break; } }
// specialization for foreach ... in (keys <hash>) {} int ForEachStatement::execKeys(QoreValue& return_value, ExceptionSink* xsink) { // instantiate local variables LVListInstantiator lvi(lvars, xsink); assert(get_node_type(list) == NT_TREE); QoreTreeNode* t = reinterpret_cast<QoreTreeNode*>(list); QoreHashNodeHolder hash(reinterpret_cast<QoreHashNode*>(t->left->eval(xsink)), xsink); if (*xsink || !code) return 0; qore_type_t hnt = get_node_type(*hash); // create an empty reference holder for a temporary hash in case the operand is an object ReferenceHolder<QoreHashNode> hh(xsink); const QoreHashNode* h; // if the result is not a hash, then return if (hnt == NT_OBJECT) { hh = reinterpret_cast<const QoreObject *>(*hash)->getRuntimeMemberHash(xsink); if (*xsink) return 0; h = *hh; } else if (hnt != NT_HASH) { return 0; } else h = reinterpret_cast<const QoreHashNode*>(*hash); ConstHashIterator hi(h); int rc = 0; int i = 0; while (hi.next()) { { LValueHelper n(var, xsink); if (!n) break; // assign variable to current key value in list if (n.assign(new QoreStringNode(hi.getKey()))) break; } // set offset in thread-local data for "$#" ImplicitElementHelper eh(i++); // execute "foreach" body if (((rc = code->execImpl(return_value, xsink)) == RC_BREAK) || *xsink) { rc = 0; break; } if (rc == RC_RETURN) break; else if (rc == RC_CONTINUE) rc = 0; } return rc; }
void qore_queue_private::clearIntern(ExceptionSink* xsink) { while (head) { printd(5, "qore_queue_private::clearIntern() this: %p deleting %p (node %p type %s)\n", this, head, head->node, get_node_type(head->node)); QoreQueueNode* w = head->next; head->del(xsink); head = w; } head = 0; tail = 0; }
status_t fs_read_vnode(fs_volume *_vol, ino_t vnid, fs_vnode *_node, int *_type, uint32 *_flags, bool reenter) { nspace *ns = (nspace*)_vol->private_volume; vnode *newNode = NULL; ntfs_inode *ni = NULL; status_t result = B_NO_ERROR; if (!reenter) LOCK_VOL(ns); ERRPRINT("fs_read_vnode - ENTER\n"); _node->private_node = NULL; _node->ops = &gNTFSVnodeOps; _flags = 0; newNode = (vnode*)ntfs_calloc(sizeof(vnode)); if (newNode != NULL) { char *name = NULL; ni = ntfs_inode_open(ns->ntvol, vnid); if (ni == NULL) { result = ENOENT; goto exit; } // get the node type result = get_node_type(ni, _type); if (result != B_OK) goto exit; newNode->vnid = vnid; newNode->parent_vnid = ntfs_get_parent_ref(ni); if (ni->mrec->flags & MFT_RECORD_IS_DIRECTORY) set_mime(newNode, ".***"); else { name = (char*)malloc(MAX_PATH); if (name != NULL) { if (utils_inode_get_name(ni, name,MAX_PATH) == 1) set_mime(newNode, name); free(name); } } _node->private_node = newNode; } else result = ENOMEM; exit: if (ni != NULL) ntfs_inode_close(ni); if (result != B_OK && newNode != NULL) free(newNode); ERRPRINT("fs_read_vnode - EXIT, result is %s\n", strerror(result)); if (!reenter) UNLOCK_VOL(ns); return result; }
bool DomNode::is_notation() const { return get_node_type() == NOTATION_NODE; }
bool DomNode::is_document_fragment() const { return get_node_type() == DOCUMENT_FRAGMENT_NODE; }
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(); }
bool DomNode::is_processing_instruction() const { return get_node_type() == PROCESSING_INSTRUCTION_NODE; }