int XMIResource::loadBase64(xmlTextReaderPtr reader, enum object_properties_t property, const model::BaseObject& o) { // iterate on attributes for (int rc = xmlTextReaderMoveToFirstAttribute(reader); rc > 0; rc = xmlTextReaderMoveToNextAttribute(reader)) { auto found = std::find(constXcosNames.begin(), constXcosNames.end(), xmlTextReaderConstName(reader)); enum xcosNames current = static_cast<enum xcosNames>(std::distance(constXcosNames.begin(), found)); switch (current) { case e_base64: { const xmlChar* base64 = xmlTextReaderConstValue(reader); std::vector<double> v = base64::decode<std::vector<double> >(to_string(base64)); controller.setObjectProperty(o.id(), o.kind(), property, v); break; } default: // ignore other parameters // TODO: Does other metamodels might be managed there ? break; } } return 1; }
gboolean xml_reader_move_to_first_attribute (XmlReader *reader) { g_return_val_if_fail (XML_IS_READER (reader), FALSE); return (xmlTextReaderMoveToFirstAttribute (reader->xml) == 1); }
/* * Parse the configuration file's pg element about connection information */ static void ows_parse_config_pg(ows * o, xmlTextReaderPtr r) { xmlChar *a, *v; assert(o); assert(r); if (xmlTextReaderMoveToFirstAttribute(r) != 1) return; do { a = xmlTextReaderName(r); if ( !strcmp((char *) a, "host") || !strcmp((char *) a, "user") || !strcmp((char *) a, "password") || !strcmp((char *) a, "dbname") || !strcmp((char *) a, "port")) { v = xmlTextReaderValue(r); buffer_add_str(o->pg_dsn, (char *) a); buffer_add_str(o->pg_dsn, "="); buffer_add_str(o->pg_dsn, (char *) v); buffer_add_str(o->pg_dsn, " "); xmlFree(v); } else if (!strcmp((char *) a, "encoding")) { v = xmlTextReaderValue(r); buffer_add_str(o->db_encoding, (char *) v); xmlFree(v); } xmlFree(a); } while (xmlTextReaderMoveToNextAttribute(r) == 1); if (!o->db_encoding->use) buffer_add_str(o->db_encoding, OWS_DEFAULT_DB_ENCODING); }
int XMIResource::loadPoint(xmlTextReaderPtr reader, const model::BaseObject& o) { assert(o.kind() == LINK); std::vector<double> points; controller.getObjectProperty(o.id(), o.kind(), CONTROL_POINTS, points); // iterate on attributes for (int rc = xmlTextReaderMoveToFirstAttribute(reader); rc > 0; rc = xmlTextReaderMoveToNextAttribute(reader)) { auto found = std::find(constXcosNames.begin(), constXcosNames.end(), xmlTextReaderConstName(reader)); enum xcosNames current = static_cast<enum xcosNames>(std::distance(constXcosNames.begin(), found)); switch (current) { case e_x: points.push_back(to_double(xmlTextReaderConstValue(reader))); break; case e_y: points.push_back(to_double(xmlTextReaderConstValue(reader))); break; default: // ignore other parameters // TODO: Does other metamodels might be managed there ? break; } } controller.setObjectProperty(o.id(), o.kind(), CONTROL_POINTS, points); return 1; }
int XMIResource::loadDiagram(xmlTextReaderPtr reader, const model::BaseObject& o) { assert(o.kind() == DIAGRAM); // abstract Layer is not decoded there as it has no attribute // iterate on attributes for (int rc = xmlTextReaderMoveToFirstAttribute(reader); rc > 0; rc = xmlTextReaderMoveToNextAttribute(reader)) { auto found = std::find(constXcosNames.begin(), constXcosNames.end(), xmlTextReaderConstName(reader)); enum xcosNames current = static_cast<enum xcosNames>(std::distance(constXcosNames.begin(), found)); switch (current) { case e_title: controller.setObjectProperty(o.id(), o.kind(), TITLE, to_string(xmlTextReaderConstValue(reader))); break; case e_path: controller.setObjectProperty(o.id(), o.kind(), PATH, to_string(xmlTextReaderConstValue(reader))); break; case e_debugLevel: controller.setObjectProperty(o.id(), o.kind(), DEBUG_LEVEL, to_int(xmlTextReaderConstValue(reader))); break; case e_version: controller.setObjectProperty(o.id(), o.kind(), VERSION_NUMBER, to_string(xmlTextReaderConstValue(reader))); break; default: // ignore other parameters // TODO: Does other metamodels might be managed there ? break; } } return 1; }
static int _exml_read(EXML *xml, xmlTextReaderPtr reader) { int empty; xmlChar *name, *value; if (!reader) return -1; exml_clear( xml ); while( xmlTextReaderRead( reader ) == 1 ) { name = xmlTextReaderName(reader); value = xmlTextReaderValue(reader); empty = xmlTextReaderIsEmptyElement(reader); switch( xmlTextReaderNodeType(reader) ) { case XML_READER_TYPE_ELEMENT: exml_start(xml); exml_tag_set(xml, (char *) name); if (xmlTextReaderHasAttributes(reader)) { xmlTextReaderMoveToFirstAttribute(reader); do { xmlChar *attr_name, *attr_value; attr_name = xmlTextReaderName(reader); attr_value = xmlTextReaderValue(reader); exml_attribute_set(xml, (char *) attr_name, (char *) attr_value); xmlFree(attr_name); xmlFree(attr_value); } while( xmlTextReaderMoveToNextAttribute(reader) == 1 ); } if (!empty) break; case XML_READER_TYPE_END_ELEMENT: exml_end(xml); break; case XML_READER_TYPE_WHITESPACE: break; case XML_READER_TYPE_TEXT: exml_value_set(xml, (char *) value); break; } xmlFree(name); xmlFree(value); } xmlTextReaderClose(reader); xmlFreeTextReader(reader); exml_goto_top( xml ); return TRUE; }
bool XmlReader::MoveToFirstAttribute() { end_element = false; bool r(xmlTextReaderMoveToFirstAttribute(libxml_stuff->reader) == 1); while (r) { int const node_type = xmlTextReaderNodeType(libxml_stuff->reader); if (node_type == XML_READER_TYPE_ATTRIBUTE) break; r = (xmlTextReaderMoveToNextAttribute(libxml_stuff->reader) == 1); } return r; //return (xmlTextReaderMoveToFirstAttribute(libxml_stuff->reader) == 1); }
int XMIResource::loadSimulationConfig(xmlTextReaderPtr reader, const model::BaseObject& o) { assert(o.kind() == DIAGRAM); std::vector<double> properties; controller.getObjectProperty(o.id(), o.kind(), PROPERTIES, properties); properties.resize(8); // iterate on attributes for (int rc = xmlTextReaderMoveToFirstAttribute(reader); rc > 0; rc = xmlTextReaderMoveToNextAttribute(reader)) { auto found = std::find(constXcosNames.begin(), constXcosNames.end(), xmlTextReaderConstName(reader)); enum xcosNames current = static_cast<enum xcosNames>(std::distance(constXcosNames.begin(), found)); switch (current) { case e_finalTime: properties[0] = to_double(xmlTextReaderConstValue(reader)); break; case e_absoluteTolerance: properties[1] = to_double(xmlTextReaderConstValue(reader)); break; case e_relativeTolerance: properties[2] = to_double(xmlTextReaderConstValue(reader)); break; case e_timeTolerance: properties[3] = to_double(xmlTextReaderConstValue(reader)); break; case e_deltaT: properties[4] = to_double(xmlTextReaderConstValue(reader)); break; case e_realtimeScale: properties[5] = to_double(xmlTextReaderConstValue(reader)); break; case e_solver: properties[6] = to_double(xmlTextReaderConstValue(reader)); break; case e_deltaH: properties[7] = to_double(xmlTextReaderConstValue(reader)); break; default: // ignore other parameters // TODO: Does other metamodels might be managed there ? break; } } controller.setObjectProperty(o.id(), o.kind(), PROPERTIES, properties); return 1; }
int XMIResource::loadAbstractBaseObject(xmlTextReaderPtr reader, const model::BaseObject& o) { assert(o.kind() == BLOCK || o.kind() == ANNOTATION || o.kind() == LINK); // abstract Layer is not decoded there as it has no attribute // iterate on attributes for (int rc = xmlTextReaderMoveToFirstAttribute(reader); rc > 0; rc = xmlTextReaderMoveToNextAttribute(reader)) { auto found = std::find(constXcosNames.begin(), constXcosNames.end(), xmlTextReaderConstName(reader)); enum xcosNames current = static_cast<enum xcosNames>(std::distance(constXcosNames.begin(), found)); switch (current) { case e_uid: { std::string uid = to_string(xmlTextReaderConstValue(reader)); controller.setObjectProperty(o.id(), o.kind(), UID, uid); references.insert(std::make_pair(uid, o.id())); break; } case e_parentDiagram: { // not lookup needed ; only one diagram is serialized at a time controller.setObjectProperty(o.id(), o.kind(), PARENT_DIAGRAM, root); break; } case e_parent: { // not lookup needed thanks to the XML hierarchy const model::BaseObject& parent = *(processed.end() - 2); controller.setObjectProperty(o.id(), o.kind(), PARENT_BLOCK, parent.id()); break; } default: // ignore other parameters // TODO: Does other metamodels might be managed there ? break; } } return 1; }
int XMIResource::loadAnnotation(xmlTextReaderPtr reader, const model::BaseObject& o) { assert(o.kind() == ANNOTATION); // load the base class int ret = loadAbstractBaseObject(reader, o); if (ret != 1) { return ret; } // geometry is handled as a node // iterate on attributes for (int rc = xmlTextReaderMoveToFirstAttribute(reader); rc > 0; rc = xmlTextReaderMoveToNextAttribute(reader)) { auto found = std::find(constXcosNames.begin(), constXcosNames.end(), xmlTextReaderConstName(reader)); enum xcosNames current = static_cast<enum xcosNames>(std::distance(constXcosNames.begin(), found)); switch (current) { case e_description: controller.setObjectProperty(o.id(), o.kind(), DESCRIPTION, to_string(xmlTextReaderConstValue(reader))); break; case e_font: controller.setObjectProperty(o.id(), o.kind(), FONT, to_string(xmlTextReaderConstValue(reader))); break; case e_fontSize: controller.setObjectProperty(o.id(), o.kind(), FONT_SIZE, to_string(xmlTextReaderConstValue(reader))); break; case e_style: controller.setObjectProperty(o.id(), o.kind(), STYLE, to_string(xmlTextReaderConstValue(reader))); break; default: // ignore other parameters // TODO: Does other metamodels might be managed there ? break; } } return ret; }
bool next() { int res; if(first) { res = xmlTextReaderMoveToFirstAttribute(reader); } else { res = xmlTextReaderMoveToNextAttribute(reader); } if(res < 0) throw std::runtime_error("parse error."); if(res == 0) { last = true; xmlTextReaderMoveToElement(reader); return false; } first = false; return true; }
int XMIResource::loadGeometry(xmlTextReaderPtr reader, const model::BaseObject& o) { assert(o.kind() == BLOCK || o.kind() == ANNOTATION || o.kind() == LINK); std::vector<double> geom; controller.getObjectProperty(o.id(), o.kind(), GEOMETRY, geom); geom.resize(4); // iterate on attributes for (int rc = xmlTextReaderMoveToFirstAttribute(reader); rc > 0; rc = xmlTextReaderMoveToNextAttribute(reader)) { auto found = std::find(constXcosNames.begin(), constXcosNames.end(), xmlTextReaderConstName(reader)); enum xcosNames current = static_cast<enum xcosNames>(std::distance(constXcosNames.begin(), found)); switch (current) { case e_x: geom[0] = to_double(xmlTextReaderConstValue(reader)); break; case e_y: geom[1] = to_double(xmlTextReaderConstValue(reader)); break; case e_width: geom[2] = to_double(xmlTextReaderConstValue(reader)); break; case e_height: geom[3] = to_double(xmlTextReaderConstValue(reader)); break; default: // ignore other parameters // TODO: Does other metamodels might be managed there ? break; } } controller.setObjectProperty(o.id(), o.kind(), GEOMETRY, geom); return 1; }
int XMIResource::loadBlock(xmlTextReaderPtr reader, const model::BaseObject& o) { assert(o.kind() == BLOCK); // load the base class int ret = loadAbstractBaseObject(reader, o); if (ret != 1) { return ret; } // Layer has no attribute so there is no need to decode it there // Geometry is handled as an element // iterate on attributes for (int rc = xmlTextReaderMoveToFirstAttribute(reader); rc > 0; rc = xmlTextReaderMoveToNextAttribute(reader)) { auto found = std::find(constXcosNames.begin(), constXcosNames.end(), xmlTextReaderConstName(reader)); enum xcosNames current = static_cast<enum xcosNames>(std::distance(constXcosNames.begin(), found)); switch (current) { case e_description: controller.setObjectProperty(o.id(), o.kind(), DESCRIPTION, to_string(xmlTextReaderConstValue(reader))); break; case e_label: controller.setObjectProperty(o.id(), o.kind(), LABEL, to_string(xmlTextReaderConstValue(reader))); break; case e_style: controller.setObjectProperty(o.id(), o.kind(), STYLE, to_string(xmlTextReaderConstValue(reader))); break; case e_interfaceFunction: controller.setObjectProperty(o.id(), o.kind(), INTERFACE_FUNCTION, to_string(xmlTextReaderConstValue(reader))); break; case e_functionName: controller.setObjectProperty(o.id(), o.kind(), SIM_FUNCTION_NAME, to_string(xmlTextReaderConstValue(reader))); break; case e_functionAPI: controller.setObjectProperty(o.id(), o.kind(), SIM_FUNCTION_API, to_int(xmlTextReaderConstValue(reader))); break; case e_dependsOnT: { std::vector<int> dep_ut; controller.getObjectProperty(o.id(), o.kind(), SIM_DEP_UT, dep_ut); dep_ut.resize(2); dep_ut[1] = to_int(xmlTextReaderConstValue(reader)); controller.setObjectProperty(o.id(), o.kind(), SIM_DEP_UT, dep_ut); break; } case e_dependsOnU: { std::vector<int> dep_ut; controller.getObjectProperty(o.id(), o.kind(), SIM_DEP_UT, dep_ut); dep_ut.resize(2); dep_ut[0] = to_int(xmlTextReaderConstValue(reader)); controller.setObjectProperty(o.id(), o.kind(), SIM_DEP_UT, dep_ut); break; } case e_blocktype: controller.setObjectProperty(o.id(), o.kind(), SIM_BLOCKTYPE, to_string(xmlTextReaderConstValue(reader))); break; default: // ignore other parameters // TODO: Does other metamodels might be managed there ? break; } } /* * Reset some properties loaded as array and initialized with non-empty value */ std::vector<int> empty_int_array; controller.setObjectProperty(o.id(), o.kind(), NZCROSS, empty_int_array); controller.setObjectProperty(o.id(), o.kind(), NMODE, empty_int_array); return 1; }
int XMIResource::loadPort(xmlTextReaderPtr reader, const model::BaseObject& o) { assert(o.kind() == PORT); // ignore datatype as it is managed as an XML node // iterate on attributes for (int rc = xmlTextReaderMoveToFirstAttribute(reader); rc > 0; rc = xmlTextReaderMoveToNextAttribute(reader)) { auto found = std::find(constXcosNames.begin(), constXcosNames.end(), xmlTextReaderConstName(reader)); enum xcosNames current = static_cast<enum xcosNames>(std::distance(constXcosNames.begin(), found)); switch (current) { case e_uid: { std::string uid = to_string(xmlTextReaderConstValue(reader)); controller.setObjectProperty(o.id(), o.kind(), UID, uid); references.insert(std::make_pair(uid, o.id())); break; } case e_firing: controller.setObjectProperty(o.id(), o.kind(), FIRING, to_double(xmlTextReaderConstValue(reader))); break; case e_sourceBlock: { // not lookup needed thanks to the XML hierarchy const model::BaseObject& parent = processed.back(); controller.setObjectProperty(o.id(), o.kind(), SOURCE_BLOCK, parent.id()); break; } case e_kind: { std::string portKindStr = to_string(xmlTextReaderConstValue(reader)); int k; if ("in" == portKindStr) { k = PORT_IN; } else if ("out" == portKindStr) { k = PORT_OUT; } else if ("ein" == portKindStr) { k = PORT_EIN; } else if ("eout" == portKindStr) { k = PORT_EOUT; } else { k = PORT_UNDEF; } controller.setObjectProperty(o.id(), o.kind(), PORT_KIND, k); break; } case e_implicit: controller.setObjectProperty(o.id(), o.kind(), IMPLICIT, to_int(xmlTextReaderConstValue(reader))); break; case e_connectedSignal: // will be resolved later unresolved.push_back( unresolvedReference(o.id(), o.kind(), CONNECTED_SIGNALS, to_string(xmlTextReaderConstValue(reader)))); break; case e_style: controller.setObjectProperty(o.id(), o.kind(), STYLE, to_string(xmlTextReaderConstValue(reader))); break; case e_label: controller.setObjectProperty(o.id(), o.kind(), LABEL, to_string(xmlTextReaderConstValue(reader))); break; default: // ignore other parameters // TODO: Does other metamodels might be managed there ? break; } } return 1; }
/* reader:move_to_first_attribute() */ static int xmlreader_move_to_first_attribute(lua_State *L) { xmlreader xr = check_xmlreader(L, 1); int ret = xmlTextReaderMoveToFirstAttribute(xr); BOOL_OR_ERROR(L, ret); }
static Eina_Bool _lng_read(Language_XML *xml, xmlTextReaderPtr reader) { Eina_Bool empty; xmlChar *name, *value; if (!reader) return EINA_FALSE; language_xml_clear(xml); while (xmlTextReaderRead(reader) == 1) { name = xmlTextReaderName(reader); value = xmlTextReaderValue(reader); empty = xmlTextReaderIsEmptyElement(reader); switch (xmlTextReaderNodeType(reader)) { case XML_READER_TYPE_ELEMENT: { _lng_start(xml); _lng_set(xml, (char *) name, NULL, "tag"); if (xmlTextReaderHasAttributes(reader)) { xmlTextReaderMoveToFirstAttribute(reader); do { xmlChar *attr_name, *attr_value; attr_name = xmlTextReaderName(reader); attr_value = xmlTextReaderValue(reader); _lng_set(xml, (char *) attr_name, (char *) attr_value, "atr"); xmlFree(attr_name); xmlFree(attr_value); } while (xmlTextReaderMoveToNextAttribute(reader) == 1); } if (!empty) break; } case XML_READER_TYPE_END_ELEMENT: { if (!xml) return EINA_FALSE; if (!xml->current) xml->current = xml->top; else xml->current = xml->current->parent; break; } case XML_READER_TYPE_WHITESPACE: break; case XML_READER_TYPE_TEXT: { _lng_set(xml, (char *) value, NULL, "val"); break; } } xmlFree(name); xmlFree(value); } xmlTextReaderClose(reader); xmlFreeTextReader(reader); xml->current = xml->top; return EINA_TRUE; }
/******************************************************************** * FUNCTION get_all_attrs * * Copy all the attributes from the current node to * the xml_attrs_t queue * * INPUTS: * scb == session control block * errnode == element node to use for reporting errors * msghdr == msg hdr w/ Q to get any rpc-errors as found, * NULL if not used * nserr == TRUE if unknown namespace should cause the * function to fail and the attr not to be saved * This is the normal mode. * == FALSE and the namespace will be marked INVALID * but an error will not be returned * * OUTPUTS: * attrs Q contains 0 or more entries * *msghdr.errQ may have rpc-errors added to it * * RETURNS: * status of the operation * returns NO_ERR if all copied okay or even zero copied *********************************************************************/ static status_t get_all_attrs (ses_cb_t *scb, xml_node_t *errnode, xml_attrs_t *attrs, ncx_layer_t layer, xml_msg_hdr_t *msghdr, boolean nserr) { /* check the attribute count first */ int cnt = xmlTextReaderAttributeCount(scb->reader); if (cnt==0) { return NO_ERR; } const xmlChar *name = NULL; status_t res = NO_ERR; boolean xpatherror = FALSE; int ret = 0; /* move through the list of attributes */ int i = 0; boolean done = FALSE; for (; i < cnt && !done; i++) { xmlChar *value = NULL; const xmlChar *badns = NULL; uint32 plen = 0; xmlns_id_t nsid = 0; res = NO_ERR; name = NULL; /* get the next attribute */ if (i==0) { ret = xmlTextReaderMoveToFirstAttribute(scb->reader); } else { ret = xmlTextReaderMoveToNextAttribute(scb->reader); } if (ret != 1) { res = ERR_XML_READER_INTERNAL; done = TRUE; } else { /* get the attribute name */ name = xmlTextReaderConstName(scb->reader); if (!name) { res = ERR_XML_READER_NULLNAME; } else { res = xml_check_ns(scb->reader, name, &nsid, &plen, &badns); if (!nserr && res != NO_ERR) { /* mask invalid namespace as requested */ nsid = xmlns_inv_id(); plen = 0; res = NO_ERR; } /* get the attribute value even if a NS error */ value = xmlTextReaderValue(scb->reader); if (!value) { res = ERR_XML_READER_NULLVAL; } else { /* save the values as received, may be QName * only error that can occur is a malloc fail */ xml_attr_t *attr = xml_add_qattr(attrs, nsid, name, plen, value, &res); if (!attr) { res = ERR_INTERNAL_MEM; } else { /* special hack: do not know which * attributes within an XML node * are tagged as XPath strings at this point * To save resources, only the 'select' and * 'key' attributes are supported at this time. */ if (!xml_strcmp(&name[plen], NCX_EL_SELECT)) { res = NO_ERR; attr->attr_xpcb = agt_new_xpath_pcb(scb, value, &res); if (!attr->attr_xpcb) { ; /* res already set */ } else { /* do a first pass parsing to resolve all * the prefixes and check well-formed XPath */ xpath_result_t *result = xpath1_eval_xmlexpr(scb->reader, attr->attr_xpcb, NULL, NULL, FALSE, FALSE, &res); if (res != NO_ERR) { xpatherror = TRUE; } xpath_free_result(result); } } else if (!xml_strcmp(&name[plen], NCX_EL_KEY)) { res = NO_ERR; attr->attr_xpcb = agt_new_xpath_pcb(scb, value, &res); if (!attr->attr_xpcb) { ; /* res already set */ } else { res = xpath_yang_validate_xmlkey (scb->reader, attr->attr_xpcb, NULL, FALSE); if (res != NO_ERR) { xpatherror = TRUE; } } } } } } } /* check the result */ if (res != NO_ERR && msghdr) { /* need a dummy attribute struct to report this error */ xml_attr_t errattr; memset(&errattr, 0x0, sizeof(xml_attr_t)); errattr.attr_ns = xmlns_nc_id(); errattr.attr_qname = name; errattr.attr_name = name; errattr.attr_val = value; /* save the error info */ if (xpatherror) { res = ERR_NCX_INVALID_XPATH_EXPR; /* generate an invalid-value error */ agt_record_attr_error(scb, msghdr, layer, res, &errattr, errnode, NULL, NCX_NT_NONE, NULL); } else if (res==ERR_XML_READER_NULLVAL || res==ERR_NCX_UNKNOWN_NAMESPACE) { /* generate a bad namespace error */ agt_record_attr_error(scb, msghdr, layer, res, &errattr, errnode, badns, NCX_NT_NONE, NULL); } else { /* generate a generic error */ agt_record_attr_error(scb, msghdr, layer, res, &errattr, errnode, NULL, NCX_NT_NONE, NULL); } } if (value) { xmlFree(value); } } /* reset the current node to where we started */ ret = xmlTextReaderMoveToElement(scb->reader); if (ret != 1) { if (msghdr) { res = ERR_XML_READER_INTERNAL; agt_record_error(scb, msghdr, layer, res, errnode, NCX_NT_STRING, name, NCX_NT_NONE, NULL); } } return res; } /* get_all_attrs */
bool XmlTextReader::MoveToFirstAttribute() const { return XmlCheck(xmlTextReaderMoveToFirstAttribute(ToReader(m_p))); }
/** * read file and print element paths */ int parse_xml_file(const char *filename) { int ret, prev_depth = 0; xmlTextReaderPtr reader; for (reader = xmlReaderForFile(filename, NULL, 0);;) { int depth; const xmlChar *name; xmlReaderTypes type; if (!reader) { fprintf(stderr, "couldn't read file '%s'\n", filename); exit(EXIT_BAD_FILE); } ret = xmlTextReaderRead(reader); if (ret <= 0) break; type = xmlTextReaderNodeType(reader); depth = xmlTextReaderDepth(reader); name = xmlTextReaderConstName(reader); if (type != XML_READER_TYPE_ELEMENT) continue; while (curXPath && depth <= prev_depth) { xmlChar *slash = BAD_CAST strrchr((char*) curXPath, '/'); if (slash) *slash = '\0'; prev_depth--; } prev_depth = depth; if (depth > 0) curXPath = xmlStrcat(curXPath, BAD_CAST "/"); curXPath = xmlStrcat(curXPath, name); if (elOps.show_attr) { int have_attr; fprintf(stdout, "%s\n", curXPath); for (have_attr = xmlTextReaderMoveToFirstAttribute(reader); have_attr; have_attr = xmlTextReaderMoveToNextAttribute(reader)) { const xmlChar *aname = xmlTextReaderConstName(reader); fprintf(stdout, "%s/@%s\n", curXPath, aname); } } else if (elOps.show_attr_and_val) { fprintf(stdout, "%s", curXPath); if (xmlTextReaderHasAttributes(reader)) { int have_attr, first = 1; fprintf(stdout, "["); for (have_attr = xmlTextReaderMoveToFirstAttribute(reader); have_attr; have_attr = xmlTextReaderMoveToNextAttribute(reader)) { const xmlChar *aname = xmlTextReaderConstName(reader), *avalue = xmlTextReaderConstValue(reader); char quote; if (!first) fprintf(stdout, " and "); first = 0; quote = xmlStrchr(avalue, '\'')? '"' : '\''; fprintf(stdout, "@%s=%c%s%c", aname, quote, avalue, quote); } fprintf(stdout, "]"); } fprintf(stdout, "\n"); } else if (elOps.sort_uniq) { if ((elOps.check_depth == 0) || (elOps.check_depth != 0 && depth < elOps.check_depth)) { xmlHashAddEntry(uniq, curXPath, (void*) 1); } } else fprintf(stdout, "%s\n", curXPath); } return ret == -1? EXIT_LIB_ERROR : ret; }
bool IWORKParser::parse() { const shared_ptr<xmlTextReader> sharedReader(xmlReaderForIO(readFromStream, closeStream, m_input.get(), "", 0, 0), xmlFreeTextReader); if (!sharedReader) return false; xmlTextReaderPtr reader = sharedReader.get(); assert(reader); const IWORKTokenizer &tokenizer = getTokenizer(); stack<IWORKXMLContextPtr_t> contextStack; int ret = xmlTextReaderRead(reader); contextStack.push(createDocumentContext()); while ((1 == ret)) { switch (xmlTextReaderNodeType(reader)) { case XML_READER_TYPE_ELEMENT: { const int id = tokenizer.getQualifiedId(char_cast(xmlTextReaderConstLocalName(reader)), char_cast(xmlTextReaderConstNamespaceUri(reader))); IWORKXMLContextPtr_t newContext = contextStack.top()->element(id); if (!newContext) newContext = createDiscardContext(); const bool isEmpty = xmlTextReaderIsEmptyElement(reader); newContext->startOfElement(); if (xmlTextReaderHasAttributes(reader)) { ret = xmlTextReaderMoveToFirstAttribute(reader); while (1 == ret) { processAttribute(reader, newContext, tokenizer); ret = xmlTextReaderMoveToNextAttribute(reader); } } if (isEmpty) newContext->endOfElement(); else contextStack.push(newContext); break; } case XML_READER_TYPE_END_ELEMENT: { contextStack.top()->endOfElement(); contextStack.pop(); break; } case XML_READER_TYPE_TEXT : { xmlChar *const text = xmlTextReaderReadString(reader); contextStack.top()->text(char_cast(text)); xmlFree(text); break; } default: break; } ret = xmlTextReaderRead(reader); } while (!contextStack.empty()) // finish parsing in case of broken XML { contextStack.top()->endOfElement(); contextStack.pop(); } xmlTextReaderClose(reader); return true; }
int XMIResource::loadLink(xmlTextReaderPtr reader, const model::BaseObject& o) { assert(o.kind() == LINK); // load the base class int ret = loadAbstractBaseObject(reader, o); if (ret != 1) { return ret; } // geometry is handled as in independent node // controlPoint is handled as in independent node // iterate on attributes for (int rc = xmlTextReaderMoveToFirstAttribute(reader); rc > 0; rc = xmlTextReaderMoveToNextAttribute(reader)) { auto found = std::find(constXcosNames.begin(), constXcosNames.end(), xmlTextReaderConstName(reader)); enum xcosNames current = static_cast<enum xcosNames>(std::distance(constXcosNames.begin(), found)); switch (current) { case e_uid: { std::string uid = to_string(xmlTextReaderConstValue(reader)); controller.setObjectProperty(o.id(), o.kind(), UID, uid); references.insert(std::make_pair(uid, o.id())); break; } case e_sourcePort: // will be resolved later unresolved.push_back( unresolvedReference(o.id(), o.kind(), SOURCE_PORT, to_string(xmlTextReaderConstValue(reader)))); break; case e_destinationPort: // will be resolved later unresolved.push_back( unresolvedReference(o.id(), o.kind(), DESTINATION_PORT, to_string(xmlTextReaderConstValue(reader)))); break; case e_style: controller.setObjectProperty(o.id(), o.kind(), STYLE, to_string(xmlTextReaderConstValue(reader))); break; case e_label: controller.setObjectProperty(o.id(), o.kind(), LABEL, to_string(xmlTextReaderConstValue(reader))); break; case e_lineWidth: { std::vector<double> thick; controller.getObjectProperty(o.id(), o.kind(), THICK, thick); thick[0] = to_double(xmlTextReaderConstValue(reader)); controller.setObjectProperty(o.id(), o.kind(), THICK, thick); break; } case e_lineHeight: { std::vector<double> thick; controller.getObjectProperty(o.id(), o.kind(), THICK, thick); thick[1] = to_double(xmlTextReaderConstValue(reader)); controller.setObjectProperty(o.id(), o.kind(), THICK, thick); break; } case e_color: controller.setObjectProperty(o.id(), o.kind(), COLOR, to_int(xmlTextReaderConstValue(reader))); break; default: // ignore other parameters // TODO: Does other metamodels might be managed there ? break; } } return ret; }
bool IWORKParser::parse() { const shared_ptr<xmlTextReader> sharedReader(xmlReaderForIO(readFromStream, closeStream, m_input.get(), "", nullptr, 0), xmlFreeTextReader); if (!sharedReader) return false; xmlTextReaderPtr reader = sharedReader.get(); assert(reader); const IWORKTokenizer &tokenizer = getTokenizer(); stack<IWORKXMLContextPtr_t> contextStack; int ret = xmlTextReaderRead(reader); contextStack.push(createDocumentContext()); bool keynoteDocTypeChecked=false; char const *defaultNS=nullptr; while ((1 == ret)) { switch (xmlTextReaderNodeType(reader)) { case XML_READER_TYPE_ELEMENT: { if (!keynoteDocTypeChecked) { // check for keynote 1 file with doctype node and not a namespace in first node keynoteDocTypeChecked=true; if (xmlTextReaderNodeType(reader)==XML_READER_TYPE_ELEMENT && xmlTextReaderConstNamespaceUri(reader)==nullptr) defaultNS="http://developer.apple.com/schemas/APXL"; } const int id = tokenizer.getQualifiedId(char_cast(xmlTextReaderConstLocalName(reader)), defaultNS ? defaultNS : char_cast(xmlTextReaderConstNamespaceUri(reader))); IWORKXMLContextPtr_t newContext = contextStack.top()->element(id); if (!newContext) newContext = createDiscardContext(); const bool isEmpty = xmlTextReaderIsEmptyElement(reader); newContext->startOfElement(); if (xmlTextReaderHasAttributes(reader)) { ret = xmlTextReaderMoveToFirstAttribute(reader); while (1 == ret) { processAttribute(reader, newContext, tokenizer); ret = xmlTextReaderMoveToNextAttribute(reader); } } if (isEmpty) newContext->endOfElement(); else contextStack.push(newContext); break; } case XML_READER_TYPE_END_ELEMENT: { contextStack.top()->endOfElement(); contextStack.pop(); break; } case XML_READER_TYPE_CDATA : { const xmlChar *text = xmlTextReaderConstValue(reader); if (text) contextStack.top()->CDATA(char_cast(text)); break; } case XML_READER_TYPE_TEXT : { xmlChar *const text = xmlTextReaderReadString(reader); contextStack.top()->text(char_cast(text)); xmlFree(text); break; } default: break; } ret = xmlTextReaderRead(reader); } while (!contextStack.empty()) // finish parsing in case of broken XML { contextStack.top()->endOfElement(); contextStack.pop(); } xmlTextReaderClose(reader); return true; }
int XMIResource::processElement(xmlTextReaderPtr reader) { const xmlChar *name = xmlTextReaderConstLocalName(reader); parent = NB_XCOS_NAMES; // lookup for known node names // thanks to the string intern-ing, the pointer comparison could be used auto found = std::find(constXcosNames.begin(), constXcosNames.end(), name); enum xcosNames current = static_cast<enum xcosNames>(std::distance(constXcosNames.begin(), found)); switch (current) { case e_Diagram: { // the root diagram should be decoded model::BaseObject o(root, DIAGRAM); processed.push_back(o); return loadDiagram(reader, o); } case e_child: { // this is a child of a diagram, resolve the type and call the loaders // iterate on attributes to lookup for EMF type // iterate on attributes for (int rc = xmlTextReaderMoveToFirstAttribute(reader); rc > 0; rc = xmlTextReaderMoveToNextAttribute(reader)) { const xmlChar* nsURI = xmlTextReaderConstNamespaceUri(reader); if (nsURI != xsiNamespaceUri) { continue; } auto foundName = std::find(constXcosNames.begin(), constXcosNames.end(), xmlTextReaderConstLocalName(reader)); enum xcosNames currentName = static_cast<enum xcosNames>(std::distance(constXcosNames.begin(), foundName)); if (currentName != e_type) { continue; } const xmlChar* value = xmlTextReaderConstValue(reader); const xmlChar* valueWithoutPrefix = BAD_CAST(std::strchr((const char*) value, ':')); if (valueWithoutPrefix == nullptr) { valueWithoutPrefix = value; } else { // remove the leading ':' valueWithoutPrefix = valueWithoutPrefix + 1; } const xmlChar* interned = xmlTextReaderConstString(reader, valueWithoutPrefix); auto found = std::find(constXcosNames.begin(), constXcosNames.end(), interned); enum xcosNames current = static_cast<enum xcosNames>(std::distance(constXcosNames.begin(), found)); switch (current) { case e_Block: { ScicosID o = controller.createObject(BLOCK); // assign the child model::BaseObject parent = processed.back(); std::vector<ScicosID> children; controller.getObjectProperty(parent.id(), parent.kind(), CHILDREN, children); children.push_back(o); controller.setObjectProperty(parent.id(), parent.kind(), CHILDREN, children); model::BaseObject child(o, BLOCK); processed.push_back(child); return loadBlock(reader, child); } case e_Link: { ScicosID o = controller.createObject(LINK); // assign the child model::BaseObject parent = processed.back(); std::vector<ScicosID> children; controller.getObjectProperty(parent.id(), parent.kind(), CHILDREN, children); children.push_back(o); controller.setObjectProperty(parent.id(), parent.kind(), CHILDREN, children); model::BaseObject child(o, LINK); processed.push_back(child); return loadLink(reader, child); } case e_Annotation: { ScicosID o = controller.createObject(ANNOTATION); // assign the child model::BaseObject parent = processed.back(); std::vector<ScicosID> children; controller.getObjectProperty(parent.id(), parent.kind(), CHILDREN, children); children.push_back(o); controller.setObjectProperty(parent.id(), parent.kind(), CHILDREN, children); model::BaseObject child(o, ANNOTATION); return loadAnnotation(reader, child); } default: sciprint("Not handled child type=%s at line %d\n", *found, xmlTextReaderGetParserLineNumber(reader) - 1); return -1; } } break; } case e_in: // no break on purpose case e_out: // no break on purpose case e_ein: // no break on purpose case e_eout: { ScicosID o = controller.createObject(PORT); enum object_properties_t p; switch (current) { case e_in: p = INPUTS; break; case e_out: p = OUTPUTS; break; case e_ein: p = EVENT_INPUTS; break; case e_eout: p = EVENT_OUTPUTS; break; default: return -1; } model::BaseObject parent = processed.back(); // add the port them to the parent std::vector<ScicosID> ports; controller.getObjectProperty(parent.id(), parent.kind(), p, ports); ports.push_back(o); controller.setObjectProperty(parent.id(), parent.kind(), p, ports); // decode content model::BaseObject child(o, PORT); return loadPort(reader, child); } case e_geometry: // geometry is used for rectangle coordinates of its parent return loadGeometry(reader, processed.back()); case e_nzcross: // nzcross is a Block property if (!xmlTextReaderIsEmptyElement(reader)) { parent = current; } return 1; case e_nmode: // nmode is a Block property if (!xmlTextReaderIsEmptyElement(reader)) { parent = current; } return 1; case e_rpar: // rpar is a Block property if (!xmlTextReaderIsEmptyElement(reader)) { parent = current; } return 1; case e_ipar: // ipar is a Block property if (!xmlTextReaderIsEmptyElement(reader)) { parent = current; } return 1; case e_opar: // ipar is a Block property return loadBase64(reader, OPAR, processed.back()); case e_state: // state is a Block property if (!xmlTextReaderIsEmptyElement(reader)) { parent = current; } return 1; case e_dstate: // dstate is a Block property if (!xmlTextReaderIsEmptyElement(reader)) { parent = current; } return 1; case e_odstate: // odstate is a Block property return loadBase64(reader, ODSTATE, processed.back()); case e_equations: // equation is a Block property return loadBase64(reader, EQUATIONS, processed.back()); case e_expression: // expression is a Block property if (!xmlTextReaderIsEmptyElement(reader)) { parent = current; } return 1; case e_exprs: // exprs is a Block property return loadBase64(reader, EXPRS, processed.back()); case e_controlPoint: // controlPoint is a link property return loadPoint(reader, processed.back()); case e_context: // context is a Layer property if (!xmlTextReaderIsEmptyElement(reader)) { parent = current; } return 1; case e_properties: // properties is a Diagram property return loadSimulationConfig(reader, processed.back()); case e_datatype: // datatype is a Port property if (!xmlTextReaderIsEmptyElement(reader)) { parent = current; } return 1; default: sciprint("Unknown \"%s\" element name at line %d\n", name, xmlTextReaderGetParserLineNumber(reader) - 1); return -1; } return 1; }
//## @Native boolean XmlReader.moveToFirstAttribute(); static KMETHOD XmlReader_moveToFirstAttribute(KonohaContext *kctx, KonohaStack *sfp) { xmlTextReaderPtr reader = getRawXmlReader(sfp[0]); int ret = (reader != NULL) ? xmlTextReaderMoveToFirstAttribute(reader) : 0; KReturnUnboxValue(ret); }
/* * call-seq: * reader.move_to_first_attribute -> code * * Move the position of the current instance to the first attribute associated * with the current node. */ static VALUE rxml_reader_move_to_first_attr(VALUE self) { return INT2FIX(xmlTextReaderMoveToFirstAttribute(rxml_text_reader_get(self))); }
/* @method Boolean XmlReader.moveToFirstAttribute() */ METHOD XmlReader_moveToFirstAttribute(Ctx *ctx, knh_sfp_t *sfp) { xmlTextReaderPtr reader = (xmlTextReaderPtr) p_cptr(sfp[0]); int ret = xmlTextReaderMoveToFirstAttribute(reader); KNH_RETURN_Boolean(ctx,sfp,ret); }