/* $NetBSD: citrus_prop.c,v 1.4 2011/03/30 08:22:01 jruoho Exp $ */

/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c)2006 Citrus Project,
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 */


#include <assert.h>
#include <errno.h>
#include <limits.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>

#include "citrus_namespace.h"
#include "citrus_bcs.h"
#include "citrus_region.h"
#include "citrus_memstream.h"
#include "citrus_prop.h"

typedef struct {
	_citrus_prop_type_t type;
	union {
		const char *str;
		int chr;
		bool boolean;
		uint64_t num;
	} u;
} _citrus_prop_object_t;

static __inline void
_citrus_prop_object_init(_citrus_prop_object_t *obj, _citrus_prop_type_t type)
{

	obj->type = type;
	memset(&obj->u, 0, sizeof(obj->u));
}

static __inline void
_citrus_prop_object_uninit(_citrus_prop_object_t *obj)
{

	if (obj->type == _CITRUS_PROP_STR)
		free(__DECONST(void *, obj->u.str));
}

static const char *xdigit = "0123456789ABCDEF";

#define _CITRUS_PROP_READ_UINT_COMMON(_func_, _type_, _max_)		\
static int								\
_citrus_prop_read_##_func_##_common(struct _memstream * __restrict ms,	\
    _type_ * __restrict result, int base, int neg)			\
{									\
	_type_ acc, cutoff;						\
	int ch, cutlim, n;						\
	char *p;							\
									\
	acc = (_type_)0;						\
	cutoff = _max_ / base;						\
	cutlim = _max_ % base;						\
	for (;;) {							\
		ch = _memstream_getc(ms);				\
		p = strchr(xdigit, _bcs_toupper(ch));			\
		if (p == NULL || (n = (p - xdigit)) >= base)		\
			break;						\
		if (acc > cutoff || (acc == cutoff && n > cutlim))	\
			break;						\
		acc *= base;						\
		acc += n;						\
	}								\
	_memstream_ungetc(ms, ch);					\
	*result = neg ? -acc : acc;					\
	return (0);							\
}
_CITRUS_PROP_READ_UINT_COMMON(chr, int, UCHAR_MAX)
_CITRUS_PROP_READ_UINT_COMMON(num, uint64_t, UINT64_MAX)
#undef _CITRUS_PROP_READ_UINT_COMMON

#define _CITRUS_PROP_READ_INT(_func_, _type_)			\
static int							\
_citrus_prop_read_##_func_(struct _memstream * __restrict ms,	\
    _citrus_prop_object_t * __restrict obj)			\
{								\
	int base, ch, neg;					\
								\
	_memstream_skip_ws(ms);					\
	ch = _memstream_getc(ms);				\
	neg = 0;						\
	switch (ch) {						\
	case '-':						\
		neg = 1;					\
	case '+':						\
		ch = _memstream_getc(ms);			\
	}							\
	base = 10;						\
	if (ch == '0') {					\
		base -= 2;					\
		ch = _memstream_getc(ms);			\
		if (ch == 'x' || ch == 'X') {			\
			ch = _memstream_getc(ms);		\
			if (_bcs_isxdigit(ch) == 0) {		\
				_memstream_ungetc(ms, ch);	\
				obj->u._func_ = 0;		\
				return (0);			\
			}					\
			base += 8;				\
		}						\
	} else if (_bcs_isdigit(ch) == 0)			\
		return (EINVAL);				\
	_memstream_ungetc(ms, ch);				\
	return (_citrus_prop_read_##_func_##_common		\
	    (ms, &obj->u._func_, base, neg));			\
}
_CITRUS_PROP_READ_INT(chr, int)
_CITRUS_PROP_READ_INT(num, uint64_t)
#undef _CITRUS_PROP_READ_INT

