int exportDatabase( const char * filename, struct database_t * databaseList, int * databaseListTotal, struct userAttr_t * userAttr ){
int subscript;
char longStr[100000];
char message[500];
xmlNodePtr node;
xmlNodePtr content;
xmlNodePtr sonNode;
xmlNodePtr grandsonNode;
// create the doc and root node
xmlDocPtr doc = xmlNewDoc( BAD_CAST "1.0" );
xmlNodePtr root_node = xmlNewNode( NULL, BAD_CAST "databaseList" );
xitoa( longStr, *databaseListTotal);
xmlNewProp( root_node, BAD_CAST "databaseListTotal", BAD_CAST longStr );
if ( userAttr->userStatus == NULL )
xmlNewProp( root_node, BAD_CAST "userStatus", BAD_CAST "disable" );
else xmlNewProp( root_node, BAD_CAST "userStatus", BAD_CAST userAttr->userStatus );
if ( userAttr->mobileNumber != NULL )
xmlNewProp( root_node, BAD_CAST "userStatus", BAD_CAST userAttr->mobileNumber );
// set the root node
xmlDocSetRootElement( doc, root_node );
// if ( *xmlItemListAlarmTotal > *xmlItemListTotal ) *xmlItemListAlarmTotal = *xmlItemListTotal;
for (subscript=1; subscript <= *databaseListTotal; subscript++){
node = xmlNewNode( NULL, BAD_CAST "item" );
xmlAddChild( root_node, node );
// xitoa( longStr, subscript );
// xmlNewProp( node, BAD_CAST "subscript", BAD_CAST longStr );
sonNode = xmlNewNode( NULL, BAD_CAST "url" );
content = xmlNewCDataBlock( NULL, BAD_CAST databaseList[subscript].url, strlen(databaseList[subscript].url) );
xmlAddChild( sonNode, content );
xmlAddChild( node, sonNode );
sonNode = xmlNewNode( NULL, BAD_CAST "urlstatus" );
content = xmlNewCDataBlock( NULL, BAD_CAST databaseList[subscript].urlstatus, strlen(databaseList[subscript].urlstatus) );
xmlAddChild( sonNode, content );
xmlAddChild( node, sonNode );
sonNode = xmlNewNode( NULL, BAD_CAST "filenamePrefix" );
content = xmlNewCDataBlock( NULL, BAD_CAST databaseList[subscript].filenamePrefix, strlen(databaseList[subscript].filenamePrefix) );
xmlAddChild( sonNode, content );
xmlAddChild( node, sonNode );
}
int nRel = xmlSaveFormatFileEnc( filename, doc, "UTF-8", 1);
/*if (nRel != -1)
printf(" created, %d bytes.\n", nRel);*/
xmlFreeDoc(doc);
if (nRel != -1) return 1;
else return 0;
}
/* {{{ proto void DOMCdataSection::__construct(string value); */
PHP_METHOD(domcdatasection, __construct)
{
zval *id = getThis();
xmlNodePtr nodep = NULL, oldnode = NULL;
dom_object *intern;
char *value = NULL;
size_t value_len;
if (zend_parse_parameters_throw(ZEND_NUM_ARGS(), "s", &value, &value_len) == FAILURE) {
return;
}
nodep = xmlNewCDataBlock(NULL, (xmlChar *) value, value_len);
if (!nodep) {
php_dom_throw_error(INVALID_STATE_ERR, 1);
RETURN_FALSE;
}
intern = Z_DOMOBJ_P(id);
oldnode = dom_object_get_node(intern);
if (oldnode != NULL) {
php_libxml_node_free_resource(oldnode );
}
php_libxml_increment_node_ptr((php_libxml_node_object *)intern, nodep, (void *)intern);
}
/* {{{ proto void DOMCdataSection::__construct(string value); */
PHP_METHOD(domcdatasection, __construct)
{
zval *id;
xmlNodePtr nodep = NULL, oldnode = NULL;
dom_object *intern;
char *value = NULL;
int value_len;
zend_error_handling error_handling;
zend_replace_error_handling(EH_THROW, dom_domexception_class_entry, &error_handling TSRMLS_CC);
if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Os", &id, dom_cdatasection_class_entry, &value, &value_len) == FAILURE) {
zend_restore_error_handling(&error_handling TSRMLS_CC);
return;
}
zend_restore_error_handling(&error_handling TSRMLS_CC);
nodep = xmlNewCDataBlock(NULL, (xmlChar *) value, value_len);
if (!nodep) {
php_dom_throw_error(INVALID_STATE_ERR, 1 TSRMLS_CC);
RETURN_FALSE;
}
intern = (dom_object *)zend_object_store_get_object(id TSRMLS_CC);
if (intern != NULL) {
oldnode = dom_object_get_node(intern);
if (oldnode != NULL) {
php_libxml_node_free_resource(oldnode TSRMLS_CC);
}
php_libxml_increment_node_ptr((php_libxml_node_object *)intern, nodep, (void *)intern TSRMLS_CC);
}
}
static
void craft_style(struct chatctx* ctx, xmlNode* head) {
// do NOT use ctx->dest because it's in the input document...
short id;
// XXX: xmlNewTextLen?
xmlNode* text = xmlNewCDataBlock(head->doc, NULL, 0);
xmlNodeAddContentLen(text, LITLEN("\n"));
/*
these should go in a global stylesheet.
xmlNodeAddContentLen(text, LITLEN(".chat { border-collapse: collapse; }\n"));
xmlNodeAddContentLen(text, LITLEN(".chat th { padding-right: 1ex; text-align: right; }\n"));
*/
char idbuf[0x100];
char huebuf[0x100];
char buf[0x100];
for(id=0;id<ctx->nnames;++id) {
int idlen = snprintf(idbuf,0x100,"%x",id);
xmlNodeAddContentLen(text, LITLEN(".n"));
xmlNodeAddContentLen(text, idbuf,idlen);
xmlNodeAddContentLen(text, LITLEN(" th {\n color: hsl("));
srandom(ctx->names[id]);
float hue = random() * 360.0 / RAND_MAX;
float sat = random() * 40.0 / RAND_MAX + 40.0; // higher saturation
float light = 30.0 + random() * 20.0 / RAND_MAX; // relatively dark
int huelen = snprintf(huebuf,0x100,"%f",hue);
xmlNodeAddContentLen(text, huebuf,huelen);
xmlNodeAddContentLen(text, LITLEN(", "));
xmlNodeAddContentLen(text, buf,
snprintf(buf,0x100,"%f",sat));
xmlNodeAddContentLen(text, LITLEN("%, "));
xmlNodeAddContentLen(text, buf,
snprintf(buf,0x100,"%f",light));
xmlNodeAddContentLen(text, LITLEN("%);\n}\n"));
// now the background
xmlNodeAddContentLen(text, LITLEN(".n"));
xmlNodeAddContentLen(text, idbuf,idlen);
xmlNodeAddContentLen(text, LITLEN(" * {\n background-color: hsl("));
xmlNodeAddContentLen(text, huebuf,huelen);
xmlNodeAddContentLen(text, LITLEN(", 100%,98%);\n}\n")); // very light
}
xmlNode* style = xmlNewNode(head->ns, "style");
xmlAddChild(style,text);
//printf("ummmmm %s\n",head->name);
xmlAddChild(head, style);
}
// CDATASection createCDATASection(in DOMString data) raises(DOMException);
static void _createCDATASection(Request& r, MethodParams& params) {
xmlChar* data=as_xmlchar(r, params, 0, XML_DATA_MUST_BE_STRING);
VXdoc& vdoc=GET_SELF(r, VXdoc);
xmlDoc& xmldoc=vdoc.get_xmldoc();
xmlNode *node=xmlNewCDataBlock(&xmldoc, data, strlen((const char*)data));
writeNode(r, vdoc, node);
}
void
XmlBuilder::AddCData( const iStringT& data )
{
check( doc_ != 0 || node_ != 0 );
CvtTA<> cntA( data.CStr(), CP_UTF8 );
xmlNodePtr cdata = xmlNewCDataBlock( doc_, (xmlChar*)cntA.str_, lstrlenA( cntA.str_ ) );
check( cdata != 0 );
if ( !xmlAddChild( node_, cdata ) ) throw XmlBuilderException();
}
static void
xml_output_xml(pcmk__output_t *out, const char *name, const char *buf) {
xmlNodePtr parent = NULL;
xmlNodePtr cdata_node = NULL;
xml_private_t *priv = out->priv;
CRM_ASSERT(priv != NULL);
parent = xmlNewChild(g_queue_peek_tail(priv->parent_q), NULL,
(pcmkXmlStr) name, NULL);
cdata_node = xmlNewCDataBlock(getDocPtr(parent), (pcmkXmlStr) buf, strlen(buf));
xmlAddChild(parent, cdata_node);
}
/*
* call-seq:
* XML::Node.new_cdata(content = nil) -> XML::Node
*
* Create a new #CDATA node, optionally setting
* the node's content.
*/
static VALUE rxml_node_new_cdata(int argc, VALUE *argv, VALUE klass)
{
VALUE content = Qnil;
xmlNodePtr xnode;
rb_scan_args(argc, argv, "01", &content);
if (NIL_P(content))
{
xnode = xmlNewCDataBlock(NULL, NULL, 0);
}
else
{
content = rb_obj_as_string(content);
xnode = xmlNewCDataBlock(NULL, (xmlChar*) StringValuePtr(content),
RSTRING_LEN(content));
}
if (xnode == NULL)
rxml_raise(&xmlLastError);
return rxml_node_wrap(xnode);
}
int SXmlNode::SetContentInCData(std::string value)
{
if (!_node)
return -1;
xmlNodePtr new_node=NULL;
xmlNodePtr new_root_node=xmlNewDocNode(NULL,0, _node->name,(const xmlChar *)"");
new_node = xmlNewCDataBlock(NULL,(const xmlChar *) (value.c_str()), value.length());
xmlAddChild(new_root_node,new_node);
//xmlNodeSetName(new_node, _node->name);
xmlReplaceNode(_node,new_root_node);
xmlFreeNode(_node);
_node=new_root_node;
return 0;
}
xmlNode* child_node_list::create_cdata_(const std::string& value)
{
xmlNode* px = xmlNewCDataBlock( raw_->doc,
detail::to_xml_chars(value.c_str()),
static_cast<int>(value.size()) );
if (px == 0)
{
std::string what = "fail to create libxml2 CData node for " + value;
throw internal_dom_error(what);
}
else
{
return px;
}
}
int exportXmlItemFileForAlarm( const char * filename, struct xmlItemAlarm_t * xmlItemAlarmList, int * xmlItemListAlarmTotal ) {
int subscript;
char longStr[100000];
char message[500];
xmlNodePtr node;
xmlNodePtr content;
xmlNodePtr sonNode;
xmlNodePtr grandsonNode;
// create the doc and root node
xmlDocPtr doc = xmlNewDoc( BAD_CAST "1.0" );
xmlNodePtr root_node = xmlNewNode( NULL, BAD_CAST "xmlItemListAlarm" );
xitoa( longStr, *xmlItemListAlarmTotal);
xmlNewProp( root_node, BAD_CAST "xmlItemListAlarmTotal", BAD_CAST longStr );
// set the root node
xmlDocSetRootElement( doc, root_node );
// if ( *xmlItemListAlarmTotal > *xmlItemListTotal ) *xmlItemListAlarmTotal = *xmlItemListTotal;
for (subscript=1; subscript <= *xmlItemListAlarmTotal; subscript++) {
node = xmlNewNode( NULL, BAD_CAST "item" );
xmlAddChild( root_node, node );
// xitoa( longStr, subscript );
// xmlNewProp( node, BAD_CAST "subscript", BAD_CAST longStr );
sonNode = xmlNewNode( NULL, BAD_CAST "message" );
// content = xmlNewCDataBlock( NULL, BAD_CAST longStr, strlen(longStr) );
// printf( "%s",longStr );
content = xmlNewCDataBlock( NULL, BAD_CAST xmlItemAlarmList[subscript].message, strlen(xmlItemAlarmList[subscript].message) );
xmlAddChild( sonNode, content );
xmlAddChild( node, sonNode );
}
int nRel = xmlSaveFormatFileEnc( filename, doc, "UTF-8", 1);
/*if (nRel != -1)
printf(" created, %d bytes.\n", nRel);*/
xmlFreeDoc(doc);
if (nRel != -1) return 1;
else return 0;
}
void
RS_XML(cdataBlockHandler)(void *ctx, const xmlChar *value, int len)
{
USER_OBJECT_ opArgs;
RS_XMLParserData *parserData = (RS_XMLParserData*) ctx;
DECL_ENCODING_FROM_EVENT_PARSER(parserData)
if(parserData->current) {
xmlAddChild(parserData->current, xmlNewCDataBlock(NULL, value, len));
return;
}
PROTECT(opArgs = NEW_LIST(1));
SET_VECTOR_ELT(opArgs, 0, NEW_CHARACTER(1));
SET_STRING_ELT(VECTOR_ELT(opArgs, 0), 0, ENC_COPY_TO_USER_STRING(XMLCHAR_TO_CHAR(value)));
RS_XML(callUserFunction)(HANDLER_FUN_NAME(parserData, "cdata"), (const char *)NULL, (RS_XMLParserData*)ctx, opArgs);
UNPROTECT(1);
}
void
XmlBuilder::AddCData( const uint8* ptr, uint32 size )
{
static xmlChar hexN[] = "0123456789ABCDEF";
check( doc_ != 0 || node_ != 0 );
if ( size == 0 ) return;
// convert to hex
xmlChar* buff = new xmlChar[ size * 2 + 1 ];
buff[ size*2 ] = 0;
for( uint32 n = 0; n < size; n++ ) {
buff[0+2*n] = hexN[ ptr[n] >> 4 ];
buff[1+2*n] = hexN[ ptr[n] & 0x0f ];
}
xmlNodePtr cdata = xmlNewCDataBlock( doc_, buff, size * 2 );
check( cdata != 0 );
delete[] buff;
if ( !xmlAddChild( node_, cdata ) ) throw XmlBuilderException();
}
int exportXmlItemFile( const char * filename, struct xmlItem_t * xmlItemList, int * xmlItemListTotal ){
int subscript;
int attrSubscript;
char longStr[100000];
xmlNodePtr node;
xmlNodePtr content;
xmlNodePtr sonNode;
xmlNodePtr grandsonNode;
// create the doc and root node
xmlDocPtr doc = xmlNewDoc( BAD_CAST "1.0" );
xmlNodePtr root_node = xmlNewNode( NULL, BAD_CAST "xmlItemList" );
xitoa( longStr, *xmlItemListTotal );
xmlNewProp( root_node, BAD_CAST "xmlItemListTotal", BAD_CAST longStr );
// set the root node
xmlDocSetRootElement( doc, root_node );
if ( *xmlItemListTotal > MAX_ITEMLIST_SAVE ) *xmlItemListTotal = MAX_ITEMLIST_SAVE;
for (subscript=1; subscript <= *xmlItemListTotal; subscript++){
node = xmlNewNode( NULL, BAD_CAST "item" );
xmlAddChild( root_node, node );
// xitoa( longStr, subscript );
// xmlNewProp( node, BAD_CAST "subscript", BAD_CAST longStr );
if ( xmlItemList[subscript].text[FRSS_ITEM_TITLE] != NULL ){
sonNode = xmlNewNode( NULL, BAD_CAST "title" );
content = xmlNewCDataBlock( NULL, BAD_CAST xmlItemList[subscript].text[FRSS_ITEM_TITLE], strlen(xmlItemList[subscript].text[FRSS_ITEM_TITLE]) );
xmlAddChild( sonNode, content );
xmlAddChild( node, sonNode );
}
if ( xmlItemList[subscript].text[FRSS_ITEM_TIME] != NULL ){
sonNode = xmlNewNode( NULL, BAD_CAST "time" );
content = xmlNewCDataBlock( NULL, BAD_CAST xmlItemList[subscript].text[FRSS_ITEM_TIME], strlen(xmlItemList[subscript].text[FRSS_ITEM_TIME]) );
xmlAddChild( sonNode, content );
xmlAddChild( node, sonNode );
}
if ( xmlItemList[subscript].text[FRSS_ITEM_CONTENT] != NULL ){
sonNode = xmlNewNode( NULL, BAD_CAST "content" );
content = xmlNewCDataBlock( NULL, BAD_CAST xmlItemList[subscript].text[FRSS_ITEM_CONTENT], strlen(xmlItemList[subscript].text[FRSS_ITEM_CONTENT]) );
xmlAddChild( sonNode, content );
xmlAddChild( node, sonNode );
}
if ( xmlItemList[subscript].richText[FRSS_ITEM_CONTENT] != NULL ){
sonNode = xmlNewNode( NULL, BAD_CAST "content:encoded" );
content = xmlNewCDataBlock( NULL, BAD_CAST xmlItemList[subscript].richText[FRSS_ITEM_CONTENT], strlen(xmlItemList[subscript].richText[FRSS_ITEM_CONTENT]) );
xmlAddChild( sonNode, content );
xmlAddChild( node, sonNode );
}
if ( xmlItemList[subscript].text[FRSS_ITEM_GUID] != NULL ){
sonNode = xmlNewNode( NULL, BAD_CAST "guid" );
content = xmlNewCDataBlock( NULL, BAD_CAST xmlItemList[subscript].text[FRSS_ITEM_GUID], strlen(xmlItemList[subscript].text[FRSS_ITEM_GUID]) );
xmlAddChild( sonNode, content );
xmlAddChild( node, sonNode );
}
}
int nRel = xmlSaveFormatFileEnc( filename, doc, "UTF-8", 1);
/*if (nRel != -1)
printf(" created, %d bytes.\n", nRel);*/
xmlFreeDoc(doc);
if (nRel != -1) return 1;
else return 0;
}
int exportRuleFile( const char * filename, struct xmlDesc_t * xmlDesc ){
int subscript;
int subscriptCount;
int attrSubscript;
char longStr[100000];
char * str;
xmlNodePtr node;
xmlNodePtr content;
xmlNodePtr sonNode;
xmlNodePtr grandsonNode;
int strType;
char title;
char attrTitle[100];
char attrValue[100];
int attrTotal;
int parent;
int tail;
// create the doc and root node
xmlDocPtr doc = xmlNewDoc( BAD_CAST "1.0" );
xmlNodePtr root_node = xmlNewNode( NULL, BAD_CAST "xmlItemDesc" );
xmlNewProp( root_node, BAD_CAST "flag", BAD_CAST "standard");
// set the root node
xmlDocSetRootElement( doc, root_node );
for (subscriptCount=1; subscriptCount <= 4; subscriptCount++){
if (subscriptCount == 1) subscript = XML_ITEM_REGION;
else if (subscriptCount == 2 ) subscript = XML_ITEM_TITLE;
else if (subscriptCount == 3 ) subscript = XML_ITEM_TIME;
else if (subscriptCount == 4 ) subscript = XML_ITEM_CONTENT;
if ( xmlDesc[subscript].title == NULL && xmlDesc[subscript].attrTotal <= 0 ) continue;
if ( subscript == XML_ITEM_REGION ) node = xmlNewNode( NULL, BAD_CAST "region" );
else if ( subscript == XML_ITEM_TITLE) node = xmlNewNode( NULL, BAD_CAST "title" );
else if ( subscript == XML_ITEM_TIME ) node = xmlNewNode( NULL, BAD_CAST "time" );
else if ( subscript == XML_ITEM_CONTENT ) node = xmlNewNode( NULL, BAD_CAST "content" );
xmlAddChild( root_node, node );
// xitoa( longStr, subscript );
// xmlNewProp( node, BAD_CAST "subscript", BAD_CAST longStr );
// xitoa( longStr, itemList[subscript].type );
// sonNode = xmlNewNode( NULL, BAD_CAST "type" );
// content = xmlNewText( BAD_CAST longStr );
// xmlAddChild( sonNode, content );
// xmlAddChild( node, sonNode );
if ( xmlDesc[subscript].title != NULL ){
sonNode = xmlNewNode( NULL, BAD_CAST "title" );
// strcpy( longStr, itemList[subscript].title );
// pushCDATA( longStr );
content = xmlNewCDataBlock( NULL, BAD_CAST xmlDesc[subscript].title, strlen(xmlDesc[subscript].title) );
// content = xmlNewText( BAD_CAST itemList[subscript].attrValue[attrSubscript]);
// str= (char *)xmlNodeGetContent( content);
// printf("%d:%d[%s]%s\n",subscript, strlen(xmlDesc[subscript].title), xmlDesc[subscript].title,str);
xmlAddChild( sonNode, content );
xmlAddChild( node, sonNode );
}
if ( xmlDesc[subscript].attrTotal > 0){
sonNode = xmlNewNode( NULL, BAD_CAST "attr" );
xitoa( longStr, xmlDesc[subscript].attrTotal );
xmlNewProp( sonNode, BAD_CAST "attrTotal", BAD_CAST longStr);
xmlAddChild( node, sonNode );
for ( attrSubscript=0; attrSubscript < xmlDesc[subscript].attrTotal; attrSubscript++){
xitoa( longStr, attrSubscript );
grandsonNode = xmlNewNode( NULL, BAD_CAST "attrTitle");
xmlNewProp( grandsonNode, BAD_CAST "attrSubscript", BAD_CAST longStr );
content = xmlNewText( BAD_CAST xmlDesc[subscript].attrTitle[attrSubscript]);
xmlAddChild( grandsonNode, content );
xmlAddChild( sonNode, grandsonNode );
grandsonNode = xmlNewNode( NULL, BAD_CAST "attrValue");
xmlNewProp( grandsonNode, BAD_CAST "attrSubscript", BAD_CAST longStr );
content = xmlNewText( BAD_CAST xmlDesc[subscript].attrValue[attrSubscript]);
xmlAddChild( grandsonNode, content );
xmlAddChild( sonNode, grandsonNode );
}
}
}
int nRel = xmlSaveFormatFileEnc( filename, doc, "UTF-8", 1);
/*if (nRel != -1)
printf(" created, %d bytes.\n", nRel);*/
xmlFreeDoc(doc);
if (nRel != -1) return 1;
else return 0;
}
bool gpl::xml::insertNodeByXPath(const char* nodeName, const char* nodeValue, int length /*= -1*/)
{
if (m_xml->resource == NULL)
return false;
int len = strlen(nodeValue);
if (length == 0 || len < length)
return false;
if (length == -1)
{
length = len;
}
//cout<<"resource->type:"<<m_xml->resource->type<<endl;
switch (m_xml->resource->type)
{
case XPATH_NODESET://Object is a Node Set
if (m_xml->resource->nodesetval == NULL)
return false;
xmlNodePtr cur, newNode;
//取得第一个节点
if ((cur = (*(m_xml->resource->nodesetval->nodeTab))) == NULL)
return false;
if (strlen(nodeName) == 0)
{
if (cur->children == NULL)
{
cur->children = xmlNewText((const xmlChar*)nodeValue);
cur->last = cur->children;
if (cur->last == NULL)
return false;
}
else
if (xmlTextConcat(cur->children, (const xmlChar *)nodeValue, length) < 0)
return false;
}
else
{
if (strcmp(nodeName, XML_CDATA) == 0)
{
if ((newNode = xmlNewCDataBlock(m_xml->doc, (const xmlChar*)nodeValue, length)) == NULL)
return false;
}
else
{
xmlNsPtr* ns = xmlGetNsList(m_xml->doc, cur);
if ((newNode = xmlNewNode((ns == NULL ? NULL : (*ns)), (const xmlChar *)nodeName)) == NULL)
return false;
xmlNodeSetContent(newNode, (const xmlChar*)nodeValue);
}
//从最后的字节点位置进行追加
if ((xmlAddChild(cur, newNode)) == NULL)
return false;
}
break;
case XPATH_XSLT_TREE://Object is an XSLT value tree
case XPATH_BOOLEAN://Object is a Boolean
case XPATH_NUMBER://Object is a number
case XPATH_STRING://Object is a string
case XPATH_POINT://Object is a point
case XPATH_RANGE://是一个范围
case XPATH_LOCATIONSET://Object is a Location Set
case XPATH_USERS://Object is user defined
case XPATH_UNDEFINED://Object is uninitialized
return false;
break;
}
return true;
}
#include <xml_cdata.h>
/*
* call-seq:
* new(document, content)
*
* Create a new CData element on the +document+ with +content+
*/
static VALUE new(VALUE klass, VALUE doc, VALUE content)
{
xmlDocPtr xml_doc;
Data_Get_Struct(doc, xmlDoc, xml_doc);
xmlNodePtr node = xmlNewCDataBlock(
xml_doc,
(const xmlChar *)StringValuePtr(content),
RSTRING_LEN(content)
);
VALUE rb_node = Nokogiri_wrap_xml_node(node);
if(rb_block_given_p()) rb_yield(rb_node);
return rb_node;
}
VALUE cNokogiriXmlCData;
void init_xml_cdata()
{
VALUE nokogiri = rb_define_module("Nokogiri");
VALUE xml = rb_define_module_under(nokogiri, "XML");
int exportXmlDom( const char * filename, struct itemnode_t * itemList, int * itemListTotal){
int subscript;
int attrSubscript;
char longStr[100000];
xmlNodePtr node;
xmlNodePtr content;
xmlNodePtr sonNode;
xmlNodePtr grandsonNode;
int strType;
char title;
char attrTitle[100];
char attrValue[100];
int attrTotal;
int parent;
int tail;
// create the doc and root node
xmlDocPtr doc = xmlNewDoc( BAD_CAST "1.0" );
xmlNodePtr root_node = xmlNewNode( NULL, BAD_CAST "xmlDomList" );
xitoa( longStr, *itemListTotal);
xmlNewProp( root_node, BAD_CAST "itemListTotal", BAD_CAST longStr );
// set the root node
xmlDocSetRootElement( doc, root_node );
for (subscript=1; subscript <= *itemListTotal; subscript++){
node = xmlNewNode( NULL, BAD_CAST "item" );
xmlAddChild( root_node, node );
xitoa( longStr, subscript );
xmlNewProp( node, BAD_CAST "subscript", BAD_CAST longStr );
xitoa( longStr, itemList[subscript].type );
sonNode = xmlNewNode( NULL, BAD_CAST "type" );
content = xmlNewText( BAD_CAST longStr );
xmlAddChild( sonNode, content );
xmlAddChild( node, sonNode );
sonNode = xmlNewNode( NULL, BAD_CAST "title" );
// strcpy( longStr, itemList[subscript].title );
// pushCDATA( longStr );
content = xmlNewCDataBlock( NULL, BAD_CAST itemList[subscript].title, strlen(itemList[subscript].title) );
xmlAddChild( sonNode, content );
xmlAddChild( node, sonNode );
sonNode = xmlNewNode( NULL, BAD_CAST "attr" );
xitoa( longStr, itemList[subscript].attrTotal );
xmlNewProp( sonNode, BAD_CAST "attrTotal", BAD_CAST longStr);
xmlAddChild( node, sonNode );
for ( attrSubscript=0; attrSubscript < itemList[subscript].attrTotal; attrSubscript++){
xitoa( longStr, attrSubscript );
grandsonNode = xmlNewNode( NULL, BAD_CAST "attrTitle");
xmlNewProp( grandsonNode, BAD_CAST "attrSubscript", BAD_CAST longStr );
content = xmlNewText( BAD_CAST itemList[subscript].attrTitle[attrSubscript]);
xmlAddChild( grandsonNode, content );
xmlAddChild( sonNode, grandsonNode );
grandsonNode = xmlNewNode( NULL, BAD_CAST "attrValue");
xmlNewProp( grandsonNode, BAD_CAST "attrSubscript", BAD_CAST longStr );
content = xmlNewText( BAD_CAST itemList[subscript].attrValue[attrSubscript]);
xmlAddChild( grandsonNode, content );
xmlAddChild( sonNode, grandsonNode );
}
xitoa( longStr, itemList[subscript].parent );
sonNode = xmlNewNode( NULL, BAD_CAST "parent" );
content = xmlNewText( BAD_CAST longStr );
xmlAddChild( sonNode, content );
xmlAddChild( node, sonNode );
xitoa( longStr, itemList[subscript].tail );
sonNode = xmlNewNode( NULL, BAD_CAST "tail" );
content = xmlNewText( BAD_CAST longStr );
xmlAddChild( sonNode, content );
xmlAddChild( node, sonNode );
}
int nRel = xmlSaveFormatFileEnc( filename, doc, "UTF-8", 1);
/*if (nRel != -1)
printf(" created, %d bytes.\n", nRel);*/
xmlFreeDoc(doc);
if (nRel != -1) return 1;
else return 0;
}
xmlNodePtr node;
VALUE doc;
VALUE content;
VALUE rest;
VALUE rb_node;
const xmlChar *content_str;
int content_str_len;
rb_scan_args(argc, argv, "2*", &doc, &content, &rest);
Data_Get_Struct(doc, xmlDoc, xml_doc);
content_str = NIL_P(content) ? NULL : (const xmlChar *)StringValueCStr(content);
content_str_len = (content_str == NULL) ? 0 : strlen(content_str);
node = xmlNewCDataBlock(xml_doc->doc, content_str, content_str_len);
nokogiri_root_node(node);
rb_node = Nokogiri_wrap_xml_node(klass, node);
rb_obj_call_init(rb_node, argc, argv);
if(rb_block_given_p()) { rb_yield(rb_node); }
return rb_node;
}
VALUE cNokogiriXmlCData;
void init_xml_cdata()
{
VALUE nokogiri = rb_define_module("Nokogiri");
