aboutsummaryrefslogtreecommitdiff
path: root/src/ini.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/ini.c')
-rw-r--r--src/ini.c398
1 files changed, 227 insertions, 171 deletions
diff --git a/src/ini.c b/src/ini.c
index e4e734d..f9dba36 100644
--- a/src/ini.c
+++ b/src/ini.c
@@ -1,188 +1,244 @@
-#include "ini.h"
+/* inih -- simple .INI file parser
+
+inih is released under the New BSD license (see LICENSE.txt). Go to the project
+home page for more info:
+
+https://github.com/benhoyt/inih
+
+*/
+
+#if defined(_MSC_VER) && !defined(_CRT_SECURE_NO_WARNINGS)
+#define _CRT_SECURE_NO_WARNINGS
+#endif
+
+#include <stdio.h>
#include <ctype.h>
-#include <stdlib.h>
#include <string.h>
-enum parse_state {
- START,
- READING_KEY,
- SEEKING_EQ,
- SEEKING_VALUE,
- READING_VALUE,
- READING_SECTION_KEY,
- SEEKING_SECTION_VALUE,
- SEEKING_END_SECTION,
- READING_SECTION_VALUE,
- ACCEPT,
- REJECT
-};
-
-int parse_ini_file(FILE* f, char *out_key, size_t key_size, char *out_value, size_t value_size)
+#include "ini.h"
+
+#if !INI_USE_STACK
+#include <stdlib.h>
+#endif
+
+#define MAX_SECTION 50
+#define MAX_NAME 50
+
+/* Used by ini_parse_string() to keep track of string parsing state. */
+typedef struct {
+ const char* ptr;
+ size_t num_left;
+} ini_parse_string_ctx;
+
+/* Strip whitespace chars off end of given string, in place. Return s. */
+static char* rstrip(char* s)
{
- char buf[512];
- while(fgets(&buf[0], sizeof(buf), f)) {
- int type = parse_ini_str(&buf[0], out_key, key_size, out_value, value_size);
- if(type != 0) {
- return type;
+ char* p = s + strlen(s);
+ while (p > s && isspace((unsigned char)(*--p)))
+ *p = '\0';
+ return s;
+}
+
+/* Return pointer to first non-whitespace char in given string. */
+static char* lskip(const char* s)
+{
+ while (*s && isspace((unsigned char)(*s)))
+ s++;
+ return (char*)s;
+}
+
+/* Return pointer to first char (of chars) or inline comment in given string,
+ or pointer to null at end of string if neither found. Inline comment must
+ be prefixed by a whitespace character to register as a comment. */
+static char* find_chars_or_comment(const char* s, const char* chars)
+{
+#if INI_ALLOW_INLINE_COMMENTS
+ int was_space = 0;
+ while (*s && (!chars || !strchr(chars, *s)) &&
+ !(was_space && strchr(INI_INLINE_COMMENT_PREFIXES, *s))) {
+ was_space = isspace((unsigned char)(*s));
+ s++;
+ }
+#else
+ while (*s && (!chars || !strchr(chars, *s))) {
+ s++;
}
- }
- return 0;
+#endif
+ return (char*)s;
}
-int parse_ini_str(const char* str, char *out_key, size_t key_size, char *out_value, size_t value_size)
+/* Version of strncpy that ensures dest (size bytes) is null-terminated. */
+static char* strncpy0(char* dest, const char* src, size_t size)
{
- /* ignore comments */
- if(*str == ';') {
- out_key[0] = 0;
- out_value[0] = 0;
- return INI_UNKNOWN;
- }
-
- const char *key_start = 0;
- size_t key_len = 0;
- const char *value_start = 0;
- size_t value_len = 0;
-
- int type = INI_UNKNOWN;
- enum parse_state state = START;
- char quote = 0;
- char c = 0;
-
- do {
- c = *str;
- switch(state) {
- case START:
- if(c == '[') {
- type = INI_SECTION;
- state = READING_SECTION_KEY;
- } else if(c != '=') {
- type = INI_VALUE;
- state = READING_KEY;
- key_start = str;
- ++key_len;
- } else {
- state = REJECT;
- }
- break;
- case READING_KEY:
- if(isspace(c)) {
- state = SEEKING_EQ;
- } else if(c == '=') {
- state = SEEKING_VALUE;
- } else {
- ++key_len;
- }
- break;
- case SEEKING_EQ:
- if(c == '=') {
- state = SEEKING_VALUE;
- } else if(!isspace(c)) {
- state = REJECT;
- }
- break;
- case SEEKING_VALUE:
- if(c == '"' || c == '\'') {
- if(!value_start) {
- quote = c;
- state = READING_VALUE;
- } else {
- state = REJECT;
- }
- } else if(!isspace(c)) {
- value_start = str;
- ++value_len;
- state = READING_VALUE;
- }
- break;
- case READING_VALUE:
- if(quote == 0 && isspace(c)) {
- state = ACCEPT;
- } else if(quote && c == quote) {
- state = ACCEPT;
- } else if(c == 0) {
- state = ACCEPT;
- } else if(c) {
- if(!value_start) {
- value_start = str;
- }
- ++value_len;
- } else {
- state = REJECT;
- }
- break;
- case READING_SECTION_KEY:
- if(isspace(c)) {
- state = SEEKING_SECTION_VALUE;
- } else if(c == ']') {
- state = ACCEPT;
- } else {
- if(!key_start) {
- key_start = str;
- }
- ++key_len;
+ strncpy(dest, src, size);
+ dest[size - 1] = '\0';
+ return dest;
+}
+
+/* See documentation in header file. */
+int ini_parse_stream(ini_reader reader, void* stream, ini_handler handler,
+ void* user)
+{
+ /* Uses a fair bit of stack (use heap instead if you need to) */
+#if INI_USE_STACK
+ char line[INI_MAX_LINE];
+#else
+ char* line;
+#endif
+ char section[MAX_SECTION] = "";
+ char prev_name[MAX_NAME] = "";
+
+ char* start;
+ char* end;
+ char* name;
+ char* value;
+ int lineno = 0;
+ int error = 0;
+
+#if !INI_USE_STACK
+ line = (char*)malloc(INI_MAX_LINE);
+ if (!line) {
+ return -2;
+ }
+#endif
+
+#if INI_HANDLER_LINENO
+#define HANDLER(u, s, n, v) handler(u, s, n, v, lineno)
+#else
+#define HANDLER(u, s, n, v) handler(u, s, n, v)
+#endif
+
+ /* Scan through stream line by line */
+ while (reader(line, INI_MAX_LINE, stream) != NULL) {
+ lineno++;
+
+ start = line;
+#if INI_ALLOW_BOM
+ if (lineno == 1 && (unsigned char)start[0] == 0xEF &&
+ (unsigned char)start[1] == 0xBB &&
+ (unsigned char)start[2] == 0xBF) {
+ start += 3;
}
- break;
- case SEEKING_SECTION_VALUE:
- if(c == '"' || c == '\'') {
- quote = c;
- state = READING_SECTION_VALUE;
- } else if(c == ']') {
- state = ACCEPT;
- } else if(!isspace(c)) {
- state = REJECT;
+#endif
+ start = lskip(rstrip(start));
+
+ if (*start == ';' || *start == '#') {
+ /* Per Python configparser, allow both ; and # comments at the
+ start of a line */
}
- break;
- case READING_SECTION_VALUE:
- if(quote == 0 && isspace(c)) {
- state = SEEKING_END_SECTION;
- } else if(quote && c == quote) {
- state = SEEKING_END_SECTION;
- } else if(c == ']') {
- state = ACCEPT;
- } else if(c) {
- if(!value_start) {
- value_start = str;
- }
- ++value_len;
- } else {
- state = REJECT;
+#if INI_ALLOW_MULTILINE
+ else if (*prev_name && *start && start > line) {
+ /* Non-blank line with leading whitespace, treat as continuation
+ of previous name's value (as per Python configparser). */
+ if (!HANDLER(user, section, prev_name, start) && !error)
+ error = lineno;
}
- break;
- case SEEKING_END_SECTION:
- if(c == ']') {
- state = ACCEPT;
- } else if(!isspace(c)) {
- state = REJECT;
+#endif
+ else if (*start == '[') {
+ /* A "[section]" line */
+ end = find_chars_or_comment(start + 1, "]");
+ if (*end == ']') {
+ *end = '\0';
+ strncpy0(section, start + 1, sizeof(section));
+ *prev_name = '\0';
+ }
+ else if (!error) {
+ /* No ']' found on section line */
+ error = lineno;
+ }
}
- break;
- case ACCEPT:
- if(c != 0 && !isspace(c)) {
- state = REJECT;
+ else if (*start) {
+ /* Not a comment, must be a name[=:]value pair */
+ end = find_chars_or_comment(start, "=:");
+ if (*end == '=' || *end == ':') {
+ *end = '\0';
+ name = rstrip(start);
+ value = end + 1;
+#if INI_ALLOW_INLINE_COMMENTS
+ end = find_chars_or_comment(value, NULL);
+ if (*end)
+ *end = '\0';
+#endif
+ value = lskip(value);
+ rstrip(value);
+
+ /* Valid name[=:]value pair found, call handler */
+ strncpy0(prev_name, name, sizeof(prev_name));
+ if (!HANDLER(user, section, name, value) && !error)
+ error = lineno;
+ }
+ else if (!error) {
+ /* No '=' or ':' found on name[=:]value line */
+ error = lineno;
+ }
}
- break;
- case REJECT:
- return 0;
- break;
- }
- ++str;
- } while(c != 0 && state != REJECT);
- if(state == ACCEPT) {
- if(key_len >= key_size) {
- key_len = key_size - 1;
+#if INI_STOP_ON_FIRST_ERROR
+ if (error)
+ break;
+#endif
}
- if(value_len >= value_size) {
- value_len = value_size - 1;
+
+#if !INI_USE_STACK
+ free(line);
+#endif
+
+ return error;
+}
+
+/* See documentation in header file. */
+int ini_parse_file(FILE* file, ini_handler handler, void* user)
+{
+ return ini_parse_stream((ini_reader)fgets, file, handler, user);
+}
+
+/* See documentation in header file. */
+int ini_parse(const char* filename, ini_handler handler, void* user)
+{
+ FILE* file;
+ int error;
+
+ file = fopen(filename, "r");
+ if (!file)
+ return -1;
+ error = ini_parse_file(file, handler, user);
+ fclose(file);
+ return error;
+}
+
+/* An ini_reader function to read the next line from a string buffer. This
+ is the fgets() equivalent used by ini_parse_string(). */
+static char* ini_reader_string(char* str, int num, void* stream) {
+ ini_parse_string_ctx* ctx = (ini_parse_string_ctx*)stream;
+ const char* ctx_ptr = ctx->ptr;
+ size_t ctx_num_left = ctx->num_left;
+ char* strp = str;
+ char c;
+
+ if (ctx_num_left == 0 || num < 2)
+ return NULL;
+
+ while (num > 1 && ctx_num_left != 0) {
+ c = *ctx_ptr++;
+ ctx_num_left--;
+ *strp++ = c;
+ if (c == '\n')
+ break;
+ num--;
}
- memcpy(out_key, key_start, key_len);
- memcpy(out_value, value_start, value_len);
- out_key[key_len] = 0;
- out_value[value_len] = 0;
- return type;
- } else {
- out_key[0] = 0;
- out_value[0] = 0;
- }
-
- return INI_UNKNOWN;
+
+ *strp = '\0';
+ ctx->ptr = ctx_ptr;
+ ctx->num_left = ctx_num_left;
+ return str;
+}
+
+/* See documentation in header file. */
+int ini_parse_string(const char* string, ini_handler handler, void* user) {
+ ini_parse_string_ctx ctx;
+
+ ctx.ptr = string;
+ ctx.num_left = strlen(string);
+ return ini_parse_stream((ini_reader)ini_reader_string, &ctx, handler,
+ user);
}