/***************************************************************************

    validity.c

    Validity checks on internal data structures.

****************************************************************************

    Copyright Aaron Giles
    All rights reserved.

    Redistribution and use in source and binary forms, with or without
    modification, are permitted provided that the following conditions are
    met:

        * Redistributions of source code must retain the above copyright
          notice, this list of conditions and the following disclaimer.
        * 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.
        * Neither the name 'MAME' nor the names of its contributors may be
          used to endorse or promote products derived from this software
          without specific prior written permission.

    THIS SOFTWARE IS PROVIDED BY AARON GILES ''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 AARON GILES 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 "emu.h"
#include "hash.h"
#include "validity.h"
#include "emuopts.h"
#include "softlist.h"
#include <ctype.h>


//**************************************************************************
//  COMPILE-TIME VALIDATION
//**************************************************************************

// if the following lines error during compile, your PTR64 switch is set incorrectly in the makefile
#ifdef PTR64
UINT8 your_ptr64_flag_is_wrong[(int)(sizeof(void *) - 7)];
#else
UINT8 your_ptr64_flag_is_wrong[(int)(5 - sizeof(void *))];
#endif



//**************************************************************************
//  TYPE DEFINITIONS
//**************************************************************************

extern const device_type *s_devices_sorted[];
extern int m_device_count;



//**************************************************************************
//  INLINE FUNCTIONS
//**************************************************************************

//-------------------------------------------------
//  ioport_string_from_index - return an indexed
//  string from the I/O port system
//-------------------------------------------------

inline const char *validity_checker::ioport_string_from_index(UINT32 index)
{
	return input_port_string_from_token((const char *)(FPTR)index);
}


//-------------------------------------------------
//  get_defstr_index - return the index of the
//  string assuming it is one of the default
//  strings
//-------------------------------------------------

inline int validity_checker::get_defstr_index(const char *string, bool suppress_error)
{
	// check for strings that should be DEF_STR
	int strindex = m_defstr_map.find(string);
	if (!suppress_error && strindex != 0 && string != ioport_string_from_index(strindex))
		mame_printf_error("Must use DEF_STR( %s )\n", string);
	return strindex;
}


//-------------------------------------------------
//  validate_tag - ensure that the given tag
//  meets the general requirements
//-------------------------------------------------

void validity_checker::validate_tag(const char *tag)
{
	// some common names that are now deprecated
	if (strcmp(tag, "main") == 0 || strcmp(tag, "audio") == 0 || strcmp(tag, "sound") == 0 || strcmp(tag, "left") == 0 || strcmp(tag, "right") == 0)
		mame_printf_error("Invalid generic tag '%s' used\n", tag);

	// scan for invalid characters
	static const char *validchars = "abcdefghijklmnopqrstuvwxyz0123456789_.:^$";
	for (const char *p = tag; *p != 0; p++)
	{
		// only lower-case permitted
		if (*p != tolower((UINT8)*p))
		{
			mame_printf_error("Tag '%s' contains upper-case characters\n", tag);
			break;
		}
		if (*p == ' ')
		{
			mame_printf_error("Tag '%s' contains spaces\n", tag);
			break;
		}
		if (strchr(validchars, *p) == NULL)
		{
			mame_printf_error("Tag '%s' contains invalid character '%c'\n",  tag, *p);
			break;
		}
	}

	// find the start of the final tag
	const char *begin = strrchr(tag, ':');
	if (begin == NULL)
		begin = tag;
	else
		begin += 1;

	// 0-length = bad
	if (strlen(begin) == 0)
		mame_printf_error("Found 0-length tag\n");

	// too short/too long = bad
	if (strlen(begin) < MIN_TAG_LENGTH)
		mame_printf_error("Tag '%s' is too short (must be at least %d characters)\n", tag, MIN_TAG_LENGTH);
	if (strlen(begin) > MAX_TAG_LENGTH)
		mame_printf_error("Tag '%s' is too longer (must be less than %d characters)\n", tag, MAX_TAG_LENGTH);
}



//**************************************************************************
//  VALIDATION FUNCTIONS
//**************************************************************************

//-------------------------------------------------
//  validity_checker - constructor
//-------------------------------------------------

validity_checker::validity_checker(emu_options &options)
	: m_drivlist(options),
	  m_errors(0),
	  m_warnings(0),
	  m_current_driver(NULL),
	  m_current_config(NULL),
	  m_current_device(NULL),
	  m_current_ioport(NULL)
{
	// pre-populate the defstr map with all the default strings
	for (int strnum = 1; strnum < INPUT_STRING_COUNT; strnum++)
	{
		const char *string = ioport_string_from_index(strnum);
		if (string != NULL)
			m_defstr_map.add(string, strnum, false);
	}
}


//-------------------------------------------------
//  check_driver - check a single driver
//-------------------------------------------------

void validity_checker::check_driver(const game_driver &driver)
{
	// simply validate the one driver
	validate_begin();
	validate_one(driver);
	validate_end();
}


//-------------------------------------------------
//  check_shared_source - check all drivers that
//  share the same source file as the given driver
//-------------------------------------------------

void validity_checker::check_shared_source(const game_driver &driver)
{
	// initialize
	validate_begin();

	// then iterate over all drivers and check the ones that share the same source file
	m_drivlist.reset();
	while (m_drivlist.next())
		if (strcmp(driver.source_file, m_drivlist.driver().source_file) == 0)
			validate_one(m_drivlist.driver());

	// cleanup
	validate_end();
}


//-------------------------------------------------
//  check_all - check all drivers
//-------------------------------------------------

void validity_checker::check_all()
{
	// start by checking core stuff
	validate_begin();
	validate_core();
	validate_inlines();

	// then iterate over all drivers and check them
	m_drivlist.reset();
	while (m_drivlist.next())
		validate_one(m_drivlist.driver());

	// cleanup
	validate_end();
}


//-------------------------------------------------
//  validate_begin - prepare for validation by
//  taking over the output callbacks and resetting
//  our internal state
//-------------------------------------------------

void validity_checker::validate_begin()
{
	// take over error and warning outputs
	m_saved_error_output = mame_set_output_channel(OUTPUT_CHANNEL_ERROR, output_delegate(FUNC(validity_checker::error_output), this));
	m_saved_warning_output = mame_set_output_channel(OUTPUT_CHANNEL_WARNING, output_delegate(FUNC(validity_checker::warning_output), this));

	// reset all our maps
	m_names_map.reset();
	m_descriptions_map.reset();
	m_roms_map.reset();
	m_defstr_map.reset();
	m_region_map.reset();

	// reset internal state
	m_errors = 0;
	m_warnings = 0;

	// reset some special case state
	software_list_device::reset_checked_lists();
}


//-------------------------------------------------
//  validate_end - restore output callbacks and
//  clean up
//-------------------------------------------------

void validity_checker::validate_end()
{
	// restore the original output callbacks
	mame_set_output_channel(OUTPUT_CHANNEL_ERROR, m_saved_error_output);
	mame_set_output_channel(OUTPUT_CHANNEL_WARNING, m_saved_warning_output);
}


//-------------------------------------------------
//  validate_drivers - master validity checker
//-------------------------------------------------

void validity_checker::validate_one(const game_driver &driver)
{
	// set the current driver
	m_current_driver = &driver;
	m_current_config = NULL;
	m_current_device = NULL;
	m_current_ioport = NULL;
	m_region_map.reset();

	// reset error/warning state
	int start_errors = m_errors;
	int start_warnings = m_warnings;
	m_error_text.reset();
	m_warning_text.reset();

	// wrap in try/except to catch fatalerrors
	try
	{
		machine_config config(driver, m_drivlist.options());
		m_current_config = &config;
		validate_driver();
		validate_roms();
		validate_inputs();
		validate_display();
		validate_gfx();
		validate_devices();
		validate_slots();
	}
	catch (emu_fatalerror &err)
	{
		mame_printf_error("Fatal error %s", err.string());
	}
	m_current_config = NULL;

	// if we had warnings or errors, output
	if (m_errors > start_errors || m_warnings > start_warnings)
	{
		astring tempstr;
		output_via_delegate(m_saved_error_output, "Driver %s (file %s): %d errors, %d warnings\n", driver.name, core_filename_extract_base(tempstr, driver.source_file).cstr(), m_errors - start_errors, m_warnings - start_warnings);
		if (m_errors > start_errors)
		{
			m_error_text.replace("\n", "\n   ");
			output_via_delegate(m_saved_error_output, "Errors:\n   %s", m_error_text.cstr());
		}
		if (m_warnings > start_warnings)
		{
			m_warning_text.replace("\n", "\n   ");
			output_via_delegate(m_saved_error_output, "Warnings:\n   %s", m_warning_text.cstr());
		}
		output_via_delegate(m_saved_error_output, "\n");
	}

	// reset the driver/device
	m_current_driver = NULL;
	m_current_config = NULL;
	m_current_device = NULL;
	m_current_ioport = NULL;
}


//-------------------------------------------------
//  validate_core - validate core internal systems
//-------------------------------------------------

void validity_checker::validate_core()
{

	// basic system checks
	UINT8 a = 0xff;
	UINT8 b = a + 1;
	if (b > a) mame_printf_error("UINT8 must be 8 bits\n");

	// check size of core integer types
	if (sizeof(INT8)   != 1) mame_printf_error("INT8 must be 8 bits\n");
	if (sizeof(UINT8)  != 1) mame_printf_error("UINT8 must be 8 bits\n");
	if (sizeof(INT16)  != 2) mame_printf_error("INT16 must be 16 bits\n");
	if (sizeof(UINT16) != 2) mame_printf_error("UINT16 must be 16 bits\n");
	if (sizeof(INT32)  != 4) mame_printf_error("INT32 must be 32 bits\n");
	if (sizeof(UINT32) != 4) mame_printf_error("UINT32 must be 32 bits\n");
	if (sizeof(INT64)  != 8) mame_printf_error("INT64 must be 64 bits\n");
	if (sizeof(UINT64) != 8) mame_printf_error("UINT64 must be 64 bits\n");

	// check pointer size
#ifdef PTR64
	if (sizeof(void *) != 8) mame_printf_error("PTR64 flag enabled, but was compiled for 32-bit target\n");
#else
	if (sizeof(void *) != 4) mame_printf_error("PTR64 flag not enabled, but was compiled for 64-bit target\n");
#endif

	// check endianness definition
	UINT16 lsbtest = 0;
	*(UINT8 *)&lsbtest = 0xff;
#ifdef LSB_FIRST
	if (lsbtest == 0xff00) mame_printf_error("LSB_FIRST specified, but running on a big-endian machine\n");
#else
	if (lsbtest == 0x00ff) mame_printf_error("LSB_FIRST not specified, but running on a little-endian machine\n");
#endif
}


//-------------------------------------------------
//  validate_inlines - validate inline function
//  behaviors
//-------------------------------------------------

void validity_checker::validate_inlines()
{
#undef rand
	volatile UINT64 testu64a = rand() ^ (rand() << 15) ^ ((UINT64)rand() << 30) ^ ((UINT64)rand() << 45);
	volatile INT64 testi64a = rand() ^ (rand() << 15) ^ ((INT64)rand() << 30) ^ ((INT64)rand() << 45);
#ifdef PTR64
	volatile INT64 testi64b = rand() ^ (rand() << 15) ^ ((INT64)rand() << 30) ^ ((INT64)rand() << 45);
#endif
	volatile UINT32 testu32a = rand() ^ (rand() << 15);
	volatile UINT32 testu32b = rand() ^ (rand() << 15);
	volatile INT32 testi32a = rand() ^ (rand() << 15);
	volatile INT32 testi32b = rand() ^ (rand() << 15);
	INT32 resulti32, expectedi32;
	UINT32 resultu32, expectedu32;
	INT64 resulti64, expectedi64;
	UINT64 resultu64, expectedu64;
	INT32 remainder, expremainder;
	UINT32 uremainder, expuremainder, bigu32 = 0xffffffff;

	// use only non-zero, positive numbers
	if (testu64a == 0) testu64a++;
	if (testi64a == 0) testi64a++;
	else if (testi64a < 0) testi64a = -testi64a;
#ifdef PTR64
	if (testi64b == 0) testi64b++;
	else if (testi64b < 0) testi64b = -testi64b;
#endif
	if (testu32a == 0) testu32a++;
	if (testu32b == 0) testu32b++;
	if (testi32a == 0) testi32a++;
	else if (testi32a < 0) testi32a = -testi32a;
	if (testi32b == 0) testi32b++;
	else if (testi32b < 0) testi32b = -testi32b;

	resulti64 = mul_32x32(testi32a, testi32b);
	expectedi64 = (INT64)testi32a * (INT64)testi32b;
	if (resulti64 != expectedi64)
		mame_printf_error("Error testing mul_32x32 (%08X x %08X) = %08X%08X (expected %08X%08X)\n", testi32a, testi32b, (UINT32)(resulti64 >> 32), (UINT32)resulti64, (UINT32)(expectedi64 >> 32), (UINT32)expectedi64);

	resultu64 = mulu_32x32(testu32a, testu32b);
	expectedu64 = (UINT64)testu32a * (UINT64)testu32b;
	if (resultu64 != expectedu64)
		mame_printf_error("Error testing mulu_32x32 (%08X x %08X) = %08X%08X (expected %08X%08X)\n", testu32a, testu32b, (UINT32)(resultu64 >> 32), (UINT32)resultu64, (UINT32)(expectedu64 >> 32), (UINT32)expectedu64);

	resulti32 = mul_32x32_hi(testi32a, testi32b);
	expectedi32 = ((INT64)testi32a * (INT64)testi32b) >> 32;
	if (resulti32 != expectedi32)
		mame_printf_error("Error testing mul_32x32_hi (%08X x %08X) = %08X (expected %08X)\n", testi32a, testi32b, resulti32, expectedi32);

	resultu32 = mulu_32x32_hi(testu32a, testu32b);
	expectedu32 = ((INT64)testu32a * (INT64)testu32b) >> 32;
	if (resultu32 != expectedu32)
		mame_printf_error("Error testing mulu_32x32_hi (%08X x %08X) = %08X (expected %08X)\n", testu32a, testu32b, resultu32, expectedu32);

	resulti32 = mul_32x32_shift(testi32a, testi32b, 7);
	expectedi32 = ((INT64)testi32a * (INT64)testi32b) >> 7;
	if (resulti32 != expectedi32)
		mame_printf_error("Error testing mul_32x32_shift (%08X x %08X) >> 7 = %08X (expected %08X)\n", testi32a, testi32b, resulti32, expectedi32);

	resultu32 = mulu_32x32_shift(testu32a, testu32b, 7);
	expectedu32 = ((INT64)testu32a * (INT64)testu32b) >> 7;
	if (resultu32 != expectedu32)
		mame_printf_error("Error testing mulu_32x32_shift (%08X x %08X) >> 7 = %08X (expected %08X)\n", testu32a, testu32b, resultu32, expectedu32);

	while ((INT64)testi32a * (INT64)0x7fffffff < testi64a)
		testi64a /= 2;
	while ((UINT64)testu32a * (UINT64)bigu32 < testu64a)
		testu64a /= 2;

	resulti32 = div_64x32(testi64a, testi32a);
	expectedi32 = testi64a / (INT64)testi32a;
	if (resulti32 != expectedi32)
		mame_printf_error("Error testing div_64x32 (%08X%08X / %08X) = %08X (expected %08X)\n", (UINT32)(testi64a >> 32), (UINT32)testi64a, testi32a, resulti32, expectedi32);

	resultu32 = divu_64x32(testu64a, testu32a);
	expectedu32 = testu64a / (UINT64)testu32a;
	if (resultu32 != expectedu32)
		mame_printf_error("Error testing divu_64x32 (%08X%08X / %08X) = %08X (expected %08X)\n", (UINT32)(testu64a >> 32), (UINT32)testu64a, testu32a, resultu32, expectedu32);

	resulti32 = div_64x32_rem(testi64a, testi32a, &remainder);
	expectedi32 = testi64a / (INT64)testi32a;
	expremainder = testi64a % (INT64)testi32a;
	if (resulti32 != expectedi32 || remainder != expremainder)
		mame_printf_error("Error testing div_64x32_rem (%08X%08X / %08X) = %08X,%08X (expected %08X,%08X)\n", (UINT32)(testi64a >> 32), (UINT32)testi64a, testi32a, resulti32, remainder, expectedi32, expremainder);

	resultu32 = divu_64x32_rem(testu64a, testu32a, &uremainder);
	expectedu32 = testu64a / (UINT64)testu32a;
	expuremainder = testu64a % (UINT64)testu32a;
	if (resultu32 != expectedu32 || uremainder != expuremainder)
		mame_printf_error("Error testing divu_64x32_rem (%08X%08X / %08X) = %08X,%08X (expected %08X,%08X)\n", (UINT32)(testu64a >> 32), (UINT32)testu64a, testu32a, resultu32, uremainder, expectedu32, expuremainder);

	resulti32 = mod_64x32(testi64a, testi32a);
	expectedi32 = testi64a % (INT64)testi32a;
	if (resulti32 != expectedi32)
		mame_printf_error("Error testing mod_64x32 (%08X%08X / %08X) = %08X (expected %08X)\n", (UINT32)(testi64a >> 32), (UINT32)testi64a, testi32a, resulti32, expectedi32);

	resultu32 = modu_64x32(testu64a, testu32a);
	expectedu32 = testu64a % (UINT64)testu32a;
	if (resultu32 != expectedu32)
		mame_printf_error("Error testing modu_64x32 (%08X%08X / %08X) = %08X (expected %08X)\n", (UINT32)(testu64a >> 32), (UINT32)testu64a, testu32a, resultu32, expectedu32);

	while ((INT64)testi32a * (INT64)0x7fffffff < ((INT32)testi64a << 3))
		testi64a /= 2;
	while ((UINT64)testu32a * (UINT64)0xffffffff < ((UINT32)testu64a << 3))
		testu64a /= 2;

	resulti32 = div_32x32_shift((INT32)testi64a, testi32a, 3);
	expectedi32 = ((INT64)(INT32)testi64a << 3) / (INT64)testi32a;
	if (resulti32 != expectedi32)
		mame_printf_error("Error testing div_32x32_shift (%08X << 3) / %08X = %08X (expected %08X)\n", (INT32)testi64a, testi32a, resulti32, expectedi32);

	resultu32 = divu_32x32_shift((UINT32)testu64a, testu32a, 3);
	expectedu32 = ((UINT64)(UINT32)testu64a << 3) / (UINT64)testu32a;
	if (resultu32 != expectedu32)
		mame_printf_error("Error testing divu_32x32_shift (%08X << 3) / %08X = %08X (expected %08X)\n", (UINT32)testu64a, testu32a, resultu32, expectedu32);

	if (fabs(recip_approx(100.0) - 0.01) > 0.0001)
		mame_printf_error("Error testing recip_approx\n");

	testi32a = (testi32a & 0x0000ffff) | 0x400000;
	if (count_leading_zeros(testi32a) != 9)
		mame_printf_error("Error testing count_leading_zeros\n");
	testi32a = (testi32a | 0xffff0000) & ~0x400000;
	if (count_leading_ones(testi32a) != 9)
		mame_printf_error("Error testing count_leading_ones\n");

	testi32b = testi32a;
	if (compare_exchange32(&testi32a, testi32b, 1000) != testi32b || testi32a != 1000)
		mame_printf_error("Error testing compare_exchange32\n");
#ifdef PTR64
	testi64b = testi64a;
	if (compare_exchange64(&testi64a, testi64b, 1000) != testi64b || testi64a != 1000)
		mame_printf_error("Error testing compare_exchange64\n");
#endif
	if (atomic_exchange32(&testi32a, testi32b) != 1000)
		mame_printf_error("Error testing atomic_exchange32\n");
	if (atomic_add32(&testi32a, 45) != testi32b + 45)
		mame_printf_error("Error testing atomic_add32\n");
	if (atomic_increment32(&testi32a) != testi32b + 46)
		mame_printf_error("Error testing atomic_increment32\n");
	if (atomic_decrement32(&testi32a) != testi32b + 45)
		mame_printf_error("Error testing atomic_decrement32\n");
}


//-------------------------------------------------
//  validate_driver - validate basic driver
//  information
//-------------------------------------------------

void validity_checker::validate_driver()
{
	// check for duplicate names
	astring tempstr;
	if (m_names_map.add(m_current_driver->name, m_current_driver, false) == TMERR_DUPLICATE)
	{
		const game_driver *match = m_names_map.find(m_current_driver->name);
		mame_printf_error("Driver name is a duplicate of %s(%s)\n", core_filename_extract_base(tempstr, match->source_file).cstr(), match->name);
	}

	// check for duplicate descriptions
	if (m_descriptions_map.add(m_current_driver->description, m_current_driver, false) == TMERR_DUPLICATE)
	{
		const game_driver *match = m_descriptions_map.find(m_current_driver->description);
		mame_printf_error("Driver description is a duplicate of %s(%s)\n", core_filename_extract_base(tempstr, match->source_file).cstr(), match->name);
	}

	// determine if we are a clone
	bool is_clone = (strcmp(m_current_driver->parent, "0") != 0);
	int clone_of = m_drivlist.clone(*m_current_driver);
	if (clone_of != -1 && (m_drivlist.driver(clone_of).flags & GAME_IS_BIOS_ROOT))
		is_clone = false;

	// if we have at least 100 drivers, validate the clone
	// (100 is arbitrary, but tries to avoid tiny.mak dependencies)
	if (driver_list::total() > 100 && clone_of == -1 && is_clone)
		mame_printf_error("Driver is a clone of nonexistant driver %s\n", m_current_driver->parent);

	// look for recursive cloning
	if (clone_of != -1 && &m_drivlist.driver(clone_of) == m_current_driver)
		mame_printf_error("Driver is a clone of itself\n");

	// look for clones that are too deep
	if (clone_of != -1 && (clone_of = m_drivlist.non_bios_clone(clone_of)) != -1)
		mame_printf_error("Driver is a clone of a clone\n");

	// make sure the driver name is not too long
	if (!is_clone && strlen(m_current_driver->name) > 8)
		mame_printf_error("Parent driver name must be 8 characters or less\n");
	if (is_clone && strlen(m_current_driver->name) > 16)
		mame_printf_error("Clone driver name must be 16 characters or less\n");

	// make sure the year is only digits, '?' or '+'
	for (const char *s = m_current_driver->year; *s != 0; s++)
		if (!isdigit((UINT8)*s) && *s != '?' && *s != '+')
		{
			mame_printf_error("Driver has an invalid year '%s'\n", m_current_driver->year);
			break;
		}

	// normalize driver->compatible_with
	const char *compatible_with = m_current_driver->compatible_with;
	if (compatible_with != NULL && strcmp(compatible_with, "0") == 0)
		compatible_with = NULL;

	// check for this driver being compatible with a non-existant driver
	if (compatible_with != NULL && m_drivlist.find(m_current_driver->compatible_with) == -1)
		mame_printf_error("Driver is listed as compatible with nonexistant driver %s\n", m_current_driver->compatible_with);

	// check for clone_of and compatible_with being specified at the same time
	if (m_drivlist.clone(*m_current_driver) != -1 && compatible_with != NULL)
		mame_printf_error("Driver cannot be both a clone and listed as compatible with another system\n");

	// find any recursive dependencies on the current driver
	for (int other_drv = m_drivlist.compatible_with(*m_current_driver); other_drv != -1; other_drv = m_drivlist.compatible_with(other_drv))
		if (m_current_driver == &m_drivlist.driver(other_drv))
		{
			mame_printf_error("Driver is recursively compatible with itself\n");
			break;
		}

	// make sure sound-less drivers are flagged
	sound_interface_iterator iter(m_current_config->root_device());
	if ((m_current_driver->flags & GAME_IS_BIOS_ROOT) == 0 && iter.first() == NULL && (m_current_driver->flags & GAME_NO_SOUND) == 0 && (m_current_driver->flags & GAME_NO_SOUND_HW) == 0)
		mame_printf_error("Driver is missing GAME_NO_SOUND flag\n");
}


//-------------------------------------------------
//  validate_roms - validate ROM definitions
//-------------------------------------------------

void validity_checker::validate_roms()
{
	// iterate, starting with the driver's ROMs and continuing with device ROMs
	for (const rom_source *source = rom_first_source(*m_current_config); source != NULL; source = rom_next_source(*source))
	{
		// for non-root devices, track the current device
		m_current_device = (source == &m_current_config->root_device()) ? NULL : source;

		// scan the ROM entries for this device
		const char *last_region_name = "???";
		const char *last_name = "???";
		UINT32 current_length = 0;
		int items_since_region = 1;
		int last_bios = 0;
		int total_files = 0;
		for (const rom_entry *romp = rom_first_region(*source); !ROMENTRY_ISEND(romp); romp++)
		{
			// if this is a region, make sure it's valid, and record the length
			if (ROMENTRY_ISREGION(romp))
			{
				// if we haven't seen any items since the last region, print a warning
				if (items_since_region == 0)
					mame_printf_warning("Empty ROM region '%s' (warning)\n", last_region_name);

				// reset our region tracking states
				const char *basetag = ROMREGION_GETTAG(romp);
				items_since_region = (ROMREGION_ISERASE(romp) || ROMREGION_ISDISKDATA(romp)) ? 1 : 0;
				last_region_name = basetag;

				// check for a valid tag
				if (basetag == NULL)
				{
					mame_printf_error("ROM_REGION tag with NULL name\n");
					continue;
				}

				// validate the base tag
				validate_tag(basetag);

				// generate the full tag
				astring fulltag;
				rom_region_name(fulltag, m_current_driver, source, romp);

				// attempt to add it to the map, reporting duplicates as errors
				current_length = ROMREGION_GETLENGTH(romp);
				if (m_region_map.add(fulltag, current_length, false) == TMERR_DUPLICATE)
					mame_printf_error("Multiple ROM_REGIONs with the same tag '%s' defined\n", fulltag.cstr());
			}

			// If this is a system bios, make sure it is using the next available bios number
			else if (ROMENTRY_ISSYSTEM_BIOS(romp))
			{
				int bios_flags = ROM_GETBIOSFLAGS(romp);
				if (bios_flags != last_bios + 1)
					mame_printf_error("Non-sequential bios %s (specified as %d, expected to be %d)\n", ROM_GETNAME(romp), bios_flags, last_bios + 1);
				last_bios = bios_flags;
			}

			// if this is a file, make sure it is properly formatted
			else if (ROMENTRY_ISFILE(romp))
			{
				// track the last filename we found
				last_name = ROM_GETNAME(romp);
				total_files++;

				// make sure it's all lowercase
				for (const char *s = last_name; *s != 0; s++)
					if (tolower((UINT8)*s) != *s)
					{
						mame_printf_error("ROM name '%s' contains upper case characters\n", last_name);
						break;
					}

				// make sure the hash is valid
				hash_collection hashes;
				if (!hashes.from_internal_string(ROM_GETHASHDATA(romp)))
					mame_printf_error("ROM '%s' has an invalid hash string '%s'\n", last_name, ROM_GETHASHDATA(romp));
			}

			// for any non-region ending entries, make sure they don't extend past the end
			if (!ROMENTRY_ISREGIONEND(romp) && current_length > 0)
			{
				items_since_region++;
				if (ROM_GETOFFSET(romp) + ROM_GETLENGTH(romp) > current_length)
					mame_printf_error("ROM '%s' extends past the defined memory region\n", last_name);
			}
		}

		// final check for empty regions
		if (items_since_region == 0)
			mame_printf_warning("Empty ROM region '%s' (warning)\n", last_region_name);

		// make sure each device is listed in the device list if it loads ROMs
		if (m_current_device != NULL && total_files > 0)
		{
			// scan the list of devices for this device type
			bool found = false;
			for (int i = 0; i < m_device_count; i++)
				if (m_current_device->type() == *s_devices_sorted[i])
				{
					found = true;
					break;
				}

			// if not found, report an error
			if (!found)
				mame_printf_error("Device %s is not listed in device list (mame_dev.lst / mess_dev.lst)\n", m_current_device->shortname());
		}

		// reset the current device
		m_current_device = NULL;
	}
}


//-------------------------------------------------
//  validate_display - validate display
//  configurations
//-------------------------------------------------

void validity_checker::validate_display()
{
	// iterate over screen devices looking for paletted screens
	screen_device_iterator iter(m_current_config->root_device());
	bool palette_modes = false;
	for (const screen_device *scrconfig = iter.first(); scrconfig != NULL; scrconfig = iter.next())
		if (scrconfig->format() == BITMAP_FORMAT_IND16)
			palette_modes = true;

	// check for empty palette
	if (palette_modes && m_current_config->m_total_colors == 0)
		mame_printf_error("Driver has zero palette entries but uses a palette-based bitmap format\n");
}


//-------------------------------------------------
//  validate_gfx - validate graphics decoding
//  configuration
//-------------------------------------------------

void validity_checker::validate_gfx()
{
	// bail if no gfx
	if (!m_current_config->m_gfxdecodeinfo)
		return;

	// iterate over graphics decoding entries
	for (int gfxnum = 0; gfxnum < MAX_GFX_ELEMENTS && m_current_config->m_gfxdecodeinfo[gfxnum].gfxlayout != NULL; gfxnum++)
	{
		const gfx_decode_entry &gfx = m_current_config->m_gfxdecodeinfo[gfxnum];
		const gfx_layout &layout = *gfx.gfxlayout;

		// make sure the region exists
		const char *region = gfx.memory_region;
		if (region != NULL)
		{
			// resolve the region
			astring gfxregion;
			m_current_config->root_device().subtag(gfxregion, region);

			// loop over gfx regions
			UINT32 region_length = m_region_map.find(gfxregion);
			if (region_length == 0)
				mame_printf_error("gfx[%d] references non-existent region '%s'\n", gfxnum, region);

			// if we have a valid region, and we're not using auto-sizing, check the decode against the region length
			else if (!IS_FRAC(layout.total))
			{
				// determine which plane is at the largest offset
				int start = 0;
				for (int plane = 0; plane < layout.planes; plane++)
					if (layout.planeoffset[plane] > start)
						start = layout.planeoffset[plane];
				start &= ~(layout.charincrement - 1);

				// determine the total length based on this info
				int len = layout.total * layout.charincrement;

				// do we have enough space in the region to cover the whole decode?
				int avail = region_length - (gfx.start & ~(layout.charincrement / 8 - 1));

				// if not, this is an error
				if ((start + len) / 8 > avail)
					mame_printf_error("gfx[%d] extends past allocated memory of region '%s'\n", gfxnum, region);
			}
		}

		int xscale = (m_current_config->m_gfxdecodeinfo[gfxnum].xscale == 0) ? 1 : m_current_config->m_gfxdecodeinfo[gfxnum].xscale;
		int yscale = (m_current_config->m_gfxdecodeinfo[gfxnum].yscale == 0) ? 1 : m_current_config->m_gfxdecodeinfo[gfxnum].yscale;

		// verify raw decode, which can only be full-region and have no scaling
		if (layout.planeoffset[0] == GFX_RAW)
		{
			if (layout.total != RGN_FRAC(1,1))
				mame_printf_error("gfx[%d] with unsupported layout total\n", gfxnum);
			if (xscale != 1 || yscale != 1)
				mame_printf_error("gfx[%d] with unsupported xscale/yscale\n", gfxnum);
		}

		// verify traditional decode doesn't have too many planes or is not too large
		else
		{
			if (layout.planes > MAX_GFX_PLANES)
				mame_printf_error("gfx[%d] with invalid planes\n", gfxnum);
			if (xscale * layout.width > MAX_ABS_GFX_SIZE || yscale * layout.height > MAX_ABS_GFX_SIZE)
				mame_printf_error("gfx[%d] with invalid xscale/yscale\n", gfxnum);
		}
	}
}


//-------------------------------------------------
//  validate_analog_input_field - validate an
//  analog input field
//-------------------------------------------------

void validity_checker::validate_analog_input_field(input_field_config &field)
{
	// analog ports must have a valid sensitivity
	if (field.sensitivity == 0)
		mame_printf_error("Analog port with zero sensitivity\n");

	// check that the default falls in the bitmask range
	if (field.defvalue & ~field.mask)
		mame_printf_error("Analog port with a default value (%X) out of the bitmask range (%X)\n", field.defvalue, field.mask);

	// tests for positional devices
	if (field.type == IPT_POSITIONAL || field.type == IPT_POSITIONAL_V)
	{
		int shift;
		for (shift = 0; shift <= 31 && (~field.mask & (1 << shift)) != 0; shift++) ;

		// convert the positional max value to be in the bitmask for testing
		INT32 analog_max = field.max;
		analog_max = (analog_max - 1) << shift;

		// positional port size must fit in bits used
		if ((field.mask >> shift) + 1 < field.max)
			mame_printf_error("Analog port with a positional port size bigger then the mask size\n");
	}

	// tests for absolute devices
	else if (field.type >= __ipt_analog_absolute_start && field.type <= __ipt_analog_absolute_end)
	{
		// adjust for signed values
		INT32 default_value = field.defvalue;
		INT32 analog_min = field.min;
		INT32 analog_max = field.max;
		if (analog_min > analog_max)
		{
			analog_min = -analog_min;
			if (default_value > analog_max)
				default_value = -default_value;
		}

		// check that the default falls in the MINMAX range
		if (default_value < analog_min || default_value > analog_max)
			mame_printf_error("Analog port with a default value (%X) out of PORT_MINMAX range (%X-%X)\n", field.defvalue, field.min, field.max);

		// check that the MINMAX falls in the bitmask range
		// we use the unadjusted min for testing
		if (field.min & ~field.mask || analog_max & ~field.mask)
			mame_printf_error("Analog port with a PORT_MINMAX (%X-%X) value out of the bitmask range (%X)\n", field.min, field.max, field.mask);

		// absolute analog ports do not use PORT_RESET
		if (field.flags & ANALOG_FLAG_RESET)
			mame_printf_error("Absolute analog port using PORT_RESET\n");

		// absolute analog ports do not use PORT_WRAPS
		if (field.flags & ANALOG_FLAG_WRAPS)
			mame_printf_error("Absolute analog port using PORT_WRAPS\n");
	}

	// tests for non IPT_POSITIONAL relative devices
	else
	{
		// relative devices do not use PORT_MINMAX
		if (field.min != 0 || field.max != field.mask)
			mame_printf_error("Relative port using PORT_MINMAX\n");

		// relative devices do not use a default value
		// the counter is at 0 on power up
		if (field.defvalue != 0)
			mame_printf_error("Relative port using non-0 default value\n");

		// relative analog ports do not use PORT_WRAPS
		if (field.flags & ANALOG_FLAG_WRAPS)
			mame_printf_error("Absolute analog port using PORT_WRAPS\n");
	}
}


//-------------------------------------------------
//  validate_dip_settings - validate a DIP switch
//  setting
//-------------------------------------------------

void validity_checker::validate_dip_settings(input_field_config &field)
{
	const char *demo_sounds = ioport_string_from_index(INPUT_STRING_Demo_Sounds);
	const char *flipscreen = ioport_string_from_index(INPUT_STRING_Flip_Screen);
	UINT8 coin_list[__input_string_coinage_end + 1 - __input_string_coinage_start] = { 0 };
	bool coin_error = false;

	// iterate through the settings
	for (const input_setting_config *setting = field.settinglist().first(); setting != NULL; setting = setting->next())
	{
		// note any coinage strings
		int strindex = get_defstr_index(setting->name);
		if (strindex >= __input_string_coinage_start && strindex <= __input_string_coinage_end)
			coin_list[strindex - __input_string_coinage_start] = 1;

		// make sure demo sounds default to on
		if (field.name == demo_sounds && strindex == INPUT_STRING_On && field.defvalue != setting->value)
			mame_printf_error("Demo Sounds must default to On\n");

		// check for bad demo sounds options
		if (field.name == demo_sounds && (strindex == INPUT_STRING_Yes || strindex == INPUT_STRING_No))
			mame_printf_error("Demo Sounds option must be Off/On, not %s\n", setting->name);

		// check for bad flip screen options
		if (field.name == flipscreen && (strindex == INPUT_STRING_Yes || strindex == INPUT_STRING_No))
			mame_printf_error("Flip Screen option must be Off/On, not %s\n", setting->name);

		// if we have a neighbor, compare ourselves to him
		if (setting->next() != NULL)
		{
			// check for inverted off/on dispswitch order
			int next_strindex = get_defstr_index(setting->next()->name, true);
			if (strindex == INPUT_STRING_On && next_strindex == INPUT_STRING_Off)
				mame_printf_error("%s option must have Off/On options in the order: Off, On\n", field.name);

			// check for inverted yes/no dispswitch order
			else if (strindex == INPUT_STRING_Yes && next_strindex == INPUT_STRING_No)
				mame_printf_error("%s option must have Yes/No options in the order: No, Yes\n", field.name);

			// check for inverted upright/cocktail dispswitch order
			else if (strindex == INPUT_STRING_Cocktail && next_strindex == INPUT_STRING_Upright)
				mame_printf_error("%s option must have Upright/Cocktail options in the order: Upright, Cocktail\n", field.name);

			// check for proper coin ordering
			else if (strindex >= __input_string_coinage_start && strindex <= __input_string_coinage_end && next_strindex >= __input_string_coinage_start && next_strindex <= __input_string_coinage_end &&
					 strindex >= next_strindex && memcmp(&setting->condition, &setting->next()->condition, sizeof(setting->condition)) == 0)
			{
				mame_printf_error("%s option has unsorted coinage %s > %s\n", field.name, setting->name, setting->next()->name);
				coin_error = true;
			}
		}
	}

	// if we have a coin error, demonstrate the correct way
	if (coin_error)
	{
		output_via_delegate(m_saved_error_output, "   Note proper coin sort order should be:\n");
		for (int entry = 0; entry < ARRAY_LENGTH(coin_list); entry++)
			if (coin_list[entry])
				output_via_delegate(m_saved_error_output, "      %s\n", ioport_string_from_index(__input_string_coinage_start + entry));
	}
}


//-------------------------------------------------
//  validate_condition - validate a condition
//  stored within an ioport field or setting
//-------------------------------------------------

void validity_checker::validate_condition(input_condition &condition, device_t &device, int_map &port_map)
{
	// resolve the tag
	astring porttag;
	device.subtag(porttag, condition.tag);

	// then find a matching port
	if (port_map.find(porttag) == 0)
		mame_printf_error("Condition referencing non-existent ioport tag '%s'\n", condition.tag);
}


//-------------------------------------------------
//  validate_inputs - validate input configuration
//-------------------------------------------------

void validity_checker::validate_inputs()
{
	int_map port_map;

	// iterate over devices
	device_iterator iter(m_current_config->root_device());
	for (device_t *device = iter.first(); device != NULL; device = iter.next())
	{
		// see if this device has ports; if not continue
		if (device->input_ports() == NULL)
			continue;

		// for non-root devices, track the current device
		m_current_device = (device == &m_current_config->root_device()) ? NULL : device;

		// allocate the input ports
		ioport_list portlist;
		astring errorbuf;
		input_port_list_init(*device, portlist, errorbuf);

		// report any errors during construction
		if (errorbuf)
			mame_printf_error("I/O port error during construction:\n%s\n", errorbuf.cstr());

		// do a first pass over ports to add their names and find duplicates
		for (input_port_config *port = portlist.first(); port != NULL; port = port->next())
			if (port_map.add(port->tag(), 1, false) == TMERR_DUPLICATE)
				mame_printf_error("Multiple I/O ports with the same tag '%s' defined\n", port->tag());

		// iterate over ports
		for (input_port_config *port = portlist.first(); port != NULL; port = port->next())
		{
			m_current_ioport = port->tag();

			// iterate through the fields on this port
			for (input_field_config *field = port->fieldlist().first(); field != NULL; field = field->next())
			{
				// verify analog inputs
				if (input_type_is_analog(field->type))
					validate_analog_input_field(*field);

				// look for invalid (0) types which should be mapped to IPT_OTHER
				if (field->type == IPT_INVALID)
					mame_printf_error("Field has an invalid type (0); use IPT_OTHER instead\n");

				// verify dip switches
				if (field->type == IPT_DIPSWITCH)
				{
					// dip switch fields must have a name
					if (field->name == NULL)
						mame_printf_error("DIP switch has a NULL name\n");

					// verify the settings list
					validate_dip_settings(*field);
				}

				// verify names
				if (field->name != NULL)
				{
					// check for empty string
					if (field->name[0] == 0)
						mame_printf_error("Field name is an empty string\n");

					// check for trailing spaces
					if (field->name[0] != 0 && field->name[strlen(field->name) - 1] == ' ')
						mame_printf_error("Field '%s' has trailing spaces\n", field->name);

					// check for invalid UTF-8
					if (!utf8_is_valid_string(field->name))
						mame_printf_error("Field '%s' has invalid characters\n", field->name);

					// look up the string and print an error if default strings are not used
					/*strindex =get_defstr_index(defstr_map, field->name, driver, &error);*/
				}

				// verify conditions on the field
				if (field->condition.tag != NULL)
					validate_condition(field->condition, *device, port_map);

				// verify conditions on the settings
				for (input_setting_config *setting = field->settinglist().first(); setting != NULL; setting = setting->next())
					if (setting->condition.tag != NULL)
						validate_condition(setting->condition, *device, port_map);
			}

			// done with this port
			m_current_ioport = NULL;
		}

		// done with this device
		m_current_device = NULL;
	}
}