static int
_citrus_prop_read_character_common(struct _memstream * __restrict ms,
    int * __restrict result)
{
	int base, ch;

	ch = _memstream_getc(ms);
	if (ch != '\\')
		*result = ch;
	else {
		ch = _memstream_getc(ms);
		base = 16;
		switch (ch) {
		case 'a':
			*result = '\a';
			break;
		case 'b':
			*result = '\b';
			break;
		case 'f':
			*result = '\f';
			break;
		case 'n':
			*result = '\n';
			break;
		case 'r':
			*result = '\r';
			break;
		case 't':
			*result = '\t';
			break;
		case 'v':
			*result = '\v';
			break;
		case '0': case '1': case '2': case '3':
		case '4': case '5': case '6': case '7':
			_memstream_ungetc(ms, ch);
			base -= 8;
			/*FALLTHROUGH*/
		case 'x':
			return (_citrus_prop_read_chr_common(ms, result,
			    base, 0));
			/*NOTREACHED*/
		default:
			/* unknown escape */
			*result = ch;
		}
	}
	return (0);
}

static int
_citrus_prop_read_character(struct _memstream * __restrict ms,
    _citrus_prop_object_t * __restrict obj)
{
	int ch, errnum;

	_memstream_skip_ws(ms);
	ch = _memstream_getc(ms);
	if (ch != '\'') {
		_memstream_ungetc(ms, ch);
		return (_citrus_prop_read_chr(ms, obj));
	}
	errnum = _citrus_prop_read_character_common(ms, &ch);
	if (errnum != 0)
		return (errnum);
	obj->u.chr = ch;
	ch = _memstream_getc(ms);
	if (ch != '\'')
		return (EINVAL);
	return (0);
}

static int
_citrus_prop_read_bool(struct _memstream * __restrict ms,
    _citrus_prop_object_t * __restrict obj)
{

	_memstream_skip_ws(ms);
	switch (_bcs_tolower(_memstream_getc(ms))) {
	case 't':
		if (_bcs_tolower(_memstream_getc(ms)) == 'r' &&
		    _bcs_tolower(_memstream_getc(ms)) == 'u' &&
		    _bcs_tolower(_memstream_getc(ms)) == 'e') {
			obj->u.boolean = true;
			return (0);
		}
		break;
	case 'f':
		if (_bcs_tolower(_memstream_getc(ms)) == 'a' &&
		    _bcs_tolower(_memstream_getc(ms)) == 'l' &&
		    _bcs_tolower(_memstream_getc(ms)) == 's' &&
		    _bcs_tolower(_memstream_getc(ms)) == 'e') {
			obj->u.boolean = false;
			return (0);
		}
	}
	return (EINVAL);
}

static int
_citrus_prop_read_str(struct _memstream * __restrict ms,
    _citrus_prop_object_t * __restrict obj)
{
	int ch, errnum, quot;
	char *s, *t;
#define _CITRUS_PROP_STR_BUFSIZ	512
	size_t m, n;

	m = _CITRUS_PROP_STR_BUFSIZ;
	s = malloc(m);
	if (s == NULL)
		return (ENOMEM);
	n = 0;
	_memstream_skip_ws(ms);
	quot = _memstream_getc(ms);
	switch (quot) {
	case EOF:
		goto done;
		/*NOTREACHED*/
	case '\\':
		_memstream_ungetc(ms, quot);
		quot = EOF;
		/*FALLTHROUGH*/
	case '\"': case '\'':
		break;
	default:
		s[n] = quot;
		++n, --m;
		quot = EOF;
	}
	for (;;) {
		if (m < 1) {
			m = _CITRUS_PROP_STR_BUFSIZ;
			t = realloc(s, n + m);
			if (t == NULL) {
				free(s);
				return (ENOMEM);
			}
			s = t;
		}
		ch = _memstream_getc(ms);
		if (quot == ch || (quot == EOF &&
		    (ch == ';' || _bcs_isspace(ch)))) {
done:
			s[n] = '\0';
			obj->u.str = (const char *)s;
			return (0);
		}
		_memstream_ungetc(ms, ch);
		errnum = _citrus_prop_read_character_common(ms, &ch);
		if (errnum != 0) {
			free(s);
			return (errnum);
		}
		s[n] = ch;
		++n, --m;
	}
	free(s);
	return (EINVAL);
#undef _CITRUS_PROP_STR_BUFSIZ
}

typedef int (*_citrus_prop_read_type_t)(struct _memstream * __restrict,
    _citrus_prop_object_t * __restrict);

