text.c File Reference

#include "sdb.h"
#include <fcntl.h>
#include <limits.h>
#include <sys/stat.h>
#include "sdb_private.h"

Go to the source code of this file.

Classes
struct	LoadCtx

Macros
#define	FLUSH
#define	ESCAPE_LOOP(fd, str, escapes)
#define	ESCAPE(c, repl, replsz)

Enumerations
enum	LoadState { STATE_NEWLINE , STATE_PATH , STATE_KEY , STATE_VALUE }

Functions
static int	cmp_ns (const void *a, const void *b)
static void	write_path (int fd, SdbList *path)
static void	write_key (int fd, const char *k)
static void	write_value (int fd, const char *v)
static bool	save_kv_cb (void *user, const char *k, const char *v)
static bool	text_save (Sdb *s, int fd, bool sort, SdbList *path)
RZ_API bool	sdb_text_save_fd (Sdb *s, int fd, bool sort)
RZ_API bool	sdb_text_save (Sdb *s, const char *file, bool sort)
static void	load_process_line (LoadCtx *ctx)
static char	unescape_raw_char (char c)
static void	load_process_single_char (LoadCtx *ctx)
static bool	load_process_final_line (LoadCtx *ctx)
static void	load_ctx_fini (LoadCtx *ctx)
static bool	load_ctx_init (LoadCtx *ctx, Sdb *s, char *buf, size_t sz)
RZ_API bool	sdb_text_load_buf (Sdb *s, char *buf, size_t sz)
RZ_API bool	sdb_text_load (Sdb *s, const char *file)

Macro Definition Documentation

ESCAPE

#define ESCAPE	(		c,
			repl,
			replsz
	)

Value:

    case c: \
        FLUSH; \
        p++; \
        write_(fd, "\\" repl, replsz + 1); \
        break;

Definition at line 91 of file text.c.

ESCAPE_LOOP

#define ESCAPE_LOOP	(		fd,
			str,
			escapes
	)

Value:

    do { \
        const char *p = str; \
        const char *n = p; \
        while (*n) { \
            switch (*n) { escapes } \
            n++; \
        } \
        FLUSH; \
    } while (0)

Definition at line 81 of file text.c.

FLUSH

#define FLUSH

Value:

    do { \
        if (p != n) { \
            write_(fd, p, n - p); \
            p = n; \
        } \
    } while (0)

Definition at line 73 of file text.c.

Enumeration Type Documentation

LoadState

enum LoadState

Enumerator
STATE_NEWLINE
STATE_PATH
STATE_KEY
STATE_VALUE

Definition at line 209 of file text.c.

             {
    STATE_NEWLINE,
    STATE_PATH,
    STATE_KEY,
    STATE_VALUE
} LoadState;

Function Documentation

cmp_ns()

static int cmp_ns ( const void *  a, const void *  b  )

static

---

Plaintext SDB Format

---

Files are UTF-8 and use '
' line endings. Always.

Lines starting with '/' denote the path of the namespace for the following data:

/some/namespace

The default path is root, just a slash also means root. These paths are always absolute from the root. Characters that must be escaped in a path are: '/', '\', '
', '\r':

/s\/ome/name\nspa\ce

SDB entries are written each as a single k=v line:

somekey=somevalue

