%{
/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c)2003, 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 "dcmtk/config/osconfig.h"
#ifdef HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif
#include <assert.h>
#include <errno.h>
#include <limits.h>
#include <stdio.h>
#include <stdarg.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>

#ifdef _MSC_VER
/* suppress warnings about unreachable (generated) code on MSVC */
#pragma warning(disable: 4702)
#endif

#ifdef HAVE_UNISTD_H
#include <unistd.h>
#else

#define BADCH   (int)'?'
#define BADARG  (int)':'
static char EMSG[] = "";

int     opterr = 1,             /* if error message should be printed */
        optind = 1,             /* index into parent argv vector */
        optopt,                 /* character checked for validity */
        optreset;               /* reset getopt */
char    *optarg;                /* argument associated with option */

int getopt(int nargc, char * const nargv[], const char *ostr)
{
        static char *place = EMSG;              /* option letter processing */
        char *oli;                              /* option letter list index */

        if (optreset || *place == 0) {          /* update scanning pointer */
                optreset = 0;
                place = nargv[optind];
                if (optind >= nargc || *place++ != '-') {
                        /* Argument is absent or is not an option */
                        place = EMSG;
                        return (-1);
                }
                optopt = *place++;
                if (optopt == '-' && *place == 0) {
                        /* "--" => end of options */
                        ++optind;
                        place = EMSG;
                        return (-1);
                }
                if (optopt == 0) {
                        /* Solitary '-', treat as a '-' option
                           if the program (eg su) is looking for it. */
                        place = EMSG;
                        if (strchr(ostr, '-') == NULL)
                                return (-1);
                        optopt = '-';
                }
        } else
                optopt = *place++;

        /* See if option letter is one the caller wanted... */
        if (optopt == ':' || (oli = (char *)strchr(ostr, optopt)) == NULL) {
                if (*place == 0)
                        ++optind;
                if (opterr && *ostr != ':')
                        (void)fprintf(stderr,
                            "mkcsmapper: illegal option -- %c\n", optopt);
                return (BADCH);
        }

        /* Does this option need an argument? */
        if (oli[1] != ':') {
                /* don't need argument */
                optarg = NULL;
                if (*place == 0)
                        ++optind;
        } else {
                /* Option-argument is either the rest of this argument or the
                   entire next argument. */
                if (*place)
                        optarg = place;
                else if (oli[2] == ':')
                        /*
                         * GNU Extension, for optional arguments if the rest of
                         * the argument is empty, we return NULL
                         */
                        optarg = NULL;
                else if (nargc > ++optind)
                        optarg = nargv[optind];
                else {
                        /* option-argument absent */
                        place = EMSG;
                        if (*ostr == ':')
                                return (BADARG);
                        if (opterr)
                                (void)fprintf(stderr,
                                    "mkcsmapper: option requires an argument -- %c\n", optopt);
                        return (BADCH);
                }
                place = EMSG;
                ++optind;
        }
        return (optopt);                        /* return option letter */
}

#endif
#ifdef HAVE_ARPA_INET_H
#include <arpa/inet.h>
#endif

#ifdef HAVE_ERR_H
#include <err.h>
#else

static void verrx(int eval, const char *fmt, va_list ap)
{
    fprintf(stderr, "mkcsmapper: ");
    if (fmt != NULL) vfprintf(stderr, fmt, ap);
    fprintf(stderr, "\n");
    exit(eval);
}

static void errx(int eval, const char *fmt, ...)
{
    va_list ap;
    va_start(ap, fmt);
    verrx(eval, fmt, ap);
    /* va_end(ap); */
}

static void verrc(int eval, int code, const char *fmt, va_list ap)
{
    fprintf(stderr, "mkcsmapper: ");
    if (fmt != NULL) {
            vfprintf(stderr, fmt, ap);
            fprintf(stderr, ": ");
    }
    fprintf(stderr, "%s\n", strerror(code));
    exit(eval);
}

static void err(int eval, const char *fmt, ...)
{
    va_list ap;
    va_start(ap, fmt);
    verrc(eval, errno, fmt, ap);
    /* va_end(ap); */
}

#endif /* HAVE_ERR_H */


#include "mkcsmapper_ldef.h"
#include "citrus_types.h"
#include "citrus_mapper_std_file.h"
#include "citrus_region.h"
#include "citrus_db_factory.h"
#include "citrus_db_hash.h"
#include "citrus_lookup_factory.h"
#include "citrus_pivot_factory.h"

