Import locale tools and ressource files

This commit requires special steps, please checkout docs/UPDATING. Tools: - gencat - locale - mkcsmapper - mkesdb - mklocale Libs: - i18n_module - libintl Ressources: - i18n - locale Change-Id: I559d0399d8e98bcee15225cab786e43f31506207
2016-07-09 12:18:33 +02:00
parent 733a844ac6
commit 36dcc4a4a9
1369 changed files with 623024 additions and 9 deletions
@@ -0,0 +1,23 @@
+#	$NetBSD: Makefile,v 1.7 2009/10/29 14:37:16 christos Exp $
+
+NOMAN=# defined (must come before bsd.own.mk)
+
+.ifndef HOSTPROG
+.include <bsd.own.mk>
+.endif
+
+.PATH: ${NETBSDSRCDIR}/lib/libc/citrus
+
+PROG=		mkcsmapper
+SRCS=		yacc.y lex.l \
+		citrus_db_factory.c citrus_bcs.c citrus_db_hash.c \
+		citrus_lookup_factory.c citrus_pivot_factory.c
+CPPFLAGS+=	-I. -I${.CURDIR} -I${NETBSDSRCDIR}/lib/libc \
+		-I${NETBSDSRCDIR}/lib/libc/citrus \
+		-I${NETBSDSRCDIR}/lib/libc/citrus/modules \
+		-DHOSTPROG -DLIBC_SCCS
+YHEADER=	1
+
+.ifndef HOSTPROG
+.include <bsd.prog.mk>
+.endif
@@ -0,0 +1,40 @@
+/*	$NetBSD: ldef.h,v 1.2 2006/09/09 14:35:17 tnozaki Exp $	*/
+
+/*-
+ * 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.
+ */
+
+typedef struct {
+	u_int32_t	begin;
+	u_int32_t	end;
+	u_int32_t	width;
+} linear_zone_t;
+
+extern int	line_number;
+extern int	debug;
+extern FILE	*yyin;
+extern int	yyparse(void);
+extern int	yylex(void);
+extern int	yyerror(const char *);
@@ -0,0 +1,113 @@
+/*	$NetBSD: lex.l,v 1.6 2009/10/29 14:37:16 christos Exp $	*/
+
+%{
+/*-
+ * Copyright (c)2003 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.
+ */
+
+#if HAVE_NBTOOL_CONFIG_H
+#include "nbtool_config.h"
+#endif
+
+#include <sys/cdefs.h>
+#if !defined(lint)
+__RCSID("$NetBSD: lex.l,v 1.6 2009/10/29 14:37:16 christos Exp $");
+#endif /* not lint */
+
+#include <assert.h>
+#include <errno.h>
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <machine/endian.h>
+
+#include "ldef.h"
+#include "yacc.h"
+
+int line_number = 1;
+
+
+%}
+
+%option noinput nounput
+
+%x	COMMENT
+
+%%
+
+[ \t]+	{ }
+#.*[\n]|"//".*[\n]|[\n]	{ line_number++; return (R_LN); }
+
+"/*"		{ BEGIN COMMENT; }
+<COMMENT>"*/"	{ BEGIN 0; }
+<COMMENT>[\n]	{ line_number++; }
+<COMMENT>.	{ }
+<COMMENT><<EOF>>	{
+		yyerror("unexpected file end (unterminate comment)\n");
+		exit(1);
+	}
+
+"="|"/"|"-"	{ return (int)yytext[0]; }
+
+([1-9][0-9]*)|(0[0-9]*)|(0[xX][0-9A-Fa-f]+)	{
+		yylval.i_value = strtoul(yytext, NULL, 0);
+		return L_IMM;
+	}
+
+"TYPE"		{ return (R_TYPE); }
+"NAME"		{ return (R_NAME); }
+"SRC_ZONE"	{ return (R_SRC_ZONE); }
+"DST_INVALID"	{ return (R_DST_INVALID); }
+"DST_ILSEQ"	{ return (R_DST_ILSEQ); }
+"DST_UNIT_BITS"	{ return (R_DST_UNIT_BITS); }
+"BEGIN_MAP"	{ return (R_BEGIN_MAP); }
+"END_MAP"	{ return (R_END_MAP); }
+"INVALID"	{ return (R_INVALID); }
+"ILSEQ"		{ return (R_ILSEQ); }
+"OOB_MODE"	{ return (R_OOB_MODE); }
+"ROWCOL"	{ return (R_ROWCOL); }
+
+\"([^\"\n]*(\\\")?)*\"|\'([^\'\n]*(\\\')?)*\'	{
+		size_t len;
+		len = strlen(yytext);
+		yylval.s_value = malloc(len-1);
+		strlcpy(yylval.s_value, yytext+1, len-1);
+		return L_STRING;
+	}
+[^ =/\-0-9\t\n][^ \t\n]*	{
+		yylval.s_value = strdup(yytext);
+		return L_STRING;
+	}
+
+%%
+
+#ifndef yywrap
+int
+yywrap(void)
+{
+	return (1);
+}
+#endif
@@ -0,0 +1,734 @@
+/*	$NetBSD: yacc.y,v 1.10 2015/06/16 22:54:10 christos Exp $	*/
+
+%{
+/*-
+ * 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.
+ */
+
+#if HAVE_NBTOOL_CONFIG_H
+#include "nbtool_config.h"
+#endif
+
+#include <sys/cdefs.h>
+#if !defined(lint)
+__RCSID("$NetBSD: yacc.y,v 1.10 2015/06/16 22:54:10 christos Exp $");
+#endif /* not lint */
+
+#include <assert.h>
+#include <err.h>
+#include <errno.h>
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <arpa/inet.h>
+#include <sys/types.h>
+
+#include "ldef.h"
+
+#ifndef __packed
+#define __packed
+#endif
+
+#include "citrus_namespace.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"
+
+int			debug = 0;
+static char		*output = NULL;
+static void		*table = NULL;
+static size_t		table_size;
+static char		*map_name;
+static int		map_type;
+static u_int32_t	dst_invalid, dst_ilseq, oob_mode, dst_unit_bits;
+static void		(*putfunc)(void *, size_t, u_int32_t) = 0;
+
+static u_int32_t	src_next;
+
+static u_int32_t	done_flag = 0;
+#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 linear_zone_t	rowcol[_CITRUS_MAPPER_STD_ROWCOL_MAX];
+static size_t		rowcol_len = 0;
+static u_int32_t	rowcol_bits = 0, rowcol_mask = 0;
+
+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(u_int32_t);
+static void	set_dst_invalid(u_int32_t);
+static void	set_dst_ilseq(u_int32_t);
+static void	set_dst_unit_bits(u_int32_t);
+static void	set_oob_mode(u_int32_t);
+static int	check_src(u_int32_t, u_int32_t);
+static void	store(const linear_zone_t *, u_int32_t, int);
+static void	put8(void *, size_t, u_int32_t);
+static void	put16(void *, size_t, u_int32_t);
+static void	put32(void *, size_t, u_int32_t);
+static void	set_range(u_int32_t, u_int32_t);
+static void	set_src(linear_zone_t *, u_int32_t, u_int32_t);
+%}
+
+%union {
+	u_int32_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, line_number);
+}
+
+int
+yyerror(const char *s)
+{
+	warning(s);
+	exit(1);
+}
+
+void
+put8(void *ptr, size_t ofs, u_int32_t val)
+{
+	*((u_int8_t *)ptr + ofs) = val;
+}
+
+void
+put16(void *ptr, size_t ofs, u_int32_t val)
+{
+	u_int16_t oval = htons(val);
+	memcpy((u_int16_t *)ptr + ofs, &oval, 2);
+}
+
+void
+put32(void *ptr, size_t ofs, u_int32_t val)
+{
+	u_int32_t oval = htonl(val);
+	memcpy((u_int32_t *)ptr + ofs, &oval, 4);
+}
+
+static void
+alloc_table(void)
+{
+	size_t i;
+	u_int32_t val = 0;
+	linear_zone_t *p;
+
+	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:
+		_DIAGASSERT(0);
+	}
+	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 _region *r)
+{
+	void *ptr;
+	size_t ofs, i, len;
+
+	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, len); ofs++;
+
+	_region_init(r, ptr, ofs * 4);
+}
+
+
+static void
+create_rowcol_ext_ilseq_info(struct _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++;
+
+	_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)
+{
+	FILE *fp;
+	int ret;
+	struct _db_factory *df;
+	struct _region data;
+	void *serialized;
+	size_t size;
+
+	/*
+	 * build database
+	 */
+	CHKERR(ret, _db_factory_create, (&df, _db_hash_std, NULL));
+
+	/* store type */
+	CHKERR(ret, _db_factory_addstr_by_s,
+	       (df, _CITRUS_MAPPER_STD_SYM_TYPE,
+		_CITRUS_MAPPER_STD_TYPE_ROWCOL));
+
+	/* store info */
+	create_rowcol_info(&data);
+	CHKERR(ret, _db_factory_add_by_s,
+	       (df, _CITRUS_MAPPER_STD_SYM_INFO, &data, 1));
+
+	/* ilseq extension */
+	create_rowcol_ext_ilseq_info(&data);
+	CHKERR(ret, _db_factory_add_by_s,
+	       (df, _CITRUS_MAPPER_STD_SYM_ROWCOL_EXT_ILSEQ, &data, 1));
+
+	/* store table */
+	_region_init(&data, table, table_size*dst_unit_bits/8);
+	CHKERR(ret, _db_factory_add_by_s,
+	       (df, _CITRUS_MAPPER_STD_SYM_TABLE, &data, 1));
+
+	/*
+	 * dump database to file
+	 */
+	if (output)
+		fp = fopen(output, "wb");
+	else
+		fp = stdout;
+
+	if (fp == NULL) {
+		perror("fopen");
+		exit(1);
+	}
+
+	/* dump database body */
+	size = _db_factory_calc_size(df);
+	serialized = malloc(size);
+	_region_init(&data, serialized, size);
+	CHKERR(ret, _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(u_int32_t val)
+{
+	size_t i;
+	linear_zone_t *p;
+
+	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 = 1 << (rowcol_bits - 1);
+	rowcol_mask |= rowcol_mask - 1;
+	for (i = 0; i < rowcol_len; ++i) {
+		p = &rowcol[i];
+		_DIAGASSERT(p->begin <= p->end);
+		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(u_int32_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(u_int32_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(u_int32_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(u_int32_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(u_int32_t begin, u_int32_t end)
+{
+	size_t i;
+	linear_zone_t *p;
+	u_int32_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;
+		_DIAGASSERT(p > rowcol);
+		--p;
+		if (n < p->begin || n > p->end)
+			return 1;
+	}
+	return 0;
+}
+static void
+store(const linear_zone_t *lz, u_int32_t dst, int inc)
+{
+	size_t i, ofs;
+	linear_zone_t *p;
+	u_int32_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(u_int32_t begin, u_int32_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, u_int32_t begin, u_int32_t end)
+{
+	_DIAGASSERT(lz != NULL);
+
+	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)
+{
+	int ret;
+	FILE *out;
+
+        /* dump DB to file */
+	if (output)
+		out = fopen(output, "wb");
+	else
+		out = stdout;
+
+	if (out==NULL)
+		err(EXIT_FAILURE, "fopen");
+
+	ret = _lookup_factory_convert(out, in);
+	fclose(out);
+	if (ret && output)
+		unlink(output); /* dump failure */
+}
+
+static void
+do_mkpv(FILE *in)
+{
+	int ret;
+	FILE *out;
+
+        /* dump pivot to file */
+	if (output)
+		out = fopen(output, "wb");
+	else
+		out = stdout;
+
+	if (out == NULL)
+		err(EXIT_FAILURE, "fopen");
+
+	ret = _pivot_factory_convert(out, in);
+	fclose(out);
+	if (ret && output)
+		unlink(output); /* dump failure */
+	if (ret)
+ 		errc(EXIT_FAILURE, ret, "");
+}
+
+__dead static void
+usage(void)
+{
+	fprintf(stderr, "Usage: %s [-m|-p] [-d] [-o outfile] [infile]\n",
+	    getprogname());
+	exit(EXIT_FAILURE);
+}
+
+int
+main(int argc, char **argv)
+{
+	int ch;
+	extern char *optarg;
+	extern int optind;
+	FILE *in = NULL;
+	int 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);
+}