added mail script to polybar

[my-dotfiles.git] / home-config / polybar / scripts / windowlist / toml-c.h

// TOML config file parsing library
// https://github.com/arp242/toml-c

#ifndef TOML_H
#define TOML_H
#ifndef _POSIX_C_SOURCE
#define _POSIX_C_SOURCE 200809L
#endif
#ifdef _MSC_VER
#pragma warning(disable : 4996)
#endif
#ifdef __cplusplus
#define TOML_EXTERN extern "C"
#else
#define TOML_EXTERN extern
#endif

#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>

typedef struct toml_table_t     toml_table_t;
typedef struct toml_array_t     toml_array_t;
typedef struct toml_value_t     toml_value_t;
typedef struct toml_timestamp_t toml_timestamp_t;
typedef struct toml_keyval_t    toml_keyval_t;
typedef struct toml_arritem_t   toml_arritem_t;

// TOML table.
struct toml_table_t {
	const char *key;       // Key for this table
	int keylen;            // length of key.
	bool implicit;         // Table was created implicitly
	bool readonly;         // No more modification allowed

	int nkval;             // key-values in the table
	toml_keyval_t **kval;
	int narr;              // arrays in the table
	toml_array_t **arr;
	int ntab;              // tables in the table
	toml_table_t **tab;
};

// TOML array.
struct toml_array_t {
	const char *key; // key to this array
	int keylen;      // length of key.
	int kind;        // element kind: 'v'alue, 'a'rray, or 't'able, 'm'ixed
	int type;        // for value kind: 'i'nt, 'd'ouble, 'b'ool, 's'tring, 't'ime, 'D'ate, 'T'imestamp, 'm'ixed
	int nitem;       // number of elements
	toml_arritem_t *item;
};
struct toml_arritem_t {
	int valtype; // for value kind: 'i'nt, 'd'ouble, 'b'ool, 's'tring, 't'ime, 'D'ate, 'T'imestamp
	char *val;
	toml_array_t *arr;
	toml_table_t *tab;
};

// TOML key/value pair.
struct toml_keyval_t {
	const char *key; // key to this value
	int keylen;      // length of key.
	const char *val; // the raw value
};

// Parsed TOML value.
//
// The string value s is a regular NULL-terminated C string, but the string
// length is also given in sl since TOML values may contain NULL bytes. The
// value is guaranteed to be correct UTF-8.
struct toml_value_t {
	bool ok; // Was this value present?
	union {
		toml_timestamp_t *ts; // datetime; must be freed after use.
		char             *s;  // string value; must be freed after use
		int              sl;  // string length, excluding NULL.
		bool             b;   // bool value
		int64_t          i;   // int value
		double           d;   // double value
	} u;
};

// Timestamp type; some values may be empty depending on the value of kind.
struct toml_timestamp_t {
	// 'd'atetime
	// 'l'local-datetime
	// 'D'ate-local
	// 't'ime-local
	char kind;
	int year, month, day;
	int hour, minute, second, millisec;
	char *z;
};

// toml_parse() parses a TOML document from a string. Returns 0 on error, with
// the error message stored in errbuf.
//
// toml_parse_file() is identical, but reads from a file descriptor.
//
// Use toml_free() to free the return value; this will invalidate all handles
// for this table.
	TOML_EXTERN toml_table_t *toml_parse      (char *toml, char *errbuf, int errbufsz);
	TOML_EXTERN toml_table_t *toml_parse_file (FILE *fp, char *errbuf, int errbufsz);
	TOML_EXTERN void          toml_free       (toml_table_t *table);

// Table functions.
//
// toml_table_len() gets the number of direct keys for this table;
// toml_table_key() gets the nth direct key in this table.
	TOML_EXTERN int           toml_table_len       (const toml_table_t *table);
	TOML_EXTERN const char   *toml_table_key       (const toml_table_t *table, int keyidx, int *keylen);
	TOML_EXTERN toml_value_t  toml_table_string    (const toml_table_t *table, const char *key);
	TOML_EXTERN toml_value_t  toml_table_bool      (const toml_table_t *table, const char *key);
	TOML_EXTERN toml_value_t  toml_table_int       (const toml_table_t *table, const char *key);
	TOML_EXTERN toml_value_t  toml_table_double    (const toml_table_t *table, const char *key);
	TOML_EXTERN toml_value_t  toml_table_timestamp (const toml_table_t *table, const char *key);
	TOML_EXTERN toml_array_t *toml_table_array     (const toml_table_t *table, const char *key);
	TOML_EXTERN toml_table_t *toml_table_table     (const toml_table_t *table, const char *key);

// Array functions.
	TOML_EXTERN int           toml_array_len       (const toml_array_t *array);
	TOML_EXTERN toml_value_t  toml_array_string    (const toml_array_t *array, int idx);
	TOML_EXTERN toml_value_t  toml_array_bool      (const toml_array_t *array, int idx);
	TOML_EXTERN toml_value_t  toml_array_int       (const toml_array_t *array, int idx);
	TOML_EXTERN toml_value_t  toml_array_double    (const toml_array_t *array, int idx);
	TOML_EXTERN toml_value_t  toml_array_timestamp (const toml_array_t *array, int idx);
	TOML_EXTERN toml_array_t *toml_array_array     (const toml_array_t *array, int idx);
	TOML_EXTERN toml_table_t *toml_array_table     (const toml_array_t *array, int idx);

#include <assert.h>
#include <ctype.h>
#include <errno.h>
#include <math.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>


#define ALIGN8(sz) (((sz) + 7) & ~7)
#define calloc(x, y) error - forbidden - use CALLOC instead
static void *CALLOC(size_t nmemb, size_t sz) {
	int nb = ALIGN8(sz) * nmemb;
	void *p = malloc(nb);
	if (p) {
		memset(p, 0, nb);
	}
	return p;
}

// some old platforms define strdup macro -- drop it.
#undef strdup
#define strdup(x) error - forbidden - use STRDUP instead
static char *STRDUP(const char *s) {
	int len = strlen(s);
	char *p = malloc(len + 1);
	if (p) {
		memcpy(p, s, len);
		p[len] = 0;
	}
	return p;
}

// some old platforms define strndup macro -- drop it.
#undef strndup
#define strndup(x) error - forbiden - use STRNDUP instead
static char *STRNDUP(const char *s, size_t n) {
	size_t len = strnlen(s, n);
	char *p = malloc(len + 1);
	if (p) {
		memcpy(p, s, len);
		p[len] = 0;
	}
	return p;
}

// Unparsed values.
typedef const char *toml_unparsed_t;
toml_unparsed_t toml_table_unparsed  (const toml_table_t *table, const char *key);
toml_unparsed_t toml_array_unparsed  (const toml_array_t *array, int idx);
int             toml_value_string    (toml_unparsed_t s, char **ret, int *len);
int             toml_value_bool      (toml_unparsed_t s, bool *ret);
int             toml_value_int       (toml_unparsed_t s, int64_t *ret);
int             toml_value_double    (toml_unparsed_t s, double *ret);
int             toml_value_timestamp (toml_unparsed_t s, toml_timestamp_t *ret);