extern FILE		*yyin;

int			 debug = 0;

static linear_zone_t	 rowcol[_CITRUS_MAPPER_STD_ROWCOL_MAX];
static char		*map_name;
static char		*output = NULL;
static void		*table = NULL;
static size_t		 rowcol_len = 0;
static size_t		 table_size;
static uint32_t	 done_flag = 0;
static uint32_t	 dst_ilseq, dst_invalid, dst_unit_bits, oob_mode;
static uint32_t	 rowcol_bits = 0, rowcol_mask = 0;
static uint32_t	 src_next;
static int		 map_type;
static void		 (*putfunc)(void *, size_t, uint32_t) = NULL;

#define DF_TYPE			0x00000001
#define DF_NAME			0x00000002
#define DF_SRC_ZONE		0x00000004
#define DF_DST_INVALID		0x00000008
#define DF_DST_ILSEQ		0x00000010
#define DF_DST_UNIT_BITS	0x00000020
#define DF_OOB_MODE		0x00000040

static void	dump_file(void);
static void	setup_map(void);
static void	set_type(int);
static void	set_name(char *);
static void	set_src_zone(uint32_t);
static void	set_dst_invalid(uint32_t);
static void	set_dst_ilseq(uint32_t);
static void	set_dst_unit_bits(uint32_t);
static void	set_oob_mode(uint32_t);
static int	check_src(uint32_t, uint32_t);
static void	store(const linear_zone_t *, uint32_t, int);
static void	put8(void *, size_t, uint32_t);
static void	put16(void *, size_t, uint32_t);
static void	put32(void *, size_t, uint32_t);
static void	set_range(uint32_t, uint32_t);
static void	set_src(linear_zone_t *, uint32_t, uint32_t);
%}

%union {
	uint32_t	 i_value;
	char		*s_value;
	linear_zone_t	 lz_value;
}

%token			R_TYPE R_NAME R_SRC_ZONE R_DST_UNIT_BITS
%token			R_DST_INVALID R_DST_ILSEQ
%token			R_BEGIN_MAP R_END_MAP R_INVALID R_ROWCOL
%token			R_ILSEQ R_OOB_MODE
%token			R_LN
%token <i_value>	L_IMM
%token <s_value>	L_STRING

%type <lz_value>	src
%type <i_value>		dst types oob_mode_sel zone

%%

file		: property mapping lns
		{ dump_file(); }

property	: /* empty */
		| property R_LN
		| property name
		| property type
		| property src_zone
		| property dst_invalid
		| property dst_ilseq
		| property dst_unit_bits
		| property oob_mode

name		: R_NAME L_STRING { set_name($2); $2 = NULL; }
type		: R_TYPE types { set_type($2); }
types		: R_ROWCOL { $$ = R_ROWCOL; }
range		: L_IMM '-' L_IMM { set_range($1, $3); }

ranges		: /* empty */
		| ranges range '/'

src_zone	: R_SRC_ZONE zone { set_src_zone($2); }
zone		: range {
			$$ = 32;
		}
		| range '/' range '/' ranges L_IMM {
			$$ = $6;
		}

dst_invalid	: R_DST_INVALID L_IMM { set_dst_invalid($2); }
dst_ilseq	: R_DST_ILSEQ L_IMM { set_dst_ilseq($2); }
dst_unit_bits	: R_DST_UNIT_BITS L_IMM { set_dst_unit_bits($2); }
oob_mode	: R_OOB_MODE oob_mode_sel { set_oob_mode($2); }

oob_mode_sel	: R_INVALID { $$ = _CITRUS_MAPPER_STD_OOB_NONIDENTICAL; }
		| R_ILSEQ { $$ = _CITRUS_MAPPER_STD_OOB_ILSEQ; }

mapping		: begin_map map_elems R_END_MAP
begin_map	: R_BEGIN_MAP lns { setup_map(); }

map_elems	: /* empty */
		| map_elems map_elem lns

map_elem	: src '=' dst
		{ store(&$1, $3, 0); }
		| src '=' L_IMM '-'
		{ store(&$1, $3, 1); }
dst		: L_IMM
		{
			$$ = $1;
		}
		| R_INVALID
		{
			$$ = dst_invalid;
		}
		| R_ILSEQ
		{
			$$ = dst_ilseq;
		}

src		: /* empty */
		{
			set_src(&$$, src_next, src_next);
		}
		| L_IMM
		{
			set_src(&$$, $1, $1);
		}
		| L_IMM '-' L_IMM
		{
			set_src(&$$, $1, $3);
		}
		| '-' L_IMM
		{
			set_src(&$$, src_next, $2);
		}
