/*
* call-seq:
* document.save(filename) -> int
* document.save(filename, :indent => true, :encoding => XML::Encoding::UTF_8) -> int
*
* Saves a document to a file. You may provide an optional hash table
* to control how the string is generated. Valid options are:
*
* :indent - Specifies if the string should be indented. The default value
* is true. Note that indentation is only added if both :indent is
* true and XML.indent_tree_output is true. If :indent is set to false,
* then both indentation and line feeds are removed from the result.
*
* :encoding - Specifies the output encoding of the string. It
* defaults to the original encoding of the document (see
* #encoding. To override the orginal encoding, use one of the
* XML::Encoding encoding constants. */
static VALUE rxml_document_save(int argc, VALUE *argv, VALUE self)
{
VALUE options = Qnil;
VALUE filename = Qnil;
xmlDocPtr xdoc;
int indent = 1;
const char *xfilename;
const char *xencoding;
int length;
rb_scan_args(argc, argv, "11", &filename, &options);
Check_Type(filename, T_STRING);
xfilename = StringValuePtr(filename);
Data_Get_Struct(self, xmlDoc, xdoc);
xencoding = xdoc->encoding;
if (!NIL_P(options))
{
VALUE rencoding, rindent;
Check_Type(options, T_HASH);
rencoding = rb_hash_aref(options, ID2SYM(rb_intern("encoding")));
rindent = rb_hash_aref(options, ID2SYM(rb_intern("indent")));
if (rindent == Qfalse)
indent = 0;
if (rencoding != Qnil)
{
xencoding = xmlGetCharEncodingName((xmlCharEncoding)NUM2INT(rencoding));
if (!xencoding)
rb_raise(rb_eArgError, "Unknown encoding value: %d", NUM2INT(rencoding));
}
}
length = xmlSaveFormatFileEnc(xfilename, xdoc, xencoding, indent);
if (length == -1)
rxml_raise(&xmlLastError);
return (INT2NUM(length));
}
/*
* call-seq:
* context.encoding = XML::Encoding::UTF_8
*
* Sets the character encoding for this context.
*/
static VALUE rxml_parser_context_encoding_set(VALUE self, VALUE encoding)
{
xmlParserCtxtPtr ctxt;
int result;
const char* xencoding = xmlGetCharEncodingName((xmlCharEncoding)NUM2INT(encoding));
xmlCharEncodingHandlerPtr hdlr = xmlFindCharEncodingHandler(xencoding);
if (!hdlr)
rb_raise(rb_eRuntimeError, "Unknown encoding: %s", encoding);
Data_Get_Struct(self, xmlParserCtxt, ctxt);
result = xmlSwitchToEncoding(ctxt, hdlr);
if (result != 0)
rxml_raise(&xmlLastError);
if (ctxt->encoding != NULL)
xmlFree((xmlChar *) ctxt->encoding);
ctxt->encoding = xmlStrdup((const xmlChar *) xencoding);
return self;
}
/* call-seq:
* XML::Reader.string(io) -> XML::Reader
* XML::Reader.string(io, :encoding => XML::Encoding::UTF_8,
* :options => XML::Parser::Options::NOENT) -> XML::Parser
*
* Creates a new reader by parsing the specified string.
*
* You may provide an optional hash table to control how the
* parsing is performed. Valid options are:
*
* base_uri - The base url for the parsed document.
* encoding - The document encoding, defaults to nil. Valid values
* are the encoding constants defined on XML::Encoding.
* options - Controls the execution of the parser, defaults to 0.
* Valid values are the constants defined on
* XML::Parser::Options. Mutliple options can be combined
* by using Bitwise OR (|).
*/
static VALUE rxml_reader_string(int argc, VALUE *argv, VALUE klass)
{
xmlTextReaderPtr xreader;
VALUE string;
VALUE options;
char *xbaseurl = NULL;
const char *xencoding = NULL;
int xoptions = 0;
rb_scan_args(argc, argv, "11", &string, &options);
Check_Type(string, T_STRING);
if (!NIL_P(options))
{
VALUE baseurl = Qnil;
VALUE encoding = Qnil;
VALUE parserOptions = Qnil;
Check_Type(options, T_HASH);
baseurl = rb_hash_aref(options, base_uri_SYMBOL);
xbaseurl = NIL_P(baseurl) ? NULL : StringValueCStr(baseurl);
encoding = rb_hash_aref(options, ENCODING_SYMBOL);
xencoding = NIL_P(encoding) ? NULL : xmlGetCharEncodingName(NUM2INT(encoding));
parserOptions = rb_hash_aref(options, OPTIONS_SYMBOL);
xoptions = NIL_P(parserOptions) ? 0 : NUM2INT(parserOptions);
}
xreader = xmlReaderForMemory(StringValueCStr(string), RSTRING_LEN(string),
xbaseurl, xencoding, xoptions);
if (xreader == NULL)
rxml_raise(&xmlLastError);
return rxml_reader_wrap(xreader);
}
/* call-seq:
* XML::Reader.io(io) -> XML::Reader
* XML::Reader.io(io, :encoding => XML::Encoding::UTF_8,
* :options => XML::Parser::Options::NOENT) -> XML::Parser
*
* Creates a new reader by parsing the specified io object.
*
* You may provide an optional hash table to control how the
* parsing is performed. Valid options are:
*
* base_uri - The base url for the parsed document.
* encoding - The document encoding, defaults to nil. Valid values
* are the encoding constants defined on XML::Encoding.
* options - Controls the execution of the parser, defaults to 0.
* Valid values are the constants defined on
* XML::Parser::Options. Mutliple options can be combined
* by using Bitwise OR (|).
*/
static VALUE rxml_reader_io(int argc, VALUE *argv, VALUE klass)
{
xmlTextReaderPtr xreader;
VALUE io;
VALUE options;
char *xbaseurl = NULL;
const char *xencoding = NULL;
int xoptions = 0;
rb_scan_args(argc, argv, "11", &io, &options);
if (!NIL_P(options))
{
VALUE baseurl = Qnil;
VALUE encoding = Qnil;
VALUE parserOptions = Qnil;
Check_Type(options, T_HASH);
baseurl = rb_hash_aref(options, base_uri_SYMBOL);
xbaseurl = NIL_P(baseurl) ? NULL : StringValueCStr(baseurl);
encoding = rb_hash_aref(options, ENCODING_SYMBOL);
xencoding = NIL_P(encoding) ? NULL : xmlGetCharEncodingName(NUM2INT(encoding));
parserOptions = rb_hash_aref(options, OPTIONS_SYMBOL);
xoptions = NIL_P(parserOptions) ? 0 : NUM2INT(parserOptions);
}
xreader = xmlReaderForIO((xmlInputReadCallback) rxml_read_callback, NULL,
(void *) io,
xbaseurl, xencoding, xoptions);
if (xreader == NULL)
rxml_raise(&xmlLastError);
return rxml_reader_wrap(xreader);
}
/*
* call-seq:
* document.to_s -> "string"
* document.to_s(:indent => true, :encoding => 'UTF-8') -> "string"
*
* Converts a document, and all of its children, to a string representation.
* You may provide an optional hash table to control how the string is
* generated. Valid options are:
*
* :indent - Specifies if the string should be indented. The default value
* is true. Note that indentation is only added if both :indent is
* true and XML.indent_tree_output is true. If :indent is set to false,
* then both indentation and line feeds are removed from the result.
*
* :encoding - Specifies the output encoding of the string. It
* defaults to XML::Encoding::UTF8. To change it, use one of the
* XML::Encoding encoding constants. */
static VALUE rxml_document_to_s(int argc, VALUE *argv, VALUE self)
{
VALUE result;
VALUE options = Qnil;
xmlDocPtr xdoc;
int indent = 1;
const char *xencoding = "UTF-8";
xmlChar *buffer;
int length;
rb_scan_args(argc, argv, "01", &options);
if (!NIL_P(options))
{
VALUE rencoding, rindent;
Check_Type(options, T_HASH);
rencoding = rb_hash_aref(options, ID2SYM(rb_intern("encoding")));
rindent = rb_hash_aref(options, ID2SYM(rb_intern("indent")));
if (rindent == Qfalse)
indent = 0;
if (rencoding != Qnil)
{
xencoding = xmlGetCharEncodingName((xmlCharEncoding)NUM2INT(rencoding));
if (!xencoding)
rb_raise(rb_eArgError, "Unknown encoding value: %d", NUM2INT(rencoding));
}
}
Data_Get_Struct(self, xmlDoc, xdoc);
xmlDocDumpFormatMemoryEnc(xdoc, &buffer, &length, xencoding, indent);
result = rb_str_new((const char*) buffer, length);
xmlFree(buffer);
return result;
}
int
freesasa_write_xml(FILE *output,
freesasa_node *root,
int options)
{
freesasa_node *child = NULL;
xmlDocPtr doc = NULL;
xmlNodePtr xml_root = NULL, xml_result_node = NULL;
xmlNsPtr ns = NULL;
xmlBufferPtr buf = NULL;
xmlTextWriterPtr writer = NULL;
int ret = FREESASA_FAIL;
assert(freesasa_node_type(root) == FREESASA_NODE_ROOT);
doc = xmlNewDoc(BAD_CAST "1.0");
if (doc == NULL) {
fail_msg("");
goto cleanup;
}
xml_root = xmlNewNode(NULL, BAD_CAST "results");
if (xml_root == NULL) {
fail_msg("");
goto cleanup;
}
ns = xmlNewNs(xml_root, BAD_CAST FREESASA_XMLNS, NULL);
if (ns == NULL) {
fail_msg("");
xmlFreeNode(xml_root);
goto cleanup;
}
xmlDocSetRootElement(doc, xml_root);
/* global attributes */
if (xmlNewProp(xml_root, BAD_CAST "source", BAD_CAST freesasa_string) == NULL) {
fail_msg("");
goto cleanup;
}
if (xmlNewProp(xml_root, BAD_CAST "lengthUnit", BAD_CAST "Ångström") == NULL) {
fail_msg("");
goto cleanup;
}
child = freesasa_node_children(root);
while (child) {
xml_result_node = xml_result(child, options);
if (xml_result_node == NULL) {
fail_msg("");
goto cleanup;
}
if (xmlAddChild(xml_root, xml_result_node) == NULL) {
fail_msg("");
xmlFreeNode(xml_result_node);
goto cleanup;
}
child = freesasa_node_next(child);
}
buf = xmlBufferCreate();
if (buf == NULL) {
fail_msg("");
goto cleanup;
}
writer = xmlNewTextWriterMemory(buf, 0);
if (writer == NULL) {
xmlBufferFree(buf);
fail_msg("");
goto cleanup;
}
if (xmlTextWriterStartDocument(writer, XML_DEFAULT_VERSION,
xmlGetCharEncodingName(XML_CHAR_ENCODING_UTF8), NULL)
== -1) {
fail_msg("");
goto cleanup;
}
if (xmlTextWriterFlush(writer) == -1) {
fail_msg("");
goto cleanup;
}
if (xmlNodeDump(buf, doc, xml_root, 0, 1) == 0) {
fail_msg("");
goto cleanup;
}
if (xmlTextWriterEndDocument(writer) == -1) {
fail_msg("");
goto cleanup;
}
fprintf(output, "%s", (const char*) buf->content);
fflush(output);
if (ferror(output)) {
fail_msg(strerror(errno));
goto cleanup;
}
ret = FREESASA_SUCCESS;
cleanup:
xmlFreeDoc(doc);
xmlFreeTextWriter(writer);
return ret;
}