// Convert escape to UTF-8; return #bytes used in buf to encode the char, or -1
// on error.
// http://stackoverflow.com/questions/6240055/manually-converting-unicode-codepoints-into-utf-8-and-utf-16
int read_unicode_escape(int64_t code, char buf[6]) {
	if (0xd800 <= code && code <= 0xdfff) /// UTF-16 surrogates
		return -1;
	if (0x10FFFF < code)
		return -1;
	if (code < 0)
		return -1;
	if (code <= 0x7F) { /// 0x00000000 - 0x0000007F: 0xxxxxxx
		buf[0] = (unsigned char)code;
		return 1;
	}
	if (code <= 0x000007FF) { /// 0x00000080 - 0x000007FF: 110xxxxx 10xxxxxx
		buf[0] = (unsigned char)(0xc0 | (code >> 6));
		buf[1] = (unsigned char)(0x80 | (code & 0x3f));
		return 2;
	}
	if (code <= 0x0000FFFF) { /// 0x00000800 - 0x0000FFFF: 1110xxxx 10xxxxxx 10xxxxxx
		buf[0] = (unsigned char)(0xe0 | (code >> 12));
		buf[1] = (unsigned char)(0x80 | ((code >> 6) & 0x3f));
		buf[2] = (unsigned char)(0x80 | (code & 0x3f));
		return 3;
	}
	if (code <= 0x001FFFFF) { /// 0x00010000 - 0x001FFFFF: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
		buf[0] = (unsigned char)(0xf0 | (code >> 18));
		buf[1] = (unsigned char)(0x80 | ((code >> 12) & 0x3f));
		buf[2] = (unsigned char)(0x80 | ((code >> 6) & 0x3f));
		buf[3] = (unsigned char)(0x80 | (code & 0x3f));
		return 4;
	}
	if (code <= 0x03FFFFFF) { /// 0x00200000 - 0x03FFFFFF: 111110xx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
		buf[0] = (unsigned char)(0xf8 | (code >> 24));
		buf[1] = (unsigned char)(0x80 | ((code >> 18) & 0x3f));
		buf[2] = (unsigned char)(0x80 | ((code >> 12) & 0x3f));
		buf[3] = (unsigned char)(0x80 | ((code >> 6) & 0x3f));
		buf[4] = (unsigned char)(0x80 | (code & 0x3f));
		return 5;
	}
	if (code <= 0x7FFFFFFF) { /// 0x04000000 - 0x7FFFFFFF: 1111110x 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
		buf[0] = (unsigned char)(0xfc | (code >> 30));
		buf[1] = (unsigned char)(0x80 | ((code >> 24) & 0x3f));
		buf[2] = (unsigned char)(0x80 | ((code >> 18) & 0x3f));
		buf[3] = (unsigned char)(0x80 | ((code >> 12) & 0x3f));
		buf[4] = (unsigned char)(0x80 | ((code >> 6) & 0x3f));
		buf[5] = (unsigned char)(0x80 | (code & 0x3f));
		return 6;
	}
	return -1;
}

static inline void xfree(const void *x) {
	if (x)
		free((void *)(intptr_t)x);
}

enum tokentype_t {
	INVALID,
	DOT,
	COMMA,
	EQUAL,
	LBRACE,
	RBRACE,
	NEWLINE,
	LBRACKET,
	RBRACKET,
	STRING,
};
typedef enum tokentype_t tokentype_t;

typedef struct token_t token_t;
struct token_t {
	tokentype_t tok;
	int lineno;
	char *ptr; // points into context->start
	int len;
	int eof;
};

typedef struct context_t context_t;
struct context_t {
	char *start;
	char *stop;
	char *errbuf;
	int errbufsz;

	token_t tok;
	toml_table_t *root;
	toml_table_t *curtab;

	struct {
		int top;
		char *key[10];
		int keylen[10];
		token_t tok[10];
	} tpath;
};

#define STRINGIFY(x) #x
#define TOSTRING(x) STRINGIFY(x)
#define FLINE __FILE__ ":" TOSTRING(__LINE__)

static int next_token(context_t *ctx, bool dotisspecial);

// Error reporting. Call when an error is detected. Always return -1.
static int e_outofmemory(context_t *ctx, const char *fline) {
	snprintf(ctx->errbuf, ctx->errbufsz, "ERROR: out of memory (%s)", fline);
	return -1;
}

static int e_internal(context_t *ctx, const char *fline) {
	snprintf(ctx->errbuf, ctx->errbufsz, "internal error (%s)", fline);
	return -1;
}

static int e_syntax(context_t *ctx, int lineno, const char *msg) {
	snprintf(ctx->errbuf, ctx->errbufsz, "line %d: %s", lineno, msg);
	return -1;
}

static int e_badkey(context_t *ctx, int lineno) {
	snprintf(ctx->errbuf, ctx->errbufsz, "line %d: bad key", lineno);
	return -1;
}

static int e_keyexists(context_t *ctx, int lineno) {
	snprintf(ctx->errbuf, ctx->errbufsz, "line %d: key exists", lineno);
	return -1;
}

static int e_forbid(context_t *ctx, int lineno, const char *msg) {
	snprintf(ctx->errbuf, ctx->errbufsz, "line %d: %s", lineno, msg);
	return -1;
}

static void *expand(void *p, int sz, int newsz) {
	void *s = malloc(newsz);
	if (!s)
		return 0;

	if (p) {
		memcpy(s, p, sz);
		free(p);
	}
	return s;
}

static void **expand_ptrarr(void **p, int n) {
	void **s = malloc((n + 1) * sizeof(void *));
	if (!s)
		return 0;

	s[n] = 0;
	if (p) {
		memcpy(s, p, n * sizeof(void *));
		free(p);
	}
	return s;
}

static toml_arritem_t *expand_arritem(toml_arritem_t *p, int n) {
	toml_arritem_t *pp = expand(p, n * sizeof(*p), (n + 1) * sizeof(*p));
	if (!pp)
		return 0;

	memset(&pp[n], 0, sizeof(pp[n]));
	return pp;
}

static uint8_t const u8_length[] = {1,1,1,1,1,1,1,1,0,0,0,0,2,2,3,4};
#define u8length(s) u8_length[(((uint8_t *)(s))[0] & 0xFF) >> 4];

static char *norm_lit_str(const char *src, int srclen, int *len, bool multiline, bool is_key, char *errbuf, int errbufsz) {
	const char *sp  = src;
	const char *sq  = src + srclen;
	char       *dst = 0; /// will write to dst[] and return it
	int        max  = 0; /// max size of dst[]
	int        off  = 0; /// cur offset in dst[]

	for (;;) { /// scan forward on src
		if (off >= max - 10) { /// have some slack for misc stuff
			int newmax = max + 50;
			char *x = expand(dst, max, newmax);
			if (!x) {
				xfree(dst);
				snprintf(errbuf, errbufsz, "out of memory");
				return 0;
			}
			dst = x;
			max = newmax;
		}

		if (sp >= sq) /// finished?
			break;

		uint8_t l = u8length(sp);
		if (l == 0) {
			xfree(dst);
			snprintf(errbuf, errbufsz, "invalid UTF-8 at byte pos %d", off);
			return 0;
		}
		if (l > 1) {
			for (int i = 0; i < l; i++) {
				char ch = *sp++;
				if ((ch & 0x80) != 0x80) {
					xfree(dst);
					snprintf(errbuf, errbufsz, "invalid UTF-8 at byte pos %d", off);
					return 0;
				}
				dst[off++] = ch;
			}
			continue;
		}

		char ch = *sp++;
		if (is_key && ch == '\n') {
			xfree(dst);
			snprintf(errbuf, errbufsz, "literal newlines not allowed in key");
			return 0;
		}
		/// control characters other than tab is not allowed
		if ((0 <= ch && ch <= 0x08) || (0x0a <= ch && ch <= 0x1f) || ch == 0x7f) {
			if (!(multiline && (ch == '\r' || ch == '\n'))) {
				xfree(dst);
				snprintf(errbuf, errbufsz, "invalid char U+%04x", ch);
				return 0;
			}
		}

		dst[off++] = ch; /// a plain copy suffice
	}

	*len = off;
	dst[off++] = 0;
	return dst;
}

/* Convert src to raw unescaped utf-8 string.
 * Returns NULL if error with errmsg in errbuf. */