lns		: R_LN
		| lns R_LN

%%

static void
warning(const char *s)
{

	fprintf(stderr, "%s in %d\n", s, linenumber);
}

int
yyerror(const char *s)
{

	warning(s);
	exit(1);
}

void
put8(void *ptr, size_t ofs, uint32_t val)
{

	*((uint8_t *)ptr + ofs) = (uint8_t) val;
}

void
put16(void *ptr, size_t ofs, uint32_t val)
{

	uint16_t oval = htons((uint16_t)val);
	memcpy((uint16_t *)ptr + ofs, &oval, 2);
}

void
put32(void *ptr, size_t ofs, uint32_t val)
{

	uint32_t oval = htonl(val);
	memcpy((uint32_t *)ptr + ofs, &oval, 4);
}

static void
alloc_table(void)
{
	linear_zone_t *p;
	size_t i;
	uint32_t val = 0;

	i = rowcol_len;
	p = &rowcol[--i];
	table_size = p->width;
	while (i > 0) {
		p = &rowcol[--i];
		table_size *= p->width;
	}
	table = (void *)malloc(table_size * dst_unit_bits / 8);
	if (table == NULL) {
		perror("malloc");
		exit(1);
	}

	switch (oob_mode) {
	case _CITRUS_MAPPER_STD_OOB_NONIDENTICAL:
		val = dst_invalid;
		break;
	case _CITRUS_MAPPER_STD_OOB_ILSEQ:
		val = dst_ilseq;
		break;
	default:
		break;
	}
	for (i = 0; i < table_size; i++)
		(*putfunc)(table, i, val);
}

static void
setup_map(void)
{

	if ((done_flag & DF_SRC_ZONE)==0) {
		fprintf(stderr, "SRC_ZONE is mandatory.\n");
		exit(1);
	}
	if ((done_flag & DF_DST_UNIT_BITS)==0) {
		fprintf(stderr, "DST_UNIT_BITS is mandatory.\n");
		exit(1);
	}

	if ((done_flag & DF_DST_INVALID) == 0)
		dst_invalid = 0xFFFFFFFF;
	if ((done_flag & DF_DST_ILSEQ) == 0)
		dst_ilseq = 0xFFFFFFFE;
	if ((done_flag & DF_OOB_MODE) == 0)
		oob_mode = _CITRUS_MAPPER_STD_OOB_NONIDENTICAL;

	alloc_table();
}

static void
create_rowcol_info(struct _citrus_region *r)
{
	void *ptr;
	size_t i, len, ofs;

	ofs = 0;
	ptr = malloc(_CITRUS_MAPPER_STD_ROWCOL_INFO_SIZE);
	if (ptr == NULL)
		err(EXIT_FAILURE, "malloc");
	put32(ptr, ofs, rowcol_bits); ofs++;
	put32(ptr, ofs, dst_invalid); ofs++;

	/* XXX: keep backward compatibility */
	switch (rowcol_len) {
	case 1:
		put32(ptr, ofs, 0); ofs++;
		put32(ptr, ofs, 0); ofs++;
	/*FALLTHROUGH*/
	case 2:
		len = 0;
		break;
	default:
		len = rowcol_len;
	}
	for (i = 0; i < rowcol_len; ++i) {
		put32(ptr, ofs, rowcol[i].begin); ofs++;
		put32(ptr, ofs, rowcol[i].end); ofs++;
	}
	put32(ptr, ofs, dst_unit_bits); ofs++;
	put32(ptr, ofs, (uint32_t)len); ofs++;

	_citrus_region_init(r, ptr, ofs * 4);
}


static void
create_rowcol_ext_ilseq_info(struct _citrus_region *r)
{
	void *ptr;
	size_t ofs;

	ofs = 0;
	ptr = malloc(_CITRUS_MAPPER_STD_ROWCOL_EXT_ILSEQ_SIZE);
	if (ptr == NULL)
		err(EXIT_FAILURE, "malloc");

	put32(ptr, ofs, oob_mode); ofs++;
	put32(ptr, ofs, dst_ilseq); ofs++;

	_citrus_region_init(r, ptr, _CITRUS_MAPPER_STD_ROWCOL_EXT_ILSEQ_SIZE);
}

