/*
 * Copyright (c) 1999 by Sun Microsystems, Inc.
 * All rights reserved.
 */

#pragma ident	"@(#)itmcomp.c 1.7	99/10/03 SMI"

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

#include "itmcomp.h"
#include "maptype.h"

#if !defined(TEXT_DOMAIN)
#define	TEXT_DOMAIN	"SYS_TEST"
#endif
#define	ITMSUFFIX	".bt"
#define	ME_DEFAULT	"geniconvtbl"
#define	CPP_PATH	"/usr/lib/cpp"

itmc_ref_t	*ref_first[ITMC_OBJ_LAST + 1];
itmc_ref_t	*ref_last[ITMC_OBJ_LAST + 1];

itmc_name_t	*name_first;
itmc_name_t	*name_last;

char		*itm_input_file;		/* referred in itm_comp.l */
char		*itm_output_file;

cmd_opt_t	cmd_opt;
itm_num_t	name_id;
itm_num_t	reg_id;

itmc_name_t	name_lookup_error;
int		error_deferred;

char *itm_name_type_name[] = {
	"UNKNOWN",
	"ITM",
	"STRING",
	"DIRECTION",
	"CONDITION",
	"MAP",
	"OPERATION",
	"EXPRESSION",
	"DATA",
	"NAME",
	"RANGE",
	"REGISTER",
};


static void	usage(int status);
static int	cpp_opt_append(char	*opt, char	*arg);
static void	cpp_opt_trunc(int num);
static int	parse_opts(int argc, char	**argv);
static char	*prog_path_expand(const char	*base_name);
static void	map_name_type_append(char	*optarg);
static char	*map_type_name_str(itmc_map_type_t);
static char	*strdup_vital(const char *);

#if defined(ENABLE_TRACE)
static void	trace_option(void);
#endif /* ENABLE_TRACE */
static FILE	*cpp_open(void);
static void	cpp_close(FILE		*fp);
static int	itm_compile(char	*file);
static void	wait_child(pid_t pid);
static int	fork_error(void);




int
main(int argc, char **argv)
{
	char	**pp;
	pid_t	pid;

	(void) setlocale(LC_ALL, "");

	(void) textdomain(TEXT_DOMAIN);

	(void) parse_opts(argc, argv);

#if defined(ENABLE_TRACE)
	trace_option();
#endif /* ENABLE_TRACE */

	if (NULL != cmd_opt.disassemble) {
		disassemble(cmd_opt.disassemble);
	} else if (NULL == cmd_opt.input_file) {
		(void) itm_compile(NULL);
	} else {
		if (1 < cmd_opt.input_file_num) {
			for (pp = cmd_opt.input_file; *pp; pp++) {
				(void) printf("%s:\n", *pp);
				pid = fork();
				switch (pid) {
				case 0:
					exit(itm_compile(*pp));
					break;
				case -1:
					(void) fork_error();
					break;
				default:
					wait_child(pid);
				}
			}
		} else {
			(void) itm_compile(*(cmd_opt.input_file));
		}
	}

	return (0);
}