static char *norm_basic_str(const char *src, int srclen, int *len, bool multiline, bool is_key, char *errbuf, int errbufsz) {
	const char *sp  = src;
	const char *sq  = src + srclen;
	char       *dst = 0; /// will write to dst[] and return it
	int        max  = 0; /// max size of dst[]
	int        off  = 0; /// cur offset in dst[]
						 ///
	/// scan forward on src
	for (;;) {
		if (off >= max - 10) { /// have some slack for misc stuff
			int newmax = max + 50;
			char *x = expand(dst, max, newmax);
			if (!x) {
				xfree(dst);
				snprintf(errbuf, errbufsz, "out of memory");
				return 0;
			}
			dst = x;
			max = newmax;
		}

		if (sp >= sq) /// finished?
			break;

		uint8_t l = u8length(sp);
		if (l == 0) {
			xfree(dst);
			snprintf(errbuf, errbufsz, "invalid UTF-8 at byte pos %d", off);
			return 0;
		}
		if (l > 1) {
			for (int i = 0; i < l; i++) {
				char ch = *sp++;
				if ((ch & 0x80) != 0x80) {
					xfree(dst);
					snprintf(errbuf, errbufsz, "invalid UTF-8 at byte pos %d", off);
					return 0;
				}
				dst[off++] = ch;
			}
			continue;
		}

		char ch = *sp++;
		if (is_key && ch == '\n') {
			xfree(dst);
			snprintf(errbuf, errbufsz, "literal newlines not allowed in key");
			return 0;
		}
		if (ch != '\\') {
			/// must be escaped: U+0000 to U+0008, U+000A to U+001F, U+007F
			if ((ch >= 0 && ch <= 0x08) || (ch >= 0x0a && ch <= 0x1f) || ch == 0x7f) {
				if (!(multiline && (ch == '\r' || ch == '\n'))) {
					xfree(dst);
					snprintf(errbuf, errbufsz, "invalid char U+%04x", ch);
					return 0;
				}
			}

			dst[off++] = ch; /// a plain copy suffice
			continue;
		}

		if (sp >= sq) { /// ch was backslash. we expect the escape char.
			snprintf(errbuf, errbufsz, "last backslash is invalid");
			xfree(dst);
			return 0;
		}

		if (multiline) { /// for multi-line, we want to kill line-ending-backslash.
			if (sp[strspn(sp, " \t\r")] == '\n') { /// if there is only whitespace after the backslash ...
				sp += strspn(sp, " \t\r\n"); /// skip all the following whitespaces
				continue;
			}
		}

		ch = *sp++; /// get the escaped char
		switch (ch) {
			case 'u':
			case 'U': {
				int64_t ucs = 0;
				int nhex = (ch == 'u' ? 4 : 8);
				for (int i = 0; i < nhex; i++) {
					if (sp >= sq) {
						snprintf(errbuf, errbufsz, "\\%c expects %d hex chars", ch, nhex);
						xfree(dst);
						return 0;
					}
					ch = *sp++;
					int v = -1;
					if ('0' <= ch && ch <= '9')
						v = ch - '0';
					else if ('A' <= ch && ch <= 'F')
						v = ch - 'A' + 10;
					else if ('a' <= ch && ch <= 'f')
						v = (ch ^ 0x20) - 'A' + 10;
					if (v == -1) {
						snprintf(errbuf, errbufsz, "invalid hex chars for \\u or \\U");
						xfree(dst);
						return 0;
					}
					ucs = ucs * 16 + v;
				}
				int n = read_unicode_escape(ucs, &dst[off]);
				if (n == -1) {
					snprintf(errbuf, errbufsz, "illegal ucs code in \\u or \\U");
					xfree(dst);
					return 0;
				}
				off += n;
			}; continue;
			case 'b':  ch = '\b';  break;
			case 't':  ch = '\t';  break;
			case 'n':  ch = '\n';  break;
			case 'f':  ch = '\f';  break;
			case 'r':  ch = '\r';  break;
			case '"':  ch = '"';   break;
			case '\\': ch = '\\'; break;
			default:
				snprintf(errbuf, errbufsz, "illegal escape char \\%c", ch);
				xfree(dst);
				return 0;
		}

		dst[off++] = ch;
	}

	*len = off;
	dst[off++] = 0; /// Cap with NUL and return it.
	return dst;
}

// Normalize a key. Convert all special chars to raw unescaped utf-8 chars.
static char *normalize_key(context_t *ctx, token_t strtok, int *keylen) {
	const char *sp    = strtok.ptr;
	const char *sq    = strtok.ptr + strtok.len;
	int        lineno = strtok.lineno;
	int        ch     = *sp;
	char       *ret;

	// Quoted string
	if (ch == '\'' || ch == '\"') {
		/// if ''' or """, take 3 chars off front and back. Else, take 1 char off.
		bool multiline = (sp[1] == ch && sp[2] == ch);
		if (multiline)
			sp += 3, sq -= 3;
		else
			sp++, sq--;

		char ebuf[80];
		if (ch == '\'')
			ret = norm_lit_str(sp, sq - sp, keylen, multiline, true, ebuf, sizeof(ebuf));
		else
			ret = norm_basic_str(sp, sq - sp, keylen, multiline, true, ebuf, sizeof(ebuf));
		if (!ret) {
			e_syntax(ctx, lineno, ebuf);
			return 0;
		}
		return ret;
	}

	*keylen = 0;
	for (const char *c = sp; c != sq; c++) { /// Bare key: allow: [A-Za-z0-9_-]+
		*keylen = *keylen + 1;
		if (isalnum(*c) || *c == '_' || *c == '-')
			continue;
		e_badkey(ctx, lineno);
		return 0;
	}

	if (!(ret = STRNDUP(sp, sq - sp))) { /// dup and return
		e_outofmemory(ctx, FLINE);
		return 0;
	}
	return ret;
}

/* Look up key in tab. Return 0 if not found, or
 * 'v'alue, 'a'rray or 't'able depending on the element. */
static int check_key(toml_table_t *tab, const char *key, toml_keyval_t **ret_val, toml_array_t **ret_arr, toml_table_t **ret_tab) {
	int i;
	void *dummy;

	if (!ret_tab)
		ret_tab = (toml_table_t **)&dummy;
	if (!ret_arr)
		ret_arr = (toml_array_t **)&dummy;
	if (!ret_val)
		ret_val = (toml_keyval_t **)&dummy;

	*ret_tab = 0;
	*ret_arr = 0;
	*ret_val = 0;

	for (i = 0; i < tab->nkval; i++) {
		if (strcmp(key, tab->kval[i]->key) == 0) {
			*ret_val = tab->kval[i];
			return 'v';
		}
	}
	for (i = 0; i < tab->narr; i++) {
		if (strcmp(key, tab->arr[i]->key) == 0) {
			*ret_arr = tab->arr[i];
			return 'a';
		}
	}
	for (i = 0; i < tab->ntab; i++) {
		if (strcmp(key, tab->tab[i]->key) == 0) {
			*ret_tab = tab->tab[i];
			return 't';
		}
	}
	return 0;
}

static int key_kind(toml_table_t *tab, const char *key) {
	return check_key(tab, key, 0, 0, 0);
}

/* Create a keyval in the table. */
static toml_keyval_t *create_keyval_in_table(context_t *ctx, toml_table_t *tab, token_t keytok) {
	int keylen;
	char *newkey = normalize_key(ctx, keytok, &keylen);
	if (!newkey)
		return 0;

	toml_keyval_t *dest = 0;
	if (key_kind(tab, newkey)) {
		xfree(newkey);
		e_keyexists(ctx, keytok.lineno);
		return 0;
	}

	int n = tab->nkval;
	toml_keyval_t **base;
	if ((base = (toml_keyval_t **)expand_ptrarr((void **)tab->kval, n)) == 0) {
		xfree(newkey);
		e_outofmemory(ctx, FLINE);
		return 0;
	}
	tab->kval = base;

	if ((base[n] = (toml_keyval_t *)CALLOC(1, sizeof(*base[n]))) == 0) {
		xfree(newkey);
		e_outofmemory(ctx, FLINE);
		return 0;
	}

	dest = tab->kval[tab->nkval++];
	dest->key = newkey;
	dest->keylen = keylen;
	return dest;
}

// Create a table in the table.
static toml_table_t *create_keytable_in_table(context_t *ctx, toml_table_t *tab, token_t keytok) {
	int keylen;
	char *newkey = normalize_key(ctx, keytok, &keylen);
	if (!newkey)
		return 0;

	toml_table_t *dest = 0;
	if (check_key(tab, newkey, 0, 0, &dest)) {
		xfree(newkey);

		/// Special case: make explicit if table exists and was created
		/// implicitly.
		if (dest && dest->implicit) {
			dest->implicit = false;
			return dest;
		}
		e_keyexists(ctx, keytok.lineno);
		return 0;
	}

	int n = tab->ntab;
	toml_table_t **base;
	if ((base = (toml_table_t **)expand_ptrarr((void **)tab->tab, n)) == 0) {
		xfree(newkey);
		e_outofmemory(ctx, FLINE);
		return 0;
	}
	tab->tab = base;

	if ((base[n] = (toml_table_t *)CALLOC(1, sizeof(*base[n]))) == 0) {
		xfree(newkey);
		e_outofmemory(ctx, FLINE);
		return 0;
	}

	dest = tab->tab[tab->ntab++];
	dest->key = newkey;
	dest->keylen = keylen;
	return dest;
}