static const _citrus_prop_read_type_t readers[] = {
	_citrus_prop_read_bool,
	_citrus_prop_read_str,
	_citrus_prop_read_character,
	_citrus_prop_read_num,
};

static __inline int
_citrus_prop_read_symbol(struct _memstream * __restrict ms,
    char * __restrict s, size_t n)
{
	int ch;
	size_t m;

	for (m = 0; m < n; ++m) {
		ch = _memstream_getc(ms);
		if (ch != '_' && _bcs_isalnum(ch) == 0)
			goto name_found;
		s[m] = ch;
	}
	ch = _memstream_getc(ms);
	if (ch == '_' || _bcs_isalnum(ch) != 0)
		return (EINVAL);

name_found:
	_memstream_ungetc(ms, ch);
	s[m] = '\0';

	return (0);
}

static int
_citrus_prop_parse_element(struct _memstream * __restrict ms,
    const _citrus_prop_hint_t * __restrict hints, void * __restrict context)
{
	int ch, errnum;
#define _CITRUS_PROP_HINT_NAME_LEN_MAX	255
	char name[_CITRUS_PROP_HINT_NAME_LEN_MAX + 1];
	const _citrus_prop_hint_t *hint;
	_citrus_prop_object_t ostart, oend;

	errnum = _citrus_prop_read_symbol(ms, name, sizeof(name));
	if (errnum != 0)
		return (errnum);
	for (hint = hints; hint->name != NULL; ++hint)
		if (_citrus_bcs_strcasecmp(name, hint->name) == 0)
			goto hint_found;
	return (EINVAL);

hint_found:
	_memstream_skip_ws(ms);
	ch = _memstream_getc(ms);
	if (ch != '=' && ch != ':')
		_memstream_ungetc(ms, ch);
	do {
		_citrus_prop_object_init(&ostart, hint->type);
		_citrus_prop_object_init(&oend, hint->type);
		errnum = (*readers[hint->type])(ms, &ostart);
		if (errnum != 0)
			return (errnum);
		_memstream_skip_ws(ms);
		ch = _memstream_getc(ms);
		switch (hint->type) {
		case _CITRUS_PROP_BOOL:
			/*FALLTHROUGH*/
		case _CITRUS_PROP_STR:
			break;
		default:
			if (ch != '-')
				break;
			errnum = (*readers[hint->type])(ms, &oend);
			if (errnum != 0)
				return (errnum);
			_memstream_skip_ws(ms);
			ch = _memstream_getc(ms);
		}
#define CALL0(_func_)					\
do {							\
	errnum = (*hint->cb._func_.func)(context,	\
	    hint->name,	ostart.u._func_);		\
} while (0)
#define CALL1(_func_)					\
do {							\
	errnum = (*hint->cb._func_.func)(context,	\
	    hint->name,	ostart.u._func_, oend.u._func_);\
} while (0)
		switch (hint->type) {
		case _CITRUS_PROP_BOOL:
			CALL0(boolean);
			break;
		case _CITRUS_PROP_STR:
			CALL0(str);
			break;
		case _CITRUS_PROP_CHR:
			CALL1(chr);
			break;
		case _CITRUS_PROP_NUM:
			CALL1(num);
			break;
		default:
			abort();
			/*NOTREACHED*/
		}
#undef CALL0
#undef CALL1
		_citrus_prop_object_uninit(&ostart);
		_citrus_prop_object_uninit(&oend);
		if (errnum != 0)
			return (errnum);
	} while (ch == ',');
	if (ch != ';')
		_memstream_ungetc(ms, ch);
	return (0);
}

int
_citrus_prop_parse_variable(const _citrus_prop_hint_t * __restrict hints,
    void * __restrict context, const void *var, size_t lenvar)
{
	struct _memstream ms;
	int ch, errnum;

	_memstream_bind_ptr(&ms, __DECONST(void *, var), lenvar);
	for (;;) {
		_memstream_skip_ws(&ms);
		ch = _memstream_getc(&ms);
		if (ch == EOF || ch == '\0')
			break;
		_memstream_ungetc(&ms, ch);
		errnum = _citrus_prop_parse_element(&ms, hints, context);
		if (errnum != 0)
			return (errnum);
	}
	return (0);
}
