pax_global_header00006660000000000000000000000064150700423700014510gustar00rootroot0000000000000052 comment=f7d74ce6c81e55976d85b824ba73c03f6c0f157a libscfg-0.2.0/000077500000000000000000000000001507004237000131205ustar00rootroot00000000000000libscfg-0.2.0/.build.yml000066400000000000000000000004411507004237000150170ustar00rootroot00000000000000image: alpine/latest packages: - meson sources: - https://codeberg.org/emersion/libscfg.git tasks: - setup: | cd libscfg meson setup build/ --fatal-meson-warnings - build: | cd libscfg ninja -C build/ - test: | cd libscfg ninja -C build/ test libscfg-0.2.0/.gitignore000066400000000000000000000000101507004237000150770ustar00rootroot00000000000000/build/ libscfg-0.2.0/LICENSE000066400000000000000000000020641507004237000141270ustar00rootroot00000000000000The MIT License (MIT) Copyright (c) 2020 Simon Ser Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. libscfg-0.2.0/README.md000066400000000000000000000001361507004237000143770ustar00rootroot00000000000000# libscfg A C library for [scfg]. ## License MIT [scfg]: https://git.sr.ht/~emersion/scfg libscfg-0.2.0/formatter.c000066400000000000000000000046231507004237000152740ustar00rootroot00000000000000#include #include #include #include static bool contains_special_char(const char *str) { for (size_t i = 0; str[i] != '\0'; i++) { switch (str[i]) { case '"': case '\\': case '\r': case '\n': case '\'': case '{': case '}': case ' ': case '\t': return true; } } return false; } static bool write_str(const char *str, FILE *f) { size_t n = strlen(str); return fwrite(str, 1, n, f) == n; } static bool write_ch(char ch, FILE *f) { return fwrite(&ch, 1, 1, f) == 1; } static bool write_indent(int level, FILE *f) { for (int i = 0; i < level; i++) { if (!write_ch('\t', f)) { return false; } } return true; } static bool format_word(const char *str, FILE *f) { if (str[0] != '\0' && !contains_special_char(str)) { return write_str(str, f); } if (!write_ch('"', f)) { return false; } for (size_t i = 0; str[i] != '\0'; i++) { char ch = str[i]; switch (ch) { case '"': case '\\': if (!write_ch('\\', f)) { return false; } break; } if (!write_ch(ch, f)) { return false; } } return write_ch('"', f); } static int format_block(const struct scfg_block *block, FILE *f, int indent); static int format_directive(const struct scfg_directive *dir, FILE *f, int indent) { if (dir->name[0] == '\0') { return -EINVAL; } if (!write_indent(indent, f) || !format_word(dir->name, f)) { return -errno; } for (size_t i = 0; i < dir->params_len; i++) { if (!write_ch(' ', f) || !format_word(dir->params[i], f)) { return -errno; } } if (dir->children.directives_len > 0) { if (!write_str(" {\n", f)) { return -errno; } int ret = format_block(&dir->children, f, indent + 1); if (ret < 0) { return ret; } if (!write_indent(indent, f) || !write_str("}", f)) { return -errno; } } if (!write_ch('\n', f)) { return -errno; } return 0; } static int format_block(const struct scfg_block *block, FILE *f, int indent) { for (size_t i = 0; i < block->directives_len; i++) { int ret = format_directive(&block->directives[i], f, indent); if (ret != 0) { return ret; } } return 0; } int scfg_format_file(const struct scfg_block *block, FILE *f) { return format_block(block, f, 0); } int scfg_store_file(const struct scfg_block *block, const char *path) { FILE *f = fopen(path, "w"); if (f == NULL) { return -errno; } int res = scfg_format_file(block, f); fclose(f); return res; } libscfg-0.2.0/include/000077500000000000000000000000001507004237000145435ustar00rootroot00000000000000libscfg-0.2.0/include/private.h000066400000000000000000000001761507004237000163720ustar00rootroot00000000000000#ifndef PRIVATE_H #define PRIVATE_H struct scfg_directive; void _scfg_directive_finish(struct scfg_directive *dir); #endif libscfg-0.2.0/include/scfg.h000066400000000000000000000011151507004237000156340ustar00rootroot00000000000000#ifndef SCFG_H #define SCFG_H #include #include struct scfg_block { struct scfg_directive *directives; size_t directives_len; }; struct scfg_directive { char *name; char **params; size_t params_len; struct scfg_block children; int lineno; }; int scfg_load_file(struct scfg_block *block, const char *path); int scfg_store_file(const struct scfg_block *block, const char *path); int scfg_parse_file(struct scfg_block *block, FILE *f); int scfg_format_file(const struct scfg_block *block, FILE *f); void scfg_block_finish(struct scfg_block *block); #endif libscfg-0.2.0/meson.build000066400000000000000000000024231507004237000152630ustar00rootroot00000000000000project( 'scfg', 'c', version: '0.2.0', license: 'MIT', meson_version: '>=0.54.0', default_options: [ 'c_std=c99', 'warning_level=3', 'werror=true', ], ) version = meson.project_version() version_major = version.split('.')[0] version_minor = version.split('.')[1] assert(version_major == '0') cc = meson.get_compiler('c') add_project_arguments(cc.get_supported_arguments([ '-Wno-missing-braces', '-Wno-missing-field-initializers', '-Wno-unused-parameter', ]), language: 'c') install_headers('include/scfg.h') scfg_inc = include_directories('include') scfg_lib = library( meson.project_name(), files('formatter.c', 'parser.c', 'scfg.c'), include_directories: scfg_inc, install: true, version: version, soversion: version_minor, ) scfg = declare_dependency( link_with: scfg_lib, include_directories: scfg_inc, ) meson.override_dependency('scfg', scfg) pkgconfig = import('pkgconfig') pkgconfig.generate( scfg_lib, version: meson.project_version(), filebase: meson.project_name(), name: meson.project_name(), description: 'Configuration file format library', ) test_exe = executable( 'scfg_test', files('test.c'), dependencies: scfg, build_by_default: false, ) foreach test_case : ['parse', 'format'] test(test_case, test_exe, args: [test_case]) endforeach libscfg-0.2.0/parser.c000066400000000000000000000173401507004237000145650ustar00rootroot00000000000000#include #include #include #include #include #include #include #include "private.h" struct scfg_buffer { void *data; size_t len, cap; }; static int buffer_append(struct scfg_buffer *buf, const void *src, size_t size) { if (buf->len + size > buf->cap) { size_t new_cap = buf->cap; if (new_cap == 0) { new_cap = 128; } while (buf->len + size > new_cap) { new_cap *= 2; } char *new_data = realloc(buf->data, new_cap); if (new_data == NULL) { return -errno; } buf->cap = new_cap; buf->data = new_data; } void *dst = (char *)buf->data + buf->len; memcpy(dst, src, size); buf->len += size; return 0; } static int buffer_append_char(struct scfg_buffer *buf, char ch) { return buffer_append(buf, &ch, 1); } static void *buffer_steal(struct scfg_buffer *buf) { void *data = buf->data; memset(buf, 0, sizeof(*buf)); return data; } struct scfg_parser { FILE *f; int prev_ch; int lineno; }; static int parser_read_char(struct scfg_parser *parser) { errno = 0; int ch = fgetc(parser->f); if (ch == EOF) { parser->prev_ch = '\0'; if (errno != 0) { return -errno; } return '\0'; } parser->prev_ch = ch; if (ch == '\n') { parser->lineno++; } return ch; } static void parser_unread_char(struct scfg_parser *parser) { assert(parser->prev_ch >= 0); if (parser->prev_ch == 0) { return; } ungetc(parser->prev_ch, parser->f); if (parser->prev_ch == '\n') { parser->lineno--; } parser->prev_ch = -1; } static void parser_set_error(struct scfg_parser *parser, const char *fmt, ...) { // TODO: don't print to stderr, expose error message to library user va_list args; va_start(args, fmt); fprintf(stderr, "scfg: on line %d: ", parser->lineno); vfprintf(stderr, fmt, args); fprintf(stderr, "\n"); va_end(args); } static void parser_consume_whitespace(struct scfg_parser *parser) { while (1) { switch (parser_read_char(parser)) { case ' ': case '\t': break; default: parser_unread_char(parser); return; } } } static void parser_consume_line(struct scfg_parser *parser) { while (1) { int ch = parser_read_char(parser); if (ch < 0 || ch == '\0' || ch == '\n') { return; } } } static int parser_read_atom(struct scfg_parser *parser, char **str_ptr) { int res = 0; struct scfg_buffer buf = {0}; while (1) { int ch = parser_read_char(parser); if (ch < 0) { res = ch; goto end; } switch (ch) { case '\0': case ' ': case '\t': case '\n': parser_unread_char(parser); res = buffer_append_char(&buf, '\0'); goto end; case '"': case '\'': case '{': case '}': parser_set_error(parser, "unexpected '%c' in atom", ch); res = -EINVAL; goto end; case '\\': ch = parser_read_char(parser); if (ch < 0) { res = ch; goto end; } else if (ch == '\n') { parser_set_error(parser, "can't escape '\\n' in atom"); res = -EINVAL; goto end; } /* fallthrough */ default: res = buffer_append_char(&buf, ch); if (res != 0) { goto end; } break; } } end: *str_ptr = buffer_steal(&buf); return res; } static int parser_read_dquote_word(struct scfg_parser *parser, char **str_ptr) { int res = 0; struct scfg_buffer buf = {0}; while (1) { int ch = parser_read_char(parser); if (ch < 0) { res = ch; goto end; } switch (ch) { case '\0': case '\n': parser_set_error(parser, "unterminated double-quoted string"); res = -EINVAL; goto end; case '"': res = buffer_append_char(&buf, '\0'); goto end; case '\\': ch = parser_read_char(parser); if (ch < 0) { res = ch; goto end; } else if (ch == '\n') { parser_set_error(parser, "can't escape '\\n' in double-quoted string"); res = -EINVAL; goto end; } /* fallthrough */ default: res = buffer_append_char(&buf, ch); if (res != 0) { goto end; } break; } } end: *str_ptr = buffer_steal(&buf); return res; } static int parser_read_squote_word(struct scfg_parser *parser, char **str_ptr) { int res = 0; struct scfg_buffer buf = {0}; while (1) { int ch = parser_read_char(parser); if (ch < 0) { res = ch; goto end; } switch (ch) { case '\0': case '\n': parser_set_error(parser, "unterminated single-quoted string"); res = -EINVAL; goto end; case '\'': res = buffer_append_char(&buf, '\0'); goto end; default: res = buffer_append_char(&buf, ch); if (res != 0) { goto end; } break; } } end: *str_ptr = buffer_steal(&buf); return res; } static int parser_read_word(struct scfg_parser *parser, char **str_ptr) { int ch = parser_read_char(parser); if (ch < 0) { return ch; } switch (ch) { case '"': return parser_read_dquote_word(parser, str_ptr); case '\'': return parser_read_squote_word(parser, str_ptr); default: parser_unread_char(parser); return parser_read_atom(parser, str_ptr); } } static int parser_read_block(struct scfg_parser *parser, struct scfg_block *block, bool *closing_brace); static int parser_read_directive(struct scfg_parser *parser, struct scfg_directive *dir) { *dir = (struct scfg_directive){0}; dir->lineno = parser->lineno; int res = parser_read_word(parser, &dir->name); if (res != 0) { return res; } parser_consume_whitespace(parser); struct scfg_buffer params_buf = {0}; while (1) { int ch = parser_read_char(parser); if (ch < 0) { res = ch; goto end; } else if (ch == '\0' || ch == '\n') { break; } else if (ch == '{') { bool closing_brace = false; res = parser_read_block(parser, &dir->children, &closing_brace); if (res != 0) { goto end; } else if (!closing_brace) { parser_set_error(parser, "scfg: expected '}'"); res = -EINVAL; goto end; } break; } switch (ch) { case '}': parser_set_error(parser, "unexpected '}'"); res = -EINVAL; goto end; default: parser_unread_char(parser); char *param = NULL; res = parser_read_word(parser, ¶m); if (res != 0) { free(param); goto end; } res = buffer_append(¶ms_buf, ¶m, sizeof(param)); if (res != 0) { free(param); goto end; } parser_consume_whitespace(parser); break; } } end: dir->params_len = params_buf.len / sizeof(char *); dir->params = buffer_steal(¶ms_buf); return res; } static int parser_read_block(struct scfg_parser *parser, struct scfg_block *block, bool *closing_brace) { *block = (struct scfg_block){0}; *closing_brace = false; int res = 0; struct scfg_buffer dirs_buf = {0}; while (1) { parser_consume_whitespace(parser); int ch = parser_read_char(parser); if (ch < 0) { res = ch; goto end; } else if (ch == '\n') { continue; } else if (ch == '#') { parser_consume_line(parser); continue; } else if (ch == 0 || ch == '}') { *closing_brace = ch == '}'; break; } parser_unread_char(parser); struct scfg_directive dir = {0}; res = parser_read_directive(parser, &dir); if (res != 0) { _scfg_directive_finish(&dir); goto end; } res = buffer_append(&dirs_buf, &dir, sizeof(dir)); if (res != 0) { _scfg_directive_finish(&dir); goto end; } } end: block->directives_len = dirs_buf.len / sizeof(struct scfg_directive); block->directives = buffer_steal(&dirs_buf); return res; } int scfg_load_file(struct scfg_block *block, const char *path) { FILE *f = fopen(path, "r"); if (f == NULL) { return -errno; } int res = scfg_parse_file(block, f); fclose(f); return res; } int scfg_parse_file(struct scfg_block *block, FILE *f) { struct scfg_parser parser = { .f = f, .lineno = 1 }; bool closing_brace = false; int res = parser_read_block(&parser, block, &closing_brace); if (res != 0) { return res; } else if (closing_brace) { parser_set_error(&parser, "unexpected '}'"); return -EINVAL; } return 0; } libscfg-0.2.0/scfg.c000066400000000000000000000007101507004237000142040ustar00rootroot00000000000000#include #include #include "private.h" void _scfg_directive_finish(struct scfg_directive *dir) { free(dir->name); for (size_t i = 0; i < dir->params_len; i++) { free(dir->params[i]); } free(dir->params); scfg_block_finish(&dir->children); } void scfg_block_finish(struct scfg_block *block) { for (size_t i = 0; i < block->directives_len; i++) { _scfg_directive_finish(&block->directives[i]); } free(block->directives); } libscfg-0.2.0/test.c000066400000000000000000000073061507004237000142510ustar00rootroot00000000000000#define _POSIX_C_SOURCE 200809L #include #include #include #include #include const char src[] = "dir1 param1 param2 \"\" param4\n" "dir2\n" "dir3 param1 {\n" " child1 param1\n" " child2\n" "}\n" "dir4 {\n" "}\n" "\n" "# comment\n" "dir5 \"param 1\" 'param 2' \"a \\b ' \\\\ \\\" c\" 'd \\ e \" f'\n"; const char formatted[] = "dir1 param1 param2 \"\" param4\n" "dir2\n" "dir3 param1 {\n" " child1 param1\n" " child2\n" "}\n" "dir4\n" "dir5 \"param 1\" \"param 2\" \"a b ' \\\\ \\\" c\" \"d \\\\ e \\\" f\"\n"; static const struct scfg_block ref = { .directives_len = 5, .directives = (struct scfg_directive[]){ { .name = "dir1", .params_len = 4, .params = (char *[]){ "param1", "param2", "", "param4" }, }, { .name = "dir2", }, { .name = "dir3", .params_len = 1, .params = (char *[]){"param1"}, .children = { .directives_len = 2, .directives = (struct scfg_directive[]){ { .name = "child1", .params_len = 1, .params = (char *[]){"param1"}, }, { .name = "child2", }, }, }, }, { .name = "dir4", }, { .name = "dir5", .params_len = 4, .params = (char *[]){"param 1", "param 2", "a b ' \\ \" c", "d \\ e \" f"}, }, }, }; static bool block_equals(const struct scfg_block *a, const struct scfg_block *b); static bool directive_equals(const struct scfg_directive *a, const struct scfg_directive *b) { if (strcmp(a->name, b->name) != 0) { fprintf(stderr, "directive name mismatch: '%s' != '%s'\n", a->name, b->name); return false; } if (a->params_len != b->params_len) { fprintf(stderr, "directive '%s': params length mismatch: %zu != %zu\n", a->name, a->params_len, b->params_len); return false; } for (size_t i = 0; i < a->params_len; i++) { const char *a_param = a->params[i]; const char *b_param = b->params[i]; if (strcmp(a_param, b_param) != 0) { fprintf(stderr, "directive '%s': param %zu mismatch: '%s' != '%s'\n", a->name, i, a_param, b_param); return false; } } if (!block_equals(&a->children, &b->children)) { fprintf(stderr, " in directive '%s'\n", a->name); return false; } return true; } static bool block_equals(const struct scfg_block *a, const struct scfg_block *b) { if (a->directives_len != b->directives_len) { fprintf(stderr, "block length mismatch: %zu != %zu\n", a->directives_len, b->directives_len); return false; } for (size_t i = 0; i < a->directives_len; i++) { const struct scfg_directive *a_dir = &a->directives[i]; const struct scfg_directive *b_dir = &b->directives[i]; if (!directive_equals(a_dir, b_dir)) { return false; } } return true; } bool test_parse(void) { FILE *f = fmemopen((char *)src, strlen(src), "r"); struct scfg_block cfg = {0}; int ret = scfg_parse_file(&cfg, f); fclose(f); if (ret != 0) { fprintf(stderr, "failed to parse file: %s\n", strerror(-ret)); return false; } bool ok = block_equals(&cfg, &ref); scfg_block_finish(&cfg); return ok; } bool test_format(void) { char *str = NULL; size_t str_size = 0; FILE *f = open_memstream(&str, &str_size); int ret = scfg_format_file(&ref, f); fclose(f); if (ret != 0) { fprintf(stderr, "failed to format file\n"); return false; } bool ok = strcmp(str, formatted) == 0; free(str); return ok; } int main(int argc, char *argv[]) { if (argc < 2) { fprintf(stderr, "usage: scfg_test \n"); return 1; } const char *test_case = argv[1]; bool ok; if (strcmp(test_case, "parse") == 0) { ok = test_parse(); } else if (strcmp(test_case, "format") == 0) { ok = test_format(); } else { fprintf(stderr, "unknown test case '%s'\n", test_case); return 1; } return ok ? 0 : 1; }