#define CHKERR(ret, func, a)						\
do {									\
	ret = func a;							\
	if (ret)							\
		errx(EXIT_FAILURE, "%s: %s", #func, strerror(ret));	\
} while (/*CONSTCOND*/0)

static void
dump_file(void)
{
	struct _citrus_db_factory *df;
	struct _citrus_region data;
	void *serialized;
	FILE *fp;
	size_t size;
	int ret;

	/*
	 * build database
	 */
	CHKERR(ret, _citrus_db_factory_create, (&df, _citrus_db_hash_std, NULL));

	/* store type */
	CHKERR(ret, _citrus_db_factory_add_string_by_string,
	    (df, _CITRUS_MAPPER_STD_SYM_TYPE, _CITRUS_MAPPER_STD_TYPE_ROWCOL));

	/* store info */
	create_rowcol_info(&data);
	CHKERR(ret, _citrus_db_factory_add_by_string,
	    (df, _CITRUS_MAPPER_STD_SYM_INFO, &data, 1));

	/* ilseq extension */
	create_rowcol_ext_ilseq_info(&data);
	CHKERR(ret, _citrus_db_factory_add_by_string,
	    (df, _CITRUS_MAPPER_STD_SYM_ROWCOL_EXT_ILSEQ, &data, 1));

	/* store table */
	_citrus_region_init(&data, table, table_size*dst_unit_bits/8);
	CHKERR(ret, _citrus_db_factory_add_by_string,
	    (df, _CITRUS_MAPPER_STD_SYM_TABLE, &data, 1));

	/*
	 * dump database to file
	 */
	fp = output ? fopen(output, "wb") : stdout;

	if (fp == NULL) {
		perror("fopen");
		exit(1);
	}

	/* dump database body */
	size = _citrus_db_factory_calc_size(df);
	serialized = malloc(size);
	_citrus_region_init(&data, serialized, size);
	CHKERR(ret, _citrus_db_factory_serialize,
	    (df, _CITRUS_MAPPER_STD_MAGIC, &data));
	if (fwrite(serialized, size, 1, fp) != 1)
		err(EXIT_FAILURE, "fwrite");

	fclose(fp);
}

static void
/*ARGSUSED*/
set_type(int type)
{

	if (done_flag & DF_TYPE) {
		warning("TYPE is duplicated. ignored this one");
		return;
	}

	map_type = type;

	done_flag |= DF_TYPE;
}

static void
/*ARGSUSED*/
set_name(char *str)
{

	if (done_flag & DF_NAME) {
		warning("NAME is duplicated. ignored this one");
		return;
	}

	map_name = str;

	done_flag |= DF_NAME;
}

static void
set_src_zone(uint32_t val)
{
	linear_zone_t *p;
	size_t i;

	if (done_flag & DF_SRC_ZONE) {
		warning("SRC_ZONE is duplicated. ignored this one");
		return;
	}
	rowcol_bits = val;

	/* sanity check */
	switch (rowcol_bits) {
	case 8: case 16: case 32:
		if (rowcol_len <= 32 / rowcol_bits)
			break;
	/*FALLTHROUGH*/
	default: 
		goto bad;
	}
	rowcol_mask = 1u << (rowcol_bits - 1);
	rowcol_mask |= rowcol_mask - 1;
	for (i = 0; i < rowcol_len; ++i) {
		p = &rowcol[i];
		if (p->end > rowcol_mask)
			goto bad;
	}
	done_flag |= DF_SRC_ZONE;
	return;

bad:
	yyerror("Illegal argument for SRC_ZONE");
}

static void
set_dst_invalid(uint32_t val)
{

	if (done_flag & DF_DST_INVALID) {
		warning("DST_INVALID is duplicated. ignored this one");
		return;
	}

	dst_invalid = val;

	done_flag |= DF_DST_INVALID;
}

static void
set_dst_ilseq(uint32_t val)
{

	if (done_flag & DF_DST_ILSEQ) {
		warning("DST_ILSEQ is duplicated. ignored this one");
		return;
	}

	dst_ilseq = val;

	done_flag |= DF_DST_ILSEQ;
}

static void
set_oob_mode(uint32_t val)
{

	if (done_flag & DF_OOB_MODE) {
		warning("OOB_MODE is duplicated. ignored this one");
		return;
	}

	oob_mode = val;

	done_flag |= DF_OOB_MODE;
}

static void
set_dst_unit_bits(uint32_t val)
{

	if (done_flag & DF_DST_UNIT_BITS) {
		warning("DST_UNIT_BITS is duplicated. ignored this one");
		return;
	}

	switch (val) {
	case 8:
		putfunc = &put8;
		dst_unit_bits = val;
		break;
	case 16:
		putfunc = &put16;
		dst_unit_bits = val;
		break;
	case 32:
		putfunc = &put32;
		dst_unit_bits = val;
		break;
	default:
		yyerror("Illegal argument for DST_UNIT_BITS");
	}
	done_flag |= DF_DST_UNIT_BITS;
}

static int
check_src(uint32_t begin, uint32_t end)
{
	linear_zone_t *p;
	size_t i;
	uint32_t m, n;

	if (begin > end)
		return (1);
	if (begin < end) {
		m = begin & ~rowcol_mask;
		n = end & ~rowcol_mask;
		if (m != n)
			return (1);
	}
	for (i = rowcol_len * rowcol_bits, p = &rowcol[0]; i > 0; ++p) {
		i -= rowcol_bits;
		m = (begin >> i) & rowcol_mask;
		if (m < p->begin || m > p->end)
			return (1);
	}
	if (begin < end) {
		n = end & rowcol_mask;
		--p;
		if (n < p->begin || n > p->end)
			return (1);
	}
	return (0);
}

static void
store(const linear_zone_t *lz, uint32_t dst, int inc)
{
	linear_zone_t *p;
	size_t i, ofs;
	uint32_t n;

	ofs = 0;
	for (i = rowcol_len * rowcol_bits, p = &rowcol[0]; i > 0; ++p) {
		i -= rowcol_bits;
		n = ((lz->begin >> i) & rowcol_mask) - p->begin;
		ofs = (ofs * p->width) + n;
	}
	n = lz->width;
	while (n-- > 0) {
		(*putfunc)(table, ofs++, dst);
		if (inc)
			dst++;
	}
}

static void
set_range(uint32_t begin, uint32_t end)
{
	linear_zone_t *p;

	if (rowcol_len >= _CITRUS_MAPPER_STD_ROWCOL_MAX)
		goto bad;
	p = &rowcol[rowcol_len++];

	if (begin > end)
		goto bad;
	p->begin = begin, p->end = end;
	p->width = end - begin + 1;

	return;

bad:
	yyerror("Illegal argument for SRC_ZONE");
}

static void
set_src(linear_zone_t *lz, uint32_t begin, uint32_t end)
{

	if (check_src(begin, end) != 0)
		yyerror("illegal zone");

	lz->begin = begin, lz->end = end;
	lz->width = end - begin + 1;

	src_next = end + 1;
}

static void
do_mkdb(FILE *in)
{
	FILE *out;
	int ret;

        /* dump DB to file */
	out = output ? fopen(output, "wb") : stdout;

	if (out == NULL)
		err(EXIT_FAILURE, "fopen");

	ret = _citrus_lookup_factory_convert(out, in);
	fclose(out);
	if (ret && output)
		unlink(output); /* dump failure */
}

static void
do_mkpv(FILE *in)
{
	FILE *out;
	int ret;

        /* dump pivot to file */
	out = output ? fopen(output, "wb") : stdout;

	if (out == NULL)
		err(EXIT_FAILURE, "fopen");

	ret = _citrus_pivot_factory_convert(out, in);
	fclose(out);
	if (ret && output)
		unlink(output); /* dump failure */
	if (ret)
		errx(EXIT_FAILURE, "%s\n", strerror(ret));
}

static void
usage(void)
{
	fprintf(stderr, "Usage: mkcsmapper [-d] [-m|-p] [-o outfile] [infile]\n");
	exit(EXIT_FAILURE);
}

int
main(int argc, char **argv)
{
	FILE *in = NULL;
	int ch, mkdb = 0, mkpv = 0;

	while ((ch = getopt(argc, argv, "do:mp")) != EOF) {
		switch (ch) {
		case 'd':
			debug = 1;
			break;
		case 'o':
			output = strdup(optarg);
			break;
		case 'm':
			mkdb = 1;
			break;
		case 'p':
			mkpv = 1;
			break;
		default:
			usage();
		}
	}

	argc -= optind;
	argv += optind;
	switch (argc) {
	case 0:
		in = stdin;
		break;
	case 1:
		in = fopen(argv[0], "r");
		if (!in)
			err(EXIT_FAILURE, "%s", argv[0]);
		break;
	default:
		usage();
	}

	if (mkdb)
		do_mkdb(in);
	else if (mkpv)
		do_mkpv(in);
	else {
		yyin = in;
		yyparse();
	}

	return (0);
}