static int
itm_compile(char *file)
{
	char	*cmd_line;
	char	*command;
	char	*p;
	size_t	length;
	FILE	*fp;

	extern int	yyparse();
	extern FILE *yyin;

	if (NULL == file) {
		itm_input_file = gettext("*stdin*");
	} else {
		if (0 != access(file, R_OK)) {
			int	e = errno;
			itm_error(
				gettext("%1$s: can not access %2$s: "),
				cmd_opt.my_name, file);
			errno = e;
			PERROR(NULL);
			exit(ITMC_STATUS_CMD2);
		}
		itm_input_file = file;
	}

	if ((NULL == cmd_opt.output_file) &&
	    (0 == cmd_opt.no_output)) {
		p = strrchr(file, '.');
		if (NULL == p) {
			length = strlen(file);
		} else {
			length = p - file;
		}
		itm_output_file = malloc_vital(length + 5);
		(void) memcpy(itm_output_file, file, length);
		(void) memcpy(itm_output_file + length, ITMSUFFIX, 5);
	} else {
		itm_output_file = cmd_opt.output_file;
	}

	if (0 != cmd_opt.preprocess) {
		if (NULL == file) {
			fp = cpp_open();
			cmd_line = cmd_opt.preprocess;
		} else {
			(void) cpp_opt_append(file, NULL);
			fp = cpp_open();
			cpp_opt_trunc(1);
		}
		if (NULL == fp) {
			p = strchr(cmd_line, ' ');
			if (NULL == p) {
				length = strlen(cmd_line);
			} else {
				length = (p - cmd_line);
			}
			command = malloc_vital((sizeof (char)) * (length + 1));
			(void) memcpy(command, cmd_line, length);
			*(command + length) = '\0';
			PERROR(command);
			itm_error(
				gettext("%1$s: can not start %2$s on %3$s\n"),
				cmd_opt.my_name, command, itm_input_file);
			exit(ITMC_STATUS_SYS);
		} else {
			yyin = fp;
		}

		(void) yyparse();
		if (NULL == cmd_opt.preprocess_specified) {
			cpp_close(fp);
		}
	} else {
		if ((NULL == file) || (0 != strcmp("-", file))) {
			yyin = stdin;
		} else {
			yyin = fopen(file, "r");
			if (NULL == yyin) {
				itm_error(
					gettext("%1$s: can not open %2$s\n"),
					cmd_opt.my_name, itm_input_file);
				exit(ITMC_STATUS_CMD2);
			}
		}
		(void) yyparse();
		if (stdin != yyin) {
			(void) fclose(yyin);
		}
	}

	return (ITMC_STATUS_SUCCESS);
}




static void
wait_child(pid_t pid)
{
	int	stat_loc;
	char *msgstr;

	(void) waitpid(pid, &stat_loc, 0);
	if (WTERMSIG(stat_loc)) {
		if (WCOREDUMP(stat_loc)) {
			msgstr = gettext("signal received: %s, core dumped\n");
		} else {
			msgstr = gettext("signal received: %s\n");
		}
		itm_error(msgstr, strsignal(WTERMSIG(stat_loc)));
	}
}


static int
fork_error(void)
{
	PERROR(gettext("fork"));
	exit(ITMC_STATUS_SYS);
	return (0); /* never return */
}



