ini.c 4.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270
  1. /** @file ini.c
  2. * @brief Functions for working with INI files.
  3. */
  4. #include <stdlib.h>
  5. #include <stdio.h>
  6. #include <string.h>
  7. #include <assert.h>
  8. #include <ctype.h>
  9. #include "private.h"
  10. #include "faux/faux.h"
  11. #include "faux/str.h"
  12. #include "faux/ini.h"
  13. faux_ini_t *faux_ini_new(void) {
  14. faux_ini_t *ini;
  15. ini = faux_zmalloc(sizeof(*ini));
  16. if (!ini)
  17. return NULL;
  18. // Init
  19. ini->list = faux_list_new(faux_pair_compare, faux_pair_free);
  20. return ini;
  21. }
  22. void faux_ini_free(faux_ini_t *ini) {
  23. assert(ini);
  24. if (!ini)
  25. return;
  26. faux_list_free(ini->list);
  27. faux_free(ini);
  28. }
  29. static int faux_ini_del(faux_ini_t *ini, faux_ini_node_t *node) {
  30. }
  31. faux_pair_t *faux_ini_set(faux_ini_t *ini, const char *name, const char *value) {
  32. faux_pair_t *pair = NULL;
  33. faux_list_node_t *node = NULL;
  34. faux_pair_t *found_pair = NULL;
  35. assert(ini);
  36. if (!ini)
  37. return NULL;
  38. pair = faux_pair_new(name, value);
  39. if (!pair)
  40. return NULL;
  41. node = faux_list_add_find(ini->list, pair);
  42. if (NULL == node) { // Something went wrong
  43. faux_pair_free(pair);
  44. return NULL;
  45. }
  46. found_pair = faux_list_data(node);
  47. if (found_pair != pair) { // Item already exists
  48. faux_pair_free(pair);
  49. faux_pair_set_value(found_pair, value); // Replace value by new one
  50. return found_pair;
  51. }
  52. return pair;
  53. }
  54. faux_pair_t *faux_ini_unset(faux_ini_t *ini, const char *name) {
  55. return faux_ini_set(ini, name, NULL);
  56. }
  57. /* Find pair by name */
  58. faux_pair_t *faux_ini_find_pair(const faux_ini_t *ini, const char *name) {
  59. faux_list_node_t *iter = NULL;
  60. faux_pair_t *pair = NULL;
  61. assert(ini);
  62. assert(name);
  63. if (!ini || !name)
  64. return NULL;
  65. pair = faux_pair_new(name, NULL);
  66. if (!pair)
  67. return NULL;
  68. iter = faux_list_find_node(ini->list, faux_pair_compare, pair);
  69. faux_pair_free(pair);
  70. return faux_list_data(iter);
  71. }
  72. /* Find value by name */
  73. const char *faux_ini_find(const faux_ini_t *ini, const char *name) {
  74. faux_pair_t *pair = faux_ini_find_pair(ini, name);
  75. if (!pair)
  76. return NULL;
  77. return faux_pair_value(pair);
  78. }
  79. int faux_ini_parse_str(faux_ini_t *ini, const char *string) {
  80. char *buffer = NULL;
  81. char *saveptr = NULL;
  82. char *line = NULL;
  83. assert(ini);
  84. if (!ini)
  85. return -1;
  86. if (!string)
  87. return 0;
  88. buffer = faux_str_dup(string);
  89. // Now loop though each line
  90. for (line = strtok_r(buffer, "\n", &saveptr);
  91. line; line = strtok_r(NULL, "\n", &saveptr)) {
  92. char *str = NULL;
  93. char *name = NULL;
  94. char *value = NULL;
  95. char *savestr = NULL;
  96. char *ns = line;
  97. const char *begin = NULL;
  98. size_t len = 0;
  99. size_t offset = 0;
  100. size_t quoted = 0;
  101. char *rname = NULL;
  102. char *rvalue = NULL;
  103. if (!*ns) // Empty
  104. continue;
  105. while (*ns && isspace(*ns))
  106. ns++;
  107. if ('#' == *ns) // Comment
  108. continue;
  109. if ('=' == *ns) // Broken string
  110. continue;
  111. str = faux_str_dup(ns);
  112. name = strtok_r(str, "=", &savestr);
  113. if (!name) {
  114. faux_str_free(str);
  115. continue;
  116. }
  117. value = strtok_r(NULL, "=", &savestr);
  118. begin = faux_str_nextword(name, &len, &offset, &quoted);
  119. rname = faux_str_dupn(begin, len);
  120. if (!value) { // Empty value
  121. rvalue = NULL;
  122. } else {
  123. begin = faux_str_nextword(value, &len, &offset, &quoted);
  124. rvalue = faux_str_dupn(begin, len);
  125. }
  126. faux_ini_set(ini, rname, rvalue);
  127. faux_str_free(rname);
  128. faux_str_free(rvalue);
  129. faux_str_free(str);
  130. }
  131. faux_str_free(buffer);
  132. return 0;
  133. }
  134. int faux_ini_parse_file(faux_ini_t *ini, const char *fn) {
  135. int ret = -1;
  136. FILE *f = NULL;
  137. char *buf = NULL;
  138. unsigned int p = 0;
  139. const int chunk_size = 128;
  140. int size = chunk_size;
  141. assert(ini);
  142. assert(fn);
  143. if (!ini)
  144. return -1;
  145. if (!fn || !*fn)
  146. return -1;
  147. f = fopen(fn, "r");
  148. if (!f)
  149. return -1;
  150. buf = faux_zmalloc(size);
  151. while (fgets(buf + p, size - p, f)) {
  152. char *tmp = NULL;
  153. if (feof(f) || strchr(buf + p, '\n') || strchr(buf + p, '\r')) {
  154. faux_ini_parse_str(ini, buf);
  155. p = 0;
  156. continue;
  157. }
  158. p = size - 1;
  159. size += chunk_size;
  160. tmp = realloc(buf, size);
  161. if (!tmp)
  162. goto error;
  163. buf = tmp;
  164. }
  165. ret = 0;
  166. error:
  167. faux_free(buf);
  168. fclose(f);
  169. return ret;
  170. }
  171. faux_ini_node_t *faux_ini_head(const faux_ini_t *ini) {
  172. assert(ini);
  173. if (!ini)
  174. return NULL;
  175. return faux_list_head(ini->list);
  176. }
  177. faux_ini_node_t *faux_ini_tail(const faux_ini_t *ini) {
  178. assert(ini);
  179. if (!ini)
  180. return NULL;
  181. return faux_list_tail(ini->list);
  182. }
  183. faux_ini_node_t *faux_ini_next(const faux_ini_node_t *node) {
  184. assert(node);
  185. if (!node)
  186. return NULL;
  187. return faux_list_next_node(node);
  188. }
  189. faux_ini_node_t *faux_ini_prev(const faux_ini_node_t *node) {
  190. assert(node);
  191. if (!node)
  192. return NULL;
  193. return faux_list_prev_node(node);
  194. }
  195. faux_pair_t *faux_ini_data(const faux_ini_node_t *node) {
  196. assert(node);
  197. if (!node)
  198. return NULL;
  199. return (faux_pair_t *)faux_list_data(node);
  200. }