/**
* 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;
}