// Create an array in the table.
static toml_array_t *create_keyarray_in_table(context_t *ctx, toml_table_t *tab, token_t keytok, char kind) {
	int keylen;
	char *newkey = normalize_key(ctx, keytok, &keylen);
	if (!newkey)
		return 0;

	if (key_kind(tab, newkey)) {
		xfree(newkey);
		e_keyexists(ctx, keytok.lineno);
		return 0;
	}

	int n = tab->narr;
	toml_array_t **base;
	if ((base = (toml_array_t **)expand_ptrarr((void **)tab->arr, n)) == 0) {
		xfree(newkey);
		e_outofmemory(ctx, FLINE);
		return 0;
	}
	tab->arr = base;

	if ((base[n] = (toml_array_t *)CALLOC(1, sizeof(*base[n]))) == 0) {
		xfree(newkey);
		e_outofmemory(ctx, FLINE);
		return 0;
	}
	toml_array_t *dest = tab->arr[tab->narr++];

	dest->keylen = keylen;
	dest->key = newkey;
	dest->kind = kind;
	return dest;
}

static toml_arritem_t *create_value_in_array(context_t *ctx, toml_array_t *parent) {
	const int n = parent->nitem;
	toml_arritem_t *base = expand_arritem(parent->item, n);
	if (!base) {
		e_outofmemory(ctx, FLINE);
		return 0;
	}
	parent->item = base;
	parent->nitem++;
	return &parent->item[n];
}

/* Create an array in an array */
static toml_array_t *create_array_in_array(context_t *ctx,
		toml_array_t *parent) {
	const int n = parent->nitem;
	toml_arritem_t *base = expand_arritem(parent->item, n);
	if (!base) {
		e_outofmemory(ctx, FLINE);
		return 0;
	}
	toml_array_t *ret = (toml_array_t *)CALLOC(1, sizeof(toml_array_t));
	if (!ret) {
		e_outofmemory(ctx, FLINE);
		return 0;
	}
	base[n].arr = ret;
	parent->item = base;
	parent->nitem++;
	return ret;
}

/* Create a table in an array */
static toml_table_t *create_table_in_array(context_t *ctx, toml_array_t *parent) {
	int n = parent->nitem;
	toml_arritem_t *base = expand_arritem(parent->item, n);
	if (!base) {
		e_outofmemory(ctx, FLINE);
		return 0;
	}
	toml_table_t *ret = (toml_table_t *)CALLOC(1, sizeof(toml_table_t));
	if (!ret) {
		e_outofmemory(ctx, FLINE);
		return 0;
	}
	base[n].tab = ret;
	parent->item = base;
	parent->nitem++;
	return ret;
}

static int skip_newlines(context_t *ctx, bool isdotspecial) {
	while (ctx->tok.tok == NEWLINE) {
		if (next_token(ctx, isdotspecial))
			return -1;
		if (ctx->tok.eof)
			break;
	}
	return 0;
}

static int parse_keyval(context_t *ctx, toml_table_t *tab);

static inline int eat_token(context_t *ctx, tokentype_t typ, bool isdotspecial, const char *fline) {
	if (ctx->tok.tok != typ)
		return e_internal(ctx, fline);

	if (next_token(ctx, isdotspecial))
		return -1;

	return 0;
}

/* We are at '{ ... }'; parse the table. */
static int parse_inline_table(context_t *ctx, toml_table_t *tab) {
	if (eat_token(ctx, LBRACE, 1, FLINE))
		return -1;

	for (;;) {
		if (ctx->tok.tok == NEWLINE)
			return e_syntax(ctx, ctx->tok.lineno, "newline not allowed in inline table");

		if (ctx->tok.tok == RBRACE) // until closing brace
			break;

		if (ctx->tok.tok != STRING)
			return e_syntax(ctx, ctx->tok.lineno, "expect a string");

		if (parse_keyval(ctx, tab))
			return -1;

		if (ctx->tok.tok == NEWLINE)
			return e_syntax(ctx, ctx->tok.lineno, "newline not allowed in inline table");

		/* on comma, continue to scan for next keyval */
		if (ctx->tok.tok == COMMA) {
			if (eat_token(ctx, COMMA, 1, FLINE))
				return -1;
			continue;
		}
		break;
	}

	if (eat_token(ctx, RBRACE, 1, FLINE))
		return -1;
	tab->readonly = 1;
	return 0;
}

static int valtype(const char *val) {
	toml_timestamp_t ts;
	if (*val == '\'' || *val == '"')
		return 's';
	if (toml_value_bool(val, false) == 0)
		return 'b';
	if (toml_value_int(val, 0) == 0)
		return 'i';
	if (toml_value_double(val, 0) == 0)
		return 'd';
	if (toml_value_timestamp(val, &ts) == 0) {
		if (ts.year && ts.hour)
			return 'T'; /// timestamp
		if (ts.year)
			return 'D'; /// date
		return 't';   /// time
	}
	return 'u'; /// unknown
}

/* We are at '[...]' */
static int parse_array(context_t *ctx, toml_array_t *arr) {
	if (eat_token(ctx, LBRACKET, 0, FLINE))
		return -1;

	for (;;) {
		if (skip_newlines(ctx, 0))
			return -1;

		if (ctx->tok.tok == RBRACKET) /// until ]
			break;

		switch (ctx->tok.tok) {
			case STRING: {
				/// set array kind if this will be the first entry
				if (arr->kind == 0)
					arr->kind = 'v';
				else if (arr->kind != 'v')
					arr->kind = 'm';

				char *val = ctx->tok.ptr;
				int vlen = ctx->tok.len;

				/// make a new value in array
				toml_arritem_t *newval = create_value_in_array(ctx, arr);
				if (!newval)
					return e_outofmemory(ctx, FLINE);

				if (!(newval->val = STRNDUP(val, vlen)))
					return e_outofmemory(ctx, FLINE);

				newval->valtype = valtype(newval->val);

				/// set array type if this is the first entry
				if (arr->nitem == 1)
					arr->type = newval->valtype;
				else if (arr->type != newval->valtype)
					arr->type = 'm'; /// mixed

				if (eat_token(ctx, ctx->tok.tok, 0, FLINE))
					return -1;
				break;
			}
			case LBRACKET: { /* [ [array], [array] ... ] */
				/* set the array kind if this will be the first entry */
				if (arr->kind == 0)
					arr->kind = 'a';
				else if (arr->kind != 'a')
					arr->kind = 'm';

				toml_array_t *subarr = create_array_in_array(ctx, arr);
				if (!subarr)
					return -1;
				if (parse_array(ctx, subarr))
					return -1;
				break;
			}
			case LBRACE: { /* [ {table}, {table} ... ] */
				/* set the array kind if this will be the first entry */
				if (arr->kind == 0)
					arr->kind = 't';
				else if (arr->kind != 't')
					arr->kind = 'm';

				toml_table_t *subtab = create_table_in_array(ctx, arr);
				if (!subtab)
					return -1;
				if (parse_inline_table(ctx, subtab))
					return -1;
				break;
			}
			default:
				return e_syntax(ctx, ctx->tok.lineno, "syntax error");
		}

		if (skip_newlines(ctx, 0))
			return -1;

		/* on comma, continue to scan for next element */
		if (ctx->tok.tok == COMMA) {
			if (eat_token(ctx, COMMA, 0, FLINE))
				return -1;
			continue;
		}
		break;
	}

	if (eat_token(ctx, RBRACKET, 1, FLINE))
		return -1;
	return 0;
}

/* handle lines like these:
   key = "value"
   key = [ array ]
   key = { table } */
static int parse_keyval(context_t *ctx, toml_table_t *tab) {
	if (tab->readonly) {
		return e_forbid(ctx, ctx->tok.lineno, "cannot insert new entry into existing table");
	}

	token_t key = ctx->tok;
	if (eat_token(ctx, STRING, 1, FLINE))
		return -1;

	if (ctx->tok.tok == DOT) {
		/* handle inline dotted key. e.g.
		   physical.color = "orange"
		   physical.shape = "round" */
		toml_table_t *subtab = 0;
		{
			int keylen;
			char *subtabstr = normalize_key(ctx, key, &keylen);
			if (!subtabstr)
				return -1;

			subtab = toml_table_table(tab, subtabstr);
			if (subtab)
				subtab->keylen = keylen;
			xfree(subtabstr);
		}
		if (!subtab) {
			subtab = create_keytable_in_table(ctx, tab, key);
			if (!subtab)
				return -1;
		}
		if (next_token(ctx, true))
			return -1;
		if (parse_keyval(ctx, subtab))
			return -1;
		return 0;
	}

	if (ctx->tok.tok != EQUAL)
		return e_syntax(ctx, ctx->tok.lineno, "missing =");

	if (next_token(ctx, false))
		return -1;

	switch (ctx->tok.tok) {
		case STRING: { // key = "value"
			toml_keyval_t *keyval = create_keyval_in_table(ctx, tab, key);
			if (!keyval)
				return -1;
			token_t val = ctx->tok;

			assert(keyval->val == 0);
			if (!(keyval->val = STRNDUP(val.ptr, val.len)))
				return e_outofmemory(ctx, FLINE);

			if (next_token(ctx, true))
				return -1;

			return 0;
		}
		case LBRACKET: { /* key = [ array ] */
			toml_array_t *arr = create_keyarray_in_table(ctx, tab, key, 0);
			if (!arr)
				return -1;
			if (parse_array(ctx, arr))
				return -1;
			return 0;
		}
		case LBRACE: { /* key = { table } */
			toml_table_t *nxttab = create_keytable_in_table(ctx, tab, key);
			if (!nxttab)
				return -1;
			if (parse_inline_table(ctx, nxttab))
				return -1;
			return 0;
		}
		default:
			return e_syntax(ctx, ctx->tok.lineno, "syntax error");
	}
	return 0;
}

