/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright (c) 1999 by Sun Microsystems, Inc.
 * All rights reserved.
 */


/*
 * For example,
 *               UCS -> UTF-8 -> IBM -> UTF-8
 *                (1)     (2)     (3)	 (4)
 *               tmp    source   result  tmp
 *                           output     (1) (2) (3)line by line
 *                           comparing  (2) (4)
 */

#include <stdio.h>
#include <libgen.h>
#include <stdlib.h>
#include <unistd.h>
#include <locale.h>
#include <iconv.h>
#include <string.h>
#include <errno.h>
#include <stdarg.h>
#include <sys/types.h>
#include <sys/wait.h>

char *	ME;
int	status;
int	flag_display = 1;
int	flag_bubun = 1;


void
usage(int status)
{
	fprintf(stderr, "Usage: %s [-b] [-d] to-code\n", ME);
	exit(status);
}


void
chkprint(char *format, ...)
{
	va_list		ap;
	va_start(ap, format);

	if (0 != flag_display)  {
		(void) vfprintf(stdout, format, ap);
	}
	va_end(ap);
}


void
validate(uint_t i, iconv_t cd, iconv_t cd2, iconv_t cd3)
{
	char		source_buf[1024];
	char		result_buf[1024];
	char		tmp_buf[1024];
	char *		source;
	char *		result;
	char *		tmp;
	size_t		source_len;
	size_t		result_len;
	size_t		result_len2;
	size_t		tmp_len;
	size_t		s;
	int		j;
	ushort_t	*shortp;
	uint_t	*intp;


#define PREPARE_ILLEGALUTF8 \
	if (i == 0xfffe) { \
		source_buf[0] = 0xef; \
		source_buf[1] = 0xbf; \
		source_buf[2] = 0xbe; \
		source_buf[3] = 0x00; \
		source = source_buf;  \
		source_len = 3; \
		chkprint("U+%04x\t** %x **", i, 0xefbfbe); \
	} else if (i == 0xffff) { \
		source_buf[0] = 0xef; \
		source_buf[1] = 0xbf; \
		source_buf[2] = 0xbf; \
		source_buf[3] = 0x00; \
		source = source_buf;  \
		source_len = 3; \
		chkprint("U+%04x\t** %x **", i, 0xefbfbf); \
	} else if (i > 0x7fffffff) { \
		source_buf[0] = 0x0; \
		source_buf[1] = 0x0; \
		source_buf[2] = 0x0; \
		source_buf[3] = 0x0; \
		source_buf[4] = 0x0; \
		source_buf[5] = 0xfe; \
		source_buf[6] = 0x0; \
		source = source_buf;  \
		source_len = 7; \
		chkprint("U+%04x\t** %x **", i, 0xfe); \
	}

#define DATASIZE 4
	/*
	shortp = (ushort_t*)&tmp_buf[0];
	*shortp = 0xfeff;
	shortp = (ushort_t*)&tmp_buf[2];
	*shortp = i;
	*/
	/* chkprint("U+");  */ \
	/*	for( j = 0; j < tmp_len ; j++)  */ \
	/* 	chkprint("%02x", (uchar_t)tmp[j]); */ \
	/*
	shortp = (ushort_t*)&tmp_buf[0]; \
	*shortp = i; \
	*/

#define PREPAREUTF8 \
	tmp = tmp_buf; \
	tmp_len = DATASIZE; \
	intp = (uint_t*)&tmp_buf[0]; \
	*intp = i; \
	source = source_buf; \
	source_len = sizeof (source_buf); \
	\
	chkprint("U+%04x", i); \
	s = iconv(cd2, (const char**)&tmp, &tmp_len, &source, &source_len); \
	if (s != 0) { \
		chkprint(" \n stopped \n"); \
		fprintf(stderr, "fail to convert Unicode to UTF-8\n"); \
		exit (status); \
	} \
	chkprint("\t0x"); \
	for( j = 0; j < sizeof (source_buf) - source_len; j++) \
		chkprint("%02x", (uchar_t)source_buf[j]); \
	source_len = sizeof (source_buf) - source_len; \
	source = &source_buf[0];

#define	COMPARE_ERROR \
	chkprint("\t-> 0x");\
	for (j = 0; j <  sizeof (tmp_buf) - tmp_len; j++) { \
		chkprint("%02x", (uchar_t)tmp_buf[j]);\
	} \
	chkprint("\n warning \n"); \
	fprintf(stderr, " Converting answer is not the same for  (U+%04x)\n", \
		i);

#define COMPARE \
	tmp = tmp_buf; \
	tmp_len = sizeof (tmp_buf); \
	result = result_buf; \
	result_len2 = sizeof (result_buf) - result_len; \
	s = iconv(cd3, (const char**)&result, &result_len2, &tmp, &tmp_len); \
	if (s != 0) { \
		chkprint(" \n WARNING \n"); \
		fprintf(stderr, "fail to convert Orignal Codeset to UTF-8\n",\
		i); \
		fprintf(stderr, "errno=%d %d %d\n", \
			errno, \
			sizeof (result_buf) - result_len - result_len2, \
			result - result_buf); \
		exit (status); \
	} \
	chkprint("\t"); \
	if (sizeof (tmp_buf) - tmp_len != source_len) { \
		COMPARE_ERROR \
	} else { \
		for (j = 0; j < source_len; j++) { \
			if ((uchar_t)tmp_buf[j] != (uchar_t)source_buf[j]) { \
				COMPARE_ERROR \
			} \
		}\
	}


	/*
	 *	LOGIC START
	 */

	if (i == 0xfffe || i == 0xffff || i > 0x7fffffff) {
		PREPARE_ILLEGALUTF8
	} else {
		PREPAREUTF8
	}

	result = result_buf;
	result_len = sizeof (result_buf);
	tmp_len = source_len; /* save to compare source data */
	s = iconv(cd,  (const char**)&source, &source_len, &result,
		&result_len);

	status = 1;
	if (i == 0xfffe || i == 0xffff || i > 0x7fffffff) {
		if ((((size_t)0) == s) ||
			(errno != EILSEQ)) {
			fprintf(stderr, "EILSEQ expected for 0x%x: %d %d %d\n",
			i,
			errno,
		        source_len,
			source - source_buf);
		}
	}
	if (((size_t)(0)) == s) {
		if ((source_len != 0) ||
			((source - source_buf) != tmp_len) ||
			((result - result_buf + result_len) !=
			sizeof (result_buf))) {
			fprintf(stderr, ": %d %d %d\n",
				errno,
				source_len,
				source - source_buf);
			exit(status);
		}
		chkprint("\t0x");
		for( j = 0; j < sizeof (result_buf) - result_len ; j++)
			chkprint("%02x", (uchar_t)result_buf[j]);
		source_len = tmp_len;
		COMPARE
		chkprint("\n");
		return;
	}

	status += 1;
	if (((size_t)(-1)) == s) {
		if (errno == EILSEQ) {
			if (((source - source_buf) !=
				(tmp_len - source_len)) ||
				((result - result_buf + result_len) !=
				sizeof (result_buf))) {
				fprintf(stderr, ": %d %d %d\n",
					errno,
					source_len,
					source - source_buf);
				exit(status);
			}
			chkprint("\tEILSEQ\n", i);
			return;
		}
		fprintf(stderr, "Error for source U+%04x: %d %d %d %d %d\n",
			i,
			errno,
			(DATASIZE) - source_len, /* not converted size */
			source - source_buf,
			(sizeof (result_buf)) - result_len,
			result - result_buf);
		exit(status);
	}

	status += 1;
	exit(status);
}