static int
parse_opts(int argc, char **argv)
{
	int		c;
	int		i;
	char		*p;
	int		error_num = 0;

#ifdef YYDEBUG
	extern int	yydebug;
#endif /* YYDEBUG */

	extern char	*optarg;
	extern int	optind;


	cmd_opt.my_name = basename(*(argv + 0));
	if ('\0' == *(cmd_opt.my_name)) {
		cmd_opt.my_name = ME_DEFAULT;
	}

	cmd_opt.preprocess_default = CPP_PATH;
	cmd_opt.preprocess = cmd_opt.preprocess_default;
	cmd_opt.strip = 1; /* stripped by default */
	while ((c = getopt(argc, argv, "d:i:p:W:D:I:U:fnsM:lo:qX:h")) != EOF) {
		switch (c) {
		case 'd':
			cmd_opt.disassemble = optarg;
			break;
		case 'i':
			cmd_opt.interpreter = optarg;
			break;
		case 'p':
			if (NULL != cmd_opt.preprocess_specified) {
				(void) fprintf(stderr,
				gettext("multiple -p options are specified\n"));
				error_num += 1;
			}
			cmd_opt.preprocess_specified =
				prog_path_expand(optarg);
			cmd_opt.preprocess = cmd_opt.preprocess_specified;
			if (NULL == cmd_opt.preprocess) {
				(void) fprintf(stderr,
				gettext("cannot find preprocessor \"%s\"\n"),
					optarg);
				error_num += 1;
			}
			(void) cpp_opt_append(NULL, NULL);
			p = basename(optarg);
			if (NULL == p) {
				*(cmd_opt.cpp_opt + 0) = strdup_vital(optarg);
			} else {
				*(cmd_opt.cpp_opt + 0) = strdup_vital(p);
			}
			break;
		case 'W':
			if (cpp_opt_append(optarg, NULL)) {
				error_num += 1;
			}
			break;
		case 'I':
			if (cpp_opt_append("-I", optarg)) {
				error_num += 1;
			}
			break;
		case 'D':
			if (cpp_opt_append("-D", optarg)) {
				error_num += 1;
			}
			break;
		case 'U':
			if (cpp_opt_append("-U", optarg)) {
				error_num += 1;
			}
			break;
		case 'f':
			cmd_opt.force_overwrite = 1;
			break;
		case 'n':
			cmd_opt.no_output = 1;
			break;
		case 'M':
			map_name_type_append(optarg);
			break;
		case 'l':
			cmd_opt.large_table = 1;
			break;
		case 'o':
			cmd_opt.output_file = optarg;
			break;
		case 's':
			cmd_opt.strip = 0;
			break;
		case 'q':
			cmd_opt.quiet = 1;
			break;
#if defined(ENABLE_TRACE)
		case 'X':
			cmd_opt.trace = malloc_vital((sizeof (char)) * 128);
			(void) memset(cmd_opt.trace, 0, (sizeof (char)) * 128);
			for (p = optarg; *p; p++) {
				*(cmd_opt.trace + ((*p) & 0x007f)) = 1;
			}
#ifdef YYDEBUG
			if (TRACE('Y'))	yydebug = 1;
#endif /* YYDEBUG */
			break;
#endif /* ENABLE_TRACE */
		case 'h':
			usage(ITMC_STATUS_SUCCESS);
			break;
		default:
			usage(ITMC_STATUS_CMD);
		}
	}

	if (optind < argc) {
		cmd_opt.input_file_num = (argc - optind);
		cmd_opt.input_file =
			malloc_vital((sizeof (char *)) *
					(argc - optind + 1));
		*(cmd_opt.input_file + (argc - optind)) = NULL;
	}

	for (i = 0; optind < argc; optind++, i++) {
		*(cmd_opt.input_file + i) = argv[optind];
	}

	/* check conflict */

	if ((1 < cmd_opt.input_file_num) && (NULL != cmd_opt.output_file)) {
		itm_error(gettext("use -o with single input file\n"));
		error_num++;
	}

	if ((cmd_opt.input_file_num <= 0) &&
	    (NULL == cmd_opt.output_file) &&
	    (NULL == cmd_opt.disassemble) &&
	    (0 == cmd_opt.no_output)) {
		itm_error(gettext(
			"output file is unnamed. "
			"use -o to specify output file\n"));
		error_num++;
	}

	if (cmd_opt.disassemble &&
	    (cmd_opt.interpreter ||
	    cmd_opt.cpp_opt ||
	    cmd_opt.preprocess_specified ||
	    cmd_opt.input_file ||
	    cmd_opt.force_overwrite ||
	    cmd_opt.no_output ||
	    cmd_opt.map_name_type ||
	    cmd_opt.large_table ||
	    cmd_opt.output_file)) {
		itm_error(
			gettext("-d may not specified with other options\n"));
		error_num++;
	}

	if (error_num) {
		usage(ITMC_STATUS_CMD);
	}

	/*
	 * do not move upward
	 * may conflict with -d option
	 */
	if ((NULL == cmd_opt.preprocess_specified) &&
	    (NULL != cmd_opt.preprocess_default)) {
		(void) cpp_opt_append(NULL, NULL);
		p = basename(cmd_opt.preprocess_default);
		if (NULL == p) {
			*(cmd_opt.cpp_opt + 0) =
				strdup_vital(cmd_opt.preprocess_default);
		} else {
			*(cmd_opt.cpp_opt + 0) = strdup_vital(p);
		}
	}
	return (0);
}