typedef struct tabpath_t tabpath_t;
struct tabpath_t {
	int cnt;
	token_t key[10];
};

/* at [x.y.z] or [[x.y.z]]
 * Scan forward and fill tabpath until it enters ] or ]]
 * There will be at least one entry on return. */
static int fill_tabpath(context_t *ctx) {
	// clear tpath
	for (int i = 0; i < ctx->tpath.top; i++) {
		char **p = &ctx->tpath.key[i];
		xfree(*p);
		*p = 0;
	}
	ctx->tpath.top = 0;

	for (;;) {
		if (ctx->tpath.top >= 10)
			return e_syntax(ctx, ctx->tok.lineno, "table path is too deep; max allowed is 10.");
		if (ctx->tok.tok != STRING)
			return e_syntax(ctx, ctx->tok.lineno, "invalid or missing key");

		int keylen;
		char *key = normalize_key(ctx, ctx->tok, &keylen);
		if (!key)
			return -1;
		ctx->tpath.tok[ctx->tpath.top] = ctx->tok;
		ctx->tpath.key[ctx->tpath.top] = key;
		ctx->tpath.keylen[ctx->tpath.top] = keylen;
		ctx->tpath.top++;

		if (next_token(ctx, true))
			return -1;

		if (ctx->tok.tok == RBRACKET)
			break;
		if (ctx->tok.tok != DOT)
			return e_syntax(ctx, ctx->tok.lineno, "invalid key");
		if (next_token(ctx, true))
			return -1;
	}

	if (ctx->tpath.top <= 0)
		return e_syntax(ctx, ctx->tok.lineno, "empty table selector");
	return 0;
}

/* Walk tabpath from the root, and create new tables on the way.
 * Sets ctx->curtab to the final table. */
static int walk_tabpath(context_t *ctx) {
	toml_table_t *curtab = ctx->root; /// start from root

	for (int i = 0; i < ctx->tpath.top; i++) {
		const char *key = ctx->tpath.key[i];
		int keylen = ctx->tpath.keylen[i];

		toml_keyval_t *nextval = 0;
		toml_array_t *nextarr = 0;
		toml_table_t *nexttab = 0;
		switch (check_key(curtab, key, &nextval, &nextarr, &nexttab)) {
			case 't': /// found a table. nexttab is where we will go next.
				break;
			case 'a': /// found an array. nexttab is the last table in the array.
				if (nextarr->kind != 't')
					return e_internal(ctx, FLINE);

				if (nextarr->nitem == 0)
					return e_internal(ctx, FLINE);

				nexttab = nextarr->item[nextarr->nitem - 1].tab;
				break;
			case 'v':
				return e_keyexists(ctx, ctx->tpath.tok[i].lineno);
			default: { /// Not found. Let's create an implicit table.
				int n = curtab->ntab;
				toml_table_t **base = (toml_table_t **)expand_ptrarr((void **)curtab->tab, n);
				if (base == 0)
					return e_outofmemory(ctx, FLINE);

				curtab->tab = base;

				if ((base[n] = (toml_table_t *)CALLOC(1, sizeof(*base[n]))) == 0)
					return e_outofmemory(ctx, FLINE);

				if ((base[n]->key = STRDUP(key)) == 0)
					return e_outofmemory(ctx, FLINE);
				base[n]->keylen = keylen;

				nexttab = curtab->tab[curtab->ntab++];

				/// tabs created by walk_tabpath are considered implicit
				nexttab->implicit = true;
			}; break;
		}
		curtab = nexttab; /// switch to next tab
	}

	ctx->curtab = curtab; /// save it
	return 0;
}

/* handle lines like [x.y.z] or [[x.y.z]] */
static int parse_select(context_t *ctx) {
	assert(ctx->tok.tok == LBRACKET);

	/* true if [[ */
	int llb = (ctx->tok.ptr + 1 < ctx->stop && ctx->tok.ptr[1] == '[');
	/* need to detect '[[' on our own because next_token() will skip whitespace,
	   and '[ [' would be taken as '[[', which is wrong. */

	/* eat [ or [[ */
	if (eat_token(ctx, LBRACKET, 1, FLINE))
		return -1;
	if (llb) {
		assert(ctx->tok.tok == LBRACKET);
		if (eat_token(ctx, LBRACKET, 1, FLINE))
			return -1;
	}

	if (fill_tabpath(ctx))
		return -1;

	/* For [x.y.z] or [[x.y.z]], remove z from tpath. */
	token_t z = ctx->tpath.tok[ctx->tpath.top - 1];
	xfree(ctx->tpath.key[ctx->tpath.top - 1]);
	ctx->tpath.top--;

	/* set up ctx->curtab */
	if (walk_tabpath(ctx))
		return -1;

	if (!llb) {
		/* [x.y.z] -> create z = {} in x.y */
		toml_table_t *curtab = create_keytable_in_table(ctx, ctx->curtab, z);
		if (!curtab)
			return -1;
		ctx->curtab = curtab;
	} else {
		/* [[x.y.z]] -> create z = [] in x.y */
		toml_array_t *arr = 0;
		{
			int keylen;
			char *zstr = normalize_key(ctx, z, &keylen);
			if (!zstr)
				return -1;
			arr = toml_table_array(ctx->curtab, zstr);
			if (arr)
				arr->keylen = keylen;
			xfree(zstr);
		}
		if (!arr) {
			arr = create_keyarray_in_table(ctx, ctx->curtab, z, 't');
			if (!arr)
				return -1;
		}
		if (arr->kind != 't')
			return e_syntax(ctx, z.lineno, "array mismatch");

		/* add to z[] */
		toml_table_t *dest;
		{
			toml_table_t *t = create_table_in_array(ctx, arr);
			if (!t)
				return -1;

			if ((t->key = STRDUP("__anon__")) == 0)
				return e_outofmemory(ctx, FLINE);

			dest = t;
		}

		ctx->curtab = dest;
	}

	if (ctx->tok.tok != RBRACKET) {
		return e_syntax(ctx, ctx->tok.lineno, "expects ]");
	}
	if (llb) {
		if (!(ctx->tok.ptr + 1 < ctx->stop && ctx->tok.ptr[1] == ']')) {
			return e_syntax(ctx, ctx->tok.lineno, "expects ]]");
		}
		if (eat_token(ctx, RBRACKET, 1, FLINE))
			return -1;
	}

	if (eat_token(ctx, RBRACKET, 1, FLINE))
		return -1;
	if (ctx->tok.tok != NEWLINE)
		return e_syntax(ctx, ctx->tok.lineno, "extra chars after ] or ]]");
	return 0;
}