main(int argc, char ** argv)
{
	int		r;
	char *		p;
	iconv_t		cd;
	iconv_t		cd2;
	iconv_t		cd3;
	uint_t		i, j, k;

	ME = basename(argv[0]);
	setlocale(LC_ALL, "");
	status = 100;


	for (j = 1;  j < argc; j++) {
		if (argv[j][0] != '-')
			break;
		for (k = 1; ; k++) {
			if (argv[j][k] == '\0')
				break;
			if (argv[j][k] == 'b') {
				flag_bubun = 0;
				continue;
			}
			if (argv[j][k] == 'd') {
				flag_display = 0;
				continue;
			}
		}
	}
	if (j >= argc) usage(-1);

	chkprint( "#UCS-4\tUTF-8\t* %s *\n", argv[j]);

	cd = iconv_open( argv[j], "UTF-8"); /* to, from */
	if (((iconv_t)(-1)) == cd) {
		perror("iconv_open");
		exit(status);
	}

	cd2 = iconv_open("UTF-8", "UCS-4");
	if (((iconv_t)(-1)) == cd2) {
		perror("iconv_open for UTF-8");
		exit(status);
	}

	cd3 = iconv_open("UTF-8", argv[j]);
	if (((iconv_t)(-1)) == cd3) {
		perror("iconv_open for reverse");
		exit(status);
	}


	/*
	 *	main logic
	 */
	if (flag_bubun) {
		for (i = 0; i <= 0xff; i++)
			validate(i, cd, cd2, cd3);
		validate(0x100, cd, cd2, cd3);
		validate(0x3ff, cd, cd2, cd3);
		validate(0x400, cd, cd2, cd3);
		validate(0xfff, cd, cd2, cd3);
		validate(0x1000, cd, cd2, cd3);
		validate(0x3fff, cd, cd2, cd3);
		validate(0x4000, cd, cd2, cd3);
		validate(0xfffd, cd, cd2, cd3);
		validate(0xfffe, cd, cd2, cd3);    /* error */
		validate(0xffff, cd, cd2, cd3);    /* error */
		validate(0x10000, cd, cd2, cd3);
		validate(0x3ffff, cd, cd2, cd3);
		validate(0x40000, cd, cd2, cd3);
		validate(0xfffff, cd, cd2, cd3);
		validate(0x100000, cd, cd2, cd3);
		validate(0x1fffff, cd, cd2, cd3);
		validate(0x200000, cd, cd2, cd3);
		validate(0x3fffff, cd, cd2, cd3);
		validate(0x400000, cd, cd2, cd3);
		validate(0xffffff, cd, cd2, cd3);
		validate(0x1000000, cd, cd2, cd3);
		validate(0x3ffffff, cd, cd2, cd3);
		validate(0x4000000, cd, cd2, cd3);
		validate(0xfffffff, cd, cd2, cd3);
		validate(0x10000000, cd, cd2, cd3);
		validate(0x7fffffff, cd, cd2, cd3);
		validate(0x80000000, cd, cd2, cd3); /* error */
	} else {
		int	k;
		for (i = 0, k = 0; i <= 0x80000000; i++, k++) {
			validate(i, cd, cd2, cd3);
			if ((k == 0x1000000) &&
				(0 == flag_display)) {
				printf(" i < 0x%x: checked\n", i);
				k = 0;
			}

		}
	}

	status = 200;
	r = iconv_close(cd);
	if (-1 == r) {
		perror("iconv_close");
		exit(status);
	}

	r = iconv_close(cd2);
	if (-1 == r) {
		perror("iconv_close for UTF-8");
		exit(status);
	}

	r = iconv_close(cd3);
	if (-1 == r) {
		perror("iconv_close for reverse");
		exit(status);
	}

	return (0);
}