Bool CXMLDocument::AddDTD(char *data, unsigned long tlength) { if (!isinited()) return False; xmlParserInputBufferPtr dtdInputBufferPtr; xmlDtdPtr dtd; dtdInputBufferPtr = xmlParserInputBufferCreateMem(data, tlength, XML_CHAR_ENCODING_UTF8); dtd = xmlIOParseDTD(NULL, dtdInputBufferPtr, XML_CHAR_ENCODING_UTF8); if (!dtd) return False; if (dtd->name != NULL) xmlFree((char*)dtd->name); CXMLElement telement; GetRootElement(&telement); dtd->name = xmlStrdup((xmlChar *)telement.GetName()); doc->intSubset = dtd; if (dtd->ExternalID != NULL) { xmlFree((xmlChar *) dtd->ExternalID); dtd->ExternalID = NULL; } if (dtd->SystemID != NULL) { xmlFree((xmlChar *) dtd->SystemID); dtd->SystemID = NULL; } dtd->doc = doc; dtd->parent = doc; if (doc->children == NULL) xmlAddChild((xmlNodePtr)doc, (xmlNodePtr)dtd); else xmlAddPrevSibling(doc->children, (xmlNodePtr)dtd); return Validate(); }
/** * Validate epg document in bstring format against dtd */ int epg_validate(const char *xml) { if (!xml) return -1; int rc; xmlValidCtxtPtr ctx = xmlNewValidCtxt(); error_if(ctx == NULL, error, "Error creating validation context"); xmlDocPtr doc = xmlParseMemory((char *)xml, strlen(xml)); error_if(doc == NULL, error, "Error creating Parser"); /* Validate against in memory dtd */ xmlParserInputBufferPtr buf = xmlParserInputBufferCreateMem( xmltv_dtd, strlen(xmltv_dtd), XML_CHAR_ENCODING_NONE); xmlDtdPtr dtd = xmlIOParseDTD(NULL, buf, XML_CHAR_ENCODING_NONE); xmlFreeParserInputBuffer(buf); /* xmlDtdPtr dtd = xmlParseDTD(NULL, BAD_CAST epg_dtd_file); */ rc = xmlValidateDtd(ctx, doc, dtd); trace("Resultado de validación: %d", rc); xmlCleanupParser(); return rc; error: xmlCleanupParser(); return -1; }
static void on_downloaded (SummerWebBackend *web, gchar *save_path, gchar *save_data, GError *error, gpointer user_data) { g_return_if_fail (SUMMER_IS_FEED (user_data)); SummerFeed *self = SUMMER_FEED (user_data); SummerFeedPrivate *priv = self->priv; if (error == NULL) { SummerFeedParser *parsers[] = { SUMMER_FEED_PARSER (summer_atom_parser_new ()), SUMMER_FEED_PARSER (summer_rss2_parser_new ())}; xmlParserInputBufferPtr buffer = xmlParserInputBufferCreateMem (save_data, strlen (save_data), 0); xmlTextReaderPtr reader = xmlNewTextReader (buffer, priv->url); priv->feed_data = summer_feed_parser_parse (parsers, sizeof (parsers) / sizeof (*parsers), reader); priv->feed_data->url = priv->url; unsigned int i; for (i = 0; i < sizeof (parsers) / sizeof (*parsers); i++) { g_object_unref (parsers[i]); } xmlTextReaderClose (reader); xmlFreeTextReader (reader); xmlFreeParserInputBuffer (buffer); g_signal_emit_by_name (self, "new-entries"); } g_object_unref (web); if (priv->frequency <= 0) g_object_unref (self); }
xmlParserInputBufferPtr mxslt_create_input_fd(mxslt_doc_t * doc, int fd) { xmlParserInputBufferPtr retval; mxslt_mmap_ctx_t * mmapd; struct stat buf; char * tmp = MAP_FAILED; if(fstat(fd, &buf) < 0) { mxslt_error(doc, "couldn't stat fd: %d, errno: %d\n", fd, errno); close(fd); return NULL; } /* We do not want to deal with weird files... * no devices nor pipes are allowed! */ if(!S_ISREG(buf.st_mode)) { mxslt_error(doc, "fd is not a regular file: %d\n", fd); close(fd); return NULL; } if(!buf.st_size) { mxslt_error(doc, "Zero sized files are not valid xml (fd: %d), out of disk space?\n", fd); close(fd); return NULL; } #ifdef HAVE_MMAP /* make sure the file is no larger than what we can hold on * a size_t - unlikely, but you never know whose files mod-xslt * is trying to load - let's be paranoid for once */ if (buf.st_size >= 0 && (uintmax_t)((size_t)-1) >= (uintmax_t)(buf.st_size) && (uintmax_t)(INT_MAX) >= (uintmax_t)(buf.st_size)) tmp=mmap(NULL, (size_t)buf.st_size, PROT_READ, MAP_PRIVATE, fd, 0); /* If mmap succedes, we should be done */ if(tmp != MAP_FAILED) { retval=xmlParserInputBufferCreateMem( tmp, buf.st_size, XML_CHAR_ENCODING_NONE); if(retval) { mmapd=(mxslt_mmap_ctx_t *)(xmalloc(sizeof(mxslt_mmap_ctx_t))); mmapd->mem=tmp; mmapd->size=(size_t)buf.st_size; mmapd->fd=fd; retval->closecallback=mxslt_destroy_input_mmap; retval->context=mmapd; return retval; } munmap(tmp, (size_t)buf.st_size); } #endif /* HAVE_MMAP */ return xmlParserInputBufferCreateFd(fd, XML_CHAR_ENCODING_NONE); }
int validateXML(const char *input_file, const char *DTDdata) { int ret = 0; char *XMLdata; xmlDocPtr doc = 0; xmlDtdPtr dtd = 0; xmlValidCtxtPtr cvp = 0; xmlParserInputBufferPtr bp; doc = xmlParseFile(input_file); if (!doc) { printf("xmlParseFile(\"%s\") failed\n", input_file); ret = 1; goto exit; } bp = xmlParserInputBufferCreateMem(DTDdata, strlen(DTDdata), XML_CHAR_ENCODING_NONE); dtd = xmlIOParseDTD(NULL, bp, XML_CHAR_ENCODING_NONE); if (!dtd) { printf("xmlIOParseDTD() failed\n"); ret = 2; goto exit; } cvp = xmlNewValidCtxt(); if (!cvp) { printf("xmlNewValidCtxt() failed\n"); ret = 3; goto exit; } cvp->userData = (void*)stderr; cvp->error = (xmlValidityErrorFunc)fprintf; cvp->warning = (xmlValidityWarningFunc)fprintf; if (!xmlValidateDtd(cvp, doc, dtd)) { printf("xmlValidateDtd() failed\n"); ret = 4; goto exit; } ret = 0; exit: if (doc) { xmlFreeDoc(doc); } if (dtd) { xmlFreeDtd(dtd); } if (cvp) { xmlFreeValidCtxt(cvp); } return ret; }
bool HHVM_METHOD(XMLReader, XML, const String& source, const Variant& encoding /*= null_variant*/, int64_t options /*= 0*/) { auto* data = Native::data<XMLReader>(this_); const String& str_encoding = encoding.isNull() ? null_string : encoding.toString(); xmlParserInputBufferPtr inputbfr = xmlParserInputBufferCreateMem( source.c_str(), source.size(), XML_CHAR_ENCODING_NONE); if (inputbfr != nullptr) { char *uri = nullptr; String directory = g_context->getCwd(); if (!directory.empty()) { if (directory[directory.size() - 1] != '/') { directory += "/"; } uri = (char *) xmlCanonicPath((const xmlChar *) directory.c_str()); } xmlTextReaderPtr reader = xmlNewTextReader(inputbfr, uri); if (reader != nullptr) { int ret = 0; #if LIBXML_VERSION >= 20628 ret = xmlTextReaderSetup(reader, nullptr, uri, str_encoding.data(), options); #endif if (ret == 0) { data->m_ptr = reader; data->m_input = inputbfr; if (uri) { xmlFree(uri); } return true; } } if (uri) { xmlFree(uri); } } if (inputbfr) { xmlFreeParserInputBuffer(inputbfr); } raise_warning("Unable to load source data"); return false; }
static bool is_dtd_valid(FILE *input, const char *filename) { bool rc = true; #if HAVE_LIBXML xmlParserCtxtPtr ctx = NULL; xmlDocPtr doc = NULL; xmlDtdPtr dtd = NULL; xmlValidCtxtPtr dtdctx; xmlParserInputBufferPtr buffer; int fd = fileno(input); dtdctx = xmlNewValidCtxt(); ctx = xmlNewParserCtxt(); if (!ctx || !dtdctx) abort(); buffer = xmlParserInputBufferCreateMem(&DTD_DATA_begin, DTD_DATA_len, XML_CHAR_ENCODING_UTF8); if (!buffer) { fprintf(stderr, "Failed to init buffer for DTD.\n"); abort(); } dtd = xmlIOParseDTD(NULL, buffer, XML_CHAR_ENCODING_UTF8); if (!dtd) { fprintf(stderr, "Failed to parse DTD.\n"); abort(); } doc = xmlCtxtReadFd(ctx, fd, filename, NULL, 0); if (!doc) { fprintf(stderr, "Failed to read XML\n"); abort(); } rc = xmlValidateDtd(dtdctx, doc, dtd); xmlFreeDoc(doc); xmlFreeParserCtxt(ctx); xmlFreeDtd(dtd); xmlFreeValidCtxt(dtdctx); /* xmlIOParseDTD consumes buffer */ if (lseek(fd, 0, SEEK_SET) != 0) { fprintf(stderr, "Failed to reset fd, output would be garbage.\n"); abort(); } #endif return rc; }
static int raptor_rss_parse_chunk(raptor_parser* rdf_parser, const unsigned char *s, size_t len, int is_end) { raptor_rss_parser_context* rss_parser=(raptor_rss_parser_context*)rdf_parser->context; int ret; if(!rss_parser->reader) { unsigned char *uri=raptor_uri_as_string(rdf_parser->base_uri); rss_parser->input=xmlParserInputBufferCreateMem((const char*)s, len, XML_CHAR_ENCODING_NONE); rss_parser->reader=xmlNewTextReader(rss_parser->input, (const char*)uri); xmlTextReaderSetErrorHandler(rss_parser->reader, raptor_rss_error_handler, rdf_parser); } else if(s && len) xmlParserInputBufferPush(rss_parser->input, len, (const char*)s); if(!is_end) return 0; ret = xmlTextReaderRead(rss_parser->reader); while (ret == 1) { if(rdf_parser->failed) break; raptor_rss_parser_processNode(rdf_parser); ret = xmlTextReaderRead(rss_parser->reader); } xmlFreeTextReader(rss_parser->reader); rss_parser->reader=NULL; xmlFreeParserInputBuffer(rss_parser->input); rss_parser->input=NULL; if(rdf_parser->failed) return 1; /* turn strings into URIs, move things around if needed */ raptor_rss_insert_identifiers(rdf_parser); /* generate the triples */ raptor_rss_emit(rdf_parser); return (ret != 0); }
/* ############################################################################# * * Description add a DTD to the xml document * Author Harry Brueckner * Date 2005-05-04 * Arguments SHOWERROR_FN - callback function for error messages * Return -1 if the DTD could not be updated, 0 if the document did not * validate and 1 if everything is ok */ int checkDtd(SHOWERROR_FN showerror_cb) { xmlDtd* dtd; xmlParserInputBuffer* inputbuffer; xmlValidCtxt* context = xmlNewValidCtxt(); char* dtdbuffer; TRACE(99, "checkDtd()", NULL); if (!xmldoc) { return -1; } xmlRemoveDtd(); /* first we create the DTD as a whole */ dtdbuffer = memAlloc(__FILE__, __LINE__, strlen(dtd_1) + strlen(dtd_2) + strlen(dtd_3) + 1); if (!dtdbuffer) { return -1; } strStrncpy(dtdbuffer, dtd_1, strlen(dtd_1) + 1); strStrncat(dtdbuffer, dtd_2, strlen(dtd_2) + 1); strStrncat(dtdbuffer, dtd_3, strlen(dtd_3) + 1); /* create the xml buffer */ inputbuffer = xmlParserInputBufferCreateMem(dtdbuffer, strlen(dtdbuffer), XML_CHAR_ENCODING_8859_1); memFreeString(__FILE__, __LINE__, dtdbuffer); if (!dtdbuffer) { return -1; } /* and finally create the DTD */ dtd = xmlIOParseDTD(NULL, inputbuffer, XML_CHAR_ENCODING_8859_1); if (!dtd) { return -1; } /* and attach the DTD to the document */ if (!xmldoc -> children) { xmlAddChild((xmlNode*)xmldoc, (xmlNode*)dtd); } else { xmlAddPrevSibling(xmldoc -> children, (xmlNode*)dtd); } /* we set our own error handler */ validateShowError = showerror_cb; context -> error = xmlValidateError; context -> warning = xmlValidateWarning; return xmlValidateDtd(context, xmldoc, dtd); }
xmlreader _xmlreader_from_string(const char *buffer, int size, const char *URL, const char *encoding, int options) { xmlTextReaderPtr reader; xmlParserInputBufferPtr buf; buf = xmlParserInputBufferCreateMem(buffer, size, XML_CHAR_ENCODING_NONE); if (buf == NULL) return (NULL); reader = xmlNewTextReader(buf, URL); if (reader == NULL) { xmlFreeParserInputBuffer(buf); return (NULL); } xmlTextReaderSetup(reader, buf, URL, encoding, options); return (reader); }
Bool CXMLDocument::ValidateDTD(char *data, unsigned long tlength) { if (!isinited()) return False; xmlParserInputBufferPtr dtdInputBufferPtr; xmlDtdPtr dtd; dtdInputBufferPtr = xmlParserInputBufferCreateMem(data, tlength, XML_CHAR_ENCODING_UTF8); dtd = xmlIOParseDTD(NULL, dtdInputBufferPtr, XML_CHAR_ENCODING_UTF8); if (!dtd) return False; xmlValidCtxt ctxt; ctxt.doc = doc; ctxt.userData = NULL; //point to dtd error handling function ctxt.error = errorCallback; ctxt.warning = warningCallback; Bool isvalid = xmlValidateDtd(&ctxt,doc,dtd); xmlFreeDtd(dtd); return isvalid; }
bool c_XMLReader::t_xml(const String& source, const String& encoding /*= null_string*/, int64_t options /*= 0*/) { xmlParserInputBufferPtr inputbfr = xmlParserInputBufferCreateMem(source.c_str(), source.size(), XML_CHAR_ENCODING_NONE); if (inputbfr != NULL) { char *uri = NULL; String directory = g_context->getCwd(); if (!directory.empty()) { if (directory[directory.size() - 1] != '/') { directory += "/"; } uri = (char *) xmlCanonicPath((const xmlChar *) directory.c_str()); } xmlTextReaderPtr reader = xmlNewTextReader(inputbfr, uri); if (reader != NULL) { int ret = 0; #if LIBXML_VERSION >= 20628 ret = xmlTextReaderSetup(reader, NULL, uri, encoding.data(), options); #endif if (ret == 0) { m_ptr = reader; m_input = inputbfr; if (uri) { xmlFree(uri); } return true; } } if (uri) { xmlFree(uri); } } if (inputbfr) { xmlFreeParserInputBuffer(inputbfr); } raise_warning("Unable to load source data"); return false; }
bool c_XMLReader::t_xml(CStrRef source, CStrRef encoding /*= null_string*/, int64 options /*= 0*/) { INSTANCE_METHOD_INJECTION_BUILTIN(XMLReader, XMLReader::xml); xmlParserInputBufferPtr inputbfr = xmlParserInputBufferCreateMem(source.c_str(), source.size(), XML_CHAR_ENCODING_NONE); if (inputbfr != NULL) { char *uri = NULL; String directory = g_context->getCwd(); if (!directory.empty()) { if (directory[directory.size() - 1] != '/') { directory += '/'; } uri = (char *) xmlCanonicPath((const xmlChar *) directory.c_str()); } xmlTextReaderPtr reader = xmlNewTextReader(inputbfr, uri); if (reader != NULL) { int ret = xmlTextReaderSetup(reader, NULL, uri, encoding.data(), options); if (ret == 0) { m_ptr = reader; m_input = inputbfr; if (uri) { xmlFree(uri); } return true; } } if (uri) { xmlFree(uri); } } if (inputbfr) { xmlFreeParserInputBuffer(inputbfr); } raise_warning("Unable to load source data"); return false; }
void CLibXmlValidator::validate() { if (!xmlFile.length() && !xml.length()) throw MakeStringException(XMLERR_MissingSource, "Source XML not provided"); if (!xsdFile.length() && !xsd.length()) throw MakeStringException(XMLERR_MissingSource, "XML Schema not provided"); xmlParserInputBufferPtr input; if (xmlFile.length()) input = xmlParserInputBufferCreateFilename(xmlFile.get(), XML_CHAR_ENCODING_NONE); else input = xmlParserInputBufferCreateMem(xml.str(), xml.length()+1, XML_CHAR_ENCODING_NONE); if (!input) throw MakeStringException(XMLERR_InvalidXml, "Failed to create XML input stream"); xmlSchemaParserCtxtPtr xsdParser; if (xsdFile.length()) xsdParser = xmlSchemaNewParserCtxt(xsdFile.get()); else xsdParser = xmlSchemaNewMemParserCtxt(xsd.str(), xsd.length()); if (!xsdParser) throw MakeStringException(XMLERR_InvalidXsd, "Failed to load XML Schema"); xmlSchemaSetParserErrors(xsdParser, libxmlXsdErrorMsgHandler, libxmlXsdErrorMsgHandler, this); xmlSchemaPtr schema = xmlSchemaParse(xsdParser); xmlSchemaFreeParserCtxt(xsdParser); if (!schema) throw MakeStringException(XMLERR_InvalidXsd, "XSD schema parsing failed"); xmlSchemaValidCtxtPtr validator = xmlSchemaNewValidCtxt(schema); xmlSchemaSetValidErrors(validator, libxmlXsdErrorMsgHandler, libxmlXsdErrorMsgHandler, this); int ret = xmlSchemaValidateStream(validator, input, XML_CHAR_ENCODING_NONE, emptySAXHandler, (void *)this); if (ret != 0) { ensureExceptions()->append(*MakeStringException(XMLERR_XsdValidationFailed, "XML validation failed")); throw exceptions.getClear(); } xmlSchemaFreeValidCtxt(validator); }
void OtNtParallels::read(const gchar * filename) { // Get contents of the data file. Bail out if not there. ustring xmlfilename = gw_build_filename(Directories->get_package_data(), filename); if (!g_file_test(xmlfilename.c_str(), G_FILE_TEST_IS_REGULAR)) return; gchar *contents; g_file_get_contents(xmlfilename.c_str(), &contents, NULL, NULL); /* Read the xml data. Example: <section title="The Descendants of Noah's Sons"> <set> <reference book="Genesis" chapter="10" verse="2-4"/> <reference book="1 Chronicles" chapter="1" verse="5-7"/> </set> <set> <reference book="Genesis" chapter="10" verse="6-8"/> <reference book="1 Chronicles" chapter="1" verse="8-10"/> </set> <set> <reference book="Genesis" chapter="10" verse="13-18"/> <reference book="1 Chronicles" chapter="1" verse="11-16"/> </set> </section> */ xmlParserInputBufferPtr inputbuffer; inputbuffer = xmlParserInputBufferCreateMem(contents, strlen(contents), XML_CHAR_ENCODING_NONE); xmlTextReaderPtr reader = xmlNewTextReader(inputbuffer, NULL); if (reader) { char *opening_element = NULL; OtNtParallelSection parallelsection(0); OtNtParallelSet parallelset(0); while ((xmlTextReaderRead(reader) == 1)) { switch (xmlTextReaderNodeType(reader)) { case XML_READER_TYPE_ELEMENT: { opening_element = (char *)xmlTextReaderName(reader); if (!strcmp(opening_element, "section")) { parallelsection.sets.clear(); parallelsection.title.clear(); char *attribute; attribute = (char *)xmlTextReaderGetAttribute(reader, BAD_CAST "title"); if (attribute) { parallelsection.title = attribute; free(attribute); } } if (!strcmp(opening_element, "set")) { parallelset.references.clear(); } if (!strcmp(opening_element, "reference")) { Reference ref(0); char *attribute; attribute = (char *)xmlTextReaderGetAttribute(reader, BAD_CAST "book"); if (attribute) { ref.book = books_english_to_id(attribute); free(attribute); } attribute = (char *)xmlTextReaderGetAttribute(reader, BAD_CAST "chapter"); if (attribute) { ref.chapter = convert_to_int(attribute); free(attribute); } attribute = (char *)xmlTextReaderGetAttribute(reader, BAD_CAST "verse"); if (attribute) { ref.verse = attribute; free(attribute); } parallelset.references.push_back(ref); } break; } case XML_READER_TYPE_TEXT: { char *text = (char *)xmlTextReaderValue(reader); if (text) { free(text); } break; } case XML_READER_TYPE_END_ELEMENT: { char *closing_element = (char *)xmlTextReaderName(reader); if (!strcmp(closing_element, "set")) { parallelsection.sets.push_back(parallelset); } if (!strcmp(closing_element, "section")) { sections.push_back(parallelsection); } break; } } } } // Free memory. if (reader) xmlFreeTextReader(reader); if (inputbuffer) xmlFreeParserInputBuffer(inputbuffer); if (contents) g_free(contents); }
/* {{{ proto boolean XMLReader::XML(string source [, string encoding [, int options]]) Sets the string that the XMLReader will parse. */ PHP_METHOD(xmlreader, XML) { zval *id; size_t source_len = 0, encoding_len = 0; zend_long options = 0; xmlreader_object *intern = NULL; char *source, *uri = NULL, *encoding = NULL; int resolved_path_len, ret = 0; char *directory=NULL, resolved_path[MAXPATHLEN]; xmlParserInputBufferPtr inputbfr; xmlTextReaderPtr reader; if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|s!l", &source, &source_len, &encoding, &encoding_len, &options) == FAILURE) { return; } id = getThis(); if (id != NULL && ! instanceof_function(Z_OBJCE_P(id), xmlreader_class_entry)) { id = NULL; } if (id != NULL) { intern = Z_XMLREADER_P(id); xmlreader_free_resources(intern); } if (!source_len) { php_error_docref(NULL, E_WARNING, "Empty string supplied as input"); RETURN_FALSE; } inputbfr = xmlParserInputBufferCreateMem(source, source_len, XML_CHAR_ENCODING_NONE); if (inputbfr != NULL) { /* Get the URI of the current script so that we can set the base directory in libxml */ #if HAVE_GETCWD directory = VCWD_GETCWD(resolved_path, MAXPATHLEN); #elif HAVE_GETWD directory = VCWD_GETWD(resolved_path); #endif if (directory) { resolved_path_len = strlen(resolved_path); if (resolved_path[resolved_path_len - 1] != DEFAULT_SLASH) { resolved_path[resolved_path_len] = DEFAULT_SLASH; resolved_path[++resolved_path_len] = '\0'; } uri = (char *) xmlCanonicPath((const xmlChar *) resolved_path); } reader = xmlNewTextReader(inputbfr, uri); if (reader != NULL) { #if LIBXML_VERSION >= 20628 ret = xmlTextReaderSetup(reader, NULL, uri, encoding, options); #endif if (ret == 0) { if (id == NULL) { object_init_ex(return_value, xmlreader_class_entry); intern = Z_XMLREADER_P(return_value); } else { RETVAL_TRUE; } intern->input = inputbfr; intern->ptr = reader; if (uri) { xmlFree(uri); } return; } } } if (uri) { xmlFree(uri); } if (inputbfr) { xmlFreeParserInputBuffer(inputbfr); } php_error_docref(NULL, E_WARNING, "Unable to load source data"); RETURN_FALSE; }
Stylesheet::Stylesheet(const ustring & name_in) { gw_message("Creating Stylesheet called '" + name_in + "'"); // Save the sheet's name. name = name_in; // If the name is empty, read from the template. ustring filename = stylesheet_xml_filename(name); if (name.empty()) filename = stylesheet_xml_template_filename(); // Read the xml data, bail out on failure. gchar *contents; g_file_get_contents(filename.c_str(), &contents, NULL, NULL); if (contents == NULL) { gw_critical(_("Failure reading stylesheet ") + filename); return; } // Parse the stylesheet. xmlParserInputBufferPtr inputbuffer; inputbuffer = xmlParserInputBufferCreateMem(contents, strlen(contents), XML_CHAR_ENCODING_NONE); ustring value; xmlTextReaderPtr reader = xmlNewTextReader(inputbuffer, NULL); if (reader) { StyleV2 * style = NULL; while ((xmlTextReaderRead(reader) == 1)) { switch (xmlTextReaderNodeType(reader)) { case XML_READER_TYPE_ELEMENT: { xmlChar *element_name = xmlTextReaderName(reader); if (!xmlStrcmp(element_name, BAD_CAST "style")) { char *attribute = (char *)xmlTextReaderGetAttribute(reader, BAD_CAST "marker"); if (attribute) { style = new StyleV2 (0); style->marker = attribute; free(attribute); } } free(element_name); element_name = NULL; break; } case XML_READER_TYPE_TEXT: { xmlChar *text = xmlTextReaderValue(reader); if (text) { value = (gchar *) text; xmlFree(text); } break; } case XML_READER_TYPE_END_ELEMENT: { xmlChar *element_name = xmlTextReaderName(reader); if (style) { if (!xmlStrcmp(element_name, BAD_CAST "marker")) style->marker = value; if (!xmlStrcmp(element_name, BAD_CAST "name")) style->name = value; if (!xmlStrcmp(element_name, BAD_CAST "info")) style->info = value; if (!xmlStrcmp(element_name, BAD_CAST "type")) style->type = (StyleType) convert_to_int(value); if (!xmlStrcmp(element_name, BAD_CAST "subtype")) style->subtype = convert_to_int(value); if (!xmlStrcmp(element_name, BAD_CAST "fontsize")) style->fontsize = convert_to_double(value); if (!xmlStrcmp(element_name, BAD_CAST "italic")) style->italic = value; if (!xmlStrcmp(element_name, BAD_CAST "bold")) style->bold = value; if (!xmlStrcmp(element_name, BAD_CAST "underline")) style->underline = value; if (!xmlStrcmp(element_name, BAD_CAST "smallcaps")) style->smallcaps = value; if (!xmlStrcmp(element_name, BAD_CAST "superscript")) style->superscript = convert_to_bool(value); if (!xmlStrcmp(element_name, BAD_CAST "justification")) style->justification = value; if (!xmlStrcmp(element_name, BAD_CAST "spacebefore")) style->spacebefore = convert_to_double(value); if (!xmlStrcmp(element_name, BAD_CAST "spaceafter")) style->spaceafter = convert_to_double(value); if (!xmlStrcmp(element_name, BAD_CAST "leftmargin")) style->leftmargin = convert_to_double(value); if (!xmlStrcmp(element_name, BAD_CAST "rightmargin")) style->rightmargin = convert_to_double(value); if (!xmlStrcmp(element_name, BAD_CAST "firstlineindent")) style->firstlineindent = convert_to_double(value); if (!xmlStrcmp(element_name, BAD_CAST "spancolumns")) style->spancolumns = convert_to_bool(value); if (!xmlStrcmp(element_name, BAD_CAST "color")) style->color = convert_to_int(value); if (!xmlStrcmp(element_name, BAD_CAST "print")) style->print = convert_to_bool(value); if (!xmlStrcmp(element_name, BAD_CAST "userbool1")) style->userbool1 = convert_to_bool(value); if (!xmlStrcmp(element_name, BAD_CAST "userbool2")) style->userbool2 = convert_to_bool(value); if (!xmlStrcmp(element_name, BAD_CAST "userbool3")) style->userbool3 = convert_to_bool(value); if (!xmlStrcmp(element_name, BAD_CAST "userint1")) style->userint1 = convert_to_int(value); if (!xmlStrcmp(element_name, BAD_CAST "userint2")) style->userint2 = convert_to_int(value); if (!xmlStrcmp(element_name, BAD_CAST "userint3")) style->userint3 = convert_to_int(value); if (!xmlStrcmp(element_name, BAD_CAST "userstring1")) style->userstring1 = value; if (!xmlStrcmp(element_name, BAD_CAST "userstring2")) style->userstring2 = value; if (!xmlStrcmp(element_name, BAD_CAST "userstring3")) style->userstring3 = value; } value.clear(); if (!xmlStrcmp(element_name, BAD_CAST "style")) { if (style) { insert (style); style = NULL; } } free(element_name); element_name = NULL; break; } } } } // Free memory. if (reader) xmlFreeTextReader(reader); if (inputbuffer) xmlFreeParserInputBuffer(inputbuffer); if (contents) g_free(contents); }
void OTQuotations::read() { // Get contents of the data file. Bail out if not there. ustring xmlfilename = gw_build_filename(Directories->get_package_data(), "ot-quotations-in-nt.xml"); if (!g_file_test(xmlfilename.c_str(), G_FILE_TEST_IS_REGULAR)) return; gchar *contents; g_file_get_contents(xmlfilename.c_str(), &contents, NULL, NULL); /* Read the xml data. Example: <set> <nt book="Matthew" chapter="1" verse="23"/> <ot book="Isaiah" chapter="8" verse="8"/> <ot book="Isaiah" chapter="8" verse="10"/> <lxx>1</lxx> </set> */ xmlParserInputBufferPtr inputbuffer; inputbuffer = xmlParserInputBufferCreateMem(contents, strlen(contents), XML_CHAR_ENCODING_NONE); xmlTextReaderPtr reader = xmlNewTextReader(inputbuffer, NULL); if (reader) { char *opening_element = NULL; OTQuotation quotation(0); while ((xmlTextReaderRead(reader) == 1)) { switch (xmlTextReaderNodeType(reader)) { case XML_READER_TYPE_ELEMENT: { opening_element = (char *)xmlTextReaderName(reader); if (!strcmp(opening_element, "set")) { quotation.reference.clear(); quotation.referents.clear(); quotation.lxx = false; free(opening_element); opening_element = NULL; // not used next loop iteration } else if (!strcmp(opening_element, "nt") || !strcmp(opening_element, "ot")) { Reference ref; char *attribute; attribute = (char *)xmlTextReaderGetAttribute(reader, BAD_CAST "book"); if (attribute) { ref.book_set(books_english_to_id(attribute)); free(attribute); } attribute = (char *)xmlTextReaderGetAttribute(reader, BAD_CAST "chapter"); if (attribute) { ref.chapter_set(convert_to_int(attribute)); free(attribute); } attribute = (char *)xmlTextReaderGetAttribute(reader, BAD_CAST "verse"); if (attribute) { ref.verse_set(attribute); free(attribute); } if (!strcmp(opening_element, "nt")) { quotation.reference.assign(ref); } if (!strcmp(opening_element, "ot")) { quotation.referents.push_back(ref); } // cannot free(opening_element) because it will be used next loop iter in following switch case } break; } case XML_READER_TYPE_TEXT: { char *text = (char *)xmlTextReaderValue(reader); if (opening_element && text) { if (!strcmp(opening_element, "lxx")) { quotation.lxx = convert_to_bool(text); } free(text); free(opening_element); opening_element = NULL; } break; } case XML_READER_TYPE_END_ELEMENT: { char *closing_element = (char *)xmlTextReaderName(reader); if (!strcmp(closing_element, "set")) { quotations_nt_order.push_back(quotation); } free(closing_element); break; } } } } // Free memory. if (reader) xmlFreeTextReader(reader); if (inputbuffer) xmlFreeParserInputBuffer(inputbuffer); if (contents) g_free(contents); }
void kjv_import_sword (const ustring& textfile, const ustring& database) { // Show the progress. KJV has 31102 verses. ProgressWindow progresswindow (_("Importing King James Bible"), false); progresswindow.set_iterate (0, 1, 31102); gchar * contents; g_file_get_contents(textfile.c_str(), &contents, NULL, NULL); if (!contents) return; // Create the database, put it in fast mode. unix_unlink (database.c_str()); sqlite3 *db; sqlite3_open(database.c_str(), &db); sqlite3_exec(db, "create table kjv (book integer, chapter integer, verse integer, item integer, fragment text, lemma text);", NULL, NULL, NULL); sqlite3_exec(db, "PRAGMA synchronous=OFF;", NULL, NULL, NULL); // Parse input. xmlParserInputBufferPtr inputbuffer; inputbuffer = xmlParserInputBufferCreateMem(contents, strlen (contents), XML_CHAR_ENCODING_NONE); xmlTextReaderPtr reader = xmlNewTextReader(inputbuffer, NULL); if (reader) { bool within_relevant_element = false; Reference reference (0, 0, "0"); unsigned int item_number = 0; ustring textfragment; ustring lemmata; while ((xmlTextReaderRead(reader) == 1)) { switch (xmlTextReaderNodeType(reader)) { case XML_READER_TYPE_ELEMENT: { xmlChar *element_name = xmlTextReaderName(reader); // Deal with a verse element. if (!xmlStrcmp(element_name, BAD_CAST "verse")) { progresswindow.iterate(); char *attribute; attribute = (char *)xmlTextReaderGetAttribute(reader, BAD_CAST "osisID"); if (attribute) { Parse parse (attribute, false, "."); if (parse.words.size() == 3) { reference.assign(books_osis_to_id (parse.words[0]), // book convert_to_int (parse.words[1]), // chapter parse.words[2]); // verse } else { gw_critical (attribute); } free(attribute); } item_number = 0; } // Deal with a w element. if (!xmlStrcmp(element_name, BAD_CAST "w")) { within_relevant_element = true; item_number++; textfragment.clear(); lemmata.clear(); char *attribute; attribute = (char *)xmlTextReaderGetAttribute(reader, BAD_CAST "lemma"); if (attribute) { lemmata = attribute; free(attribute); } } break; } case XML_READER_TYPE_TEXT: { if (within_relevant_element) { xmlChar *text = xmlTextReaderValue(reader); if (text) { textfragment = (const char *)text; xmlFree(text); textfragment = textfragment.casefold(); } } break; } case XML_READER_TYPE_END_ELEMENT: { xmlChar *element_name = xmlTextReaderName(reader); if (!xmlStrcmp(element_name, BAD_CAST "w")) { replace_text (lemmata, "strong:", ""); char *sql; sql = g_strdup_printf("insert into kjv values (%d, %d, %d, %d, '%s', '%s');", reference.book_get(), reference.chapter_get(), convert_to_int (reference.verse_get()), item_number, double_apostrophy (textfragment).c_str(), lemmata.c_str()); sqlite3_exec(db, sql, NULL, NULL, NULL); g_free(sql); within_relevant_element = false; } break; } } } } if (reader) xmlFreeTextReader(reader); if (inputbuffer) xmlFreeParserInputBuffer(inputbuffer); // Close database. sqlite3_close(db); // Free xml data. g_free(contents); }
/** * Validation function take first argument as XML type, then check if is * well formated. If so, do the same for DTD document. If both success, check * XML document against DTD schema restrictions. * @return true if pass, false otherwise */ Datum xmlvalidate_dtd(PG_FUNCTION_ARGS) { #ifdef USE_LIBXML int ret = -1; xmlValidCtxtPtr validctxt = NULL; xmlDtdPtr dtd = NULL; bool result = false; text *data = NULL; char *dtdstr = NULL; xmltype *xmldata = NULL; char *xmldataint = NULL; xmlChar *xmldatastr = NULL; int lenxml = -1; // length of xml data xmlDocPtr doc = NULL; // creating xmlChar * from internal xmltype of stored XML xmldata = PG_GETARG_XML_P(0); xmldataint = VARDATA(xmldata); lenxml = VARSIZE(xmldata) - VARHDRSZ; xmldatastr = (xmlChar *) palloc((lenxml + 1) * sizeof(xmlChar)); memcpy(xmldatastr, xmldataint, lenxml); xmldatastr[lenxml] = '\0'; // creating xmlChar* from text representation of DTD data = PG_GETARG_TEXT_P(1); dtdstr = text_to_cstring(data); //initialize LibXML structures, if allready done -> do nothing pg_xml_init(); xmlInitParser(); doc = xmlReadMemory((const char *)xmldatastr, lenxml, "include.xml", NULL, 0); if (doc == NULL) { elog(ERROR, "Failed to parse XML document"); PG_RETURN_BOOL (false); } // create DTD from memory, must use XML_CHAR_ENCODING_NONE dtd = xmlIOParseDTD(NULL, xmlParserInputBufferCreateMem(dtdstr, strlen(dtdstr), XML_CHAR_ENCODING_NONE), XML_CHAR_ENCODING_NONE); if (dtd == NULL) { // unable to create parser context elog(ERROR, "Error with creating DTD schema, check if schema is valid"); PG_RETURN_BOOL (false); } validctxt = xmlNewValidCtxt(); if (validctxt == NULL) { // cant create validation context elog(INFO ,"cant create validation context"); xmlFreeDtd(dtd); PG_RETURN_BOOL (false); } ret = xmlValidateDtd(validctxt, doc, dtd); if (ret == 0) { elog(INFO, "Validates"); result = true; } else if (ret > 0) { elog(INFO, "Dont validates"); result = false; } else { elog(INFO, "Validation generated an internal error"); result = false; } xmlFreeDtd(dtd); xmlFreeValidCtxt(validctxt); xmlFreeDoc(doc); // clean up document in memmory xmlCleanupParser(); // clean up stream parser PG_RETURN_BOOL (result); #else NO_XML_SUPPORT(); PG_RETURN_BOOL (false); #endif }