static FILE *
cpp_open(void)
{
	pid_t	pid;
	int	filedes[2];
	int	i;

	for (i = 0; i < cmd_opt.cpp_opt_num; i++) {
		TRACE_MESSAGE('C', ("%s\n", *(cmd_opt.cpp_opt + i)));
	}

	if (pipe(filedes)) {
		PERROR(gettext("pipe"));
		itm_error(gettext("failed to open pipe\n"));
		exit(ITMC_STATUS_SYS);
	}
	pid = fork();
	if (pid == 0) {	/* child */
		(void) close(filedes[0]);
		(void) close(1);
		(void) dup2(filedes[1], 1);
		(void) execv(cmd_opt.preprocess, cmd_opt.cpp_opt);
		exit(0);
	} else if (pid == (pid_t)(-1)) {	/* error */
		return	(NULL);
	} else {
		(void) close(filedes[1]);
		return (fdopen(filedes[0], "r"));
	}
	return	(NULL); /* NEVER */
}


static int
cpp_opt_append(char	*opt, char	*arg)
{
	size_t	opt_len;
	size_t	arg_len;
	char	*new_opt;
	char	**new_opt_list;

	opt_len = ((NULL == opt) ? 0 : strlen(opt));
	arg_len = ((NULL == arg) ? 0 : strlen(arg));
	if (0 < (opt_len + arg_len)) {
		new_opt = malloc_vital(opt_len + arg_len + 1);
		if (NULL != opt) {
			(void) memcpy(new_opt, opt, opt_len + 1);
		}
		if (NULL != arg) {
			(void) memcpy(new_opt + opt_len, arg, arg_len + 1);
		}
	} else {
		new_opt = NULL;
	}

	if (0 == cmd_opt.cpp_opt_reserved) {
		cmd_opt.cpp_opt_reserved = 32;
		cmd_opt.cpp_opt = malloc_vital((sizeof (char *)) * 32);
		*(cmd_opt.cpp_opt + 0) = "cpp";
		cmd_opt.cpp_opt_num = 1;
	} else if ((cmd_opt.cpp_opt_reserved - 2) <= cmd_opt.cpp_opt_num) {
		cmd_opt.cpp_opt_reserved += 32;
		new_opt_list = malloc_vital((sizeof (char *)) *
					    cmd_opt.cpp_opt_reserved);
		(void) memcpy(new_opt_list, cmd_opt.cpp_opt,
			(sizeof (char *)) * cmd_opt.cpp_opt_num);
		(void) memset(new_opt_list + cmd_opt.cpp_opt_num, 0, 32);
		free(cmd_opt.cpp_opt);
		cmd_opt.cpp_opt = new_opt_list;
	}
	if (NULL != new_opt) {
		*(cmd_opt.cpp_opt + cmd_opt.cpp_opt_num) = new_opt;
		cmd_opt.cpp_opt_num += 1;
	}
	return (0);
}


static void
cpp_opt_trunc(int num)
{
	if (cmd_opt.cpp_opt_num < num) {
		num = cmd_opt.cpp_opt_num;
	}
	for (; 0 < num; --num) {
		free(cmd_opt.cpp_opt + cmd_opt.cpp_opt_num);
		--(cmd_opt.cpp_opt_num);
	}
}


static void
cpp_close(FILE *fp)
{
	(void) fclose(fp);
	(void) wait_child(0);
}




static char *
prog_path_expand(const char *base_name)
{
	size_t	base_len;
	size_t	dir_len;
	char	path[MAXPATHLEN];
	char	*p;
	char	*pe;

	base_len = strlen(base_name);
	path[0] = '\0';

	if (NULL != strchr(base_name, '/')) {
		if (0 == access(base_name, X_OK)) {
			return (strdup_vital(base_name));
		} else {
			return (NULL);
		}
	}

	for (p = getenv("PATH"); p; ) {
		pe = strchr(p, ':');
		dir_len = ((NULL == pe) ? strlen(p) : (pe - p));
		(void) memcpy(path, p, dir_len);
		if ((0 != dir_len) &&
		    ('/' != path[dir_len - 1])) {
			path[dir_len] = '/';
			dir_len += 1;
		}
		if ((dir_len + base_len) < MAXPATHLEN) {
			(void) memcpy(path + dir_len, base_name, base_len + 1);
			if (0 == access(path, X_OK)) {
				return (strdup_vital(path));
			}
		}
		p = ((NULL == pe) ? NULL : (pe + 1));
	}
	return	(NULL);
}


