src/interface/romtype.cpp

   1 #include "core/misc.hpp"
   2 #include "interface/romtype.hpp"
   3 #include "interface/callbacks.hpp"
   4 #include "library/minmax.hpp"
   5 #include "library/string.hpp"
   6 #include <set>
   7 #include <map>
   8 #include <string>
   9 #include <algorithm>
  10 #include <cctype>
  11 #include <stdexcept>
  12 #include <list>
  13 #include <limits>
  14
  15 namespace
  16 {
  17         bool install_handlers_automatically;
  18
  19         std::map<std::string, std::string>& sysreg_mapping()
  20         {
  21                 static std::map<std::string, std::string> x;
  22                 return x;
  23         }
  24
  25         std::set<core_core*>& all_cores_set()
  26         {
  27                 static std::set<core_core*> x;
  28                 return x;
  29         }
  30
  31         std::set<core_core*>& uninitialized_cores_set()
  32         {
  33                 static std::set<core_core*> x;
  34                 return x;
  35         }
  36
  37         std::multimap<std::string, core_sysregion*>& sysregions()
  38         {
  39                 static std::multimap<std::string, core_sysregion*> x;
  40                 return x;
  41         }
  42
  43         std::set<core_type*>& types()
  44         {
  45                 static std::set<core_type*> x;
  46                 return x;
  47         }
  48
  49         bool compare_coretype(core_type* a, core_type* b)
  50         {
  51                 return (a->get_id() < b->get_id());
  52         }
  53
  54         bool compare_regions(core_region* a, core_region* b)
  55         {
  56                 return (a->get_handle() < b->get_handle());
  57         }
  58 }
  59
  60 bool interface_action::is_toggle() const
  61 {
  62         for(auto i : params)
  63                 if(!strcmp(i.model, "toggle"))
  64                         return true;
  65         return false;
  66 }
  67
  68 core_region::core_region(const core_region_params& params)
  69 {
  70         iname = params.iname;
  71         hname = params.hname;
  72         multi = params.multi;
  73         handle = params.handle;
  74         priority = params.priority;
  75         magic[0] = params.framemagic[0];
  76         magic[1] = params.framemagic[1];
  77         magic[2] = 1000 * params.framemagic[0] / params.framemagic[1];
  78         magic[3] = 1000 * params.framemagic[0] % params.framemagic[1];
  79         compatible = params.compatible_runs;
  80 }
  81
  82
  83 bool core_region::compatible_with(core_region& run)
  84 {
  85         for(auto i : compatible)
  86                 if(i == run.handle)
  87                         return true;
  88         return false;
  89 }
  90
  91 bool core_region::is_multi()
  92 {
  93         return multi;
  94 }
  95
  96 const std::string& core_region::get_iname()
  97 {
  98         return iname;
  99 }
 100
 101 const std::string& core_region::get_hname()
 102 {
 103         return hname;
 104 }
 105
 106 unsigned core_region::get_priority()
 107 {
 108         return priority;
 109 }
 110
 111 unsigned core_region:: get_handle()
 112 {
 113         return handle;
 114 }
 115
 116 void core_region::fill_framerate_magic(uint64_t* _magic)
 117 {
 118         for(size_t i = 0; i < 4; i++)
 119                 _magic[i] = magic[i];
 120 }
 121
 122 double core_region::approx_framerate()
 123 {
 124         return (double)magic[1] / magic[0];
 125 }
 126
 127 core_romimage_info::core_romimage_info(const core_romimage_info_params& params)
 128 {
 129         iname = params.iname;
 130         hname = params.hname;
 131         mandatory = params.mandatory;
 132         pass_mode = params.pass_mode;
 133         headersize = params.headersize;
 134         if(params.extensions) {
 135                 std::string tmp = params.extensions;
 136                 for(auto& ext : token_iterator_foreach(tmp, {";"}))
 137                         extensions.insert(ext);
 138         }
 139 }
 140
 141 size_t core_romimage_info::get_headnersize(size_t imagesize)
 142 {
 143         if(headersize && imagesize % (2 * headersize) == headersize)
 144                 return headersize;
 145         return 0;
 146 }
 147
 148 core_type::core_type(const core_type_params& params)
 149         : settings(params.settings)
 150 {
 151         iname = params.iname;
 152         hname = params.hname;
 153         sysname = params.sysname;
 154         id = params.id;
 155         core = params.core;
 156         if(params.bios)
 157                 biosname = params.bios;
 158         for(auto i : params.regions)
 159                 regions.push_back(i);
 160         imageinfo = params.images.get();
 161         types().insert(this);
 162 }
 163
 164 core_type::~core_type() throw()
 165 {
 166         types().erase(this);
 167 }
 168
 169 unsigned core_type::get_id()
 170 {
 171         return id;
 172 }
 173
 174 const std::string& core_type::get_iname()
 175 {
 176         return iname;
 177 }
 178
 179 const std::string& core_type::get_hname()
 180 {
 181         return hname;
 182 }
 183
 184 unsigned core_type::get_image_count()
 185 {
 186         return imageinfo.size();
 187 }
 188
 189 core_setting_group& core_type::get_settings()
 190 {
 191         return settings;
 192 }
 193
 194 core_romimage_info core_type::get_image_info(unsigned index)
 195 {
 196         if(index >= imageinfo.size())
 197                 throw std::runtime_error("Requested invalid image index");
 198         return imageinfo[index];
 199 }
 200
 201 std::list<core_type*> core_type::get_core_types()
 202 {
 203         std::list<core_type*> ret;
 204         for(auto i : types())
 205                 ret.push_back(i);
 206         ret.sort(compare_coretype);
 207         return ret;
 208 }
 209
 210 std::list<core_region*> core_type::get_regions()
 211 {
 212         std::list<core_region*> ret = regions;
 213         ret.sort(compare_regions);
 214         return ret;
 215 }
 216
 217 core_region& core_type::get_preferred_region()
 218 {
 219         core_region* p = NULL;
 220         unsigned cutoff = 0;
 221         for(auto i : regions) {
 222                 unsigned pri = i->get_priority();
 223                 if(pri >= cutoff) {
 224                         cutoff = max(pri + 1, pri);
 225                         p = i;
 226                 }
 227         }
 228         return *p;
 229 }
 230
 231 bool core_type::load(core_romimage* images, std::map<std::string, std::string>& settings, uint64_t rtc_sec,
 232         uint64_t rtc_subsec)
 233 {
 234         return (t_load_rom(images, settings, rtc_sec, rtc_subsec) >= 0);
 235 }
 236
 237 core_sysregion& core_type::combine_region(core_region& reg)
 238 {
 239         for(auto i : sysregions())
 240                 if(&(i.second->get_type()) == this && &(i.second->get_region()) == &reg)
 241                         return *(i.second);
 242         throw std::runtime_error("Invalid region for system type");
 243 }
 244
 245 std::list<std::string> core_type::get_extensions()
 246 {
 247         static std::list<std::string> empty;
 248         unsigned base = (biosname != "") ? 1 : 0;
 249         if(imageinfo.size() <= base)
 250                 return empty;
 251         auto s = imageinfo[base].extensions;
 252         std::list<std::string> ret;
 253         for(auto i : s)
 254                 ret.push_back(i);
 255         return ret;
 256 }
 257
 258 std::string core_type::get_biosname()
 259 {
 260         return biosname;
 261 }
 262
 263 bool core_type::is_known_extension(const std::string& ext)
 264 {
 265         std::string _ext = ext;
 266         std::transform(_ext.begin(), _ext.end(), _ext.begin(), ::tolower);
 267         for(auto i : get_extensions())
 268                 if(i == _ext)
 269                         return true;
 270         return false;
 271 }
 272
 273 controller_set core_type::controllerconfig(std::map<std::string, std::string>& settings)
 274 {
 275         return t_controllerconfig(settings);
 276 }
 277
 278 std::pair<uint64_t, uint64_t> core_core::get_bus_map()
 279 {
 280         return c_get_bus_map();
 281 }
 282
 283 double core_core::get_PAR()
 284 {
 285         return c_get_PAR();
 286 }
 287
 288 std::list<core_vma_info> core_core::vma_list()
 289 {
 290         return c_vma_list();
 291 }
 292
 293 std::set<std::string> core_core::srams()
 294 {
 295         return c_srams();
 296 }
 297
 298 bool core_core::isnull()
 299 {
 300         return c_isnull();
 301 }
 302
 303 std::pair<unsigned, unsigned> core_core::lightgun_scale()
 304 {
 305         return c_lightgun_scale();
 306 }
 307
 308 std::pair<unsigned, unsigned> core_core::c_lightgun_scale()
 309 {
 310         return std::make_pair(0, 0);
 311 }
 312
 313 void core_core::debug_reset()
 314 {
 315         return c_debug_reset();
 316 }
 317
 318 bool core_core::c_isnull()
 319 {
 320         return false;
 321 }
 322
 323 core_sysregion::core_sysregion(const std::string& _name, core_type& _type, core_region& _region)
 324         : name(_name), type(_type), region(_region)
 325 {
 326         sysregions().insert(std::make_pair(_name, this));
 327 }
 328
 329 core_sysregion::~core_sysregion() throw()
 330 {
 331         for(auto i = sysregions().begin(); i != sysregions().end(); i++)
 332                 if(i->second == this) {
 333                         sysregions().erase(i);
 334                         break;
 335                 }
 336 }
 337
 338 core_sysregion& core_type::lookup_sysregion(const std::string& sysreg)
 339 {
 340         for(auto i : sysregions())
 341                 if(i.first == sysreg && &i.second->get_type() == this)
 342                         return *i.second;
 343         throw std::runtime_error("Bad system-region type");
 344 }
 345
 346 const std::string& core_sysregion::get_name()
 347 {
 348         return name;
 349 }
 350
 351 core_region& core_sysregion::get_region()
 352 {
 353         return region;
 354 }
 355
 356 core_type& core_sysregion::get_type()
 357 {
 358         return type;
 359 }
 360
 361 void core_sysregion::fill_framerate_magic(uint64_t* magic)
 362 {
 363         region.fill_framerate_magic(magic);
 364 }
 365
 366 core_core::core_core(std::initializer_list<port_type*> ports, std::initializer_list<interface_action> x_actions)
 367 {
 368         for(auto i : ports)
 369                 port_types.push_back(i);
 370         for(auto i : x_actions)
 371                 actions[i._symbol] = i;
 372
 373         hidden = false;
 374         uninitialized_cores_set().insert(this);
 375         all_cores_set().insert(this);
 376         new_core_flag = true;
 377 }
 378
 379 core_core::core_core(std::vector<port_type*> ports, std::vector<interface_action> x_actions)
 380 {
 381         for(auto i : ports)
 382                 port_types.push_back(i);
 383         for(auto i : x_actions)
 384                 actions[i._symbol] = i;
 385
 386         hidden = false;
 387         uninitialized_cores_set().insert(this);
 388         all_cores_set().insert(this);
 389         new_core_flag = true;
 390 }
 391
 392 core_core::~core_core() throw()
 393 {
 394         all_cores().erase(this);
 395 }
 396
 397 void core_core::initialize_new_cores()
 398 {
 399         for(auto i : uninitialized_cores_set())
 400                 i->install_handler();
 401         uninitialized_cores_set().clear();
 402 }
 403
 404 std::string core_core::get_core_shortname()
 405 {
 406         return c_get_core_shortname();
 407 }
 408
 409 bool core_core::set_region(core_region& region)
 410 {
 411         return c_set_region(region);
 412 }
 413
 414 std::pair<uint32_t, uint32_t> core_core::get_video_rate()
 415 {
 416         return c_video_rate();
 417 }
 418
 419 std::pair<uint32_t, uint32_t> core_core::get_audio_rate()
 420 {
 421         return c_audio_rate();
 422 }
 423
 424 std::string core_core::get_core_identifier()
 425 {
 426         return c_core_identifier();
 427 }
 428
 429 std::set<core_core*> core_core::all_cores()
 430 {
 431         return all_cores_set();
 432 }
 433
 434 void core_core::install_all_handlers()
 435 {
 436         install_handlers_automatically = true;
 437         for(auto i : all_cores_set())
 438                 i->install_handler();
 439 }
 440
 441 void core_core::uninstall_all_handlers()
 442 {
 443         install_handlers_automatically = false;
 444         for(auto i : all_cores_set())
 445                 i->uninstall_handler();
 446 }
 447
 448 std::map<std::string, std::vector<char>> core_core::save_sram() throw(std::bad_alloc)
 449 {
 450         return c_save_sram();
 451 }
 452
 453 void core_core::load_sram(std::map<std::string, std::vector<char>>& sram) throw(std::bad_alloc)
 454 {
 455         c_load_sram(sram);
 456 }
 457
 458 void core_core::serialize(std::vector<char>& out)
 459 {
 460         c_serialize(out);
 461 }
 462
 463 void core_core::unserialize(const char* in, size_t insize)
 464 {
 465         c_unserialize(in, insize);
 466 }
 467
 468 core_region& core_core::get_region()
 469 {
 470         return c_get_region();
 471 }
 472
 473 void core_core::power()
 474 {
 475         c_power();
 476 }
 477
 478 void core_core::unload_cartridge()
 479 {
 480         c_unload_cartridge();
 481 }
 482
 483 std::pair<uint32_t, uint32_t> core_core::get_scale_factors(uint32_t width, uint32_t height)
 484 {
 485         return c_get_scale_factors(width, height);
 486 }
 487
 488 void core_core::install_handler()
 489 {
 490         c_install_handler();
 491 }
 492
 493 void core_core::uninstall_handler()
 494 {
 495         c_uninstall_handler();
 496 }
 497
 498 void core_core::emulate()
 499 {
 500         c_emulate();
 501 }
 502
 503 void core_core::runtosave()
 504 {
 505         c_runtosave();
 506 }
 507
 508 bool core_core::get_pflag()
 509 {
 510         return c_get_pflag();
 511 }
 512
 513 void core_core::set_pflag(bool pflag)
 514 {
 515         return c_set_pflag(pflag);
 516 }
 517
 518 framebuffer::raw& core_core::draw_cover()
 519 {
 520         return c_draw_cover();
 521 }
 522
 523 void core_core::pre_emulate_frame(controller_frame& cf)
 524 {
 525         c_pre_emulate_frame(cf);
 526 }
 527
 528 void core_core::execute_action(unsigned id, const std::vector<interface_action_paramval>& p)
 529 {
 530         return c_execute_action(id, p);
 531 }
 532
 533 const struct interface_device_reg* core_core::get_registers()
 534 {
 535         return c_get_registers();
 536 }
 537
 538 unsigned core_core::action_flags(unsigned id)
 539 {
 540         return c_action_flags(id);
 541 }
 542
 543 std::set<const interface_action*> core_core::get_actions()
 544 {
 545         threads::alock h(actions_lock);
 546         std::set<const interface_action*> r;
 547         for(auto& i : actions)
 548                 r.insert(&i.second);
 549         return r;
 550 }
 551
 552 int core_core::reset_action(bool hard)
 553 {
 554         return c_reset_action(hard);
 555 }
 556
 557 void core_core::set_debug_flags(uint64_t addr, unsigned flags_set, unsigned flags_clear)
 558 {
 559         return c_set_debug_flags(addr, flags_set, flags_clear);
 560 }
 561
 562 void core_core::set_cheat(uint64_t addr, uint64_t value, bool set)
 563 {
 564         return c_set_cheat(addr, value, set);
 565 }
 566
 567 std::vector<std::string> core_core::get_trace_cpus()
 568 {
 569         return c_get_trace_cpus();
 570 }
 571
 572 emucore_callbacks::~emucore_callbacks() throw()
 573 {
 574 }
 575
 576 core_romimage_info_collection::core_romimage_info_collection()
 577 {
 578 }
 579
 580 core_romimage_info_collection::core_romimage_info_collection(std::initializer_list<core_romimage_info_params> idata)
 581 {
 582         for(auto i : idata)
 583                 data.push_back(core_romimage_info(i));
 584 }
 585
 586 core_romimage_info_collection::core_romimage_info_collection(std::vector<core_romimage_info_params> idata)
 587 {
 588         for(auto i : idata)
 589                 data.push_back(core_romimage_info(i));
 590 }
 591
 592 std::set<core_sysregion*> core_sysregion::find_matching(const std::string& name)
 593 {
 594         std::set<core_sysregion*> ret;
 595         auto u = sysregions().upper_bound(name);
 596         for(auto i = sysregions().lower_bound(name); i != u; ++i)
 597                 ret.insert(i->second);
 598         return ret;
 599 }
 600
 601 void register_sysregion_mapping(std::string from, std::string to)
 602 {
 603         sysreg_mapping()[from] = to;
 604 }
 605
 606 std::string lookup_sysregion_mapping(std::string from)
 607 {
 608         if(sysreg_mapping().count(from))
 609                 return sysreg_mapping()[from];
 610         else
 611                 return "";
 612 }
 613
 614 struct emucore_callbacks* ecore_callbacks;
 615
 616 bool new_core_flag = false;
 617 uint32_t magic_flags = 0;