toml_table_t *toml_parse(char *toml, char *errbuf, int errbufsz) {
	context_t ctx;

	/// clear errbuf
	if (errbufsz <= 0)
		errbufsz = 0;
	if (errbufsz > 0)
		errbuf[0] = 0;

	// init context
	memset(&ctx, 0, sizeof(ctx));
	ctx.start = toml;
	ctx.stop = ctx.start + strlen(toml);
	ctx.errbuf = errbuf;
	ctx.errbufsz = errbufsz;

	// start with an artificial newline of length 0
	ctx.tok.tok = NEWLINE;
	ctx.tok.lineno = 1;
	ctx.tok.ptr = toml;
	ctx.tok.len = 0;

	// make a root table
	if ((ctx.root = CALLOC(1, sizeof(*ctx.root))) == 0) {
		e_outofmemory(&ctx, FLINE);
		return 0; // Do not goto fail, root table not set up yet
	}

	// set root as default table
	ctx.curtab = ctx.root;

	// Scan forward until EOF
	for (token_t tok = ctx.tok; !tok.eof; tok = ctx.tok) {
		switch (tok.tok) {
			case NEWLINE:
				if (next_token(&ctx, true))
					goto fail;
				break;

			case STRING:
				if (parse_keyval(&ctx, ctx.curtab))
					goto fail;

				if (ctx.tok.tok != NEWLINE) {
					e_syntax(&ctx, ctx.tok.lineno, "extra chars after value");
					goto fail;
				}

				if (eat_token(&ctx, NEWLINE, 1, FLINE))
					goto fail;
				break;

			case LBRACKET: /* [ x.y.z ] or [[ x.y.z ]] */
				if (parse_select(&ctx))
					goto fail;
				break;

			default:
				e_syntax(&ctx, tok.lineno, "syntax error");
				goto fail;
		}
	}

	/// success
	for (int i = 0; i < ctx.tpath.top; i++)
		xfree(ctx.tpath.key[i]);
	return ctx.root;

fail:
	// Something bad has happened. Free resources and return error.
	for (int i = 0; i < ctx.tpath.top; i++)
		xfree(ctx.tpath.key[i]);
	toml_free(ctx.root);
	return 0;
}

toml_table_t *toml_parse_file(FILE *fp, char *errbuf, int errbufsz) {
	int bufsz = 0;
	char *buf = 0;
	int off = 0;
	int inc = 1024;

	while (!feof(fp)) {
		if (bufsz == 1024 * 20) /// Increment buffer by 20k after 20k.
			inc = 1024 * 20;
		if (off == bufsz) {
			int xsz = bufsz + inc;
			char *x = expand(buf, bufsz, xsz);
			if (!x) {
				snprintf(errbuf, errbufsz, "out of memory");
				xfree(buf);
				return 0;
			}
			buf = x;
			bufsz = xsz;
		}

		errno = 0;
		int n = fread(buf + off, 1, bufsz - off, fp);
		if (ferror(fp)) {
			snprintf(errbuf, errbufsz, "%s", (errno ? strerror(errno) : "Error reading file"));
			xfree(buf);
			return 0;
		}
		off += n;
	}

	/// tag on a NUL to cap the string
	if (off == bufsz) {
		int xsz = bufsz + 1;
		char *x = expand(buf, bufsz, xsz);
		if (!x) {
			snprintf(errbuf, errbufsz, "out of memory");
			xfree(buf);
			return 0;
		}
		buf = x;
		bufsz = xsz;
	}
	buf[off] = 0;

	/// parse it, cleanup and finish.
	toml_table_t *ret = toml_parse(buf, errbuf, errbufsz);
	xfree(buf);
	return ret;
}

static void xfree_kval(toml_keyval_t *p) {
	if (!p)
		return;
	xfree(p->key);
	xfree(p->val);
	xfree(p);
}

static void xfree_tab(toml_table_t *p);

static void xfree_arr(toml_array_t *p) {
	if (!p)
		return;

	xfree(p->key);
	const int n = p->nitem;
	for (int i = 0; i < n; i++) {
		toml_arritem_t *a = &p->item[i];
		if (a->val)
			xfree(a->val);
		else if (a->arr)
			xfree_arr(a->arr);
		else if (a->tab)
			xfree_tab(a->tab);
	}
	xfree(p->item);
	xfree(p);
}

static void xfree_tab(toml_table_t *p) {
	if (!p)
		return;

	xfree(p->key);

	for (int i = 0; i < p->nkval; i++)
		xfree_kval(p->kval[i]);
	xfree(p->kval);

	for (int i = 0; i < p->narr; i++)
		xfree_arr(p->arr[i]);
	xfree(p->arr);

	for (int i = 0; i < p->ntab; i++)
		xfree_tab(p->tab[i]);
	xfree(p->tab);

	xfree(p);
}

void toml_free(toml_table_t *tab) { xfree_tab(tab); }

static void set_token(context_t *ctx, tokentype_t tok, int lineno, char *ptr, int len) {
	token_t t;
	t.tok    = tok;
	t.lineno = lineno;
	t.ptr    = ptr;
	t.len    = len;
	t.eof    = 0;
	ctx->tok = t;
}

static void set_eof(context_t *ctx, int lineno) {
	set_token(ctx, NEWLINE, lineno, ctx->stop, 0);
	ctx->tok.eof = 1;
}

/* Scan p for n digits compositing entirely of [0-9] */
static int scan_digits(const char *p, int n) {
	int ret = 0;
	for (; n > 0 && isdigit(*p); n--, p++) {
		ret = 10 * ret + (*p - '0');
	}
	return n ? -1 : ret;
}

static int scan_date(const char *p, int *YY, int *MM, int *DD) {
	int year, month, day;
	year = scan_digits(p, 4);
	month = (year >= 0 && p[4] == '-') ? scan_digits(p + 5, 2) : -1;
	day = (month >= 0 && p[7] == '-') ? scan_digits(p + 8, 2) : -1;
	if (YY)
		*YY = year;
	if (MM)
		*MM = month;
	if (DD)
		*DD = day;
	return (year >= 0 && month >= 0 && day >= 0) ? 0 : -1;
}

static int scan_time(const char *p, int *hh, int *mm, int *ss) {
	int hour = scan_digits(p, 2);
	int minute = (hour >= 0 && p[2] == ':') ? scan_digits(p + 3, 2) : -1;
	int second = (minute >= 0 && p[5] == ':') ? scan_digits(p + 6, 2) : -1;
	if (hh)
		*hh = hour;
	if (mm)
		*mm = minute;
	if (ss)
		*ss = second;
	return (hour >= 0 && minute >= 0 && second >= 0) ? 0 : -1;
}

static int scan_string(context_t *ctx, char *p, int lineno, bool dotisspecial) {
	char *orig = p;

	// Literal multiline.
	if (strncmp(p, "'''", 3) == 0) {
		char *q = p + 3;
		while (true) {
			q = strstr(q, "'''");
			if (q == 0)
				return e_syntax(ctx, lineno, "unterminated triple-s-quote");
			int i = 0;
			while (q[3] == '\'') {
				i++;
				if (i >= 3)
					return e_syntax(ctx, lineno, "too many ''' in triple-s-quote");
				q++;
			}
			break;
		}
		set_token(ctx, STRING, lineno, orig, q + 3 - orig);
		return 0;
	}

	// Multiline.
	if (strncmp(p, "\"\"\"", 3) == 0) {
		char *q = p + 3;
		while (true) {
			q = strstr(q, "\"\"\"");
			if (q == 0)
				return e_syntax(ctx, lineno, "unterminated triple-d-quote");
			if (q[-1] == '\\') {
				q++;
				continue;
			}
			int i = 0;
			while (q[3] == '\"') {
				i++;
				if (i >= 3)
					return e_syntax(ctx, lineno, "too many \"\"\" in triple-d-quote");
				q++;
			}
			break;
		}

		/// the string is [p+3, q-1]
		int hexreq = 0; /// #hex required
		bool escape = false;
		for (p += 3; p < q; p++) {
			if (escape) {
				escape = false;
				if (strchr("btnfr\"\\", *p))
					continue;
				if (*p == 'u') {
					hexreq = 4;
					continue;
				}
				if (*p == 'U') {
					hexreq = 8;
					continue;
				}
				if (p[strspn(p, " \t\r")] == '\n')
					continue; /* allow for line ending backslash */
				return e_syntax(ctx, lineno, "bad escape char");
			}
			if (hexreq) {
				hexreq--;
				if (strchr("0123456789ABCDEFabcdef", *p))
					continue;
				return e_syntax(ctx, lineno, "expect hex char");
			}
			if (*p == '\\') {
				escape = true;
				continue;
			}
		}
		if (escape)
			return e_syntax(ctx, lineno, "expect an escape char");
		if (hexreq)
			return e_syntax(ctx, lineno, "expected more hex char");

		set_token(ctx, STRING, lineno, orig, q + 3 - orig);
		return 0;
	}

	// Literal string.
	if (*p == '\'') {
		for (p++; *p && *p != '\n' && *p != '\''; p++)
			;
		if (*p != '\'')
			return e_syntax(ctx, lineno, "unterminated s-quote");

		set_token(ctx, STRING, lineno, orig, p + 1 - orig);
		return 0;
	}

	// Basic String.
	if (*p == '\"') {
		int hexreq = 0; /// #hex required
		bool escape = false;
		for (p++; *p; p++) {
			if (escape) {
				escape = false;
				if (strchr("btnfr\"\\", *p))
					continue;
				if (*p == 'u') {
					hexreq = 4;
					continue;
				}
				if (*p == 'U') {
					hexreq = 8;
					continue;
				}
				return e_syntax(ctx, lineno, "bad escape char");
			}
			if (hexreq) {
				hexreq--;
				if (strchr("0123456789ABCDEFabcdef", *p))
					continue;
				return e_syntax(ctx, lineno, "expect hex char");
			}
			if (*p == '\\') {
				escape = true;
				continue;
			}
			if (*p == '\n')
				break;
			if (*p == '"')
				break;
		}
		if (*p != '"')
			return e_syntax(ctx, lineno, "unterminated quote");

		set_token(ctx, STRING, lineno, orig, p + 1 - orig);
		return 0;
	}

	// Datetime.
	if (scan_date(p, 0, 0, 0) == 0 || scan_time(p, 0, 0, 0) == 0) {
		p += strspn(p, "0123456789.:+-Tt Zz"); /// forward thru the timestamp
		for (; p[-1] == ' '; p--) /// squeeze out any spaces at end of string
			;
		set_token(ctx, STRING, lineno, orig, p - orig); /// tokenize
		return 0;
	}

	// literals
	for (; *p && *p != '\n'; p++) {
		int ch = *p;
		if (ch == '.' && dotisspecial)
			break;
		if ('A' <= ch && ch <= 'Z')
			continue;
		if ('a' <= ch && ch <= 'z')
			continue;
		if (strchr("0123456789+-_.", ch))
			continue;
		break;
	}

	set_token(ctx, STRING, lineno, orig, p - orig);
	return 0;
}

