/**
* xsltUnparsedEntityURIFunction:
* @ctxt: the XPath Parser context
* @nargs: the number of arguments
*
* Implement the unparsed-entity-uri() XSLT function
* string unparsed-entity-uri(string)
*/
void
xsltUnparsedEntityURIFunction(xmlXPathParserContextPtr ctxt, int nargs){
xmlXPathObjectPtr obj;
xmlChar *str;
if ((nargs != 1) || (ctxt->value == NULL)) {
xsltGenericError(xsltGenericErrorContext,
"unparsed-entity-uri() : expects one string arg\n");
ctxt->error = XPATH_INVALID_ARITY;
return;
}
obj = valuePop(ctxt);
if (obj->type != XPATH_STRING) {
obj = xmlXPathConvertString(obj);
}
str = obj->stringval;
if (str == NULL) {
valuePush(ctxt, xmlXPathNewString((const xmlChar *)""));
} else {
xmlEntityPtr entity;
entity = xmlGetDocEntity(ctxt->context->doc, str);
if (entity == NULL) {
valuePush(ctxt, xmlXPathNewString((const xmlChar *)""));
} else {
if (entity->URI != NULL)
valuePush(ctxt, xmlXPathNewString(entity->URI));
else
valuePush(ctxt, xmlXPathNewString((const xmlChar *)""));
}
}
xmlXPathFreeObject(obj);
}
bool gpl::xml::getEntityValue(const std::string& entName, std::map<std::string, std::string>& props)
{
xmlEntityPtr ent;
if (m_xml->doc == 0)
return false;
std::string str;
//debug output
//xmlDebugDumpEntities(stdout,m_xml->doc);
//end debug
ent = xmlGetDocEntity(m_xml->doc, (const xmlChar*)entName.c_str());
if (ent != NULL)
{
props.clear();
#ifdef WIN32
this->ltoa((long)ent->etype, str);
#else
char buff[100];
str = ltoa((long)ent->etype, buff, 100);
#endif
props.insert(std::map<std::string, std::string>::value_type(std::string("ETYPE"), str));
str = m_xml->getStringByXmlCharPtr((xmlChar*)ent->ExternalID);
props.insert(std::map<std::string, std::string>::value_type(std::string("ID"), str));
str = m_xml->getStringByXmlCharPtr((xmlChar*)ent->SystemID);
props.insert(std::map<std::string, std::string>::value_type(std::string("SYSTEM"), str));
str = m_xml->getStringByXmlCharPtr((xmlChar*)ent->orig);
props.insert(std::map<std::string, std::string>::value_type(std::string("ORIG"), str));
str = m_xml->getStringByXmlCharPtr((xmlChar*)ent->content);
props.insert(std::map<std::string, std::string>::value_type(std::string("CONTENT"), str));
}
else
return false;
return true;
}
static xmlEntityPtr
_get_entity(void *user, const xmlChar *name)
{
XML_Parser parser = (XML_Parser) user;
xmlEntityPtr ret = NULL;
if (parser->parser->inSubset == 0) {
ret = xmlGetPredefinedEntity(name);
if (ret == NULL)
ret = xmlGetDocEntity(parser->parser->myDoc, name);
if (ret == NULL || (parser->parser->instate != XML_PARSER_ENTITY_VALUE && parser->parser->instate != XML_PARSER_ATTRIBUTE_VALUE)) {
if (ret == NULL || ret->etype == XML_INTERNAL_GENERAL_ENTITY || ret->etype == XML_INTERNAL_PARAMETER_ENTITY || ret->etype == XML_INTERNAL_PREDEFINED_ENTITY) {
/* Predefined entities will expand unless no cdata handler is present */
if (parser->h_default && ! (ret && ret->etype == XML_INTERNAL_PREDEFINED_ENTITY && parser->h_cdata)) {
xmlChar *entity;
int len;
_build_entity(name, xmlStrlen(name), &entity, &len);
parser->h_default(parser->user, (const xmlChar *) entity, len);
xmlFree(entity);
} else {
/* expat will not expand internal entities if default handler is present otherwise
it will expand and pass them to cdata handler */
if (parser->h_cdata && ret) {
parser->h_cdata(parser->user, ret->content, xmlStrlen(ret->content));
}
}
} else {
if (ret->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY) {
_external_entity_ref_handler(user, ret->name, ret->etype, ret->SystemID, ret->ExternalID, NULL);
}
}
}
}
return ret;
}
static xmlEntityPtr
xml_process_entities (void *ctxt, const xmlChar *name)
{
gchar *path;
xmlEntityPtr entity;
xmlEntityPtr found;
xmlChar *tmp;
static xmlDocPtr entities = NULL;
entity = xmlGetPredefinedEntity (name);
if (!entity) {
if (!entities) {
/* loading HTML entities from external DTD file */
entities = xmlNewDoc (BAD_CAST "1.0");
path = g_build_filename (g_get_user_data_dir (), PACKAGE, "/dtd/html.ent", NULL);
xmlCreateIntSubset (entities, BAD_CAST "HTML entities", NULL, BAD_CAST path);
g_free (path);
entities->extSubset = xmlParseDTD (entities->intSubset->ExternalID, entities->intSubset->SystemID);
}
if (NULL != (found = xmlGetDocEntity (entities, name))) {
/* returning as faked predefined entity... */
tmp = xmlStrdup (found->content);
tmp = BAD_CAST unhtmlize ((gchar*) tmp); /* arghh ... slow... */
entity = (xmlEntityPtr) g_new0 (xmlEntity, 1);
entity->type = XML_ENTITY_DECL;
entity->name = name;
entity->orig = NULL;
entity->content = tmp;
entity->length = g_utf8_strlen ((gchar*) tmp, -1);
entity->etype = XML_INTERNAL_PREDEFINED_ENTITY;
}
}
return entity;
}
/*Modified libxml code to avoid truncating text of child elements*/
static xmlChar *
MyxmlNodeGetContent(xmlNodePtr cur) {
if (cur == NULL) return(NULL);
switch (cur->type) {
case XML_DOCUMENT_FRAG_NODE:
case XML_ELEMENT_NODE: {
xmlNodePtr tmp = cur;
xmlBufferPtr buffer;
xmlChar *ret;
buffer = xmlBufferCreate();
if (buffer == NULL)
return(NULL);
while (tmp != NULL) {
switch (tmp->type) {
case XML_CDATA_SECTION_NODE:
case XML_TEXT_NODE:
if (tmp->content != NULL)
#ifndef XML_USE_BUFFER_CONTENT
xmlBufferCat(buffer, tmp->content);
#else
xmlBufferCat(buffer,
xmlBufferContent(tmp->content));
#endif
break;
case XML_ENTITY_REF_NODE: {
xmlEntityPtr ent;
ent = xmlGetDocEntity(cur->doc, tmp->name);
if (ent != NULL)
xmlBufferCat(buffer, ent->content);
}
default:
break;
}
/*
* Skip to next node
*/
if (tmp->children != NULL) {
if (tmp->children->type != XML_ENTITY_DECL && tmp->children->type != XML_ELEMENT_NODE) {
tmp = tmp->children;
continue;
}
}
if (tmp == cur)
break;
if (tmp->next != NULL) {
tmp = tmp->next;
continue;
}
do {
tmp = tmp->parent;
if (tmp == NULL)
break;
if (tmp == cur) {
tmp = NULL;
break;
}
if (tmp->next != NULL) {
tmp = tmp->next;
break;
}
} while (tmp != NULL);
}
ret = buffer->content;
buffer->content = NULL;
xmlBufferFree(buffer);
return(ret);
}
case XML_ATTRIBUTE_NODE: {
xmlAttrPtr attr = (xmlAttrPtr) cur;
if (attr->parent != NULL)
return(xmlNodeListGetString(attr->parent->doc, attr->children, 1));
else
return(xmlNodeListGetString(NULL, attr->children, 1));
break;
}
case XML_COMMENT_NODE:
case XML_PI_NODE:
if (cur->content != NULL)
#ifndef XML_USE_BUFFER_CONTENT
return(xmlStrdup(cur->content));
#else
return(xmlStrdup(xmlBufferContent(cur->content)));
#endif
return(NULL);
case XML_ENTITY_REF_NODE:
/*
* Locate the entity, and get it's content
* @@@
*/
return(NULL);
case XML_ENTITY_NODE:
case XML_DOCUMENT_NODE:
case XML_HTML_DOCUMENT_NODE:
case XML_DOCUMENT_TYPE_NODE:
case XML_NOTATION_NODE:
case XML_DTD_NODE:
case XML_XINCLUDE_START:
case XML_XINCLUDE_END:
#ifdef LIBXML_DOCB_ENABLED
case XML_DOCB_DOCUMENT_NODE:
#endif
return(NULL);
case XML_NAMESPACE_DECL:
return(xmlStrdup(((xmlNsPtr)cur)->href));
case XML_ELEMENT_DECL:
/* UNIMPLEMENTED */
return(NULL);
case XML_ATTRIBUTE_DECL:
/* UNIMPLEMENTED */
return(NULL);
case XML_ENTITY_DECL:
/* UNIMPLEMENTED */
return(NULL);
case XML_CDATA_SECTION_NODE:
case XML_TEXT_NODE:
if (cur->content != NULL)
#ifndef XML_USE_BUFFER_CONTENT
return(xmlStrdup(cur->content));
#else
return(xmlStrdup(xmlBufferContent(cur->content)));
#endif
return(NULL);
}
return(NULL);
}
/**
*dump一个节点到结果集
*@param nodePtr 当前的节点指针
*@param resultSet 返回的结果集,参见XmlApi::getXPathResultSet(multimap<string,string>& resultSet)方法的说明
*@return 成功返回true,否则返回false;
*/
bool gpl::xml::LibXml::getDumpNode(xmlNodePtr nodePtr, std::multimap<std::string, std::string>&resultSet)
{
if (nodePtr == NULL)
return false;
std::string name, value;
switch (nodePtr->type)
{
case XML_ELEMENT_NODE:
name = getStringByXmlCharPtr((xmlChar *)nodePtr->name);
value = getStringByXmlCharPtr(xmlNodeListGetString(doc, nodePtr->xmlChildrenNode, 1), 1);
resultSet.insert(std::multimap<std::string, std::string>::value_type(name, value));
break;
case XML_TEXT_NODE:
case XML_CDATA_SECTION_NODE:
name = getStringByXmlCharPtr((xmlChar *)nodePtr->name);
value = "";
if (nodePtr->content != NULL)
{
if (isOnlyEntityName)
value = getStringByXmlCharPtr(nodePtr->content);
else
{
xmlChar *buffer;
buffer = xmlEncodeEntitiesReentrant(doc, nodePtr->content);
if (buffer != NULL)
{
value = getStringByXmlCharPtr(buffer, 1);
}
}
}
resultSet.insert(std::multimap<std::string, std::string>::value_type(name, value));
break;
case XML_PI_NODE:
case XML_COMMENT_NODE:
name = getStringByXmlCharPtr((xmlChar *)nodePtr->name);
if (nodePtr->content != NULL)
{
value = getStringByXmlCharPtr(nodePtr->content);
}
resultSet.insert(std::multimap<std::string, std::string>::value_type(name, value));
break;
case XML_DOCUMENT_NODE:
case XML_HTML_DOCUMENT_NODE:
resultSet.insert(std::multimap<std::string, std::string>::value_type(std::string("document or html_document"), std::string("/")));
break;
case XML_ATTRIBUTE_NODE:
return getDumpAttribute(reinterpret_cast<xmlAttrPtr>(nodePtr), resultSet);
case XML_ENTITY_REF_NODE:
name = getStringByXmlCharPtr((xmlChar *)nodePtr->name);
value = "";
if (nodePtr->content != NULL)
{
if (isOnlyEntityName)
{
//value = getStringByXmlCharPtr(nodePtr->content);
xmlEntityPtr ent = xmlGetDocEntity(doc, nodePtr->name);
if (ent != NULL)
{
xmlChar *buffer;
/* an entity content can be any "well balanced chunk",
* i.e. the result of the content [43] production:
* http://www.w3.org/TR/REC-xml#NT-content.
* So it can contain text, CDATA section or nested
* entity reference nodes (among others).
* -> we recursive call xmlNodeListGetString()
* which handles these types */
buffer = xmlNodeListGetString(doc, ent->children, 1);
if (buffer != NULL)
{
value = getStringByXmlCharPtr(buffer, 1);
}
}
else
{
value = getStringByXmlCharPtr(nodePtr->content);
}
}
else
{
value = "&" + getStringByXmlCharPtr((xmlChar*)nodePtr->name) + ";";
}
}
resultSet.insert(std::multimap<std::string, std::string>::value_type(name, value));
break;
default:
;
}
return true;
}
void xmlDebugDumpNode(FILE *output, xmlNodePtr node, int depth) {
int i;
char shift[100];
for (i = 0;((i < depth) && (i < 25));i++)
shift[2 * i] = shift[2 * i + 1] = ' ';
shift[2 * i] = shift[2 * i + 1] = 0;
fprintf(output, shift);
switch (node->type) {
case XML_ELEMENT_NODE:
fprintf(output, "ELEMENT ");
if (node->ns != NULL)
fprintf(output, "%s:%s\n", node->ns->prefix, node->name);
else
fprintf(output, "%s\n", node->name);
break;
case XML_ATTRIBUTE_NODE:
fprintf(output, "Error, ATTRIBUTE found here\n");
break;
case XML_TEXT_NODE:
fprintf(output, "TEXT\n");
break;
case XML_CDATA_SECTION_NODE:
fprintf(output, "CDATA_SECTION\n");
break;
case XML_ENTITY_REF_NODE:
fprintf(output, "ENTITY_REF\n");
break;
case XML_ENTITY_NODE:
fprintf(output, "ENTITY\n");
break;
case XML_PI_NODE:
fprintf(output, "PI\n");
break;
case XML_COMMENT_NODE:
fprintf(output, "COMMENT\n");
break;
case XML_DOCUMENT_NODE:
fprintf(output, "Error, DOCUMENT found here\n");
break;
case XML_DOCUMENT_TYPE_NODE:
fprintf(output, "DOCUMENT_TYPE\n");
break;
case XML_DOCUMENT_FRAG_NODE:
fprintf(output, "DOCUMENT_FRAG\n");
break;
case XML_NOTATION_NODE:
fprintf(output, "NOTATION\n");
break;
default:
fprintf(output, "NODE_%d\n", node->type);
}
if (node->doc == NULL) {
fprintf(output, shift);
fprintf(output, "doc == NULL !!!\n");
}
if (node->nsDef != NULL)
xmlDebugDumpNamespaceList(output, node->nsDef, depth + 1);
if (node->properties != NULL)
xmlDebugDumpAttrList(output, node->properties, depth + 1);
if (node->type != XML_ENTITY_REF_NODE) {
if (node->content != NULL) {
fprintf(output, shift);
fprintf(output, "content=");
xmlDebugDumpString(output, node->content);
fprintf(output, "\n");
}
} else {
xmlEntityPtr ent;
ent = xmlGetDocEntity(node->doc, node->name);
if (ent != NULL)
xmlDebugDumpEntity(output, ent, depth + 1);
}
if (node->childs != NULL)
xmlDebugDumpNodeList(output, node->childs, depth + 1);
}
xmlEntityPtr Document::NamedEntity(const string &name) const
{
return xmlGetDocEntity(const_cast<xmlDocPtr>(xml()), name.utf8());
}
