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