static void
usage(int status)
{

	if (ITMC_STATUS_SUCCESS == status) {
		(void) fprintf(stdout,
		gettext("Usage: %1$s [-n] [-f] [-q]\n"
		"	     [-p preprocessor] [-W argument]\n"
		"	     [-Dname] [-Dname=def] [-Idirectory] [-Uname]\n"
		"	     [file ...]\n	%2$s -h\n"),
		cmd_opt.my_name, cmd_opt.my_name);
	} else {
		(void) itm_error(
		gettext("Usage: %1$s [-n] [-f] [-q]\n"
		"	     [-p preprocessor] [-W argument]\n"
		"	     [-Dname] [-Dname=def] [-Idirectory] [-Uname]\n"
		"	     [file ...]\n	%2$s -h\n"),
		cmd_opt.my_name, cmd_opt.my_name);
	}
	exit(status);
}


static char *
map_type_name_str(itmc_map_type_t type)
{
	int	i;
	for (i = 0; NULL != map_type_name[i].name; i++) {
		if (type == map_type_name[i].type) {
			return (map_type_name[i].name);
		}
	}
	return ("");
}

static void
map_name_type_append(char *optarg)
{
	char			*oa;
	char			*oa_save;
	char			*name;
	char			*p;
	char			*phf;
	int			hash_factor = 0;
	itmc_map_type_t		type;
	itmc_map_name_type_t	*m;
	int			i;

	oa = oa_save = strdup_vital(optarg);

	while ((NULL != oa) && ('\0' != *oa)) {
		name = oa;
		oa = strchr(oa, ',');
		if (NULL != oa) {
			*(oa++) = '\0';
		}
		p = strchr(name, '=');
		if (NULL == p) {
			type = ITMC_MAP_AUTOMATIC;
		} else {
			*(p++) = '\0';
			if ('\0' == *p) {
				type = ITMC_MAP_AUTOMATIC;
			} else {
				phf = strchr(p, ':');
				if (NULL != phf) {
					*(phf++) = '\0';
					hash_factor = atoi(phf);
					if (hash_factor < 0) {
						itm_error(
						gettext(
						"invalid hash factor is "
						"specified: %s\n"),
							phf);
						hash_factor = 0;
						error_deferred += 1;
					}
				}
				for (i = 0;
				    NULL != map_type_name[i].name; i++) {
					if (0 ==
					    strcmp(p, map_type_name[i].name)) {
						type = map_type_name[i].type;
						break;
					}
				}
				if (NULL == map_type_name[i].name) {
					itm_error(
					gettext(
					"unknown map type is specified: %s\n"),
					p);
					error_deferred += 1;
					continue;
				}
			}
		}
		if (0 == strcmp(name, "default")) {
			*name = '\0';
		}
		m = cmd_opt.map_name_type;
		if (NULL == m) {
			m = malloc_vital(sizeof (itmc_map_name_type_t));
			m->name = strdup_vital(name);
			m->type = type;
			m->hash_factor = hash_factor;
			m->next = NULL;
			cmd_opt.map_name_type = m;
			continue;
		}
		for (; ; m = m->next) {
			if (0 == strcmp(name, m->name)) {
				if (type == m->type) {
					m = NULL;
					break;
				}
				if ('\0' == *name) {
					itm_error(
					gettext(
					"multiple default types are specified:"
					" \"%1$s\" and \"%2$s\"\n"),
						map_type_name_str(type),
						map_type_name_str(m->type));
				} else {
					itm_error(
					gettext("map \"%1$s\" is specified as "
					"two types \"%2$s\" and \"%3$s\"\n"),
					name,
					map_type_name_str(type),
					map_type_name_str(m->type));
				}
				error_deferred += 1;
				m = NULL;
				break;
			}
			if (NULL == m->next) {
				break;
			}
		}
		if (NULL != m) {
			m->next = malloc_vital(sizeof (itmc_map_name_type_t));
			m = m->next;
			m->name = strdup_vital(name);
			m->type = type;
			m->hash_factor = hash_factor;
			m->next = NULL;

		}
	}
	free(oa_save);
}



