summaryrefslogblamecommitdiffstatshomepage
path: root/src/emu/drivenum.cpp
blob: b3e9ce93d6298f3fce7003bf31b57f2dbef17ad7 (plain) (tree)
1
2
3
4
5
6
7
8
9
10

                                

                                                                            
                
 

                               

                                                                            
                
                     
                         
 



                  


                                                                            
 


                                                   
 


                          
 
 


                                                   
 


                                       
                  

                          
                                   




                                                                                                                           
 

 
                                                   



                                                   
                                                                     

                                                                                      
                                                                                


                                         
                                                                                   



                                                   


                                                   
 



                                                                        
 



                                              
                                                                               
 


                                                    
 

                                                         
                 


                                       
                 
         
 






                                                             
 
                    


 
 


                                                                            
 




                                                          




                                      

                      


 
                                                                              
                                    



                       
 
                                                                                     
                                    
 
                       


 


                                                   
 
                                       
 
                                         
 
 
 



                                                   
 
                                                                                                               
 
                                       
 
                                             




                                                                                             
 
 
 



                                                   
 
                                                               


                          
 
                                                     
                                                                    
                                                                         



                                       
 
 



                                                   
 
                                                                


                          
 
                                                     
                                                                    




                                                       
 
 
                                                   




                                                   
                                                              
                                             
 
                                          
                                  



                                                   





                                                   
                          
 
                             
                                                              
                                                                                                  
 
                                            
                                                                
 
 
 



                                                   
 

                                       
                          
 
                             
                                                              
                                                                                                 
 
                                            
                                                                


 



                                                   
 
                                                                                                     
 
           
 
                                          
                                  
         

                                     
 
                                            
                                                            




                                                                    
 
                          
                                                                                
                 




                                                              
                 
 


                                                                                  
         
            
         

                                                             
 

                                                                    
                 


                                                 
 



                                                                    
                                              
                         
                                                                                          
                                                                                                                   

                                                                                                 
 

                                                                                         
                                 











                                                                                                   
                                 

                         
         
 

 


                                                   
                      
                                                   
 
                                               
 
                                   










                                                                                                                            
 
