trunk/src/emu/clifront.cpp
| r253726 | r253727 | |
| 231 | 231 | |
| 232 | 232 | // if a game was specified, wasn't a wildcard, and our error indicates this was the |
| 233 | 233 | // reason for failure, offer some suggestions |
| 234 | | if (m_result == MAMERR_NO_SUCH_GAME && *(m_options.system_name()) != 0 && strchr(m_options.system_name(), '*') == nullptr) |
| 234 | if (m_result == MAMERR_NO_SUCH_GAME && *(m_options.system_name()) != 0 && strchr(m_options.system_name(), '*') == nullptr && m_options.system() == nullptr) |
| 235 | 235 | { |
| 236 | 236 | // get the top 16 approximate matches |
| 237 | 237 | driver_enumerator drivlist(m_options); |
| r253726 | r253727 | |
| 328 | 328 | |
| 329 | 329 | // iterate through drivers and output the info |
| 330 | 330 | while (drivlist.next()) |
| 331 | | { |
| 332 | | osd_printf_info("%-16s @%s", drivlist.driver().name, core_filename_extract_base(drivlist.driver().source_file).c_str()); |
| 333 | | int bios = drivlist.bios_root(); |
| 334 | | if (bios != -1) |
| 335 | | osd_printf_info(" :%s", drivlist.driver(bios).name); |
| 336 | | int parent = drivlist.non_bios_clone(); |
| 337 | | if (parent != -1) |
| 338 | | osd_printf_info(" ^%s", drivlist.driver(parent).name); |
| 339 | | osd_printf_info("\n"); |
| 340 | | } |
| 331 | osd_printf_info("%-16s %s\n", drivlist.driver().name, core_filename_extract_base(drivlist.driver().source_file).c_str()); |
| 341 | 332 | } |
| 342 | 333 | |
| 343 | 334 | |
| r253726 | r253727 | |
| 350 | 341 | { |
| 351 | 342 | // start with a filtered list of drivers |
| 352 | 343 | driver_enumerator drivlist(m_options, gamename); |
| 344 | int original_count = drivlist.count(); |
| 353 | 345 | |
| 354 | | // return an error if none found |
| 355 | | if (drivlist.count() == 0) |
| 356 | | throw emu_fatalerror(MAMERR_NO_SUCH_GAME, "No matching games found for '%s'", gamename); |
| 357 | | |
| 358 | | // find the parent sets and BIOSes of the matching drivers |
| 359 | | driver_enumerator parentlist(m_options); |
| 360 | | driver_enumerator bioslist(m_options); |
| 361 | | parentlist.exclude_all(); |
| 362 | | bioslist.exclude_all(); |
| 363 | | while (drivlist.next()) |
| 364 | | { |
| 365 | | // check if we have a non-bios clone |
| 366 | | int clone_of = drivlist.non_bios_clone(); |
| 367 | | if (clone_of != -1) |
| 368 | | { |
| 369 | | // add the parent to the list |
| 370 | | drivlist.include(clone_of); |
| 371 | | parentlist.include(clone_of); |
| 372 | | } |
| 373 | | |
| 374 | | // add BIOS roots to a separate list |
| 375 | | int bios = drivlist.bios_root(); |
| 376 | | if (bios != -1) |
| 377 | | bioslist.include(bios); |
| 378 | | } |
| 379 | | |
| 380 | 346 | // iterate through the remaining ones to see if their parent matches |
| 381 | | drivlist.reset(); |
| 382 | 347 | while (drivlist.next_excluded()) |
| 383 | 348 | { |
| 384 | 349 | // if we have a non-bios clone and it matches, keep it |
| 385 | | int clone_of = drivlist.non_bios_clone(); |
| 386 | | if (clone_of != -1 && drivlist.included(clone_of)) |
| 387 | | { |
| 388 | | drivlist.include(); |
| 389 | | parentlist.include(clone_of); |
| 390 | | } |
| 350 | int clone_of = drivlist.clone(); |
| 351 | if (clone_of != -1 && (drivlist.driver(clone_of).flags & MACHINE_IS_BIOS_ROOT) == 0) |
| 352 | if (drivlist.matches(gamename, drivlist.driver(clone_of).name)) |
| 353 | drivlist.include(); |
| 391 | 354 | } |
| 392 | 355 | |
| 393 | | if (parentlist.count() == 0) |
| 394 | | osd_printf_info("No clones found for games matching '%s'\n", gamename); |
| 395 | | else |
| 356 | // return an error if none found |
| 357 | if (drivlist.count() == 0) |
| 396 | 358 | { |
| 397 | | // iterate through the list of parents |
| 398 | | parentlist.reset(); |
| 399 | | bool first = true; |
| 400 | | while (parentlist.next()) |
| 401 | | { |
| 402 | | int bios = parentlist.bios_root(); |
| 403 | | |
| 404 | | // print a separate header for each parent |
| 405 | | if (!first) |
| 406 | | osd_printf_info("\n"); |
| 407 | | first = false; |
| 408 | | if (bios == -1) |
| 409 | | osd_printf_info("Clones of \"%s\" (%s):\n", parentlist.driver().description, parentlist.driver().name); |
| 410 | | else |
| 411 | | { |
| 412 | | osd_printf_info("Clones of \"%s\" (%s, %s BIOS):\n", parentlist.driver().description, parentlist.driver().name, parentlist.driver(bios).name); |
| 413 | | drivlist.exclude(bios); |
| 414 | | } |
| 415 | | |
| 416 | | // prevent further output about parent |
| 417 | | drivlist.exclude(parentlist.current()); |
| 418 | | |
| 419 | | // iterate through drivers |
| 420 | | drivlist.reset(); |
| 421 | | while (drivlist.next()) |
| 422 | | { |
| 423 | | // keep clones of the same parent together |
| 424 | | if (drivlist.is_clone_of(parentlist.current())) |
| 425 | | { |
| 426 | | // output the info and remove the driver from the list |
| 427 | | osd_printf_info("%-18s\"%s\"\n", drivlist.driver().name, drivlist.driver().description); |
| 428 | | drivlist.exclude(); |
| 429 | | } |
| 430 | | } |
| 431 | | } |
| 359 | // see if we match but just weren't a clone |
| 360 | if (original_count == 0) |
| 361 | throw emu_fatalerror(MAMERR_NO_SUCH_GAME, "No matching games found for '%s'", gamename); |
| 362 | else |
| 363 | osd_printf_info("Found %d matches for '%s' but none were clones\n", drivlist.count(), gamename); |
| 364 | return; |
| 432 | 365 | } |
| 433 | 366 | |
| 434 | | // sort non-clone sets by BIOS, if any |
| 435 | | bioslist.reset(); |
| 436 | | while (bioslist.next() && drivlist.count() != 0) |
| 437 | | { |
| 438 | | // iterate over the remaining drivers |
| 439 | | bool first = true; |
| 440 | | drivlist.reset(); |
| 441 | | while (drivlist.next()) |
| 442 | | { |
| 443 | | if (drivlist.bios_root() == bioslist.current()) |
| 444 | | { |
| 445 | | // print a header for the BIOS |
| 446 | | if (first) |
| 447 | | { |
| 448 | | osd_printf_info("\nOther sets (%s BIOS):\n", bioslist.driver().name); |
| 449 | | drivlist.exclude(bioslist.current()); |
| 450 | | first = false; |
| 451 | | } |
| 367 | // print the header |
| 368 | osd_printf_info("Name: Clone of:\n"); |
| 452 | 369 | |
| 453 | | // output the info and remove the driver from the list |
| 454 | | osd_printf_info("%-18s\"%s\"\n", drivlist.driver().name, drivlist.driver().description); |
| 455 | | drivlist.exclude(); |
| 456 | | } |
| 457 | | } |
| 458 | | } |
| 459 | | |
| 460 | | // finally list any remaining matching drivers that have no clones |
| 461 | | if (drivlist.count() != 0) |
| 370 | // iterate through drivers and output the info |
| 371 | drivlist.reset(); |
| 372 | while (drivlist.next()) |
| 462 | 373 | { |
| 463 | | // print a header |
| 464 | | osd_printf_info("\nUnique sets:\n"); |
| 465 | | |
| 466 | | // iterate and output the info |
| 467 | | drivlist.reset(); |
| 468 | | while (drivlist.next()) |
| 469 | | osd_printf_info("%-18s\"%s\"\n", drivlist.driver().name, drivlist.driver().description); |
| 374 | int clone_of = drivlist.clone(); |
| 375 | if (clone_of != -1 && (drivlist.driver(clone_of).flags & MACHINE_IS_BIOS_ROOT) == 0) |
| 376 | osd_printf_info("%-16s %-8s\n", drivlist.driver().name, drivlist.driver(clone_of).name); |
| 470 | 377 | } |
| 471 | 378 | } |
| 472 | 379 | |
| r253726 | r253727 | |
| 516 | 423 | |
| 517 | 424 | |
| 518 | 425 | //------------------------------------------------- |
| 519 | | // listtree - output a tree of matching games, |
| 520 | | // their parents and BIOS roots, separated by |
| 521 | | // source file |
| 522 | | //------------------------------------------------- |
| 523 | | |
| 524 | | void cli_frontend::listtree(const char *gamename) |
| 525 | | { |
| 526 | | // start with a filtered list of drivers; return an error if none found |
| 527 | | driver_enumerator initial_drivlist(m_options, gamename); |
| 528 | | if (initial_drivlist.count() == 0) |
| 529 | | throw emu_fatalerror(MAMERR_NO_SUCH_GAME, "No matching games found for '%s'", gamename); |
| 530 | | |
| 531 | | // scan through the initially-selected drivers |
| 532 | | bool first = true; |
| 533 | | while (initial_drivlist.next()) |
| 534 | | { |
| 535 | | // get the source file and print the header |
| 536 | | if (!first) |
| 537 | | osd_printf_info("\n"); |
| 538 | | first = false; |
| 539 | | const char *source = initial_drivlist.driver().source_file; |
| 540 | | osd_printf_info("Drivers in source file %s:\n", core_filename_extract_base(source).c_str()); |
| 541 | | |
| 542 | | // build a new brother list for each source file |
| 543 | | driver_enumerator drivlist(m_options); |
| 544 | | driver_enumerator brotherlist(m_options); |
| 545 | | driver_enumerator bioslist(m_options); |
| 546 | | drivlist.exclude_all(); |
| 547 | | brotherlist.exclude_all(); |
| 548 | | bioslist.exclude_all(); |
| 549 | | |
| 550 | | // walk the initial driver list and mark those with the same source |
| 551 | | initial_drivlist.reset(); |
| 552 | | while (initial_drivlist.next()) |
| 553 | | { |
| 554 | | if (strcmp(initial_drivlist.driver().source_file, source) == 0) |
| 555 | | { |
| 556 | | brotherlist.include(initial_drivlist.current()); |
| 557 | | int parent = initial_drivlist.non_bios_clone(); |
| 558 | | drivlist.include(parent != -1 ? parent : initial_drivlist.current()); |
| 559 | | int bios = initial_drivlist.bios_root(); |
| 560 | | if (bios != -1) |
| 561 | | bioslist.include(bios); |
| 562 | | initial_drivlist.exclude(); |
| 563 | | } |
| 564 | | } |
| 565 | | |
| 566 | | // output the entries found for each source file (with BIOS root) |
| 567 | | bioslist.reset(); |
| 568 | | while (bioslist.next()) |
| 569 | | { |
| 570 | | if (strcmp(bioslist.driver().source_file, source) != 0) |
| 571 | | osd_printf_info("%-16s (BIOS root in %s)\n", bioslist.driver().name, core_filename_extract_base(bioslist.driver().source_file).c_str()); |
| 572 | | else |
| 573 | | { |
| 574 | | osd_printf_info("%-16s %s\n", bioslist.driver().name, bioslist.driver().description); |
| 575 | | brotherlist.exclude(bioslist.current()); |
| 576 | | drivlist.exclude(bioslist.current()); |
| 577 | | } |
| 578 | | drivlist.reset(); |
| 579 | | while (drivlist.next()) |
| 580 | | { |
| 581 | | // drivers with this BIOS |
| 582 | | if (drivlist.bios_root() != bioslist.current()) |
| 583 | | continue; |
| 584 | | |
| 585 | | // print the parent |
| 586 | | if (strcmp(drivlist.driver().source_file, source) != 0) |
| 587 | | osd_printf_info(" %-16s (parent set in %s)\n", drivlist.driver().name, core_filename_extract_base(drivlist.driver().source_file).c_str()); |
| 588 | | else |
| 589 | | { |
| 590 | | osd_printf_info(" %-16s %s\n", drivlist.driver().name, drivlist.driver().description); |
| 591 | | brotherlist.exclude(drivlist.current()); |
| 592 | | } |
| 593 | | |
| 594 | | // print the clones |
| 595 | | brotherlist.reset(); |
| 596 | | while (brotherlist.next()) |
| 597 | | { |
| 598 | | if (!brotherlist.is_clone_of(drivlist.current())) |
| 599 | | continue; |
| 600 | | osd_printf_info(" %-16s %s\n", brotherlist.driver().name, brotherlist.driver().description); |
| 601 | | brotherlist.exclude(); |
| 602 | | } |
| 603 | | drivlist.exclude(); |
| 604 | | } |
| 605 | | } |
| 606 | | |
| 607 | | // output the entries found for each source file (no BIOS root) |
| 608 | | drivlist.reset(); |
| 609 | | while (drivlist.next()) |
| 610 | | { |
| 611 | | // print the parent |
| 612 | | if (strcmp(drivlist.driver().source_file, source) != 0) |
| 613 | | osd_printf_info("%-16s (parent set in %s)\n", drivlist.driver().name, core_filename_extract_base(drivlist.driver().source_file).c_str()); |
| 614 | | else |
| 615 | | { |
| 616 | | osd_printf_info("%-16s %s\n", drivlist.driver().name, drivlist.driver().description); |
| 617 | | brotherlist.exclude(drivlist.current()); |
| 618 | | } |
| 619 | | |
| 620 | | // print the clones |
| 621 | | brotherlist.reset(); |
| 622 | | while (brotherlist.next()) |
| 623 | | { |
| 624 | | if (!brotherlist.is_clone_of(drivlist.current())) |
| 625 | | continue; |
| 626 | | osd_printf_info(" %-16s %s\n", brotherlist.driver().name, brotherlist.driver().description); |
| 627 | | brotherlist.exclude(); |
| 628 | | } |
| 629 | | } |
| 630 | | |
| 631 | | // reset for next source |
| 632 | | initial_drivlist.reset(); |
| 633 | | } |
| 634 | | } |
| 635 | | |
| 636 | | |
| 637 | | //------------------------------------------------- |
| 638 | 426 | // listcrc - output the CRC and name of all ROMs |
| 639 | 427 | // referenced by the emulator |
| 640 | 428 | //------------------------------------------------- |
| r253726 | r253727 | |
| 1868 | 1656 | { CLICOMMAND_LISTSOURCE, &cli_frontend::listsource }, |
| 1869 | 1657 | { CLICOMMAND_LISTCLONES, &cli_frontend::listclones }, |
| 1870 | 1658 | { CLICOMMAND_LISTBROTHERS, &cli_frontend::listbrothers }, |
| 1871 | | { CLICOMMAND_LISTTREE, &cli_frontend::listtree }, |
| 1872 | 1659 | { CLICOMMAND_LISTCRC, &cli_frontend::listcrc }, |
| 1873 | 1660 | { CLICOMMAND_LISTDEVICES, &cli_frontend::listdevices }, |
| 1874 | 1661 | { CLICOMMAND_LISTSLOTS, &cli_frontend::listslots }, |
trunk/src/emu/drivenum.cpp
| r253726 | r253727 | |
| 54 | 54 | // account wildcards in the wildstring |
| 55 | 55 | //------------------------------------------------- |
| 56 | 56 | |
| 57 | | bool driver_list::matches(const char *wildstring, const game_driver &driver) |
| 57 | bool driver_list::matches(const char *wildstring, const char *string) |
| 58 | 58 | { |
| 59 | 59 | // can only match internal drivers if the wildstring starts with an underscore |
| 60 | | if (driver.name[0] == '_' && (wildstring == nullptr || wildstring[0] != '_')) |
| 60 | if (string[0] == '_' && (wildstring == nullptr || wildstring[0] != '_')) |
| 61 | 61 | return false; |
| 62 | 62 | |
| 63 | | // null matches any normal driver |
| 64 | | if (wildstring == nullptr) |
| 65 | | return true; |
| 66 | | |
| 67 | | // special case: match on parent name |
| 68 | | if (wildstring[0] == '^') |
| 69 | | { |
| 70 | | int clone_index = non_bios_clone(driver); |
| 71 | | if (clone_index == -1) |
| 72 | | return (wildstring[1] == '\0') || (core_stricmp(wildstring+1, driver.name) == 0); |
| 73 | | else |
| 74 | | return (core_stricmp(wildstring+1, s_drivers_sorted[clone_index]->name) == 0); |
| 75 | | } |
| 76 | | |
| 77 | | // special case: match on BIOS name |
| 78 | | if (wildstring[0] == ':') |
| 79 | | { |
| 80 | | int bios_index = bios_root(driver); |
| 81 | | if (bios_index == -1) |
| 82 | | return (driver.flags & MACHINE_IS_BIOS_ROOT) && ((wildstring[1] == '\0') || (core_stricmp(wildstring+1, driver.name) == 0)); |
| 83 | | else |
| 84 | | return (core_stricmp(wildstring+1, s_drivers_sorted[bios_index]->name) == 0); |
| 85 | | } |
| 86 | | |
| 87 | | // special case: match on source filename |
| 88 | | if (wildstring[0] == '@') |
| 89 | | return (core_stricmp(wildstring+1, core_filename_extract_base(driver.source_file).c_str()) == 0); |
| 90 | | |
| 91 | 63 | // match everything else normally |
| 92 | | return (core_strwildcmp(wildstring, driver.name) == 0); |
| 64 | return (wildstring == nullptr || core_strwildcmp(wildstring, string) == 0); |
| 93 | 65 | } |
| 94 | 66 | |
| 95 | 67 | |
| r253726 | r253727 | |
| 243 | 215 | |
| 244 | 216 | // match name against each driver in the list |
| 245 | 217 | for (int index = 0; index < s_driver_count; index++) |
| 246 | | if (matches(filterstring, *s_drivers_sorted[index])) |
| 218 | if (matches(filterstring, s_drivers_sorted[index]->name)) |
| 247 | 219 | include(index); |
| 248 | 220 | |
| 249 | 221 | return m_filtered_count; |
| r253726 | r253727 | |
| 281 | 253 | // always exclude the empty driver |
| 282 | 254 | int empty = find("___empty"); |
| 283 | 255 | assert(empty != -1); |
| 284 | | exclude(empty); |
| 256 | m_included[empty] = 0; |
| 285 | 257 | } |
| 286 | 258 | |
| 287 | 259 | |
| r253726 | r253727 | |
| 341 | 313 | void driver_enumerator::find_approximate_matches(const char *string, int count, int *results) |
| 342 | 314 | { |
| 343 | 315 | #undef rand |
| 344 | | // skip leading nonalphanumeric characters |
| 345 | | if (string != nullptr) |
| 346 | | { |
| 347 | | while (string[0] != '\0' && !isalnum(string[0])) |
| 348 | | string++; |
| 349 | | } |
| 350 | 316 | |
| 351 | 317 | // if no name, pick random entries |
| 352 | | if (string == nullptr || string[0] == '\0') |
| 318 | if (string == nullptr || string[0] == 0) |
| 353 | 319 | { |
| 354 | 320 | // seed the RNG first |
| 355 | 321 | srand(osd_ticks()); |
trunk/src/emu/drivenum.h
| r253726 | r253727 | |
| 35 | 35 | |
| 36 | 36 | // any item by index |
| 37 | 37 | static const game_driver &driver(int index) { assert(index >= 0 && index < s_driver_count); return *s_drivers_sorted[index]; } |
| 38 | | static int clone(int index) { return clone(driver(index)); } |
| 39 | | static int non_bios_clone(int index) { return non_bios_clone(driver(index)); } |
| 40 | | static int bios_root(int index) { return bios_root(driver(index)); } |
| 41 | | static int compatible_with(int index) { return compatible_with(driver(index)); } |
| 38 | static int clone(int index) { return find(driver(index).parent); } |
| 39 | static int non_bios_clone(int index) { int result = find(driver(index).parent); return (result != -1 && (driver(result).flags & MACHINE_IS_BIOS_ROOT) == 0) ? result : -1; } |
| 40 | static int compatible_with(int index) { return find(driver(index).compatible_with); } |
| 42 | 41 | |
| 43 | 42 | // any item by driver |
| 44 | | static int clone(const game_driver &driver) { return find(driver.parent); } |
| 45 | | static int non_bios_clone(const game_driver &driver) { int result = find(driver.parent); return (result != -1 && (driver_list::driver(result).flags & MACHINE_IS_BIOS_ROOT) == 0) ? result : -1; } |
| 46 | | static int bios_root(const game_driver &driver) { int result = find(driver.parent); return (result == -1) ? -1 : ((driver_list::driver(result).flags & MACHINE_IS_BIOS_ROOT) == 0) ? bios_root(result) : result; } |
| 47 | | static int compatible_with(const game_driver &driver) { return find(driver.compatible_with); } |
| 43 | static int clone(const game_driver &driver) { int index = find(driver); assert(index != -1); return clone(index); } |
| 44 | static int non_bios_clone(const game_driver &driver) { int index = find(driver); assert(index != -1); return non_bios_clone(index); } |
| 45 | static int compatible_with(const game_driver &driver) { int index = find(driver); assert(index != -1); return compatible_with(index); } |
| 48 | 46 | |
| 49 | 47 | // general helpers |
| 50 | 48 | static int find(const char *name); |
| 51 | 49 | static int find(const game_driver &driver) { return find(driver.name); } |
| 52 | 50 | |
| 53 | 51 | // static helpers |
| 54 | | static bool matches(const char *wildstring, const game_driver &driver); |
| 52 | static bool matches(const char *wildstring, const char *string); |
| 55 | 53 | static int penalty_compare(const char *source, const char *target); |
| 56 | 54 | |
| 57 | 55 | protected: |
| r253726 | r253727 | |
| 86 | 84 | // current item |
| 87 | 85 | const game_driver &driver() const { return driver_list::driver(m_current); } |
| 88 | 86 | machine_config &config() const { return config(m_current, m_options); } |
| 89 | | int clone() const { return driver_list::clone(m_current); } |
| 90 | | int non_bios_clone() const { return driver_list::non_bios_clone(m_current); } |
| 91 | | int bios_root() const { return driver_list::bios_root(m_current); } |
| 92 | | int compatible_with() const { return driver_list::compatible_with(m_current); } |
| 93 | | bool is_clone_of(int index) const { return strcmp(driver_list::driver(index).name, driver_list::driver(m_current).parent) == 0; } |
| 94 | | bool is_clone_of(const game_driver &driver) const { return strcmp(driver.name, driver_list::driver(m_current).parent) == 0; } |
| 87 | int clone() { return driver_list::clone(m_current); } |
| 88 | int non_bios_clone() { return driver_list::non_bios_clone(m_current); } |
| 89 | int compatible_with() { return driver_list::compatible_with(m_current); } |
| 95 | 90 | void include() { include(m_current); } |
| 96 | 91 | void exclude() { exclude(m_current); } |
| 97 | 92 | |
| r253726 | r253727 | |
| 105 | 100 | using driver_list::driver; |
| 106 | 101 | using driver_list::clone; |
| 107 | 102 | using driver_list::non_bios_clone; |
| 108 | | using driver_list::bios_root; |
| 109 | 103 | using driver_list::compatible_with; |
| 110 | 104 | |
| 111 | 105 | // filtering/iterating |
trunk/src/osd/sdl/man/mame.6
| r253726 | r253727 | |
| 91 | 91 | driver name or wildcard after the \-listfull command. |
| 92 | 92 | .TP |
| 93 | 93 | .B \-listsource, \-ls \fR[\fIgamename\fR|\fIwildcard\fR] |
| 94 | | Displays a list of drivers, the names of the source files their game |
| 95 | | drivers live in, and their parent sets and BIOS roots, if any. These |
| 96 | | are listed in the form of wildcards that will match all drivers with |
| 97 | | similar properties. By default all games are listed; however, you can |
| 94 | Displays a list of drivers and the names of the source files their game |
| 95 | drivers live in. Useful for finding which driver a game runs on in |
| 96 | order to fix bugs. By default all games are listed; however, you can |
| 98 | 97 | limit this list by specifying a driver name or wildcard after the |
| 99 | 98 | \-listsource command. |
| 100 | 99 | .TP |
| 101 | 100 | .B \-listclones, \-lc \fR[\fIgamename\fR|\fIwildcard\fR] |
| 102 | | Displays a list of clones, sorted under their parent sets. By default |
| 103 | | all drivers are listed; however, you can limit this list to clones of |
| 104 | | certain drivers by specifying a name or wildcard after the \-listclones |
| 105 | | command. |
| 101 | Displays a list of clones. By default all clones are listed; however, |
| 102 | you can limit this list by specifying a driver name or wildcard after |
| 103 | the \-listclones command. |
| 106 | 104 | .TP |
| 107 | 105 | .B \-listbrothers, \-lb \fR[\fIgamename\fR|\fIwildcard\fR] |
| 108 | 106 | Displays a list of "brothers" or other drivers from same sourcefile. |
| 109 | 107 | By default all games are listed; however, you can limit this list by |
| 110 | 108 | specifying a driver name or wildcard after the \-listbrothers command. |
| 111 | 109 | .TP |
| 112 | | .B \-listtree, \-lt \fR[\fIgamename\fR|\fIwildcard\fR] |
| 113 | | Displays a list of driver names and descriptions in tree format. |
| 114 | | Clones are listed under their parent sets, and drivers are grouped |
| 115 | | together with their "brothers" from the same sourcefile. By default |
| 116 | | all games are listed; however, you can limit this list by specifying a |
| 117 | | driver name or wildcard. |
| 118 | | .TP |
| 119 | 110 | .B \-listcrc |
| 120 | 111 | Displays a full list of CRCs of all ROM images referenced by all |
| 121 | 112 | drivers within MAME code. |
trunk/src/osd/sdl/man/mess.6
| r253726 | r253727 | |
| 113 | 113 | driver name or wildcard. |
| 114 | 114 | .TP |
| 115 | 115 | .B \-listsource, \-ls \fR[\fIsystem\fR|\fIwildcard\fR] |
| 116 | | Displays a list of drivers, the names of the source files their system |
| 117 | | drivers live in, and their parent sets and BIOS roots, if any. These |
| 118 | | are listed in the form of wildcards that will match all drivers with |
| 119 | | similar properties. By default all systems are listed; however, you |
| 120 | | can limit this list by specifying a driver name or wildcard after the |
| 121 | | \-listsource command. |
| 116 | Displays a list of drivers and the names of the source files their system |
| 117 | drivers live in. Useful for finding which driver a system runs on in |
| 118 | order to fix bugs. By default all systems are listed; however, you can |
| 119 | limit this list by specifying a driver name or wildcard. |
| 122 | 120 | .TP |
| 123 | 121 | .B \-listclones, \-lc \fR[\fIsystem\fR|\fIwildcard\fR] |
| 124 | | Displays a list of clones, sorted under their parent sets. By default |
| 125 | | all drivers are listed; however, you can limit this list to clones of |
| 126 | | certain drivers by specifying a name or wildcard after the \-listclones |
| 127 | | command. |
| 122 | Displays a list of clones. By default all clones are listed; however, |
| 123 | you can limit this list by specifying a driver name or wildcard. |
| 128 | 124 | .TP |
| 129 | 125 | .B \-listbrothers, \-lb \fR[\fIsystem\fR|\fIwildcard\fR] |
| 130 | 126 | Displays a list of "brothers" or other drivers from same sourcefile. |
| 131 | 127 | By default all systems are listed; however, you can limit this list by |
| 132 | 128 | specifying a driver name or wildcard. |
| 133 | 129 | .TP |
| 134 | | .B \-listtree, \-lt \fR[\fIsystem\fR|\fIwildcard\fR] |
| 135 | | Displays a list of driver names and descriptions in tree format. |
| 136 | | Clones are listed under their parent sets, and drivers are grouped |
| 137 | | together with their "brothers" from the same sourcefile. By default |
| 138 | | all systems are listed; however, you can limit this list by specifying |
| 139 | | a driver name or wildcard. |
| 140 | | .TP |
| 141 | 130 | .B \-listcrc |
| 142 | 131 | Displays a full list of CRCs of all ROM images referenced by all |
| 143 | 132 | drivers within MESS code. |
| r253726 | r253727 | |
| 185 | 174 | .B \-listsoftware, \-lsoft |
| 186 | 175 | Output the list of known software for the system. |
| 187 | 176 | .TP |
| 188 | | .B \-verifysoftware, \-vsoft \fR[\fIsystem\fR|\fIwildcard\fR] |
| 177 | .B \-verifysoftware, \-vsoft \fR[\fIgamename\fR|\fIwildcard\fR] |
| 189 | 178 | Checks for invalid or missing ROM images in your software lists. |
| 190 | 179 | By default all drivers that have valid ZIP files or directories |
| 191 | 180 | in the rompath are verified; however, you can limit this list by |