void *
malloc_vital(size_t size)
{
	void	*p;

	TRACE_MESSAGE('M', ("malloc_vital: %d\n", size));

	size = ITMROUNDUP(size);

	p = (void*) malloc(size);
	if (NULL == p) {
		PERROR(gettext("malloc"));
		exit(ITMC_STATUS_SYS);
	}

	(void) memset(p, 0, size);

	return	(p);
}


static char *
strdup_vital(const char		*str)
{
	char	*p;
	size_t	len;

	if (NULL == str) {
		return	(NULL);
	}

	len = strlen(str) + 1;
	p = malloc_vital(len);
	(void) memcpy(p, str, len);
	return	(p);
}





itm_data_t *
str_to_data(int size, char *seq)
{
	itm_data_t *data;

	data = malloc_vital(sizeof (itm_data_t));

	data->size = size;
	if (size <= sizeof (data->place)) {
		(void) memmove(&(data->place), seq, size);
	} else {
		data->place.itm_ptr = (itm_place2_t)malloc_vital(size);
		(void) memmove((char *)(data->place.itm_ptr), seq, size);
	}

	return	(data);
}


char *
name_to_str(itm_data_t *name)
{
	static char	*ptr = NULL;
	static size_t	len = 0;
	size_t		req_len;
	char		*p;

	if (NULL == name) {
		p = gettext("(no name)");
		req_len = strlen(p) + 1;
	} else {
		req_len = name->size + 1;
	}

	if (len <= req_len) {
		len += 512;
		free(ptr);
		ptr = malloc_vital(len);
	}

	if (NULL == name) {
		(void) memcpy(ptr, p, req_len);
		*(ptr + req_len) = '\0';
	} else if (name->size <= (sizeof (name->place))) {
		(void) memcpy(ptr, (char *)(&(name->place)), name->size);
		*(ptr + name->size) = '\0';
	} else {
		(void) memcpy(ptr, (char *)(name->place.itm_ptr), name->size);
		*(ptr + name->size) = '\0';
	}

	return	(ptr);
}

#define	ARGUMENTSMAX (8)
char *
data_to_hexadecimal(itm_data_t		*data)
{
	static int index = 0;
	static char	*ptr[ARGUMENTSMAX] = { NULL, NULL, NULL, NULL,
						NULL, NULL, NULL, NULL};
	static long	len[ARGUMENTSMAX] = { 0, 0, 0, 0, 0, 0, 0, 0};
	char		*hdp;
	char		*p;
	long		i;
	int		val;
	size_t		req_len;

	if (ARGUMENTSMAX <= index) index = 0;
	req_len = (2 * data->size) + 1;
	if (len[index] <= req_len) {
		len[index] += 512;
		free(ptr[index]);
		ptr[index] = malloc_vital(len[index]);
	}
	hdp = ptr[index];

	if (data->size <= (sizeof (itm_place_t))) {
		p = (char *)&(data->place);
	} else {
		p = (char *)(data->place.itm_ptr);
	}

	for (i = 0; i < data->size; i++, p++) {
		val = ((*p & 0x00f0) >> 4);
		if ((0 <= val) && (val <= 9)) {
			*hdp = '0' + val;
		} else {
			*hdp = 'a' + val - 10;
		}
		hdp++;

		val = (*p & 0x000f);
		if ((0 <= val) && (val <= 9)) {
			*hdp = '0' + val;
		} else {
			*hdp = 'a' + val - 10;
		}
		hdp++;
	}
	*hdp = '\0';
	return (ptr[index++]);
}





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

	if (0 == cmd_opt.quiet) {
		(void) vfprintf(stderr, format, ap);
	}
	va_end(ap);
}

