void driver_get_approx_matches(const char *name, int matches, int *indexes)
{
int *penalty;
int drvnum;
int matchnum;
/* allocate some temp memory */
penalty = malloc_or_die(matches * sizeof(*penalty));
/* initialize everyone's states */
for (matchnum = 0; matchnum < matches; matchnum++)
{
penalty[matchnum] = 9999;
indexes[matchnum] = -1;
}
/* scan the entire drivers array */
for (drvnum = 0; drivers[drvnum] != NULL; drvnum++)
{
int curpenalty, tmp;
/* skip non-drivers */
if ((drivers[drvnum]->flags & NOT_A_DRIVER) != 0)
continue;
/* pick the best match between driver name and description */
curpenalty = penalty_compare(name, drivers[drvnum]->description);
tmp = penalty_compare(name, drivers[drvnum]->name);
curpenalty = MIN(curpenalty, tmp);
/* insert into the sorted table of matches */
for (matchnum = matches - 1; matchnum >= 0; matchnum--)
{
/* stop if we're worse than the current entry */
if (curpenalty >= penalty[matchnum])
break;
/* as lng as this isn't the last entry, bump this one down */
if (matchnum < matches - 1)
{
penalty[matchnum + 1] = penalty[matchnum];
indexes[matchnum + 1] = indexes[matchnum];
}
indexes[matchnum] = drvnum;
penalty[matchnum] = curpenalty;
}
}
/* free our temp memory */
free(penalty);
}
/*
* We compare the game name given on the CLI against the long and
* the short game names supported
*/
void show_approx_matches(void)
{
struct { int penalty; int index; } topten[10];
int i,j;
int penalty; /* best fuzz factor so far */
for (i = 0; i < 10; i++)
{
topten[i].penalty = 9999;
topten[i].index = -1;
}
for (i = 0; (drivers[i] != 0); i++)
{
int tmp;
if ((drivers[i]->flags & NOT_A_DRIVER) != 0)
continue;
penalty = penalty_compare (gamename, drivers[i]->description);
tmp = penalty_compare (gamename, drivers[i]->name);
if (tmp < penalty) penalty = tmp;
/* eventually insert into table of approximate matches */
for (j = 0; j < 10; j++)
{
if (penalty >= topten[j].penalty) break;
if (j > 0)
{
topten[j-1].penalty = topten[j].penalty;
topten[j-1].index = topten[j].index;
}
topten[j].index = i;
topten[j].penalty = penalty;
}
}
for (i = 9; i >= 0; i--)
{
if (topten[i].index != -1)
fprintf (stderr, "%-10s%s\n", drivers[topten[i].index]->name, drivers[topten[i].index]->description);
}
}
void driver_enumerator::find_approximate_matches(const char *string, int count, int *results)
{
#undef rand
// if no name, pick random entries
if (string == NULL || string[0] == 0)
{
// seed the RNG first
srand(osd_ticks());
// allocate a temporary list
dynamic_array<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];
return;
}
// allocate memory to track the penalty value
dynamic_array<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++)
if (m_included[index])
{
// skip things that can't run
if ((s_drivers_sorted[index]->flags & GAME_NO_STANDALONE) != 0)
continue;
// pick the best match between driver name and description
int curpenalty = penalty_compare(string, s_drivers_sorted[index]->description);
int tmp = penalty_compare(string, s_drivers_sorted[index]->name);
curpenalty = 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;
}
}
}
void driver_list_get_approx_matches(const game_driver * const driverlist[], const char *name, int matches, const game_driver **list)
{
#undef rand
int matchnum, drvnum;
int *penalty;
#if 0
/* if no name, pick random entries */
if (name == NULL || name[0] == 0)
{
const game_driver **templist;
int driver_count;
int shufnum;
/* allocate a temporary list */
templist = alloc_array_or_die(const game_driver *, driver_list_get_count(driverlist));
/* build up a list of valid entries */
for (drvnum = driver_count = 0; driverlist[drvnum] != NULL; drvnum++)
if ((driverlist[drvnum]->flags & GAME_NO_STANDALONE) == 0)
templist[driver_count++] = driverlist[drvnum];
/* seed the RNG first */
srand(osd_ticks());
/* shuffle */
for (shufnum = 0; shufnum < 4 * driver_count; shufnum++)
{
int item1 = rand() % driver_count;
int item2 = rand() % driver_count;
const game_driver *temp;
temp = templist[item1];
templist[item1] = templist[item2];
templist[item2] = temp;
}
/* copy out the first few entries */
for (matchnum = 0; matchnum < matches; matchnum++)
list[matchnum] = templist[matchnum % driver_count];
free((void *)templist);
return;
}
#endif
/* allocate some temp memory */
penalty = alloc_array_or_die(int, matches);
/* initialize everyone's states */
for (matchnum = 0; matchnum < matches; matchnum++)
{
penalty[matchnum] = 9999;
list[matchnum] = NULL;
}
/* scan the entire drivers array */
for (drvnum = 0; driverlist[drvnum] != NULL; drvnum++)
{
int curpenalty, tmp;
/* skip things that can't run */
if ((driverlist[drvnum]->flags & GAME_NO_STANDALONE) != 0)
continue;
/* pick the best match between driver name and description */
curpenalty = penalty_compare(name, driverlist[drvnum]->description);
tmp = penalty_compare(name, driverlist[drvnum]->name);
curpenalty = MIN(curpenalty, tmp);
/* insert into the sorted table of matches */
for (matchnum = matches - 1; matchnum >= 0; matchnum--)
{
/* stop if we're worse than the current entry */
if (curpenalty >= penalty[matchnum])
break;
/* as lng as this isn't the last entry, bump this one down */
if (matchnum < matches - 1)
{
penalty[matchnum + 1] = penalty[matchnum];
list[matchnum + 1] = list[matchnum];
}
list[matchnum] = driverlist[drvnum];
penalty[matchnum] = curpenalty;
}
}
/* free our temp memory */
free(penalty);
}