//-------------------------------------------------
//  validate_devices - run per-device validity
//  checks
//-------------------------------------------------

void validity_checker::validate_devices()
{
	int_map device_map;

	// iterate over devices
	device_iterator iter(m_current_config->root_device());
	for (const device_t *device = iter.first(); device != NULL; device = iter.next())
	{
		// for non-root devices, track the current device
		m_current_device = (device == &m_current_config->root_device()) ? NULL : device;

		// validate the device tag
		validate_tag(device->basetag());

		// look for duplicates
		if (device_map.add(device->tag(), 0, false) == TMERR_DUPLICATE)
			mame_printf_error("Multiple devices with the same tag '%s' defined\n", device->tag());

		// if we have a ROM region, we must have a shortname
		if (device->rom_region() != NULL && strcmp(device->shortname(), "") == 0)
			mame_printf_error("Device %s has ROM definition but does not have short name defined\n", device->name());

		// check for device-specific validity check
		device->validity_check(*this);

		// done with this device
		m_current_device = NULL;
	}
}


//-------------------------------------------------
//  validate_slots - run per-slot validity
//  checks
//-------------------------------------------------

void validity_checker::validate_slots()
{
	// iterate over slots
	slot_interface_iterator iter(m_current_config->root_device());
	for (const device_slot_interface *slot = iter.first(); slot != NULL; slot = iter.next())
	{
		// iterate over interfaces
		const slot_interface *intf = slot->get_slot_interfaces();
		for (int j = 0; intf[j].name != NULL; j++)
		{
			// instantiate the device
			device_t *dev = (*intf[j].devtype)(*m_current_config, "dummy", &m_current_config->root_device(), 0);
			dev->config_complete();

			// if a ROM region is present
			if (dev->rom_region() != NULL)
			{
				bool has_romfiles = false;
				for (const rom_entry *romp = rom_first_region(*dev); !ROMENTRY_ISEND(romp); romp++)
					if (ROMENTRY_ISFILE(romp))
					{
						has_romfiles = true;
						break;
					}

				if (has_romfiles)
				{
					// scan the list of devices for this device type
					bool found = false;
					for (int i = 0; i < m_device_count; i++)
						if (dev->type() == *s_devices_sorted[i])
						{
							found = true;
							break;
						}

					// if not found, report an error
					if (!found)
						mame_printf_error("Device %s in slot %s is not listed in device list (mame_dev.lst / mess_dev.lst)\n", dev->shortname(), intf[j].name);
				}
			}
			global_free(dev);
		}
	}
}


