short ParseFlowListTag( char *fname, void **list ) { xmlDocPtr doc = NULL; xmlNodePtr current; FLOWCOMP rootComp; short result = -1; if ( list == NULL ) goto Err1; if ( (doc = xmlParseFile( fname )) == NULL ) goto Err1; current = xmlDocGetRootElement( doc ); if ( (current == NULL) || xmlStrcmp( current->name, (const xmlChar *)"maintenance-resource" ) ){ goto Err2; } memset( &rootComp, 0, sizeof(FLOWCOMP) ); current = current->xmlChildrenNode; while ( current != NULL ){ if ( (!xmlStrcmp( current->name, (const xmlChar *)"flowlist" )) ){ if ( ParseFlowTag( current->xmlChildrenNode, &rootComp ) != 0 ) goto Err2; break; } current = current->next; } *list = rootComp.next; result = 0; EXIT: xmlFreeDoc( doc ); return result; Err2: FreeFlowCompList( rootComp.next ); Err1: goto EXIT; }
int interpret_oglerc(char *filename) { xmlDocPtr doc; xmlNodePtr cur; doc = xmlParseFile(filename); if(doc != NULL) { cur = xmlDocGetRootElement(doc); while(cur != NULL) { if(!xmlIsBlankNode(cur)) { if(!strcmp("ogle_conf", cur->name)) { interpret_ogle_conf(doc, cur); } } cur = cur->next; } xmlFreeDoc(doc); return 0; } else { WARNING("Couldn't load config file\n"); return -1; } }
bool CZBConfiguration::ReadModelsFile(const char *_file) { std::cout << "parsing models file " << std::string(_file) << std::endl; doc = xmlParseFile(_file); if(doc==NULL) { //std::cerr << "XML file " << std::string(_file) << " empty" << std::endl; return false; } root_element = xmlDocGetRootElement(doc); for( xmlNode *level_1 = root_element->children ; level_1 != NULL ; level_1 = level_1->next) { // end_devices_models level if(!xmlStrcmp(level_1->name,(const char *)"end_devices_model")) for( xmlNode *level_2 = level_1->children ; level_2 != NULL; level_2 = level_2->next) { // model level if(!xmlStrcmp(level_2->name,(const char *)"model")) for( xmlNode *level_3 = level2->children; level_3 != NULL ; level_3 = level_3->next ) { // channel level } if(!xmlStrcmp(level_2->name,(const char *)"models_version")) { } } } return true; }
/*** loadCfg: This function loads cfg file to RAM memory using libxml API functions xmlfile: Cfg's file name */ void loadCfg(char *xmlfile) { xmlDoc *doc = NULL; xmlNode *root_element = NULL; LIBXML_TEST_VERSION doc = xmlParseFile(xmlfile); if (doc == NULL) { printf("error: could not parse file file.xml\n"); exit(1); } root_element = xmlDocGetRootElement(doc); puts("carregando nodos\n"); loadNodes(getElement(root_element, "nodes")); puts("construindo arestas\n"); buildGraphFromEdges(getElement(root_element, "edges")); xmlFreeDoc(doc); xmlCleanupParser(); }
static void findTags (void) { xmlNode *i; xmlDocPtr doc = xmlParseFile(getInputFileName()); xmlNode *root; if (doc == NULL) { g_warning ("could not parse file"); } root = xmlDocGetRootElement(doc); for (i = root->children; i; i = i->next) { xmlNode *j; if (!i->name) continue; if (strcmp ((const char*)i->name, "namespace") !=0) continue; for (j = i->children; j; j = j->next) { makeTags (j, NULL); } } }
void create_file(char *to, char *from, char *msg){ int rc; xmlTextWriterPtr writer; xmlDocPtr doc; xmlNodePtr node, root; xmlChar *tmp; if(doc = xmlParseFile(to)){ root = xmlDocGetRootElement(doc); xmlNodePtr pNode = xmlNewNode(0, (xmlChar*)"mes"); //xmlSetProp(pNode, (const xmlChar*) "id", (const xmlChar*) "val"); xmlSetProp(pNode, (const xmlChar*) "from", (const xmlChar*) from); xmlNodeSetContent(pNode, (xmlChar*)msg); xmlAddChild(root, pNode); xmlSaveFileEnc(to, doc, MY_ENCODING); xmlFreeDoc(doc); }else{ doc = xmlNewDoc(BAD_CAST XML_DEFAULT_VERSION); node = xmlNewDocNode(doc, NULL, BAD_CAST "inbox", NULL); xmlDocSetRootElement(doc, node); writer = xmlNewTextWriterTree(doc, node, 0); rc = xmlTextWriterStartDocument(writer, NULL, MY_ENCODING, NULL); rc = xmlTextWriterStartElement(writer, BAD_CAST "mes"); //rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "id", BAD_CAST "1"); rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "from", BAD_CAST from); rc = xmlTextWriterEndAttribute(writer); rc = xmlTextWriterWriteString(writer, (const xmlChar*) msg); rc = xmlTextWriterEndElement(writer); rc = xmlTextWriterEndDocument(writer); xmlFreeTextWriter(writer); xmlSaveFileEnc(to, doc, MY_ENCODING); xmlFreeDoc(doc); } }
bool load_player_objects_from_file(struct creature *ch, const char *path) { int axs = access(path, W_OK); if (axs != 0) { if (errno != ENOENT) { errlog("Unable to open xml equipment file '%s': %s", path, strerror(errno)); return -1; } else { return 1; // normal no eq file } } xmlDocPtr doc = xmlParseFile(path); if (!doc) { errlog("XML parse error while loading %s", path); return -1; } xmlNodePtr root = xmlDocGetRootElement(doc); if (!root) { xmlFreeDoc(doc); errlog("XML file %s is empty", path); return 1; } for (xmlNodePtr node = root->xmlChildrenNode; node; node = node->next) { if (xmlMatches(node->name, "object")) (void)load_object_from_xml(NULL, ch, NULL, node); } xmlFreeDoc(doc); return 0; }
Manifest *create_manifest(const gchar *manifest_file, const unsigned int flags, const gchar *container_filter, const gchar *component_filter) { xmlDocPtr doc; xmlNodePtr node_root; Manifest *manifest; /* Parse the XML document */ if((doc = xmlParseFile(manifest_file)) == NULL) { g_printerr("Error with parsing the manifest XML file!\n"); xmlCleanupParser(); return NULL; } /* Retrieve root element */ node_root = xmlDocGetRootElement(doc); if(node_root == NULL) { g_printerr("The manifest XML file is empty!\n"); xmlFreeDoc(doc); xmlCleanupParser(); return NULL; } /* Parse manifest */ manifest = parse_manifest(node_root, flags, container_filter, component_filter); /* Cleanup */ xmlFreeDoc(doc); xmlCleanupParser(); /* Return manifest */ return manifest; }
/** * gpa_printer_new_from_file: * @file: * * Load a new printer from @filename, file should contain a XML description * * Return Value: **/ static GPANode * gpa_printer_new_from_file (const gchar *file) { GPANode *printer = NULL; xmlDocPtr doc; xmlNodePtr node; doc = xmlParseFile (file); if (!doc) { g_warning ("Could not parse %s\n", file); return NULL; } node = doc->xmlRootNode; printer = gpa_printer_new_from_tree (node); xmlFreeDoc (doc); if (!printer || !gpa_node_verify (printer)) { g_warning ("Could not load printer from %s", file); printer = NULL; } return printer; }
GameManager::GameManager () : _currentGameDescription(0), _enginePath(GlobalRegistry().get(RKEY_ENGINE_PATH)), _cleanedEnginePath( DirectoryCleaned(_enginePath)), _emptyString("") { GlobalRegistry().addKeyObserver(this, RKEY_ENGINE_PATH); // greebo: Register this class in the preference system so that the constructPreferencePage() gets called. GlobalPreferenceSystem().addConstructor(this); // TODO Remove this and read the game.xml data from the xmlregistry, too std::string strGameFilename = Environment::Instance().getAppPath() + "game.xml"; xmlDocPtr pDoc = xmlParseFile(strGameFilename.c_str()); if (pDoc) { _currentGameDescription = new GameDescription(pDoc, strGameFilename); // Import this information into the registry //GlobalRegistry().importFromFile(strGameFilename, ""); xmlFreeDoc(pDoc); } else { gtkutil::errorDialog(_("XML parser failed to parse game.xml")); } initialise(); }
int config_parse_file(const char *filename, ice_config_t *configuration) { xmlDocPtr doc; xmlNodePtr node; if (filename == NULL || strcmp(filename, "") == 0) return CONFIG_EINSANE; xmlInitParser(); doc = xmlParseFile(filename); if (doc == NULL) { return CONFIG_EPARSE; } node = xmlDocGetRootElement(doc); if (node == NULL) { xmlFreeDoc(doc); xmlCleanupParser(); return CONFIG_ENOROOT; } if (strcmp(node->name, "icecast") != 0) { xmlFreeDoc(doc); xmlCleanupParser(); return CONFIG_EBADROOT; } config_init_configuration(configuration); configuration->config_filename = (char *)strdup(filename); _parse_root(doc, node->xmlChildrenNode, configuration); xmlFreeDoc(doc); return 0; }
int main(int argc, char **argv) { xmlDocPtr doc; char buf[1024]; FILE *f; size_t l; printf("- From file\n"); doc = xmlParseFile(argv[1]); printf("encoding: %s\ncharset: %d\n", doc->encoding, doc->charset); xmlFreeDoc(doc); f = fopen(argv[1], "r"); l = fread(buf, 1, 1024, f); printf("- From memory\n"); doc = xmlParseMemory(buf, l); printf("encoding: %s\ncharset: %d\n", doc->encoding, doc->charset); xmlFreeDoc(doc); return 0; }
bool Vocations::loadFromXml() { xmlDocPtr doc = xmlParseFile(getFilePath(FILE_TYPE_XML,"vocations.xml").c_str()); if(!doc) { std::clog << "[Warning - Vocations::loadFromXml] Cannot load vocations file." << std::endl; std::clog << getLastXMLError() << std::endl; return false; } xmlNodePtr p, root = xmlDocGetRootElement(doc); if(xmlStrcmp(root->name,(const xmlChar*)"vocations")) { std::clog << "[Error - Vocations::loadFromXml] Malformed vocations file." << std::endl; xmlFreeDoc(doc); return false; } for(p = root->children; p; p = p->next) parseVocationNode(p); xmlFreeDoc(doc); return true; }
GRSTgaclAcl *GRSTxacmlAclLoadFile(char *filename) { xmlDocPtr doc; xmlNodePtr cur; GRSTgaclAcl *acl; doc = xmlParseFile(filename); if (doc == NULL) return NULL; cur = xmlDocGetRootElement(doc); if (cur == NULL) return NULL; if (!xmlStrcmp(cur->name, (const xmlChar *) "Policy")) { acl=GRSTxacmlAclParse(doc, cur, acl);} else if (!xmlStrcmp(cur->name, (const xmlChar *) "gacl")) {acl=GRSTgaclAclParse(doc, cur, acl);} else /* ACL format not recognised */ { xmlFreeDoc(doc); free(cur); return NULL; } xmlFreeDoc(doc); return acl; }
int File::loadXML(const char *filename, Context *ctx) { xmlDocPtr doc = NULL; xmlNodePtr root; int length; doc = xmlParseFile(filename); if (!doc) { fprintf(stderr, "could not parse XML\n"); return false; } root = doc->xmlRootNode; length = setXML(root, ctx); xmlFreeDoc(doc); return length; fail: if (doc) { xmlFreeDoc(doc); } return 0; }
/** * * @param fileName Full path to the XML file to be read * @return true if the file could be read and parsed. Else false. */ bool XMLConfParser::readFile(std::string fileName){ if(fDoc != NULL) closeFile(); fDoc = xmlParseFile(fileName.data()); if (fDoc == NULL ) { std::stringstream ss; xmlErrorPtr errPtr = xmlGetLastError(); ss << "Document not parsed successfully." << std::endl; ss << "File: " << errPtr->file << " at (l:"; ss << errPtr->line << ", c:" << errPtr->int2; ss << "): " << errPtr->message << std::endl; throw XMLConfParserFatalException(ss); return false; } fRoot = xmlDocGetRootElement(fDoc); if (fRoot == NULL) { throw XMLConfParserFatalException("Document is empty."); return false; } return true; }
void readinput_init(){ if(myid == 0) { doc = xmlParseFile("input"); if (doc == NULL ) { fprintf(stderr,"input file not parsed successfully. \n"); #if defined(HAVE_MPI) MPI_Finalize(); #endif exit(0); } cur = xmlDocGetRootElement(doc); if (cur == NULL) { fprintf(stderr,"input file is empty\n"); xmlFreeDoc(doc); #if defined(HAVE_MPI) MPI_Finalize(); #endif exit(0); } } }
bool Vocations::loadFromXml() { std::string filename = "data/XML/vocations.xml"; xmlDocPtr doc = xmlParseFile(filename.c_str()); if (doc) { xmlNodePtr root, p; root = xmlDocGetRootElement(doc); if (xmlStrcmp(root->name, (const xmlChar*)"vocations") != 0) { xmlFreeDoc(doc); return false; } p = root->children; while (p) { std::string str; int32_t intVal; if (xmlStrcmp(p->name, (const xmlChar*)"vocation") == 0) { Vocation* voc = new Vocation(); uint32_t voc_id; xmlNodePtr configNode; if (readXMLInteger(p, "id", intVal)) { float floatVal; voc_id = intVal; if (readXMLString(p, "name", str)) { voc->name = str; } if (readXMLInteger(p, "clientid", intVal)) { voc->clientId = intVal; } if (readXMLString(p, "description", str)) { voc->description = str; } if (readXMLInteger(p, "gaincap", intVal)) { voc->gainCap = intVal; } if (readXMLInteger(p, "gainhp", intVal)) { voc->gainHP = intVal; } if (readXMLInteger(p, "gainmana", intVal)) { voc->gainMana = intVal; } if (readXMLInteger(p, "gainhpticks", intVal)) { voc->gainHealthTicks = intVal; } if (readXMLInteger(p, "gainhpamount", intVal)) { voc->gainHealthAmount = intVal; } if (readXMLInteger(p, "gainmanaticks", intVal)) { voc->gainManaTicks = intVal; } if (readXMLInteger(p, "gainmanaamount", intVal)) { voc->gainManaAmount = intVal; } if (readXMLFloat(p, "manamultiplier", floatVal)) { voc->manaMultiplier = floatVal; } if (readXMLInteger(p, "attackspeed", intVal)) { voc->attackSpeed = intVal; } if (readXMLInteger(p, "basespeed", intVal)) { voc->baseSpeed = intVal; } if (readXMLInteger(p, "soulmax", intVal)) { voc->soulMax = intVal; } if (readXMLInteger(p, "gainsoulticks", intVal)) { voc->gainSoulTicks = intVal; } if (readXMLInteger(p, "fromvoc", intVal)) { voc->fromVocation = intVal; } configNode = p->children; while (configNode) { if (xmlStrcmp(configNode->name, (const xmlChar*)"skill") == 0) { uint32_t skill_id; if (readXMLInteger(configNode, "id", intVal)) { skill_id = intVal; if (skill_id > SKILL_LAST) { std::cout << "No valid skill id. " << skill_id << std::endl; } else { if (readXMLFloat(configNode, "multiplier", floatVal)) { voc->skillMultipliers[skill_id] = floatVal; } } } else { std::cout << "Missing skill id." << std::endl; } } else if (xmlStrcmp(configNode->name, (const xmlChar*)"formula") == 0) { if (readXMLFloat(configNode, "meleeDamage", floatVal)) { voc->meleeDamageMultipler = floatVal; } if (readXMLFloat(configNode, "distDamage", floatVal)) { voc->distDamageMultipler = floatVal; } if (readXMLFloat(configNode, "defense", floatVal)) { voc->defenseMultipler = floatVal; } if (readXMLFloat(configNode, "armor", floatVal)) { voc->armorMultipler = floatVal; } } configNode = configNode->next; } vocationsMap[voc_id] = voc; } else { std::cout << "Missing vocation id." << std::endl; } } p = p->next; } xmlFreeDoc(doc); } return true; }
static void get_tone_set(const char *tone_file, const char *set_id) { xmlDocPtr doc; xmlNsPtr ns; xmlNodePtr cur; #if 0 xmlValidCtxt valid; #endif xmlChar *x; ns = NULL; xmlKeepBlanksDefault(0); xmlCleanupParser(); doc = xmlParseFile(tone_file); if (doc == NULL) { fprintf(stderr, "No document\n"); exit(2); } /*endif*/ xmlXIncludeProcess(doc); #if 0 if (!xmlValidateDocument(&valid, doc)) { fprintf(stderr, "Invalid document\n"); exit(2); } /*endif*/ #endif /* Check the document is of the right kind */ if ((cur = xmlDocGetRootElement(doc)) == NULL) { fprintf(stderr, "Empty document\n"); xmlFreeDoc(doc); exit(2); } /*endif*/ if (xmlStrcmp(cur->name, (const xmlChar *) "global-tones")) { fprintf(stderr, "Document of the wrong type, root node != global-tones"); xmlFreeDoc(doc); exit(2); } /*endif*/ cur = cur->xmlChildrenNode; while (cur && xmlIsBlankNode(cur)) cur = cur->next; /*endwhile*/ if (cur == NULL) exit(2); /*endif*/ while (cur) { if (xmlStrcmp(cur->name, (const xmlChar *) "tone-set") == 0) { if ((x = xmlGetProp(cur, (const xmlChar *) "uncode"))) { if (strcmp((char *) x, set_id) == 0) parse_tone_set(doc, ns, cur); /*endif*/ xmlFree(x); } /*endif*/ } /*endif*/ cur = cur->next; } /*endwhile*/ xmlFreeDoc(doc); }
// Processes input XML file (e.g., instance metadata) into output XML file or string (e.g., for libvirt) // using XSL-T specification file (e.g., libvirt.xsl) static int apply_xslt_stylesheet (const char * xsltStylesheetPath, const char * inputXmlPath, const char * outputXmlPath, char * outputXmlBuffer, int outputXmlBufferSize) { int err = OK; INIT(); xsltStylesheetPtr cur = xsltParseStylesheetFile ((const xmlChar *)xsltStylesheetPath); if (cur) { xmlDocPtr doc = xmlParseFile (inputXmlPath); if (doc) { xsltTransformContextPtr ctxt = xsltNewTransformContext (cur, doc); // need context to get result xsltSetCtxtParseOptions (ctxt, 0); // TODO: do we want any XSL-T parsing options? xmlDocPtr res = xsltApplyStylesheetUser (cur, doc, NULL, NULL, NULL, ctxt); // applies XSLT to XML int applied_ok = ctxt->state==XSLT_STATE_OK; // errors are communicated via ctxt->state xsltFreeTransformContext (ctxt); if (res && applied_ok) { // save to a file, if path was provied if (outputXmlPath!=NULL) { FILE * fp = fopen (outputXmlPath, "w"); if (fp) { int bytes = xsltSaveResultToFile (fp, res, cur); if (bytes==-1) { logprintfl (EUCAERROR, "ERROR: failed to save XML document to %s\n", outputXmlPath); err = ERROR; } fclose (fp); } else { logprintfl (EUCAERROR, "ERROR: failed to create file %s\n", outputXmlPath); err = ERROR; } } // convert to an ASCII buffer, if such was provided if (err==OK && outputXmlBuffer!=NULL && outputXmlBufferSize > 0) { xmlChar * buf; int buf_size; if (xsltSaveResultToString (&buf, &buf_size, res, cur)==0) { // success if (buf_size < outputXmlBufferSize) { bzero (outputXmlBuffer, outputXmlBufferSize); for (int i=0, j=0; i<buf_size; i++) { char c = (char) buf [i]; if (c != '\n') // remove newlines outputXmlBuffer [j++] = c; } } else { logprintfl (EUCAERROR, "ERROR: XML string buffer is too small (%d > %d)\n", buf_size, outputXmlBufferSize); err = ERROR; } xmlFree (buf); } else { logprintfl (EUCAERROR, "ERROR: failed to save XML document to a string\n"); err = ERROR; } } } else { logprintfl (EUCAERROR, "ERROR: failed to apply stylesheet %s to %s\n", xsltStylesheetPath, inputXmlPath); err = ERROR; } if (res!=NULL) xmlFreeDoc(res); xmlFreeDoc(doc); } else { logprintfl (EUCAERROR, "ERROR: failed to parse XML document %s\n", inputXmlPath); err = ERROR; } xsltFreeStylesheet(cur); } else { logprintfl (EUCAERROR, "ERROR: failed to open and parse XSL-T stylesheet file %s\n", xsltStylesheetPath); err = ERROR; } return err; }
static gboolean convert_metadata_file (const gchar *filename) { ConvertData *data; xmlDocPtr doc; xmlNodePtr cur; if (!g_file_test (filename, G_FILE_TEST_EXISTS)) return FALSE; doc = xmlParseFile (filename); if (!doc) { g_printerr ("Error loading metadata file %s\n", filename); return FALSE; } cur = xmlDocGetRootElement (doc); if (!cur) { g_printerr ("Metadata file %s is empty\n", filename); xmlFreeDoc (doc); return TRUE; } if (xmlStrcmp (cur->name, (const xmlChar *) "metadata")) { g_printerr ("File %s is not a valid atril metadata file\n", filename); xmlFreeDoc (doc); return FALSE; } data = g_new0 (ConvertData, 1); data->doc = doc; for (cur = cur->xmlChildrenNode; cur != NULL; cur = cur->next) { xmlChar *uri; DocItem *item; if (xmlStrcmp (cur->name, (const xmlChar *)"document") != 0) continue; uri = xmlGetProp (cur, (const xmlChar *)"uri"); if (!uri) continue; item = g_new (DocItem, 1); item->uri = uri; item->cur = cur; data->items = g_list_prepend (data->items, item); } if (!data->items) { xmlFreeDoc (data->doc); g_free (data); return TRUE; } show_progress_dialog (data); data->current = data->items; g_idle_add_full (G_PRIORITY_DEFAULT_IDLE, (GSourceFunc)convert_file, data, (GDestroyNotify)convert_finish); return TRUE; }
bool Traces::parse(const char *filename, int verbose) { xmlDocPtr doc = xmlParseFile(filename); if (doc == NULL) { cout << "Error parsing the "<< filename << " !" << endl; goto err; } xmlNodePtr node; node = doc->children; XMLASSERT(node->type == XML_ELEMENT_NODE && !strcmp((const char*)node->name, "gltrace")); { // parse tracelist xmlNodePtr xmllist = get_child_element(node, "tracelist"); XMLASSERT(xmllist); for(xmlNodePtr tracenode = xmllist->children; tracenode; tracenode = tracenode->next) { if(tracenode->type == XML_TEXT_NODE) continue; XMLASSERT(tracenode->type == XML_ELEMENT_NODE && !strcmp((const char*)tracenode->name, "trace")); const char *object = get_element_attribute(tracenode, "object"); const char *name = get_element_attribute(tracenode, "name"); XMLASSERT(object && name); xmlNodePtr shot = get_child_element(tracenode, "shot"); XMLASSERT(shot); const char *id_str = get_element_attribute(shot, "id"); XMLASSERT(id_str); int id; XMLASSERT(sscanf(id_str, "%d", &id) == 1); while((int)tracelist.size() <= id) { tracelist.push_back(TracedEvent()); } tracelist[id].name = name; tracelist[id].obj = object; } if(verbose) printf("loaded %ld traces\n", tracelist.size()); } { // load links xmlNodePtr linklist = get_child_element(node, "linklist"); XMLASSERT(linklist); for(xmlNodePtr linknode = linklist->children; linknode; linknode = linknode->next) { if(linknode->type == XML_TEXT_NODE) continue; Link link; XMLASSERT(linknode->type == XML_ELEMENT_NODE && !strcmp((const char*)linknode->name, "link")); xmlNodePtr source = get_child_element(linknode, "source"); xmlNodePtr destination = get_child_element(linknode, "destination"); XMLASSERT(source && destination); string sourcecol = get_element_attribute(source, "name"); string destcol = get_element_attribute(destination, "name"); XMLASSERT(sourcecol.size() && destcol.size()); link.source = sourcecol.substr(0, sourcecol.find(':')); link.sourceport = sourcecol.substr(sourcecol.find(':') + 1); link.dest = destcol.substr(0, destcol.find(':')); link.destport = destcol.substr(destcol.find(':') + 1); // printf("size %d %p\n", links.size(), &links[0]); links.push_back(link); // printf("osize %d %s\n", links.size(), links[0].source.c_str()); } if(verbose) printf("%ld links\n", links.size()); } { // fill in nextEvents for(int i = 0; i < tracelist.size(); i++) { TracedEvent &ev = tracelist[i]; Link *waitBeginLink = NULL; bool recorded = false; for(int l = 0; l < links.size(); l++) { Link & link = links[l]; if(link.source == ev.obj && link.sourceport == ev.name) { int dest_ev = find_event(link.dest, link.destport); ev.links.push_back(&link); if(dest_ev >= 0) { ev.nextEvents.push_back(dest_ev); recorded = true; } } if(link.source == ev.obj && link.sourceport == "waitBegin") waitBeginLink = &link; if(link.dest == ev.obj && link.destport == ev.name && link.destport != "waitEnd") { ev.links.push_back(&link); recorded = true; } } if(!recorded) { // probably a user event if(waitBeginLink) { ev.links.push_back(waitBeginLink); } else { printf("could not find waitBegin/waitEnd where trace %d %s:%s fits\n", i, ev.obj.c_str(), ev.name.c_str()); } } if(verbose) { printf("tev %d %s:%s, nextEvents = [", i, ev.obj.c_str(), ev.name.c_str()); for(int j = 0; j < ev.nextEvents.size(); j++) printf("%d ", ev.nextEvents[j]); printf("] links = ["); for(int j = 0; j < ev.links.size(); j++) { Link & link = *ev.links[j]; printf("%s:%s->%s:%s ", link.source.c_str(), link.sourceport.c_str(), link.dest.c_str(), link.destport.c_str()); } printf("]\n"); } } } { // load actual trace data xmlNodePtr xmlfiles = get_child_element(node, "filelist"); XMLASSERT(xmlfiles); vector<Chunk> chunks; for(xmlNodePtr filenode = xmlfiles->children; filenode; filenode = filenode->next) { if(filenode->type == XML_TEXT_NODE || (filenode->type == XML_ELEMENT_NODE && !strcmp((const char*)filenode->name, "pingresults"))) continue; XMLASSERT(filenode->type == XML_ELEMENT_NODE && !strcmp((const char*)filenode->name, "tracefile")); const char *chunkfilename = get_element_attribute(filenode, "file"); XMLASSERT(chunkfilename); { FILE *chunkfile = fopen(chunkfilename, "r"); XMLASSERT(chunkfile); size_t file_size; { struct stat sbuf; fstat(fileno(chunkfile), &sbuf); file_size = sbuf.st_size; } XMLASSERT(file_size % sizeof(Chunk) == 0); size_t nelt = file_size / sizeof(Chunk); size_t n0 = chunks.size(); chunks.resize(n0 + nelt); fread(&chunks[n0], nelt, sizeof(Chunk), chunkfile); fclose(chunkfile); } } if(verbose) printf("loaded %ld chunks\n", chunks.size()); chunks_to_evlists(chunks, tracelist, t0, t1); {// also record all timestamps double t_prev = -10; for(int i = 0; i < chunks.size(); i++) { double t = chunks[i].tv_sec + chunks[i].tv_usec * 1e-6; if(t > t_prev) timestamps.push_back(t); t_prev = t; } } } xmlFreeDoc(doc); return true; err: xmlFreeDoc(doc); return false; }
/*---------------------------------------------------------------------------* * NAME: xml_parsing * DESC: Main xml parsing function *---------------------------------------------------------------------------*/ void xml_parsing(config *conf) { /* open the file using the libxml2 library */ debug(3, "xml parsing of the file: %s\n", conf->xml_filename); conf->doc = xmlParseFile(conf->xml_filename); if (conf->doc == NULL) { error_("Document not parsed successfully!\n"); return; } verbose_("[*] parsing the file: %s\n", conf->xml_filename); /* point on the root element of the tree */ conf->cur = xmlDocGetRootElement(conf->doc); if (conf->cur == NULL) { error_("Empty Document!\n"); xmlFreeDoc(conf->doc); return; } /* check if the format seems to be PDML: ie root = pdml */ debug(3,"name of the root: %s\n", conf->cur->name); if (xmlStrcmp(conf->cur->name, (const xmlChar *) "pdml")) { error_("Document NOT a PDML file!\n"); xmlFreeDoc(conf->doc); return; } /* start the autodafe's script language */ output_("/*--------------------------------------------------------------------------*\n"); output_(" * xml autodafe's parser v.%d.%d (c) Martin Vuagnoux - 2004-2006 *\n", MAJOR_VERSION, MINOR_VERSION); output_(" * auto-generated script using PDML (Packet Details Markup Language) source *\n"); output_(" *--------------------------------------------------------------------------*/\n\n"); /* the file is good, check for the packet entry (child) */ conf->cur = conf->cur->xmlChildrenNode; while (conf->cur != NULL) { if (!xmlStrcmp(conf->cur->name, (const xmlChar *) "packet")) { debug(3, "packet field found\n"); /* open the block */ output_(AD_F_BLOCK_BEGIN"(\"packet_%d\");\n", conf->packet_counter); /* parse the internal data of the packet block */ xml_parse_packet(conf); /* close the block */ output_(AD_F_BLOCK_END"(\"packet_%d\");\n", conf->packet_counter); /* client send/recv */ if ((conf->ip_pkt == conf->ip_client) && (conf->port_pkt == conf->port_client)) { debug(3, "check client\n"); if (conf->transport_type == 1) { if (conf->invert == 0) output_(AD_F_SEND"(\"packet_%d\"); /* tcp */\n\n", conf->packet_counter); else output_(AD_F_RECV"(\"packet_%d\"); /* tcp */\n\n", conf->packet_counter); } else if (conf->transport_type == 2) { if (conf->invert == 0) output_(AD_F_SEND"(\"packet_%d\"); /* udp */\n\n", conf->packet_counter); else output_(AD_F_RECV"(\"packet_%d\"); /* udp */\n\n", conf->packet_counter); } } /* server send/recv */ else if ((conf->ip_pkt == conf->ip_server) && (conf->port_pkt == conf->port_server)) { debug(3, "check server\n"); if (conf->transport_type == 1) { if (conf->invert == 1) output_(AD_F_SEND"(\"packet_%d\"); /* tcp */\n\n", conf->packet_counter); else output_(AD_F_RECV"(\"packet_%d\"); /* tcp */\n\n", conf->packet_counter); } else if (conf->transport_type == 2) { if (conf->invert == 1) output_(AD_F_SEND"(\"packet_%d\"); /* udp */\n\n", conf->packet_counter); else output_(AD_F_RECV"(\"packet_%d\"); /* udp */\n\n", conf->packet_counter); } } else { error_("too much different packets?! Check your Ethereal logs!\n"); error_("client: ip->%d, port->%d\n", conf->ip_client, conf->port_client); error_("server: ip->%d, port->%d\n", conf->ip_server, conf->port_server); error_("packet: ip->%d, port->%d\n", conf->ip_pkt, conf->port_pkt); exit(-1); } conf->packet_counter++; } conf->cur = conf->cur->next; } /* free */ xmlFreeDoc(conf->doc); }
int settings_read(const char* path) { xmlDocPtr doc; xmlNodePtr noderoot; xmlNodePtr node1; xmlNodePtr node2; xmlChar* prop; msg_log(MSG_MESSAGE, "Reading global settings from: %s\n",path); doc = xmlParseFile (path); if (doc == NULL) { msg_log(MSG_ERROR, "Failed to parse %s\n", path); return -1; } noderoot = xmlDocGetRootElement(doc); if (noderoot == NULL) { msg_log(MSG_WARNING, "%s is empty\n", path); xmlFreeDoc(doc); return -1; } if (xmlStrcmp(noderoot->name, BAD_CAST "Petri-Foo-Settings") != 0) { msg_log(MSG_ERROR, "%s is not a valid 'Petri-Foo-Settings' file\n", path); xmlFreeDoc(doc); return -1; } for (node1 = noderoot->children; node1 != NULL; node1 = node1->next) { if (node1->type != XML_ELEMENT_NODE) continue; for ( node2 = node1->children; node2 != NULL; node2 = node2->next) { int n; if (xmlStrcmp(node2->name, BAD_CAST "property") == 0) { prop = BAD_CAST xmlGetProp(node2, BAD_CAST "name"); if (xmlStrcmp(prop, BAD_CAST "last-sample-directory") == 0) { free(gbl_settings->last_sample_dir); gbl_settings->last_sample_dir = (char*) xmlGetProp(node2, BAD_CAST "value"); } if (xmlStrcmp(prop, BAD_CAST "last-bank-directory") == 0) { free(gbl_settings->last_bank_dir); gbl_settings->last_bank_dir = (char*) xmlGetProp(node2, BAD_CAST "value"); } if (xmlStrcmp(prop, BAD_CAST "sliders-use-fans") == 0) { phin_fan_slider_set_fans_active( xmlstr_to_gboolean(xmlGetProp(node2, BAD_CAST "value"))); } if (xmlStrcmp(prop, BAD_CAST "log-lines") == 0) { xmlChar* vprop = xmlGetProp(node2, BAD_CAST "value"); if (sscanf((const char*)vprop, "%d", &n) == 1) gbl_settings->log_lines = n; } } } } return 0; }
int ReadGPX(const char* File, struct GPSTrack* Track) { /* Init the libxml library. Also checks version. */ LIBXML_TEST_VERSION xmlDocPtr GPXData; /* Read the GPX data from file. */ GPXData = xmlParseFile(File); if (GPXData == NULL) { fprintf(stderr, _("Failed to parse GPX data from %s.\n"), File); return 0; } /* Now grab the "root" node. */ xmlNodePtr GPXRoot; GPXRoot = xmlDocGetRootElement(GPXData); if (GPXRoot == NULL) { fprintf(stderr, _("GPX file has no root. Not healthy.\n")); xmlFreeDoc(GPXData); xmlCleanupParser(); return 0; } /* Check that this is indeed a GPX - the root node * should be "gpx". */ if (strcmp((const char *)GPXRoot->name, "gpx") == 0) { /* Ok, it is a GPX file. */ } else { /* Not valid. */ fprintf(stderr, _("Invalid GPX file.\n")); xmlFreeDoc(GPXData); xmlCleanupParser(); return 0; } /* Now comes the messy part... walking the tree to find * what we want. * I've chosen to do it with two functions, one of which * is recursive, rather than a clever inside-this-function * walk the tree thing. * * We start by calling the recursive function to look for * <trkseg> tags, and then that function calls another * when it has found one... this sub function then * hauls out the <trkpt> tags with the actual data. * Messy, convoluted, but it seems to work... */ /* As to where to store the data? Again, its messy. * We maintain two global vars, FirstPoint and LastPoint. * FirstPoint points to the first GPSPoint done, and * LastPoint is the last point done, used for the next * point... we use this to build a singly-linked list. */ /* (I think I'll just be grateful for the work that libxml * puts in for me... imagine having to write an XML parser! * Nasty.) */ /* Before we go into this function, we also setlocale to "C". * The GPX def indicates that the decimal separator should be * ".", but certain locales specify otherwise. Which has caused issues. * So we set the locale for this function, and then revert it. */ FirstPoint = NULL; LastPoint = NULL; char* OldLocale = setlocale(LC_NUMERIC, "C"); FindTrackSeg(GPXRoot); setlocale(LC_NUMERIC, OldLocale); /* Clean up stuff for the XML library. */ xmlFreeDoc(GPXData); xmlCleanupParser(); Track->Points = FirstPoint; /* Find the time range for this track */ GetTrackRange(Track); return 1; }
/** * xmlSecSimpleKeysStoreLoad: * @store: the pointer to simple keys store. * @uri: the filename. * @keysMngr: the pointer to associated keys manager. * * Reads keys from an XML file. * * Returns 0 on success or a negative value if an error occurs. */ int xmlSecSimpleKeysStoreLoad(xmlSecKeyStorePtr store, const char *uri, xmlSecKeysMngrPtr keysMngr) { xmlDocPtr doc; xmlNodePtr root; xmlNodePtr cur; xmlSecKeyPtr key; xmlSecKeyInfoCtx keyInfoCtx; int ret; xmlSecAssert2(xmlSecKeyStoreCheckId(store, xmlSecSimpleKeysStoreId), -1); xmlSecAssert2(uri != NULL, -1); doc = xmlParseFile(uri); if(doc == NULL) { xmlSecErr_a_ignorar6(XMLSEC_ERRORS_HERE, xmlSecErrorsSafeString(xmlSecKeyStoreGetName(store)), "xmlParseFile", XMLSEC_ERRORS_R_XML_FAILED, "uri=%s", xmlSecErrorsSafeString(uri)); return(-1); } root = xmlDocGetRootElement(doc); if(!xmlSecCheckNodeName(root, BAD_CAST "Keys", xmlSecNs)) { xmlSecErr_a_ignorar5(XMLSEC_ERRORS_HERE, xmlSecErrorsSafeString(xmlSecKeyStoreGetName(store)), xmlSecErrorsSafeString(xmlSecNodeGetName(root)), XMLSEC_ERRORS_R_INVALID_NODE, "expected-node=<xmlsec:Keys>"); xmlFreeDoc(doc); return(-1); } cur = xmlSecGetNextElementNode(root->children); while((cur != NULL) && xmlSecCheckNodeName(cur, xmlSecNodeKeyInfo, xmlSecDSigNs)) { key = xmlSecKeyCreate(); if(key == NULL) { xmlSecErr_a_ignorar6(XMLSEC_ERRORS_HERE, xmlSecErrorsSafeString(xmlSecKeyStoreGetName(store)), xmlSecErrorsSafeString(xmlSecNodeGetName(cur)), XMLSEC_ERRORS_R_INVALID_NODE, "expected-node=%s", xmlSecErrorsSafeString(xmlSecNodeKeyInfo)); xmlFreeDoc(doc); return(-1); } ret = xmlSecKeyInfoCtxInitialize(&keyInfoCtx, NULL); if(ret < 0) { xmlSecErr_a_ignorar5(XMLSEC_ERRORS_HERE, xmlSecErrorsSafeString(xmlSecKeyStoreGetName(store)), "xmlSecKeyInfoCtxInitialize", XMLSEC_ERRORS_R_XMLSEC_FAILED, XMLSEC_ERRORS_NO_MESSAGE); xmlSecKeyDestroy(key); xmlFreeDoc(doc); return(-1); } keyInfoCtx.mode = xmlSecKeyInfoModeRead; keyInfoCtx.keysMngr = keysMngr; keyInfoCtx.flags = XMLSEC_KEYINFO_FLAGS_DONT_STOP_ON_KEY_FOUND | XMLSEC_KEYINFO_FLAGS_X509DATA_DONT_VERIFY_CERTS; keyInfoCtx.keyReq.keyId = xmlSecKeyDataIdUnknown; keyInfoCtx.keyReq.keyType = xmlSecKeyDataTypeAny; keyInfoCtx.keyReq.keyUsage= xmlSecKeyDataUsageAny; ret = xmlSecKeyInfoNodeRead(cur, key, &keyInfoCtx); if(ret < 0) { xmlSecErr_a_ignorar5(XMLSEC_ERRORS_HERE, xmlSecErrorsSafeString(xmlSecKeyStoreGetName(store)), "xmlSecKeyInfoNodeRead", XMLSEC_ERRORS_R_XMLSEC_FAILED, XMLSEC_ERRORS_NO_MESSAGE); xmlSecKeyInfoCtxFinalize(&keyInfoCtx); xmlSecKeyDestroy(key); xmlFreeDoc(doc); return(-1); } xmlSecKeyInfoCtxFinalize(&keyInfoCtx); if(xmlSecKeyIsValid(key)) { ret = xmlSecSimpleKeysStoreAdoptKey(store, key); if(ret < 0) { xmlSecErr_a_ignorar5(XMLSEC_ERRORS_HERE, xmlSecErrorsSafeString(xmlSecKeyStoreGetName(store)), "xmlSecSimpleKeysStoreAdoptKey", XMLSEC_ERRORS_R_XMLSEC_FAILED, XMLSEC_ERRORS_NO_MESSAGE); xmlSecKeyDestroy(key); xmlFreeDoc(doc); return(-1); } } else { /* we have an unknown key in our file, just ignore it */ xmlSecKeyDestroy(key); } cur = xmlSecGetNextElementNode(cur->next); } if(cur != NULL) { xmlSecErr_a_ignorar5(XMLSEC_ERRORS_HERE, xmlSecErrorsSafeString(xmlSecKeyStoreGetName(store)), xmlSecErrorsSafeString(xmlSecNodeGetName(cur)), XMLSEC_ERRORS_R_UNEXPECTED_NODE, XMLSEC_ERRORS_NO_MESSAGE); xmlFreeDoc(doc); return(-1); } xmlFreeDoc(doc); return(0); }
static void save_obconf_settings (void) { const char *session_name; char *user_config_file, *c, *font, *fname; int count; const gchar *size = NULL, *bold = NULL, *italic = NULL; // construct the file path session_name = g_getenv ("DESKTOP_SESSION"); if (!session_name) session_name = DEFAULT_SES; fname = g_strconcat (g_ascii_strdown (session_name, -1), "-rc.xml", NULL); user_config_file = g_build_filename (g_get_user_config_dir (), "openbox/", fname, NULL); g_free (fname); // set the font description variables for XML from the font name font = g_strdup (desktop_font); while ((c = strrchr (font, ' '))) { if (!bold && !italic && !size && atoi (c + 1)) size = c + 1; else if (!bold && !italic && !g_ascii_strcasecmp (c + 1, "italic")) italic = c + 1; else if (!bold && !g_ascii_strcasecmp (c + 1, "bold")) bold = c + 1; else break; *c = '\0'; } if (!bold) bold = "Normal"; if (!italic) italic = "Normal"; // read in data from XML file xmlInitParser (); LIBXML_TEST_VERSION xmlDocPtr xDoc = xmlParseFile (user_config_file); if (xDoc == NULL) { g_free (font); g_free (user_config_file); return; } xmlXPathContextPtr xpathCtx = xmlXPathNewContext (xDoc); xmlXPathObjectPtr xpathObj = xmlXPathEvalExpression ((xmlChar *) "/*[local-name()='openbox_config']/*[local-name()='theme']/*[local-name()='font']", xpathCtx); // update relevant nodes with new values for (count = 0; count < xpathObj->nodesetval->nodeNr; count++) { xmlNode *node = xpathObj->nodesetval->nodeTab[count]; xmlAttr *attr = node->properties; xmlNode *cur_node = NULL; for (cur_node = node->children; cur_node; cur_node = cur_node->next) { if (cur_node->type == XML_ELEMENT_NODE) { if (!strcmp (cur_node->name, "name")) xmlNodeSetContent (cur_node, font); if (!strcmp (cur_node->name, "size")) xmlNodeSetContent (cur_node, size); if (!strcmp (cur_node->name, "weight")) xmlNodeSetContent (cur_node, bold); if (!strcmp (cur_node->name, "slant")) xmlNodeSetContent (cur_node, italic); } } } // cleanup XML xmlXPathFreeObject (xpathObj); xmlXPathFreeContext (xpathCtx); xmlSaveFile (user_config_file, xDoc); xmlFreeDoc (xDoc); xmlCleanupParser (); g_free (font); g_free (user_config_file); }
static void check_themes (void) { const char *session_name, *ret; char *user_config_file, *cptr, *nptr, *fname; GKeyFile *kf; GError *err; int count; orig_lxsession_theme = ""; orig_openbox_theme = ""; // construct the file path for lxsession settings session_name = g_getenv ("DESKTOP_SESSION"); if (!session_name) session_name = DEFAULT_SES; user_config_file = g_build_filename (g_get_user_config_dir (), "lxsession/", session_name, "/desktop.conf", NULL); // read in data from file to a key file structure kf = g_key_file_new (); if (g_key_file_load_from_file (kf, user_config_file, G_KEY_FILE_KEEP_COMMENTS | G_KEY_FILE_KEEP_TRANSLATIONS, NULL)) { // get data from the key file err = NULL; ret = g_key_file_get_string (kf, "GTK", "sNet/ThemeName", &err); if (err == NULL) orig_lxsession_theme = ret; } // construct the file path for openbox settings fname = g_strconcat (g_ascii_strdown (session_name, -1), "-rc.xml", NULL); user_config_file = g_build_filename (g_get_user_config_dir (), "openbox/", fname, NULL); g_free (fname); // read in data from XML file xmlInitParser (); LIBXML_TEST_VERSION xmlDocPtr xDoc = xmlParseFile (user_config_file); if (xDoc) { xmlXPathContextPtr xpathCtx = xmlXPathNewContext (xDoc); xmlXPathObjectPtr xpathObj = xmlXPathEvalExpression ((xmlChar *) "/*[local-name()='openbox_config']/*[local-name()='theme']", xpathCtx); // find relevant node and read value for (count = 0; count < xpathObj->nodesetval->nodeNr; count++) { xmlNode *node = xpathObj->nodesetval->nodeTab[count]; xmlAttr *attr = node->properties; xmlNode *cur_node = NULL; for (cur_node = node->children; cur_node; cur_node = cur_node->next) { if (cur_node->type == XML_ELEMENT_NODE) { if (!strcmp (cur_node->name, "name")) orig_openbox_theme = xmlNodeGetContent (cur_node); } } } // cleanup XML xmlXPathFreeObject (xpathObj); xmlXPathFreeContext (xpathCtx); xmlSaveFile (user_config_file, xDoc); xmlFreeDoc (xDoc); xmlCleanupParser (); } g_free (user_config_file); // set the new themes if needed if (strcmp ("PiX", orig_lxsession_theme)) { set_lxsession_theme ("PiX"); if (needs_refresh) system (RELOAD_LXSESSION); } if (strcmp ("PiX", orig_openbox_theme)) { set_openbox_theme ("PiX"); system (RELOAD_OPENBOX); } }
static void *construct_xslt(const xmlNode *ptr, const char *path, WRBUF wr_error) { struct _xmlAttr *attr; const char *stylesheet = 0; struct xslt_info *info = 0; NMEM nmem = 0; int max_parms = 10; int no_parms = 0; if (strcmp((const char *) ptr->name, "xslt")) return 0; for (attr = ptr->properties; attr; attr = attr->next) { if (!xmlStrcmp(attr->name, BAD_CAST "stylesheet") && attr->children && attr->children->type == XML_TEXT_NODE) stylesheet = (const char *) attr->children->content; else { wrbuf_printf(wr_error, "Bad attribute '%s'" "Expected stylesheet.", attr->name); return 0; } } nmem = nmem_create(); info = nmem_malloc(nmem, sizeof(*info)); info->nmem = nmem; info->xsl_parms = nmem_malloc( nmem, (2 * max_parms + 1) * sizeof(*info->xsl_parms)); for (ptr = ptr->children; ptr; ptr = ptr->next) { const char *name = 0; const char *value = 0; char *qvalue = 0; if (ptr->type != XML_ELEMENT_NODE) continue; if (strcmp((const char *) ptr->name, "param")) { wrbuf_printf(wr_error, "Bad element '%s'" "Expected param.", ptr->name); nmem_destroy(nmem); return 0; } for (attr = ptr->properties; attr; attr = attr->next) { if (!xmlStrcmp(attr->name, BAD_CAST "name") && attr->children && attr->children->type == XML_TEXT_NODE) name = (const char *) attr->children->content; else if (!xmlStrcmp(attr->name, BAD_CAST "value") && attr->children && attr->children->type == XML_TEXT_NODE) value = (const char *) attr->children->content; else { wrbuf_printf(wr_error, "Bad attribute '%s'" "Expected name or value.", attr->name); nmem_destroy(nmem); return 0; } } if (!name || !value) { wrbuf_printf(wr_error, "Missing attributes name or value"); nmem_destroy(nmem); return 0; } if (no_parms >= max_parms) { wrbuf_printf(wr_error, "Too many parameters given"); nmem_destroy(nmem); return 0; } qvalue = nmem_malloc(nmem, strlen(value) + 3); strcpy(qvalue, "\'"); strcat(qvalue, value); strcat(qvalue, "\'"); info->xsl_parms[2 * no_parms] = nmem_strdup(nmem, name); info->xsl_parms[2 * no_parms + 1] = qvalue; no_parms++; } info->xsl_parms[2 * no_parms] = 0; if (!stylesheet) { wrbuf_printf(wr_error, "Element <xslt>: " "attribute 'stylesheet' expected"); nmem_destroy(nmem); } else { char fullpath[1024]; xsltStylesheetPtr xsp; if (!yaz_filepath_resolve(stylesheet, path, 0, fullpath)) { wrbuf_printf(wr_error, "Element <xslt stylesheet=\"%s\"/>:" " could not locate stylesheet '%s'", stylesheet, stylesheet); if (path) wrbuf_printf(wr_error, " with path '%s'", path); nmem_destroy(nmem); return 0; } info->xsp_doc = xmlParseFile(fullpath); if (!info->xsp_doc) { wrbuf_printf(wr_error, "Element: <xslt stylesheet=\"%s\"/>:" " xml parse failed: %s", stylesheet, fullpath); if (path) wrbuf_printf(wr_error, " with path '%s'", path); nmem_destroy(nmem); return 0; } /* need to copy this before passing it to the processor. It will be encapsulated in the xsp and destroyed by xsltFreeStylesheet */ xsp = xsltParseStylesheetDoc(xmlCopyDoc(info->xsp_doc, 1)); if (!xsp) { wrbuf_printf(wr_error, "Element: <xslt stylesheet=\"%s\"/>:" " xslt parse failed: %s", stylesheet, fullpath); if (path) wrbuf_printf(wr_error, " with path '%s'", path); wrbuf_printf(wr_error, " (" #if YAZ_HAVE_EXSLT "EXSLT enabled" #else "EXSLT not supported" #endif ")"); xmlFreeDoc(info->xsp_doc); nmem_destroy(info->nmem); } else { xsltFreeStylesheet(xsp); return info; } } return 0; }
Map* parseDoc(char* filename){ xmlDocPtr doc; xmlNodePtr root_element; doc = xmlParseFile(filename); if (doc == NULL) { fprintf(stderr, "Failed to parse %s\n", filename); return NULL; } root_element = xmlDocGetRootElement(doc); if (root_element == NULL){ fprintf(stderr, "empty document\n"); xmlFreeDoc(doc); return NULL; } Map* map = malloc(sizeof(Map)); map = parseElements(doc, root_element); xmlFreeDoc(doc); return map; }