// license:BSD-3-Clause
// copyright-holders:Aaron Giles
/***************************************************************************
devfind.cpp
Device finding template helpers.
***************************************************************************/
#include "emu.h"
#include "romload.h"
#include "validity.h"
//**************************************************************************
// BASE FINDER CLASS
//**************************************************************************
constexpr char finder_base::DUMMY_TAG[];
//-------------------------------------------------
// finder_base - constructor
//-------------------------------------------------
finder_base::finder_base(device_t &base, char const *tag)
: m_next(base.register_auto_finder(*this))
, m_base(base)
, m_tag(tag)
, m_resolved(false)
{
}
//-------------------------------------------------
// ~finder_base - destructor
//-------------------------------------------------
finder_base::~finder_base()
{
}
//-------------------------------------------------
// set_tag - set tag
//-------------------------------------------------
void finder_base::set_tag(char const *tag)
{
assert(!m_resolved);
m_base = m_base.get().mconfig().current_device();
m_tag = tag;
}
//-------------------------------------------------
// find_memregion - find memory region
//-------------------------------------------------
void *finder_base::find_memregion(u8 width, size_t &length, bool required) const
{
// look up the region and return nullptr if not found
memory_region *const region(m_base.get().memregion(m_tag));
if (!region)
{
length = 0;
return nullptr;
}
// check the width and warn if not correct
if (region->bytewidth() != width)
{
if (required)
osd_printf_warning("Region '%s' found but is width %d, not %d as requested\n", m_tag, region->bitwidth(), width * 8);
length = 0;
return nullptr;
}
// return results
length = region->bytes() / width;
return region->base();
}
//-------------------------------------------------
// validate_memregion - find memory region
//-------------------------------------------------
bool finder_base::validate_memregion(bool required) const
{
// make sure we can resolve the full path to the region
size_t bytes_found = 0;
std::string const region_fulltag(m_base.get().subtag(m_tag));
// look for the region
for (device_t const &dev : device_enumerator(m_base.get().mconfig().root_device()))
{
for (romload::region const ®ion : romload::entries(dev.rom_region()).get_regions())
{
if (dev.subtag(region.get_tag()) == region_fulltag)
{
bytes_found = region.get_length();
break;
}
}
if (bytes_found != 0)
break;
}
return report_missing(bytes_found != 0, "memory region", required);
}
//-------------------------------------------------
// find_memshare - find memory share
//-------------------------------------------------
void *finder_base::find_memshare(u8 width, size_t &bytes, bool required) const
{
// look up the share and return nullptr if not found
memory_share *const share(m_base.get().memshare(m_tag));
if (!share)
return nullptr;
// check the width and warn if not correct
if (width != 0 && share->bitwidth() != width)
{
osd_printf_warning("Shared ptr '%s' found but is width %d, not %d as requested\n", m_tag, share->bitwidth(), width);
return nullptr;
}
// return results
bytes = share->bytes();
return share->ptr();
}
//-------------------------------------------------
// find_addrspace - find address space
//-------------------------------------------------
address_space *finder_base::find_addrspace(int spacenum, u8 width, bool required) const
{
// look up the device and return nullptr if not found
device_t *const device(m_base.get().subdevice(m_tag));
if (device == nullptr)
return nullptr;
// check for memory interface and the specified space number
const device_memory_interface *memory;
if (!device->interface(memory))
{
if (required)
osd_printf_warning("Device '%s' found but lacks memory interface\n", m_tag);
return nullptr;
}
if (!memory->has_space(spacenum))
{
if (required)
osd_printf_warning("Device '%s' found but lacks address space #%d\n", m_tag, spacenum);
return nullptr;
}
// check data width
address_space &space(memory->space(spacenum));
if (width != 0 && width != space.data_width())
{
osd_printf_warning("Device '%s' found but address space #%d has the wrong data width (expected %d, found %d)\n", m_tag, spacenum, width, space.data_width());
return nullptr;
}
// return result
return &space;
}
//-------------------------------------------------
// validate_addrspace - find address space
//-------------------------------------------------
bool finder_base::validate_addrspace(int spacenum, u8 width, bool required) const
{
// look up the device and return false if not found
device_t *const device(m_base.get().subdevice(m_tag));
if (!device)
return report_missing(false, "address space", required);
// check for memory interface and a configuration for the designated space
const device_memory_interface *memory = nullptr;
const address_space_config *config = nullptr;
if (device->interface(memory))
{
config = memory->space_config(spacenum);
if (required)
{
if (config == nullptr)
osd_printf_warning("Device '%s' found but lacks address space #%d\n", m_tag, spacenum);
else if (width != 0 && width != config->data_width())
osd_printf_warning("Device '%s' found but space #%d has the wrong data width (expected %d, found %d)\n", m_tag, spacenum, width, config->data_width());
}
}
else if (required)
osd_printf_warning("Device '%s' found but lacks memory interface\n", m_tag);
// report result
return report_missing(config != nullptr && (width == 0 || width == config->data_width()), "address space", required);
}
//-------------------------------------------------
// report_missing - report missing objects and
// return true if it's ok
//-------------------------------------------------
bool finder_base::report_missing(bool found, const char *objname, bool required) const
{
if (required && (DUMMY_TAG == m_tag))
{
osd_printf_error("Tag not defined for required %s\n", objname);
return false;
}
else if (found)
{
// just pass through in the found case
return true;
}
else
{
// otherwise, report
std::string const region_fulltag(m_base.get().subtag(m_tag));
if (required)
osd_printf_error("Required %s '%s' not found\n", objname, region_fulltag);
else if (DUMMY_TAG != m_tag)
osd_printf_verbose("Optional %s '%s' not found\n", objname, region_fulltag);
return !required;
}
}
//**************************************************************************
// MEMORY REGION FINDER
//**************************************************************************
template <bool Required>
memory_region_finder<Required>::memory_region_finder(device_t &base, char const *tag)
: object_finder_base<memory_region, Required>(base, tag)
{
}
template <bool Required>
bool memory_region_finder<Required>::findit(validity_checker *valid)
{
if (valid)
return this->validate_memregion(Required);
assert(!this->m_resolved);
this->m_resolved = true;
this->m_target = this->m_base.get().memregion(this->m_tag);
return this->report_missing("memory region");
}
//**************************************************************************
// MEMORY BANK FINDER
//**************************************************************************
template <bool Required>
memory_bank_finder<Required>::memory_bank_finder(device_t &base, char const *tag)
: object_finder_base<memory_bank, Required>(base, tag)
{
}
template <bool Required>
bool memory_bank_finder<Required>::findit(validity_checker *valid)
{
if (valid)
return true;
assert(!this->m_resolved);
this->m_resolved = true;
this->m_target = this->m_base.get().membank(this->m_tag);
return this->report_missing("memory bank");
}
//**************************************************************************
// I/O PORT FINDER
//**************************************************************************
template <bool Required>
ioport_finder<Required>::ioport_finder(device_t &base, char const *tag)
: object_finder_base<ioport_port, Required>(base, tag)
{
}
template <bool Required>
bool ioport_finder<Required>::findit(validity_checker *valid)
{
if (valid)
return finder_base::report_missing(!valid->ioport_missing(this->m_base.get().subtag(this->m_tag).c_str()), "I/O port", Required);
assert(!this->m_resolved);
this->m_resolved = true;
this->m_target = this->m_base.get().ioport(this->m_tag);
return this->report_missing("I/O port");
}
//**************************************************************************
// ADDRESS SPACE FINDER
//**************************************************************************
template <bool Required>
address_space_finder<Required>::address_space_finder(device_t &base, char const *tag, int spacenum, u8 width)
: object_finder_base<address_space, Required>(base, tag)
, m_spacenum(spacenum)
, m_data_width(width)
{
}
template <bool Required>
bool address_space_finder<Required>::findit(validity_checker *valid)
{
if (valid)
return this->validate_addrspace(this->m_spacenum, this->m_data_width, Required);
assert(!this->m_resolved);
this->m_resolved = true;
this->m_target = this->find_addrspace(this->m_spacenum, this->m_data_width, Required);
return this->report_missing("address space");
}
//**************************************************************************
// MEMORY BANK CREATOR
//**************************************************************************
bool memory_bank_creator::findit(validity_checker *valid)
{
if (valid)
return true;
device_t &dev = m_base.get();
memory_manager &manager = dev.machine().memory();
std::string const tag = dev.subtag(m_tag);
memory_bank *const bank = manager.bank_find(tag);
m_target = bank ? bank : manager.bank_alloc(dev, tag);
return true;
}
void memory_bank_creator::end_configuration()
{
m_target = nullptr;
}
//**************************************************************************
// MEMORY SHARE CREATOR
//**************************************************************************
template <typename PointerType>
memory_share_creator<PointerType>::memory_share_creator(device_t &base, char const *tag, size_t bytes, endianness_t endianness)
: finder_base(base, tag)
, m_width(sizeof(PointerType) * 8)
, m_bytes(bytes)
, m_endianness(endianness)
{
}
template <typename PointerType>
bool memory_share_creator<PointerType>::findit(validity_checker *valid)
{
if (valid)
return true;
device_t &dev = m_base.get();
memory_manager &manager = dev.machine().memory();
std::string const tag = dev.subtag(m_tag);
memory_share *const share = manager.share_find(tag);
if (share)
{
std::string const result = share->compare(m_width, m_bytes, m_endianness);
if (!result.empty())
{
osd_printf_error("%s\n", result);
return false;
}
m_target = share;
}
else
{
m_target = manager.share_alloc(dev, tag, m_width, m_bytes, m_endianness);
}
return true;
}
template <typename PointerType>
void memory_share_creator<PointerType>::end_configuration()
{
m_target = nullptr;
}
//**************************************************************************
// EXPLICIT TEMPLATE INSTANTIATIONS
//**************************************************************************
template class object_finder_base<memory_region, false>;
template class object_finder_base<memory_region, true>;
template class object_finder_base<memory_bank, false>;
template class object_finder_base<memory_bank, true>;
template class object_finder_base<ioport_port, false>;
template class object_finder_base<ioport_port, true>;
template class object_finder_base<address_space, false>;
template class object_finder_base<address_space, true>;
template class object_finder_base<u8, false>;
template class object_finder_base<u8, true>;
template class object_finder_base<u16, false>;
template class object_finder_base<u16, true>;
template class object_finder_base<u32, false>;
template class object_finder_base<u32, true>;
template class object_finder_base<u64, false>;
template class object_finder_base<u64, true>;
template class object_finder_base<s8, false>;
template class object_finder_base<s8, true>;
template class object_finder_base<s16, false>;
template class object_finder_base<s16, true>;
template class object_finder_base<s32, false>;
template class object_finder_base<s32, true>;
template class object_finder_base<s64, false>;
template class object_finder_base<s64, true>;
template class memory_region_finder<false>;
template class memory_region_finder<true>;
template class memory_bank_finder<false>;
template class memory_bank_finder<true>;
template class ioport_finder<false>;
template class ioport_finder<true>;
template class address_space_finder<false>;
template class address_space_finder<true>;
template class region_ptr_finder<u8, false>;
template class region_ptr_finder<u8, true>;
template class region_ptr_finder<u16, false>;
template class region_ptr_finder<u16, true>;
template class region_ptr_finder<u32, false>;
template class region_ptr_finder<u32, true>;
template class region_ptr_finder<u64, false>;
template class region_ptr_finder<u64, true>;
template class region_ptr_finder<s8, false>;
template class region_ptr_finder<s8, true>;
template class region_ptr_finder<s16, false>;
template class region_ptr_finder<s16, true>;
template class region_ptr_finder<s32, false>;
template class region_ptr_finder<s32, true>;
template class region_ptr_finder<s64, false>;
template class region_ptr_finder<s64, true>;
template class shared_ptr_finder<u8, false>;
template class shared_ptr_finder<u8, true>;
template class shared_ptr_finder<u16, false>;
template class shared_ptr_finder<u16, true>;
template class shared_ptr_finder<u32, false>;
template class shared_ptr_finder<u32, true>;
template class shared_ptr_finder<u64, false>;
template class shared_ptr_finder<u64, true>;
template class shared_ptr_finder<s8, false>;
template class shared_ptr_finder<s8, true>;
template class shared_ptr_finder<s16, false>;
template class shared_ptr_finder<s16, true>;
template class shared_ptr_finder<s32, false>;
template class shared_ptr_finder<s32, true>;
template class shared_ptr_finder<s64, false>;
template class shared_ptr_finder<s64, true>;
template class memory_share_creator<u8>;
template class memory_share_creator<u16>;
template class memory_share_creator<u32>;
template class memory_share_creator<u64>;
template class memory_share_creator<s8>;
template class memory_share_creator<s16>;
template class memory_share_creator<s32>;
template class memory_share_creator<s64>;