/** * HTML整形 */ const wxString ExtractBoardList::HtmlFormat(const wxString& html) { /** ### XML入出力のためのバッファを作成する ### xmlOutputBufferPtr xmlOutputBufferCreateIO (xmlOutputWriteCallback iowrite, xmlOutputCloseCallback ioclose, void * ioctx, xmlCharEncodingHandlerPtr encoder) */ htmlDocPtr docPtr = htmlReadMemory(html.mb_str(), html.Len(), "", "utf-8", HTML_PARSE_RECOVER); if (docPtr) { // libxml2の***Ptrは何かの構造体のポインタ wxString val; xmlOutputBufferPtr buf = xmlOutputBufferCreateIO((xmlOutputWriteCallback)writeToWxString, (xmlOutputCloseCallback)closeWxString, &val, 0); htmlDocContentDumpOutput(buf, docPtr, "utf-8"); return val; } }
XmlWriter::XmlWriter(std::ostream &os) : os_(os), xmlWriter_(xmlNewTextWriter(xmlOutputBufferCreateIO(xmlOutputWriteCallback, 0, &os_, 0))) { if (!xmlWriter_) { BOOST_THROW_EXCEPTION(XmlWriterException("xmlNewTextWriter failed")); } int written = xmlTextWriterStartDocument(xmlWriter_, 0, 0, 0); if (-1 == written) { BOOST_THROW_EXCEPTION(XmlWriterException(std::string("xmlTextWriterStartDocument returned -1"))); } if (-1 == xmlTextWriterSetIndent(xmlWriter_, 1)) { BOOST_THROW_EXCEPTION(XmlWriterException(std::string("xmlTextWriterSetIndent returned -1"))); } if (-1 == xmlTextWriterSetIndentString(xmlWriter_, BAD_CAST " ")) { BOOST_THROW_EXCEPTION(XmlWriterException(std::string("xmlTextWriterSetIndentString returned -1"))); } }
bool XMLConversion::SetupWriter() { //Set up XML writer if one does not already exist if(_writer) return true; _buf = xmlOutputBufferCreateIO ( WriteStream, //xmlOutputWriteCallback NULL, //xmlOutputCloseCallback this, //context NULL); //xmlCharEncodingHandlerPtr _writer = xmlNewTextWriter(_buf); if(!_buf || !_writer) { cerr << "Error setting up xml writer\n" << endl; return false; } int ret; if(IsOption("c")) ret = xmlTextWriterSetIndent(_writer,0); else { ret = xmlTextWriterSetIndent(_writer,1); ret = xmlTextWriterSetIndentString(_writer, BAD_CAST " "); } return ret==0; }
void DFSerializeXMLBuffer(DFDocument *doc, NamespaceID defaultNS, int indent, DFBuffer *buf) { xmlOutputBufferPtr output = xmlOutputBufferCreateIO(StringBufferWrite, StringBufferClose, buf, NULL); xmlTextWriterPtr writer = xmlNewTextWriter(output); int html = 0; for (DFNode *child = doc->docNode->first; child != NULL; child = child->next) { if (child->tag == HTML_HTML) html = 1; } Serialization serialization; bzero(&serialization,sizeof(serialization)); serialization.ic = iconv_open("UTF-8","UTF-16LE"); if (serialization.ic == ((iconv_t)-1)) { fprintf(stderr,"FATAL: Can't open iconv descriptor\n"); abort(); } serialization.writer = writer; serialization.doc = doc; serialization.defaultNS = defaultNS; serialization.html = html; serialization.indent = indent; writeNode(&serialization,doc->docNode,0); iconv_close(serialization.ic); xmlFreeTextWriter(writer); }
void XMLNode::GetXML(std::string& out_xml_str, bool user_friendly) const { out_xml_str.resize(0); if (!node_) return; if (node_->type != XML_ELEMENT_NODE) return; xmlDocPtr doc = node_->doc; if (doc == NULL) return; // Printing non-root node omits namespaces defined at higher level. // So we need to create temporary namespace definitions and place them // at node being printed std::map<xmlNsPtr,xmlNsPtr> extns; CollectExternalNamespaces(node_, extns); // It is easier to insert namespaces into final text. Hence // allocating place for them. std::string ns_str; NamespacesToString(extns, ns_str); out_xml_str.append(ns_str.length(),' '); /* xmlBufferPtr buf = xmlBufferCreate(); xmlNodeDump(buf, doc, node_, 0, user_friendly ? 1 : 0); out_xml_str = (char*)(buf->content); xmlBufferFree(buf); */ xmlOutputBufferPtr buf = xmlOutputBufferCreateIO(&write_to_string,&close_string,&out_xml_str,NULL); if(buf == NULL) return; xmlNodeDumpOutput(buf, doc, node_, 0, user_friendly ? 1 : 0, (const char*)(doc->encoding)); xmlOutputBufferClose(buf); // Insert external namespaces into final string using allocated space InsertExternalNamespaces(out_xml_str, ns_str); }
void XMLNode::GetDoc(std::string& out_xml_str, bool user_friendly) const { out_xml_str.resize(0); if (!node_) return; xmlDocPtr doc = node_->doc; if (doc == NULL) return; xmlOutputBufferPtr buf = xmlOutputBufferCreateIO(&write_to_string,&close_string,&out_xml_str,NULL); if(buf == NULL) return; /* xmlChar *buf = NULL; int bufsize = 0; if (user_friendly) xmlDocDumpFormatMemory(doc, &buf, &bufsize, 1); else xmlDocDumpMemory(doc, &buf, &bufsize); if (buf) { out_xml_str = (char*)buf; xmlFree(buf); } */ // Note xmlSaveFormatFileTo/xmlSaveFileTo call xmlOutputBufferClose if (user_friendly) xmlSaveFormatFileTo(buf, doc, (const char*)(doc->encoding), 1); else xmlSaveFileTo(buf, doc, (const char*)(doc->encoding)); }
char * noit_xmlSaveToBuffer(xmlDocPtr doc) { xmlOutputBufferPtr out; xmlCharEncodingHandlerPtr enc; struct noit_xml_buffer_ptr buf = { NULL,0,0,0 }; enc = xmlGetCharEncodingHandler(XML_CHAR_ENCODING_UTF8); out = xmlOutputBufferCreateIO(noit_xml_save_writer, noit_xml_save_closer, &buf, enc); assert(out); xmlSaveFormatFileTo(out, doc, "utf8", 1); return buf.buff; }
bool c_XMLWriter::t_openuri(const String& uri) { Variant file = File::Open(uri, "wb"); if (same(file, false)) { return false; } m_uri = file.toResource().getTyped<File>(); m_uri_output = xmlOutputBufferCreateIO(write_file, close_file, this, NULL); if (m_uri_output == NULL) { raise_warning("Unable to create output buffer"); return false; } m_ptr = xmlNewTextWriter(m_uri_output); return true; }
void XMLStream::toStream( xmlDocPtr doc, std::ostream &os ) { void *IOContexte = &os; const char *encoding="UTF-8"; int formatWithSpace=1; xmlCharEncodingHandlerPtr handler = xmlFindCharEncodingHandler(encoding); //xmlCharEncodingHandlerPtr handler = xmlGetCharEncodingHandler(XML_CHAR_ENCODING_UTF8); doesnt work :/ SLM_ASSERT("handler not instanced", handler); //xmlThrDefIndentTreeOutput(4); xmlOutputBufferPtr outBuff = xmlOutputBufferCreateIO( streamIOWrite , streamIOClose, IOContexte, handler); xmlSaveFormatFileTo( outBuff, doc, encoding, formatWithSpace ); }
static inline int setupCopyToStringWriter(MwsHarvest_SaxUserData* data) { xmlOutputBuffer* outPtr; data->buffer.clear(); if ((outPtr = xmlOutputBufferCreateIO(copyToCharBufCallback, nullptr, &data->buffer, nullptr)) == nullptr) { PRINT_WARN("Error while creating the OutputBuffer\n"); return -1; } else if ((data->stringWriter = xmlNewTextWriter(outPtr)) == nullptr) { PRINT_WARN("Error while creating the XML Writer\n"); return -1; } return 0; }
bool c_XMLWriter::t_openuri(const String& uri) { m_uri = File::Open(uri, "wb"); if (m_uri.isNull()) { return false; } xmlOutputBufferPtr uri_output = xmlOutputBufferCreateIO( write_file, close_file, this, nullptr); if (uri_output == nullptr) { raise_warning("Unable to create output buffer"); return false; } m_ptr = xmlNewTextWriter(uri_output); return true; }
bool c_XMLWriter::t_openuri(CStrRef uri) { INSTANCE_METHOD_INJECTION_BUILTIN(XMLWriter, XMLWriter::openuri); Variant file = File::Open(uri, "wb"); if (same(file, false)) { return false; } m_uri = file.toObject().getTyped<File>(); m_uri_output = xmlOutputBufferCreateIO(write_file, close_file, this, NULL); if (m_uri_output == NULL) { raise_warning("Unable to create output buffer"); return false; } m_ptr = xmlNewTextWriter(m_uri_output); return true; }
std::string NSXmlCanonicalizator::Execute(const std::string& sXml, int mode, bool withComments) { xmlDocPtr xmlDoc = xmlParseMemory((char*)sXml.c_str(), (int)sXml.length()); CXmlBuffer bufferC14N; xmlOutputBufferPtr _buffer = xmlOutputBufferCreateIO((xmlOutputWriteCallback)buffer_xmlBufferIOWrite, (xmlOutputCloseCallback)buffer_xmlBufferIOClose, &bufferC14N, NULL); xmlC14NExecute(xmlDoc, buffer_xmlC14NIsVisibleCallback, NULL, mode, NULL, withComments ? 1 : 0, _buffer); xmlOutputBufferClose(_buffer); return bufferC14N.builder.GetData(); }
OutputBuffer::OutputBuffer(const std::string & encoding) { xmlCharEncodingHandlerPtr encoder = nullptr; if ( !encoding.empty() ) { xmlCharEncoding enc = xmlParseCharEncoding(encoding.c_str()); if ( enc != XML_CHAR_ENCODING_UTF8 ) { encoder = xmlFindCharEncodingHandler(encoding.c_str()); if ( encoder == nullptr ) throw InternalError("Unsupported output encoding: " + encoding); } } _buf = xmlOutputBufferCreateIO(OutputBuffer::write_cb, OutputBuffer::close_cb, this, encoder); if ( _buf == nullptr ) throw InternalError("Failed to create xml output buffer"); }
// create a new XML writer using writer callback functions xml_writer::xml_writer(boost::shared_ptr<output_buffer> &out, bool indent) : pimpl(new pimpl_()) { xmlOutputBufferPtr output_buffer = xmlOutputBufferCreateIO(wrap_write, wrap_close, out.get(), NULL); // allocate a writer using the output buffer object pimpl->writer = xmlNewTextWriter(output_buffer); // check the return value if (pimpl->writer == NULL) { // free the output buffer free(output_buffer); throw std::runtime_error("error creating xml writer."); } init(indent); }
void COXml::flush () { if (_Document) { // Generate indentation xmlKeepBlanksDefault (0); // Create a output context xmlOutputBufferPtr outputBuffer = xmlOutputBufferCreateIO ( xmlOutputWriteCallbackForNeL, xmlOutputCloseCallbackForNeL, this, NULL ); // Save the file int res = xmlSaveFormatFileTo (outputBuffer, _Document, NULL, 1); // No error should be returned because, exception should be raised by the internal stream nlassert (res!=-1); // Free the document xmlFreeDoc (_Document); _Document = NULL; } }
int xslt_SaveResultToBuf (refbuf_t **bptr, int *len, xmlDocPtr result, xsltStylesheetPtr style) { xmlOutputBufferPtr buf; struct bufs x; if (result->children == NULL) { *bptr = NULL; *len = 0; return 0; } memset (&x, 0, sizeof (x)); x.tail = &x.head; buf = xmlOutputBufferCreateIO (xslt_write_callback, NULL, &x, NULL); if (buf == NULL) return -1; xsltSaveResultTo (buf, result, style); *bptr = x.head; *len = x.len; xmlOutputBufferClose(buf); return 0; }
void XMLNode::GetXML(std::string& out_xml_str, const std::string& encoding, bool user_friendly) const { out_xml_str.resize(0); if (!node_) return; if (node_->type != XML_ELEMENT_NODE) return; xmlDocPtr doc = node_->doc; if (doc == NULL) return; xmlCharEncodingHandlerPtr handler = NULL; handler = xmlFindCharEncodingHandler(encoding.c_str()); if (handler == NULL) return; std::map<xmlNsPtr,xmlNsPtr> extns; CollectExternalNamespaces(node_, extns); std::string ns_str; NamespacesToString(extns, ns_str); out_xml_str.append(ns_str.length(),' '); //xmlOutputBufferPtr buf = xmlAllocOutputBuffer(handler); xmlOutputBufferPtr buf = xmlOutputBufferCreateIO(&write_to_string,&close_string,&out_xml_str,NULL); if(buf == NULL) return; xmlNodeDumpOutput(buf, doc, node_, 0, user_friendly ? 1 : 0, encoding.c_str()); xmlOutputBufferFlush(buf); //out_xml_str = (char*)(buf->conv ? buf->conv->content : buf->buffer->content); xmlOutputBufferClose(buf); InsertExternalNamespaces(out_xml_str, ns_str); }
bool XmlWriter::Create(IOStream *output, XmlWriter **r) { if (!LibXmlInitialized) { Error(StringPieceFromLiteral("XmlWriter::Create(): call LibXmlInit first()")); return false; } if (!output) return false; xmlOutputBufferPtr output_buffer = xmlOutputBufferCreateIO(_writeCallback, _closeCallback, output, NULL); if (!output_buffer) { Error(StringPieceFromLiteral("XmlWriter::Create(): xmlOutputBufferCreateIO fails")); return false; } std::auto_ptr<XmlWriter> xml(new XmlWriter()); xml->libxml_stuff.reset(new LibXmlStuff()); /* NOTE: the xmlOutputBufferPtr parameter will be deallocated when the writer is closed (if the call succeed.) */ xml->libxml_stuff->writer = xmlNewTextWriter(output_buffer); if (!xml->libxml_stuff->writer) { xmlOutputBufferClose(output_buffer); output_buffer = NULL; Error(StringPieceFromLiteral("XmlWriter::Create(): xmlNewTextWriter fails")); return false; } if (r) { xmlTextWriterSetIndent(xml->libxml_stuff->writer, 1); /*if (!xml->StartDocument(output)) { cpcl::Error(cpcl::StringPieceFromLiteral("XmlWriter::Create(): xmlTextWriterStartDocument fails")); return false; }*/ *r = xml.release(); } return true; }
/** * HTML整形 */ const wxString ExtractBoardList::HtmlFormat(const wxString& html) { wxString val; const wxCharBuffer& cb = html.utf8_str(); htmlDocPtr docPtr = htmlReadMemory(cb.data(), ::strlen(cb.data()), "", "utf-8", HTML_PARSE_RECOVER); if (docPtr) { // libxml2の***Ptrは何かの構造体のポインタ xmlOutputBufferPtr buf = xmlOutputBufferCreateIO((xmlOutputWriteCallback)writeToWxString, (xmlOutputCloseCallback)closeWxString, &val, 0); htmlDocContentDumpOutput(buf, docPtr, "utf-8"); xmlOutputBufferClose(buf); xmlFreeDoc(docPtr); } xmlCleanupParser(); return val; }
void DFSerializeXMLBuffer(DFDocument *doc, NamespaceID defaultNS, int indent, DFBuffer *buf) { xmlOutputBufferPtr output = xmlOutputBufferCreateIO(StringBufferWrite, StringBufferClose, buf, NULL); xmlTextWriterPtr writer = xmlNewTextWriter(output); int html = 0; for (DFNode *child = doc->docNode->first; child != NULL; child = child->next) { if (child->tag == HTML_HTML) html = 1; } Serialization serialization; bzero(&serialization,sizeof(serialization)); serialization.writer = writer; serialization.doc = doc; serialization.defaultNS = defaultNS; serialization.html = html; serialization.indent = indent; writeNode(&serialization,doc->docNode,0); xmlFreeTextWriter(writer); }
void Server::sendResponse(Context *ctx, XmlDocSharedHelper doc) { sendHeaders(ctx); if (ctx->response()->suppressBody(ctx->request())) { return; } xmlCharEncodingHandlerPtr encoder = NULL; const std::string &encoding = ctx->documentWriter()->outputEncoding(); if (!encoding.empty() && 0 != strncasecmp(encoding.c_str(), "utf-8", sizeof("utf-8"))) { encoder = xmlFindCharEncodingHandler(encoding.c_str()); } xmlOutputBufferPtr buf = xmlOutputBufferCreateIO(writeFunc, closeFunc, ctx, encoder); XmlUtils::throwUnless(NULL != buf); try { ctx->documentWriter()->write(ctx->response(), doc.get(), buf); } catch(const std::exception &e) { xmlOutputBufferClose(buf); throw e; } }
int writeXmlAnswsetToFd(MwsAnswset* answset, int fd) { #ifdef TRACE_FUNC_CALLS LOG_TRACE_IN; #endif xmlOutputBuffer* outPtr; xmlTextWriter* writerPtr; size_t qvarNr; int ret; unsigned int i; vector<MwsAnsw*>::iterator it; // Initializing values outPtr = NULL; writerPtr = NULL; ret = -1; qvarNr = answset->qvarNames.size(); if (answset == NULL) { fprintf(stderr, "NULL answset passed to writeXmlAnswsetToFd"); } // Creating the xmlOutputBuffer else if ((outPtr = xmlOutputBufferCreateIO(fdXmlOutputWriteCallback, NULL, &fd, NULL)) == NULL) { fprintf(stderr, "Error while creating the OutputBuffer\n"); } // Creating the xmlTextWriter else if ((writerPtr = xmlNewTextWriter(outPtr)) == NULL) { fprintf(stderr, "Error while creating the TextWriter\n"); } else if ((ret = xmlTextWriterStartDocument(writerPtr, // xmlTextWriter NULL, // XML version ("1.0") NULL, // Encoding ("UTF-8") NULL)) // Standalone ("yes") == -1) { fprintf(stderr, "Error at xmlTextWriterStartDocument\n"); } // MWS timestamp comment else if ((ret = xmlTextWriterWriteComment(writerPtr, BAD_CAST "MwsAnswset generated by " __MWSTIMESTAMP__ " ")) == -1) { fprintf(stderr, "Error at xmlTextWriterStartDocument\n"); } // MWS answset else if ((ret = xmlTextWriterStartElement(writerPtr, BAD_CAST MWSANSWSET_MAIN_NAME)) == -1) { fprintf(stderr, "Error at xmlTextWriterStartElement\n"); } // mws namespace else if ((ret = xmlTextWriterWriteAttribute(writerPtr, BAD_CAST "xmlns:mws", BAD_CAST "http://www.mathweb.org/mws/ns")) == -1) { fprintf(stderr, "Error at xmlTextWriterWriteAttribute\n"); } // attribute size else if ((ret = xmlTextWriterWriteAttribute(writerPtr, BAD_CAST "size", BAD_CAST ToString(answset->answers.size()).c_str())) == -1) { fprintf(stderr, "Error at xmlTextWriterWriteAttribute\n"); } // attribute total else if ((ret = xmlTextWriterWriteAttribute(writerPtr, BAD_CAST "total", BAD_CAST ToString(answset->total).c_str())) == -1) { fprintf(stderr, "Error at xmlTextWriterWriteAttribute\n"); } else // Writing the answers { for (it = answset->answers.begin(); it != answset->answers.end(); it++) { if ((ret = xmlTextWriterStartElement(writerPtr, BAD_CAST MWSANSWSET_ANSW_NAME)) == -1) { fprintf(stderr, "Error at xmlTextWriterStartElement\n"); break; } else if ((ret = xmlTextWriterWriteAttribute(writerPtr, BAD_CAST MWSANSWSET_URI_NAME, BAD_CAST (*it)->uri.c_str())) == -1) { fprintf(stderr, "Error at xmlTextWriterWriteAttribute\n"); break; } else if ((ret = xmlTextWriterWriteAttribute(writerPtr, BAD_CAST MWSANSWSET_XPATH_NAME, BAD_CAST (*it)->xpath.c_str())) == -1) { fprintf(stderr, "Error at xmlTextWriterWriteAttribute\n"); break; } else { // Writing the substitutions for (i = 0; i < qvarNr; i++) { if ((ret = xmlTextWriterStartElement(writerPtr, BAD_CAST MWSANSWSET_SUBSTPAIR_NAME)) == -1) { fprintf(stderr, "Error at xmlTextWriterStartElement\n"); break; } else if ((ret = xmlTextWriterWriteAttribute(writerPtr, BAD_CAST "qvar", BAD_CAST answset->qvarNames[i].c_str())) == -1) { fprintf(stderr, "Error at xmlTextWriterWriteAttribute\n"); break; } else if ((ret = xmlTextWriterWriteAttribute(writerPtr, BAD_CAST "xpath", BAD_CAST (*it)->subst.qvarXpaths[i].c_str())) == -1) { fprintf(stderr, "Error at xmlTextWriterWriteAttribute\n"); break; } else if ((ret = xmlTextWriterEndElement(writerPtr)) == -1) { fprintf(stderr, "Error at xmlTextWriterEndElement\n"); break; } } } if (ret == -1) { fprintf(stderr, "Error while writing xml substpairs\n"); break; } else if ((ret = xmlTextWriterEndElement(writerPtr)) == -1) { fprintf(stderr, "Error at xmlTextWriterEndElement\n"); break; } } } if (ret == -1) { fprintf(stderr, "Error while writing xml answers\n"); } else if ((ret = xmlTextWriterEndElement(writerPtr)) == -1) { fprintf(stderr, "Error at xmlTextWriterEndElement\n"); } // Closing the document else if ((ret = xmlTextWriterEndDocument(writerPtr)) == -1) { fprintf(stderr, "Error at xmlTextWriterEndDocument\n"); } // Flushing the buffer else if ((ret = xmlTextWriterFlush(writerPtr)) == -1) { fprintf(stderr, "Error at xmlTextWriterFlush\n"); } // Everything ok else { ret = 0; } // Cleaning data if (writerPtr) { // This also cleans the outPtr xmlFreeTextWriter(writerPtr); } else if (outPtr) { xmlOutputBufferClose(outPtr); } #ifdef TRACE_FUNC_CALLS LOG_TRACE_OUT; #endif return ret; }
int MwsXmlResponseFormatter::writeData(const GenericAnswer* ans, FILE* output) const { const MwsAnswset& answerSet = *((const MwsAnswset*)ans); xmlOutputBuffer* outPtr; xmlTextWriter* writerPtr; size_t qvarNr; int ret; unsigned int i; LocalContext ctxt; // Initializing values outPtr = nullptr; writerPtr = nullptr; ret = -1; qvarNr = answerSet.qvarNames.size(); ctxt.file = output; ctxt.total_bytes_written = 0; if ((outPtr = xmlOutputBufferCreateIO(fileXmlOutputWriteCallback, nullptr, &ctxt, nullptr)) == nullptr) { PRINT_WARN("Error while creating the OutputBuffer\n"); } else if ((writerPtr = xmlNewTextWriter(outPtr)) == nullptr) { PRINT_WARN("Error while creating the TextWriter\n"); } else if ((ret = xmlTextWriterStartDocument(writerPtr, // xmlTextWriter nullptr, // XML version ("1.0") nullptr, // Encoding ("UTF-8") nullptr)) // Standalone ("yes") == -1) { PRINT_WARN("Error at xmlTextWriterStartDocument\n"); } else if ((ret = xmlTextWriterWriteComment( writerPtr, BAD_CAST "MwsAnswset generated by " MWS_BUILD)) == -1) { PRINT_WARN("Error at xmlTextWriterStartDocument\n"); } else if ((ret = xmlTextWriterStartElement( writerPtr, BAD_CAST MWSANSWSET_MAIN_NAME)) == -1) { PRINT_WARN("Error at xmlTextWriterStartElement\n"); } else if ((ret = xmlTextWriterWriteAttribute( writerPtr, BAD_CAST "xmlns:mws", BAD_CAST "http://www.mathweb.org/mws/ns")) == -1) { PRINT_WARN("Error at xmlTextWriterWriteAttribute\n"); } else if ((ret = xmlTextWriterWriteAttribute( writerPtr, BAD_CAST "size", BAD_CAST std::to_string(answerSet.answers.size()) .c_str())) == -1) { PRINT_WARN("Error at xmlTextWriterWriteAttribute\n"); } else if ((ret = xmlTextWriterWriteAttribute( writerPtr, BAD_CAST "total", BAD_CAST std::to_string(answerSet.total).c_str())) == -1) { PRINT_WARN("Error at xmlTextWriterWriteAttribute\n"); } else { for (auto& answer : answerSet.answers) { if ((ret = xmlTextWriterStartElement( writerPtr, BAD_CAST MWSANSWSET_ANSW_NAME)) == -1) { PRINT_WARN("Error at xmlTextWriterStartElement\n"); break; } else if ((ret = xmlTextWriterWriteAttribute( writerPtr, BAD_CAST MWSANSWSET_URI_NAME, BAD_CAST answer->uri.c_str())) == -1) { PRINT_WARN("Error at xmlTextWriterWriteAttribute\n"); break; } else if ((ret = xmlTextWriterWriteAttribute( writerPtr, BAD_CAST MWSANSWSET_XPATH_NAME, BAD_CAST answer->xpath.c_str())) == -1) { PRINT_WARN("Error at xmlTextWriterWriteAttribute\n"); break; } else { // Writing the substitutions for (i = 0; i < qvarNr; i++) { string qvarXpath = answer->xpath + answerSet.qvarXpaths[i]; if ((ret = xmlTextWriterStartElement( writerPtr, BAD_CAST MWSANSWSET_SUBSTPAIR_NAME)) == -1) { PRINT_WARN("Error at xmlTextWriterStartElement\n"); break; } else if ((ret = xmlTextWriterWriteAttribute( writerPtr, BAD_CAST "qvar", BAD_CAST answerSet.qvarNames[i].c_str())) == -1) { PRINT_WARN("Error at xmlTextWriterWriteAttribute\n"); break; } else if ((ret = xmlTextWriterWriteAttribute( writerPtr, BAD_CAST "xpath", BAD_CAST qvarXpath.c_str())) == -1) { PRINT_WARN("Error at xmlTextWriterWriteAttribute\n"); break; } else if ((ret = xmlTextWriterEndElement(writerPtr)) == -1) { PRINT_WARN("Error at xmlTextWriterEndElement\n"); break; } } // <data> ... </data> xmlTextWriterWriteElement(writerPtr, BAD_CAST "data", BAD_CAST answer->data.c_str()); } if (ret == -1) { PRINT_WARN("Error while writing xml substpairs\n"); break; } else if ((ret = xmlTextWriterEndElement(writerPtr)) == -1) { PRINT_WARN("Error at xmlTextWriterEndElement\n"); break; } } } if (ret == -1) { PRINT_WARN("Error while writing xml answers\n"); } else if ((ret = xmlTextWriterEndElement(writerPtr)) == -1) { PRINT_WARN("Error at xmlTextWriterEndElement\n"); } else if ((ret = xmlTextWriterEndDocument(writerPtr)) == -1) { PRINT_WARN("Error at xmlTextWriterEndDocument\n"); } else if ((ret = xmlTextWriterFlush(writerPtr)) == -1) { PRINT_WARN("Error at xmlTextWriterFlush\n"); } else { ret = 0; } // Cleaning data if (writerPtr) { // This also cleans the outPtr xmlFreeTextWriter(writerPtr); } else if (outPtr) { xmlOutputBufferClose(outPtr); } if (ret == 0) { return ctxt.total_bytes_written; } else { return ret; } }
XMLPhysfsWriter(WriteFile* newfile) : file(newfile) { buffer = xmlOutputBufferCreateIO(write, close, file, 0); }
static void Save(const SObject *object, const char *path, s_erc *error) { int rc; SUtterance *utt = S_UTTERANCE(object); SDatasource *ds; xmlTextWriterPtr writer; xmlOutputBufferPtr out; const char * xsi = "http://www.w3.org/2001/XMLSchema-instance"; S_CLR_ERR(error); ds = SFilesourceOpenFile(path, "wt", error); if (S_CHK_ERR(error, S_CONTERR, "Save", "Call to \"SFilesourceOpenFile\" failed")) return; out = xmlOutputBufferCreateIO(_ds_write, _ds_close, ds, NULL); if (out == NULL) { S_CTX_ERR(error, S_CONTERR, "Save", "Call to \"xmlOutputBufferCreateIO\" failed"); return; } writer = xmlNewTextWriter(out); if (writer == NULL) { xmlOutputBufferClose(out); S_CTX_ERR(error, S_CONTERR, "Save", "Call to \"xmlNewTextWriter\" failed"); return; } /* Start Document */ rc = xmlTextWriterStartDocument(writer, NULL, ENCODING, NULL); if (rc < 0) { S_CTX_ERR(error, S_CONTERR, "Save", "Call to \"xmlTextWriterStartDocument\" failed"); goto s_write_utt_exit; } /* Write the maryxml namespace */ rc = xmlTextWriterStartElement(writer, BAD_CAST "xml"); if (rc < 0) { S_CTX_ERR(error, S_CONTERR, "Save", "Call to \"xmlTextWriterStartElement\" failed"); goto s_write_utt_exit; } rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "xmlns:xsi", BAD_CAST xsi); if (rc < 0) { S_CTX_ERR(error, S_CONTERR, "Save", "Call to \"xmlTextWriterWriteAttribute\" failed"); goto s_write_utt_exit; } rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "version", BAD_CAST "0.5"); if (rc < 0) { S_CTX_ERR(error, S_CONTERR, "Save", "Call to \"xmlTextWriterWriteAttribute\" failed"); goto s_write_utt_exit; } // print labels /* get to the first syllable of the current word */ const SItem* itrSegments = SRelationHead(SUtteranceGetRelation(utt, "Segment", error), error); if (S_CHK_ERR(error, S_CONTERR, "Save", "Call to \"SItemPathToItem\" failed")) goto s_write_utt_exit; while (itrSegments != NULL) { /* get segment content */ const char* label = SItemGetString(itrSegments, "hts_label", error); if (S_CHK_ERR(error, S_CONTERR, "Save", "Call to \"SItemGetName\" failed")) goto s_write_utt_exit; /* get next segment */ itrSegments = SItemNext(itrSegments, error); if (S_CHK_ERR(error, S_CONTERR, "Save", "Call to \"SItemNext\" failed")) goto s_write_utt_exit; xmlTextWriterWriteElement(writer, BAD_CAST "label", BAD_CAST label); } /* Close the tag xml */ rc = xmlTextWriterEndElement(writer); if (rc < 0) { S_CTX_ERR(error, S_CONTERR, "Save", "Call to \"xmlTextWriterEndDocument\" failed"); goto s_write_utt_exit; } /* Close the document */ rc = xmlTextWriterEndDocument(writer); if (rc < 0) { S_CTX_ERR(error, S_CONTERR, "Save", "Call to \"xmlTextWriterEndDocument\" failed"); goto s_write_utt_exit; } s_write_utt_exit: xmlFreeTextWriter(writer); }
QString transform(const QString &pat, const QString &tss, const QVector<const char *> ¶ms) { QString parsed; INFO(i18n("Parsing stylesheet")); #if defined (SIMPLE_XSLT) && defined(Q_OS_WIN) // prepare use of local available dtd versions instead of fetching every time from the internet // this approach is url based if (!defaultEntityLoader) { defaultEntityLoader = xmlGetExternalEntityLoader(); xmlSetExternalEntityLoader(xsltprocExternalEntityLoader); replaceURLList[QLatin1String("http://www.oasis-open.org/docbook/xml/4.5")] = QString("file:///%1").arg(DOCBOOK_XML_CURRDTD); } #endif xsltStylesheetPtr style_sheet = xsltParseStylesheetFile((const xmlChar *)QFile::encodeName(tss).constData()); if (!style_sheet) { return parsed; } if (style_sheet->indent == 1) { xmlIndentTreeOutput = 1; } else { xmlIndentTreeOutput = 0; } INFO(i18n("Parsing document")); xmlParserCtxtPtr pctxt; pctxt = xmlNewParserCtxt(); if ( pctxt == NULL ) { return parsed; } xmlDocPtr doc = xmlCtxtReadFile(pctxt, QFile::encodeName(pat).constData(), NULL, XML_PARSE_NOENT|XML_PARSE_DTDLOAD|XML_PARSE_NONET); /* Clean the context pointer, now useless */ const bool context_valid = (pctxt->valid == 0); xmlFreeParserCtxt(pctxt); /* Check both the returned doc (for parsing errors) and the context (for validation errors) */ if (doc == NULL) { return parsed; } else { if (context_valid) { xmlFreeDoc(doc); return parsed; } } INFO(i18n("Applying stylesheet")); QVector<const char *> p = params; p.append(NULL); xmlDocPtr res = xsltApplyStylesheet(style_sheet, doc, const_cast<const char **>(&p[0])); xmlFreeDoc(doc); if (res != NULL) { xmlOutputBufferPtr outp = xmlOutputBufferCreateIO(writeToQString, 0, &parsed, 0); outp->written = 0; INFO(i18n("Writing document")); xsltSaveResultTo(outp, res, style_sheet); xmlOutputBufferClose(outp); xmlFreeDoc(res); } xsltFreeStylesheet(style_sheet); if (parsed.isEmpty()) { parsed = QLatin1Char(' '); // avoid error message } return parsed; }
int main( int argc, const char* argv[] ) { #ifdef WIN32 _CrtSetDbgFlag (_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF); #endif int ret=-1; time_t start_time=time(NULL); FILE *file=NULL; const xmlChar *containerPath8=NULL; const xmlChar *partName8=NULL; xmlTextWriter *writer=NULL; int writer_indent=0; opc_bool_t reader_mce=OPC_TRUE; for(int i=1;i<argc;i++) { if ((0==xmlStrcmp(_X("--understands"), _X(argv[i])) || 0==xmlStrcmp(_X("-u"), _X(argv[i]))) && i+1<argc) { i++; // skip namespace, registered later when parser was created. } else if ((0==xmlStrcmp(_X("--out"), _X(argv[i])) || 0==xmlStrcmp(_X("--out"), _X(argv[i]))) && i+1<argc && NULL==file) { const char *filename=argv[++i]; file=fopen(filename, "w"); } else if (0==xmlStrcmp(_X("--indent"), _X(argv[i]))) { writer_indent=1; } else if (0==xmlStrcmp(_X("--raw"), _X(argv[i]))) { reader_mce=OPC_FALSE; } else if (NULL==containerPath8) { containerPath8=_X(argv[i]); } else if (NULL==partName8) { partName8=_X(argv[i]); } else { fprintf(stderr, "IGNORED: %s\n", argv[i]); } } if (NULL!=file) { xmlOutputBuffer *out=xmlOutputBufferCreateIO(xmlOutputWrite, xmlOutputClose, file, NULL); if (NULL!=out) { writer=xmlNewTextWriter(out); } } else { xmlOutputBuffer *out=xmlOutputBufferCreateIO(xmlOutputWrite, xmlOutputClose, stdout, NULL); if (NULL!=out) { writer=xmlNewTextWriter(out); } } if (NULL==containerPath8 || NULL==writer) { printf("mce_extract FILENAME.\n\n"); printf("Sample: mce_extract test.docx word/document.xml\n"); } else if (OPC_ERROR_NONE==opcInitLibrary()) { xmlTextWriterSetIndent(writer, writer_indent); opcContainer *c=NULL; if (NULL!=(c=opcContainerOpen(containerPath8, OPC_OPEN_READ_ONLY, NULL, NULL))) { if (NULL==partName8) { dumpPartsAsJSON(c, writer_indent); } else { opcPart part=OPC_PART_INVALID; if ((part=opcPartFind(c, partName8, NULL, 0))!=OPC_PART_INVALID) { mceTextReader_t reader; if (OPC_ERROR_NONE==opcXmlReaderOpen(c, &reader, part, NULL, NULL, 0)) { mceTextReaderDisableMCE(&reader, !reader_mce); for(int i=1;i<argc;i++) { if ((0==xmlStrcmp(_X("--understands"), _X(argv[i])) || 0==xmlStrcmp(_X("-u"), _X(argv[i]))) && i+1<argc) { const xmlChar *ns=_X(argv[++i]); mceTextReaderUnderstandsNamespace(&reader, ns); } } if (-1==mceTextReaderDump(&reader, writer, PTRUE)) { ret=mceTextReaderGetError(&reader); } else { ret=0; } mceTextReaderCleanup(&reader); } else { fprintf(stderr, "ERROR: part \"%s\" could not be opened for XML reading.\n", argv[2]); } } else { fprintf(stderr, "ERROR: part \"%s\" could not be opened in \"%s\".\n", argv[2], argv[1]); } } opcContainerClose(c, OPC_CLOSE_NOW); } else { fprintf(stderr, "ERROR: file \"%s\" could not be opened.\n", argv[1]); } opcFreeLibrary(); } else { fprintf(stderr, "ERROR: initialization of libopc failed.\n"); } if (NULL!=writer) xmlFreeTextWriter(writer); if (NULL!=file) fclose(file); time_t end_time=time(NULL); fprintf(stderr, "time %.2lfsec\n", difftime(end_time, start_time)); return ret; }