// -------------------------------------------------------------------------------------
// Sets new attribute value exactly as presented in the string.
//
// Predefined entities are not converted into characters they represent.
//
// @see TXmlEngAttr::SetValueL()
// -------------------------------------------------------------------------------------
//
EXPORT_C void TXmlEngAttr::SetValueNoEncL( const TDesC8& aNewValue )
{
if (!LIBXML_ATTRIBUTE)
{
User::Leave(KXmlEngErrNullNode);
}
//
xmlAttrPtr prop = LIBXML_ATTRIBUTE;
xmlNodePtr new_ch;
if (!aNewValue.Length())
{
prop->last = NULL;
new_ch = NULL;
}
else
{
xmlChar* value = xmlCharFromDesC8L(aNewValue);
new_ch = xmlNewText(NULL);
if(!new_ch)
{
delete value;
OOM_HAPPENED;
};
new_ch->name = xmlStringTextNoenc;
new_ch->content = value;
new_ch->parent = (xmlNodePtr) prop;
prop->last = new_ch;
}
xmlFreeNodeList(prop->children);
prop->children = new_ch;
}
void
network_client_send_number_of_players(NetworkClient * client,
int n)
{
xmlDoc * doc;
xmlNode * root;
xmlNode * text;
doc = xmlNewDoc((guchar*)"1.0");
root = xmlNewNode(NULL, (guchar*)"message");
xmlDocSetRootElement(doc, root);
xmlNewProp(root, (guchar*)"name", (guchar*)"number_of_players");
text = xmlNewText((guchar*)g_strdup_printf("%d",n));
xmlAddChild(root,text);
network_message_handler_send_xml_message(PRIVATE(client)->handler,
PRIVATE(client)->client_id,
doc);
xmlFreeDoc(doc);
}
static int32_t package_add_xml_leaf(xmlNodePtr child_node, xmlNodePtr far_node, char *key_name, char *key_value)
{
child_node = xmlNewNode(NULL, BAD_CAST key_name);
xmlAddChild(far_node, child_node);
xmlAddChild(child_node, xmlNewText(BAD_CAST key_value));
return 1;
}
/* {{{ proto void DOMText::__construct([string value]); */
PHP_METHOD(domtext, __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(), "O|s", &id, dom_text_class_entry, &value, &value_len) == FAILURE) {
zend_restore_error_handling(&error_handling TSRMLS_CC);
return;
}
zend_restore_error_handling(&error_handling TSRMLS_CC);
nodep = xmlNewText((xmlChar *) value);
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);
}
}
/* {{{ proto void DOMText::__construct([string value]); */
PHP_METHOD(domtext, __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 = xmlNewText((xmlChar *) value);
if (!nodep) {
php_dom_throw_error(INVALID_STATE_ERR, 1);
RETURN_FALSE;
}
intern = Z_DOMOBJ_P(id);
if (intern != NULL) {
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);
}
}
int main()
{
xmlDoc *doc = NULL;
xmlNode *root = NULL, *node;
const char **next;
int a;
doc = xmlNewDoc("1.0");
root = xmlNewNode(NULL, "CharacterRemarks");
xmlDocSetRootElement(doc, root);
for(next = names, a = 0; *next != NULL; next++, a++) {
node = xmlNewNode(NULL, "Character");
(void)xmlNewProp(node, "name", *next);
xmlAddChild(node, xmlNewText(remarks[a]));
xmlAddChild(root, node);
}
xmlElemDump(stdout, doc, root);
xmlFreeDoc(doc);
xmlCleanupParser();
return EXIT_SUCCESS;
}
/**
* New API expected new behavior of this function
* Example: node:set_text("text");
* - node is regular node, not the text one
* - text will be set as new child of node
* - if node has some text as it's child, it will be replaced
* - replacing text mean delete all text and CDATA nodes and crete new text one
*/
static int node_set_text(lua_State *L) {
xmlNodePtr node = lua_touserdata(L, 1);
const char *text = lua_tostring(L, 2);
if (node == NULL) return luaL_error(L, "set_text: Invalid parent node");
if (node->type != XML_ELEMENT_NODE) return luaL_error(L, "set_text: Invalid parent node type (not element node)");
if (text == NULL) return luaL_error(L, "Got NULL text");
//First, delete all CDATA and text nodes
//It is not good idea to use for loop...
xmlNodePtr child = node->children;
xmlNodePtr to_del;
while (child) {
if (child->type == XML_TEXT_NODE || child->type == XML_CDATA_SECTION_NODE) {
to_del = child;
child = child->next;
internal_delete_node(to_del);
} else {
child = child->next;
}
}
//Second, create new text node
xmlNodePtr text_node = xmlNewText(BAD_CAST text);
xmlAddChild(node, text_node);
lua_pushlightuserdata(L, node);
luaL_setmetatable(L, WRAP_XMLNODE);
return 1;
}
int main (int argc, char **argv)
{
xmlDocPtr pdoc = NULL;
xmlNodePtr proot_node = NULL,pnode = NULL,pnode1 = NULL;
// 创建一个新文档并设置 root 节点
// 一个 XML 文件只有一个 root 节点
pdoc = xmlNewDoc (BAD_CAST "1.0");
proot_node = xmlNewNode (NULL, BAD_CAST "根节点");
xmlNewProp (proot_node, BAD_CAST "版本", BAD_CAST "1.0");
xmlDocSetRootElement (pdoc, proot_node);
pnode = xmlNewNode (NULL, BAD_CAST "子节点1");
// 创建上面 pnode 的子节点
xmlNewChild (pnode, NULL, BAD_CAST "子子节点1", BAD_CAST "信息");
// 添加子节点到 root 节点
xmlAddChild (proot_node, pnode);
pnode1 = xmlNewNode (NULL, BAD_CAST "子子节点1");
xmlAddChild (pnode, pnode1);
xmlAddChild (pnode1,xmlNewText (BAD_CAST "这是更低的节点,子子子节点1"));
// 还可以这样直接创建一个子节点到 root 节点上
xmlNewTextChild (proot_node, NULL, BAD_CAST "子节点2", BAD_CAST "子节点2的内容");
xmlNewTextChild (proot_node, NULL, BAD_CAST "子节点3", BAD_CAST "子节点3的内容");
// 保存 xml 为文件,如果没有给出文件名参数，就输出到标准输出
xmlSaveFormatFileEnc (argc > 1 ? argv[1]:"-", pdoc, "UTF-8", 1);
// 释放资源
xmlFreeDoc (pdoc);
xmlCleanupParser ();
xmlMemoryDump ();
return 0;
}
// -------------------------------------------------------------------------------------
// Sets new value of the attribute. Provided new value will be escaped as needed.
//
// @param aNewValue A string value for the attribute
//
// The new value should not contain entity references. Entity references are not expanded,
// but used as text, because the ampersand (&) character of reference is escaped.
//
// @see SetRawValueL(TDOMString)
// -------------------------------------------------------------------------------------
//
EXPORT_C void TXmlEngAttr::SetValueL(
const TDesC8& aNewValue)
{
if (!LIBXML_ATTRIBUTE)
{
User::Leave(KXmlEngErrNullNode);
}
//
xmlAttrPtr prop = LIBXML_ATTRIBUTE;
xmlNodePtr new_ch;
if (!aNewValue.Length())
{
new_ch = NULL;
}
else
{
xmlChar* value = xmlCharFromDesC8L(aNewValue);
new_ch = xmlNewText(NULL);
if(!new_ch)
{
delete value;
OOM_HAPPENED;
};
new_ch->content = value;
new_ch->parent = reinterpret_cast<xmlNodePtr>(prop);
new_ch->doc = prop->doc;
}
xmlFreeNodeList(prop->children);
prop->children = new_ch;
prop->last = new_ch;
}
static xmlNodePtr yaz_query2xml_term(const Z_Term *term, xmlNodePtr parent)
{
xmlNodePtr t = 0;
xmlNodePtr node = xmlNewChild(parent, /* NS */ 0, BAD_CAST "term", 0);
char formstr[20];
const char *type = 0;
switch (term->which)
{
case Z_Term_general:
type = "general";
t = xmlNewTextLen(BAD_CAST term->u.general->buf, term->u.general->len);
break;
case Z_Term_numeric:
type = "numeric";
sprintf(formstr, ODR_INT_PRINTF, *term->u.numeric);
t = xmlNewText(BAD_CAST formstr);
break;
case Z_Term_characterString:
type = "string";
t = xmlNewText(BAD_CAST term->u.characterString);
break;
case Z_Term_oid:
type = "oid";
break;
case Z_Term_dateTime:
type = "dateTime";
break;
case Z_Term_external:
type = "external";
break;
case Z_Term_integerAndUnit:
type ="integerAndUnit";
break;
case Z_Term_null:
type = "null";
break;
default:
break;
}
if (t) /* got a term node ? */
xmlAddChild(node, t);
if (type)
xmlNewProp(node, BAD_CAST "type", BAD_CAST type);
return node;
}
void
slaxJsonElementValue (slax_data_t *sdp, slax_string_t *value)
{
xmlNodePtr nodep;
char *cp = value->ss_token;
nodep = xmlNewText((const xmlChar *) cp);
if (nodep)
slaxAddChild(sdp, NULL, nodep);
}
void Node::addText(const std::string& text)
{
// Allocate a new text node
xmlNodePtr whitespace = xmlNewText(
reinterpret_cast<const xmlChar*>(text.c_str())
);
// Add the newly allocated text as sibling of this node
xmlAddSibling(_xmlNode, whitespace);
}
void
XmlBuilder::AddText(const iStringT& content)
{
check( doc_ != 0 || node_ != 0 );
CvtTA<> cntA( content.CStr(), CP_UTF8 );
xmlNodePtr text = xmlNewText( (xmlChar*)cntA.str_ );
check( text != 0 );
if ( !xmlAddChild( node_, text ) ) throw XmlBuilderException();
}
/*
* call-seq:
* XML::Node.new_text(content) -> XML::Node
*
* Create a new text node.
*
*/
static VALUE rxml_node_new_text(VALUE klass, VALUE content)
{
xmlNodePtr xnode;
Check_Type(content, T_STRING);
content = rb_obj_as_string(content);
xnode = xmlNewText((xmlChar*) StringValueCStr(content));
if (xnode == NULL)
rxml_raise(&xmlLastError);
return rxml_node_wrap(xnode);
}
static void xspf_add_node(xmlNodePtr node, TupleValueType type,
gboolean isMeta, const gchar *xspfName, const gchar *strVal,
const gint intVal)
{
gchar tmps[64];
xmlNodePtr tmp;
if (isMeta) {
tmp = xmlNewNode(NULL, (xmlChar *) "meta");
xmlSetProp(tmp, (xmlChar *) "rel", (xmlChar *) xspfName);
} else
tmp = xmlNewNode(NULL, (xmlChar *) xspfName);
switch (type) {
case TUPLE_STRING:;
gchar * subst;
if (is_valid_string (strVal, & subst))
xmlAddChild (tmp, xmlNewText ((xmlChar *) strVal));
else
{
xmlAddChild (tmp, xmlNewText ((xmlChar *) subst));
g_free (subst);
}
break;
case TUPLE_INT:
g_snprintf(tmps, sizeof(tmps), "%d", intVal);
xmlAddChild(tmp, xmlNewText((xmlChar *) tmps));
break;
default:
break;
}
xmlAddChild(node, tmp);
}
xmlNodePtr
dav_lock_get_activelock_node (const DAVLock *lock,
xmlNsPtr ns)
{
xmlNodePtr node, active;
active = xmlNewNode (ns, BAD_CAST "activelock");
node = xmlNewChild (active, ns, BAD_CAST "locktype", NULL);
xmlNewChild (node, ns, BAD_CAST locktype_to_string (lock->type), NULL);
node = xmlNewChild (active, ns, BAD_CAST "lockscope", NULL);
xmlNewChild (node, ns, BAD_CAST lockscope_to_string (lock->scope), NULL);
node = xmlNewChild (active, ns, BAD_CAST "depth", NULL);
xmlAddChild (node, xmlNewText (BAD_CAST depth_to_string (lock->depth)));
if (lock->owner)
xmlAddChild (active, xmlCopyNode (lock->owner, 1));
node = xmlNewChild (active, ns, BAD_CAST "locktoken", NULL);
node = xmlNewChild (node, ns, BAD_CAST "href", NULL);
xmlAddChild (node, xmlNewText (BAD_CAST lock->token));
node = xmlNewChild (active, ns, BAD_CAST "lockroot", NULL);
node = xmlNewChild (node, ns, BAD_CAST "href", NULL);
xmlAddChild (node, xmlNewText (BAD_CAST lock->path->path));
if (lock->timeout)
{
gchar *tmp = g_strdup_printf ("Second-%" G_GINT64_FORMAT, lock->timeout -
g_get_monotonic_time () / G_USEC_PER_SEC);
node = xmlNewChild (active, ns, BAD_CAST "timeout", NULL);
xmlAddChild (node, xmlNewText (BAD_CAST tmp));
g_free (tmp);
}
return active;
}
/**
* Creates a content node and appends it to the list of children
* in "this".
*
* @param pcszContent
* @return
*/
ContentNode* ElementNode::addContent(const char *pcszContent)
{
// libxml side: create new node
xmlNode *plibNode;
if (!(plibNode = xmlNewText((const xmlChar*)pcszContent)))
throw std::bad_alloc();
xmlAddChild(m_plibNode, plibNode);
// now wrap this in C++
ContentNode *p = new ContentNode(this, plibNode);
boost::shared_ptr<ContentNode> pNew(p);
m->children.push_back(pNew);
return p;
}
void XMLElement::setChildren(const std::string & xmlCode) const
{
std::string error;
XMLDocument document = XMLDocument(xmlCode, false, &error);
if (error.empty())
{
setChildren(*document.getRoot());
}
else
{
xmlNode *n = xmlNewText((xmlChar *) xmlCode.c_str());
setChildren(XMLElement(doc, n));
}
}
// Inherits XMLSpy generation source function.
xmlNodePtr CNode::InternalCreate(ENodeType eNodeType, const tstring& sNamespaceURI, const tstring& sName, const tstring& sValue)
{
if (eNodeType == Element)
{
xmlNodePtr pElement = xmlNewNode(NULL, X(sName));
if(sNamespaceURI.size() > 0)
xmlNewNs(pElement, X(sNamespaceURI), NULL);
xmlAddChild(pElement, xmlNewText(X(sValue)));
return pElement;
}
else
{
return NULL;
}
}
void XMLNodeList::setElementAtPosition(double index, const std::string & xmlCode)
{
std::string error;
XMLDocument document = XMLDocument(xmlCode, false, &error);
if (error.empty())
{
setElementAtPosition(index, document);
}
else
{
xmlNode *n = xmlNewText((xmlChar *) xmlCode.c_str());
setElementAtPosition(index, XMLElement(doc, n));
}
}
inline void COXml::flushContentString ()
{
// Current node must exist here
nlassert (_CurrentNode);
// String size
uint size=(uint)_ContentString.length();
// Some content to write ?
if (size)
{
// Write it in the current node
xmlNodePtr textNode = xmlNewText ((const xmlChar *)_ContentString.c_str());
xmlAddChild (_CurrentNode, textNode);
// Empty the string
_ContentString.erase ();
}
}
PKI_CONFIG_ELEMENT *PKI_CONFIG_ELEMENT_new ( char *name, char *value ) {
PKI_CONFIG_ELEMENT *ret = NULL;
// xmlNsPtr ns = NULL;
if( !name ) return ( NULL );
if((ret = xmlNewNode( NULL, BAD_CAST name )) == NULL ) {
return ( NULL );
}
// ns = xmlNewNs ( ret, PKI_NAMESPACE_PREFIX, NULL );
if( value ) {
xmlAddChild( ret, xmlNewText ( BAD_CAST value ));
}
return ( ret );
}
int main()
{
xmlDocPtr doc = xmlNewDoc(BAD_CAST"1.0");
xmlNodePtr root_node = xmlNewNode(NULL, BAD_CAST"root");
//设置根节点
xmlDocSetRootElement(doc, root_node);
//在根结点中创建节点
xmlNewTextChild(root_node, NULL, BAD_CAST"newNode1",
BAD_CAST"newNode1 content");
xmlNewTextChild(root_node, NULL, BAD_CAST"newNode2",
BAD_CAST"newNode2 content");
xmlNewTextChild(root_node, NULL, BAD_CAST"newNode3",
BAD_CAST"newNode3 content");
//创建一个节点，设置其内容和属性，然后加入根节点
xmlNodePtr node = xmlNewNode(NULL, BAD_CAST"node2");
xmlNodePtr content = xmlNewText(BAD_CAST"NODE_CONTENT");
xmlAddChild(root_node, node);
xmlAddChild(node, content);
xmlNewProp(node, BAD_CAST"attribute", BAD_CAST"yes");
//创建一个儿子及孙子节点
node = xmlNewNode(NULL, BAD_CAST"son");
xmlAddChild(root_node, node);
xmlNodePtr grandson = xmlNewNode(NULL, BAD_CAST"grandson");
xmlAddChild(node, grandson);
//xmlAddChild(grandson, xmlNewText(BAD_CAST"This is a grandson node"));
//存储xml文档
int nRel = xmlSaveFile("CreatedXml.xml", doc);
if (-1 != nRel)
{
printf("一个XML文档被创建，写入%d个字节\n", nRel);
}
xmlFreeDoc(doc);
return 0;
}
static gboolean
game_created_ok(GameNetworkPlayerManager * manager)
{
xmlDoc * doc;
xmlNode * text, * root;
UiMain * ui_main;
ui_main = ui_main_get_instance();
if( PRIVATE(manager)->current_game != NULL) {
ui_main_set_game(ui_main,NULL);
g_object_unref(G_OBJECT(PRIVATE(manager)->current_game));
PRIVATE(manager)->current_game = NULL;
}
PRIVATE(manager)->monkey = monkey_new(TRUE);
doc = xmlNewDoc((guchar*)"1.0");
root = xmlNewNode(NULL, (guchar*)"message");
xmlDocSetRootElement(doc, root);
xmlNewProp(root,(guchar*)"name",(guchar*)"game_created_ok");
text = xmlNewText((guchar*)"1");
xmlAddChild(root,text);
network_message_handler_send_xml_message(PRIVATE(manager)->handler,
PRIVATE(manager)->client_id,
doc);
xmlFreeDoc(doc);
return FALSE;
}
/*
* value_to_node
*
* Converts @value to a string
*/
static xmlNodePtr
value_to_node (GdaReportEngine *engine, G_GNUC_UNUSED RunContext *context, const GValue *value, GdaSet *options)
{
xmlNodePtr retnode = NULL;
GdaHolder *converter = NULL;
if (options)
converter = gda_set_get_holder (options, "converter");
if (!value || gda_value_is_null (value))
retnode = xmlNewText (BAD_CAST "");
else if ((G_VALUE_TYPE (value) == GDA_TYPE_BINARY) ||
(G_VALUE_TYPE (value) == GDA_TYPE_BLOB)) {
TO_IMPLEMENT;
retnode = xmlNewText (BAD_CAST _("Binary data"));
}
else {
GdaDataHandler *dh;
gchar *str;
if (!data_handlers) {
/* initialize the internal data handlers */
data_handlers = g_hash_table_new_full (gtype_hash, gtype_equal,
NULL, (GDestroyNotify) g_object_unref);
g_hash_table_insert (data_handlers, (gpointer) G_TYPE_INT64, gda_handler_numerical_new ());
g_hash_table_insert (data_handlers, (gpointer) G_TYPE_UINT64, gda_handler_numerical_new ());
g_hash_table_insert (data_handlers, (gpointer) G_TYPE_BOOLEAN, gda_handler_boolean_new ());
g_hash_table_insert (data_handlers, (gpointer) G_TYPE_DATE, gda_handler_time_new ());
g_hash_table_insert (data_handlers, (gpointer) G_TYPE_DOUBLE, gda_handler_numerical_new ());
g_hash_table_insert (data_handlers, (gpointer) G_TYPE_INT, gda_handler_numerical_new ());
g_hash_table_insert (data_handlers, (gpointer) GDA_TYPE_NUMERIC, gda_handler_numerical_new ());
g_hash_table_insert (data_handlers, (gpointer) G_TYPE_FLOAT, gda_handler_numerical_new ());
g_hash_table_insert (data_handlers, (gpointer) GDA_TYPE_SHORT, gda_handler_numerical_new ());
g_hash_table_insert (data_handlers, (gpointer) GDA_TYPE_USHORT, gda_handler_numerical_new ());
g_hash_table_insert (data_handlers, (gpointer) G_TYPE_STRING, gda_handler_string_new ());
g_hash_table_insert (data_handlers, (gpointer) GDA_TYPE_TIME, gda_handler_time_new ());
g_hash_table_insert (data_handlers, (gpointer) GDA_TYPE_TIMESTAMP, gda_handler_time_new ());
g_hash_table_insert (data_handlers, (gpointer) G_TYPE_CHAR, gda_handler_numerical_new ());
g_hash_table_insert (data_handlers, (gpointer) G_TYPE_UCHAR, gda_handler_numerical_new ());
g_hash_table_insert (data_handlers, (gpointer) G_TYPE_ULONG, gda_handler_numerical_new ());
g_hash_table_insert (data_handlers, (gpointer) G_TYPE_LONG, gda_handler_numerical_new ());
g_hash_table_insert (data_handlers, (gpointer) G_TYPE_GTYPE, gda_handler_type_new ());
g_hash_table_insert (data_handlers, (gpointer) G_TYPE_UINT, gda_handler_numerical_new ());
}
gboolean converted = FALSE;
dh = g_hash_table_lookup (data_handlers, (gpointer) G_VALUE_TYPE (value));
if (dh)
str = gda_data_handler_get_str_from_value (dh, value);
else
str = gda_value_stringify (value);
if (converter) {
const GValue *cvalue;
cvalue = gda_holder_get_value (converter);
if ((G_VALUE_TYPE (cvalue) == G_TYPE_STRING) && g_value_get_string (cvalue)) {
gchar **array;
array = g_strsplit (g_value_get_string (cvalue), "::", 0);
if (array[0] && !strcmp (array[0], "richtext")) {
if (array[1] && !strcmp (array[1], "docbook")) {
retnode = xmlNewNode (NULL, BAD_CAST "para");
parse_rich_text_to_docbook (engine, retnode, str);
converted = TRUE;
}
else if (array[1] && !strcmp (array[1], "html")) {
retnode = xmlNewNode (NULL, BAD_CAST "p");
parse_rich_text_to_html (engine, retnode, str);
converted = TRUE;
}
}
}
}
if (!converted)
retnode = xmlNewText (BAD_CAST (str ? str : ""));
g_free (str);
}
return retnode;
}
/**
* xsltAttrListTemplateProcess:
* @ctxt: the XSLT transformation context
* @target: the element where the attributes will be grafted
* @attrs: the first attribute
*
* Processes all attributes of a Literal Result Element.
* Attribute references are applied via xsl:use-attribute-set
* attributes.
* Copies all non XSLT-attributes over to the @target element
* and evaluates Attribute Value Templates.
*
* Called by xsltApplySequenceConstructor() (transform.c).
*
* Returns a new list of attribute nodes, or NULL in case of error.
* (Don't assign the result to @target->properties; if
* the result is NULL, you'll get memory leaks, since the
* attributes will be disattached.)
*/
xmlAttrPtr
xsltAttrListTemplateProcess(xsltTransformContextPtr ctxt,
xmlNodePtr target, xmlAttrPtr attrs)
{
xmlAttrPtr attr, copy, last;
xmlNodePtr oldInsert, text;
xmlNsPtr origNs = NULL, copyNs = NULL;
const xmlChar *value;
xmlChar *valueAVT;
if ((ctxt == NULL) || (target == NULL) || (attrs == NULL))
return(NULL);
oldInsert = ctxt->insert;
ctxt->insert = target;
/*
* Instantiate LRE-attributes.
*/
if (target->properties) {
last = target->properties;
while (last->next != NULL)
last = last->next;
} else {
last = NULL;
}
attr = attrs;
do {
/*
* Skip XSLT attributes.
*/
#ifdef XSLT_REFACTORED
if (attr->psvi == xsltXSLTAttrMarker) {
goto next_attribute;
}
#else
if ((attr->ns != NULL) &&
xmlStrEqual(attr->ns->href, XSLT_NAMESPACE))
{
goto next_attribute;
}
#endif
/*
* Get the value.
*/
if (attr->children != NULL) {
if ((attr->children->type != XML_TEXT_NODE) ||
(attr->children->next != NULL))
{
xsltTransformError(ctxt, NULL, attr->parent,
"Internal error: The children of an attribute node of a "
"literal result element are not in the expected form.\n");
goto error;
}
value = attr->children->content;
if (value == NULL)
value = xmlDictLookup(ctxt->dict, BAD_CAST "", 0);
} else
value = xmlDictLookup(ctxt->dict, BAD_CAST "", 0);
/*
* Create a new attribute.
*/
copy = xmlNewDocProp(target->doc, attr->name, NULL);
if (copy == NULL) {
if (attr->ns) {
xsltTransformError(ctxt, NULL, attr->parent,
"Internal error: Failed to create attribute '{%s}%s'.\n",
attr->ns->href, attr->name);
} else {
xsltTransformError(ctxt, NULL, attr->parent,
"Internal error: Failed to create attribute '%s'.\n",
attr->name);
}
goto error;
}
/*
* Attach it to the target element.
*/
copy->parent = target;
if (last == NULL) {
target->properties = copy;
last = copy;
} else {
last->next = copy;
copy->prev = last;
last = copy;
}
/*
* Set the namespace. Avoid lookups of same namespaces.
*/
if (attr->ns != origNs) {
origNs = attr->ns;
if (attr->ns != NULL) {
#ifdef XSLT_REFACTORED
copyNs = xsltGetSpecialNamespace(ctxt, attr->parent,
attr->ns->href, attr->ns->prefix, target);
#else
copyNs = xsltGetNamespace(ctxt, attr->parent,
attr->ns, target);
#endif
if (copyNs == NULL)
goto error;
} else
copyNs = NULL;
}
copy->ns = copyNs;
/*
* Set the value.
*/
text = xmlNewText(NULL);
if (text != NULL) {
copy->last = copy->children = text;
text->parent = (xmlNodePtr) copy;
text->doc = copy->doc;
if (attr->psvi != NULL) {
/*
* Evaluate the Attribute Value Template.
*/
valueAVT = xsltEvalAVT(ctxt, attr->psvi, attr->parent);
if (valueAVT == NULL) {
/*
* TODO: Damn, we need an easy mechanism to report
* qualified names!
*/
if (attr->ns) {
xsltTransformError(ctxt, NULL, attr->parent,
"Internal error: Failed to evaluate the AVT "
"of attribute '{%s}%s'.\n",
attr->ns->href, attr->name);
} else {
xsltTransformError(ctxt, NULL, attr->parent,
"Internal error: Failed to evaluate the AVT "
"of attribute '%s'.\n",
attr->name);
}
text->content = xmlStrdup(BAD_CAST "");
goto error;
} else {
text->content = valueAVT;
}
} else if ((ctxt->internalized) &&
(target->doc != NULL) &&
(target->doc->dict == ctxt->dict) &&
xmlDictOwns(ctxt->dict, value))
{
text->content = (xmlChar *) value;
} else {
text->content = xmlStrdup(value);
}
if ((copy != NULL) && (text != NULL) &&
(xmlIsID(copy->doc, copy->parent, copy)))
xmlAddID(NULL, copy->doc, text->content, copy);
}
next_attribute:
attr = attr->next;
} while (attr != NULL);
/*
* Apply attribute-sets.
* The creation of such attributes will not overwrite any existing
* attribute.
*/
attr = attrs;
do {
#ifdef XSLT_REFACTORED
if ((attr->psvi == xsltXSLTAttrMarker) &&
xmlStrEqual(attr->name, (const xmlChar *)"use-attribute-sets"))
{
xsltApplyAttributeSet(ctxt, ctxt->node, (xmlNodePtr) attr, NULL);
}
#else
if ((attr->ns != NULL) &&
xmlStrEqual(attr->name, (const xmlChar *)"use-attribute-sets") &&
xmlStrEqual(attr->ns->href, XSLT_NAMESPACE))
{
xsltApplyAttributeSet(ctxt, ctxt->node, (xmlNodePtr) attr, NULL);
}
#endif
attr = attr->next;
} while (attr != NULL);
ctxt->insert = oldInsert;
return(target->properties);
error:
ctxt->insert = oldInsert;
return(NULL);
}
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;
}
/*
* Add the proper XML element for an iCalendar value.
*/
static void icalproperty_add_value_as_xml_element(xmlNodePtr xprop,
icalproperty *prop)
{
const char *type, *str = NULL;
xmlNodePtr xtype;
const icalvalue *value;
char buf[40];
/* Add type */
type = lcase(icalmemory_tmp_copy(
icalproperty_value_kind_as_string(prop)));
xtype = xmlNewChild(xprop, NULL, BAD_CAST type, NULL);
/* Add value */
value = icalproperty_get_value(prop);
switch (icalvalue_isa(value)) {
case ICAL_DATE_VALUE:
str = icaltime_as_iso_string(icalvalue_get_date(value));
break;
case ICAL_DATETIME_VALUE:
str = icaltime_as_iso_string(icalvalue_get_datetime(value));
break;
case ICAL_DATETIMEPERIOD_VALUE: {
struct icaldatetimeperiodtype dtp =
icalvalue_get_datetimeperiod(value);
if (!icaltime_is_null_time(dtp.time)) {
str = icaltime_as_iso_string(dtp.time);
break;
}
else {
icalperiodtype_add_as_xml_element(xtype, dtp.period);
return;
}
}
case ICAL_GEO_VALUE: {
struct icalgeotype geo = icalvalue_get_geo(value);
snprintf(buf, sizeof(buf), "%f", geo.lat);
xmlNewTextChild(xtype, NULL, BAD_CAST "latitude", BAD_CAST buf);
snprintf(buf, sizeof(buf), "%f", geo.lon);
xmlNewTextChild(xtype, NULL, BAD_CAST "longitude", BAD_CAST buf);
return;
}
case ICAL_PERIOD_VALUE:
icalperiodtype_add_as_xml_element(xtype, icalvalue_get_period(value));
return;
case ICAL_RECUR_VALUE: {
struct icalrecurrencetype recur = icalvalue_get_recur(value);
icalrecurrencetype_add_as_xxx(&recur, xtype, NULL,
&icalrecur_add_string_as_xml_element);
return;
}
case ICAL_REQUESTSTATUS_VALUE: {
struct icalreqstattype stat = icalvalue_get_requeststatus(value);
if (!stat.desc) stat.desc = icalenum_reqstat_desc(stat.code);
snprintf(buf, sizeof(buf), "%u.%u",
icalenum_reqstat_major(stat.code),
icalenum_reqstat_minor(stat.code));
xmlNewTextChild(xtype, NULL, BAD_CAST "code", BAD_CAST buf);
xmlNewTextChild(xtype, NULL, BAD_CAST "description", BAD_CAST stat.desc);
if (stat.debug)
xmlNewTextChild(xtype, NULL, BAD_CAST "data", BAD_CAST stat.debug);
return;
}
case ICAL_TRIGGER_VALUE: {
struct icaltriggertype trig = icalvalue_get_trigger(value);
if (!icaltime_is_null_time(trig.time))
str = icaltime_as_iso_string(trig.time);
else
str = icaldurationtype_as_ical_string(trig.duration);
break;
}
case ICAL_UTCOFFSET_VALUE:
str = icalvalue_utcoffset_as_iso_string(value);
break;
default:
str = icalvalue_as_ical_string(value);
switch (icalproperty_isa(prop)) {
case ICAL_CATEGORIES_PROPERTY:
case ICAL_RESOURCES_PROPERTY:
case ICAL_POLLPROPERTIES_PROPERTY:
if (strchr(str, ',')) {
/* Handle multi-valued properties */
tok_t tok;
tok_init(&tok, str, ",", TOK_TRIMLEFT|TOK_TRIMRIGHT|TOK_EMPTY);
str = tok_next(&tok);
xmlAddChild(xtype, xmlNewText(BAD_CAST str));
while ((str = tok_next(&tok))) {
if (*str) {
xtype = xmlNewChild(xprop, NULL, BAD_CAST type, NULL);
xmlAddChild(xtype, xmlNewText(BAD_CAST str));
}
}
tok_fini(&tok);
return;
}
default:
break;
}
break;
}
if (str) xmlAddChild(xtype, xmlNewText(BAD_CAST str));
}
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;
}
static gboolean xspf_playlist_save (const gchar * filename, VFSFile * file,
const gchar * title, Index * filenames, Index * tuples)
{
gint entries = index_count (filenames);
xmlDocPtr doc;
xmlNodePtr rootnode, tracklist;
gint count;
doc = xmlNewDoc((xmlChar *)"1.0");
doc->charset = XML_CHAR_ENCODING_UTF8;
doc->encoding = xmlStrdup((xmlChar *)"UTF-8");
rootnode = xmlNewNode(NULL, (xmlChar *)XSPF_ROOT_NODE_NAME);
xmlSetProp(rootnode, (xmlChar *)"version", (xmlChar *)"1");
xmlSetProp(rootnode, (xmlChar *)"xmlns", (xmlChar *)XSPF_XMLNS);
/* common */
xmlDocSetRootElement(doc, rootnode);
if (title)
xspf_add_node (rootnode, TUPLE_STRING, FALSE, "title", title, 0);
tracklist = xmlNewNode(NULL, (xmlChar *)"trackList");
xmlAddChild(rootnode, tracklist);
for (count = 0; count < entries; count ++)
{
const gchar * filename = index_get (filenames, count);
const Tuple * tuple = index_get (tuples, count);
xmlNodePtr track, location;
gchar *scratch = NULL;
gint scratchi = 0;
track = xmlNewNode(NULL, (xmlChar *)"track");
location = xmlNewNode(NULL, (xmlChar *)"location");
xmlAddChild(location, xmlNewText((xmlChar *)filename));
xmlAddChild(track, location);
xmlAddChild(tracklist, track);
if (tuple != NULL)
{
gint i;
for (i = 0; i < xspf_nentries; i++) {
const xspf_entry_t *xs = &xspf_entries[i];
gboolean isOK = (tuple_get_value_type (tuple, xs->tupleField,
NULL) == xs->type);
switch (xs->type) {
case TUPLE_STRING:
scratch = tuple_get_str (tuple, xs->tupleField, NULL);
if (! scratch)
isOK = FALSE;
str_unref(scratch);
break;
case TUPLE_INT:
scratchi = tuple_get_int (tuple, xs->tupleField, NULL);
break;
default:
break;
}
if (isOK)
xspf_add_node(track, xs->type, xs->isMeta, xs->xspfName, scratch, scratchi);
}
}
}
xmlSaveCtxt * save = xmlSaveToIO (write_cb, close_cb, file, NULL,
XML_SAVE_FORMAT);
if (! save)
goto ERR;
if (xmlSaveDoc (save, doc) < 0 || xmlSaveClose (save) < 0)
goto ERR;
xmlFreeDoc(doc);
return TRUE;
ERR:
xmlFreeDoc (doc);
return FALSE;
}