#if defined(ENABLE_TRACE)
static void
trace_option(void)
{
	char **pp;
	int	i;

	if (!(TRACE('o')))
		return;

	itm_error("my_name	   = %s\n", cmd_opt.my_name);
	if (NULL == cmd_opt.input_file) {
		(void) fprintf(stdout, "input_file   = (stdin)\n");
	} else {
		for (pp = cmd_opt.input_file; *pp; pp++) {
			(void) fprintf(stdout, "input_file   = %s\n", *pp);
		}
	}
	itm_error("output_file  = %s\n",
		cmd_opt.output_file ? cmd_opt.output_file : "(stdout)");
	itm_error("interpreter  = %s\n",
		cmd_opt.interpreter ? cmd_opt.interpreter : "(default)");
	if (cmd_opt.cpp_opt) {
		itm_error("cpp_opt	   = %s\n", *(cmd_opt.cpp_opt));
		for (i = 1; i < cmd_opt.cpp_opt_num; i++) {
			itm_error("\t%s\n", *(cmd_opt.cpp_opt + i));
		}
	} else {
		itm_error("cpp_opt	   = %s\n", "(none)");
	}
	itm_error("preprocess_default = %s\n",
		cmd_opt.preprocess_default ? cmd_opt.preprocess_default :
		"(no)");
	itm_error("preprocess_specified = %s\n",
		cmd_opt.preprocess_specified ? cmd_opt.preprocess_specified :
		"(no)");
	itm_error("preprocess   = %s\n",
		cmd_opt.preprocess ? cmd_opt.preprocess : "(no)");
	itm_error("disassemble  = %s\n",
		cmd_opt.disassemble ? "yes" : "no");
	itm_error("map type	   =");
	if (NULL == cmd_opt.map_name_type) {
		itm_error("\n");
	} else {
		itmc_map_name_type_t *m;
		itm_error(" ");
		m = cmd_opt.map_name_type;
		itm_error("%s=%s",
			(((NULL == m->name) || ('\0' == *(m->name))) ?
				"default" : m->name),
			map_type_name_str(m->type));
		if (0 != m->hash_factor) {
			itm_error(":%ld\n", m->hash_factor);
		} else {
			(void) fputc('\n', stderr);
		}
		for (m = m->next; NULL != m; m = m->next) {
			itm_error("		%s=%s",
				(((NULL == m->name) || ('\0' == *(m->name))) ?
					"default" : m->name),
				map_type_name_str(m->type));
			if (0 != m->hash_factor) {
				itm_error(":%ld\n", m->hash_factor);
			} else {
				(void) fputc('\n', stderr);
			}
		}
	}
	itm_error("large table  = %s\n",
		cmd_opt.large_table ? "true" : "false");
	itm_error("overwrite	   = %s\n",
		cmd_opt.force_overwrite ? "true" : "false");
	itm_error("strip	      = %s\n",
		cmd_opt.strip ? "true" : "false");
	itm_error("no_output	   = %s\n",
		cmd_opt.no_output ? "true" : "false");
	itm_error("trace	      = ");
	if (NULL == cmd_opt.trace) {
		itm_error("(no)\n");
	} else {
		for (i = 0x21; i < 0x7f; i++) {
			if (TRACE(i)) {
				(void) fputc(i, stderr);
			}
		}
		(void) fputc('\n', stderr);
	}
}
#endif /* ENABLE_TRACE */

#if defined(ENABLE_TRACE)
extern void
trace_message(char *format, ...)
{
	va_list	ap;
	va_start(ap, format);

	(void) vfprintf(stderr, format, ap);

	va_end(ap);
}
#endif /* ENABLE_TRACE */
