Simple XML subset parser comparable to glib's Markup parser, but without any dependencies in one self contained file. Forked from https://github.com/ooxi/xml.c
No puede seleccionar más de 25 temas Los temas deben comenzar con una letra o número, pueden incluir guiones ('-') y pueden tener hasta 35 caracteres de largo.

154 líneas
4.5 KiB

  1. /**
  2. * Copyright (c) 2012 ooxi/xml.c
  3. * https://github.com/ooxi/xml.c
  4. *
  5. * This software is provided 'as-is', without any express or implied warranty.
  6. * In no event will the authors be held liable for any damages arising from the
  7. * use of this software.
  8. *
  9. * Permission is granted to anyone to use this software for any purpose,
  10. * including commercial applications, and to alter it and redistribute it
  11. * freely, subject to the following restrictions:
  12. *
  13. * 1. The origin of this software must not be misrepresented; you must not
  14. * claim that you wrote the original software. If you use this software in a
  15. * product, an acknowledgment in the product documentation would be
  16. * appreciated but is not required.
  17. *
  18. * 2. Altered source versions must be plainly marked as such, and must not be
  19. * misrepresented as being the original software.
  20. *
  21. * 3. This notice may not be removed or altered from any source distribution.
  22. */
  23. #include <stdbool.h>
  24. #include <stdio.h>
  25. #include <stdlib.h>
  26. #include <xml.h>
  27. /**
  28. * Will halt the program iff assertion fails
  29. */
  30. static void _assert_that(_Bool condition, char const* message, char const* func, char const* file, int line) {
  31. if (!condition) {
  32. fprintf(stderr, "Assertion failed: %s, in %s (%s:%i)\n", message, func, file, line);
  33. exit(EXIT_FAILURE);
  34. }
  35. }
  36. #define assert_that(condition, message) \
  37. _assert_that(condition, message, __func__, __FILE__, __LINE__)
  38. /**
  39. * @return true iff xml string equals the c string
  40. */
  41. static _Bool string_equals(struct xml_string* a, char const* b) {
  42. size_t a_length = xml_string_length(a);
  43. size_t b_length = strlen(b);
  44. uint8_t* a_buffer = alloca((a_length + 1) * sizeof(uint8_t));
  45. xml_string_copy(a, a_buffer, a_length);
  46. a_buffer[a_length] = 0;
  47. if (a_length != b_length) {
  48. fprintf(stderr, "string_equals: %s#%i <> %s#%i\n", a_buffer, (int)a_length, b, (int)b_length);
  49. return false;
  50. }
  51. size_t i = 0; for (; i < a_length; ++i) {
  52. if (a_buffer[i] != b[i]) {
  53. fprintf(stderr, "string_equals: %s <> %s\n", a_buffer, b);
  54. return false;
  55. }
  56. }
  57. return true;
  58. }
  59. /**
  60. * Converts a static character array to an uint8_t data source
  61. */
  62. #define SOURCE(source, content) \
  63. uint8_t* source = alloca(strlen(content) * sizeof(uint8_t)); \
  64. { size_t i = 0; for (; i < strlen(content); ++i) { \
  65. source[i] = content[i]; \
  66. } \
  67. }
  68. /**
  69. * Tries to parse a simple document containing only one tag
  70. */
  71. static void test_xml_parse_document_0() {
  72. SOURCE(source, "<Hello>World</Hello>");
  73. struct xml_document* document = xml_parse_document(source, strlen(source));
  74. assert_that(document, "Could not parse document");
  75. struct xml_node* root = xml_document_root(document);
  76. assert_that(string_equals(xml_node_name(root), "Hello"), "root node name must be `Hello'");
  77. assert_that(string_equals(xml_node_content(root), "World"), "root node content must be `World'");
  78. xml_document_free(document, false);
  79. }
  80. /**
  81. * Tries to parse a document containing multiple tags
  82. */
  83. static void test_xml_parse_document_1() {
  84. SOURCE(source, ""
  85. "<Parent>\n"
  86. "\t<Child>\n"
  87. "\t\tFirst content\n"
  88. "\t</Child>\n"
  89. "\t<Child>\n"
  90. "\t\tSecond content\n"
  91. "\t</Child>\n"
  92. "</Parent>\n"
  93. );
  94. struct xml_document* document = xml_parse_document(source, strlen(source));
  95. assert_that(document, "Could not parse document");
  96. struct xml_node* root = xml_document_root(document);
  97. assert_that(string_equals(xml_node_name(root), "Parent"), "root node name must be `Parent'");
  98. assert_that(2 == xml_node_children(root), "root must have two children");
  99. struct xml_node* first_child = xml_node_child(root, 0);
  100. struct xml_node* second_child = xml_node_child(root, 1);
  101. assert_that(first_child && second_child, "Failed retrieving the children of root");
  102. struct xml_node* third_child = xml_node_child(root, 2);
  103. assert_that(!third_child, "root has a third child where non should be");
  104. assert_that(string_equals(xml_node_name(first_child), "Child"), "first_child node name must be `Child'");
  105. assert_that(string_equals(xml_node_content(first_child), "First content"), "first_child node content must be `First content'");
  106. assert_that(string_equals(xml_node_name(second_child), "Child"), "second_child node name must be `Child'");
  107. assert_that(string_equals(xml_node_content(second_child), "Second content"), "second_child node content must be `tSecond content'");
  108. xml_document_free(document, false);
  109. }
  110. /**
  111. * Console interface
  112. */
  113. int main(int argc, char** argv) {
  114. test_xml_parse_document_0();
  115. test_xml_parse_document_1();
  116. fprintf(stdout, "All tests passed :-)\n");
  117. exit(EXIT_SUCCESS);
  118. }