To distinguish these from path lines, if there is a leading '/' in the key, it must be escaped (slashes later in the line don't have to be escaped):

\/slashedkey=somevalue

Other than that, at any postion, '\', '
' and '\r' must be escaped:

some\key=some\nvalue

In the key, '=' must also be escaped (not necessary in the value):

some=key=some=value

---

Example:

/ key=intheroot \/slashedkey=somevalue some\key=some\nvalue some=key=some=value

/subns some=stuff in the sub-namespace

/subns/deeper this=is in /subns/deeper

Definition at line 64 of file text.c.

                                                {
    const SdbNs *nsa = a;
    const SdbNs *cia = b;
    return strcmp(nsa->name, cia->name);
}

References a, b, and sdb_ns_t::name.

Referenced by text_save().

load_ctx_fini()

static void load_ctx_fini ( LoadCtx *  ctx )

static

Definition at line 362 of file text.c.

                                        {
    ls_free(ctx->path);
}

References ls_free().

Referenced by load_ctx_init(), and sdb_text_load_buf().

load_ctx_init()

static bool load_ctx_init ( LoadCtx *  ctx, Sdb *  s, char *  buf, size_t  sz  )

static

Definition at line 366 of file text.c.

                                                                      {
    ctx->eof = false;
    ctx->buf = buf;
    ctx->bufsz = sz;
    ctx->root_db = s;
    ctx->cur_db = s;
    ctx->pos = 0;
    ctx->line_begin = 0;
    ctx->token_begin = 0;
    ctx->shift = 0;
    ctx->path = ls_new();
    ctx->state = STATE_NEWLINE;
    ctx->unescape = false;
    if (!ctx->buf || !ctx->path) {
        load_ctx_fini(ctx);
        return false;
    }
    return true;
}

References load_ctx_fini(), ls_new(), s, and STATE_NEWLINE.

Referenced by sdb_text_load_buf().

load_process_final_line()

static bool load_process_final_line ( LoadCtx *  ctx )

static

Definition at line 336 of file text.c.

                                                  {
    // load_process_line needs ctx.buf[ctx.pos] to be allocated!
    // so we need room for one additional byte after the buffer.
    size_t linesz = ctx->bufsz - ctx->line_begin;
    char *linebuf = malloc(linesz + 1);
    if (!linebuf) {
        return false;
    }
    memcpy(linebuf, ctx->buf + ctx->line_begin, linesz);
    ctx->buf = linebuf;
    // shift everything by the size we skipped
    ctx->bufsz -= ctx->line_begin;
    ctx->pos = linesz;
    ctx->token_begin -= ctx->line_begin;
    SdbListIter *it;
    void *token_off_tmp;
    ls_foreach (ctx->path, it, token_off_tmp) {
        it->data = (void *)((size_t)token_off_tmp - ctx->line_begin);
    }
    ctx->line_begin = 0;
    load_process_line(ctx);
    free(linebuf);
    ctx->buf = NULL;
    return true;
}

References ls_iter_t::data, free(), load_process_line(), ls_foreach, malloc(), memcpy(), and NULL.

Referenced by sdb_text_load_buf().

load_process_line()

static void load_process_line ( LoadCtx *  ctx )

static

Definition at line 234 of file text.c.

                                            {
    ctx->unescape = false;
    // finish up the line
    ctx->buf[ctx->pos - ctx->shift] = '\0';
    switch (ctx->state) {
    case STATE_PATH: {
        ls_push(ctx->path, (void *)ctx->token_begin);
        SdbListIter *it;
        void *token_off_tmp;
        ctx->cur_db = ctx->root_db;
        ls_foreach (ctx->path, it, token_off_tmp) {
            size_t token_off = (size_t)token_off_tmp;
            if (!ctx->buf[token_off]) {
                continue;
            }
            ctx->cur_db = sdb_ns(ctx->cur_db, ctx->buf + token_off, 1);
            if (!ctx->cur_db) {
                ctx->cur_db = ctx->root_db;
                break;
            }
        }
        ls_destroy(ctx->path);
        break;
    }
    case STATE_VALUE: {
        const char *k = ctx->buf + ctx->line_begin;
        const char *v = ctx->buf + ctx->token_begin;
        if (!*k || !*v) {
            break;
        }
        sdb_set(ctx->cur_db, k, v, 0);
        break;
    }
    default:
        break;
    }
    // prepare for next line
    ctx->shift = 0;
    ctx->state = STATE_NEWLINE;
}

References k, ls_destroy(), ls_foreach, ls_push, sdb_ns(), sdb_set(), STATE_NEWLINE, STATE_PATH, STATE_VALUE, and v.

Referenced by load_process_final_line(), and load_process_single_char().

load_process_single_char()

static void load_process_single_char ( LoadCtx *  ctx )

static

Definition at line 288 of file text.c.

                                                   {
    char c = ctx->buf[ctx->pos];
    if (c == '\n' || c == '\r') {
        load_process_line(ctx);
        ctx->pos++;
        return;
    }
 
    if (ctx->state == STATE_NEWLINE) {
        ctx->line_begin = ctx->pos;
        // at the start of a line, decide whether it's a path or a k=v
        // by whether there is a leading slash.
        if (c == '/') {
            ctx->state = STATE_PATH;
            ctx->token_begin = ctx->pos + 1;
            ctx->pos++;
            c = ctx->buf[ctx->pos];
            return;
        }
        ctx->state = STATE_KEY;
    }
 
    if (ctx->unescape) {
        ctx->buf[ctx->pos - ctx->shift] = unescape_raw_char(c);
        ctx->unescape = false;
    } else if (c == '\\') {
        // got a backslash, the next char, unescape in the next iteration or die!
        ctx->shift++;
        ctx->unescape = true;
    } else if (ctx->state == STATE_PATH && c == '/') {
        // new path token
        ctx->buf[ctx->pos - ctx->shift] = '\0';
        ls_push(ctx->path, (void *)ctx->token_begin);
        ctx->token_begin = ctx->pos + 1;
        ctx->shift = 0;
    } else if (ctx->state == STATE_KEY && c == '=') {
        // switch from key to value mode
        ctx->buf[ctx->pos - ctx->shift] = '\0';
        ctx->token_begin = ctx->pos + 1;
        ctx->shift = 0;
        ctx->state = STATE_VALUE;
    } else if (ctx->shift) {
        // just some char, shift it back if necessary
        ctx->buf[ctx->pos - ctx->shift] = c;
    }
    ctx->pos++;
}

References c, load_process_line(), ls_push, STATE_KEY, STATE_NEWLINE, STATE_PATH, STATE_VALUE, and unescape_raw_char().

Referenced by sdb_text_load_buf().

save_kv_cb()

static bool save_kv_cb ( void *  user, const char *  k, const char *  v  )

static

Definition at line 139 of file text.c.

                                                                 {
    int fd = *(int *)user;
    write_key(fd, k);
    write_(fd, "=", 1);
    write_value(fd, v);
    write_(fd, "\n", 1);
    return true;
}

References fd, k, v, write_, write_key(), and write_value().

Referenced by text_save().

sdb_text_load()

RZ_API bool sdb_text_load	(	Sdb *	s,
		const char *	file
	)

Definition at line 405 of file text.c.

                                                    {
    int fd = open(file, O_RDONLY | O_BINARY);
    if (fd < 0) {
        return false;
    }
    bool r = false;
    struct stat st;
    if (fstat(fd, &st) || !st.st_size) {
        goto beach;
    }
#if HAVE_HEADER_SYS_MMAN_H
    char *x = mmap(0, st.st_size, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
    if (x == MAP_FAILED) {
        goto beach;
    }
#else
    char *x = calloc(1, st.st_size);
    if (!x) {
        goto beach;
    }
    if (read(fd, x, st.st_size) != st.st_size) {
        free(x);
        goto beach;
    }
#endif
    r = sdb_text_load_buf(s, x, st.st_size);
#if HAVE_HEADER_SYS_MMAN_H
    munmap(x, st.st_size);
#else
    free(x);
#endif
beach:
    close(fd);
    return r;
}

References calloc(), close, fd, free(), fstat, MAP_PRIVATE, mmap, munmap, O_BINARY, O_RDONLY, PROT_READ, PROT_WRITE, r, read(), s, sdb_text_load_buf(), and x.

Referenced by createdb(), and rz_project_load_file_raw().

sdb_text_load_buf()

RZ_API bool sdb_text_load_buf	(	Sdb *	s,
		char *	buf,
		size_t	sz
	)

Definition at line 386 of file text.c.

                                                            {
    if (!sz) {
        return true;
    }
    LoadCtx ctx;
    if (!load_ctx_init(&ctx, s, buf, sz)) {
        return false;
    }
    bool ret = true;
    while (ctx.pos < ctx.bufsz) {
        load_process_single_char(&ctx);
    }
    if (ctx.line_begin < ctx.bufsz && ctx.state != STATE_NEWLINE) {
        load_process_final_line(&ctx);
    }
    load_ctx_fini(&ctx);
    return ret;
}

References load_ctx_fini(), load_ctx_init(), load_process_final_line(), load_process_single_char(), s, and STATE_NEWLINE.

Referenced by createdb(), and sdb_text_load().

sdb_text_save()

RZ_API bool sdb_text_save	(	Sdb *	s,
		const char *	file,
		bool	sort
	)

Definition at line 199 of file text.c.

                                                               {
    int fd = open(file, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 0644);
    if (fd < 0) {
        return false;
    }
    bool r = sdb_text_save_fd(s, fd, sort);
    close(fd);
    return r;
}

References close, fd, O_BINARY, O_CREAT, O_TRUNC, O_WRONLY, r, s, and sdb_text_save_fd().

Referenced by rz_project_save_file().

sdb_text_save_fd()

RZ_API bool sdb_text_save_fd	(	Sdb *	s,
		int	fd,
		bool	sort
	)

Definition at line 189 of file text.c.

                                                        {
    SdbList *path = ls_new();
    if (!path) {
        return false;
    }
    bool r = text_save(s, fd, sort, path);
    ls_free(path);
    return r;
}

References fd, ls_free(), ls_new(), path, r, s, and text_save().

Referenced by sdb_text_save().

text_save()

static bool text_save ( Sdb *  s, int  fd, bool  sort, SdbList *  path  )

static

Definition at line 148 of file text.c.

                                                                {
    // path
    write_path(fd, path);
    write_(fd, "\n", 1);
 
    // k=v entries
    if (sort) {
        SdbList *l = sdb_foreach_list(s, true);
        SdbKv *kv;
        SdbListIter *it;
        ls_foreach (l, it, kv) {
            save_kv_cb(&fd, sdbkv_key(kv), sdbkv_value(kv));
        }
        ls_free(l);
    } else {
        // This is faster when sorting is not needed.
        sdb_foreach(s, save_kv_cb, &fd);
    }
 
    // sub-namespaces
    SdbList *l = s->ns;
    if (sort) {
        l = ls_clone(l);
        ls_sort(l, cmp_ns);
    }
    SdbNs *ns;
    SdbListIter *it;
    ls_foreach (l, it, ns) {
        write_(fd, "\n", 1);
        ls_push(path, ns->name);
        text_save(ns->sdb, fd, sort, path);
        ls_pop(path);
    }
    if (l != s->ns) {
        ls_free(l);
    }
 
    return true;
}

References cmp_ns(), fd, ls_clone(), ls_foreach, ls_free(), ls_pop(), ls_push, ls_sort(), sdb_ns_t::name, path, s, save_kv_cb(), sdb_ns_t::sdb, sdb_foreach(), sdb_foreach_list(), sdbkv_key(), sdbkv_value(), write_, and write_path().

Referenced by sdb_text_save_fd().

unescape_raw_char()

static char unescape_raw_char ( char  c )

inlinestatic

Definition at line 275 of file text.c.

                                             {
    switch (c) {
    case 'n':
        return '\n';
    case 'r':
        return '\r';
    case 't':
        return '\t';
    default:
        return c;
    }
}

References c.

Referenced by load_process_single_char().

write_key()

static void write_key ( int  fd, const char *  k  )

static

Definition at line 117 of file text.c.

                                             {
    // escape leading '/'
    if (*k == '/') {
        write_(fd, "\\", 1);
    }
    ESCAPE_LOOP(fd, k,
            ESCAPE('\\', "\\", 1);
            ESCAPE('=', "=", 1);
            ESCAPE('\n', "n", 1);
            ESCAPE('\r', "r", 1););
}

References ESCAPE, ESCAPE_LOOP, fd, k, and write_.

Referenced by save_kv_cb().

write_path()

static void write_path ( int  fd, SdbList *  path  )

static

Definition at line 98 of file text.c.

                                              {
    write_(fd, "/", 1); // always print a /, even if path is empty
    SdbListIter *it;
    const char *path_token;
    bool first = true;
    ls_foreach (path, it, path_token) {
        if (first) {
            first = false;
        } else {
            write_(fd, "/", 1);
        }
        ESCAPE_LOOP(fd, path_token,
                ESCAPE('\\', "\\", 1);
                ESCAPE('/', "/", 1);
                ESCAPE('\n', "n", 1);
                ESCAPE('\r', "r", 1););
    }
}

References ESCAPE, ESCAPE_LOOP, fd, ls_foreach, path, and write_.

Referenced by text_save().

write_value()

static void write_value ( int  fd, const char *  v  )

static

Definition at line 129 of file text.c.

                                               {
    ESCAPE_LOOP(fd, v,
            ESCAPE('\\', "\\", 1);
            ESCAPE('\n', "n", 1);
            ESCAPE('\r', "r", 1););
}

References ESCAPE, ESCAPE_LOOP, fd, and v.

Referenced by save_kv_cb().