//-------------------------------------------------
//  build_output_prefix - create a prefix
//  indicating the current source file, driver,
//  and device
//-------------------------------------------------

void validity_checker::build_output_prefix(astring &string)
{
	// start empty
	string.reset();

	// if we have a current device, indicate that
	if (m_current_device != NULL)
		string.cat(m_current_device->name()).cat(" device '").cat(m_current_device->tag()).cat("': ");

	// if we have a current port, indicate that as well
	if (m_current_ioport != NULL)
		string.cat("ioport '").cat(m_current_ioport).cat("': ");
}


//-------------------------------------------------
//  error_output - error message output override
//-------------------------------------------------

void validity_checker::error_output(const char *format, va_list argptr)
{
	// count the error
	m_errors++;

	// output the source(driver) device 'tag'
	astring output;
	build_output_prefix(output);

	// generate the string
	output.catvprintf(format, argptr);
	m_error_text.cat(output);
}


//-------------------------------------------------
//  warning_output - warning message output
//  override
//-------------------------------------------------

void validity_checker::warning_output(const char *format, va_list argptr)
{
	// count the error
	m_warnings++;

	// output the source(driver) device 'tag'
	astring output;
	build_output_prefix(output);

	// generate the string and output to the original target
	output.catvprintf(format, argptr);
	m_warning_text.cat(output);
}


//-------------------------------------------------
//  output_via_delegate - helper to output a
//  message via a varargs string, so the argptr
//  can be forwarded onto the given delegate
//-------------------------------------------------

void validity_checker::output_via_delegate(output_delegate &delegate, const char *format, ...)
{
	va_list argptr;

	// call through to the delegate with the proper parameters
	va_start(argptr, format);
	delegate(format, argptr);
	va_end(argptr);
}