static int next_token(context_t *ctx, bool dotisspecial) {
	// Eat this tok.
	char *p = ctx->tok.ptr;
	int lineno = ctx->tok.lineno;
	for (int i = 0; i < ctx->tok.len; i++)
		if (*p++ == '\n')
			lineno++;

	/// Make next tok
	while (p < ctx->stop) {
		if (*p == '#') { /// Skip comment. stop just before the \n.
			for (p++; p < ctx->stop && *p != '\n'; p++)
				;
			continue;
		}

		if (dotisspecial && *p == '.') {
			set_token(ctx, DOT, lineno, p, 1);
			return 0;
		}

		switch (*p) {
			case ',':
				set_token(ctx, COMMA, lineno, p, 1);
				return 0;
			case '=':
				set_token(ctx, EQUAL, lineno, p, 1);
				return 0;
			case '{':
				set_token(ctx, LBRACE, lineno, p, 1);
				return 0;
			case '}':
				set_token(ctx, RBRACE, lineno, p, 1);
				return 0;
			case '[':
				set_token(ctx, LBRACKET, lineno, p, 1);
				return 0;
			case ']':
				set_token(ctx, RBRACKET, lineno, p, 1);
				return 0;
			case '\n':
				set_token(ctx, NEWLINE, lineno, p, 1);
				return 0;
			case '\r': case ' ': case '\t': /// ignore white spaces
				p++;
				continue;
		}

		return scan_string(ctx, p, lineno, dotisspecial);
	}

	set_eof(ctx, lineno);
	return 0;
}

const char *toml_table_key(const toml_table_t *tab, int keyidx, int *keylen) {
	if (keyidx < tab->nkval) {
		*keylen = tab->kval[keyidx]->keylen;
		return    tab->kval[keyidx]->key;
	}
	if ((keyidx -= tab->nkval) < tab->narr) {
		*keylen = tab->arr[keyidx]->keylen;
		return    tab->arr[keyidx]->key;
	}
	if ((keyidx -= tab->narr) < tab->ntab) {
		*keylen = tab->tab[keyidx]->keylen;
		return    tab->tab[keyidx]->key;
	}
	*keylen = 0;
	return 0;
}

toml_unparsed_t toml_table_unparsed(const toml_table_t *tab, const char *key) {
	for (int i = 0; i < tab->nkval; i++)
		if (strcmp(key, tab->kval[i]->key) == 0)
			return tab->kval[i]->val;
	return 0;
}

toml_array_t *toml_table_array(const toml_table_t *tab, const char *key) {
	for (int i = 0; i < tab->narr; i++)
		if (strcmp(key, tab->arr[i]->key) == 0)
			return tab->arr[i];
	return 0;
}

toml_table_t *toml_table_table(const toml_table_t *tab, const char *key) {
	for (int i  = 0; i < tab->ntab; i++)
		if (strcmp(key, tab->tab[i]->key) == 0)
			return tab->tab[i];
	return 0;
}

toml_unparsed_t toml_array_unparsed(const toml_array_t *arr, int idx) {
	return (0 <= idx && idx < arr->nitem) ? arr->item[idx].val : 0;
}

int toml_table_len(const toml_table_t *tbl) {
	return tbl->nkval + tbl->narr + tbl->ntab;
}

int toml_array_len(const toml_array_t *arr) {
	return arr->nitem;
}

toml_array_t *toml_array_array(const toml_array_t *arr, int idx) {
	return (0 <= idx && idx < arr->nitem) ? arr->item[idx].arr : 0;
}

toml_table_t *toml_array_table(const toml_array_t *arr, int idx) {
	return (0 <= idx && idx < arr->nitem) ? arr->item[idx].tab : 0;
}

static int parse_millisec(const char *p, const char **endp);

bool is_leap(int y) { return y % 4 == 0 && (y % 100 != 0 || y % 400 == 0); }

int toml_value_timestamp(toml_unparsed_t src_, toml_timestamp_t *ret) {
	if (!src_)
		return -1;

	const char *p = src_;
	bool must_parse_time = false;

	memset(ret, 0, sizeof(*ret));

	/// YYYY-MM-DD
	if (scan_date(p, &ret->year, &ret->month, &ret->day) == 0) {
		if (ret->month < 1 || ret->day < 1 || ret->month > 12 || ret->day > 31)
			return -1;
		if (ret->month == 2 && ret->day > (is_leap(ret->year) ? 29 : 28))
			return -1;
		ret->kind = 'D';

		p += 10;
		if (*p) {
			if (*p != 'T' && *p != 't' && *p != ' ') /// T or space
				return -1;
			must_parse_time = true;
			p++;
		}
	}

	/// HH:MM:SS
	if (scan_time(p, &ret->hour, &ret->minute, &ret->second) == 0) {
		if (ret->second < 0 || ret->minute < 0 || ret->hour < 0 || ret->hour > 23 || ret->minute > 59 || ret->second > 60)
			return -1;
		ret->kind = (ret->kind == 'D' ? 'l' : 't');

		p += 8;
		if (*p == '.') { /// optionally, parse millisec
			p++; /// skip '.'
			const char *qq;
			ret->millisec = parse_millisec(p, &qq);
			p = qq;
		}

		if (*p) { /// parse and copy Z
			ret->kind = 'd';
			char *z = malloc(10);
			ret->z = z;
			if (*p == 'Z' || *p == 'z') {
				*z++ = 'Z';
				p++;
				*z = 0;
			} else if (*p == '+' || *p == '-') {
				*z++ = *p++;

				if (!(isdigit(p[0]) && isdigit(p[1])))
					return -1;
				*z++ = *p++;
				*z++ = *p++;

				if (*p == ':') {
					*z++ = *p++;
					if (!(isdigit(p[0]) && isdigit(p[1])))
						return -1;
					*z++ = *p++;
					*z++ = *p++;
				}

				*z = 0;
			}
		}
	}
	if (*p != 0)
		return -1;
	if (must_parse_time && ret->kind == 'D')
		return -1;
	return 0;
}

/* Raw to boolean */
int toml_value_bool(toml_unparsed_t src, bool *ret_) {
	if (!src)
		return -1;
	bool dummy;
	bool *ret = ret_ ? ret_ : &dummy;

	if (strcmp(src, "true") == 0) {
		*ret = true;
		return 0;
	}
	if (strcmp(src, "false") == 0) {
		*ret = false;
		return 0;
	}
	return -1;
}

