开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 浏览器 > 查看源码
xml.c
资源名称：Client.rar　[点击查看]
上传用户：szjkjd
上传日期：2022-06-27
资源大小：8968k
文件大小：11k
源码类别：

浏览器

开发平台：

Visual C++

xml.c：源码内容
  1. #include <stdlib.h>
  2. #include <stdarg.h>
  3. #include <memory.h>
  4. #include <errno.h>
  5. #include <string.h>
  6. #include <libxml/xmlsave.h>
  7. #include "xml.h"
  9. TXML *xml_create(const char *filename, const char *encoding, const char *root)
  10. {
  11.         TXML *xml;
  12.         int saveno;
  13.         xmlNodePtr root_node;
  15.         if (!(xml = (TXML *)malloc(sizeof(TXML))))
  16.         {
  17.                 return NULL;
  18.         }
  19.         memset(xml, 0, sizeof(TXML));
  20.         xmlKeepBlanksDefault(0);
  22.         if (!(xml->doc = xmlNewDoc(BAD_CAST("1.0"))))
  23.         {
  24.                 saveno = errno;
  25.                 free(xml);
  26.                 errno = saveno;
  27.                 return NULL;
  28.         }
  30.         xml->encoding = strdup(encoding);
  31.         xml->filename = filename ? strdup(filename) : NULL;
  32.         root_node = xmlNewNode(NULL, BAD_CAST(root));
  33.         xmlDocSetRootElement(xml->doc, root_node);
  34.         FIFO_INIT(&xml->rubbish);
  35.         return xml;
  36. }
  38. TXML *xml_create_file(const char *filename)
  39. {
  40.         TXML *xml;
  41.         int saveno;
  43.         if (!filename)
  44.         {
  45.                 errno = EINVAL;
  46.                 return NULL;
  47.         }
  48.         if (!(xml = (TXML *)malloc(sizeof(TXML))))
  49.         {
  50.                 return NULL;
  51.         }
  52.         memset(xml, 0, sizeof(TXML));
  53.         xmlKeepBlanksDefault(0);
  54.         if (!(xml->doc = xmlParseFile(filename)))
  55.         {
  56.                 saveno = errno;
  57.                 free(xml);
  58.                 errno = saveno;
  59.                 return NULL;
  60.         }
  61.         xml->filename = strdup(filename);
  62.         FIFO_INIT(&xml->rubbish);
  63.         return xml;
  64. }
  66. TXML *xml_create_memory(const char *buffer, size_t size)
  67. {
  68.         TXML *xml;
  69.         int saveno;
  71.         if (!(buffer && size))
  72.         {
  73.                 errno = EINVAL;
  74.                 return NULL;
  75.         }
  76.         if (!(xml = (TXML *)malloc(sizeof(TXML))))
  77.         {
  78.                 return NULL;
  79.         }
  80.         memset(xml, 0, sizeof(TXML));
  81.         xmlKeepBlanksDefault(0);
  82.         if (!(xml->doc = xmlParseMemory(buffer, size)))
  83.         {
  84.                 saveno = errno;
  85.                 free(xml);
  86.                 errno = saveno;
  87.                 return NULL;
  88.         }
  89.         FIFO_INIT(&xml->rubbish);
  90.         return xml;
  91. }
  93. void xml_cleanup(TXML *xml)
  94. {
  95.         TXMLStr *res;
  97. #ifndef WIN32
  98.         while (FIFO_POP(&xml->rubbish, res, node))
  99.         {
  100.                 if (res->str)
  101.                 {
  102.                         xmlFree((xmlChar *)res->str);
  103.                 }
  104.                 free(res);
  105.         }
  106. #else
  107. FIFO_POP(&xml->rubbish, res, node);
  108. while (res)
  109. {
  110.                 if (res->str)
  111.                 {
  112.                         xmlFree((xmlChar *)res->str);
  113.                 }
  114.                 free(res);
  115. FIFO_POP(&xml->rubbish, res, node);
  116. }
  117. #endif
  118.         return;
  119. }
  121. void xml_close(TXML *xml)
  122. {
  123.         if (xml)
  124.         {
  125.                 xml_cleanup(xml);
  126.                 if (xml->object)
  127.                 {
  128.                         xmlXPathFreeObject(xml->object);
  129.                 }
  130.                 if (xml->doc)
  131.                 {
  132.                         xmlFreeDoc(xml->doc);
  133.                         xmlCleanupParser();
  134.                 }
  135.                 if (xml->encoding)
  136.                 {
  137.                         free(xml->encoding);
  138.                 }
  139.                 if (xml->filename)
  140.                 {
  141.                         free(xml->filename);
  142.                 }
  143.                 free(xml);
  144.         }
  145.         return;
  146. }
  148. int xml_save_to(TXML *xml, const char *filename)
  149. {
  150.         char *encoding = xml->encoding ? xml->encoding : (char *)xml->doc->encoding;
  151.         return xmlSaveFormatFileEnc(filename, xml->doc, encoding, XML_SAVE_FORMAT) ? -1 : 0;
  152. }
  154. int xml_save(TXML *xml)
  155. {
  156.         char *encoding;
  158.         if (!xml->filename)
  159.         {
  160.                 errno = EINVAL;
  161.                 return -1;
  162.         }
  163.         encoding = xml->encoding ? xml->encoding : (char *)xml->doc->encoding;
  164.         return xmlSaveFormatFileEnc(xml->filename, xml->doc, encoding, XML_SAVE_FORMAT) ? -1 : 0;
  165. }
  167. int xml_save_close(TXML *xml)
  168. {
  169.         int ret;
  170.         int saveno;
  172.         ret = xml_save(xml);
  173.         saveno = errno;
  174.         xml_close(xml);
  175.         errno = saveno;
  176.         return ret;
  177. }
  179. int xml_select_nodes(TXML *xml, const char *xpath)
  180. {
  181.         xmlXPathContextPtr context;
  183.         if(!xml || !xpath)
  184.         {
  185.                 errno = EINVAL;
  186.                 return -1;
  187.         }
  189.         if (!(context = xmlXPathNewContext(xml->doc)))
  190.         {
  191.                 return -1;
  192.         }
  193.         if (xml->object)
  194.         {
  195.                 xmlXPathFreeObject(xml->object);
  196.         }
  197.         if (!(xml->object = xmlXPathEvalExpression(BAD_CAST(xpath), context)))
  198.         {
  199.                 goto err_context;
  200.         }
  201.         if (xmlXPathNodeSetIsEmpty(xml->object->nodesetval))
  202.         {
  203.                 goto err_object;
  204.         }
  206.         xmlXPathFreeContext(context);
  207.         return xml->object->nodesetval->nodeNr > 0 ? xml->object->nodesetval->nodeNr : 0;
  209. err_object:
  210.         xmlXPathFreeObject(xml->object);
  211.         xml->object = NULL;
  212. err_context:
  213.         xmlXPathFreeContext(context);
  214.         return 0;
  215. }
  217. char *xml_read_set_prop(TXML *xml, const int n, const char *name)
  218. {
  219.         TXMLStr *res;
  221.         if (!(xml && xml->object))
  222.         {
  223.                 errno = EINVAL;
  224.                 return NULL;
  225.         }
  226.         if (xmlXPathNodeSetIsEmpty(xml->object->nodesetval))
  227.         {
  228.                 errno = EINVAL;
  229.                 return NULL;
  230.         }
  231.         if (xml->object->nodesetval->nodeNr < n)
  232.         {
  233.                 errno = EINVAL;
  234.                 return NULL;
  235.         }
  236.         if (!xmlHasProp(xml->object->nodesetval->nodeTab[n], BAD_CAST(name)))
  237.         {
  238.                 errno = EINVAL;
  239.                 return NULL;
  240.         }
  241.         if (!(res = (TXMLStr *)malloc(sizeof(TXMLStr))))
  242.         {
  243.                 return NULL;
  244.         }
  245.         res->str = (char *)xmlGetProp(xml->object->nodesetval->nodeTab[n], BAD_CAST(name));
  246.         FIFO_PUSH(&xml->rubbish, res, node);
  247.         return res->str;
  248. }
  250. char *xml_read_set_content(TXML *xml, const int n)
  251. {
  252.         TXMLStr *res;
  254.         if (!(xml && xml->object))
  255.         {
  256.                 errno = EINVAL;
  257.                 return NULL;
  258.         }
  259.         if (xmlXPathNodeSetIsEmpty(xml->object->nodesetval))
  260.         {
  261.                 errno = EINVAL;
  262.                 return NULL;
  263.         }
  264.         if (xml->object->nodesetval->nodeNr < n)
  265.         {
  266.                 errno = EINVAL;
  267.                 return NULL;
  268.         }
  269.         if (!(res = (TXMLStr *)malloc(sizeof(TXMLStr))))
  270.         {
  271.                 return NULL;
  272.         }
  273.         res->str = (char *)xmlNodeGetContent(xml->object->nodesetval->nodeTab[n]);
  274.         FIFO_PUSH(&xml->rubbish, res, node);
  275.         return res->str;
  276. }
  278. int xml_write_set_prop(TXML *xml, const int n, const char *name, const char *value)
  279. {
  280.         if (!(xml && xml->object))
  281.         {
  282.                 errno = EINVAL;
  283.                 return -1;
  284.         }
  285.         if (xmlXPathNodeSetIsEmpty(xml->object->nodesetval))
  286.         {
  287.                 errno = EINVAL;
  288.                 return -1;
  289.         }
  290.         if (xml->object->nodesetval->nodeNr < n)
  291.         {
  292.                 errno = EINVAL;
  293.                 return -1;
  294.         }
  295.         if (!xmlHasProp(xml->object->nodesetval->nodeTab[n], BAD_CAST(name)))
  296.         {
  297.                 errno = EINVAL;
  298.                 return -1;
  299.         }
  300.         xmlSetProp(xml->object->nodesetval->nodeTab[n], BAD_CAST(name), BAD_CAST(value));
  301.         return 0;
  302. }
  304. int xml_write_set_content(TXML *xml, const int n, const char *value)
  305. {
  306.         if (!(xml && xml->object))
  307.         {
  308.                 errno = EINVAL;
  309.                 return -1;
  310.         }
  311.         if (xmlXPathNodeSetIsEmpty(xml->object->nodesetval))
  312.         {
  313.                 errno = EINVAL;
  314.                 return -1;
  315.         }
  316.         if (xml->object->nodesetval->nodeNr < n)
  317.         {
  318.                 errno = EINVAL;
  319.                 return -1;
  320.         }
  321.         xmlNodeSetContent(xml->object->nodesetval->nodeTab[n], BAD_CAST(value));
  322.         return 0;
  323. }
  325. char *xml_read_item_prop(TXML *xml, const char *xpath, const char *name)
  326. {
  327.         return xml_select_nodes(xml, xpath) > 0 ? xml_read_set_prop(xml, 0, name) : NULL;
  328. }
  330. char *xml_read_item_content(TXML *xml, const char *xpath)
  331. {
  332.         return xml_select_nodes(xml, xpath) > 0 ? xml_read_set_content(xml, 0) : NULL;
  333. }
  335. int xml_write_item_prop(TXML *xml, const char *xpath, const char *name, const char *value)
  336. {
  337.         return xml_select_nodes(xml, xpath) > 0 ? xml_write_set_prop(xml, 0, name, value) : -1;
  338. }
  340. int xml_write_item_content(TXML *xml, const char *xpath, const char *value)
  341. {
  342.         return xml_select_nodes(xml, xpath) > 0 ? xml_write_set_content(xml, 0, value) : -1;
  343. }
  344. static int xml_add_node(xmlNodePtr (*add)(xmlNodePtr, xmlNodePtr), TXML *xml, const char *xpath,
  345.                 const char *node_name, va_list ap)
  346. {
  347.         xmlNodePtr node;
  348.         char *str = NULL, *name = NULL;
  350.         if (xml_select_nodes(xml, xpath) != 1)
  351.         {
  352.                 return -1;
  353.         }
  355.         node = xmlNewNode(NULL, BAD_CAST(node_name));
  356.         while ((str = va_arg(ap, char *)))
  357.         {
  358.                 if (!name)
  359.                 {
  360.                         name = str;
  361.                 }
  362.                 else
  363.                 {
  364.                         xmlSetProp(node, BAD_CAST(name), BAD_CAST(str));
  365.                         name = NULL;
  366.                 }
  367.         }
  368.         if (name)
  369.         {
  370.                 xmlNodeSetContent(node, BAD_CAST(name));
  371.         }
  372.         return add(xml->object->nodesetval->nodeTab[0], node) ? 0 : -1;
  373. }
  375. int xml_add_child(TXML *xml, const char *xpath, const char *name, ...)
  376. {
  377.         int ret;
  378.         va_list ap;
  380.         va_start(ap, name);
  381.         ret = xml_add_node(xmlAddChild, xml, xpath, name, ap);
  382.         va_end(ap);
  383.         return ret;
  384. }
  386. int xml_add_prev_sibling(TXML *xml, const char *xpath, const char *name, ...)
  387. {
  388.         int ret;
  389.         va_list ap;
  391.         va_start(ap, name);
  392.         ret = xml_add_node(xmlAddPrevSibling, xml, xpath, name, ap);
  393.         va_end(ap);
  394.         return ret;
  395. }
  397. int xml_add_next_sibling(TXML *xml, const char *xpath, const char *name, ...)
  398. {
  399.         int ret;
  400.         va_list ap;
  402.         va_start(ap, name);
  403.         ret = xml_add_node(xmlAddNextSibling, xml, xpath, name, ap);
  404.         va_end(ap);
  405.         return ret;
  406. }
  408. int xml_add_sibling(TXML *xml, const char *xpath, const char *name, ...)
  409. {
  410.         int ret;
  411.         va_list ap;
  413.         va_start(ap, name);
  414.         ret = xml_add_node(xmlAddSibling, xml, xpath, name, ap);
  415.         va_end(ap);
  416.         return ret;
  417. }
  419. int xml_remove(TXML *xml, const char *xpath)
  420. {
  421.         int i, n;
  422.         xmlNodePtr tempNode, curNode;
  424.         if ((n = xml_select_nodes(xml, xpath)) <= 0)
  425.         {
  426.                 return -1;
  427.         }
  428.         for (i = 0; i < n; ++i)
  429.         {
  430.                 curNode = xml->object->nodesetval->nodeTab[i];
  431.                 tempNode = curNode->next;
  432.                 xmlUnlinkNode(curNode);
  433.                 xmlFreeNode(curNode);
  434.                 curNode = tempNode;
  435.         }
  436.         if (xml->object)
  437.         {
  438.                 xmlXPathFreeObject(xml->object);
  439.                 xml->object = NULL;
  440.         }
  441.         return 0;
  442. }
  444. // vim: ts=8 sw=8 expandtab