// license:BSD-3-Clause
// copyright-holders:Aaron Giles
/***************************************************************************

    drivenum.cpp

    Driver enumeration helpers.

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

#include "emu.h"
#include "drivenum.h"
#include "softlist_dev.h"

#include <ctype.h>



//**************************************************************************
//  DRIVER LIST
//**************************************************************************

//-------------------------------------------------
//  driver_list - constructor
//-------------------------------------------------

driver_list::driver_list()
{
}


//-------------------------------------------------
//  find - find a driver by name
//-------------------------------------------------

int driver_list::find(const char *name)
{
	// if no name, bail
	if (!name)
		return -1;

	// binary search to find it
	game_driver const *const *const begin = s_drivers_sorted;
	game_driver const *const *const end = begin + s_driver_count;
	auto const cmp = [] (game_driver const *driver, char const *name) { return core_stricmp(driver->name, name) < 0; };
	game_driver const *const *const result = std::lower_bound(begin, end, name, cmp);
	return ((result == end) || core_stricmp((*result)->name, name)) ? -1 : std::distance(begin, result);
}


//-------------------------------------------------
//  matches - true if we match, taking into
//  account wildcards in the wildstring
//-------------------------------------------------

bool driver_list::matches(const char *wildstring, const char *string)
{
	// can only match internal drivers if the wildstring starts with an underscore
	if (string[0] == '_' && (wildstring == nullptr || wildstring[0] != '_'))
		return false;

	// match everything else normally
	return (wildstring == nullptr || core_strwildcmp(wildstring, string) == 0);
}


//-------------------------------------------------
//  penalty_compare - compare two strings for
//  closeness and assign a score.
//-------------------------------------------------

int driver_list::penalty_compare(const char *source, const char *target)
{
	int gaps = 1;
	bool last = true;

	// scan the strings
	for ( ; *source && *target; target++)
	{
		// do a case insensitive match
		bool const match(tolower(u8(*source)) == tolower(u8(*target)));

		// if we matched, advance the source
		if (match)
			source++;

		// if the match state changed, count gaps
		if (match != last)
		{
			last = match;
			if (!match)
				gaps++;
		}
	}

	// penalty if short string does not completely fit in
	for ( ; *source; source++)
		gaps++;

	// if we matched perfectly, gaps == 0
	if (gaps == 1 && *source == 0 && *target == 0)
		gaps = 0;

	return gaps;
}



//**************************************************************************
//  DRIVER ENUMERATOR
//**************************************************************************

//-------------------------------------------------
//  driver_enumerator - constructor
//-------------------------------------------------

driver_enumerator::driver_enumerator(emu_options &options)
	: m_current(-1)
	, m_filtered_count(0)
	, m_options(options)
	, m_included(s_driver_count)
	, m_config(CONFIG_CACHE_COUNT)
{
	include_all();
}


driver_enumerator::driver_enumerator(emu_options &options, const char *string)
	: driver_enumerator(options)
{
	filter(string);
}


driver_enumerator::driver_enumerator(emu_options &options, const game_driver &driver)
	: driver_enumerator(options)
{
	filter(driver);
}


//-------------------------------------------------
//  ~driver_enumerator - destructor
//-------------------------------------------------

driver_enumerator::~driver_enumerator()
{
	// configs are freed by the cache
}


//-------------------------------------------------
//  config - return a machine_config for the given
//  driver, allocating on demand if needed
//-------------------------------------------------

std::shared_ptr<machine_config> const &driver_enumerator::config(std::size_t index, emu_options &options) const
{
	assert(index < s_driver_count);

	// if we don't have it cached, add it
	std::shared_ptr<machine_config> &config = m_config[index];
	if (!config)
		config = std::make_shared<machine_config>(*s_drivers_sorted[index], options);

	return config;
}


//-------------------------------------------------
//  filter - filter the driver list against the
//  given string
//-------------------------------------------------

std::size_t driver_enumerator::filter(const char *filterstring)
{
	// reset the count
	exclude_all();

	// match name against each driver in the list
	for (std::size_t index = 0; index < s_driver_count; index++)
		if (matches(filterstring, s_drivers_sorted[index]->name))
			include(index);

	return m_filtered_count;
}


//-------------------------------------------------
//  filter - filter the driver list against the
//  given driver
//-------------------------------------------------

std::size_t driver_enumerator::filter(const game_driver &driver)
{
	// reset the count
	exclude_all();

	// match name against each driver in the list
	for (std::size_t index = 0; index < s_driver_count; index++)
		if (s_drivers_sorted[index] == &driver)
			include(index);

	return m_filtered_count;
}


//-------------------------------------------------
//  include_all - include all non-internal drivers
//-------------------------------------------------

void driver_enumerator::include_all()
{
	std::fill(m_included.begin(), m_included.end(), true);
	m_filtered_count = m_included.size();

	// always exclude the empty driver
	exclude(find("___empty"));
}


//-------------------------------------------------
//  next - get the next driver matching the given
//  filter
//-------------------------------------------------

bool driver_enumerator::next()
{
	release_current();

	// always advance one
	// if we have a filter, scan forward to the next match
	for (m_current++; (m_current < s_driver_count) && !m_included[m_current]; m_current++) { }

	// return true if we end up in range
	return (m_current >= 0) && (m_current < s_driver_count);
}


//-------------------------------------------------
//  next_excluded - get the next driver that is
//  not currently included in the list
//-------------------------------------------------

bool driver_enumerator::next_excluded()
{
	release_current();

	// always advance one
	// if we have a filter, scan forward to the next match
	for (m_current++; (m_current < s_driver_count) && m_included[m_current]; m_current++) { }

	// return true if we end up in range
	return (m_current >= 0) && (m_current < s_driver_count);
}


//-------------------------------------------------
//  driver_sort_callback - compare two items in
//  an array of game_driver pointers
//-------------------------------------------------

void driver_enumerator::find_approximate_matches(const char *string, std::size_t count, int *results)
{
#undef rand

	// if no name, pick random entries
	if (!string || !string[0])
	{
		// seed the RNG first
		srand(osd_ticks());

		// allocate a temporary list
		std::vector<int> templist(m_filtered_count);
		int arrayindex = 0;
		for (int index = 0; index < s_driver_count; index++)
			if (m_included[index])
				templist[arrayindex++] = index;
		assert(arrayindex == m_filtered_count);

		// shuffle
		for (int shufnum = 0; shufnum < (4 * s_driver_count); shufnum++)
		{
			int item1 = rand() % m_filtered_count;
			int item2 = rand() % m_filtered_count;
			int temp = templist[item1];
			templist[item1] = templist[item2];
			templist[item2] = temp;
		}

		// copy out the first few entries
		for (int matchnum = 0; matchnum < count; matchnum++)
			results[matchnum] = templist[matchnum % m_filtered_count];
	}
	else
	{
		// allocate memory to track the penalty value
		std::vector<int> penalty(count);

		// initialize everyone's states
		for (int matchnum = 0; matchnum < count; matchnum++)
		{
			penalty[matchnum] = 9999;
			results[matchnum] = -1;
		}

		// scan the entire drivers array
		for (int index = 0; index < s_driver_count; index++)
		{
			// skip things that can't run
			if (m_included[index])
			{
				// pick the best match between driver name and description
				int curpenalty = penalty_compare(string, s_drivers_sorted[index]->type.fullname());
				int tmp = penalty_compare(string, s_drivers_sorted[index]->name);
				curpenalty = (std::min)(curpenalty, tmp);

				// insert into the sorted table of matches
				for (int matchnum = count - 1; matchnum >= 0; matchnum--)
				{
					// stop if we're worse than the current entry
					if (curpenalty >= penalty[matchnum])
						break;

					// as long as this isn't the last entry, bump this one down
					if (matchnum < count - 1)
					{
						penalty[matchnum + 1] = penalty[matchnum];
						results[matchnum + 1] = results[matchnum];
					}
					results[matchnum] = index;
					penalty[matchnum] = curpenalty;
				}
			}
		}
	}
}


//-------------------------------------------------
//  release_current - release bulky memory
//  structures from the current entry because
//  we're done with it
//-------------------------------------------------

void driver_enumerator::release_current() const
{
	// skip if no current entry
	if ((m_current >= 0) && (m_current < s_driver_count))
	{
		// skip if we haven't cached a config
		auto const cached = m_config.find(m_current);
		if (cached != m_config.end())
		{
			// iterate over software lists in this entry and reset
			for (software_list_device &swlistdev : software_list_device_iterator(cached->second->root_device()))
				swlistdev.release();
		}
	}
}