/* Raw to integer */
int toml_value_int(toml_unparsed_t src, int64_t *ret_) {
	if (!src)
		return -1;

	char buf[100];
	char *p = buf;
	char *q = p + sizeof(buf);
	const char *s = src;
	int base = 0;
	int64_t dummy;
	int64_t *ret = ret_ ? ret_ : &dummy;
	bool have_sign = false;

	if (s[0] == '+' || s[0] == '-') { /// allow +/-
		have_sign = true;
		*p++ = *s++;
	}

	if (s[0] == '_') /// disallow +_100
		return -1;

	if (s[0] == '0') { /// if 0* ...
		switch (s[1]) {
			case 'x': base = 16; s += 2; break;
			case 'o': base = 8;  s += 2; break;
			case 'b': base = 2;  s += 2; break;
			case '\0':
				return *ret = 0, 0;
			default:
				if (s[1]) /// ensure no other digits after it
					return -1;
		}
		if (!*s)
			return -1;
		if (have_sign)   /// disallow +0xff, -0xff
			return -1;
		if (s[0] == '_') /// disallow 0x_, 0o_, 0b_
			return -1;
	}

	while (*s && p < q) { /// just strip underscores and pass to strtoll
		int ch = *s++;
		if (ch == '_') {
			if (s[0] == '_')  /// disallow '__'
				return -1;
			if (s[0] == '\0') /// numbers cannot end with '_'
				return -1;
			continue; /// skip _
		}
		*p++ = ch;
	}

	if (*s || p == q) /// if not at end-of-string or we ran out of buffer ...
		return -1;

	*p = 0; /// cap with NUL

	/// Run strtoll on buf to get the integer
	char *endp;
	errno = 0;
	*ret = strtoll(buf, &endp, base);
	return (errno || *endp) ? -1 : 0;
}

int toml_value_double(toml_unparsed_t src, double *ret_) {
	if (!src)
		return -1;

	char buf[100];
	char *p = buf;
	char *q = p + sizeof(buf);
	const char *s = src;
	double dummy;
	double *ret = ret_ ? ret_ : &dummy;
	bool have_us = false;

	if (s[0] == '+' || s[0] == '-') /// allow +/-
		*p++ = *s++;

	if (s[0] == '_') /// disallow +_1.00
		return -1;

	{ /// decimal point, if used, must be surrounded by at least one digit on each side
		char *dot = strchr(s, '.');
		if (dot) {
			if (dot == s || !isdigit(dot[-1]) || !isdigit(dot[1]))
				return -1;
		}
	}

	/// zero must be followed by . or 'e', or NUL
	if (s[0] == '0' && s[1] && !strchr("eE.", s[1]))
		return -1;

	/// just strip underscores and pass to strtod
	while (*s && p < q) {
		int ch = *s++;
		if (ch == '_') {
			have_us = true;
			if (s[0] == '_') /// disallow '__'
				return -1;
			if (s[0] == 'e') /// disallow _e
				return -1;
			if (s[0] == 0)   /// disallow last char '_'
				return -1;
			continue; /// skip _
		}
		if (ch == 'I' || ch == 'N' || ch == 'F' || ch == 'A') /// inf and nan are case-sensitive.
			return -1;
		if (ch == 'e' && s[0] == '_') /// disallow e_
			return -1;
		*p++ = ch;
	}
	if (*s || p == q)
		return -1; /// reached end of string or buffer is full?

	*p = 0; /// cap with NUL

	/// Run strtod on buf to get the value
	char *endp;
	errno = 0;
	*ret = strtod(buf, &endp);
	if (errno || *endp)
		return -1;
	if (have_us && (isnan(*ret) || isinf(*ret)))
		return -1;
	return 0;
}

int toml_value_string(toml_unparsed_t src, char **ret, int *len) {
	bool multiline = false;
	const char *sp;
	const char *sq;

	*ret = 0;
	if (!src)
		return -1;

	/// First char must be a s-quote or d-quote
	int qchar = src[0];
	int srclen = strlen(src);
	if (!(qchar == '\'' || qchar == '"')) {
		return -1;
	}

	/// triple quotes?
	if (qchar == src[1] && qchar == src[2]) {
		multiline = true;      /// triple-quote implies multiline
		sp = src + 3;          /// first char after quote
		sq = src + srclen - 3; /// first char of ending quote

		if (!(sp <= sq && sq[0] == qchar && sq[1] == qchar && sq[2] == qchar))
			return -1; /// last 3 chars in src must be qchar

		if (sp[0] == '\n') /// skip new line immediate after qchar
			sp++;
		else if (sp[0] == '\r' && sp[1] == '\n')
			sp += 2;
	} else {
		sp = src + 1;          /// first char after quote
		sq = src + srclen - 1; /// ending quote
		if (!(sp <= sq && *sq == qchar)) /// last char in src must be qchar
			return -1;
	}

	/// at this point:
	///     sp points to first valid char after quote.
	///     sq points to one char beyond last valid char.
	///     string len is (sq - sp).
	if (qchar == '\'')
		*ret = norm_lit_str(sp, sq - sp, len, multiline, false, 0, 0);
	else
		*ret = norm_basic_str(sp, sq - sp, len, multiline, false, 0, 0);
	return *ret ? 0 : -1;
}

toml_value_t toml_array_string(const toml_array_t *arr, int idx) {
	toml_value_t ret;
	memset(&ret, 0, sizeof(ret));
	ret.ok = (toml_value_string(toml_array_unparsed(arr, idx), &ret.u.s, &ret.u.sl) == 0);
	return ret;
}

toml_value_t toml_array_bool(const toml_array_t *arr, int idx) {
	toml_value_t ret;
	memset(&ret, 0, sizeof(ret));
	ret.ok = (toml_value_bool(toml_array_unparsed(arr, idx), &ret.u.b) == 0);
	return ret;
}

toml_value_t toml_array_int(const toml_array_t *arr, int idx) {
	toml_value_t ret;
	memset(&ret, 0, sizeof(ret));
	ret.ok = (toml_value_int(toml_array_unparsed(arr, idx), &ret.u.i) == 0);
	return ret;
}

toml_value_t toml_array_double(const toml_array_t *arr, int idx) {
	toml_value_t ret;
	memset(&ret, 0, sizeof(ret));
	ret.ok = (toml_value_double(toml_array_unparsed(arr, idx), &ret.u.d) == 0);
	return ret;
}

toml_value_t toml_array_timestamp(const toml_array_t *arr, int idx) {
	toml_timestamp_t ts;
	toml_value_t ret;
	memset(&ret, 0, sizeof(ret));
	ret.ok = (toml_value_timestamp(toml_array_unparsed(arr, idx), &ts) == 0);
	if (ret.ok) {
		ret.ok = !!(ret.u.ts = malloc(sizeof(*ret.u.ts)));
		if (ret.ok)
			*ret.u.ts = ts;
	}
	return ret;
}

toml_value_t toml_table_string(const toml_table_t *tbl, const char *key) {
	toml_value_t ret;
	memset(&ret, 0, sizeof(ret));
	toml_unparsed_t raw = toml_table_unparsed(tbl, key);
	if (raw)
		ret.ok = (toml_value_string(raw, &ret.u.s, &ret.u.sl) == 0);
	return ret;
}

toml_value_t toml_table_bool(const toml_table_t *tbl, const char *key) {
	toml_value_t ret;
	memset(&ret, 0, sizeof(ret));
	ret.ok = (toml_value_bool(toml_table_unparsed(tbl, key), &ret.u.b) == 0);
	return ret;
}

toml_value_t toml_table_int(const toml_table_t *tbl, const char *key) {
	toml_value_t ret;
	memset(&ret, 0, sizeof(ret));
	ret.ok = (toml_value_int(toml_table_unparsed(tbl, key), &ret.u.i) == 0);
	return ret;
}

toml_value_t toml_table_double(const toml_table_t *tbl, const char *key) {
	toml_value_t ret;
	memset(&ret, 0, sizeof(ret));
	ret.ok = (toml_value_double(toml_table_unparsed(tbl, key), &ret.u.d) == 0);
	return ret;
}

toml_value_t toml_table_timestamp(const toml_table_t *tbl, const char *key) {
	toml_timestamp_t ts;
	toml_value_t ret;
	memset(&ret, 0, sizeof(ret));
	ret.ok = (toml_value_timestamp(toml_table_unparsed(tbl, key), &ts) == 0);
	if (ret.ok) {
		ret.ok = !!(ret.u.ts = malloc(sizeof(*ret.u.ts)));
		if (ret.ok)
			*ret.u.ts = ts;
	}
	return ret;
}

static int parse_millisec(const char *p, const char **endp) {
	int ret = 0;
	int unit = 100; /// unit in millisec
	for (; '0' <= *p && *p <= '9'; p++, unit /= 10)
		ret += (*p - '0') * unit;
	*endp = p;
	return ret;
}
#endif // TOML_H