v110

Corrections for IOKit joypad driver [Sintendo]

.cirrus.yml

@@ -0,0 +1,81 @@
+linux-x86_64-binaries_task:
+    container:
+        image: ubuntu:latest
+
+    setup_script:
+        - apt-get update && apt-get -y install build-essential libgtk2.0-dev libpulse-dev mesa-common-dev libgtksourceview2.0-dev libcairo2-dev libsdl2-dev libxv-dev libao-dev libopenal-dev libudev-dev zip
+
+    compile_script:
+        - make -C bsnes local=false
+
+    package_script:
+        - mkdir bsnes-nightly
+        - mkdir bsnes-nightly/Database
+        - mkdir bsnes-nightly/Firmware
+        - cp -a bsnes/out/bsnes bsnes-nightly/bsnes
+        - cp -a bsnes/Database/* bsnes-nightly/Database
+        - cp -a GPLv3.txt bsnes-nightly
+        - zip -r bsnes-nightly.zip bsnes-nightly
+
+    bsnes-nightly_artifacts:
+        path: "bsnes-nightly.zip"
+
+freebsd-x86_64-binaries_task:
+    freebsd_instance:
+        image: freebsd-12-0-release-amd64
+
+    setup_script:
+        - pkg install --yes gmake gdb gcc8 pkgconf sdl2 openal-soft gtksourceview2 libXv zip
+
+    compile_script:
+        - gmake -C bsnes local=false
+
+    package_script:
+        - mkdir bsnes-nightly
+        - mkdir bsnes-nightly/Database
+        - mkdir bsnes-nightly/Firmware
+        - cp -a bsnes/out/bsnes bsnes-nightly/bsnes
+        - cp -a bsnes/Database/* bsnes-nightly/Database
+        - cp -a GPLv3.txt bsnes-nightly
+        - zip -r bsnes-nightly.zip bsnes-nightly
+
+    bsnes-nightly_artifacts:
+        path: "bsnes-nightly.zip"
+
+windows-x86_64-binaries_task:
+    container:
+        image: ubuntu:latest
+
+    setup_script:
+        - apt-get update && apt-get -y install build-essential mingw-w64 zip
+
+    compile_script:
+        - make -C bsnes local=false platform=windows compiler="x86_64-w64-mingw32-g++" windres="x86_64-w64-mingw32-windres"
+
+    package_script:
+        - mkdir bsnes-nightly
+        - mkdir bsnes-nightly/Database
+        - mkdir bsnes-nightly/Firmware
+        - cp -a bsnes/out/bsnes bsnes-nightly/bsnes.exe
+        - cp -a bsnes/Database/* bsnes-nightly/Database
+        - cp -a GPLv3.txt bsnes-nightly
+        - zip -r bsnes-nightly.zip bsnes-nightly
+
+    bsnes-nightly_artifacts:
+        path: "bsnes-nightly.zip"
+
+macOS-x86_64-binaries_task:
+    osx_instance:
+        image: mojave-base
+
+    compile_script:
+        - make -C bsnes local=false
+
+    package_script:
+        - mkdir bsnes-nightly
+        - cp -a bsnes/out/bsnes.app bsnes-nightly
+        - cp -a GPLv3.txt bsnes-nightly
+        - zip -r bsnes-nightly.zip bsnes-nightly
+
+    bsnes-nightly_artifacts:
+        path: "bsnes-nightly.zip"

.github/FUNDING.yml

@@ -0,0 +1 @@
+patreon: byuu

GPLv3.txt

@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<https://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<https://www.gnu.org/licenses/why-not-lgpl.html>.

LICENSE.txt

@@ -0,0 +1,43 @@
+----------------------------------------------------------------------
+bsnes - Super Nintendo emulator
+
+  Copyright © 2004-2019 byuu
+
+  https://byuu.org
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, specifically version 3 of the License
+and no other version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program. If not, see <https://www.gnu.org/licenses/>.
+----------------------------------------------------------------------
+
+----------------------------------------------------------------------
+libco - C cooperative threading library
+nall  - C++ template library
+ruby  - Hardware abstraction library
+hiro  - User interface library
+
+  Copyright © 2006-2019 byuu
+
+Permission to use, copy, modify, and/or distribute this software for
+any purpose with or without fee is hereby granted, provided that the
+above copyright notice and this permission notice appear in all
+copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+----------------------------------------------------------------------

README.md

@@ -0,0 +1,81 @@
+bsnes
+=====
+
+bsnes is a multi-platform Super Nintendo (Super Famicom) emulator that focuses
+on performance, features, and ease of use.
+
+bsnes currently enjoys 100% known, bug-free compatibility with the entire SNES
+library when configured to its most accurate settings, giving it the same
+accuracy level as higan. Accuracy can also optionally be traded for performance,
+allowing bsnes to operate more than 300% faster than higan while still remaining
+almost as accurate.
+
+Development
+-----------
+
+Git is used for the development of new releases, and represents a staging
+environment. As bsnes is rather mature, things should generally be quite stable.
+However, bugs will exist, regressions will occur, so proceed at your own risk.
+
+If stability is required, please download the latest stable release from the
+[official website.](https://bsnes.byuu.org)
+
+Unique Features
+---------------
+
+  - 100% (known) bug-free compatibility with the entire officially licensed SNES games library
+  - True Super Game Boy emulation (using the SameBoy core by Lior Halphon)
+  - HD mode 7 graphics with optional supersampling (by DerKoun)
+  - Low-level emulation of all SNES coprocessors (DSP-n, ST-01n, Cx4)
+  - Multi-threaded PPU graphics renderer
+  - Speed mode settings which retain smooth audio output (50%, 75%, 100%, 150%, 200%)
+  - Built-in games database with thousands of game entries
+  - Built-in cheat code database for hundreds of popular games (by mightymo)
+  - Built-in save state manager with screenshot previews and naming capabilities
+  - Support for ASIO low-latency audio
+  - Customizable per-byte game mappings to support any cartridges, including prototype games
+  - 7-zip decompression support
+  - Extensive Satellaview emulation, including BS Memory flash write and wear-leveling emulation
+  - 30-bit color output support (where supported)
+  - Optional higan game folder support (standard game ROM files are also fully supported!)
+
+Standard Features
+-----------------
+
+  - MSU1 support
+  - BPS and IPS soft-patching support
+  - Save states with undo and redo support (for reverting accidental saves and loads)
+  - OpenGL multi-pass pixel shaders
+  - Several built-in software filters, including HQ2x (by MaxSt) and snes_ntsc (by blargg)
+  - Adaptive sync and dynamic rate control for perfect audio/video synchronization
+  - Just-in-time input polling for minimal input latency
+  - Support for Direct3D exclusive mode video
+  - Support for WASAPI exclusive mode audio
+  - Periodic auto-saving of game saves
+  - Auto-saving of states when unloading games, and auto-resuming of states when reloading games
+  - Sprite limit disable support
+  - Cubic audio interpolation support
+  - Optional high-level emulation of most SNES coprocessors
+  - CPU, SA1, and SuperFX overclocking support
+  - Frame advance support
+  - Screenshot support
+  - Cheat code search support
+  - Movie recording and playback support
+  - Rewind support
+  - HiDPI support
+
+Links
+-----
+
+  - [Official website](https://bsnes.byuu.org)
+  - [Official git repository](https://github.com/byuu/bsnes)
+  - [Donations](https://patreon.com/byuu)
+
+Nightly Builds
+--------------
+
+  - [Download](https://cirrus-ci.com/github/byuu/bsnes/master)
+  - ![Build status](https://api.cirrus-ci.com/github/byuu/bsnes.svg?task=windows-x86_64-binaries)
+  - ![Build status](https://api.cirrus-ci.com/github/byuu/bsnes.svg?task=macOS-x86_64-binaries)
+  - ![Build status](https://api.cirrus-ci.com/github/byuu/bsnes.svg?task=linux-x86_64-binaries)
+  - ![Build status](https://api.cirrus-ci.com/github/byuu/bsnes.svg?task=freebsd-x86_64-binaries)

bsnes/Database/BS Memory.bml

@@ -0,0 +1,44 @@
+database
+  revision: 2018-09-20
+
+//BS Memory (JPN)
+
+database
+  revision: 2018-04-14
+
+game
+  sha256:   80c34b50817d58820bc8c88d2d9fa462550b4a76372e19c6467cbfbc8cf5d9ef
+  label:    鮫亀 キャラカセット
+  name:     Same Game - Chara Cassette
+  region:   BSMC-ZS5J-JPN
+  revision: BSMC-ZS5J-0
+  board:    BSMC-CR-01
+    memory
+      type: ROM
+      size: 0x80000
+      content: Program
+
+game
+  sha256:   859c7f7b4771d920a5bdb11f1d247ab6b43fb026594d1062f6f72d32cd340a0a
+  label:    鮫亀 キャラデータ集
+  name:     Same Game - Chara Data Shuu
+  region:   BSMC-YS5J-JPN
+  revision: BSMC-YS5J-0
+  board:    BSMC-CR-01
+    memory
+      type: ROM
+      size: 0x80000
+      content: Program
+
+game
+  sha256:   c92a15fdd9b0133f9ea69105d0230a3acd1cdeef98567462eca86ea02a959e4e
+  label:    SDガンダム ジーネクスト ユニット&マップコレクション
+  name:     SD Gundam G Next - Unit & Map Collection
+  region:   BSMC-ZX3J-JPN
+  revision: BSMC-ZX3J-0
+  board:    BSMC-BR-01
+    memory
+      type: ROM
+      size: 0x80000
+      content: Program
+

bsnes/Database/Sufami Turbo.bml

@@ -0,0 +1,213 @@
+database
+  revision: 2018-09-20
+
+//Sufami Turbo (JPN)
+
+database
+  revision: 2018-04-14
+
+game
+  sha256:   f73bda08743565e0bd101632ebbac2d363d703a3ab39d23f49d95217cab29269
+  label:    美少女戦士セーラームーン セーラースターズ ふわふわパニック2
+  name:     Bishoujo Senshi Sailor Moon Sailor Stars - Fuwafuwa Panic 2
+  region:   SFT-0112-JPN
+  revision: SAILOR MOON
+  board:    PT-911
+    memory
+      type: ROM
+      size: 0x100000
+      content: Program
+  note: Unlinkable
+
+game
+  sha256:   afb3f2a83b5bfcb1b8829b6995f108cc4d64ca322d1ba4a50b83af6e1f2e89bd
+  label:    クレヨンしんちゃん 長ぐつドボン!!
+  name:     Crayon Shin-chan - Nagagutsu Dobon!!
+  region:   SFT-0113-JPN
+  revision: SHINCYAN
+  board:    PT-911
+    memory
+      type: ROM
+      size: 0x80000
+      content: Program
+  note: Unlinkable
+
+game
+  sha256:   d93b3a570e7cf343f680ab0768a50b77e3577f9c555007e2de3decd6bc4765c8
+  label:    ゲゲゲの鬼太郎 妖怪ドンジャラ
+  name:     Gegege no Kitarou - Youkai Donjara
+  region:   SFT-0106-JPN
+  revision: KITARO DONJYAR
+  board:    PT-911
+    memory
+      type: ROM
+      size: 0x80000
+      content: Program
+  note: Unlinkable
+
+game
+  sha256:   89aecd4e23d8219c8de3e71bb75db3dfe667d51c1eba4ea7239d2f772743d0cc
+  label:    激走戦隊カーレンジャ 全開!レーサー戦士
+  name:     Gekisou Sentai Carranger - Zenkai! Racer Senshi
+  region:   SFT-0109-JPN
+  revision: CAR RANGER
+  board:    PT-911
+    memory
+      type: ROM
+      size: 0x80000
+      content: Program
+  note: Unlinkable
+
+game
+  sha256:   602b20b788640f5743487108a10f3f77bca5ce2d24208b25b1ca498a96eb0d69
+  label:    ぽいぽい忍者ワールド
+  name:     Poi Poi Ninja World
+  region:   SFT-0103-JPN
+  revision: POI POI NINJYA
+  board:    PT-911
+    memory
+      type: ROM
+      size: 0x80000
+      content: Program
+    memory
+      type: RAM
+      size: 0x800
+      content: Save
+  note: Linkable: SFT-0103-JPN
+
+game
+  sha256:   2a9d7c9a61318861028a73ca03e32a48cff162d76cba36fbaab8690b212efe9b
+  label:    SDガンダムジェネレーション アクシズ戦記
+  name:     SD Gundam Generation - Axis Senki
+  region:   SFT-0107-JPN
+  revision: GUNDAM C
+  board:    PT-912
+    memory
+      type: ROM
+      size: 0x80000
+      content: Program
+    memory
+      type: RAM
+      size: 0x2000
+      content: Save
+  note: Linkable: SFT-0104-JPN, SFT-0105-JPN, SFT-0107-JPN, SFT-0108-JPN, SFT-0110-JPN, SFT-0111-JPN
+
+game
+  sha256:   60ac017c18f534e8cf24ca7f38e22ce92db95ea6c30b2d59d76f13c4f1c8a6e4
+  label:    SDガンダムジェネレーション バビロニア建国戦記
+  name:     SD Gundam Generation - Babylonia Kenkoku Senki
+  region:   SFT-0108-JPN
+  revision: GUNDAM D
+  board:    PT-912
+    memory
+      type: ROM
+      size: 0x80000
+      content: Program
+    memory
+      type: RAM
+      size: 0x2000
+      content: Save
+  note: Linkable: SFT-0104-JPN, SFT-0105-JPN, SFT-0107-JPN, SFT-0108-JPN, SFT-0110-JPN, SFT-0111-JPN
+
+game
+  sha256:   e639b5d5d722432b6809ccc6801dc584e1a3016379f34b335ed2dfa73b1ebf69
+  label:    SDガンダムジェネレーション コロニー格闘記
+  name:     SD Gundam Generation - Colony Kakutouki
+  region:   SFT-0111-JPN
+  revision: GUNDAM F
+  board:    PT-912
+    memory
+      type: ROM
+      size: 0x80000
+      content: Program
+    memory
+      type: RAM
+      size: 0x2000
+      content: Save
+  note: Linkable: SFT-0104-JPN, SFT-0105-JPN, SFT-0107-JPN, SFT-0108-JPN, SFT-0110-JPN, SFT-0111-JPN
+
+game
+  sha256:   8547a08ed11fe408eac282a90ac46654bd2e5f49bda3aec8e5edf166a0a4b9af
+  label:    SDガンダムジェネレーション グリプス戦記
+  name:     SD Gundam Generation - Gryps Senki
+  region:   SFT-0105-JPN
+  revision: GUNDAM B
+  board:    PT-912
+    memory
+      type: ROM
+      size: 0x80000
+      content: Program
+    memory
+      type: RAM
+      size: 0x2000
+      content: Save
+  note: Linkable: SFT-0104-JPN, SFT-0105-JPN, SFT-0107-JPN, SFT-0108-JPN, SFT-0110-JPN, SFT-0111-JPN
+
+game
+  sha256:   3e82215bed08274874b30d461fc4a965c6bca932229da5d46d56e36f484d65eb
+  label:    SDガンダムジェネレーション 一年戦争記
+  name:     SD Gundam Generation - Ichinen Sensouki
+  region:   SFT-0104-JPN
+  revision: GUNDAM A
+  board:    PT-912
+    memory
+      type: ROM
+      size: 0x80000
+      content: Program
+    memory
+      type: RAM
+      size: 0x2000
+      content: Save
+  note: Linkable: SFT-0104-JPN, SFT-0105-JPN, SFT-0107-JPN, SFT-0108-JPN, SFT-0110-JPN, SFT-0111-JPN
+
+game
+  sha256:   5951a58a91d8e397d0a237ccc2b1248e17c7312cb9cc11cbc350200a97b4e021
+  label:    SDガンダムジェネレーション ザンスカール戦記
+  name:     SD Gundam Generation - Zanscare Senki
+  region:   SFT-0110-JPN
+  revision: GUNDAM E
+  board:    PT-912
+    memory
+      type: ROM
+      size: 0x80000
+      content: Program
+    memory
+      type: RAM
+      size: 0x2000
+      content: Save
+  note: Linkable: SFT-0104-JPN, SFT-0105-JPN, SFT-0107-JPN, SFT-0108-JPN, SFT-0110-JPN, SFT-0111-JPN
+
+game
+  sha256:   2fec5f2bc7dee010af10569a3d2bc18715a79a126940800c3eade5abbd625e3f
+  label:    SDウルトラバトル セブン伝説
+  name:     SD Ultra Battle - Seven Densetsu
+  region:   SFT-0102-JPN
+  revision: ULTRA SEVEN 1
+  board:    PT-911
+    memory
+      type: ROM
+      size: 0x80000
+      content: Program
+    memory
+      type: RAM
+      size: 0x800
+      content: Save
+  note: Linkable: SFT-0101-JPN, SFT-0102-JPN
+
+game
+  sha256:   2bb55214fb668ca603d7b944b14f105dfb10b987a8902d420fe4ae1cb69c1d4a
+  label:    SDウルトラバトル ウルトラマン伝説
+  name:     SD Ultra Battle - Ultraman Densetsu
+  region:   SFT-0101-JPN
+  revision: ULTRA MAN 1
+  board:    PT-911
+    memory
+      type: ROM
+      size: 0x80000
+      content: Program
+    memory
+      type: RAM
+      size: 0x800
+      content: Save
+  note: Linkable: SFT-0101-JPN, SFT-0102-JPN
+

bsnes/GNUmakefile

@@ -0,0 +1,66 @@
+target := bsnes
+binary := application
+build := performance
+openmp := true
+local := true
+flags += -I. -I..
+
+# in order for this to work, obj/lzma.o must be omitted or bsnes will hang on startup.
+# further, only the X-Video driver works reliably. OpenGL 3.2, OpenGL 2.0, and XShm crash bsnes.
+ifeq ($(profile),true)
+  flags += -pg
+  options += -pg
+endif
+
+# binaries built with this flag are faster, but are not portable to multiple machines.
+ifeq ($(local),true)
+  flags += -march=native
+endif
+
+nall.path := ../nall
+include $(nall.path)/GNUmakefile
+
+ifeq ($(platform),windows)
+  ifeq ($(binary),application)
+    options += -luuid -lkernel32 -luser32 -lgdi32 -lcomctl32 -lcomdlg32 -lshell32
+    options += -Wl,-enable-auto-import
+    options += -Wl,-enable-runtime-pseudo-reloc
+  else ifeq ($(binary),library)
+    options += -shared
+  endif
+else ifeq ($(platform),macos)
+  ifeq ($(binary),application)
+  else ifeq ($(binary),library)
+    flags += -fPIC
+    options += -dynamiclib
+  endif
+else ifneq ($(filter $(platform),linux bsd),)
+  ifeq ($(binary),application)
+    options += -Wl,-export-dynamic
+    options += -lX11 -lXext
+  else ifeq ($(binary),library)
+    flags += -fPIC
+    options += -shared
+  endif
+else
+  $(error "unsupported platform")
+endif
+
+objects := libco emulator filter lzma
+
+obj/libco.o: ../libco/libco.c
+obj/emulator.o: emulator/emulator.cpp
+obj/filter.o: filter/filter.cpp
+obj/lzma.o: lzma/lzma.cpp
+
+include sfc/GNUmakefile
+include gb/GNUmakefile
+include processor/GNUmakefile
+
+ui := target-$(target)
+include $(ui)/GNUmakefile
+-include obj/*.d
+
+clean:
+	$(call delete,obj/*)
+	$(call delete,out/*)

bsnes/Locale/Japanese.bml

@@ -0,0 +1,127 @@
+locale
+  language: 日本語
+
+namespace: MessageDialog
+  map
+    input: Yes
+    value: はい
+  map
+    input: No
+    value: いいえ
+  map
+    input: Cancel
+    value: キャンセル
+
+namespace: BrowserDialog
+  map
+    input: Open
+    value: 開く
+  map
+    input: Save
+    value: 保存
+  map
+    input: Select
+    value: 選択
+  map
+    input: Cancel
+    value: キャンセル
+
+namespace: Program
+  map
+    input: Unloaded
+    value: アンロードされる
+  map
+    input: Paused
+    value: ポーズ
+
+namespace: Presentation
+  map
+    input: System
+    value: システム
+  map
+    input: Load Game
+    value: ゲームを読み込み
+  map
+    input: Load Recent Game
+    value: 最新ゲームを読み込み
+  map
+    input: empty
+    value: なし
+  map
+    input: Clear List
+    value: 全部を消す
+  map
+    input: Reset System
+    value: システムをリセット
+  map
+    input: Unload Game
+    value: ゲームをアンロード
+  map
+    input: Controller Port 1
+    value: コントローラポート1
+  map
+    input: Controller Port 2
+    value: コントローラポート2
+  map
+    input: Expansion Port
+    value: 拡張ポート
+  map
+    input: Gamepad
+    value: ゲームパッド
+  map
+    input: Mouse
+    value: マウス
+  map
+    input: Super Multitap
+    value: スーパーマルチタップ
+  map
+    input: Super Scope
+    value: スーパースコップ
+  map
+    input: Justifier
+    value: 1挺のジャスティファイアー
+  map
+    input: Justifiers
+    value: 2挺のジャスティファイアー
+  map
+    input: None
+    value: なし
+  map
+    input: Satellaview
+    value: サテラビュー
+  map
+    input: Quit
+    value: 終了
+  map
+    input: Settings
+    value: 設定
+  map
+    input: Tools
+    value: ツール
+  map
+    input: Help
+    value: ヘルプ
+  map
+    input: Documentation
+    value: オンラインマニュアル
+  map
+    input: About
+    value: 情報
+
+namespace: AboutWindow
+  map
+    input: About {0}
+    value: {0}について
+  map
+    input: Version
+    value: バージョン
+  map
+    input: Author
+    value: 作者
+  map
+    input: License
+    value: ライセンス
+  map
+    input: Website
+    value: 公式サイト
+

bsnes/Makefile

@@ -1,75 +0,0 @@
-include nall/Makefile
-snes := snes
-gameboy := gameboy
-profile := compatibility
-ui := ui
-
-# debugger
-options :=
-
-# compiler
-c       := $(compiler) -std=gnu99
-cpp     := $(subst cc,++,$(compiler)) -std=gnu++0x
-flags   := -O3 -fomit-frame-pointer -I.
-link    :=
-objects := libco
-
-# profile-guided instrumentation
-# flags += -fprofile-generate
-# link += -lgcov
-
-# profile-guided optimization
-# flags += -fprofile-use
-
-flags := $(flags) $(foreach o,$(call strupper,$(options)),-D$o)
-
-# platform
-ifeq ($(platform),x)
-  link += -s -ldl -lX11 -lXext
-else ifeq ($(platform),osx)
-else ifeq ($(platform),win)
-  link += -mwindows
-# link += -mconsole
-  link += -mthreads -s -luuid -lkernel32 -luser32 -lgdi32 -lcomctl32 -lcomdlg32 -lshell32 -lole32
-  link += -enable-stdcall-fixup -Wl,-enable-auto-import -Wl,-enable-runtime-pseudo-reloc
-else
-  unknown_platform: help;
-endif
-
-# implicit rules
-compile = \
-  $(strip \
-    $(if $(filter %.c,$<), \
-      $(c) $(flags) $1 -c $< -o $@, \
-      $(if $(filter %.cpp,$<), \
-        $(cpp) $(flags) $1 -c $< -o $@ \
-      ) \
-    ) \
-  )
-
-%.o: $<; $(call compile)
-
-all: build;
-
-obj/libco.o: libco/libco.c libco/*
-
-include $(ui)/Makefile
-
-# targets
-clean:
-	-@$(call delete,obj/*.o)
-	-@$(call delete,obj/*.a)
-	-@$(call delete,obj/*.so)
-	-@$(call delete,obj/*.dylib)
-	-@$(call delete,obj/*.dll)
-	-@$(call delete,*.res)
-	-@$(call delete,*.pgd)
-	-@$(call delete,*.pgc)
-	-@$(call delete,*.ilk)
-	-@$(call delete,*.pdb)
-	-@$(call delete,*.manifest)
-
-archive-all:
-	tar -cjf bsnes.tar.bz2 data gameboy libco nall obj out phoenix ruby snes ui ui-gameboy ui-libsnes Makefile cc.bat clean.bat sync.sh
-
-help:;

bsnes/cc.bat

@@ -1,2 +0,0 @@
-@mingw32-make -j 8
-@pause

bsnes/clean.bat

@@ -1 +0,0 @@
-@mingw32-make clean

bsnes/data/bsnes.Manifest

@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
-  <assemblyIdentity type="win32" name="bsnes" version="1.0.0.0" processorArchitecture="*"/>
-  <dependency>
-    <dependentAssembly>
-      <assemblyIdentity type="win32" name="Microsoft.Windows.Common-Controls" version="6.0.0.0" processorArchitecture="*" publicKeyToken="6595b64144ccf1df" language="*"/>
-    </dependentAssembly>
-  </dependency>
-</assembly>

bsnes/emulator/audio/audio.cpp

@@ -0,0 +1,75 @@
+#define double float
+
+namespace Emulator {
+
+#include "stream.cpp"
+Audio audio;
+
+Audio::~Audio() {
+  reset(nullptr);
+}
+
+auto Audio::reset(Interface* interface) -> void {
+  _interface = interface;
+  _streams.reset();
+  _channels = 0;
+}
+
+auto Audio::setFrequency(double frequency) -> void {
+  _frequency = frequency;
+  for(auto& stream : _streams) {
+    stream->setFrequency(stream->inputFrequency, frequency);
+  }
+}
+
+auto Audio::setVolume(double volume) -> void {
+  _volume = volume;
+}
+
+auto Audio::setBalance(double balance) -> void {
+  _balance = balance;
+}
+
+auto Audio::createStream(uint channels, double frequency) -> shared_pointer<Stream> {
+  _channels = max(_channels, channels);
+  shared_pointer<Stream> stream = new Stream;
+  stream->reset(channels, frequency, _frequency);
+  _streams.append(stream);
+  return stream;
+}
+
+auto Audio::process() -> void {
+  while(_streams) {
+    for(auto& stream : _streams) {
+      if(!stream->pending()) return;
+    }
+
+    double samples[_channels];
+    for(auto& sample : samples) sample = 0.0;
+
+    for(auto& stream : _streams) {
+      double buffer[_channels];
+      uint length = stream->read(buffer), offset = 0;
+
+      for(auto& sample : samples) {
+        sample += buffer[offset];
+        if(++offset >= length) offset = 0;
+      }
+    }
+
+    for(auto c : range(_channels)) {
+      samples[c] = max(-1.0, min(+1.0, samples[c] * _volume));
+    }
+
+    if(_channels == 2) {
+      if(_balance < 0.0) samples[1] *= 1.0 + _balance;
+      if(_balance > 0.0) samples[0] *= 1.0 - _balance;
+    }
+
+    platform->audioFrame(samples, _channels);
+  }
+}
+
+}
+
+#undef double

bsnes/emulator/audio/audio.hpp

@@ -0,0 +1,91 @@
+#pragma once
+#define double float
+
+#include <nall/dsp/iir/dc-removal.hpp>
+#include <nall/dsp/iir/one-pole.hpp>
+#include <nall/dsp/iir/biquad.hpp>
+#include <nall/dsp/resampler/cubic.hpp>
+
+namespace Emulator {
+
+struct Interface;
+struct Audio;
+struct Filter;
+struct Stream;
+
+struct Audio {
+  ~Audio();
+  auto reset(Interface* interface) -> void;
+
+  inline auto channels() const -> uint { return _channels; }
+  inline auto frequency() const -> double { return _frequency; }
+  inline auto volume() const -> double { return _volume; }
+  inline auto balance() const -> double { return _balance; }
+
+  auto setFrequency(double frequency) -> void;
+  auto setVolume(double volume) -> void;
+  auto setBalance(double balance) -> void;
+
+  auto createStream(uint channels, double frequency) -> shared_pointer<Stream>;
+
+private:
+  auto process() -> void;
+
+  Interface* _interface = nullptr;
+  vector<shared_pointer<Stream>> _streams;
+
+  uint _channels = 0;
+  double _frequency = 48000.0;
+
+  double _volume = 1.0;
+  double _balance = 0.0;
+
+  friend class Stream;
+};
+
+struct Filter {
+  enum class Mode : uint { DCRemoval, OnePole, Biquad } mode;
+  enum class Type : uint { None, LowPass, HighPass } type;
+  enum class Order : uint { None, First, Second } order;
+
+  DSP::IIR::DCRemoval dcRemoval;
+  DSP::IIR::OnePole onePole;
+  DSP::IIR::Biquad biquad;
+};
+
+struct Stream {
+  auto reset(uint channels, double inputFrequency, double outputFrequency) -> void;
+
+  auto setFrequency(double inputFrequency, maybe<double> outputFrequency = nothing) -> void;
+
+  auto addDCRemovalFilter() -> void;
+  auto addLowPassFilter(double cutoffFrequency, Filter::Order order, uint passes = 1) -> void;
+  auto addHighPassFilter(double cutoffFrequency, Filter::Order order, uint passes = 1) -> void;
+
+  auto pending() const -> bool;
+  auto read(double samples[]) -> uint;
+  auto write(const double samples[]) -> void;
+
+  template<typename... P> auto sample(P&&... p) -> void {
+    double samples[sizeof...(P)] = {forward<P>(p)...};
+    write(samples);
+  }
+
+private:
+  struct Channel {
+    vector<Filter> filters;
+    vector<DSP::IIR::Biquad> nyquist;
+    DSP::Resampler::Cubic resampler;
+  };
+  vector<Channel> channels;
+  double inputFrequency;
+  double outputFrequency;
+
+  friend class Audio;
+};
+
+extern Audio audio;
+
+}
+
+#undef double

bsnes/emulator/audio/stream.cpp

@@ -0,0 +1,106 @@
+auto Stream::reset(uint channelCount, double inputFrequency, double outputFrequency) -> void {
+  channels.reset();
+  channels.resize(channelCount);
+
+  for(auto& channel : channels) {
+    channel.filters.reset();
+  }
+
+  setFrequency(inputFrequency, outputFrequency);
+}
+
+auto Stream::setFrequency(double inputFrequency, maybe<double> outputFrequency) -> void {
+  this->inputFrequency = inputFrequency;
+  if(outputFrequency) this->outputFrequency = outputFrequency();
+
+  for(auto& channel : channels) {
+    channel.nyquist.reset();
+    channel.resampler.reset(this->inputFrequency, this->outputFrequency);
+  }
+
+  if(this->inputFrequency >= this->outputFrequency * 2) {
+    //add a low-pass filter to prevent aliasing during resampling
+    double cutoffFrequency = min(25000.0, this->outputFrequency / 2.0 - 2000.0);
+    for(auto& channel : channels) {
+      uint passes = 3;
+      for(uint pass : range(passes)) {
+        DSP::IIR::Biquad filter;
+        double q = DSP::IIR::Biquad::butterworth(passes * 2, pass);
+        filter.reset(DSP::IIR::Biquad::Type::LowPass, cutoffFrequency, this->inputFrequency, q);
+        channel.nyquist.append(filter);
+      }
+    }
+  }
+}
+
+auto Stream::addDCRemovalFilter() -> void {
+  return;  //todo: test to ensure this is desirable before enabling
+  for(auto& channel : channels) {
+    Filter filter{Filter::Mode::DCRemoval, Filter::Type::None, Filter::Order::None};
+    channel.filters.append(filter);
+  }
+}
+
+auto Stream::addLowPassFilter(double cutoffFrequency, Filter::Order order, uint passes) -> void {
+  for(auto& channel : channels) {
+    for(uint pass : range(passes)) {
+      if(order == Filter::Order::First) {
+        Filter filter{Filter::Mode::OnePole, Filter::Type::LowPass, Filter::Order::First};
+        filter.onePole.reset(DSP::IIR::OnePole::Type::LowPass, cutoffFrequency, inputFrequency);
+        channel.filters.append(filter);
+      }
+      if(order == Filter::Order::Second) {
+        Filter filter{Filter::Mode::Biquad, Filter::Type::LowPass, Filter::Order::Second};
+        double q = DSP::IIR::Biquad::butterworth(passes * 2, pass);
+        filter.biquad.reset(DSP::IIR::Biquad::Type::LowPass, cutoffFrequency, inputFrequency, q);
+        channel.filters.append(filter);
+      }
+    }
+  }
+}
+
+auto Stream::addHighPassFilter(double cutoffFrequency, Filter::Order order, uint passes) -> void {
+  for(auto& channel : channels) {
+    for(uint pass : range(passes)) {
+      if(order == Filter::Order::First) {
+        Filter filter{Filter::Mode::OnePole, Filter::Type::HighPass, Filter::Order::First};
+        filter.onePole.reset(DSP::IIR::OnePole::Type::HighPass, cutoffFrequency, inputFrequency);
+        channel.filters.append(filter);
+      }
+      if(order == Filter::Order::Second) {
+        Filter filter{Filter::Mode::Biquad, Filter::Type::HighPass, Filter::Order::Second};
+        double q = DSP::IIR::Biquad::butterworth(passes * 2, pass);
+        filter.biquad.reset(DSP::IIR::Biquad::Type::HighPass, cutoffFrequency, inputFrequency, q);
+        channel.filters.append(filter);
+      }
+    }
+  }
+}
+
+auto Stream::pending() const -> bool {
+  return channels && channels[0].resampler.pending();
+}
+
+auto Stream::read(double samples[]) -> uint {
+  for(uint c : range(channels.size())) samples[c] = channels[c].resampler.read();
+  return channels.size();
+}
+
+auto Stream::write(const double samples[]) -> void {
+  for(auto c : range(channels.size())) {
+    double sample = samples[c] + 1e-25;  //constant offset used to suppress denormals
+    for(auto& filter : channels[c].filters) {
+      switch(filter.mode) {
+      case Filter::Mode::DCRemoval: sample = filter.dcRemoval.process(sample); break;
+      case Filter::Mode::OnePole: sample = filter.onePole.process(sample); break;
+      case Filter::Mode::Biquad: sample = filter.biquad.process(sample); break;
+      }
+    }
+    for(auto& filter : channels[c].nyquist) {
+      sample = filter.process(sample);
+    }
+    channels[c].resampler.write(sample);
+  }
+
+  audio.process();
+}

bsnes/emulator/cheat.hpp

@@ -0,0 +1,57 @@
+#pragma once
+
+namespace Emulator {
+
+struct Cheat {
+  struct Code {
+    auto operator==(const Code& code) const -> bool {
+      if(address != code.address) return false;
+      if(data != code.data) return false;
+      if((bool)compare != (bool)code.compare) return false;
+      if(compare && code.compare && compare() != code.compare()) return false;
+      return true;
+    }
+
+    uint address;
+    uint data;
+    maybe<uint> compare;
+    bool enable;
+    uint restore;
+  };
+
+  explicit operator bool() const {
+    return codes.size() > 0;
+  }
+
+  auto reset() -> void {
+    codes.reset();
+  }
+
+  auto append(uint address, uint data, maybe<uint> compare = {}) -> void {
+    codes.append({address, data, compare});
+  }
+
+  auto assign(const vector<string>& list) -> void {
+    reset();
+    for(auto& entry : list) {
+      for(auto code : entry.split("+")) {
+        auto part = code.transform("=?", "//").split("/");
+        if(part.size() == 2) append(part[0].hex(), part[1].hex());
+        if(part.size() == 3) append(part[0].hex(), part[2].hex(), part[1].hex());
+      }
+    }
+  }
+
+  auto find(uint address, uint compare) -> maybe<uint> {
+    for(auto& code : codes) {
+      if(code.address == address && (!code.compare || code.compare() == compare)) {
+        return code.data;
+      }
+    }
+    return nothing;
+  }
+
+  vector<Code> codes;
+};
+
+}

bsnes/emulator/emulator.cpp

@@ -0,0 +1,8 @@
+#include <emulator/emulator.hpp>
+#include <emulator/audio/audio.cpp>
+
+namespace Emulator {
+
+Platform* platform = nullptr;
+
+}

bsnes/emulator/emulator.hpp

@@ -0,0 +1,58 @@
+#pragma once
+
+#include <nall/platform.hpp>
+#include <nall/adaptive-array.hpp>
+#include <nall/any.hpp>
+#include <nall/chrono.hpp>
+#include <nall/dl.hpp>
+#include <nall/endian.hpp>
+#include <nall/image.hpp>
+#include <nall/literals.hpp>
+#include <nall/random.hpp>
+#include <nall/serializer.hpp>
+#include <nall/shared-pointer.hpp>
+#include <nall/string.hpp>
+#include <nall/traits.hpp>
+#include <nall/unique-pointer.hpp>
+#include <nall/vector.hpp>
+#include <nall/vfs.hpp>
+#include <nall/hash/crc32.hpp>
+#include <nall/hash/sha256.hpp>
+using namespace nall;
+
+#include <libco/libco.h>
+
+#include <emulator/types.hpp>
+#include <emulator/memory/readable.hpp>
+#include <emulator/memory/writable.hpp>
+#include <emulator/audio/audio.hpp>
+
+namespace Emulator {
+  static const string Name    = "bsnes";
+  static const string Version = "110";
+  static const string Author  = "byuu";
+  static const string License = "GPLv3";
+  static const string Website = "https://byuu.org";
+
+  //incremented only when serialization format changes
+  static const string SerializerVersion = "110";
+
+  namespace Constants {
+    namespace Colorburst {
+      static constexpr double NTSC = 315.0 / 88.0 * 1'000'000.0;
+      static constexpr double PAL  = 283.75 * 15'625.0 + 25.0;
+    }
+  }
+
+  //nall/vfs shorthand constants for open(), load()
+  namespace File {
+    static const auto Read  = vfs::file::mode::read;
+    static const auto Write = vfs::file::mode::write;
+    static const auto Optional = false;
+    static const auto Required = true;
+  };
+}
+
+#include "platform.hpp"
+#include "interface.hpp"
+#include "game.hpp"

bsnes/emulator/game.hpp

@@ -0,0 +1,112 @@
+#pragma once
+
+namespace Emulator {
+
+struct Game {
+  struct Memory;
+  struct Oscillator;
+
+  inline auto load(string_view) -> void;
+  inline auto memory(Markup::Node) -> maybe<Memory>;
+  inline auto oscillator(natural = 0) -> maybe<Oscillator>;
+
+  struct Memory {
+    Memory() = default;
+    inline Memory(Markup::Node);
+    explicit operator bool() const { return (bool)type; }
+    inline auto name() const -> string;
+
+    string type;
+    natural size;
+    string content;
+    string manufacturer;
+    string architecture;
+    string identifier;
+    boolean nonVolatile;
+  };
+
+  struct Oscillator {
+    Oscillator() = default;
+    inline Oscillator(Markup::Node);
+    explicit operator bool() const { return frequency; }
+
+    natural frequency;
+  };
+
+  Markup::Node document;
+  string sha256;
+  string label;
+  string name;
+  string title;
+  string region;
+  string revision;
+  string board;
+  vector<Memory> memoryList;
+  vector<Oscillator> oscillatorList;
+};
+
+auto Game::load(string_view text) -> void {
+  document = BML::unserialize(text);
+
+  sha256 = document["game/sha256"].text();
+  label = document["game/label"].text();
+  name = document["game/name"].text();
+  title = document["game/title"].text();
+  region = document["game/region"].text();
+  revision = document["game/revision"].text();
+  board = document["game/board"].text();
+
+  for(auto node : document.find("game/board/memory")) {
+    memoryList.append(Memory{node});
+  }
+
+  for(auto node : document.find("game/board/oscillator")) {
+    oscillatorList.append(Oscillator{node});
+  }
+}
+
+auto Game::memory(Markup::Node node) -> maybe<Memory> {
+  if(!node) return nothing;
+  for(auto& memory : memoryList) {
+    auto type = node["type"].text();
+    auto size = node["size"].natural();
+    auto content = node["content"].text();
+    auto manufacturer = node["manufacturer"].text();
+    auto architecture = node["architecture"].text();
+    auto identifier = node["identifier"].text();
+    if(type && type != memory.type) continue;
+    if(size && size != memory.size) continue;
+    if(content && content != memory.content) continue;
+    if(manufacturer && manufacturer != memory.manufacturer) continue;
+    if(architecture && architecture != memory.architecture) continue;
+    if(identifier && identifier != memory.identifier) continue;
+    return memory;
+  }
+  return nothing;
+}
+
+auto Game::oscillator(natural index) -> maybe<Oscillator> {
+  if(index < oscillatorList.size()) return oscillatorList[index];
+  return nothing;
+}
+
+Game::Memory::Memory(Markup::Node node) {
+  type = node["type"].text();
+  size = node["size"].natural();
+  content = node["content"].text();
+  manufacturer = node["manufacturer"].text();
+  architecture = node["architecture"].text();
+  identifier = node["identifier"].text();
+  nonVolatile = !(bool)node["volatile"];
+}
+
+auto Game::Memory::name() const -> string {
+  if(architecture) return string{architecture, ".", content, ".", type}.downcase();
+  return string{content, ".", type}.downcase();
+}
+
+Game::Oscillator::Oscillator(Markup::Node node) {
+  frequency = node["frequency"].natural();
+}
+
+}

bsnes/emulator/interface.hpp

@@ -0,0 +1,106 @@
+#pragma once
+
+namespace Emulator {
+
+struct Interface {
+  struct Information {
+    string manufacturer;
+    string name;
+    string extension;
+    bool resettable = false;
+  };
+
+  struct Display {
+    struct Type { enum : uint {
+      CRT,
+      LCD,
+    };};
+    uint id = 0;
+    string name;
+    uint type = 0;
+    uint colors = 0;
+    uint width = 0;
+    uint height = 0;
+    uint internalWidth = 0;
+    uint internalHeight = 0;
+    double aspectCorrection = 0;
+  };
+
+  struct Port {
+    uint id;
+    string name;
+  };
+
+  struct Device {
+    uint id;
+    string name;
+  };
+
+  struct Input {
+    struct Type { enum : uint {
+      Hat,
+      Button,
+      Trigger,
+      Control,
+      Axis,
+      Rumble,
+    };};
+
+    uint type;
+    string name;
+  };
+
+  //information
+  virtual auto information() -> Information { return {}; }
+
+  virtual auto display() -> Display { return {}; }
+  virtual auto color(uint32 color) -> uint64 { return 0; }
+
+  //game interface
+  virtual auto loaded() -> bool { return false; }
+  virtual auto hashes() -> vector<string> { return {}; }
+  virtual auto manifests() -> vector<string> { return {}; }
+  virtual auto titles() -> vector<string> { return {}; }
+  virtual auto title() -> string { return {}; }
+  virtual auto load() -> bool { return false; }
+  virtual auto save() -> void {}
+  virtual auto unload() -> void {}
+
+  //system interface
+  virtual auto ports() -> vector<Port> { return {}; }
+  virtual auto devices(uint port) -> vector<Device> { return {}; }
+  virtual auto inputs(uint device) -> vector<Input> { return {}; }
+  virtual auto connected(uint port) -> uint { return 0; }
+  virtual auto connect(uint port, uint device) -> void {}
+  virtual auto power() -> void {}
+  virtual auto reset() -> void {}
+  virtual auto run() -> void {}
+
+  //time functions
+  virtual auto rtc() -> bool { return false; }
+  virtual auto synchronize(uint64 timestamp = 0) -> void {}
+
+  //state functions
+  virtual auto serialize() -> serializer { return {}; }
+  virtual auto unserialize(serializer&) -> bool { return false; }
+
+  //cheat functions
+  virtual auto read(uint24 address) -> uint8 { return 0; }
+  virtual auto cheats(const vector<string>& = {}) -> void {}
+
+  //configuration
+  virtual auto configuration() -> string { return {}; }
+  virtual auto configuration(string name) -> string { return {}; }
+  virtual auto configure(string configuration = "") -> bool { return false; }
+  virtual auto configure(string name, string value) -> bool { return false; }
+
+  //settings
+  virtual auto cap(const string& name) -> bool { return false; }
+  virtual auto get(const string& name) -> any { return {}; }
+  virtual auto set(const string& name, const any& value) -> bool { return false; }
+
+  virtual auto frameSkip() -> uint { return 0; }
+  virtual auto setFrameSkip(uint frameSkip) -> void {}
+};
+
+}

bsnes/emulator/memory/memory.hpp

@@ -0,0 +1,30 @@
+#pragma once
+
+namespace Emulator::Memory {
+
+inline auto mirror(uint address, uint size) -> uint {
+  if(size == 0) return 0;
+  uint base = 0;
+  uint mask = 1 << 31;
+  while(address >= size) {
+    while(!(address & mask)) mask >>= 1;
+    address -= mask;
+    if(size > mask) {
+      size -= mask;
+      base += mask;
+    }
+    mask >>= 1;
+  }
+  return base + address;
+}
+
+inline auto reduce(uint address, uint mask) -> uint {
+  while(mask) {
+    uint bits = (mask & -mask) - 1;
+    address = address >> 1 & ~bits | address & bits;
+    mask = (mask & mask - 1) >> 1;
+  }
+  return address;
+}
+
+}

bsnes/emulator/memory/readable.hpp

@@ -0,0 +1,63 @@
+#pragma once
+
+#include <emulator/memory/memory.hpp>
+
+namespace Emulator::Memory {
+
+template<typename T>
+struct Readable {
+  ~Readable() { reset(); }
+
+  inline auto reset() -> void {
+    delete[] self.data;
+    self.data = nullptr;
+    self.size = 0;
+    self.mask = 0;
+  }
+
+  inline auto allocate(uint size, T fill = ~0ull) -> void {
+    if(!size) return reset();
+    delete[] self.data;
+    self.size = size;
+    self.mask = bit::round(self.size) - 1;
+    self.data = new T[self.mask + 1];
+    memory::fill<T>(self.data, self.mask + 1, fill);
+  }
+
+  inline auto load(shared_pointer<vfs::file> fp) -> void {
+    fp->read(self.data, min(fp->size(), self.size * sizeof(T)));
+    for(uint address = self.size; address <= self.mask; address++) {
+      self.data[address] = self.data[mirror(address, self.size)];
+    }
+  }
+
+  inline auto save(shared_pointer<vfs::file> fp) -> void {
+    fp->write(self.data, self.size * sizeof(T));
+  }
+
+  explicit operator bool() const { return (bool)self.data; }
+  inline auto data() const -> const T* { return self.data; }
+  inline auto size() const -> uint { return self.size; }
+  inline auto mask() const -> uint { return self.mask; }
+
+  inline auto operator[](uint address) const -> T { return self.data[address & self.mask]; }
+  inline auto read(uint address) const -> T { return self.data[address & self.mask]; }
+  inline auto write(uint address, T data) const -> void {}
+
+  auto serialize(serializer& s) -> void {
+    const uint size = self.size;
+    s.integer(self.size);
+    s.integer(self.mask);
+    if(self.size != size) allocate(self.size);
+    s.array(self.data, self.size);
+  }
+
+private:
+  struct {
+    T* data = nullptr;
+    uint size = 0;
+    uint mask = 0;
+  } self;
+};
+
+}

bsnes/emulator/memory/writable.hpp

@@ -0,0 +1,65 @@
+#pragma once
+
+#include <emulator/memory/memory.hpp>
+
+namespace Emulator::Memory {
+
+template<typename T>
+struct Writable {
+  ~Writable() { reset(); }
+
+  inline auto reset() -> void {
+    delete[] self.data;
+    self.data = nullptr;
+    self.size = 0;
+    self.mask = 0;
+  }
+
+  inline auto allocate(uint size, T fill = ~0ull) -> void {
+    if(!size) return reset();
+    delete[] self.data;
+    self.size = size;
+    self.mask = bit::round(self.size) - 1;
+    self.data = new T[self.mask + 1];
+    memory::fill<T>(self.data, self.mask + 1, fill);
+  }
+
+  inline auto load(shared_pointer<vfs::file> fp) -> void {
+    fp->read(self.data, min(fp->size(), self.size * sizeof(T)));
+    for(uint address = self.size; address <= self.mask; address++) {
+      self.data[address] = self.data[mirror(address, self.size)];
+    }
+  }
+
+  inline auto save(shared_pointer<vfs::file> fp) -> void {
+    fp->write(self.data, self.size * sizeof(T));
+  }
+
+  explicit operator bool() const { return (bool)self.data; }
+  inline auto data() -> T* { return self.data; }
+  inline auto data() const -> const T* { return self.data; }
+  inline auto size() const -> uint { return self.size; }
+  inline auto mask() const -> uint { return self.mask; }
+
+  inline auto operator[](uint address) -> T& { return self.data[address & self.mask]; }
+  inline auto operator[](uint address) const -> T { return self.data[address & self.mask]; }
+  inline auto read(uint address) const -> T { return self.data[address & self.mask]; }
+  inline auto write(uint address, T data) -> void { self.data[address & self.mask] = data; }
+
+  auto serialize(serializer& s) -> void {
+    const uint size = self.size;
+    s.integer(self.size);
+    s.integer(self.mask);
+    if(self.size != size) allocate(self.size);
+    s.array(self.data, self.size);
+  }
+
+private:
+  struct {
+    T* data = nullptr;
+    uint size = 0;
+    uint mask = 0;
+  } self;
+};
+
+}

bsnes/emulator/platform.hpp

@@ -0,0 +1,29 @@
+#pragma once
+
+namespace Emulator {
+
+struct Platform {
+  struct Load {
+    Load() = default;
+    Load(uint pathID, string option = "") : valid(true), pathID(pathID), option(option) {}
+    explicit operator bool() const { return valid; }
+
+    bool valid = false;
+    uint pathID = 0;
+    string option;
+  };
+
+  virtual auto path(uint id) -> string { return ""; }
+  virtual auto open(uint id, string name, vfs::file::mode mode, bool required = false) -> shared_pointer<vfs::file> { return {}; }
+  virtual auto load(uint id, string name, string type, vector<string> options = {}) -> Load { return {}; }
+  virtual auto videoFrame(const uint16* data, uint pitch, uint width, uint height, uint scale) -> void {}
+  virtual auto audioFrame(const float* samples, uint channels) -> void {}
+  virtual auto inputPoll(uint port, uint device, uint input) -> int16 { return 0; }
+  virtual auto inputRumble(uint port, uint device, uint input, bool enable) -> void {}
+  virtual auto dipSettings(Markup::Node node) -> uint { return 0; }
+  virtual auto notify(string text) -> void {}
+};
+
+extern Platform* platform;
+
+}

bsnes/emulator/random.hpp

@@ -0,0 +1,96 @@
+#pragma once
+
+namespace Emulator {
+
+struct Random {
+  enum class Entropy : uint { None, Low, High };
+
+  auto operator()() -> uint64 {
+    return random();
+  }
+
+  auto entropy(Entropy entropy) -> void {
+    _entropy = entropy;
+    seed();
+  }
+
+  auto seed(maybe<uint32> seed = nothing, maybe<uint32> sequence = nothing) -> void {
+    if(!seed) seed = (uint32)clock();
+    if(!sequence) sequence = 0;
+
+    _state = 0;
+    _increment = sequence() << 1 | 1;
+    step();
+    _state += seed();
+    step();
+  }
+
+  auto random() -> uint64 {
+    if(_entropy == Entropy::None) return 0;
+    return (uint64)step() << 32 | (uint64)step() << 0;
+  }
+
+  auto bias(uint64 bias) -> uint64 {
+    if(_entropy == Entropy::None) return bias;
+    return random();
+  }
+
+  auto bound(uint64 bound) -> uint64 {
+    uint64 threshold = -bound % bound;
+    while(true) {
+      uint64 result = random();
+      if(result >= threshold) return result % bound;
+    }
+  }
+
+  auto array(uint8* data, uint32 size) -> void {
+    if(_entropy == Entropy::None) {
+      memory::fill(data, size);
+      return;
+    }
+
+    if(_entropy == Entropy::High) {
+      for(uint32 address : range(size)) {
+        data[address] = random();
+      }
+      return;
+    }
+
+    //Entropy::Low
+    uint lobit = random() & 3;
+    uint hibit = (lobit + 8 + (random() & 3)) & 15;
+    uint lovalue = random() & 255;
+    uint hivalue = random() & 255;
+    if((random() & 3) == 0) lovalue = 0;
+    if((random() & 1) == 0) hivalue = ~lovalue;
+
+    for(uint32 address : range(size)) {
+      uint8 value = (address & 1ull << lobit) ? lovalue : hivalue;
+      if((address & 1ull << hibit)) value = ~value;
+      if((random() &  511) == 0) value ^= 1 << (random() & 7);
+      if((random() & 2047) == 0) value ^= 1 << (random() & 7);
+      data[address] = value;
+    }
+  }
+
+  auto serialize(serializer& s) -> void {
+    s.integer((uint&)_entropy);
+    s.integer(_state);
+    s.integer(_increment);
+  }
+
+private:
+  auto step() -> uint32 {
+    uint64 state = _state;
+    _state = state * 6364136223846793005ull + _increment;
+    uint32 xorshift = (state >> 18 ^ state) >> 27;
+    uint32 rotate = state >> 59;
+    return xorshift >> rotate | xorshift << (-rotate & 31);
+  }
+
+  Entropy _entropy = Entropy::High;
+  uint64 _state;
+  uint64 _increment;
+};
+
+}

bsnes/emulator/types.hpp

@@ -0,0 +1,72 @@
+#pragma once
+
+using  int1 = nall::Integer< 1>;
+using  int2 = nall::Integer< 2>;
+using  int3 = nall::Integer< 3>;
+using  int4 = nall::Integer< 4>;
+using  int5 = nall::Integer< 5>;
+using  int6 = nall::Integer< 6>;
+using  int7 = nall::Integer< 7>;
+using  int8 = int8_t;
+using  int9 = nall::Integer< 9>;
+using int10 = nall::Integer<10>;
+using int11 = nall::Integer<11>;
+using int12 = nall::Integer<12>;
+using int13 = nall::Integer<13>;
+using int14 = nall::Integer<14>;
+using int15 = nall::Integer<15>;
+using int16 = int16_t;
+using int17 = nall::Integer<17>;
+using int18 = nall::Integer<18>;
+using int19 = nall::Integer<19>;
+using int20 = nall::Integer<20>;
+using int21 = nall::Integer<21>;
+using int22 = nall::Integer<22>;
+using int23 = nall::Integer<23>;
+using int24 = nall::Integer<24>;
+using int25 = nall::Integer<25>;
+using int26 = nall::Integer<26>;
+using int27 = nall::Integer<27>;
+using int28 = nall::Integer<28>;
+using int29 = nall::Integer<29>;
+using int30 = nall::Integer<30>;
+using int31 = nall::Integer<31>;
+using int32 = int32_t;
+using int48 = nall::Integer<48>;  //Cx4
+using int64 = int64_t;
+
+using  uint1 = nall::Natural< 1>;
+using  uint2 = nall::Natural< 2>;
+using  uint3 = nall::Natural< 3>;
+using  uint4 = nall::Natural< 4>;
+using  uint5 = nall::Natural< 5>;
+using  uint6 = nall::Natural< 6>;
+using  uint7 = nall::Natural< 7>;
+using  uint8 = uint8_t;
+using  uint9 = nall::Natural< 9>;
+using uint10 = nall::Natural<10>;
+using uint11 = nall::Natural<11>;
+using uint12 = nall::Natural<12>;
+using uint13 = nall::Natural<13>;
+using uint14 = nall::Natural<14>;
+using uint15 = nall::Natural<15>;
+using uint16 = uint16_t;
+using uint17 = nall::Natural<17>;
+using uint18 = nall::Natural<18>;
+using uint19 = nall::Natural<19>;
+using uint20 = nall::Natural<20>;
+using uint21 = nall::Natural<21>;
+using uint22 = nall::Natural<22>;
+using uint23 = nall::Natural<23>;
+using uint24 = nall::Natural<24>;
+using uint25 = nall::Natural<25>;
+using uint26 = nall::Natural<26>;
+using uint27 = nall::Natural<27>;
+using uint28 = nall::Natural<28>;
+using uint29 = nall::Natural<29>;
+using uint30 = nall::Natural<30>;
+using uint31 = nall::Natural<31>;
+using uint32 = uint32_t;
+using uint40 = nall::Natural<40>;  //SA1
+using uint48 = nall::Natural<48>;  //Cx4
+using uint64 = uint64_t;

bsnes/filter/2xsai.cpp

@@ -0,0 +1,25 @@
+namespace Filter::_2xSaI {
+
+auto size(uint& width, uint& height) -> void {
+  width  *= 2;
+  height *= 2;
+}
+
+uint32_t temp[512 * 480];
+
+auto render(
+  uint32_t* colortable, uint32_t* output, uint outpitch,
+  const uint16_t* input, uint pitch, uint width, uint height
+) -> void {
+  for(unsigned y = 0; y < height; y++) {
+    const uint16_t *line_in = (const uint16_t*)(((const uint8_t*)input) + pitch * y);
+    uint32_t *line_out = temp + y * width;
+    for(unsigned x = 0; x < width; x++) {
+      line_out[x] = colortable[line_in[x]];
+    }
+  }
+
+  _2xSaI32((unsigned char*)temp, width * sizeof(uint32_t), 0, (unsigned char*)output, outpitch, width, height);
+}
+
+}

bsnes/filter/filter.cpp

@@ -0,0 +1,25 @@
+#include <emulator/emulator.hpp>
+
+#undef register
+#define register
+#include "sai/sai.cpp"
+
+uint32_t* colortable;
+#include "snes_ntsc/snes_ntsc.h"
+#include "snes_ntsc/snes_ntsc.c"
+
+#include "none.cpp"
+#include "scanlines-light.cpp"
+#include "scanlines-dark.cpp"
+#include "scanlines-black.cpp"
+#include "pixellate2x.cpp"
+#include "scale2x.cpp"
+#include "2xsai.cpp"
+#include "super-2xsai.cpp"
+#include "super-eagle.cpp"
+#include "lq2x.cpp"
+#include "hq2x.cpp"
+#include "ntsc-rf.cpp"
+#include "ntsc-composite.cpp"
+#include "ntsc-svideo.cpp"
+#include "ntsc-rgb.cpp"

bsnes/filter/filter.hpp

@@ -0,0 +1,129 @@
+#pragma once
+
+#include <emulator/emulator.hpp>
+
+namespace Filter {
+  using Size = auto (*)(uint& width, uint& height) -> void;
+  using Render = auto (*)(uint32_t* palette, uint32_t* output, uint outpitch,
+    const uint16_t* input, uint pitch, uint width, uint height) -> void;
+}
+
+namespace Filter::None {
+  auto size(uint& width, uint& height) -> void;
+  auto render(
+    uint32_t* colortable, uint32_t* output, uint outpitch,
+    const uint16_t* input, uint pitch, uint width, uint height
+  ) -> void;
+}
+
+namespace Filter::ScanlinesLight {
+  auto size(uint& width, uint& height) -> void;
+  auto render(
+    uint32_t* colortable, uint32_t* output, uint outpitch,
+    const uint16_t* input, uint pitch, uint width, uint height
+  ) -> void;
+}
+
+namespace Filter::ScanlinesDark {
+  auto size(uint& width, uint& height) -> void;
+  auto render(
+    uint32_t* colortable, uint32_t* output, uint outpitch,
+    const uint16_t* input, uint pitch, uint width, uint height
+  ) -> void;
+}
+
+namespace Filter::ScanlinesBlack {
+  auto size(uint& width, uint& height) -> void;
+  auto render(
+    uint32_t* colortable, uint32_t* output, uint outpitch,
+    const uint16_t* input, uint pitch, uint width, uint height
+  ) -> void;
+}
+
+namespace Filter::Pixellate2x {
+  auto size(uint& width, uint& height) -> void;
+  auto render(
+    uint32_t* colortable, uint32_t* output, uint outpitch,
+    const uint16_t* input, uint pitch, uint width, uint height
+  ) -> void;
+}
+
+namespace Filter::Scale2x {
+  auto size(uint& width, uint& height) -> void;
+  auto render(
+    uint32_t* colortable, uint32_t* output, uint outpitch,
+    const uint16_t* input, uint pitch, uint width, uint height
+  ) -> void;
+}
+
+namespace Filter::_2xSaI {
+  auto size(uint& width, uint& height) -> void;
+  auto render(
+    uint32_t* colortable, uint32_t* output, uint outpitch,
+    const uint16_t* input, uint pitch, uint width, uint height
+  ) -> void;
+}
+
+namespace Filter::Super2xSaI {
+  auto size(uint& width, uint& height) -> void;
+  auto render(
+    uint32_t* colortable, uint32_t* output, uint outpitch,
+    const uint16_t* input, uint pitch, uint width, uint height
+  ) -> void;
+}
+
+namespace Filter::SuperEagle {
+  auto size(uint& width, uint& height) -> void;
+  auto render(
+    uint32_t* colortable, uint32_t* output, uint outpitch,
+    const uint16_t* input, uint pitch, uint width, uint height
+  ) -> void;
+}
+
+namespace Filter::LQ2x {
+  auto size(uint& width, uint& height) -> void;
+  auto render(
+    uint32_t* colortable, uint32_t* output, uint outpitch,
+    const uint16_t* input, uint pitch, uint width, uint height
+  ) -> void;
+}
+
+namespace Filter::HQ2x {
+  auto size(uint& width, uint& height) -> void;
+  auto render(
+    uint32_t* colortable, uint32_t* output, uint outpitch,
+    const uint16_t* input, uint pitch, uint width, uint height
+  ) -> void;
+}
+
+namespace Filter::NTSC_RF {
+  auto size(uint& width, uint& height) -> void;
+  auto render(
+    uint32_t* colortable, uint32_t* output, uint outpitch,
+    const uint16_t* input, uint pitch, uint width, uint height
+  ) -> void;
+}
+
+namespace Filter::NTSC_Composite {
+  auto size(uint& width, uint& height) -> void;
+  auto render(
+    uint32_t* colortable, uint32_t* output, uint outpitch,
+    const uint16_t* input, uint pitch, uint width, uint height
+  ) -> void;
+}
+
+namespace Filter::NTSC_SVideo {
+  auto size(uint& width, uint& height) -> void;
+  auto render(
+    uint32_t* colortable, uint32_t* output, uint outpitch,
+    const uint16_t* input, uint pitch, uint width, uint height
+  ) -> void;
+}
+
+namespace Filter::NTSC_RGB {
+  auto size(uint& width, uint& height) -> void;
+  auto render(
+    uint32_t* colortable, uint32_t* output, uint outpitch,
+    const uint16_t* input, uint pitch, uint width, uint height
+  ) -> void;
+}

bsnes/filter/hq2x.cpp

@@ -0,0 +1,200 @@
+namespace Filter::HQ2x {
+
+enum {
+  diff_offset = (0x440 << 21) + (0x207 << 11) + 0x407,
+  diff_mask   = (0x380 << 21) + (0x1f0 << 11) + 0x3f0,
+};
+
+uint32_t *yuvTable;
+uint8_t rotate[256];
+
+const uint8_t hqTable[256] = {
+  4, 4, 6,  2, 4, 4, 6,  2, 5,  3, 15, 12, 5,  3, 17, 13,
+  4, 4, 6, 18, 4, 4, 6, 18, 5,  3, 12, 12, 5,  3,  1, 12,
+  4, 4, 6,  2, 4, 4, 6,  2, 5,  3, 17, 13, 5,  3, 16, 14,
+  4, 4, 6, 18, 4, 4, 6, 18, 5,  3, 16, 12, 5,  3,  1, 14,
+  4, 4, 6,  2, 4, 4, 6,  2, 5, 19, 12, 12, 5, 19, 16, 12,
+  4, 4, 6,  2, 4, 4, 6,  2, 5,  3, 16, 12, 5,  3, 16, 12,
+  4, 4, 6,  2, 4, 4, 6,  2, 5, 19,  1, 12, 5, 19,  1, 14,
+  4, 4, 6,  2, 4, 4, 6, 18, 5,  3, 16, 12, 5, 19,  1, 14,
+  4, 4, 6,  2, 4, 4, 6,  2, 5,  3, 15, 12, 5,  3, 17, 13,
+  4, 4, 6,  2, 4, 4, 6,  2, 5,  3, 16, 12, 5,  3, 16, 12,
+  4, 4, 6,  2, 4, 4, 6,  2, 5,  3, 17, 13, 5,  3, 16, 14,
+  4, 4, 6,  2, 4, 4, 6,  2, 5,  3, 16, 13, 5,  3,  1, 14,
+  4, 4, 6,  2, 4, 4, 6,  2, 5,  3, 16, 12, 5,  3, 16, 13,
+  4, 4, 6,  2, 4, 4, 6,  2, 5,  3, 16, 12, 5,  3,  1, 12,
+  4, 4, 6,  2, 4, 4, 6,  2, 5,  3, 16, 12, 5,  3,  1, 14,
+  4, 4, 6,  2, 4, 4, 6,  2, 5,  3,  1, 12, 5,  3,  1, 14,
+};
+
+static void initialize() {
+  static bool initialized = false;
+  if(initialized == true) return;
+  initialized = true;
+
+  yuvTable = new uint32_t[32768];
+
+  for(unsigned i = 0; i < 32768; i++) {
+    uint8_t R = (i >>  0) & 31;
+    uint8_t G = (i >>  5) & 31;
+    uint8_t B = (i >> 10) & 31;
+
+    //bgr555->bgr888
+    double r = (R << 3) | (R >> 2);
+    double g = (G << 3) | (G >> 2);
+    double b = (B << 3) | (B >> 2);
+
+    //bgr888->yuv
+    double y = (r + g + b) * (0.25f * (63.5f / 48.0f));
+    double u = ((r - b) * 0.25f + 128.0f) * (7.5f / 7.0f);
+    double v = ((g * 2.0f - r - b) * 0.125f + 128.0f) * (7.5f / 6.0f);
+
+    yuvTable[i] = ((unsigned)y << 21) + ((unsigned)u << 11) + ((unsigned)v);
+  }
+
+  //counter-clockwise rotation table; one revolution:
+  //123    369  12346789
+  //4.6 -> 2.8  =
+  //789    147  36928147
+  for(unsigned n = 0; n < 256; n++) {
+    rotate[n] = ((n >> 2) & 0x11) | ((n << 2) & 0x88)
+              | ((n & 0x01) << 5) | ((n & 0x08) << 3)
+              | ((n & 0x10) >> 3) | ((n & 0x80) >> 5);
+  }
+}
+
+static void terminate() {
+  delete[] yuvTable;
+}
+
+static bool same(uint16_t x, uint16_t y) {
+  return !((yuvTable[x] - yuvTable[y] + diff_offset) & diff_mask);
+}
+
+static bool diff(uint32_t x, uint16_t y) {
+  return ((x - yuvTable[y]) & diff_mask);
+}
+
+static void grow(uint32_t &n) { n |= n << 16; n &= 0x03e07c1f; }
+static uint16_t pack(uint32_t n) { n &= 0x03e07c1f; return n | (n >> 16); }
+
+static uint16_t blend1(uint32_t A, uint32_t B) {
+  grow(A); grow(B);
+  return pack((A * 3 + B) >> 2);
+}
+
+static uint16_t blend2(uint32_t A, uint32_t B, uint32_t C) {
+  grow(A); grow(B); grow(C);
+  return pack((A * 2 + B + C) >> 2);
+}
+
+static uint16_t blend3(uint32_t A, uint32_t B, uint32_t C) {
+  grow(A); grow(B); grow(C);
+  return pack((A * 5 + B * 2 + C) >> 3);
+}
+
+static uint16_t blend4(uint32_t A, uint32_t B, uint32_t C) {
+  grow(A); grow(B); grow(C);
+  return pack((A * 6 + B + C) >> 3);
+}
+
+static uint16_t blend5(uint32_t A, uint32_t B, uint32_t C) {
+  grow(A); grow(B); grow(C);
+  return pack((A * 2 + (B + C) * 3) >> 3);
+}
+
+static uint16_t blend6(uint32_t A, uint32_t B, uint32_t C) {
+  grow(A); grow(B); grow(C);
+  return pack((A * 14 + B + C) >> 4);
+}
+
+static uint16_t blend(unsigned rule, uint16_t E, uint16_t A, uint16_t B, uint16_t D, uint16_t F, uint16_t H) {
+  switch(rule) { default:
+    case  0: return E;
+    case  1: return blend1(E, A);
+    case  2: return blend1(E, D);
+    case  3: return blend1(E, B);
+    case  4: return blend2(E, D, B);
+    case  5: return blend2(E, A, B);
+    case  6: return blend2(E, A, D);
+    case  7: return blend3(E, B, D);
+    case  8: return blend3(E, D, B);
+    case  9: return blend4(E, D, B);
+    case 10: return blend5(E, D, B);
+    case 11: return blend6(E, D, B);
+    case 12: return same(B, D) ? blend2(E, D, B) : E;
+    case 13: return same(B, D) ? blend5(E, D, B) : E;
+    case 14: return same(B, D) ? blend6(E, D, B) : E;
+    case 15: return same(B, D) ? blend2(E, D, B) : blend1(E, A);
+    case 16: return same(B, D) ? blend4(E, D, B) : blend1(E, A);
+    case 17: return same(B, D) ? blend5(E, D, B) : blend1(E, A);
+    case 18: return same(B, F) ? blend3(E, B, D) : blend1(E, D);
+    case 19: return same(D, H) ? blend3(E, D, B) : blend1(E, B);
+  }
+}
+
+auto size(uint& width, uint& height) -> void {
+  width  *= 2;
+  height *= 2;
+}
+
+auto render(
+  uint32_t* colortable, uint32_t* output, uint outpitch,
+  const uint16_t* input, uint pitch, uint width, uint height
+) -> void {
+  initialize();
+
+  pitch    >>= 1;
+  outpitch >>= 2;
+
+  for(uint y = 0; y < height; y++) {
+    const uint16_t* in = input + y * pitch;
+    uint32_t* out0 = output + y * outpitch * 2;
+    uint32_t* out1 = output + y * outpitch * 2 + outpitch;
+
+    int prevline = (y == 0 ? 0 : pitch);
+    int nextline = (y == height - 1 ? 0 : pitch);
+
+    in++;
+    *out0++ = 0; *out0++ = 0;
+    *out1++ = 0; *out1++ = 0;
+
+    for(unsigned x = 1; x < width - 1; x++) {
+      uint16_t A = *(in - prevline - 1);
+      uint16_t B = *(in - prevline + 0);
+      uint16_t C = *(in - prevline + 1);
+      uint16_t D = *(in - 1);
+      uint16_t E = *(in + 0);
+      uint16_t F = *(in + 1);
+      uint16_t G = *(in + nextline - 1);
+      uint16_t H = *(in + nextline + 0);
+      uint16_t I = *(in + nextline + 1);
+      uint32_t e = yuvTable[E] + diff_offset;
+
+      uint8_t pattern;
+      pattern  = diff(e, A) << 0;
+      pattern |= diff(e, B) << 1;
+      pattern |= diff(e, C) << 2;
+      pattern |= diff(e, D) << 3;
+      pattern |= diff(e, F) << 4;
+      pattern |= diff(e, G) << 5;
+      pattern |= diff(e, H) << 6;
+      pattern |= diff(e, I) << 7;
+
+      *(out0 + 0) = colortable[blend(hqTable[pattern], E, A, B, D, F, H)]; pattern = rotate[pattern];
+      *(out0 + 1) = colortable[blend(hqTable[pattern], E, C, F, B, H, D)]; pattern = rotate[pattern];
+      *(out1 + 1) = colortable[blend(hqTable[pattern], E, I, H, F, D, B)]; pattern = rotate[pattern];
+      *(out1 + 0) = colortable[blend(hqTable[pattern], E, G, D, H, B, F)];
+
+      in++;
+      out0 += 2;
+      out1 += 2;
+    }
+
+    in++;
+    *out0++ = 0; *out0++ = 0;
+    *out1++ = 0; *out1++ = 0;
+  }
+}
+
+}

bsnes/filter/lq2x.cpp

@@ -0,0 +1,46 @@
+namespace Filter::LQ2x {
+
+auto size(uint& width, uint& height) -> void {
+  width  *= 2;
+  height *= 2;
+}
+
+auto render(
+  uint32_t* colortable, uint32_t* output, uint outpitch,
+  const uint16_t* input, uint pitch, uint width, uint height
+) -> void {
+  pitch    >>= 1;
+  outpitch >>= 2;
+
+  for(uint y = 0; y < height; y++) {
+    const uint16_t* in = input + y * pitch;
+    uint32_t* out0 = output + y * outpitch * 2;
+    uint32_t* out1 = output + y * outpitch * 2 + outpitch;
+
+    int prevline = (y == 0 ? 0 : pitch);
+    int nextline = (y == height - 1 ? 0 : pitch);
+
+    for(uint x = 0; x < width; x++) {
+      uint16_t A = *(in - prevline);
+      uint16_t B = (x > 0) ? *(in - 1) : *in;
+      uint16_t C = *in;
+      uint16_t D = (x < width - 1) ? *(in + 1) : *in;
+      uint16_t E = *(in++ + nextline);
+      uint32_t c = colortable[C];
+
+      if(A != E && B != D) {
+        *out0++ = (A == B ? colortable[C + A - ((C ^ A) & 0x0421) >> 1] : c);
+        *out0++ = (A == D ? colortable[C + A - ((C ^ A) & 0x0421) >> 1] : c);
+        *out1++ = (E == B ? colortable[C + E - ((C ^ E) & 0x0421) >> 1] : c);
+        *out1++ = (E == D ? colortable[C + E - ((C ^ E) & 0x0421) >> 1] : c);
+      } else {
+        *out0++ = c;
+        *out0++ = c;
+        *out1++ = c;
+        *out1++ = c;
+      }
+    }
+  }
+}
+
+}

bsnes/filter/none.cpp

@@ -0,0 +1,24 @@
+namespace Filter::None {
+
+auto size(uint& width, uint& height) -> void {
+  width  = width;
+  height = height;
+}
+
+auto render(
+  uint32_t* colortable, uint32_t* output, uint outpitch,
+  const uint16_t* input, uint pitch, uint width, uint height
+) -> void {
+  pitch    >>= 1;
+  outpitch >>= 2;
+
+  for(uint y = 0; y < height; y++) {
+    const uint16_t* in = input + y * pitch;
+    uint32_t* out = output + y * outpitch;
+    for(uint x = 0; x < width; x++) {
+      *out++ = colortable[*in++];
+    }
+  }
+}
+
+}

bsnes/filter/ntsc-composite.cpp

@@ -0,0 +1,50 @@
+namespace Filter::NTSC_Composite {
+
+struct snes_ntsc_t *ntsc;
+snes_ntsc_setup_t setup;
+int burst;
+int burst_toggle;
+
+void initialize() {
+  static bool initialized = false;
+  if(initialized == true) return;
+  initialized = true;
+
+  ntsc = (snes_ntsc_t*)malloc(sizeof *ntsc);
+  setup = snes_ntsc_composite;
+  setup.merge_fields = 1;
+  snes_ntsc_init(ntsc, &setup);
+
+  burst = 0;
+  burst_toggle = (setup.merge_fields ? 0 : 1);
+}
+
+void terminate() {
+  if(ntsc) free(ntsc);
+}
+
+auto size(uint& width, uint& height) -> void {
+  width  = SNES_NTSC_OUT_WIDTH(256);
+  height = height;
+}
+
+auto render(
+  uint32_t* colortable_, uint32_t* output, uint outpitch,
+  const uint16_t* input, uint pitch, uint width, uint height
+) -> void {
+  initialize();
+  colortable = colortable_;
+
+  pitch    >>= 1;
+  outpitch >>= 2;
+
+  if(width <= 256) {
+    snes_ntsc_blit      (ntsc, input, pitch, burst, width, height, output, outpitch << 2);
+  } else {
+    snes_ntsc_blit_hires(ntsc, input, pitch, burst, width, height, output, outpitch << 2);
+  }
+
+  burst ^= burst_toggle;
+}
+
+}

bsnes/filter/ntsc-rf.cpp

@@ -0,0 +1,50 @@
+namespace Filter::NTSC_RF {
+
+struct snes_ntsc_t *ntsc;
+snes_ntsc_setup_t setup;
+int burst;
+int burst_toggle;
+
+void initialize() {
+  static bool initialized = false;
+  if(initialized == true) return;
+  initialized = true;
+
+  ntsc = (snes_ntsc_t*)malloc(sizeof *ntsc);
+  setup = snes_ntsc_composite;
+  setup.merge_fields = 0;
+  snes_ntsc_init(ntsc, &setup);
+
+  burst = 0;
+  burst_toggle = (setup.merge_fields ? 0 : 1);
+}
+
+void terminate() {
+  if(ntsc) free(ntsc);
+}
+
+auto size(uint& width, uint& height) -> void {
+  width  = SNES_NTSC_OUT_WIDTH(256);
+  height = height;
+}
+
+auto render(
+  uint32_t* colortable_, uint32_t* output, uint outpitch,
+  const uint16_t* input, uint pitch, uint width, uint height
+) -> void {
+  initialize();
+  colortable = colortable_;
+
+  pitch    >>= 1;
+  outpitch >>= 2;
+
+  if(width <= 256) {
+    snes_ntsc_blit      (ntsc, input, pitch, burst, width, height, output, outpitch << 2);
+  } else {
+    snes_ntsc_blit_hires(ntsc, input, pitch, burst, width, height, output, outpitch << 2);
+  }
+
+  burst ^= burst_toggle;
+}
+
+}

bsnes/filter/ntsc-rgb.cpp

@@ -0,0 +1,50 @@
+namespace Filter::NTSC_RGB {
+
+struct snes_ntsc_t *ntsc;
+snes_ntsc_setup_t setup;
+int burst;
+int burst_toggle;
+
+void initialize() {
+  static bool initialized = false;
+  if(initialized == true) return;
+  initialized = true;
+
+  ntsc = (snes_ntsc_t*)malloc(sizeof *ntsc);
+  setup = snes_ntsc_rgb;
+  setup.merge_fields = 1;
+  snes_ntsc_init(ntsc, &setup);
+
+  burst = 0;
+  burst_toggle = (setup.merge_fields ? 0 : 1);
+}
+
+void terminate() {
+  if(ntsc) free(ntsc);
+}
+
+auto size(uint& width, uint& height) -> void {
+  width  = SNES_NTSC_OUT_WIDTH(256);
+  height = height;
+}
+
+auto render(
+  uint32_t* colortable_, uint32_t* output, uint outpitch,
+  const uint16_t* input, uint pitch, uint width, uint height
+) -> void {
+  initialize();
+  colortable = colortable_;
+
+  pitch    >>= 1;
+  outpitch >>= 2;
+
+  if(width <= 256) {
+    snes_ntsc_blit      (ntsc, input, pitch, burst, width, height, output, outpitch << 2);
+  } else {
+    snes_ntsc_blit_hires(ntsc, input, pitch, burst, width, height, output, outpitch << 2);
+  }
+
+  burst ^= burst_toggle;
+}
+
+}

bsnes/filter/ntsc-svideo.cpp

@@ -0,0 +1,50 @@
+namespace Filter::NTSC_SVideo {
+
+struct snes_ntsc_t *ntsc;
+snes_ntsc_setup_t setup;
+int burst;
+int burst_toggle;
+
+void initialize() {
+  static bool initialized = false;
+  if(initialized == true) return;
+  initialized = true;
+
+  ntsc = (snes_ntsc_t*)malloc(sizeof *ntsc);
+  setup = snes_ntsc_svideo;
+  setup.merge_fields = 1;
+  snes_ntsc_init(ntsc, &setup);
+
+  burst = 0;
+  burst_toggle = (setup.merge_fields ? 0 : 1);
+}
+
+void terminate() {
+  if(ntsc) free(ntsc);
+}
+
+auto size(uint& width, uint& height) -> void {
+  width  = SNES_NTSC_OUT_WIDTH(256);
+  height = height;
+}
+
+auto render(
+  uint32_t* colortable_, uint32_t* output, uint outpitch,
+  const uint16_t* input, uint pitch, uint width, uint height
+) -> void {
+  initialize();
+  colortable = colortable_;
+
+  pitch    >>= 1;
+  outpitch >>= 2;
+
+  if(width <= 256) {
+    snes_ntsc_blit      (ntsc, input, pitch, burst, width, height, output, outpitch << 2);
+  } else {
+    snes_ntsc_blit_hires(ntsc, input, pitch, burst, width, height, output, outpitch << 2);
+  }
+
+  burst ^= burst_toggle;
+}
+
+}

bsnes/filter/pixellate2x.cpp

@@ -0,0 +1,40 @@
+namespace Filter::Pixellate2x {
+
+auto size(uint& width, uint& height) -> void {
+  width  = (width  <= 256) ? width  * 2 : width;
+  height = (height <= 240) ? height * 2 : height;
+}
+
+auto render(
+  uint32_t* colortable, uint32_t* output, uint outpitch,
+  const uint16_t* input, uint pitch, uint width, uint height
+) -> void {
+  pitch >>= 1;
+  outpitch >>= 2;
+
+  uint32_t *out0 = output;
+  uint32_t *out1 = output + outpitch;
+
+  for(unsigned y = 0; y < height; y++) {
+    for(unsigned x = 0; x < width; x++) {
+      uint32_t p = colortable[*input++];
+
+      *out0++ = p;
+      if(height <= 240) *out1++ = p;
+      if(width > 256) continue;
+
+      *out0++ = p;
+      if(height <= 240) *out1++ = p;
+    }
+
+    input += pitch - width;
+    if(height <= 240) {
+      out0 += outpitch + outpitch - 512;
+      out1 += outpitch + outpitch - 512;
+    } else {
+      out0 += outpitch - 512;
+    }
+  }
+}
+
+}

bsnes/filter/scale2x.cpp

@@ -0,0 +1,46 @@
+namespace Filter::Scale2x {
+
+auto size(uint& width, uint& height) -> void {
+  width  *= 2;
+  height *= 2;
+}
+
+auto render(
+  uint32_t* colortable, uint32_t* output, uint outpitch,
+  const uint16_t* input, uint pitch, uint width, uint height
+) -> void {
+  pitch    >>= 1;
+  outpitch >>= 2;
+
+  for(uint y = 0; y < height; y++) {
+    const uint16_t* in = input + y * pitch;
+    uint32_t* out0 = output + y * outpitch * 2;
+    uint32_t* out1 = output + y * outpitch * 2 + outpitch;
+
+    int prevline = (y == 0 ? 0 : pitch);
+    int nextline = (y == height - 1 ? 0 : pitch);
+
+    for(unsigned x = 0; x < width; x++) {
+      uint16_t A = *(in - prevline);
+      uint16_t B = (x > 0) ? *(in - 1) : *in;
+      uint16_t C = *in;
+      uint16_t D = (x < width - 1) ? *(in + 1) : *in;
+      uint16_t E = *(in++ + nextline);
+      uint32_t c = colortable[C];
+
+      if(A != E && B != D) {
+        *out0++ = (A == B ? colortable[A] : c);
+        *out0++ = (A == D ? colortable[A] : c);
+        *out1++ = (E == B ? colortable[E] : c);
+        *out1++ = (E == D ? colortable[E] : c);
+      } else {
+        *out0++ = c;
+        *out0++ = c;
+        *out1++ = c;
+        *out1++ = c;
+      }
+    }
+  }
+}
+
+}

bsnes/filter/scanlines-black.cpp

@@ -0,0 +1,28 @@
+namespace Filter::ScanlinesBlack {
+
+auto size(uint& width, uint& height) -> void {
+  width  = width;
+  height = height * 2;
+}
+
+auto render(
+  uint32_t* palette, uint32_t* output, uint outpitch,
+  const uint16_t* input, uint pitch, uint width, uint height
+) -> void {
+  pitch    >>= 1;
+  outpitch >>= 2;
+
+  for(unsigned y = 0; y < height; y++) {
+    const uint16_t *in = input + y * pitch;
+    uint32_t *out0 = output + y * outpitch * 2;
+    uint32_t *out1 = output + y * outpitch * 2 + outpitch;
+
+    for(unsigned x = 0; x < width; x++) {
+      uint16_t color = *in++;
+      *out0++ = palette[color];
+      *out1++ = 0;
+    }
+  }
+}
+
+}

bsnes/filter/scanlines-dark.cpp

@@ -0,0 +1,48 @@
+namespace Filter::ScanlinesDark {
+
+uint16_t adjust[32768];
+
+void initialize() {
+  static bool initialized = false;
+  if(initialized == true) return;
+  initialized = true;
+
+  for(unsigned i = 0; i < 32768; i++) {
+    uint8_t r = (i >> 10) & 31;
+    uint8_t g = (i >>  5) & 31;
+    uint8_t b = (i >>  0) & 31;
+    r *= 0.333;
+    g *= 0.333;
+    b *= 0.333;
+    adjust[i] = (r << 10) + (g << 5) + (b << 0);
+  }
+}
+
+auto size(uint& width, uint& height) -> void {
+  width  = width;
+  height = height * 2;
+}
+
+auto render(
+  uint32_t* palette, uint32_t* output, uint outpitch,
+  const uint16_t* input, uint pitch, uint width, uint height
+) -> void {
+  initialize();
+
+  pitch    >>= 1;
+  outpitch >>= 2;
+
+  for(unsigned y = 0; y < height; y++) {
+    const uint16_t *in = input + y * pitch;
+    uint32_t *out0 = output + y * outpitch * 2;
+    uint32_t *out1 = output + y * outpitch * 2 + outpitch;
+
+    for(unsigned x = 0; x < width; x++) {
+      uint16_t color = *in++;
+      *out0++ = palette[color];
+      *out1++ = palette[adjust[color]];
+    }
+  }
+}
+
+}

bsnes/filter/scanlines-light.cpp

@@ -0,0 +1,48 @@
+namespace Filter::ScanlinesLight {
+
+uint16_t adjust[32768];
+
+void initialize() {
+  static bool initialized = false;
+  if(initialized == true) return;
+  initialized = true;
+
+  for(unsigned i = 0; i < 32768; i++) {
+    uint8_t r = (i >> 10) & 31;
+    uint8_t g = (i >>  5) & 31;
+    uint8_t b = (i >>  0) & 31;
+    r *= 0.666;
+    g *= 0.666;
+    b *= 0.666;
+    adjust[i] = (r << 10) + (g << 5) + (b << 0);
+  }
+}
+
+auto size(uint& width, uint& height) -> void {
+  width  = width;
+  height = height * 2;
+}
+
+auto render(
+  uint32_t* palette, uint32_t* output, uint outpitch,
+  const uint16_t* input, uint pitch, uint width, uint height
+) -> void {
+  initialize();
+
+  pitch    >>= 1;
+  outpitch >>= 2;
+
+  for(unsigned y = 0; y < height; y++) {
+    const uint16_t *in = input + y * pitch;
+    uint32_t *out0 = output + y * outpitch * 2;
+    uint32_t *out1 = output + y * outpitch * 2 + outpitch;
+
+    for(unsigned x = 0; x < width; x++) {
+      uint16_t color = *in++;
+      *out0++ = palette[color];
+      *out1++ = palette[adjust[color]];
+    }
+  }
+}
+
+}

bsnes/filter/super-2xsai.cpp

@@ -0,0 +1,25 @@
+namespace Filter::Super2xSaI {
+
+auto size(uint& width, uint& height) -> void {
+  width  *= 2;
+  height *= 2;
+}
+
+uint32_t temp[512 * 480];
+
+auto render(
+  uint32_t* colortable, uint32_t* output, uint outpitch,
+  const uint16_t* input, uint pitch, uint width, uint height
+) -> void {
+  for(unsigned y = 0; y < height; y++) {
+    const uint16_t *line_in = (const uint16_t*)(((const uint8_t*)input) + pitch * y);
+    uint32_t *line_out = temp + y * width;
+    for(unsigned x = 0; x < width; x++) {
+      line_out[x] = colortable[line_in[x]];
+    }
+  }
+
+  Super2xSaI32((unsigned char*)temp, width * sizeof(uint32_t), 0, (unsigned char*)output, outpitch, width, height);
+}
+
+}

bsnes/filter/super-eagle.cpp

@@ -0,0 +1,25 @@
+namespace Filter::SuperEagle {
+
+auto size(uint& width, uint& height) -> void {
+  width  *= 2;
+  height *= 2;
+}
+
+uint32_t temp[512 * 480];
+
+auto render(
+  uint32_t* colortable, uint32_t* output, uint outpitch,
+  const uint16_t* input, uint pitch, uint width, uint height
+) -> void {
+  for(unsigned y = 0; y < height; y++) {
+    const uint16_t *line_in = (const uint16_t*)(((const uint8_t*)input) + pitch * y);
+    uint32_t *line_out = temp + y * width;
+    for(unsigned x = 0; x < width; x++) {
+      line_out[x] = colortable[line_in[x]];
+    }
+  }
+
+  SuperEagle32((unsigned char*)temp, width * sizeof(uint32_t), 0, (unsigned char*)output, outpitch, width, height);
+}
+
+}

bsnes/gameboy/Makefile

@@ -1,12 +0,0 @@
-gameboy_objects := gameboy-system gameboy-scheduler
-gameboy_objects += gameboy-memory gameboy-cartridge
-gameboy_objects += gameboy-cpu gameboy-apu gameboy-lcd
-objects += $(gameboy_objects)
-
-obj/gameboy-system.o: $(gameboy)/system/system.cpp $(call rwildcard,$(gameboy)/system/)
-obj/gameboy-scheduler.o: $(gameboy)/scheduler/scheduler.cpp $(call rwildcard,$(gameboy)/scheduler/)
-obj/gameboy-cartridge.o: $(gameboy)/cartridge/cartridge.cpp $(call rwildcard,$(gameboy)/cartridge/)
-obj/gameboy-memory.o: $(gameboy)/memory/memory.cpp $(call rwildcard,$(gameboy)/memory/)
-obj/gameboy-cpu.o: $(gameboy)/cpu/cpu.cpp $(call rwildcard,$(gameboy)/cpu/)
-obj/gameboy-apu.o: $(gameboy)/apu/apu.cpp $(call rwildcard,$(gameboy)/apu/)
-obj/gameboy-lcd.o: $(gameboy)/lcd/lcd.cpp $(call rwildcard,$(gameboy)/lcd/)

bsnes/gameboy/apu/apu.cpp

@@ -1,105 +0,0 @@
-#include <gameboy/gameboy.hpp>
-
-#define APU_CPP
-namespace GameBoy {
-
-#include "square1/square1.cpp"
-#include "square2/square2.cpp"
-#include "wave/wave.cpp"
-#include "noise/noise.cpp"
-#include "master/master.cpp"
-#include "serialization.cpp"
-APU apu;
-
-void APU::Main() {
-  apu.main();
-}
-
-void APU::main() {
-  while(true) {
-    if(scheduler.sync == Scheduler::SynchronizeMode::All) {
-      scheduler.exit(Scheduler::ExitReason::SynchronizeEvent);
-    }
-
-    if(sequencer_base == 0) {  //512hz
-      if(sequencer_step == 0 || sequencer_step == 2 || sequencer_step == 4 || sequencer_step == 6) {  //256hz
-        square1.clock_length();
-        square2.clock_length();
-        wave.clock_length();
-        noise.clock_length();
-      }
-      if(sequencer_step == 2 || sequencer_step == 6) {  //128hz
-        square1.clock_sweep();
-      }
-      if(sequencer_step == 7) {  //64hz
-        square1.clock_envelope();
-        square2.clock_envelope();
-        noise.clock_envelope();
-      }
-      sequencer_step++;
-    }
-    sequencer_base++;
-
-    square1.run();
-    square2.run();
-    wave.run();
-    noise.run();
-    master.run();
-
-    system.interface->audio_sample(master.center, master.left, master.right);
-    if(++clock >= 0) co_switch(scheduler.active_thread = cpu.thread);
-  }
-}
-
-void APU::power() {
-  create(Main, 4194304);
-  for(unsigned n = 0xff10; n <= 0xff3f; n++) bus.mmio[n] = this;
-
-  foreach(n, mmio_data) n = 0x00;
-  sequencer_base = 0;
-  sequencer_step = 0;
-
-  square1.power();
-  square2.power();
-  wave.power();
-  noise.power();
-  master.power();
-}
-
-uint8 APU::mmio_read(uint16 addr) {
-  static const uint8 table[48] = {
-    0x80, 0x3f, 0x00, 0xff, 0xbf,                          //square1
-    0xff, 0x3f, 0x00, 0xff, 0xbf,                          //square2
-    0x7f, 0xff, 0x9f, 0xff, 0xbf,                          //wave
-    0xff, 0xff, 0x00, 0x00, 0xbf,                          //noise
-    0x00, 0x00, 0x70,                                      //master
-    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,  //unmapped
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,        //wave pattern
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,        //wave pattern
-  };
-
-  if(addr == 0xff26) {
-    uint8 data = master.enable << 7;
-    if(square1.counter && square1.length) data |= 0x01;
-    if(square2.counter && square2.length) data |= 0x02;
-    if(   wave.counter &&    wave.length) data |= 0x04;
-    if(  noise.counter &&   noise.length) data |= 0x08;
-    return data | table[addr - 0xff10];
-  }
-
-  if(addr >= 0xff10 && addr <= 0xff3f) return mmio_data[addr - 0xff10] | table[addr - 0xff10];
-  return 0xff;
-}
-
-void APU::mmio_write(uint16 addr, uint8 data) {
-  if(addr >= 0xff10 && addr <= 0xff3f) mmio_data[addr - 0xff10] = data;
-
-  if(addr >= 0xff10 && addr <= 0xff14) return square1.write        (addr - 0xff10, data);
-  if(addr >= 0xff15 && addr <= 0xff19) return square2.write        (addr - 0xff15, data);
-  if(addr >= 0xff1a && addr <= 0xff1e) return    wave.write        (addr - 0xff1a, data);
-  if(addr >= 0xff1f && addr <= 0xff23) return   noise.write        (addr - 0xff1f, data);
-  if(addr >= 0xff24 && addr <= 0xff26) return  master.write        (addr - 0xff24, data);
-  if(addr >= 0xff30 && addr <= 0xff3f) return    wave.write_pattern(addr - 0xff30, data);
-}
-
-}

bsnes/gameboy/apu/apu.hpp

@@ -1,28 +0,0 @@
-struct APU : Processor, MMIO {
-  #include "square1/square1.hpp"
-  #include "square2/square2.hpp"
-  #include "wave/wave.hpp"
-  #include "noise/noise.hpp"
-  #include "master/master.hpp"
-
-  uint8 mmio_data[48];
-  uint13 sequencer_base;
-  uint3 sequencer_step;
-
-  Square1 square1;
-  Square2 square2;
-  Wave wave;
-  Noise noise;
-  Master master;
-
-  static void Main();
-  void main();
-  void power();
-
-  uint8 mmio_read(uint16 addr);
-  void mmio_write(uint16 addr, uint8 data);
-
-  void serialize(serializer&);
-};
-
-extern APU apu;

bsnes/gameboy/apu/master/master.cpp

@@ -1,132 +0,0 @@
-#ifdef APU_CPP
-
-void APU::Master::run() {
-  if(enable == false) {
-    center = 0;
-    left   = 0;
-    right  = 0;
-    return;
-  }
-
-  signed sample = 0, channels;
-  sample += apu.square1.output;
-  sample += apu.square2.output;
-  sample +=    apu.wave.output;
-  sample +=   apu.noise.output;
-  sample >>= 2;
-  center = sclamp<16>(sample);
-
-  if(left_enable == false && right_enable == false) {
-    left  = center;
-    right = center;
-    return;
-  }
-
-  sample = 0;
-  channels = 0;
-  if(channel1_left_enable) { sample += apu.square1.output; channels++; }
-  if(channel2_left_enable) { sample += apu.square2.output; channels++; }
-  if(channel3_left_enable) { sample +=    apu.wave.output; channels++; }
-  if(channel4_left_enable) { sample +=   apu.noise.output; channels++; }
-  if(channels) sample /= channels;
-  left = sclamp<16>(sample);
-
-  switch(left_volume) {
-    case 0: left >>= 3;                       break;  // 12.5%
-    case 1: left >>= 2;                       break;  // 25.0%
-    case 2: left = (left >> 2) + (left >> 3); break;  // 37.5%
-    case 3: left >>= 1;                       break;  // 50.0%
-    case 4: left = (left >> 1) + (left >> 3); break;  // 62.5%
-    case 5: left -= (left >> 2);              break;  // 75.0%
-    case 6: left -= (left >> 3);              break;  // 87.5%
-  //case 7:                                   break;  //100.0%
-  }
-  if(left_enable == false) left = 0;
-
-  sample = 0;
-  channels = 0;
-  if(channel1_right_enable) { sample += apu.square1.output; channels++; }
-  if(channel2_right_enable) { sample += apu.square2.output; channels++; }
-  if(channel3_right_enable) { sample +=    apu.wave.output; channels++; }
-  if(channel4_right_enable) { sample +=   apu.noise.output; channels++; }
-  if(channels) sample /= channels;
-  right = sclamp<16>(sample);
-
-  switch(right_volume) {
-    case 0: right >>= 3;                         break;  // 12.5%
-    case 1: right >>= 2;                         break;  // 25.0%
-    case 2: right = (right >> 2) + (right >> 3); break;  // 37.5%
-    case 3: right >>= 1;                         break;  // 50.0%
-    case 4: right = (right >> 1) + (right >> 3); break;  // 62.5%
-    case 5: right -= (right >> 2);               break;  // 75.0%
-    case 6: right -= (right >> 3);               break;  // 87.5%
-  //case 7:                                      break;  //100.0%
-  }
-  if(right_enable == false) right = 0;
-}
-
-void APU::Master::write(unsigned r, uint8 data) {
-  if(r == 0) {
-    left_enable  = data & 0x80;
-    left_volume  = (data >> 4) & 7;
-    right_enable = data & 0x08;
-    right_volume = (data >> 0) & 7;
-  }
-
-  if(r == 1) {
-    channel4_left_enable  = data & 0x80;
-    channel3_left_enable  = data & 0x40;
-    channel2_left_enable  = data & 0x20;
-    channel1_left_enable  = data & 0x10;
-    channel4_right_enable = data & 0x08;
-    channel3_right_enable = data & 0x04;
-    channel2_right_enable = data & 0x02;
-    channel1_right_enable = data & 0x01;
-  }
-
-  if(r == 2) {
-    enable = data & 0x80;
-  }
-}
-
-void APU::Master::power() {
-  left_enable = 0;
-  left_volume = 0;
-  right_enable = 0;
-  right_volume = 0;
-  channel4_left_enable  = 0;
-  channel3_left_enable  = 0;
-  channel2_left_enable  = 0;
-  channel1_left_enable  = 0;
-  channel4_right_enable = 0;
-  channel3_right_enable = 0;
-  channel2_right_enable = 0;
-  channel1_right_enable = 0;
-  enable = 0;
-
-  center = 0;
-  left   = 0;
-  right  = 0;
-}
-
-void APU::Master::serialize(serializer &s) {
-  s.integer(left_enable);
-  s.integer(left_volume);
-  s.integer(right_enable);
-  s.integer(right_volume);
-  s.integer(channel4_left_enable);
-  s.integer(channel3_left_enable);
-  s.integer(channel2_left_enable);
-  s.integer(channel1_left_enable);
-  s.integer(channel4_right_enable);
-  s.integer(channel3_right_enable);
-  s.integer(channel2_right_enable);
-  s.integer(channel1_right_enable);
-  s.integer(enable);
-
-  s.integer(center);
-  s.integer(left);
-  s.integer(right);
-}
-
-#endif

bsnes/gameboy/apu/master/master.hpp

@@ -1,24 +0,0 @@
-struct Master {
-  bool left_enable;
-  unsigned left_volume;
-  bool right_enable;
-  unsigned right_volume;
-  bool channel4_left_enable;
-  bool channel3_left_enable;
-  bool channel2_left_enable;
-  bool channel1_left_enable;
-  bool channel4_right_enable;
-  bool channel3_right_enable;
-  bool channel2_right_enable;
-  bool channel1_right_enable;
-  bool enable;
-
-  int16 center;
-  int16 left;
-  int16 right;
-
-  void run();
-  void write(unsigned r, uint8 data);
-  void power();
-  void serialize(serializer&);
-};

bsnes/gameboy/apu/noise/noise.cpp

@@ -1,102 +0,0 @@
-#ifdef APU_CPP
-
-void APU::Noise::run() {
-  if(period && --period == 0) {
-    period = divisor << frequency;
-    if(frequency < 14) {
-      bool bit = (lfsr ^ (lfsr >> 1)) & 1;
-      lfsr = (lfsr >> 1) ^ (bit << 14);
-      if(narrow_lfsr) lfsr |= (bit << 6);
-    }
-  }
-
-  uint4 sample = (lfsr & 1) ? 0 : volume;
-  if(counter && length == 0) sample = 0;
-
-  output = (sample * 4369) - 32768;
-}
-
-void APU::Noise::clock_length() {
-  if(counter && length) length--;
-}
-
-void APU::Noise::clock_envelope() {
-  if(envelope_period && --envelope_period == 0) {
-    envelope_period = envelope_frequency;
-    if(envelope_direction == 0 && volume >  0) volume--;
-    if(envelope_direction == 1 && volume < 15) volume++;
-  }
-}
-
-void APU::Noise::write(unsigned r, uint8 data) {
-  if(r == 1) {
-    initial_length = 64 - (data & 0x3f);
-
-    length = initial_length;
-  }
-
-  if(r == 2) {
-    envelope_volume = data >> 4;
-    envelope_direction = data & 0x08;
-    envelope_frequency = data & 0x07;
-  }
-
-  if(r == 3) {
-    frequency = data >> 4;
-    narrow_lfsr = data & 0x08;
-    divisor = (data & 0x07) << 4;
-    if(divisor == 0) divisor = 8;
-
-    period = divisor << frequency;
-  }
-
-  if(r == 4) {
-    bool initialize = data & 0x80;
-    counter = data & 0x40;
-
-    if(initialize) {
-      lfsr = ~0U;
-      length = initial_length;
-      envelope_period = envelope_frequency;
-      volume = envelope_volume;
-    }
-  }
-}
-
-void APU::Noise::power() {
-  initial_length = 0;
-  envelope_volume = 0;
-  envelope_direction = 0;
-  envelope_frequency = 0;
-  frequency = 0;
-  narrow_lfsr = 0;
-  divisor = 0;
-  counter = 0;
-
-  output = 0;
-  length = 0;
-  envelope_period = 0;
-  volume = 0;
-  period = 0;
-  lfsr = 0;
-}
-
-void APU::Noise::serialize(serializer &s) {
-  s.integer(initial_length);
-  s.integer(envelope_volume);
-  s.integer(envelope_direction);
-  s.integer(envelope_frequency);
-  s.integer(frequency);
-  s.integer(narrow_lfsr);
-  s.integer(divisor);
-  s.integer(counter);
-
-  s.integer(output);
-  s.integer(length);
-  s.integer(envelope_period);
-  s.integer(volume);
-  s.integer(period);
-  s.integer(lfsr);
-}
-
-#endif

bsnes/gameboy/apu/noise/noise.hpp

@@ -1,24 +0,0 @@
-struct Noise {
-  unsigned initial_length;
-  unsigned envelope_volume;
-  bool envelope_direction;
-  unsigned envelope_frequency;
-  unsigned frequency;
-  bool narrow_lfsr;
-  unsigned divisor;
-  bool counter;
-
-  int16 output;
-  unsigned length;
-  unsigned envelope_period;
-  unsigned volume;
-  unsigned period;
-  uint15 lfsr;
-
-  void run();
-  void clock_length();
-  void clock_envelope();
-  void write(unsigned r, uint8 data);
-  void power();
-  void serialize(serializer&);
-};

bsnes/gameboy/apu/serialization.cpp

@@ -1,15 +0,0 @@
-#ifdef APU_CPP
-
-void APU::serialize(serializer &s) {
-  s.array(mmio_data);
-  s.integer(sequencer_base);
-  s.integer(sequencer_step);
-
-  square1.serialize(s);
-  square2.serialize(s);
-  wave.serialize(s);
-  noise.serialize(s);
-  master.serialize(s);
-}
-
-#endif

bsnes/gameboy/apu/square1/square1.cpp

@@ -1,146 +0,0 @@
-#ifdef APU_CPP
-
-void APU::Square1::run() {
-  if(period && --period == 0) {
-    period = 4 * (2048 - frequency);
-    phase = (phase + 1) & 7;
-    switch(duty) {
-      case 0: duty_output = (phase == 6); break;  //______-_
-      case 1: duty_output = (phase >= 6); break;  //______--
-      case 2: duty_output = (phase >= 4); break;  //____----
-      case 3: duty_output = (phase <= 5); break;  //------__
-    }
-  }
-
-  uint4 sample = (duty_output ? volume : 0);
-  if(counter && length == 0) sample = 0;
-
-  output = (sample * 4369) - 32768;
-}
-
-void APU::Square1::sweep() {
-  if(enable == false) return;
-
-  signed offset = frequency_shadow >> sweep_shift;
-  if(sweep_direction) offset = -offset;
-  frequency_shadow += offset;
-
-  if(frequency_shadow < 0) {
-    frequency_shadow = 0;
-  } else if(frequency_shadow > 2047) {
-    frequency_shadow = 2048;
-    enable = false;
-  }
-
-  if(frequency_shadow <= 2047 && sweep_shift) {
-    frequency = frequency_shadow;
-    period = 4 * (2048 - frequency);
-  }
-}
-
-void APU::Square1::clock_length() {
-  if(counter && length) length--;
-}
-
-void APU::Square1::clock_sweep() {
-  if(sweep_frequency && sweep_period && --sweep_period == 0) {
-    sweep_period = sweep_frequency;
-    sweep();
-  }
-}
-
-void APU::Square1::clock_envelope() {
-  if(envelope_period && --envelope_period == 0) {
-    envelope_period = envelope_frequency;
-    if(envelope_direction == 0 && volume >  0) volume--;
-    if(envelope_direction == 1 && volume < 15) volume++;
-  }
-}
-
-void APU::Square1::write(unsigned r, uint8 data) {
-  if(r == 0) {
-    sweep_frequency = (data >> 4) & 7;
-    sweep_direction = data & 0x08;
-    sweep_shift = data & 0x07;
-  }
-
-  if(r == 1) {
-    duty = data >> 6;
-    length = data & 0x3f;
-  }
-
-  if(r == 2) {
-    envelope_volume = data >> 4;
-    envelope_direction = data & 0x08;
-    envelope_frequency = data & 0x07;
-  }
-
-  if(r == 3) {
-    frequency = (frequency & 0x0700) | data;
-  }
-
-  if(r == 4) {
-    bool initialize = data & 0x80;
-    counter = data & 0x40;
-    frequency = ((data & 7) << 8) | (frequency & 0x00ff);
-
-    if(initialize) {
-      envelope_period = envelope_frequency;
-      volume = envelope_volume;
-      frequency_shadow = frequency;
-      sweep_period = sweep_frequency;
-      enable = sweep_period || sweep_shift;
-      if(sweep_shift) sweep();
-    }
-  }
-
-  period = 4 * (2048 - frequency);
-}
-
-void APU::Square1::power() {
-  sweep_frequency = 0;
-  sweep_direction = 0;
-  sweep_shift = 0;
-  duty = 0;
-  length = 0;
-  envelope_volume = 0;
-  envelope_direction = 0;
-  envelope_frequency = 0;
-  frequency = 0;
-  counter = 0;
-
-  output = 0;
-  duty_output = 0;
-  phase = 0;
-  period = 0;
-  envelope_period = 0;
-  sweep_period = 0;
-  frequency_shadow = 0;
-  enable = 0;
-  volume = 0;
-}
-
-void APU::Square1::serialize(serializer &s) {
-  s.integer(sweep_frequency);
-  s.integer(sweep_direction);
-  s.integer(sweep_shift);
-  s.integer(duty);
-  s.integer(length);
-  s.integer(envelope_volume);
-  s.integer(envelope_direction);
-  s.integer(envelope_frequency);
-  s.integer(frequency);
-  s.integer(counter);
-
-  s.integer(output);
-  s.integer(duty_output);
-  s.integer(phase);
-  s.integer(period);
-  s.integer(envelope_period);
-  s.integer(sweep_period);
-  s.integer(frequency_shadow);
-  s.integer(enable);
-  s.integer(volume);
-}
-
-#endif

bsnes/gameboy/apu/square1/square1.hpp

@@ -1,31 +0,0 @@
-struct Square1 {
-  unsigned sweep_frequency;
-  unsigned sweep_direction;
-  unsigned sweep_shift;
-  unsigned duty;
-  unsigned length;
-  unsigned envelope_volume;
-  unsigned envelope_direction;
-  unsigned envelope_frequency;
-  unsigned frequency;
-  unsigned counter;
-
-  int16 output;
-  bool duty_output;
-  unsigned phase;
-  unsigned period;
-  unsigned envelope_period;
-  unsigned sweep_period;
-  signed frequency_shadow;
-  bool enable;
-  unsigned volume;
-
-  void run();
-  void sweep();
-  void clock_length();
-  void clock_sweep();
-  void clock_envelope();
-  void write(unsigned r, uint8 data);
-  void power();
-  void serialize(serializer&);
-};

bsnes/gameboy/apu/square2/square2.cpp

@@ -1,97 +0,0 @@
-#ifdef APU_CPP
-
-void APU::Square2::run() {
-  if(period && --period == 0) {
-    period = 4 * (2048 - frequency);
-    phase = (phase + 1) & 7;
-    switch(duty) {
-      case 0: duty_output = (phase == 6); break;  //______-_
-      case 1: duty_output = (phase >= 6); break;  //______--
-      case 2: duty_output = (phase >= 4); break;  //____----
-      case 3: duty_output = (phase <= 5); break;  //------__
-    }
-  }
-
-  uint4 sample = (duty_output ? volume : 0);
-  if(counter && length == 0) sample = 0;
-
-  output = (sample * 4369) - 32768;
-}
-
-void APU::Square2::clock_length() {
-  if(counter && length) length--;
-}
-
-void APU::Square2::clock_envelope() {
-  if(envelope_period && --envelope_period == 0) {
-    envelope_period = envelope_frequency;
-    if(envelope_direction == 0 && volume >  0) volume--;
-    if(envelope_direction == 1 && volume < 15) volume++;
-  }
-}
-
-void APU::Square2::write(unsigned r, uint8 data) {
-  if(r == 1) {
-    duty = data >> 6;
-    length = data & 0x3f;
-  }
-
-  if(r == 2) {
-    envelope_volume = data >> 4;
-    envelope_direction = data & 0x08;
-    envelope_frequency = data & 0x07;
-  }
-
-  if(r == 3) {
-    frequency = (frequency & 0x0700) | data;
-  }
-
-  if(r == 4) {
-    bool initialize = data & 0x80;
-    counter = data & 0x40;
-    frequency = ((data & 7) << 8) | (frequency & 0x00ff);
-
-    if(initialize) {
-      envelope_period = envelope_frequency;
-      volume = envelope_volume;
-    }
-  }
-
-  period = 4 * (2048 - frequency);
-}
-
-void APU::Square2::power() {
-  duty = 0;
-  length = 0;
-  envelope_volume = 0;
-  envelope_direction = 0;
-  envelope_frequency = 0;
-  frequency = 0;
-  counter = 0;
-
-  output = 0;
-  duty_output = 0;
-  phase = 0;
-  period = 0;
-  envelope_period = 0;
-  volume = 0;
-}
-
-void APU::Square2::serialize(serializer &s) {
-  s.integer(duty);
-  s.integer(length);
-  s.integer(envelope_volume);
-  s.integer(envelope_direction);
-  s.integer(envelope_frequency);
-  s.integer(frequency);
-  s.integer(counter);
-
-  s.integer(output);
-  s.integer(duty_output);
-  s.integer(phase);
-  s.integer(period);
-  s.integer(envelope_period);
-  s.integer(volume);
-}
-
-#endif

bsnes/gameboy/apu/square2/square2.hpp

@@ -1,23 +0,0 @@
-struct Square2 {
-  unsigned duty;
-  unsigned length;
-  unsigned envelope_volume;
-  unsigned envelope_direction;
-  unsigned envelope_frequency;
-  unsigned frequency;
-  unsigned counter;
-
-  int16 output;
-  bool duty_output;
-  unsigned phase;
-  unsigned period;
-  unsigned envelope_period;
-  unsigned volume;
-
-  void run();
-  void clock_length();
-  void clock_envelope();
-  void write(unsigned r, uint8 data);
-  void power();
-  void serialize(serializer&);
-};

bsnes/gameboy/apu/wave/wave.cpp

@@ -1,103 +0,0 @@
-#ifdef APU_CPP
-
-void APU::Wave::run() {
-  if(period && --period == 0) {
-    period = 2 * (2048 - frequency);
-    pattern_offset = (pattern_offset + 1) & 31;
-    pattern_sample = pattern[pattern_offset];
-  }
-
-  uint4 sample = pattern_sample;
-  if(counter && length == 0) sample = 0;
-  if(enable == false) sample = 0;
-
-  output = (sample * 4369) - 32768;
-  output >>= volume;
-}
-
-void APU::Wave::clock_length() {
-  if(counter && length) length--;
-}
-
-void APU::Wave::write(unsigned r, uint8 data) {
-  if(r == 0) {
-    dac_enable = data & 0x80;
-
-    if(dac_enable == false) enable = false;
-  }
-
-  if(r == 1) {
-    initial_length = 256 - data;
-
-    length = initial_length;
-  }
-
-  if(r == 2) {
-    switch((data >> 5) & 3) {
-      case 0: volume = 16; break;  //  0%
-      case 1: volume =  0; break;  //100%
-      case 2: volume =  1; break;  // 50%
-      case 3: volume =  2; break;  // 25%
-    }
-  }
-
-  if(r == 3) {
-    frequency = (frequency & 0x0700) | data;
-  }
-
-  if(r == 4) {
-    bool initialize = data & 0x80;
-    counter = data & 0x40;
-    frequency = ((data & 7) << 8) | (frequency & 0x00ff);
-
-    if(initialize && dac_enable) {
-      enable = true;
-      pattern_offset = 0;
-      length = initial_length;
-    }
-  }
-
-  period = 2 * (2048 - frequency);
-}
-
-void APU::Wave::write_pattern(unsigned p, uint8 data) {
-  p <<= 1;
-  pattern[p + 0] = (data >> 4) & 15;
-  pattern[p + 1] = (data >> 0) & 15;
-}
-
-void APU::Wave::power() {
-  dac_enable = 0;
-  initial_length = 0;
-  volume = 0;
-  frequency = 0;
-  counter = 0;
-
-  random_lfsr r;
-  foreach(n, pattern) n = r() & 15;
-
-  output = 0;
-  enable = 0;
-  length = 0;
-  period = 0;
-  pattern_offset = 0;
-  pattern_sample = 0;
-}
-
-void APU::Wave::serialize(serializer &s) {
-  s.integer(dac_enable);
-  s.integer(initial_length);
-  s.integer(volume);
-  s.integer(frequency);
-  s.integer(counter);
-  s.array(pattern);
-
-  s.integer(output);
-  s.integer(enable);
-  s.integer(length);
-  s.integer(period);
-  s.integer(pattern_offset);
-  s.integer(pattern_sample);
-}
-
-#endif

bsnes/gameboy/apu/wave/wave.hpp

@@ -1,22 +0,0 @@
-struct Wave {
-  bool dac_enable;
-  unsigned initial_length;
-  unsigned volume;
-  unsigned frequency;
-  bool counter;
-  uint8 pattern[32];
-
-  int16 output;
-  bool enable;
-  unsigned length;
-  unsigned period;
-  unsigned pattern_offset;
-  unsigned pattern_sample;
-
-  void run();
-  void clock_length();
-  void write(unsigned r, uint8 data);
-  void write_pattern(unsigned p, uint8 data);
-  void power();
-  void serialize(serializer&);
-};

bsnes/gameboy/cartridge/cartridge.cpp

@@ -1,156 +0,0 @@
-#include <gameboy/gameboy.hpp>
-
-#include <nall/crc32.hpp>
-
-#define CARTRIDGE_CPP
-namespace GameBoy {
-
-#include "mbc0/mbc0.cpp"
-#include "mbc1/mbc1.cpp"
-#include "mbc2/mbc2.cpp"
-#include "mbc3/mbc3.cpp"
-#include "mbc5/mbc5.cpp"
-#include "mmm01/mmm01.cpp"
-#include "huc1/huc1.cpp"
-#include "huc3/huc3.cpp"
-#include "serialization.cpp"
-Cartridge cartridge;
-
-void Cartridge::load(const string &xml, const uint8_t *data, unsigned size) {
-  if(size == 0) size = 32768;
-  romdata = allocate<uint8>(romsize = size, 0xff);
-  if(data) memcpy(romdata, data, size);
-
-//uint32_t crc = crc32_calculate(data, size);
-//print("CRC32 = ", hex<4>(crc), "\n");
-
-  info.mapper = Mapper::Unknown;
-  info.ram = false;
-  info.battery = false;
-  info.rtc = false;
-  info.rumble = false;
-
-  info.romsize = 0;
-  info.ramsize = 0;
-
-  xml_element document = xml_parse(xml);
-  foreach(head, document.element) {
-    if(head.name == "cartridge") {
-      foreach(attr, head.attribute) {
-        if(attr.name == "mapper") {
-          if(attr.content == "none")  info.mapper = Mapper::MBC0;
-          if(attr.content == "MBC1")  info.mapper = Mapper::MBC1;
-          if(attr.content == "MBC2")  info.mapper = Mapper::MBC2;
-          if(attr.content == "MBC3")  info.mapper = Mapper::MBC3;
-          if(attr.content == "MBC5")  info.mapper = Mapper::MBC5;
-          if(attr.content == "MMM01") info.mapper = Mapper::MMM01;
-          if(attr.content == "HuC1")  info.mapper = Mapper::HuC1;
-          if(attr.content == "HuC3")  info.mapper = Mapper::HuC3;
-        }
-
-        if(attr.name == "rtc") info.rtc = (attr.content == "true" ? true : false);
-        if(attr.name == "rumble") info.rumble = (attr.content == "true" ? true : false);
-      }
-
-      foreach(elem, head.element) {
-        if(elem.name == "rom") {
-          foreach(attr, elem.attribute) {
-            if(attr.name == "size") info.romsize = hex(attr.content);
-          }
-        }
-
-        if(elem.name == "ram") {
-          info.ram = true;
-          foreach(attr, elem.attribute) {
-            if(attr.name == "size") info.ramsize = hex(attr.content);
-            if(attr.name == "battery") info.battery = (attr.content == "true" ? true : false);
-          }
-        }
-      }
-    }
-  }
-
-  switch(info.mapper) { default:
-    case Mapper::MBC0:  mapper = &mbc0;  break;
-    case Mapper::MBC1:  mapper = &mbc1;  break;
-    case Mapper::MBC2:  mapper = &mbc2;  break;
-    case Mapper::MBC3:  mapper = &mbc3;  break;
-    case Mapper::MBC5:  mapper = &mbc5;  break;
-    case Mapper::MMM01: mapper = &mmm01; break;
-    case Mapper::HuC1:  mapper = &huc1;  break;
-    case Mapper::HuC3:  mapper = &huc3;  break;
-  }
-
-  ramdata = new uint8_t[ramsize = info.ramsize]();
-  system.load();
-  loaded = true;
-}
-
-void Cartridge::unload() {
-  if(loaded == false) return;
-
-  if(romdata) { delete[] romdata; romdata = 0; }
-  if(ramdata) { delete[] ramdata; ramdata = 0; }
-  loaded = false;
-}
-
-uint8 Cartridge::rom_read(unsigned addr) {
-  if(addr >= romsize) addr %= romsize;
-  return romdata[addr];
-}
-
-void Cartridge::rom_write(unsigned addr, uint8 data) {
-  if(addr >= romsize) addr %= romsize;
-  romdata[addr] = data;
-}
-
-uint8 Cartridge::ram_read(unsigned addr) {
-  if(ramsize == 0) return 0x00;
-  if(addr >= ramsize) addr %= ramsize;
-  return ramdata[addr];
-}
-
-void Cartridge::ram_write(unsigned addr, uint8 data) {
-  if(ramsize == 0) return;
-  if(addr >= ramsize) addr %= ramsize;
-  ramdata[addr] = data;
-}
-
-uint8 Cartridge::mmio_read(uint16 addr) {
-  if(bootrom_enable && within<0x0000, 0x00ff>(addr)) return System::BootROM::sgb[addr];
-  return mapper->mmio_read(addr);
-}
-
-void Cartridge::mmio_write(uint16 addr, uint8 data) {
-  if(bootrom_enable && addr == 0xff50) bootrom_enable = false;
-  mapper->mmio_write(addr, data);
-}
-
-void Cartridge::power() {
-  bootrom_enable = true;
-
-  mbc0.power();
-  mbc1.power();
-  mbc2.power();
-  mbc3.power();
-  mbc5.power();
-  mmm01.power();
-  huc1.power();
-  huc3.power();
-
-  for(unsigned n = 0x0000; n <= 0x7fff; n++) bus.mmio[n] = this;
-  for(unsigned n = 0xa000; n <= 0xbfff; n++) bus.mmio[n] = this;
-  bus.mmio[0xff50] = this;
-}
-
-Cartridge::Cartridge() {
-  loaded = false;
-  romdata = 0;
-  ramdata = 0;
-}
-
-Cartridge::~Cartridge() {
-  unload();
-}
-
-}

bsnes/gameboy/cartridge/cartridge.hpp

@@ -1,65 +0,0 @@
-struct Cartridge : MMIO, property<Cartridge> {
-  #include "mbc0/mbc0.hpp"
-  #include "mbc1/mbc1.hpp"
-  #include "mbc2/mbc2.hpp"
-  #include "mbc3/mbc3.hpp"
-  #include "mbc5/mbc5.hpp"
-  #include "mmm01/mmm01.hpp"
-  #include "huc1/huc1.hpp"
-  #include "huc3/huc3.hpp"
-
-  enum Mapper : unsigned {
-    MBC0,
-    MBC1,
-    MBC2,
-    MBC3,
-    MBC5,
-    MMM01,
-    HuC1,
-    HuC3,
-    Unknown,
-  };
-
-  struct Information {
-    string xml;
-
-    Mapper mapper;
-    bool ram;
-    bool battery;
-    bool rtc;
-    bool rumble;
-
-    unsigned romsize;
-    unsigned ramsize;
-  } info;
-
-  readonly<bool> loaded;
-
-  uint8_t *romdata;
-  unsigned romsize;
-
-  uint8_t *ramdata;
-  unsigned ramsize;
-
-  MMIO *mapper;
-  bool bootrom_enable;
-
-  void load(const string &xml, const uint8_t *data, unsigned size);
-  void unload();
-
-  uint8 rom_read(unsigned addr);
-  void rom_write(unsigned addr, uint8 data);
-  uint8 ram_read(unsigned addr);
-  void ram_write(unsigned addr, uint8 data);
-
-  uint8 mmio_read(uint16 addr);
-  void mmio_write(uint16 addr, uint8 data);
-
-  void power();
-
-  void serialize(serializer&);
-  Cartridge();
-  ~Cartridge();
-};
-
-extern Cartridge cartridge;

bsnes/gameboy/cartridge/huc1/huc1.cpp

@@ -1,53 +0,0 @@
-#ifdef CARTRIDGE_CPP
-
-uint8 Cartridge::HuC1::mmio_read(uint16 addr) {
-  if(within<0x0000, 0x3fff>(addr)) {
-    return cartridge.rom_read(addr);
-  }
-
-  if(within<0x4000, 0x7fff>(addr)) {
-    return cartridge.rom_read((rom_select << 14) | (addr & 0x3fff));
-  }
-
-  if(within<0xa000, 0xbfff>(addr)) {
-    if(ram_enable) return cartridge.ram_read((ram_select << 13) | (addr & 0x1fff));
-    return 0x00;
-  }
-
-  return 0x00;
-}
-
-void Cartridge::HuC1::mmio_write(uint16 addr, uint8 data) {
-  if(within<0x0000, 0x1fff>(addr)) {
-    ram_enable = (data & 0x0f) == 0x0a;
-    return;
-  }
-
-  if(within<0x2000, 0x3fff>(addr)) {
-    rom_select = data;
-    return;
-  }
-
-  if(within<0x4000, 0x5fff>(addr)) {
-    ram_select = data;
-    return;
-  }
-
-  if(within<0x6000, 0x7fff>(addr)) {
-    //unknown purpose
-    return;
-  }
-
-  if(within<0xa000, 0xbfff>(addr)) {
-    if(ram_enable) cartridge.ram_write((ram_select << 13) | (addr & 0x1fff), data);
-    return;
-  }
-}
-
-void Cartridge::HuC1::power() {
-  ram_enable = false;
-  rom_select = 0x01;
-  ram_select = 0x00;
-}
-
-#endif

bsnes/gameboy/cartridge/huc1/huc1.hpp

@@ -1,9 +0,0 @@
-struct HuC1 : MMIO {
-  bool ram_enable;   //0000-1fff
-  uint8 rom_select;  //2000-3fff
-  uint8 ram_select;  //4000-5fff
-
-  uint8 mmio_read(uint16 addr);
-  void mmio_write(uint16 addr, uint8 data);
-  void power();
-} huc1;

bsnes/gameboy/cartridge/huc3/huc3.cpp

@@ -1,53 +0,0 @@
-#ifdef CARTRIDGE_CPP
-
-uint8 Cartridge::HuC3::mmio_read(uint16 addr) {
-  if(within<0x0000, 0x3fff>(addr)) {
-    return cartridge.rom_read(addr);
-  }
-
-  if(within<0x4000, 0x7fff>(addr)) {
-    return cartridge.rom_read((rom_select << 14) | (addr & 0x3fff));
-  }
-
-  if(within<0xa000, 0xbfff>(addr)) {
-    if(ram_enable) return cartridge.ram_read((ram_select << 13) | (addr & 0x1fff));
-    return 0x00;
-  }
-
-  return 0x00;
-}
-
-void Cartridge::HuC3::mmio_write(uint16 addr, uint8 data) {
-  if(within<0x0000, 0x1fff>(addr)) {
-    ram_enable = (data & 0x0f) == 0x0a;
-    return;
-  }
-
-  if(within<0x2000, 0x3fff>(addr)) {
-    rom_select = data;
-    return;
-  }
-
-  if(within<0x4000, 0x5fff>(addr)) {
-    ram_select = data;
-    return;
-  }
-
-  if(within<0x6000, 0x7fff>(addr)) {
-    //unknown purpose
-    return;
-  }
-
-  if(within<0xa000, 0xbfff>(addr)) {
-    if(ram_enable) cartridge.ram_write((ram_select << 13) | (addr & 0x1fff), data);
-    return;
-  }
-}
-
-void Cartridge::HuC3::power() {
-  ram_enable = false;
-  rom_select = 0x01;
-  ram_select = 0x00;
-}
-
-#endif

bsnes/gameboy/cartridge/huc3/huc3.hpp

@@ -1,9 +0,0 @@
-struct HuC3 : MMIO {
-  bool ram_enable;   //0000-1fff
-  uint8 rom_select;  //2000-3fff
-  uint8 ram_select;  //4000-5fff
-
-  uint8 mmio_read(uint16 addr);
-  void mmio_write(uint16 addr, uint8 data);
-  void power();
-} huc3;

bsnes/gameboy/cartridge/mbc0/mbc0.cpp

@@ -1,25 +0,0 @@
-#ifdef CARTRIDGE_CPP
-
-uint8 Cartridge::MBC0::mmio_read(uint16 addr) {
-  if(within<0x0000, 0x7fff>(addr)) {
-    return cartridge.rom_read(addr);
-  }
-
-  if(within<0xa000, 0xbfff>(addr)) {
-    return cartridge.ram_read(addr & 0x1fff);
-  }
-
-  return 0x00;
-}
-
-void Cartridge::MBC0::mmio_write(uint16 addr, uint8 data) {
-  if(within<0xa000, 0xbfff>(addr)) {
-    cartridge.ram_write(addr & 0x1fff, data);
-    return;
-  }
-}
-
-void Cartridge::MBC0::power() {
-}
-
-#endif

bsnes/gameboy/cartridge/mbc0/mbc0.hpp

@@ -1,5 +0,0 @@
-struct MBC0 : MMIO {
-  uint8 mmio_read(uint16 addr);
-  void mmio_write(uint16 addr, uint8 data);
-  void power();
-} mbc0;

bsnes/gameboy/cartridge/mbc1/mbc1.cpp

@@ -1,70 +0,0 @@
-#ifdef CARTRIDGE_CPP
-
-uint8 Cartridge::MBC1::mmio_read(uint16 addr) {
-  if(within<0x0000, 0x3fff>(addr)) {
-    return cartridge.rom_read(addr);
-  }
-
-  if(within<0x4000, 0x7fff>(addr)) {
-    if(mode_select == 0) {
-      return cartridge.rom_read((ram_select << 19) | (rom_select << 14) | (addr & 0x3fff));
-    } else {
-      return cartridge.rom_read((rom_select << 14) | (addr & 0x3fff));
-    }
-  }
-
-  if(within<0xa000, 0xbfff>(addr)) {
-    if(ram_enable) {
-      if(mode_select == 0) {
-        return cartridge.ram_read(addr & 0x1fff);
-      } else {
-        return cartridge.ram_read((ram_select << 13) | (addr & 0x1fff));
-      }
-    }
-    return 0x00;
-  }
-
-  return 0x00;
-}
-
-void Cartridge::MBC1::mmio_write(uint16 addr, uint8 data) {
-  if(within<0x0000, 0x1fff>(addr)) {
-    ram_enable = (data & 0x0f) == 0x0a;
-    return;
-  }
-
-  if(within<0x2000, 0x3fff>(addr)) {
-    rom_select = (data & 0x1f) + ((data & 0x1f) == 0);
-    return;
-  }
-
-  if(within<0x4000, 0x5fff>(addr)) {
-    ram_select = data & 0x03;
-    return;
-  }
-
-  if(within<0x6000, 0x7fff>(addr)) {
-    mode_select = data & 0x01;
-    return;
-  }
-
-  if(within<0xa000, 0xbfff>(addr)) {
-    if(ram_enable) {
-      if(mode_select == 0) {
-        cartridge.ram_write(addr & 0x1fff, data);
-      } else {
-        cartridge.ram_write((ram_select << 13) | (addr & 0x1fff), data);
-      }
-    }
-    return;
-  }
-}
-
-void Cartridge::MBC1::power() {
-  ram_enable = false;
-  rom_select = 0x01;
-  ram_select = 0x00;
-  mode_select = 0;
-}
-
-#endif

bsnes/gameboy/cartridge/mbc1/mbc1.hpp

@@ -1,10 +0,0 @@
-struct MBC1 : MMIO {
-  bool  ram_enable;   //0000-1fff
-  uint8 rom_select;   //2000-3fff
-  uint8 ram_select;   //4000-5fff
-  bool  mode_select;  //6000-7fff
-
-  uint8 mmio_read(uint16 addr);
-  void mmio_write(uint16 addr, uint8 data);
-  void power();
-} mbc1;

bsnes/gameboy/cartridge/mbc2/mbc2.cpp

@@ -1,42 +0,0 @@
-#ifdef CARTRIDGE_CPP
-
-uint8 Cartridge::MBC2::mmio_read(uint16 addr) {
-  if(within<0x0000, 0x3fff>(addr)) {
-    return cartridge.rom_read(addr);
-  }
-
-  if(within<0x4000, 0x7fff>(addr)) {
-    return cartridge.rom_read((rom_select << 14) | (addr & 0x3fff));
-  }
-
-  if(within<0xa000, 0xa1ff>(addr)) {
-    if(ram_enable) return cartridge.ram_read(addr & 0x1ff);
-    return 0x00;
-  }
-
-  return 0x00;
-}
-
-void Cartridge::MBC2::mmio_write(uint16 addr, uint8 data) {
-  if(within<0x0000, 0x1fff>(addr)) {
-    if(!(addr & 0x0100)) ram_enable = (data & 0x0f) == 0x0a;
-    return;
-  }
-
-  if(within<0x2000, 0x3fff>(addr)) {
-    if( (addr & 0x0100)) rom_select = (data & 0x0f) + ((data & 0x0f) == 0);
-    return;
-  }
-
-  if(within<0xa000, 0xa1ff>(addr)) {
-    if(ram_enable) cartridge.ram_write(addr & 0x1ff, data & 0x0f);
-    return;
-  }
-}
-
-void Cartridge::MBC2::power() {
-  ram_enable = false;
-  rom_select = 0x01;
-}
-
-#endif

bsnes/gameboy/cartridge/mbc2/mbc2.hpp

@@ -1,8 +0,0 @@
-struct MBC2 : MMIO {
-  bool  ram_enable;  //0000-1fff
-  uint8 rom_select;  //2000-3fff
-
-  uint8 mmio_read(uint16 addr);
-  void mmio_write(uint16 addr, uint8 data);
-  void power();
-} mbc2;

bsnes/gameboy/cartridge/mbc3/mbc3.cpp

@@ -1,120 +0,0 @@
-#ifdef CARTRIDGE_CPP
-
-void Cartridge::MBC3::second() {
-  if(rtc_halt == false) {
-    if(++rtc_second >= 60) {
-      rtc_second = 0;
-      if(++rtc_minute >= 60) {
-        rtc_minute = 0;
-        if(++rtc_hour >= 24) {
-          rtc_hour = 0;
-          if(++rtc_day >= 512) {
-            rtc_day = 0;
-            rtc_day_carry = true;
-          }
-        }
-      }
-    }
-  }
-}
-
-uint8 Cartridge::MBC3::mmio_read(uint16 addr) {
-  if(within<0x0000, 0x3fff>(addr)) {
-    return cartridge.rom_read(addr);
-  }
-
-  if(within<0x4000, 0x7fff>(addr)) {
-    return cartridge.rom_read((rom_select << 14) | (addr & 0x3fff));
-  }
-
-  if(within<0xa000, 0xbfff>(addr)) {
-    if(ram_enable) {
-      if(ram_select >= 0x00 && ram_select <= 0x03) {
-        return cartridge.ram_read((ram_select << 13) | (addr & 0x1fff));
-      }
-      if(ram_select == 0x08) return rtc_latch_second;
-      if(ram_select == 0x09) return rtc_latch_minute;
-      if(ram_select == 0x0a) return rtc_latch_hour;
-      if(ram_select == 0x0b) return rtc_latch_day;
-      if(ram_select == 0x0c) return (rtc_latch_day_carry << 7) | (rtc_latch_day >> 8);
-    }
-    return 0x00;
-  }
-
-  return 0x00;
-}
-
-void Cartridge::MBC3::mmio_write(uint16 addr, uint8 data) {
-  if(within<0x0000, 0x1fff>(addr)) {
-    ram_enable = (data & 0x0f) == 0x0a;
-    return;
-  }
-
-  if(within<0x2000, 0x3fff>(addr)) {
-    rom_select = (data & 0x7f) + ((data & 0x7f) == 0);
-    return;
-  }
-
-  if(within<0x4000, 0x5fff>(addr)) {
-    ram_select = data;
-    return;
-  }
-
-  if(within<0x6000, 0x7fff>(addr)) {
-    if(rtc_latch == 0 && data == 1) {
-      rtc_latch_second = rtc_second;
-      rtc_latch_minute = rtc_minute;
-      rtc_latch_hour = rtc_hour;
-      rtc_latch_day = rtc_day;
-      rtc_latch_day_carry = rtc_day_carry;
-    }
-    rtc_latch = data;
-    return;
-  }
-
-  if(within<0xa000, 0xbfff>(addr)) {
-    if(ram_enable) {
-      if(ram_select >= 0x00 && ram_select <= 0x03) {
-        cartridge.ram_write((ram_select << 13) | (addr & 0x1fff), data);
-      } else if(ram_select == 0x08) {
-        if(data >= 60) data = 0;
-        rtc_second = data;
-      } else if(ram_select == 0x09) {
-        if(data >= 60) data = 0;
-        rtc_minute = data;
-      } else if(ram_select == 0x0a) {
-        if(data >= 24) data = 0;
-        rtc_hour = data;
-      } else if(ram_select == 0x0b) {
-        rtc_day = (rtc_day & 0x0100) | data;
-      } else if(ram_select == 0x0c) {
-        rtc_day = ((data & 1) << 8) | (rtc_day & 0xff);
-        rtc_halt = data & 0x40;
-        rtc_day_carry = data & 0x80;
-      }
-    }
-    return;
-  }
-}
-
-void Cartridge::MBC3::power() {
-  ram_enable = false;
-  rom_select = 0x01;
-  ram_select = 0x00;
-  rtc_latch = 0;
-
-  rtc_halt = true;
-  rtc_second = 0;
-  rtc_minute = 0;
-  rtc_hour = 0;
-  rtc_day = 0;
-  rtc_day_carry = false;
-
-  rtc_latch_second = 0;
-  rtc_latch_minute = 0;
-  rtc_latch_hour = 0;
-  rtc_latch_day = 0;
-  rtc_latch_day_carry = false;
-}
-
-#endif

bsnes/gameboy/cartridge/mbc3/mbc3.hpp

@@ -1,24 +0,0 @@
-struct MBC3 : MMIO {
-  bool  ram_enable;  //0000-1fff
-  uint8 rom_select;  //2000-3fff
-  uint8 ram_select;  //4000-5fff
-  bool rtc_latch;    //6000-7fff
-
-  bool rtc_halt;
-  unsigned rtc_second;
-  unsigned rtc_minute;
-  unsigned rtc_hour;
-  unsigned rtc_day;
-  bool rtc_day_carry;
-
-  unsigned rtc_latch_second;
-  unsigned rtc_latch_minute;
-  unsigned rtc_latch_hour;
-  unsigned rtc_latch_day;
-  unsigned rtc_latch_day_carry;
-
-  void second();
-  uint8 mmio_read(uint16 addr);
-  void mmio_write(uint16 addr, uint8 data);
-  void power();
-} mbc3;

bsnes/gameboy/cartridge/mbc5/mbc5.cpp

@@ -1,53 +0,0 @@
-#ifdef CARTRIDGE_CPP
-
-uint8 Cartridge::MBC5::mmio_read(uint16 addr) {
-  if(within<0x0000, 0x3fff>(addr)) {
-    return cartridge.rom_read(addr);
-  }
-
-  if(within<0x4000, 0x7fff>(addr)) {
-    return cartridge.rom_read((rom_select << 14) | (addr & 0x3fff));
-  }
-
-  if(within<0xa000, 0xbfff>(addr)) {
-    if(ram_enable) return cartridge.ram_read((ram_select << 13) | (addr & 0x1fff));
-    return 0x00;
-  }
-
-  return 0x00;
-}
-
-void Cartridge::MBC5::mmio_write(uint16 addr, uint8 data) {
-  if(within<0x0000, 0x1fff>(addr)) {
-    ram_enable = (data & 0x0f) == 0x0a;
-    return;
-  }
-
-  if(within<0x2000, 0x2fff>(addr)) {
-    rom_select = (rom_select & 0x0100) | data;
-    return;
-  }
-
-  if(within<0x3000, 0x3fff>(addr)) {
-    rom_select = ((data & 1) << 8) | (rom_select & 0x00ff);
-    return;
-  }
-
-  if(within<0x4000, 0x5fff>(addr)) {
-    ram_select = data & 0x0f;
-    return;
-  }
-
-  if(within<0xa000, 0xbfff>(addr)) {
-    if(ram_enable) cartridge.ram_write((ram_select << 13) | (addr & 0x1fff), data);
-    return;
-  }
-}
-
-void Cartridge::MBC5::power() {
-  ram_enable = false;
-  rom_select = 0x001;
-  ram_select = 0x00;
-}
-
-#endif

bsnes/gameboy/cartridge/mbc5/mbc5.hpp

@@ -1,9 +0,0 @@
-struct MBC5 : MMIO {
-  bool ram_enable;    //0000-1fff
-  uint16 rom_select;  //2000-2fff + 3000-3fff
-  uint8 ram_select;   //4000-5fff
-
-  uint8 mmio_read(uint16 addr);
-  void mmio_write(uint16 addr, uint8 data);
-  void power();
-} mbc5;

bsnes/gameboy/cartridge/mmm01/mmm01.cpp

@@ -1,65 +0,0 @@
-#ifdef CARTRIDGE_CPP
-
-uint8 Cartridge::MMM01::mmio_read(uint16 addr) {
-  if(within<0x0000, 0x7fff>(addr)) {
-    if(rom_mode == 0) return cartridge.rom_read(addr);
-  }
-
-  if(within<0x0000, 0x3fff>(addr)) {
-    return cartridge.rom_read(0x8000 + (rom_base << 14) + (addr & 0x3fff));
-  }
-
-  if(within<0x4000, 0x7fff>(addr)) {
-    return cartridge.rom_read(0x8000 + (rom_base << 14) + (rom_select << 14) + (addr & 0x3fff));
-  }
-
-  if(within<0xa000, 0xbfff>(addr)) {
-    if(ram_enable) return cartridge.ram_read((ram_select << 13) + (addr & 0x1fff));
-    return 0x00;
-  }
-
-  return 0x00;
-}
-
-void Cartridge::MMM01::mmio_write(uint16 addr, uint8 data) {
-  if(within<0x0000, 0x1fff>(addr)) {
-    if(rom_mode == 0) {
-      rom_mode = 1;
-    } else {
-      ram_enable = (data & 0x0f) == 0x0a;
-    }
-  }
-
-  if(within<0x2000, 0x3fff>(addr)) {
-    if(rom_mode == 0) {
-      rom_base = data & 0x3f;
-    } else {
-      rom_select = data;
-    }
-  }
-
-  if(within<0x4000, 0x5fff>(addr)) {
-    if(rom_mode == 1) {
-      ram_select = data;
-    }
-  }
-
-  if(within<0x6000, 0x7fff>(addr)) {
-    //unknown purpose
-  }
-
-  if(within<0xa000, 0xbfff>(addr)) {
-    if(ram_enable) cartridge.ram_write((ram_select << 13) + (addr & 0x1fff), data);
-  }
-}
-
-void Cartridge::MMM01::power() {
-  rom_mode = 0;
-  rom_base = 0x00;
-
-  ram_enable = false;
-  rom_select = 0x01;
-  ram_select = 0x00;
-}
-
-#endif

bsnes/gameboy/cartridge/mmm01/mmm01.hpp

@@ -1,12 +0,0 @@
-struct MMM01 : MMIO {
-  bool rom_mode;
-  uint8 rom_base;
-
-  bool ram_enable;
-  uint8 rom_select;
-  uint8 ram_select;
-
-  uint8 mmio_read(uint16 addr);
-  void mmio_write(uint16 addr, uint8 data);
-  void power();
-} mmm01;

bsnes/gameboy/cartridge/serialization.cpp

@@ -1,53 +0,0 @@
-#ifdef CARTRIDGE_CPP
-
-void Cartridge::serialize(serializer &s) {
-  if(info.battery) s.array(ramdata, ramsize);
-  s.integer(bootrom_enable);
-
-  s.integer(mbc1.ram_enable);
-  s.integer(mbc1.rom_select);
-  s.integer(mbc1.ram_select);
-  s.integer(mbc1.mode_select);
-
-  s.integer(mbc2.ram_enable);
-  s.integer(mbc2.rom_select);
-
-  s.integer(mbc3.ram_enable);
-  s.integer(mbc3.rom_select);
-  s.integer(mbc3.ram_select);
-  s.integer(mbc3.rtc_latch);
-
-  s.integer(mbc3.rtc_halt);
-  s.integer(mbc3.rtc_second);
-  s.integer(mbc3.rtc_minute);
-  s.integer(mbc3.rtc_hour);
-  s.integer(mbc3.rtc_day);
-  s.integer(mbc3.rtc_day_carry);
-
-  s.integer(mbc3.rtc_latch_second);
-  s.integer(mbc3.rtc_latch_minute);
-  s.integer(mbc3.rtc_latch_hour);
-  s.integer(mbc3.rtc_latch_day);
-  s.integer(mbc3.rtc_latch_day_carry);
-
-  s.integer(mbc5.ram_enable);
-  s.integer(mbc5.rom_select);
-  s.integer(mbc5.ram_select);
-
-  s.integer(mmm01.rom_mode);
-  s.integer(mmm01.rom_base);
-
-  s.integer(mmm01.ram_enable);
-  s.integer(mmm01.rom_select);
-  s.integer(mmm01.ram_select);
-
-  s.integer(huc1.ram_enable);
-  s.integer(huc1.rom_select);
-  s.integer(huc1.ram_select);
-
-  s.integer(huc3.ram_enable);
-  s.integer(huc3.rom_select);
-  s.integer(huc3.ram_select);
-}
-
-#endif

bsnes/gameboy/cpu/core/core.cpp

@@ -1,674 +0,0 @@
-#ifdef CPU_CPP
-
-#include "table.cpp"
-#include "disassembler.cpp"
-
-void CPU::op_xx() {
-}
-
-void CPU::op_cb() {
-  uint8 opcode = op_read(r[PC]++);
-  (this->*opcode_table_cb[opcode])();
-}
-
-//8-bit load commands
-
-template<unsigned x, unsigned y> void CPU::op_ld_r_r() {
-  r[x] = r[y];
-}
-
-template<unsigned x> void CPU::op_ld_r_n() {
-  r[x] = op_read(r[PC]++);
-}
-
-template<unsigned x> void CPU::op_ld_r_hl() {
-  r[x] = op_read(r[HL]);
-}
-
-template<unsigned x> void CPU::op_ld_hl_r() {
-  op_write(r[HL], r[x]);
-}
-
-void CPU::op_ld_hl_n() {
-  op_write(r[HL], op_read(r[PC]++));
-}
-
-template<unsigned x> void CPU::op_ld_a_rr() {
-  r[A] = op_read(r[x]);
-}
-
-void CPU::op_ld_a_nn() {
-  uint8 lo = op_read(r[PC]++);
-  uint8 hi = op_read(r[PC]++);
-  r[A] = op_read((hi << 8) | (lo << 0));
-}
-
-template<unsigned x> void CPU::op_ld_rr_a() {
-  op_write(r[x], r[A]);
-}
-
-void CPU::op_ld_nn_a() {
-  uint8 lo = op_read(r[PC]++);
-  uint8 hi = op_read(r[PC]++);
-  op_write((hi << 8) | (lo << 0), r[A]);
-}
-
-void CPU::op_ld_a_ffn() {
-  r[A] = op_read(0xff00 + op_read(r[PC]++));
-}
-
-void CPU::op_ld_ffn_a() {
-  op_write(0xff00 + op_read(r[PC]++), r[A]);
-}
-
-void CPU::op_ld_a_ffc() {
-  r[A] = op_read(0xff00 + r[C]);
-}
-
-void CPU::op_ld_ffc_a() {
-  op_write(0xff00 + r[C], r[A]);
-}
-
-void CPU::op_ldi_hl_a() {
-  op_write(r[HL], r[A]);
-  r[HL]++;
-}
-
-void CPU::op_ldi_a_hl() {
-  r[A] = op_read(r[HL]);
-  r[HL]++;
-}
-
-void CPU::op_ldd_hl_a() {
-  op_write(r[HL], r[A]);
-  r[HL]--;
-}
-
-void CPU::op_ldd_a_hl() {
-  r[A] = op_read(r[HL]);
-  r[HL]--;
-}
-
-//16-bit load commands
-
-template<unsigned x> void CPU::op_ld_rr_nn() {
-  r[x]  = op_read(r[PC]++) << 0;
-  r[x] |= op_read(r[PC]++) << 8;
-}
-
-void CPU::op_ld_nn_sp() {
-  uint16 addr = op_read(r[PC]++) << 0;
-  addr |= op_read(r[PC]++) << 8;
-  op_write(addr + 0, r[SP] >> 0);
-  op_write(addr + 1, r[SP] >> 8);
-}
-
-void CPU::op_ld_sp_hl() {
-  r[SP] = r[HL];
-  op_io();
-}
-
-template<unsigned x> void CPU::op_push_rr() {
-  op_write(--r[SP], r[x] >> 8);
-  op_write(--r[SP], r[x] >> 0);
-  op_io();
-}
-
-template<unsigned x> void CPU::op_pop_rr() {
-  r[x]  = op_read(r[SP]++) << 0;
-  r[x] |= op_read(r[SP]++) << 8;
-}
-
-//8-bit arithmetic commands
-
-void CPU::opi_add_a(uint8 x) {
-  uint16 rh = r[A] + x;
-  uint16 rl = (r[A] & 0x0f) + (x & 0x0f);
-  r[A] = rh;
-  r.f.z = (uint8)rh == 0;
-  r.f.n = 0;
-  r.f.h = rl > 0x0f;
-  r.f.c = rh > 0xff;
-}
-
-template<unsigned x> void CPU::op_add_a_r() { opi_add_a(r[x]); }
-void CPU::op_add_a_n() { opi_add_a(op_read(r[PC]++)); }
-void CPU::op_add_a_hl() { opi_add_a(op_read(r[HL])); }
-
-void CPU::opi_adc_a(uint8 x) {
-  uint16 rh = r[A] + x + r.f.c;
-  uint16 rl = (r[A] & 0x0f) + (x & 0x0f) + r.f.c;
-  r[A] = rh;
-  r.f.z = (uint8)rh == 0;
-  r.f.n = 0;
-  r.f.h = rl > 0x0f;
-  r.f.c = rh > 0xff;
-}
-
-template<unsigned x> void CPU::op_adc_a_r() { opi_adc_a(r[x]); }
-void CPU::op_adc_a_n() { opi_adc_a(op_read(r[PC]++)); }
-void CPU::op_adc_a_hl() { opi_adc_a(op_read(r[HL])); }
-
-void CPU::opi_sub_a(uint8 x) {
-  uint16 rh = r[A] - x;
-  uint16 rl = (r[A] & 0x0f) - (x & 0x0f);
-  r[A] = rh;
-  r.f.z = (uint8)rh == 0;
-  r.f.n = 1;
-  r.f.h = rl > 0x0f;
-  r.f.c = rh > 0xff;
-}
-
-template<unsigned x> void CPU::op_sub_a_r() { opi_sub_a(r[x]); }
-void CPU::op_sub_a_n() { opi_sub_a(op_read(r[PC]++)); }
-void CPU::op_sub_a_hl() { opi_sub_a(op_read(r[HL])); }
-
-void CPU::opi_sbc_a(uint8 x) {
-  uint16 rh = r[A] - x - r.f.c;
-  uint16 rl = (r[A] & 0x0f) - (x & 0x0f) - r.f.c;
-  r[A] = rh;
-  r.f.z = (uint8)rh == 0;
-  r.f.n = 1;
-  r.f.h = rl > 0x0f;
-  r.f.c = rh > 0xff;
-}
-
-template<unsigned x> void CPU::op_sbc_a_r() { opi_sbc_a(r[x]); }
-void CPU::op_sbc_a_n() { opi_sbc_a(op_read(r[PC]++)); }
-void CPU::op_sbc_a_hl() { opi_sbc_a(op_read(r[HL])); }
-
-void CPU::opi_and_a(uint8 x) {
-  r[A] &= x;
-  r.f.z = r[A] == 0;
-  r.f.n = 0;
-  r.f.h = 1;
-  r.f.c = 0;
-}
-
-template<unsigned x> void CPU::op_and_a_r() { opi_and_a(r[x]); }
-void CPU::op_and_a_n() { opi_and_a(op_read(r[PC]++)); }
-void CPU::op_and_a_hl() { opi_and_a(op_read(r[HL])); }
-
-void CPU::opi_xor_a(uint8 x) {
-  r[A] ^= x;
-  r.f.z = r[A] == 0;
-  r.f.n = 0;
-  r.f.h = 0;
-  r.f.c = 0;
-}
-
-template<unsigned x> void CPU::op_xor_a_r() { opi_xor_a(r[x]); }
-void CPU::op_xor_a_n() { opi_xor_a(op_read(r[PC]++)); }
-void CPU::op_xor_a_hl() { opi_xor_a(op_read(r[HL])); }
-
-void CPU::opi_or_a(uint8 x) {
-  r[A] |= x;
-  r.f.z = r[A] == 0;
-  r.f.n = 0;
-  r.f.h = 0;
-  r.f.c = 0;
-}
-
-template<unsigned x> void CPU::op_or_a_r() { opi_or_a(r[x]); }
-void CPU::op_or_a_n() { opi_or_a(op_read(r[PC]++)); }
-void CPU::op_or_a_hl() { opi_or_a(op_read(r[HL])); }
-
-void CPU::opi_cp_a(uint8 x) {
-  uint16 rh = r[A] - x;
-  uint16 rl = (r[A] & 0x0f) - (x & 0x0f);
-  r.f.z = (uint8)rh == 0;
-  r.f.n = 1;
-  r.f.h = rl > 0x0f;
-  r.f.c = rh > 0xff;
-}
-
-template<unsigned x> void CPU::op_cp_a_r() { opi_cp_a(r[x]); }
-void CPU::op_cp_a_n() { opi_cp_a(op_read(r[PC]++)); }
-void CPU::op_cp_a_hl() { opi_cp_a(op_read(r[HL])); }
-
-template<unsigned x> void CPU::op_inc_r() {
-  r[x]++;
-  r.f.z = r[x] == 0;
-  r.f.n = 0;
-  r.f.h = (r[x] & 0x0f) == 0x00;
-}
-
-void CPU::op_inc_hl() {
-  uint8 n = op_read(r[HL]);
-  op_write(r[HL], ++n);
-  r.f.z = n == 0;
-  r.f.n = 0;
-  r.f.h = (n & 0x0f) == 0x00;
-}
-
-template<unsigned x> void CPU::op_dec_r() {
-  r[x]--;
-  r.f.z = r[x] == 0;
-  r.f.n = 1;
-  r.f.h = (r[x] & 0x0f) == 0x0f;
-}
-
-void CPU::op_dec_hl() {
-  uint8 n = op_read(r[HL]);
-  op_write(r[HL], --n);
-  r.f.z = n == 0;
-  r.f.n = 1;
-  r.f.h = (n & 0x0f) == 0x0f;
-}
-
-void CPU::op_daa() {
-  uint16 a = r[A];
-  if(r.f.n == 0) {
-    if(r.f.h || (a & 0x0f) > 0x09) a += 0x06;
-    if(r.f.c || (a       ) > 0x9f) a += 0x60;
-  } else {
-    if(r.f.h) {
-      a -= 0x06;
-      if(r.f.c == 0) a &= 0xff;
-    }
-    if(r.f.c) a -= 0x60;
-  }
-  r[A] = a;
-  r.f.z = r[A] == 0;
-  r.f.h = 0;
-  r.f.c |= a & 0x100;
-}
-
-void CPU::op_cpl() {
-  r[A] ^= 0xff;
-  r.f.n = 1;
-  r.f.h = 1;
-}
-
-//16-bit arithmetic commands
-
-template<unsigned x> void CPU::op_add_hl_rr() {
-  op_io();
-  uint32 rb = (r[HL] + r[x]);
-  uint32 rn = (r[HL] & 0xfff) + (r[x] & 0xfff);
-  r[HL] = rb;
-  r.f.n = 0;
-  r.f.h = rn > 0x0fff;
-  r.f.c = rb > 0xffff;
-}
-
-template<unsigned x> void CPU::op_inc_rr() {
-  op_io();
-  r[x]++;
-}
-
-template<unsigned x> void CPU::op_dec_rr() {
-  op_io();
-  r[x]--;
-}
-
-void CPU::op_add_sp_n() {
-  op_io();
-  op_io();
-  signed n = (int8)op_read(r[PC]++);
-  r.f.z = 0;
-  r.f.n = 0;
-  r.f.h = ((r[SP] & 0x0f) + (n & 0x0f)) > 0x0f;
-  r.f.c = ((r[SP] & 0xff) + (n & 0xff)) > 0xff;
-  r[SP] += n;
-}
-
-void CPU::op_ld_hl_sp_n() {
-  op_io();
-  signed n = (int8)op_read(r[PC]++);
-  r.f.z = 0;
-  r.f.n = 0;
-  r.f.h = ((r[SP] & 0x0f) + (n & 0x0f)) > 0x0f;
-  r.f.c = ((r[SP] & 0xff) + (n & 0xff)) > 0xff;
-  r[HL] = r[SP] + n;
-}
-
-//rotate/shift commands
-
-void CPU::op_rlca() {
-  r[A] = (r[A] << 1) | (r[A] >> 7);
-  r.f.z = 0;
-  r.f.n = 0;
-  r.f.h = 0;
-  r.f.c = r[A] & 0x01;
-}
-
-void CPU::op_rla() {
-  bool c = r[A] & 0x80;
-  r[A] = (r[A] << 1) | (r.f.c << 0);
-  r.f.z = 0;
-  r.f.n = 0;
-  r.f.h = 0;
-  r.f.c = c;
-}
-
-void CPU::op_rrca() {
-  r[A] = (r[A] >> 1) | (r[A] << 7);
-  r.f.z = 0;
-  r.f.n = 0;
-  r.f.h = 0;
-  r.f.c = r[A] & 0x80;
-}
-
-void CPU::op_rra() {
-  bool c = r[A] & 0x01;
-  r[A] = (r[A] >> 1) | (r.f.c << 7);
-  r.f.z = 0;
-  r.f.n = 0;
-  r.f.h = 0;
-  r.f.c = c;
-}
-
-template<unsigned x> void CPU::op_rlc_r() {
-  r[x] = (r[x] << 1) | (r[x] >> 7);
-  r.f.z = r[x] == 0;
-  r.f.n = 0;
-  r.f.h = 0;
-  r.f.c = r[x] & 0x01;
-}
-
-void CPU::op_rlc_hl() {
-  uint8 n = op_read(r[HL]);
-  n = (n << 1) | (n >> 7);
-  op_write(r[HL], n);
-  r.f.z = n == 0;
-  r.f.n = 0;
-  r.f.h = 0;
-  r.f.c = n & 0x01;
-}
-
-template<unsigned x> void CPU::op_rl_r() {
-  bool c = r[x] & 0x80;
-  r[x] = (r[x] << 1) | (r.f.c << 0);
-  r.f.z = r[x] == 0;
-  r.f.n = 0;
-  r.f.h = 0;
-  r.f.c = c;
-}
-
-void CPU::op_rl_hl() {
-  uint8 n = op_read(r[HL]);
-  bool c = n & 0x80;
-  n = (n << 1) | (r.f.c << 0);
-  op_write(r[HL], n);
-  r.f.z = n == 0;
-  r.f.n = 0;
-  r.f.h = 0;
-  r.f.c = c;
-}
-
-template<unsigned x> void CPU::op_rrc_r() {
-  r[x] = (r[x] >> 1) | (r[x] << 7);
-  r.f.z = r[x] == 0;
-  r.f.n = 0;
-  r.f.h = 0;
-  r.f.c = r[x] & 0x80;
-}
-
-void CPU::op_rrc_hl() {
-  uint8 n = op_read(r[HL]);
-  n = (n >> 1) | (n << 7);
-  op_write(r[HL], n);
-  r.f.z = n == 0;
-  r.f.n = 0;
-  r.f.h = 0;
-  r.f.c = n & 0x80;
-}
-
-template<unsigned x> void CPU::op_rr_r() {
-  bool c = r[x] & 0x01;
-  r[x] = (r[x] >> 1) | (r.f.c << 7);
-  r.f.z = r[x] == 0;
-  r.f.n = 0;
-  r.f.h = 0;
-  r.f.c = c;
-}
-
-void CPU::op_rr_hl() {
-  uint8 n = op_read(r[HL]);
-  bool c = n & 0x01;
-  n = (n >> 1) | (r.f.c << 7);
-  op_write(r[HL], n);
-  r.f.z = n == 0;
-  r.f.n = 0;
-  r.f.h = 0;
-  r.f.c = c;
-}
-
-template<unsigned x> void CPU::op_sla_r() {
-  bool c = r[x] & 0x80;
-  r[x] <<= 1;
-  r.f.z = r[x] == 0;
-  r.f.n = 0;
-  r.f.h = 0;
-  r.f.c = c;
-}
-
-void CPU::op_sla_hl() {
-  uint8 n = op_read(r[HL]);
-  bool c = n & 0x80;
-  n <<= 1;
-  op_write(r[HL], n);
-  r.f.z = n == 0;
-  r.f.n = 0;
-  r.f.h = 0;
-  r.f.c = c;
-}
-
-template<unsigned x> void CPU::op_swap_r() {
-  r[x] = (r[x] << 4) | (r[x] >> 4);
-  r.f.z = r[x] == 0;
-  r.f.n = 0;
-  r.f.h = 0;
-  r.f.c = 0;
-}
-
-void CPU::op_swap_hl() {
-  uint8 n = op_read(r[HL]);
-  n = (n << 4) | (n >> 4);
-  op_write(r[HL], n);
-  r.f.z = n == 0;
-  r.f.n = 0;
-  r.f.h = 0;
-  r.f.c = 0;
-}
-
-template<unsigned x> void CPU::op_sra_r() {
-  bool c = r[x] & 0x01;
-  r[x] = (int8)r[x] >> 1;
-  r.f.z = r[x] == 0;
-  r.f.n = 0;
-  r.f.h = 0;
-  r.f.c = c;
-}
-
-void CPU::op_sra_hl() {
-  uint8 n = op_read(r[HL]);
-  bool c = n & 0x01;
-  n = (int8)n >> 1;
-  op_write(r[HL], n);
-  r.f.z = n == 0;
-  r.f.n = 0;
-  r.f.h = 0;
-  r.f.c = c;
-}
-
-template<unsigned x> void CPU::op_srl_r() {
-  bool c = r[x] & 0x01;
-  r[x] >>= 1;
-  r.f.z = r[x] == 0;
-  r.f.n = 0;
-  r.f.h = 0;
-  r.f.c = c;
-}
-
-void CPU::op_srl_hl() {
-  uint8 n = op_read(r[HL]);
-  bool c = n & 0x01;
-  n >>= 1;
-  op_write(r[HL], n);
-  r.f.z = n == 0;
-  r.f.n = 0;
-  r.f.h = 0;
-  r.f.c = c;
-}
-
-//single-bit commands
-
-template<unsigned b, unsigned x> void CPU::op_bit_n_r() {
-  r.f.z = (r[x] & (1 << b)) == 0;
-  r.f.n = 0;
-  r.f.h = 1;
-}
-
-template<unsigned b> void CPU::op_bit_n_hl() {
-  uint8 n = op_read(r[HL]);
-  r.f.z = (n & (1 << b)) == 0;
-  r.f.n = 0;
-  r.f.h = 1;
-}
-
-template<unsigned b, unsigned x> void CPU::op_set_n_r() {
-  r[x] |= 1 << b;
-}
-
-template<unsigned b> void CPU::op_set_n_hl() {
-  uint8 n = op_read(r[HL]);
-  n |= 1 << b;
-  op_write(r[HL], n);
-}
-
-template<unsigned b, unsigned x> void CPU::op_res_n_r() {
-  r[x] &= ~(1 << b);
-}
-
-template<unsigned b> void CPU::op_res_n_hl() {
-  uint8 n = op_read(r[HL]);
-  n &= ~(1 << b);
-  op_write(r[HL], n);
-}
-
-//control commands
-
-void CPU::op_ccf() {
-  r.f.n = 0;
-  r.f.h = 0;
-  r.f.c = !r.f.c;
-}
-
-void CPU::op_scf() {
-  r.f.n = 0;
-  r.f.h = 0;
-  r.f.c = 1;
-}
-
-void CPU::op_nop() {
-}
-
-void CPU::op_halt() {
-  status.halt = true;
-  while(status.halt == true) op_io();
-}
-
-void CPU::op_stop() {
-  status.stop = true;
-  while(status.stop == true) op_io();
-}
-
-void CPU::op_di() {
-  status.ime = 0;
-}
-
-void CPU::op_ei() {
-  status.ime = 1;
-}
-
-//jump commands
-
-void CPU::op_jp_nn() {
-  uint8 lo = op_read(r[PC]++);
-  uint8 hi = op_read(r[PC]++);
-  r[PC] = (hi << 8) | (lo << 0);
-  op_io();
-}
-
-void CPU::op_jp_hl() {
-  r[PC] = r[HL];
-}
-
-template<unsigned x, bool y> void CPU::op_jp_f_nn() {
-  uint8 lo = op_read(r[PC]++);
-  uint8 hi = op_read(r[PC]++);
-  if(r.f[x] == y) {
-    r[PC] = (hi << 8) | (lo << 0);
-    op_io();
-  }
-}
-
-void CPU::op_jr_n() {
-  int8 n = op_read(r[PC]++);
-  r[PC] += n;
-  op_io();
-}
-
-template<unsigned x, bool y> void CPU::op_jr_f_n() {
-  int8 n = op_read(r[PC]++);
-  if(r.f[x] == y) {
-    r[PC] += n;
-    op_io();
-  }
-}
-
-void CPU::op_call_nn() {
-  uint8 lo = op_read(r[PC]++);
-  uint8 hi = op_read(r[PC]++);
-  op_write(--r[SP], r[PC] >> 8);
-  op_write(--r[SP], r[PC] >> 0);
-  r[PC] = (hi << 8) | (lo << 0);
-  op_io();
-}
-
-template<unsigned x, bool y> void CPU::op_call_f_nn() {
-  uint8 lo = op_read(r[PC]++);
-  uint8 hi = op_read(r[PC]++);
-  if(r.f[x] == y) {
-    op_write(--r[SP], r[PC] >> 8);
-    op_write(--r[SP], r[PC] >> 0);
-    r[PC] = (hi << 8) | (lo << 0);
-    op_io();
-  }
-}
-
-void CPU::op_ret() {
-  uint8 lo = op_read(r[SP]++);
-  uint8 hi = op_read(r[SP]++);
-  r[PC] = (hi << 8) | (lo << 0);
-  op_io();
-}
-
-template<unsigned x, bool y> void CPU::op_ret_f() {
-  op_io();
-  if(r.f[x] == y) {
-    uint8 lo = op_read(r[SP]++);
-    uint8 hi = op_read(r[SP]++);
-    r[PC] = (hi << 8) | (lo << 0);
-    op_io();
-  }
-}
-
-void CPU::op_reti() {
-  uint8 lo = op_read(r[SP]++);
-  uint8 hi = op_read(r[SP]++);
-  r[PC] = (hi << 8) | (lo << 0);
-  op_io();
-  status.ime = 1;
-}
-
-template<unsigned n> void CPU::op_rst_n() {
-  op_write(--r[SP], r[PC] >> 8);
-  op_write(--r[SP], r[PC] >> 0);
-  r[PC] = n;
-  op_io();
-}
-
-#endif

bsnes/gameboy/cpu/core/core.hpp

@@ -1,145 +0,0 @@
-#include "registers.hpp"
-void (CPU::*opcode_table[256])();
-void (CPU::*opcode_table_cb[256])();
-void initialize_opcode_table();
-
-void op_xx();
-void op_cb();
-
-//8-bit load commands
-template<unsigned x, unsigned y> void op_ld_r_r();
-template<unsigned x> void op_ld_r_n();
-template<unsigned x> void op_ld_r_hl();
-template<unsigned x> void op_ld_hl_r();
-void op_ld_hl_n();
-template<unsigned x> void op_ld_a_rr();
-void op_ld_a_nn();
-template<unsigned x> void op_ld_rr_a();
-void op_ld_nn_a();
-void op_ld_a_ffn();
-void op_ld_ffn_a();
-void op_ld_a_ffc();
-void op_ld_ffc_a();
-void op_ldi_hl_a();
-void op_ldi_a_hl();
-void op_ldd_hl_a();
-void op_ldd_a_hl();
-
-//16-bit load commands
-template<unsigned x> void op_ld_rr_nn();
-void op_ld_nn_sp();
-void op_ld_sp_hl();
-template<unsigned x> void op_push_rr();
-template<unsigned x> void op_pop_rr();
-
-//8-bit arithmetic commands
-void opi_add_a(uint8 x);
-template<unsigned x> void op_add_a_r();
-void op_add_a_n();
-void op_add_a_hl();
-
-void opi_adc_a(uint8 x);
-template<unsigned x> void op_adc_a_r();
-void op_adc_a_n();
-void op_adc_a_hl();
-
-void opi_sub_a(uint8 x);
-template<unsigned x> void op_sub_a_r();
-void op_sub_a_n();
-void op_sub_a_hl();
-
-void opi_sbc_a(uint8 x);
-template<unsigned x> void op_sbc_a_r();
-void op_sbc_a_n();
-void op_sbc_a_hl();
-
-void opi_and_a(uint8 x);
-template<unsigned x> void op_and_a_r();
-void op_and_a_n();
-void op_and_a_hl();
-
-void opi_xor_a(uint8 x);
-template<unsigned x> void op_xor_a_r();
-void op_xor_a_n();
-void op_xor_a_hl();
-
-void opi_or_a(uint8 x);
-template<unsigned x> void op_or_a_r();
-void op_or_a_n();
-void op_or_a_hl();
-
-void opi_cp_a(uint8 x);
-template<unsigned x> void op_cp_a_r();
-void op_cp_a_n();
-void op_cp_a_hl();
-
-template<unsigned x> void op_inc_r();
-void op_inc_hl();
-template<unsigned x> void op_dec_r();
-void op_dec_hl();
-void op_daa();
-void op_cpl();
-
-//16-bit arithmetic commands
-template<unsigned x> void op_add_hl_rr();
-template<unsigned x> void op_inc_rr();
-template<unsigned x> void op_dec_rr();
-void op_add_sp_n();
-void op_ld_hl_sp_n();
-
-//rotate/shift commands
-void op_rlca();
-void op_rla();
-void op_rrca();
-void op_rra();
-template<unsigned x> void op_rlc_r();
-void op_rlc_hl();
-template<unsigned x> void op_rl_r();
-void op_rl_hl();
-template<unsigned x> void op_rrc_r();
-void op_rrc_hl();
-template<unsigned x> void op_rr_r();
-void op_rr_hl();
-template<unsigned x> void op_sla_r();
-void op_sla_hl();
-template<unsigned x> void op_swap_r();
-void op_swap_hl();
-template<unsigned x> void op_sra_r();
-void op_sra_hl();
-template<unsigned x> void op_srl_r();
-void op_srl_hl();
-
-//single-bit commands
-template<unsigned b, unsigned x> void op_bit_n_r();
-template<unsigned b> void op_bit_n_hl();
-template<unsigned b, unsigned x> void op_set_n_r();
-template<unsigned b> void op_set_n_hl();
-template<unsigned b, unsigned x> void op_res_n_r();
-template<unsigned b> void op_res_n_hl();
-
-//control commands
-void op_ccf();
-void op_scf();
-void op_nop();
-void op_halt();
-void op_stop();
-void op_di();
-void op_ei();
-
-//jump commands
-void op_jp_nn();
-void op_jp_hl();
-template<unsigned x, bool y> void op_jp_f_nn();
-void op_jr_n();
-template<unsigned x, bool y> void op_jr_f_n();
-void op_call_nn();
-template<unsigned x, bool y> void op_call_f_nn();
-void op_ret();
-template<unsigned x, bool y> void op_ret_f();
-void op_reti();
-template<unsigned n> void op_rst_n();
-
-//disassembler.cpp
-string disassemble(uint16 pc);
-string disassemble_opcode(uint16 pc);
-string disassemble_opcode_cb(uint16 pc);

bsnes/gameboy/cpu/core/disassembler.cpp

@@ -1,560 +0,0 @@
-#ifdef CPU_CPP
-
-string CPU::disassemble(uint16 pc) {
-  char output[80];
-  memset(output, ' ', sizeof output);
-  output[79] = 0;
-
-  string opcode = disassemble_opcode(pc);
-  string registers = {
-    " AF:", hex<4>(r[AF]),
-    " BC:", hex<4>(r[BC]),
-    " DE:", hex<4>(r[DE]),
-    " HL:", hex<4>(r[HL]),
-    " SP:", hex<4>(r[SP])
-  };
-
-  memcpy(output +   0, hex<4>(pc), 4);
-  memcpy(output +   6, opcode, opcode.length());
-  memcpy(output +  23, registers, registers.length());
-  output[63] = 0;
-  return output;
-}
-
-string CPU::disassemble_opcode(uint16 pc) {
-  uint8 opcode = bus.read(pc);
-  uint8 p0 = bus.read(pc + 1);
-  uint8 p1 = bus.read(pc + 2);
-  uint8 p2 = bus.read(pc + 3);
-
-  switch(opcode) {
-    case 0x00: return { "nop" };
-    case 0x01: return { "ld   bc,$", hex<2>(p1), hex<2>(p0) };
-    case 0x02: return { "ld   (bc),a" };
-    case 0x03: return { "inc  bc" };
-    case 0x04: return { "inc  b" };
-    case 0x05: return { "dec  b" };
-    case 0x06: return { "ld   b,$", hex<2>(p0) };
-    case 0x07: return { "rlc  a" };
-    case 0x08: return { "ld   ($", hex<2>(p1), hex<2>(p0), "),sp" };
-    case 0x09: return { "add  hl,bc" };
-    case 0x0a: return { "ld   a,(bc)" };
-    case 0x0b: return { "dec  bc" };
-    case 0x0c: return { "inc  c" };
-    case 0x0d: return { "dec  c" };
-    case 0x0e: return { "ld   c,$", hex<2>(p0) };
-    case 0x0f: return { "rrc  a" };
-    case 0x10: return { "stop" };
-    case 0x11: return { "ld   de,$", hex<2>(p1), hex<2>(p0) };
-    case 0x12: return { "ld   (de),a" };
-    case 0x13: return { "inc  de" };
-    case 0x14: return { "inc  d" };
-    case 0x15: return { "dec  d" };
-    case 0x16: return { "ld   d,$", hex<2>(p0) };
-    case 0x17: return { "rl   a" };
-    case 0x18: return { "jr   $", hex<4>(r[PC] + 2 + (int8)p0) };
-    case 0x19: return { "add  hl,de" };
-    case 0x1a: return { "ld   a,(de)" };
-    case 0x1b: return { "dec  de" };
-    case 0x1c: return { "inc  e" };
-    case 0x1d: return { "dec  e" };
-    case 0x1e: return { "ld   e,$", hex<2>(p0) };
-    case 0x1f: return { "rr   a" };
-    case 0x20: return { "jr   nz,$", hex<4>(r[PC] + 2 + (int8)p0) };
-    case 0x21: return { "ld   hl,$", hex<2>(p1), hex<2>(p0) };
-    case 0x22: return { "ldi  (hl),a" };
-    case 0x23: return { "inc  hl" };
-    case 0x24: return { "inc  h" };
-    case 0x25: return { "dec  h" };
-    case 0x26: return { "ld   h,$", hex<2>(p0) };
-    case 0x27: return { "daa" };
-    case 0x28: return { "jr   z,$", hex<4>(r[PC] + 2 + (int8)p0) };
-    case 0x29: return { "add  hl,hl" };
-    case 0x2a: return { "ldi  a,(hl)" };
-    case 0x2b: return { "dec  hl" };
-    case 0x2c: return { "inc  l" };
-    case 0x2d: return { "dec  l" };
-    case 0x2e: return { "ld   l,$", hex<2>(p0) };
-    case 0x2f: return { "cpl" };
-    case 0x30: return { "jr   nc,$", hex<4>(r[PC] + 2 + (int8)p0) };
-    case 0x31: return { "ld   sp,$", hex<2>(p1), hex<2>(p0) };
-    case 0x32: return { "ldd  (hl),a" };
-    case 0x33: return { "inc  sp" };
-    case 0x34: return { "inc  (hl)" };
-    case 0x35: return { "dec  (hl)" };
-    case 0x36: return { "ld   (hl),$", hex<2>(p0) };
-    case 0x37: return { "scf" };
-    case 0x38: return { "jr   c,$", hex<4>(r[PC] + 2 + (int8)p0) };
-    case 0x39: return { "add  hl,sp" };
-    case 0x3a: return { "ldd  a,(hl)" };
-    case 0x3b: return { "dec  sp" };
-    case 0x3c: return { "inc  a" };
-    case 0x3d: return { "dec  a" };
-    case 0x3e: return { "ld   a,$", hex<2>(p0) };
-    case 0x3f: return { "ccf" };
-    case 0x40: return { "ld   b,b" };
-    case 0x41: return { "ld   b,c" };
-    case 0x42: return { "ld   b,d" };
-    case 0x43: return { "ld   b,e" };
-    case 0x44: return { "ld   b,h" };
-    case 0x45: return { "ld   b,l" };
-    case 0x46: return { "ld   b,(hl)" };
-    case 0x47: return { "ld   b,a" };
-    case 0x48: return { "ld   c,b" };
-    case 0x49: return { "ld   c,c" };
-    case 0x4a: return { "ld   c,d" };
-    case 0x4b: return { "ld   c,e" };
-    case 0x4c: return { "ld   c,h" };
-    case 0x4d: return { "ld   c,l" };
-    case 0x4e: return { "ld   c,(hl)" };
-    case 0x4f: return { "ld   c,a" };
-    case 0x50: return { "ld   d,b" };
-    case 0x51: return { "ld   d,c" };
-    case 0x52: return { "ld   d,d" };
-    case 0x53: return { "ld   d,e" };
-    case 0x54: return { "ld   d,h" };
-    case 0x55: return { "ld   d,l" };
-    case 0x56: return { "ld   d,(hl)" };
-    case 0x57: return { "ld   d,a" };
-    case 0x58: return { "ld   e,b" };
-    case 0x59: return { "ld   e,c" };
-    case 0x5a: return { "ld   e,d" };
-    case 0x5b: return { "ld   e,e" };
-    case 0x5c: return { "ld   e,h" };
-    case 0x5d: return { "ld   e,l" };
-    case 0x5e: return { "ld   e,(hl)" };
-    case 0x5f: return { "ld   e,a" };
-    case 0x60: return { "ld   h,b" };
-    case 0x61: return { "ld   h,c" };
-    case 0x62: return { "ld   h,d" };
-    case 0x63: return { "ld   h,e" };
-    case 0x64: return { "ld   h,h" };
-    case 0x65: return { "ld   h,l" };
-    case 0x66: return { "ld   h,(hl)" };
-    case 0x67: return { "ld   h,a" };
-    case 0x68: return { "ld   l,b" };
-    case 0x69: return { "ld   l,c" };
-    case 0x6a: return { "ld   l,d" };
-    case 0x6b: return { "ld   l,e" };
-    case 0x6c: return { "ld   l,h" };
-    case 0x6d: return { "ld   l,l" };
-    case 0x6e: return { "ld   l,(hl)" };
-    case 0x6f: return { "ld   l,a" };
-    case 0x70: return { "ld   (hl),b" };
-    case 0x71: return { "ld   (hl),c" };
-    case 0x72: return { "ld   (hl),d" };
-    case 0x73: return { "ld   (hl),e" };
-    case 0x74: return { "ld   (hl),h" };
-    case 0x75: return { "ld   (hl),l" };
-    case 0x76: return { "halt" };
-    case 0x77: return { "ld   (hl),a" };
-    case 0x78: return { "ld   a,b" };
-    case 0x79: return { "ld   a,c" };
-    case 0x7a: return { "ld   a,d" };
-    case 0x7b: return { "ld   a,e" };
-    case 0x7c: return { "ld   a,h" };
-    case 0x7d: return { "ld   a,l" };
-    case 0x7e: return { "ld   a,(hl)" };
-    case 0x7f: return { "ld   a,a" };
-    case 0x80: return { "add  a,b" };
-    case 0x81: return { "add  a,c" };
-    case 0x82: return { "add  a,d" };
-    case 0x83: return { "add  a,e" };
-    case 0x84: return { "add  a,h" };
-    case 0x85: return { "add  a,l" };
-    case 0x86: return { "add  a,(hl)" };
-    case 0x87: return { "add  a,a" };
-    case 0x88: return { "adc  a,b" };
-    case 0x89: return { "adc  a,c" };
-    case 0x8a: return { "adc  a,d" };
-    case 0x8b: return { "adc  a,e" };
-    case 0x8c: return { "adc  a,h" };
-    case 0x8d: return { "adc  a,l" };
-    case 0x8e: return { "adc  a,(hl)" };
-    case 0x8f: return { "adc  a,a" };
-    case 0x90: return { "sub  a,b" };
-    case 0x91: return { "sub  a,c" };
-    case 0x92: return { "sub  a,d" };
-    case 0x93: return { "sub  a,e" };
-    case 0x94: return { "sub  a,h" };
-    case 0x95: return { "sub  a,l" };
-    case 0x96: return { "sub  a,(hl)" };
-    case 0x97: return { "sub  a,a" };
-    case 0x98: return { "sbc  a,b" };
-    case 0x99: return { "sbc  a,c" };
-    case 0x9a: return { "sbc  a,d" };
-    case 0x9b: return { "sbc  a,e" };
-    case 0x9c: return { "sbc  a,h" };
-    case 0x9d: return { "sbc  a,l" };
-    case 0x9e: return { "sbc  a,(hl)" };
-    case 0x9f: return { "sbc  a,a" };
-    case 0xa0: return { "and  a,b" };
-    case 0xa1: return { "and  a,c" };
-    case 0xa2: return { "and  a,d" };
-    case 0xa3: return { "and  a,e" };
-    case 0xa4: return { "and  a,h" };
-    case 0xa5: return { "and  a,l" };
-    case 0xa6: return { "and  a,(hl)" };
-    case 0xa7: return { "and  a,a" };
-    case 0xa8: return { "xor  a,b" };
-    case 0xa9: return { "xor  a,c" };
-    case 0xaa: return { "xor  a,d" };
-    case 0xab: return { "xor  a,e" };
-    case 0xac: return { "xor  a,h" };
-    case 0xad: return { "xor  a,l" };
-    case 0xae: return { "xor  a,(hl)" };
-    case 0xaf: return { "xor  a,a" };
-    case 0xb0: return { "or   a,b" };
-    case 0xb1: return { "or   a,c" };
-    case 0xb2: return { "or   a,d" };
-    case 0xb3: return { "or   a,e" };
-    case 0xb4: return { "or   a,h" };
-    case 0xb5: return { "or   a,l" };
-    case 0xb6: return { "or   a,(hl)" };
-    case 0xb7: return { "or   a,a" };
-    case 0xb8: return { "cp   a,b" };
-    case 0xb9: return { "cp   a,c" };
-    case 0xba: return { "cp   a,d" };
-    case 0xbb: return { "cp   a,e" };
-    case 0xbc: return { "cp   a,h" };
-    case 0xbd: return { "cp   a,l" };
-    case 0xbe: return { "cp   a,(hl)" };
-    case 0xbf: return { "cp   a,a" };
-    case 0xc0: return { "ret  nz" };
-    case 0xc1: return { "pop  bc" };
-    case 0xc2: return { "jp   nz,$", hex<2>(p1), hex<2>(p0) };
-    case 0xc3: return { "jp   $", hex<2>(p1), hex<2>(p0) };
-    case 0xc4: return { "call nz,$", hex<2>(p1), hex<2>(p0) };
-    case 0xc5: return { "push bc" };
-    case 0xc6: return { "add  a,$", hex<2>(p0) };
-    case 0xc7: return { "rst  $0000" };
-    case 0xc8: return { "ret  z" };
-    case 0xc9: return { "ret" };
-    case 0xca: return { "jp   z,$", hex<2>(p1), hex<2>(p0) };
-    case 0xcb: return disassemble_opcode_cb(pc + 1);
-    case 0xcc: return { "call z,$", hex<2>(p1), hex<2>(p0) };
-    case 0xcd: return { "call $", hex<2>(p1), hex<2>(p0) };
-    case 0xce: return { "adc  a,$", hex<2>(p0) };
-    case 0xcf: return { "rst  $0008" };
-    case 0xd0: return { "ret  nc" };
-    case 0xd1: return { "pop  de" };
-    case 0xd2: return { "jp   nc,$", hex<2>(p1), hex<2>(p0) };
-    case 0xd3: return { "xx" };
-    case 0xd4: return { "call nc,$", hex<2>(p1), hex<2>(p0) };
-    case 0xd5: return { "push de" };
-    case 0xd6: return { "sub  a,$", hex<2>(p0) };
-    case 0xd7: return { "rst  $0010" };
-    case 0xd8: return { "ret  c" };
-    case 0xd9: return { "reti" };
-    case 0xda: return { "jp   c,$", hex<2>(p1), hex<2>(p0) };
-    case 0xdb: return { "xx" };
-    case 0xdc: return { "call c,$", hex<2>(p1), hex<2>(p0) };
-    case 0xdd: return { "xx" };
-    case 0xde: return { "sbc  a,$", hex<2>(p0) };
-    case 0xdf: return { "rst  $0018" };
-    case 0xe0: return { "ld   ($ff", hex<2>(p0), "),a" };
-    case 0xe1: return { "pop  hl" };
-    case 0xe2: return { "ld   ($ff00+c),a" };
-    case 0xe3: return { "xx" };
-    case 0xe4: return { "xx" };
-    case 0xe5: return { "push hl" };
-    case 0xe6: return { "and  a,$", hex<2>(p0) };
-    case 0xe7: return { "rst  $0020" };
-    case 0xe8: return { "add  sp,$", hex<4>((int8)p0) };
-    case 0xe9: return { "jp   hl" };
-    case 0xea: return { "ld   ($", hex<2>(p1), hex<2>(p0), "),a" };
-    case 0xeb: return { "xx" };
-    case 0xec: return { "xx" };
-    case 0xed: return { "xx" };
-    case 0xee: return { "xor  a,$", hex<2>(p0) };
-    case 0xef: return { "rst  $0028" };
-    case 0xf0: return { "ld   a,($ff", hex<2>(p0), ")" };
-    case 0xf1: return { "pop  af" };
-    case 0xf2: return { "ld   a,($ff00+c)" };
-    case 0xf3: return { "di" };
-    case 0xf4: return { "xx" };
-    case 0xf5: return { "push af" };
-    case 0xf6: return { "or  a,$", hex<2>(p0) };
-    case 0xf7: return { "rst  $0030" };
-    case 0xf8: return { "ld   hl,sp+$", hex<4>((int8)p0) };
-    case 0xf9: return { "ld   sp,hl" };
-    case 0xfa: return { "ld   a,($", hex<2>(p1), hex<2>(p0), ")" };
-    case 0xfb: return { "ei" };
-    case 0xfc: return { "xx" };
-    case 0xfd: return { "xx" };
-    case 0xfe: return { "cp   a,$", hex<2>(p0) };
-    case 0xff: return { "rst  $0038" };
-  }
-
-  return "";
-}
-
-string CPU::disassemble_opcode_cb(uint16 pc) {
-  uint8 opcode = bus.read(pc);
-  uint8 p0 = bus.read(pc + 1);
-  uint8 p1 = bus.read(pc + 2);
-  uint8 p2 = bus.read(pc + 3);
-
-  switch(opcode) {
-    case 0x00: return { "rlc  b" };
-    case 0x01: return { "rlc  c" };
-    case 0x02: return { "rlc  d" };
-    case 0x03: return { "rlc  e" };
-    case 0x04: return { "rlc  h" };
-    case 0x05: return { "rlc  l" };
-    case 0x06: return { "rlc  (hl)" };
-    case 0x07: return { "rlc  a" };
-    case 0x08: return { "rrc  b" };
-    case 0x09: return { "rrc  c" };
-    case 0x0a: return { "rrc  d" };
-    case 0x0b: return { "rrc  e" };
-    case 0x0c: return { "rrc  h" };
-    case 0x0d: return { "rrc  l" };
-    case 0x0e: return { "rrc  (hl)" };
-    case 0x0f: return { "rrc  a" };
-    case 0x10: return { "rl   b" };
-    case 0x11: return { "rl   c" };
-    case 0x12: return { "rl   d" };
-    case 0x13: return { "rl   e" };
-    case 0x14: return { "rl   h" };
-    case 0x15: return { "rl   l" };
-    case 0x16: return { "rl   (hl)" };
-    case 0x17: return { "rl   a" };
-    case 0x18: return { "rr   b" };
-    case 0x19: return { "rr   c" };
-    case 0x1a: return { "rr   d" };
-    case 0x1b: return { "rr   e" };
-    case 0x1c: return { "rr   h" };
-    case 0x1d: return { "rr   l" };
-    case 0x1e: return { "rr   (hl)" };
-    case 0x1f: return { "rr   a" };
-    case 0x20: return { "sla  b" };
-    case 0x21: return { "sla  c" };
-    case 0x22: return { "sla  d" };
-    case 0x23: return { "sla  e" };
-    case 0x24: return { "sla  h" };
-    case 0x25: return { "sla  l" };
-    case 0x26: return { "sla  (hl)" };
-    case 0x27: return { "sla  a" };
-    case 0x28: return { "sra  b" };
-    case 0x29: return { "sra  c" };
-    case 0x2a: return { "sra  d" };
-    case 0x2b: return { "sra  e" };
-    case 0x2c: return { "sra  h" };
-    case 0x2d: return { "sra  l" };
-    case 0x2e: return { "sra  (hl)" };
-    case 0x2f: return { "sra  a" };
-    case 0x30: return { "swap b" };
-    case 0x31: return { "swap c" };
-    case 0x32: return { "swap d" };
-    case 0x33: return { "swap e" };
-    case 0x34: return { "swap h" };
-    case 0x35: return { "swap l" };
-    case 0x36: return { "swap (hl)" };
-    case 0x37: return { "swap a" };
-    case 0x38: return { "srl  b" };
-    case 0x39: return { "srl  c" };
-    case 0x3a: return { "srl  d" };
-    case 0x3b: return { "srl  e" };
-    case 0x3c: return { "srl  h" };
-    case 0x3d: return { "srl  l" };
-    case 0x3e: return { "srl  (hl)" };
-    case 0x3f: return { "srl  a" };
-    case 0x40: return { "bit  0,b" };
-    case 0x41: return { "bit  0,c" };
-    case 0x42: return { "bit  0,d" };
-    case 0x43: return { "bit  0,e" };
-    case 0x44: return { "bit  0,h" };
-    case 0x45: return { "bit  0,l" };
-    case 0x46: return { "bit  0,(hl)" };
-    case 0x47: return { "bit  0,a" };
-    case 0x48: return { "bit  1,b" };
-    case 0x49: return { "bit  1,c" };
-    case 0x4a: return { "bit  1,d" };
-    case 0x4b: return { "bit  1,e" };
-    case 0x4c: return { "bit  1,h" };
-    case 0x4d: return { "bit  1,l" };
-    case 0x4e: return { "bit  1,(hl)" };
-    case 0x4f: return { "bit  1,a" };
-    case 0x50: return { "bit  2,b" };
-    case 0x51: return { "bit  2,c" };
-    case 0x52: return { "bit  2,d" };
-    case 0x53: return { "bit  2,e" };
-    case 0x54: return { "bit  2,h" };
-    case 0x55: return { "bit  2,l" };
-    case 0x56: return { "bit  2,(hl)" };
-    case 0x57: return { "bit  2,a" };
-    case 0x58: return { "bit  3,b" };
-    case 0x59: return { "bit  3,c" };
-    case 0x5a: return { "bit  3,d" };
-    case 0x5b: return { "bit  3,e" };
-    case 0x5c: return { "bit  3,h" };
-    case 0x5d: return { "bit  3,l" };
-    case 0x5e: return { "bit  3,(hl)" };
-    case 0x5f: return { "bit  3,a" };
-    case 0x60: return { "bit  4,b" };
-    case 0x61: return { "bit  4,c" };
-    case 0x62: return { "bit  4,d" };
-    case 0x63: return { "bit  4,e" };
-    case 0x64: return { "bit  4,h" };
-    case 0x65: return { "bit  4,l" };
-    case 0x66: return { "bit  4,(hl)" };
-    case 0x67: return { "bit  4,a" };
-    case 0x68: return { "bit  5,b" };
-    case 0x69: return { "bit  5,c" };
-    case 0x6a: return { "bit  5,d" };
-    case 0x6b: return { "bit  5,e" };
-    case 0x6c: return { "bit  5,h" };
-    case 0x6d: return { "bit  5,l" };
-    case 0x6e: return { "bit  5,(hl)" };
-    case 0x6f: return { "bit  5,a" };
-    case 0x70: return { "bit  6,b" };
-    case 0x71: return { "bit  6,c" };
-    case 0x72: return { "bit  6,d" };
-    case 0x73: return { "bit  6,e" };
-    case 0x74: return { "bit  6,h" };
-    case 0x75: return { "bit  6,l" };
-    case 0x76: return { "bit  6,(hl)" };
-    case 0x77: return { "bit  6,a" };
-    case 0x78: return { "bit  7,b" };
-    case 0x79: return { "bit  7,c" };
-    case 0x7a: return { "bit  7,d" };
-    case 0x7b: return { "bit  7,e" };
-    case 0x7c: return { "bit  7,h" };
-    case 0x7d: return { "bit  7,l" };
-    case 0x7e: return { "bit  7,(hl)" };
-    case 0x7f: return { "bit  7,a" };
-    case 0x80: return { "res  0,b" };
-    case 0x81: return { "res  0,c" };
-    case 0x82: return { "res  0,d" };
-    case 0x83: return { "res  0,e" };
-    case 0x84: return { "res  0,h" };
-    case 0x85: return { "res  0,l" };
-    case 0x86: return { "res  0,(hl)" };
-    case 0x87: return { "res  0,a" };
-    case 0x88: return { "res  1,b" };
-    case 0x89: return { "res  1,c" };
-    case 0x8a: return { "res  1,d" };
-    case 0x8b: return { "res  1,e" };
-    case 0x8c: return { "res  1,h" };
-    case 0x8d: return { "res  1,l" };
-    case 0x8e: return { "res  1,(hl)" };
-    case 0x8f: return { "res  1,a" };
-    case 0x90: return { "res  2,b" };
-    case 0x91: return { "res  2,c" };
-    case 0x92: return { "res  2,d" };
-    case 0x93: return { "res  2,e" };
-    case 0x94: return { "res  2,h" };
-    case 0x95: return { "res  2,l" };
-    case 0x96: return { "res  2,(hl)" };
-    case 0x97: return { "res  2,a" };
-    case 0x98: return { "res  3,b" };
-    case 0x99: return { "res  3,c" };
-    case 0x9a: return { "res  3,d" };
-    case 0x9b: return { "res  3,e" };
-    case 0x9c: return { "res  3,h" };
-    case 0x9d: return { "res  3,l" };
-    case 0x9e: return { "res  3,(hl)" };
-    case 0x9f: return { "res  3,a" };
-    case 0xa0: return { "res  4,b" };
-    case 0xa1: return { "res  4,c" };
-    case 0xa2: return { "res  4,d" };
-    case 0xa3: return { "res  4,e" };
-    case 0xa4: return { "res  4,h" };
-    case 0xa5: return { "res  4,l" };
-    case 0xa6: return { "res  4,(hl)" };
-    case 0xa7: return { "res  4,a" };
-    case 0xa8: return { "res  5,b" };
-    case 0xa9: return { "res  5,c" };
-    case 0xaa: return { "res  5,d" };
-    case 0xab: return { "res  5,e" };
-    case 0xac: return { "res  5,h" };
-    case 0xad: return { "res  5,l" };
-    case 0xae: return { "res  5,(hl)" };
-    case 0xaf: return { "res  5,a" };
-    case 0xb0: return { "res  6,b" };
-    case 0xb1: return { "res  6,c" };
-    case 0xb2: return { "res  6,d" };
-    case 0xb3: return { "res  6,e" };
-    case 0xb4: return { "res  6,h" };
-    case 0xb5: return { "res  6,l" };
-    case 0xb6: return { "res  6,(hl)" };
-    case 0xb7: return { "res  6,a" };
-    case 0xb8: return { "res  7,b" };
-    case 0xb9: return { "res  7,c" };
-    case 0xba: return { "res  7,d" };
-    case 0xbb: return { "res  7,e" };
-    case 0xbc: return { "res  7,h" };
-    case 0xbd: return { "res  7,l" };
-    case 0xbe: return { "res  7,(hl)" };
-    case 0xbf: return { "res  7,a" };
-    case 0xc0: return { "set  0,b" };
-    case 0xc1: return { "set  0,c" };
-    case 0xc2: return { "set  0,d" };
-    case 0xc3: return { "set  0,e" };
-    case 0xc4: return { "set  0,h" };
-    case 0xc5: return { "set  0,l" };
-    case 0xc6: return { "set  0,(hl)" };
-    case 0xc7: return { "set  0,a" };
-    case 0xc8: return { "set  1,b" };
-    case 0xc9: return { "set  1,c" };
-    case 0xca: return { "set  1,d" };
-    case 0xcb: return { "set  1,e" };
-    case 0xcc: return { "set  1,h" };
-    case 0xcd: return { "set  1,l" };
-    case 0xce: return { "set  1,(hl)" };
-    case 0xcf: return { "set  1,a" };
-    case 0xd0: return { "set  2,b" };
-    case 0xd1: return { "set  2,c" };
-    case 0xd2: return { "set  2,d" };
-    case 0xd3: return { "set  2,e" };
-    case 0xd4: return { "set  2,h" };
-    case 0xd5: return { "set  2,l" };
-    case 0xd6: return { "set  2,(hl)" };
-    case 0xd7: return { "set  2,a" };
-    case 0xd8: return { "set  3,b" };
-    case 0xd9: return { "set  3,c" };
-    case 0xda: return { "set  3,d" };
-    case 0xdb: return { "set  3,e" };
-    case 0xdc: return { "set  3,h" };
-    case 0xdd: return { "set  3,l" };
-    case 0xde: return { "set  3,(hl)" };
-    case 0xdf: return { "set  3,a" };
-    case 0xe0: return { "set  4,b" };
-    case 0xe1: return { "set  4,c" };
-    case 0xe2: return { "set  4,d" };
-    case 0xe3: return { "set  4,e" };
-    case 0xe4: return { "set  4,h" };
-    case 0xe5: return { "set  4,l" };
-    case 0xe6: return { "set  4,(hl)" };
-    case 0xe7: return { "set  4,a" };
-    case 0xe8: return { "set  5,b" };
-    case 0xe9: return { "set  5,c" };
-    case 0xea: return { "set  5,d" };
-    case 0xeb: return { "set  5,e" };
-    case 0xec: return { "set  5,h" };
-    case 0xed: return { "set  5,l" };
-    case 0xee: return { "set  5,(hl)" };
-    case 0xef: return { "set  5,a" };
-    case 0xf0: return { "set  6,b" };
-    case 0xf1: return { "set  6,c" };
-    case 0xf2: return { "set  6,d" };
-    case 0xf3: return { "set  6,e" };
-    case 0xf4: return { "set  6,h" };
-    case 0xf5: return { "set  6,l" };
-    case 0xf6: return { "set  6,(hl)" };
-    case 0xf7: return { "set  6,a" };
-    case 0xf8: return { "set  7,b" };
-    case 0xf9: return { "set  7,c" };
-    case 0xfa: return { "set  7,d" };
-    case 0xfb: return { "set  7,e" };
-    case 0xfc: return { "set  7,h" };
-    case 0xfd: return { "set  7,l" };
-    case 0xfe: return { "set  7,(hl)" };
-    case 0xff: return { "set  7,a" };
-  }
-
-  return "";
-}
-
-#endif

bsnes/gameboy/cpu/core/registers.hpp

@@ -1,101 +0,0 @@
-enum {
-  A, F, AF,
-  B, C, BC,
-  D, E, DE,
-  H, L, HL,
-  SP, PC,
-};
-
-enum {
-  ZF, NF, HF, CF,
-};
-
-//register base class
-//the idea here is to have all registers derive from a single base class.
-//this allows construction of opcodes that can take any register as input or output,
-//despite the fact that behind-the-scenes, special handling is done for eg: F, AF, HL, etc.
-//registers can also be chained together: eg af = 0x0000 writes both a and f.
-struct Register {
-  virtual operator unsigned() const = 0;
-  virtual unsigned operator=(unsigned x) = 0;
-  Register& operator=(const Register &x) { operator=((unsigned)x); return *this; }
-
-  unsigned operator++(int) { unsigned r = *this; operator=(*this + 1); return r; }
-  unsigned operator--(int) { unsigned r = *this; operator=(*this - 1); return r; }
-  unsigned operator++() { return operator=(*this + 1); }
-  unsigned operator--() { return operator=(*this - 1); }
-
-  unsigned operator |=(unsigned x) { return operator=(*this | x); }
-  unsigned operator ^=(unsigned x) { return operator=(*this ^ x); }
-  unsigned operator &=(unsigned x) { return operator=(*this & x); }
-
-  unsigned operator<<=(unsigned x) { return operator=(*this << x); }
-  unsigned operator>>=(unsigned x) { return operator=(*this >> x); }
-
-  unsigned operator +=(unsigned x) { return operator=(*this + x); }
-  unsigned operator -=(unsigned x) { return operator=(*this - x); }
-  unsigned operator *=(unsigned x) { return operator=(*this * x); }
-  unsigned operator /=(unsigned x) { return operator=(*this / x); }
-  unsigned operator %=(unsigned x) { return operator=(*this % x); }
-};
-
-struct Register8 : Register {
-  uint8 data;
-  operator unsigned() const { return data; }
-  unsigned operator=(unsigned x) { return data = x; }
-};
-
-struct RegisterF : Register {
-  bool z, n, h, c;
-  operator unsigned() const { return (z << 7) | (n << 6) | (h << 5) | (c << 4); }
-  unsigned operator=(unsigned x) { z = x & 0x80; n = x & 0x40; h = x & 0x20; c = x & 0x10; return *this; }
-  bool& operator[](unsigned r) {
-    static bool* table[] = { &z, &n, &h, &c };
-    return *table[r];
-  }
-};
-
-struct Register16 : Register {
-  uint16 data;
-  operator unsigned() const { return data; }
-  unsigned operator=(unsigned x) { return data = x; }
-};
-
-struct RegisterAF : Register {
-  Register8 &hi;
-  RegisterF &lo;
-  operator unsigned() const { return (hi << 8) | (lo << 0); }
-  unsigned operator=(unsigned x) { hi = x >> 8; lo = x >> 0; return *this; }
-  RegisterAF(Register8 &hi, RegisterF &lo) : hi(hi), lo(lo) {}
-};
-
-struct RegisterW : Register {
-  Register8 &hi, &lo;
-  operator unsigned() const { return (hi << 8) | (lo << 0); }
-  unsigned operator=(unsigned x) { hi = x >> 8; lo = x >> 0; return *this; }
-  RegisterW(Register8 &hi, Register8 &lo) : hi(hi), lo(lo) {}
-};
-
-struct Registers {
-  Register8  a;
-  RegisterF  f;
-  RegisterAF af;
-  Register8  b;
-  Register8  c;
-  RegisterW  bc;
-  Register8  d;
-  Register8  e;
-  RegisterW  de;
-  Register8  h;
-  Register8  l;
-  RegisterW  hl;
-  Register16 sp;
-  Register16 pc;
-
-  Register& operator[](unsigned r) {
-    static Register* table[] = { &a, &f, &af, &b, &c, &bc, &d, &e, &de, &h, &l, &hl, &sp, &pc };
-    return *table[r];
-  }
-
-  Registers() : af(a, f), bc(b, c), de(d, e), hl(h, l) {}
-} r;

bsnes/gameboy/cpu/core/table.cpp

@@ -1,519 +0,0 @@
-#ifdef CPU_CPP
-
-void CPU::initialize_opcode_table() {
-  opcode_table[0x00] = &CPU::op_nop;
-  opcode_table[0x01] = &CPU::op_ld_rr_nn<BC>;
-  opcode_table[0x02] = &CPU::op_ld_rr_a<BC>;
-  opcode_table[0x03] = &CPU::op_inc_rr<BC>;
-  opcode_table[0x04] = &CPU::op_inc_r<B>;
-  opcode_table[0x05] = &CPU::op_dec_r<B>;
-  opcode_table[0x06] = &CPU::op_ld_r_n<B>;
-  opcode_table[0x07] = &CPU::op_rlca;
-  opcode_table[0x08] = &CPU::op_ld_nn_sp;
-  opcode_table[0x09] = &CPU::op_add_hl_rr<BC>;
-  opcode_table[0x0a] = &CPU::op_ld_a_rr<BC>;
-  opcode_table[0x0b] = &CPU::op_dec_rr<BC>;
-  opcode_table[0x0c] = &CPU::op_inc_r<C>;
-  opcode_table[0x0d] = &CPU::op_dec_r<C>;
-  opcode_table[0x0e] = &CPU::op_ld_r_n<C>;
-  opcode_table[0x0f] = &CPU::op_rrca;
-  opcode_table[0x10] = &CPU::op_stop;
-  opcode_table[0x11] = &CPU::op_ld_rr_nn<DE>;
-  opcode_table[0x12] = &CPU::op_ld_rr_a<DE>;
-  opcode_table[0x13] = &CPU::op_inc_rr<DE>;
-  opcode_table[0x14] = &CPU::op_inc_r<D>;
-  opcode_table[0x15] = &CPU::op_dec_r<D>;
-  opcode_table[0x16] = &CPU::op_ld_r_n<D>;
-  opcode_table[0x17] = &CPU::op_rla;
-  opcode_table[0x18] = &CPU::op_jr_n;
-  opcode_table[0x19] = &CPU::op_add_hl_rr<DE>;
-  opcode_table[0x1a] = &CPU::op_ld_a_rr<DE>;
-  opcode_table[0x1b] = &CPU::op_dec_rr<DE>;
-  opcode_table[0x1c] = &CPU::op_inc_r<E>;
-  opcode_table[0x1d] = &CPU::op_dec_r<E>;
-  opcode_table[0x1e] = &CPU::op_ld_r_n<E>;
-  opcode_table[0x1f] = &CPU::op_rra;
-  opcode_table[0x20] = &CPU::op_jr_f_n<ZF, 0>;
-  opcode_table[0x21] = &CPU::op_ld_rr_nn<HL>;
-  opcode_table[0x22] = &CPU::op_ldi_hl_a;
-  opcode_table[0x23] = &CPU::op_inc_rr<HL>;
-  opcode_table[0x24] = &CPU::op_inc_r<H>;
-  opcode_table[0x25] = &CPU::op_dec_r<H>;
-  opcode_table[0x26] = &CPU::op_ld_r_n<H>;
-  opcode_table[0x27] = &CPU::op_daa;
-  opcode_table[0x28] = &CPU::op_jr_f_n<ZF, 1>;
-  opcode_table[0x29] = &CPU::op_add_hl_rr<HL>;
-  opcode_table[0x2a] = &CPU::op_ldi_a_hl;
-  opcode_table[0x2b] = &CPU::op_dec_rr<HL>;
-  opcode_table[0x2c] = &CPU::op_inc_r<L>;
-  opcode_table[0x2d] = &CPU::op_dec_r<L>;
-  opcode_table[0x2e] = &CPU::op_ld_r_n<L>;
-  opcode_table[0x2f] = &CPU::op_cpl;
-  opcode_table[0x30] = &CPU::op_jr_f_n<CF, 0>;
-  opcode_table[0x31] = &CPU::op_ld_rr_nn<SP>;
-  opcode_table[0x32] = &CPU::op_ldd_hl_a;
-  opcode_table[0x33] = &CPU::op_inc_rr<SP>;
-  opcode_table[0x34] = &CPU::op_inc_hl;
-  opcode_table[0x35] = &CPU::op_dec_hl;
-  opcode_table[0x36] = &CPU::op_ld_hl_n;
-  opcode_table[0x37] = &CPU::op_scf;
-  opcode_table[0x38] = &CPU::op_jr_f_n<CF, 1>;
-  opcode_table[0x39] = &CPU::op_add_hl_rr<SP>;
-  opcode_table[0x3a] = &CPU::op_ldd_a_hl;
-  opcode_table[0x3b] = &CPU::op_dec_rr<SP>;
-  opcode_table[0x3c] = &CPU::op_inc_r<A>;
-  opcode_table[0x3d] = &CPU::op_dec_r<A>;
-  opcode_table[0x3e] = &CPU::op_ld_r_n<A>;
-  opcode_table[0x3f] = &CPU::op_ccf;
-  opcode_table[0x40] = &CPU::op_ld_r_r<B, B>;
-  opcode_table[0x41] = &CPU::op_ld_r_r<B, C>;
-  opcode_table[0x42] = &CPU::op_ld_r_r<B, D>;
-  opcode_table[0x43] = &CPU::op_ld_r_r<B, E>;
-  opcode_table[0x44] = &CPU::op_ld_r_r<B, H>;
-  opcode_table[0x45] = &CPU::op_ld_r_r<B, L>;
-  opcode_table[0x46] = &CPU::op_ld_r_hl<B>;
-  opcode_table[0x47] = &CPU::op_ld_r_r<B, A>;
-  opcode_table[0x48] = &CPU::op_ld_r_r<C, B>;
-  opcode_table[0x49] = &CPU::op_ld_r_r<C, C>;
-  opcode_table[0x4a] = &CPU::op_ld_r_r<C, D>;
-  opcode_table[0x4b] = &CPU::op_ld_r_r<C, E>;
-  opcode_table[0x4c] = &CPU::op_ld_r_r<C, H>;
-  opcode_table[0x4d] = &CPU::op_ld_r_r<C, L>;
-  opcode_table[0x4e] = &CPU::op_ld_r_hl<C>;
-  opcode_table[0x4f] = &CPU::op_ld_r_r<C, A>;
-  opcode_table[0x50] = &CPU::op_ld_r_r<D, B>;
-  opcode_table[0x51] = &CPU::op_ld_r_r<D, C>;
-  opcode_table[0x52] = &CPU::op_ld_r_r<D, D>;
-  opcode_table[0x53] = &CPU::op_ld_r_r<D, E>;
-  opcode_table[0x54] = &CPU::op_ld_r_r<D, H>;
-  opcode_table[0x55] = &CPU::op_ld_r_r<D, L>;
-  opcode_table[0x56] = &CPU::op_ld_r_hl<D>;
-  opcode_table[0x57] = &CPU::op_ld_r_r<D, A>;
-  opcode_table[0x58] = &CPU::op_ld_r_r<E, B>;
-  opcode_table[0x59] = &CPU::op_ld_r_r<E, C>;
-  opcode_table[0x5a] = &CPU::op_ld_r_r<E, D>;
-  opcode_table[0x5b] = &CPU::op_ld_r_r<E, E>;
-  opcode_table[0x5c] = &CPU::op_ld_r_r<E, H>;
-  opcode_table[0x5d] = &CPU::op_ld_r_r<E, L>;
-  opcode_table[0x5e] = &CPU::op_ld_r_hl<E>;
-  opcode_table[0x5f] = &CPU::op_ld_r_r<E, A>;
-  opcode_table[0x60] = &CPU::op_ld_r_r<H, B>;
-  opcode_table[0x61] = &CPU::op_ld_r_r<H, C>;
-  opcode_table[0x62] = &CPU::op_ld_r_r<H, D>;
-  opcode_table[0x63] = &CPU::op_ld_r_r<H, E>;
-  opcode_table[0x64] = &CPU::op_ld_r_r<H, H>;
-  opcode_table[0x65] = &CPU::op_ld_r_r<H, L>;
-  opcode_table[0x66] = &CPU::op_ld_r_hl<H>;
-  opcode_table[0x67] = &CPU::op_ld_r_r<H, A>;
-  opcode_table[0x68] = &CPU::op_ld_r_r<L, B>;
-  opcode_table[0x69] = &CPU::op_ld_r_r<L, C>;
-  opcode_table[0x6a] = &CPU::op_ld_r_r<L, D>;
-  opcode_table[0x6b] = &CPU::op_ld_r_r<L, E>;
-  opcode_table[0x6c] = &CPU::op_ld_r_r<L, H>;
-  opcode_table[0x6d] = &CPU::op_ld_r_r<L, L>;
-  opcode_table[0x6e] = &CPU::op_ld_r_hl<L>;
-  opcode_table[0x6f] = &CPU::op_ld_r_r<L, A>;
-  opcode_table[0x70] = &CPU::op_ld_hl_r<B>;
-  opcode_table[0x71] = &CPU::op_ld_hl_r<C>;
-  opcode_table[0x72] = &CPU::op_ld_hl_r<D>;
-  opcode_table[0x73] = &CPU::op_ld_hl_r<E>;
-  opcode_table[0x74] = &CPU::op_ld_hl_r<H>;
-  opcode_table[0x75] = &CPU::op_ld_hl_r<L>;
-  opcode_table[0x76] = &CPU::op_halt;
-  opcode_table[0x77] = &CPU::op_ld_hl_r<A>;
-  opcode_table[0x78] = &CPU::op_ld_r_r<A, B>;
-  opcode_table[0x79] = &CPU::op_ld_r_r<A, C>;
-  opcode_table[0x7a] = &CPU::op_ld_r_r<A, D>;
-  opcode_table[0x7b] = &CPU::op_ld_r_r<A, E>;
-  opcode_table[0x7c] = &CPU::op_ld_r_r<A, H>;
-  opcode_table[0x7d] = &CPU::op_ld_r_r<A, L>;
-  opcode_table[0x7e] = &CPU::op_ld_r_hl<A>;
-  opcode_table[0x7f] = &CPU::op_ld_r_r<A, A>;
-  opcode_table[0x80] = &CPU::op_add_a_r<B>;
-  opcode_table[0x81] = &CPU::op_add_a_r<C>;
-  opcode_table[0x82] = &CPU::op_add_a_r<D>;
-  opcode_table[0x83] = &CPU::op_add_a_r<E>;
-  opcode_table[0x84] = &CPU::op_add_a_r<H>;
-  opcode_table[0x85] = &CPU::op_add_a_r<L>;
-  opcode_table[0x86] = &CPU::op_add_a_hl;
-  opcode_table[0x87] = &CPU::op_add_a_r<A>;
-  opcode_table[0x88] = &CPU::op_adc_a_r<B>;
-  opcode_table[0x89] = &CPU::op_adc_a_r<C>;
-  opcode_table[0x8a] = &CPU::op_adc_a_r<D>;
-  opcode_table[0x8b] = &CPU::op_adc_a_r<E>;
-  opcode_table[0x8c] = &CPU::op_adc_a_r<H>;
-  opcode_table[0x8d] = &CPU::op_adc_a_r<L>;
-  opcode_table[0x8e] = &CPU::op_adc_a_hl;
-  opcode_table[0x8f] = &CPU::op_adc_a_r<A>;
-  opcode_table[0x90] = &CPU::op_sub_a_r<B>;
-  opcode_table[0x91] = &CPU::op_sub_a_r<C>;
-  opcode_table[0x92] = &CPU::op_sub_a_r<D>;
-  opcode_table[0x93] = &CPU::op_sub_a_r<E>;
-  opcode_table[0x94] = &CPU::op_sub_a_r<H>;
-  opcode_table[0x95] = &CPU::op_sub_a_r<L>;
-  opcode_table[0x96] = &CPU::op_sub_a_hl;
-  opcode_table[0x97] = &CPU::op_sub_a_r<A>;
-  opcode_table[0x98] = &CPU::op_sbc_a_r<B>;
-  opcode_table[0x99] = &CPU::op_sbc_a_r<C>;
-  opcode_table[0x9a] = &CPU::op_sbc_a_r<D>;
-  opcode_table[0x9b] = &CPU::op_sbc_a_r<E>;
-  opcode_table[0x9c] = &CPU::op_sbc_a_r<H>;
-  opcode_table[0x9d] = &CPU::op_sbc_a_r<L>;
-  opcode_table[0x9e] = &CPU::op_sbc_a_hl;
-  opcode_table[0x9f] = &CPU::op_sbc_a_r<A>;
-  opcode_table[0xa0] = &CPU::op_and_a_r<B>;
-  opcode_table[0xa1] = &CPU::op_and_a_r<C>;
-  opcode_table[0xa2] = &CPU::op_and_a_r<D>;
-  opcode_table[0xa3] = &CPU::op_and_a_r<E>;
-  opcode_table[0xa4] = &CPU::op_and_a_r<H>;
-  opcode_table[0xa5] = &CPU::op_and_a_r<L>;
-  opcode_table[0xa6] = &CPU::op_and_a_hl;
-  opcode_table[0xa7] = &CPU::op_and_a_r<A>;
-  opcode_table[0xa8] = &CPU::op_xor_a_r<B>;
-  opcode_table[0xa9] = &CPU::op_xor_a_r<C>;
-  opcode_table[0xaa] = &CPU::op_xor_a_r<D>;
-  opcode_table[0xab] = &CPU::op_xor_a_r<E>;
-  opcode_table[0xac] = &CPU::op_xor_a_r<H>;
-  opcode_table[0xad] = &CPU::op_xor_a_r<L>;
-  opcode_table[0xae] = &CPU::op_xor_a_hl;
-  opcode_table[0xaf] = &CPU::op_xor_a_r<A>;
-  opcode_table[0xb0] = &CPU::op_or_a_r<B>;
-  opcode_table[0xb1] = &CPU::op_or_a_r<C>;
-  opcode_table[0xb2] = &CPU::op_or_a_r<D>;
-  opcode_table[0xb3] = &CPU::op_or_a_r<E>;
-  opcode_table[0xb4] = &CPU::op_or_a_r<H>;
-  opcode_table[0xb5] = &CPU::op_or_a_r<L>;
-  opcode_table[0xb6] = &CPU::op_or_a_hl;
-  opcode_table[0xb7] = &CPU::op_or_a_r<A>;
-  opcode_table[0xb8] = &CPU::op_cp_a_r<B>;
-  opcode_table[0xb9] = &CPU::op_cp_a_r<C>;
-  opcode_table[0xba] = &CPU::op_cp_a_r<D>;
-  opcode_table[0xbb] = &CPU::op_cp_a_r<E>;
-  opcode_table[0xbc] = &CPU::op_cp_a_r<H>;
-  opcode_table[0xbd] = &CPU::op_cp_a_r<L>;
-  opcode_table[0xbe] = &CPU::op_cp_a_hl;
-  opcode_table[0xbf] = &CPU::op_cp_a_r<A>;
-  opcode_table[0xc0] = &CPU::op_ret_f<ZF, 0>;
-  opcode_table[0xc1] = &CPU::op_pop_rr<BC>;
-  opcode_table[0xc2] = &CPU::op_jp_f_nn<ZF, 0>;
-  opcode_table[0xc3] = &CPU::op_jp_nn;
-  opcode_table[0xc4] = &CPU::op_call_f_nn<ZF, 0>;
-  opcode_table[0xc5] = &CPU::op_push_rr<BC>;
-  opcode_table[0xc6] = &CPU::op_add_a_n;
-  opcode_table[0xc7] = &CPU::op_rst_n<0x00>;
-  opcode_table[0xc8] = &CPU::op_ret_f<ZF, 1>;
-  opcode_table[0xc9] = &CPU::op_ret;
-  opcode_table[0xca] = &CPU::op_jp_f_nn<ZF, 1>;
-  opcode_table[0xcb] = &CPU::op_cb;
-  opcode_table[0xcc] = &CPU::op_call_f_nn<ZF, 1>;
-  opcode_table[0xcd] = &CPU::op_call_nn;
-  opcode_table[0xce] = &CPU::op_adc_a_n;
-  opcode_table[0xcf] = &CPU::op_rst_n<0x08>;
-  opcode_table[0xd0] = &CPU::op_ret_f<CF, 0>;
-  opcode_table[0xd1] = &CPU::op_pop_rr<DE>;
-  opcode_table[0xd2] = &CPU::op_jp_f_nn<CF, 0>;
-  opcode_table[0xd3] = &CPU::op_xx;
-  opcode_table[0xd4] = &CPU::op_call_f_nn<CF, 0>;
-  opcode_table[0xd5] = &CPU::op_push_rr<DE>;
-  opcode_table[0xd6] = &CPU::op_sub_a_n;
-  opcode_table[0xd7] = &CPU::op_rst_n<0x10>;
-  opcode_table[0xd8] = &CPU::op_ret_f<CF, 1>;
-  opcode_table[0xd9] = &CPU::op_reti;
-  opcode_table[0xda] = &CPU::op_jp_f_nn<CF, 1>;
-  opcode_table[0xdb] = &CPU::op_xx;
-  opcode_table[0xdc] = &CPU::op_call_f_nn<CF, 1>;
-  opcode_table[0xdd] = &CPU::op_xx;
-  opcode_table[0xde] = &CPU::op_sbc_a_n;
-  opcode_table[0xdf] = &CPU::op_rst_n<0x18>;
-  opcode_table[0xe0] = &CPU::op_ld_ffn_a;
-  opcode_table[0xe1] = &CPU::op_pop_rr<HL>;
-  opcode_table[0xe2] = &CPU::op_ld_ffc_a;
-  opcode_table[0xe3] = &CPU::op_xx;
-  opcode_table[0xe4] = &CPU::op_xx;
-  opcode_table[0xe5] = &CPU::op_push_rr<HL>;
-  opcode_table[0xe6] = &CPU::op_and_a_n;
-  opcode_table[0xe7] = &CPU::op_rst_n<0x20>;
-  opcode_table[0xe8] = &CPU::op_add_sp_n;
-  opcode_table[0xe9] = &CPU::op_jp_hl;
-  opcode_table[0xea] = &CPU::op_ld_nn_a;
-  opcode_table[0xeb] = &CPU::op_xx;
-  opcode_table[0xec] = &CPU::op_xx;
-  opcode_table[0xed] = &CPU::op_xx;
-  opcode_table[0xee] = &CPU::op_xor_a_n;
-  opcode_table[0xef] = &CPU::op_rst_n<0x28>;
-  opcode_table[0xf0] = &CPU::op_ld_a_ffn;
-  opcode_table[0xf1] = &CPU::op_pop_rr<AF>;
-  opcode_table[0xf2] = &CPU::op_ld_a_ffc;
-  opcode_table[0xf3] = &CPU::op_di;
-  opcode_table[0xf4] = &CPU::op_xx;
-  opcode_table[0xf5] = &CPU::op_push_rr<AF>;
-  opcode_table[0xf6] = &CPU::op_or_a_n;
-  opcode_table[0xf7] = &CPU::op_rst_n<0x30>;
-  opcode_table[0xf8] = &CPU::op_ld_hl_sp_n;
-  opcode_table[0xf9] = &CPU::op_ld_sp_hl;
-  opcode_table[0xfa] = &CPU::op_ld_a_nn;
-  opcode_table[0xfb] = &CPU::op_ei;
-  opcode_table[0xfc] = &CPU::op_xx;
-  opcode_table[0xfd] = &CPU::op_xx;
-  opcode_table[0xfe] = &CPU::op_cp_a_n;
-  opcode_table[0xff] = &CPU::op_rst_n<0x38>;
-
-  opcode_table_cb[0x00] = &CPU::op_rlc_r<B>;
-  opcode_table_cb[0x01] = &CPU::op_rlc_r<C>;
-  opcode_table_cb[0x02] = &CPU::op_rlc_r<D>;
-  opcode_table_cb[0x03] = &CPU::op_rlc_r<E>;
-  opcode_table_cb[0x04] = &CPU::op_rlc_r<H>;
-  opcode_table_cb[0x05] = &CPU::op_rlc_r<L>;
-  opcode_table_cb[0x06] = &CPU::op_rlc_hl;
-  opcode_table_cb[0x07] = &CPU::op_rlc_r<A>;
-  opcode_table_cb[0x08] = &CPU::op_rrc_r<B>;
-  opcode_table_cb[0x09] = &CPU::op_rrc_r<C>;
-  opcode_table_cb[0x0a] = &CPU::op_rrc_r<D>;
-  opcode_table_cb[0x0b] = &CPU::op_rrc_r<E>;
-  opcode_table_cb[0x0c] = &CPU::op_rrc_r<H>;
-  opcode_table_cb[0x0d] = &CPU::op_rrc_r<L>;
-  opcode_table_cb[0x0e] = &CPU::op_rrc_hl;
-  opcode_table_cb[0x0f] = &CPU::op_rrc_r<A>;
-  opcode_table_cb[0x10] = &CPU::op_rl_r<B>;
-  opcode_table_cb[0x11] = &CPU::op_rl_r<C>;
-  opcode_table_cb[0x12] = &CPU::op_rl_r<D>;
-  opcode_table_cb[0x13] = &CPU::op_rl_r<E>;
-  opcode_table_cb[0x14] = &CPU::op_rl_r<H>;
-  opcode_table_cb[0x15] = &CPU::op_rl_r<L>;
-  opcode_table_cb[0x16] = &CPU::op_rl_hl;
-  opcode_table_cb[0x17] = &CPU::op_rl_r<A>;
-  opcode_table_cb[0x18] = &CPU::op_rr_r<B>;
-  opcode_table_cb[0x19] = &CPU::op_rr_r<C>;
-  opcode_table_cb[0x1a] = &CPU::op_rr_r<D>;
-  opcode_table_cb[0x1b] = &CPU::op_rr_r<E>;
-  opcode_table_cb[0x1c] = &CPU::op_rr_r<H>;
-  opcode_table_cb[0x1d] = &CPU::op_rr_r<L>;
-  opcode_table_cb[0x1e] = &CPU::op_rr_hl;
-  opcode_table_cb[0x1f] = &CPU::op_rr_r<A>;
-  opcode_table_cb[0x20] = &CPU::op_sla_r<B>;
-  opcode_table_cb[0x21] = &CPU::op_sla_r<C>;
-  opcode_table_cb[0x22] = &CPU::op_sla_r<D>;
-  opcode_table_cb[0x23] = &CPU::op_sla_r<E>;
-  opcode_table_cb[0x24] = &CPU::op_sla_r<H>;
-  opcode_table_cb[0x25] = &CPU::op_sla_r<L>;
-  opcode_table_cb[0x26] = &CPU::op_sla_hl;
-  opcode_table_cb[0x27] = &CPU::op_sla_r<A>;
-  opcode_table_cb[0x28] = &CPU::op_sra_r<B>;
-  opcode_table_cb[0x29] = &CPU::op_sra_r<C>;
-  opcode_table_cb[0x2a] = &CPU::op_sra_r<D>;
-  opcode_table_cb[0x2b] = &CPU::op_sra_r<E>;
-  opcode_table_cb[0x2c] = &CPU::op_sra_r<H>;
-  opcode_table_cb[0x2d] = &CPU::op_sra_r<L>;
-  opcode_table_cb[0x2e] = &CPU::op_sra_hl;
-  opcode_table_cb[0x2f] = &CPU::op_sra_r<A>;
-  opcode_table_cb[0x30] = &CPU::op_swap_r<B>;
-  opcode_table_cb[0x31] = &CPU::op_swap_r<C>;
-  opcode_table_cb[0x32] = &CPU::op_swap_r<D>;
-  opcode_table_cb[0x33] = &CPU::op_swap_r<E>;
-  opcode_table_cb[0x34] = &CPU::op_swap_r<H>;
-  opcode_table_cb[0x35] = &CPU::op_swap_r<L>;
-  opcode_table_cb[0x36] = &CPU::op_swap_hl;
-  opcode_table_cb[0x37] = &CPU::op_swap_r<A>;
-  opcode_table_cb[0x38] = &CPU::op_srl_r<B>;
-  opcode_table_cb[0x39] = &CPU::op_srl_r<C>;
-  opcode_table_cb[0x3a] = &CPU::op_srl_r<D>;
-  opcode_table_cb[0x3b] = &CPU::op_srl_r<E>;
-  opcode_table_cb[0x3c] = &CPU::op_srl_r<H>;
-  opcode_table_cb[0x3d] = &CPU::op_srl_r<L>;
-  opcode_table_cb[0x3e] = &CPU::op_srl_hl;
-  opcode_table_cb[0x3f] = &CPU::op_srl_r<A>;
-  opcode_table_cb[0x40] = &CPU::op_bit_n_r<0, B>;
-  opcode_table_cb[0x41] = &CPU::op_bit_n_r<0, C>;
-  opcode_table_cb[0x42] = &CPU::op_bit_n_r<0, D>;
-  opcode_table_cb[0x43] = &CPU::op_bit_n_r<0, E>;
-  opcode_table_cb[0x44] = &CPU::op_bit_n_r<0, H>;
-  opcode_table_cb[0x45] = &CPU::op_bit_n_r<0, L>;
-  opcode_table_cb[0x46] = &CPU::op_bit_n_hl<0>;
-  opcode_table_cb[0x47] = &CPU::op_bit_n_r<0, A>;
-  opcode_table_cb[0x48] = &CPU::op_bit_n_r<1, B>;
-  opcode_table_cb[0x49] = &CPU::op_bit_n_r<1, C>;
-  opcode_table_cb[0x4a] = &CPU::op_bit_n_r<1, D>;
-  opcode_table_cb[0x4b] = &CPU::op_bit_n_r<1, E>;
-  opcode_table_cb[0x4c] = &CPU::op_bit_n_r<1, H>;
-  opcode_table_cb[0x4d] = &CPU::op_bit_n_r<1, L>;
-  opcode_table_cb[0x4e] = &CPU::op_bit_n_hl<1>;
-  opcode_table_cb[0x4f] = &CPU::op_bit_n_r<1, A>;
-  opcode_table_cb[0x50] = &CPU::op_bit_n_r<2, B>;
-  opcode_table_cb[0x51] = &CPU::op_bit_n_r<2, C>;
-  opcode_table_cb[0x52] = &CPU::op_bit_n_r<2, D>;
-  opcode_table_cb[0x53] = &CPU::op_bit_n_r<2, E>;
-  opcode_table_cb[0x54] = &CPU::op_bit_n_r<2, H>;
-  opcode_table_cb[0x55] = &CPU::op_bit_n_r<2, L>;
-  opcode_table_cb[0x56] = &CPU::op_bit_n_hl<2>;
-  opcode_table_cb[0x57] = &CPU::op_bit_n_r<2, A>;
-  opcode_table_cb[0x58] = &CPU::op_bit_n_r<3, B>;
-  opcode_table_cb[0x59] = &CPU::op_bit_n_r<3, C>;
-  opcode_table_cb[0x5a] = &CPU::op_bit_n_r<3, D>;
-  opcode_table_cb[0x5b] = &CPU::op_bit_n_r<3, E>;
-  opcode_table_cb[0x5c] = &CPU::op_bit_n_r<3, H>;
-  opcode_table_cb[0x5d] = &CPU::op_bit_n_r<3, L>;
-  opcode_table_cb[0x5e] = &CPU::op_bit_n_hl<3>;
-  opcode_table_cb[0x5f] = &CPU::op_bit_n_r<3, A>;
-  opcode_table_cb[0x60] = &CPU::op_bit_n_r<4, B>;
-  opcode_table_cb[0x61] = &CPU::op_bit_n_r<4, C>;
-  opcode_table_cb[0x62] = &CPU::op_bit_n_r<4, D>;
-  opcode_table_cb[0x63] = &CPU::op_bit_n_r<4, E>;
-  opcode_table_cb[0x64] = &CPU::op_bit_n_r<4, H>;
-  opcode_table_cb[0x65] = &CPU::op_bit_n_r<4, L>;
-  opcode_table_cb[0x66] = &CPU::op_bit_n_hl<4>;
-  opcode_table_cb[0x67] = &CPU::op_bit_n_r<4, A>;
-  opcode_table_cb[0x68] = &CPU::op_bit_n_r<5, B>;
-  opcode_table_cb[0x69] = &CPU::op_bit_n_r<5, C>;
-  opcode_table_cb[0x6a] = &CPU::op_bit_n_r<5, D>;
-  opcode_table_cb[0x6b] = &CPU::op_bit_n_r<5, E>;
-  opcode_table_cb[0x6c] = &CPU::op_bit_n_r<5, H>;
-  opcode_table_cb[0x6d] = &CPU::op_bit_n_r<5, L>;
-  opcode_table_cb[0x6e] = &CPU::op_bit_n_hl<5>;
-  opcode_table_cb[0x6f] = &CPU::op_bit_n_r<5, A>;
-  opcode_table_cb[0x70] = &CPU::op_bit_n_r<6, B>;
-  opcode_table_cb[0x71] = &CPU::op_bit_n_r<6, C>;
-  opcode_table_cb[0x72] = &CPU::op_bit_n_r<6, D>;
-  opcode_table_cb[0x73] = &CPU::op_bit_n_r<6, E>;
-  opcode_table_cb[0x74] = &CPU::op_bit_n_r<6, H>;
-  opcode_table_cb[0x75] = &CPU::op_bit_n_r<6, L>;
-  opcode_table_cb[0x76] = &CPU::op_bit_n_hl<6>;
-  opcode_table_cb[0x77] = &CPU::op_bit_n_r<6, A>;
-  opcode_table_cb[0x78] = &CPU::op_bit_n_r<7, B>;
-  opcode_table_cb[0x79] = &CPU::op_bit_n_r<7, C>;
-  opcode_table_cb[0x7a] = &CPU::op_bit_n_r<7, D>;
-  opcode_table_cb[0x7b] = &CPU::op_bit_n_r<7, E>;
-  opcode_table_cb[0x7c] = &CPU::op_bit_n_r<7, H>;
-  opcode_table_cb[0x7d] = &CPU::op_bit_n_r<7, L>;
-  opcode_table_cb[0x7e] = &CPU::op_bit_n_hl<7>;
-  opcode_table_cb[0x7f] = &CPU::op_bit_n_r<7, A>;
-  opcode_table_cb[0x80] = &CPU::op_res_n_r<0, B>;
-  opcode_table_cb[0x81] = &CPU::op_res_n_r<0, C>;
-  opcode_table_cb[0x82] = &CPU::op_res_n_r<0, D>;
-  opcode_table_cb[0x83] = &CPU::op_res_n_r<0, E>;
-  opcode_table_cb[0x84] = &CPU::op_res_n_r<0, H>;
-  opcode_table_cb[0x85] = &CPU::op_res_n_r<0, L>;
-  opcode_table_cb[0x86] = &CPU::op_res_n_hl<0>;
-  opcode_table_cb[0x87] = &CPU::op_res_n_r<0, A>;
-  opcode_table_cb[0x88] = &CPU::op_res_n_r<1, B>;
-  opcode_table_cb[0x89] = &CPU::op_res_n_r<1, C>;
-  opcode_table_cb[0x8a] = &CPU::op_res_n_r<1, D>;
-  opcode_table_cb[0x8b] = &CPU::op_res_n_r<1, E>;
-  opcode_table_cb[0x8c] = &CPU::op_res_n_r<1, H>;
-  opcode_table_cb[0x8d] = &CPU::op_res_n_r<1, L>;
-  opcode_table_cb[0x8e] = &CPU::op_res_n_hl<1>;
-  opcode_table_cb[0x8f] = &CPU::op_res_n_r<1, A>;
-  opcode_table_cb[0x90] = &CPU::op_res_n_r<2, B>;
-  opcode_table_cb[0x91] = &CPU::op_res_n_r<2, C>;
-  opcode_table_cb[0x92] = &CPU::op_res_n_r<2, D>;
-  opcode_table_cb[0x93] = &CPU::op_res_n_r<2, E>;
-  opcode_table_cb[0x94] = &CPU::op_res_n_r<2, H>;
-  opcode_table_cb[0x95] = &CPU::op_res_n_r<2, L>;
-  opcode_table_cb[0x96] = &CPU::op_res_n_hl<2>;
-  opcode_table_cb[0x97] = &CPU::op_res_n_r<2, A>;
-  opcode_table_cb[0x98] = &CPU::op_res_n_r<3, B>;
-  opcode_table_cb[0x99] = &CPU::op_res_n_r<3, C>;
-  opcode_table_cb[0x9a] = &CPU::op_res_n_r<3, D>;
-  opcode_table_cb[0x9b] = &CPU::op_res_n_r<3, E>;
-  opcode_table_cb[0x9c] = &CPU::op_res_n_r<3, H>;
-  opcode_table_cb[0x9d] = &CPU::op_res_n_r<3, L>;
-  opcode_table_cb[0x9e] = &CPU::op_res_n_hl<3>;
-  opcode_table_cb[0x9f] = &CPU::op_res_n_r<3, A>;
-  opcode_table_cb[0xa0] = &CPU::op_res_n_r<4, B>;
-  opcode_table_cb[0xa1] = &CPU::op_res_n_r<4, C>;
-  opcode_table_cb[0xa2] = &CPU::op_res_n_r<4, D>;
-  opcode_table_cb[0xa3] = &CPU::op_res_n_r<4, E>;
-  opcode_table_cb[0xa4] = &CPU::op_res_n_r<4, H>;
-  opcode_table_cb[0xa5] = &CPU::op_res_n_r<4, L>;
-  opcode_table_cb[0xa6] = &CPU::op_res_n_hl<4>;
-  opcode_table_cb[0xa7] = &CPU::op_res_n_r<4, A>;
-  opcode_table_cb[0xa8] = &CPU::op_res_n_r<5, B>;
-  opcode_table_cb[0xa9] = &CPU::op_res_n_r<5, C>;
-  opcode_table_cb[0xaa] = &CPU::op_res_n_r<5, D>;
-  opcode_table_cb[0xab] = &CPU::op_res_n_r<5, E>;
-  opcode_table_cb[0xac] = &CPU::op_res_n_r<5, H>;
-  opcode_table_cb[0xad] = &CPU::op_res_n_r<5, L>;
-  opcode_table_cb[0xae] = &CPU::op_res_n_hl<5>;
-  opcode_table_cb[0xaf] = &CPU::op_res_n_r<5, A>;
-  opcode_table_cb[0xb0] = &CPU::op_res_n_r<6, B>;
-  opcode_table_cb[0xb1] = &CPU::op_res_n_r<6, C>;
-  opcode_table_cb[0xb2] = &CPU::op_res_n_r<6, D>;
-  opcode_table_cb[0xb3] = &CPU::op_res_n_r<6, E>;
-  opcode_table_cb[0xb4] = &CPU::op_res_n_r<6, H>;
-  opcode_table_cb[0xb5] = &CPU::op_res_n_r<6, L>;
-  opcode_table_cb[0xb6] = &CPU::op_res_n_hl<6>;
-  opcode_table_cb[0xb7] = &CPU::op_res_n_r<6, A>;
-  opcode_table_cb[0xb8] = &CPU::op_res_n_r<7, B>;
-  opcode_table_cb[0xb9] = &CPU::op_res_n_r<7, C>;
-  opcode_table_cb[0xba] = &CPU::op_res_n_r<7, D>;
-  opcode_table_cb[0xbb] = &CPU::op_res_n_r<7, E>;
-  opcode_table_cb[0xbc] = &CPU::op_res_n_r<7, H>;
-  opcode_table_cb[0xbd] = &CPU::op_res_n_r<7, L>;
-  opcode_table_cb[0xbe] = &CPU::op_res_n_hl<7>;
-  opcode_table_cb[0xbf] = &CPU::op_res_n_r<7, A>;
-  opcode_table_cb[0xc0] = &CPU::op_set_n_r<0, B>;
-  opcode_table_cb[0xc1] = &CPU::op_set_n_r<0, C>;
-  opcode_table_cb[0xc2] = &CPU::op_set_n_r<0, D>;
-  opcode_table_cb[0xc3] = &CPU::op_set_n_r<0, E>;
-  opcode_table_cb[0xc4] = &CPU::op_set_n_r<0, H>;
-  opcode_table_cb[0xc5] = &CPU::op_set_n_r<0, L>;
-  opcode_table_cb[0xc6] = &CPU::op_set_n_hl<0>;
-  opcode_table_cb[0xc7] = &CPU::op_set_n_r<0, A>;
-  opcode_table_cb[0xc8] = &CPU::op_set_n_r<1, B>;
-  opcode_table_cb[0xc9] = &CPU::op_set_n_r<1, C>;
-  opcode_table_cb[0xca] = &CPU::op_set_n_r<1, D>;
-  opcode_table_cb[0xcb] = &CPU::op_set_n_r<1, E>;
-  opcode_table_cb[0xcc] = &CPU::op_set_n_r<1, H>;
-  opcode_table_cb[0xcd] = &CPU::op_set_n_r<1, L>;
-  opcode_table_cb[0xce] = &CPU::op_set_n_hl<1>;
-  opcode_table_cb[0xcf] = &CPU::op_set_n_r<1, A>;
-  opcode_table_cb[0xd0] = &CPU::op_set_n_r<2, B>;
-  opcode_table_cb[0xd1] = &CPU::op_set_n_r<2, C>;
-  opcode_table_cb[0xd2] = &CPU::op_set_n_r<2, D>;
-  opcode_table_cb[0xd3] = &CPU::op_set_n_r<2, E>;
-  opcode_table_cb[0xd4] = &CPU::op_set_n_r<2, H>;
-  opcode_table_cb[0xd5] = &CPU::op_set_n_r<2, L>;
-  opcode_table_cb[0xd6] = &CPU::op_set_n_hl<2>;
-  opcode_table_cb[0xd7] = &CPU::op_set_n_r<2, A>;
-  opcode_table_cb[0xd8] = &CPU::op_set_n_r<3, B>;
-  opcode_table_cb[0xd9] = &CPU::op_set_n_r<3, C>;
-  opcode_table_cb[0xda] = &CPU::op_set_n_r<3, D>;
-  opcode_table_cb[0xdb] = &CPU::op_set_n_r<3, E>;
-  opcode_table_cb[0xdc] = &CPU::op_set_n_r<3, H>;
-  opcode_table_cb[0xdd] = &CPU::op_set_n_r<3, L>;
-  opcode_table_cb[0xde] = &CPU::op_set_n_hl<3>;
-  opcode_table_cb[0xdf] = &CPU::op_set_n_r<3, A>;
-  opcode_table_cb[0xe0] = &CPU::op_set_n_r<4, B>;
-  opcode_table_cb[0xe1] = &CPU::op_set_n_r<4, C>;
-  opcode_table_cb[0xe2] = &CPU::op_set_n_r<4, D>;
-  opcode_table_cb[0xe3] = &CPU::op_set_n_r<4, E>;
-  opcode_table_cb[0xe4] = &CPU::op_set_n_r<4, H>;
-  opcode_table_cb[0xe5] = &CPU::op_set_n_r<4, L>;
-  opcode_table_cb[0xe6] = &CPU::op_set_n_hl<4>;
-  opcode_table_cb[0xe7] = &CPU::op_set_n_r<4, A>;
-  opcode_table_cb[0xe8] = &CPU::op_set_n_r<5, B>;
-  opcode_table_cb[0xe9] = &CPU::op_set_n_r<5, C>;
-  opcode_table_cb[0xea] = &CPU::op_set_n_r<5, D>;
-  opcode_table_cb[0xeb] = &CPU::op_set_n_r<5, E>;
-  opcode_table_cb[0xec] = &CPU::op_set_n_r<5, H>;
-  opcode_table_cb[0xed] = &CPU::op_set_n_r<5, L>;
-  opcode_table_cb[0xee] = &CPU::op_set_n_hl<5>;
-  opcode_table_cb[0xef] = &CPU::op_set_n_r<5, A>;
-  opcode_table_cb[0xf0] = &CPU::op_set_n_r<6, B>;
-  opcode_table_cb[0xf1] = &CPU::op_set_n_r<6, C>;
-  opcode_table_cb[0xf2] = &CPU::op_set_n_r<6, D>;
-  opcode_table_cb[0xf3] = &CPU::op_set_n_r<6, E>;
-  opcode_table_cb[0xf4] = &CPU::op_set_n_r<6, H>;
-  opcode_table_cb[0xf5] = &CPU::op_set_n_r<6, L>;
-  opcode_table_cb[0xf6] = &CPU::op_set_n_hl<6>;
-  opcode_table_cb[0xf7] = &CPU::op_set_n_r<6, A>;
-  opcode_table_cb[0xf8] = &CPU::op_set_n_r<7, B>;
-  opcode_table_cb[0xf9] = &CPU::op_set_n_r<7, C>;
-  opcode_table_cb[0xfa] = &CPU::op_set_n_r<7, D>;
-  opcode_table_cb[0xfb] = &CPU::op_set_n_r<7, E>;
-  opcode_table_cb[0xfc] = &CPU::op_set_n_r<7, H>;
-  opcode_table_cb[0xfd] = &CPU::op_set_n_r<7, L>;
-  opcode_table_cb[0xfe] = &CPU::op_set_n_hl<7>;
-  opcode_table_cb[0xff] = &CPU::op_set_n_r<7, A>;
-}
-
-#endif

bsnes/gameboy/cpu/cpu.cpp

@@ -1,156 +0,0 @@
-#include <gameboy/gameboy.hpp>
-
-#define CPU_CPP
-namespace GameBoy {
-
-#include "core/core.cpp"
-#include "mmio/mmio.cpp"
-#include "timing/timing.cpp"
-#include "serialization.cpp"
-CPU cpu;
-
-void CPU::Main() {
-  cpu.main();
-}
-
-void CPU::main() {
-  while(true) {
-    if(scheduler.sync == Scheduler::SynchronizeMode::CPU) {
-      scheduler.sync = Scheduler::SynchronizeMode::All;
-      scheduler.exit(Scheduler::ExitReason::SynchronizeEvent);
-    }
-
-    if(trace) print(disassemble(r[PC]), "\n");
-    interrupt_test();
-    uint8 opcode = op_read(r[PC]++);
-    (this->*opcode_table[opcode])();
-  }
-}
-
-void CPU::interrupt_raise(CPU::Interrupt id) {
-  if(id == Interrupt::Vblank) {
-    status.interrupt_request_vblank = 1;
-    if(status.interrupt_enable_vblank) status.halt = false;
-  }
-
-  if(id == Interrupt::Stat) {
-    status.interrupt_request_stat = 1;
-    if(status.interrupt_enable_stat) status.halt = false;
-  }
-
-  if(id == Interrupt::Timer) {
-    status.interrupt_request_timer = 1;
-    if(status.interrupt_enable_timer) status.halt = false;
-  }
-
-  if(id == Interrupt::Serial) {
-    status.interrupt_request_serial = 1;
-    if(status.interrupt_enable_serial) status.halt = false;
-  }
-
-  if(id == Interrupt::Joypad) {
-    status.interrupt_request_joypad = 1;
-    if(status.interrupt_enable_joypad) status.halt = status.stop = false;
-  }
-}
-
-void CPU::interrupt_test() {
-  if(status.ime) {
-    if(status.interrupt_request_vblank && status.interrupt_enable_vblank) {
-      status.interrupt_request_vblank = 0;
-      return interrupt_exec(0x0040);
-    }
-
-    if(status.interrupt_request_stat && status.interrupt_enable_stat) {
-      status.interrupt_request_stat = 0;
-      return interrupt_exec(0x0048);
-    }
-
-    if(status.interrupt_request_timer && status.interrupt_enable_timer) {
-      status.interrupt_request_timer = 0;
-      return interrupt_exec(0x0050);
-    }
-
-    if(status.interrupt_request_serial && status.interrupt_enable_serial) {
-      status.interrupt_request_serial = 0;
-      return interrupt_exec(0x0058);
-    }
-
-    if(status.interrupt_request_joypad && status.interrupt_enable_joypad) {
-      status.interrupt_request_joypad = 0;
-      return interrupt_exec(0x0060);
-    }
-  }
-}
-
-void CPU::interrupt_exec(uint16 pc) {
-  status.ime = 0;
-  op_write(--r[SP], r[PC] >> 8);
-  op_write(--r[SP], r[PC] >> 0);
-  r[PC] = pc;
-  op_io();
-  op_io();
-  op_io();
-}
-
-void CPU::power() {
-  create(Main, 4194304);
-
-  for(unsigned n = 0xc000; n <= 0xdfff; n++) bus.mmio[n] = this;  //WRAM
-  for(unsigned n = 0xe000; n <= 0xfdff; n++) bus.mmio[n] = this;  //WRAM (mirror)
-  for(unsigned n = 0xff00; n <= 0xff0f; n++) bus.mmio[n] = this;  //MMIO
-  for(unsigned n = 0xff80; n <= 0xffff; n++) bus.mmio[n] = this;  //HRAM+IE
-
-  for(unsigned n = 0; n < 8192; n++) wram[n] = 0x00;
-  for(unsigned n = 0; n <  128; n++) hram[n] = 0x00;
-
-  r[PC] = 0x0000;
-  r[SP] = 0x0000;
-  r[AF] = 0x0000;
-  r[BC] = 0x0000;
-  r[DE] = 0x0000;
-  r[HL] = 0x0000;
-
-  status.clock = 0;
-  status.halt = false;
-  status.stop = false;
-  status.ime = 0;
-
-  status.p15 = 0;
-  status.p14 = 0;
-  status.joyp = 0;
-  status.mlt_req = 0;
-
-  status.serial_data = 0;
-  status.serial_bits = 0;
-
-  status.serial_transfer = 0;
-  status.serial_clock = 0;
-
-  status.div = 0;
-
-  status.tima = 0;
-
-  status.tma = 0;
-
-  status.timer_enable = 0;
-  status.timer_clock = 0;
-
-  status.interrupt_request_joypad = 0;
-  status.interrupt_request_serial = 0;
-  status.interrupt_request_timer = 0;
-  status.interrupt_request_stat = 0;
-  status.interrupt_request_vblank = 0;
-
-  status.interrupt_enable_joypad = 0;
-  status.interrupt_enable_serial = 0;
-  status.interrupt_enable_timer = 0;
-  status.interrupt_enable_stat = 0;
-  status.interrupt_enable_vblank = 0;
-}
-
-CPU::CPU() : trace(false) {
-  initialize_opcode_table();
-}
-
-}

bsnes/gameboy/cpu/cpu.hpp

@@ -1,78 +0,0 @@
-struct CPU : Processor, MMIO {
-  #include "core/core.hpp"
-  #include "mmio/mmio.hpp"
-  #include "timing/timing.hpp"
-
-  bool trace;
-
-  enum class Interrupt : unsigned {
-    Vblank,
-    Stat,
-    Timer,
-    Serial,
-    Joypad,
-  };
-
-  struct Status {
-    unsigned clock;
-    bool halt;
-    bool stop;
-    bool ime;
-
-    //$ff00  JOYP
-    bool p15;
-    bool p14;
-    uint8 joyp;
-    uint8 mlt_req;
-
-    //$ff01  SB
-    uint8 serial_data;
-    unsigned serial_bits;
-
-    //$ff02  SC
-    bool serial_transfer;
-    bool serial_clock;
-
-    //$ff04  DIV
-    uint8 div;
-
-    //$ff05  TIMA
-    uint8 tima;
-
-    //$ff06  TMA
-    uint8 tma;
-
-    //$ff07  TAC
-    bool timer_enable;
-    unsigned timer_clock;
-
-    //$ff0f  IF
-    bool interrupt_request_joypad;
-    bool interrupt_request_serial;
-    bool interrupt_request_timer;
-    bool interrupt_request_stat;
-    bool interrupt_request_vblank;
-
-    //$ffff  IE
-    bool interrupt_enable_joypad;
-    bool interrupt_enable_serial;
-    bool interrupt_enable_timer;
-    bool interrupt_enable_stat;
-    bool interrupt_enable_vblank;
-  } status;
-
-  uint8 wram[8192];
-  uint8 hram[128];
-
-  static void Main();
-  void main();
-  void interrupt_raise(Interrupt id);
-  void interrupt_test();
-  void interrupt_exec(uint16 pc);
-  void power();
-
-  void serialize(serializer&);
-  CPU();
-};
-
-extern CPU cpu;

bsnes/gameboy/cpu/mmio/mmio.cpp

@@ -1,144 +0,0 @@
-#ifdef CPU_CPP
-
-void CPU::mmio_joyp_poll() {
-  unsigned button = 0, dpad = 0;
-
-  button |= system.interface->input_poll((unsigned)Input::Start) << 3;
-  button |= system.interface->input_poll((unsigned)Input::Select) << 2;
-  button |= system.interface->input_poll((unsigned)Input::B) << 1;
-  button |= system.interface->input_poll((unsigned)Input::A) << 0;
-
-  dpad |= system.interface->input_poll((unsigned)Input::Down) << 3;
-  dpad |= system.interface->input_poll((unsigned)Input::Up) << 2;
-  dpad |= system.interface->input_poll((unsigned)Input::Left) << 1;
-  dpad |= system.interface->input_poll((unsigned)Input::Right) << 0;
-
-  status.joyp = 0x0f;
-  if(status.p15 == 1 && status.p14 == 1) status.joyp -= status.mlt_req;
-  if(status.p15 == 0) status.joyp &= button ^ 0x0f;
-  if(status.p14 == 0) status.joyp &= dpad ^ 0x0f;
-  if(status.joyp != 0x0f) interrupt_raise(Interrupt::Joypad);
-}
-
-uint8 CPU::mmio_read(uint16 addr) {
-  if(addr >= 0xc000 && addr <= 0xdfff) return wram[addr & 0x1fff];
-  if(addr >= 0xe000 && addr <= 0xfdff) return wram[addr & 0x1fff];
-  if(addr >= 0xff80 && addr <= 0xfffe) return hram[addr & 0x7f];
-
-  if(addr == 0xff00) {  //JOYP
-    return (status.p15 << 5)
-         | (status.p14 << 4)
-         | (status.joyp << 0);
-  }
-
-  if(addr == 0xff01) {  //SB
-    return 0xff;
-  }
-
-  if(addr == 0xff02) {  //SC
-    return (status.serial_transfer << 7)
-         | (status.serial_clock << 0);
-  }
-
-  if(addr == 0xff04) {  //DIV
-    return status.div;
-  }
-
-  if(addr == 0xff05) {  //TIMA
-    return status.tima;
-  }
-
-  if(addr == 0xff06) {  //TMA
-    return status.tma;
-  }
-
-  if(addr == 0xff07) {  //TAC
-    return (status.timer_enable << 2)
-         | (status.timer_clock << 0);
-  }
-
-  if(addr == 0xff0f) {  //IF
-    return (status.interrupt_request_joypad << 4)
-         | (status.interrupt_request_serial << 3)
-         | (status.interrupt_request_timer << 2)
-         | (status.interrupt_request_stat << 1)
-         | (status.interrupt_request_vblank << 0);
-  }
-
-  if(addr == 0xffff) {  //IE
-    return (status.interrupt_enable_joypad << 4)
-         | (status.interrupt_enable_serial << 3)
-         | (status.interrupt_enable_timer << 2)
-         | (status.interrupt_enable_stat << 1)
-         | (status.interrupt_enable_vblank << 0);
-  }
-
-  return 0x00;
-}
-
-void CPU::mmio_write(uint16 addr, uint8 data) {
-  if(addr >= 0xc000 && addr <= 0xdfff) { wram[addr & 0x1fff] = data; return; }
-  if(addr >= 0xe000 && addr <= 0xfdff) { wram[addr & 0x1fff] = data; return; }
-  if(addr >= 0xff80 && addr <= 0xfffe) { hram[addr & 0x7f] = data; return; }
-
-  if(addr == 0xff00) {  //JOYP
-    status.p15 = data & 0x20;
-    status.p14 = data & 0x10;
-    system.interface->joyp_write(status.p15, status.p14);
-    mmio_joyp_poll();
-    return;
-  }
-
-  if(addr == 0xff01) {  //SB
-    status.serial_data = data;
-    return;
-  }
-
-  if(addr == 0xff02) {  //SC
-    status.serial_transfer = data & 0x80;
-    status.serial_clock = data & 0x01;
-    if(status.serial_transfer) status.serial_bits = 8;
-    return;
-  }
-
-  if(addr == 0xff04) {  //DIV
-    status.div = 0;
-    return;
-  }
-
-  if(addr == 0xff05) {  //TIMA
-    status.tima = data;
-    return;
-  }
-
-  if(addr == 0xff06) {  //TMA
-    status.tma = data;
-    return;
-  }
-
-  if(addr == 0xff07) {  //TAC
-    status.timer_enable = data & 0x04;
-    status.timer_clock = data & 0x03;
-    return;
-  }
-
-  if(addr == 0xff0f) {  //IF
-    status.interrupt_request_joypad = data & 0x10;
-    status.interrupt_request_serial = data & 0x08;
-    status.interrupt_request_timer = data & 0x04;
-    status.interrupt_request_stat = data & 0x02;
-    status.interrupt_request_vblank = data & 0x01;
-    return;
-  }
-
-  if(addr == 0xffff) {  //IE
-    status.interrupt_enable_joypad = data & 0x10;
-    status.interrupt_enable_serial = data & 0x08;
-    status.interrupt_enable_timer = data & 0x04;
-    status.interrupt_enable_stat = data & 0x02;
-    status.interrupt_enable_vblank = data & 0x01;
-    return;
-  }
-}
-
-#endif

bsnes/gameboy/cpu/mmio/mmio.hpp

@@ -1,3 +0,0 @@
-void mmio_joyp_poll();
-uint8 mmio_read(uint16 addr);
-void mmio_write(uint16 addr, uint8 data);

bsnes/gameboy/cpu/serialization.cpp

@@ -1,56 +0,0 @@
-#ifdef CPU_CPP
-
-void CPU::serialize(serializer &s) {
-  s.array(wram);
-  s.array(hram);
-
-  s.integer(r.a.data);
-  s.integer(r.f.z);
-  s.integer(r.f.n);
-  s.integer(r.f.h);
-  s.integer(r.f.c);
-  s.integer(r.b.data);
-  s.integer(r.c.data);
-  s.integer(r.d.data);
-  s.integer(r.e.data);
-  s.integer(r.h.data);
-  s.integer(r.l.data);
-  s.integer(r.sp.data);
-  s.integer(r.pc.data);
-
-  s.integer(status.clock);
-  s.integer(status.halt);
-  s.integer(status.stop);
-  s.integer(status.ime);
-
-  s.integer(status.p15);
-  s.integer(status.p14);
-  s.integer(status.joyp);
-  s.integer(status.mlt_req);
-
-  s.integer(status.serial_data);
-  s.integer(status.serial_bits);
-
-  s.integer(status.serial_transfer);
-  s.integer(status.serial_clock);
-
-  s.integer(status.div);
-  s.integer(status.tima);
-  s.integer(status.tma);
-  s.integer(status.timer_enable);
-  s.integer(status.timer_clock);
-
-  s.integer(status.interrupt_request_joypad);
-  s.integer(status.interrupt_request_serial);
-  s.integer(status.interrupt_request_timer);
-  s.integer(status.interrupt_request_stat);
-  s.integer(status.interrupt_request_vblank);
-
-  s.integer(status.interrupt_enable_joypad);
-  s.integer(status.interrupt_enable_serial);
-  s.integer(status.interrupt_enable_timer);
-  s.integer(status.interrupt_enable_stat);
-  s.integer(status.interrupt_enable_vblank);
-}
-
-#endif

bsnes/gameboy/cpu/timing/opcode.cpp

@@ -1,18 +0,0 @@
-#ifdef CPU_CPP
-
-void CPU::op_io() {
-  add_clocks(4);
-}
-
-uint8 CPU::op_read(uint16 addr) {
-  uint8 r = bus.read(addr);
-  add_clocks(4);
-  return r;
-}
-
-void CPU::op_write(uint16 addr, uint8 data) {
-  bus.write(addr, data);
-  add_clocks(4);
-}
-
-#endif

bsnes/gameboy/cpu/timing/timing.cpp

@@ -1,82 +0,0 @@
-//4194304hz (4 * 1024 * 1024)
-
-//70224 clocks/frame
-//  456 clocks/scanline
-//  154 scanlines/frame
-
-#ifdef CPU_CPP
-
-#include "opcode.cpp"
-
-void CPU::add_clocks(unsigned clocks) {
-  system.clocks_executed += clocks;
-  scheduler.exit(Scheduler::ExitReason::StepEvent);
-
-  status.clock += clocks;
-  if(status.clock >= 4194304) {
-    status.clock -= 4194304;
-    cartridge.mbc3.second();
-  }
-
-  //4194304 / N(hz) - 1 = mask
-  if((status.clock &   15) == 0) timer_262144hz();
-  if((status.clock &   63) == 0)  timer_65536hz();
-  if((status.clock &  255) == 0)  timer_16384hz();
-  if((status.clock &  511) == 0)   timer_8192hz();
-  if((status.clock & 1023) == 0)   timer_4096hz();
-
-  lcd.clock -= clocks;
-  if(lcd.clock <= 0) co_switch(scheduler.active_thread = lcd.thread);
-
-  apu.clock -= clocks;
-  if(apu.clock <= 0) co_switch(scheduler.active_thread = apu.thread);
-}
-
-void CPU::timer_262144hz() {
-  if(status.timer_enable && status.timer_clock == 1) {
-    if(++status.tima == 0) {
-      status.tima = status.tma;
-      interrupt_raise(Interrupt::Timer);
-    }
-  }
-}
-
-void CPU::timer_65536hz() {
-  if(status.timer_enable && status.timer_clock == 2) {
-    if(++status.tima == 0) {
-      status.tima = status.tma;
-      interrupt_raise(Interrupt::Timer);
-    }
-  }
-}
-
-void CPU::timer_16384hz() {
-  if(status.timer_enable && status.timer_clock == 3) {
-    if(++status.tima == 0) {
-      status.tima = status.tma;
-      interrupt_raise(Interrupt::Timer);
-    }
-  }
-
-  status.div++;
-}
-
-void CPU::timer_8192hz() {
-  if(status.serial_transfer && status.serial_clock) {
-    if(--status.serial_bits == 0) {
-      status.serial_transfer = 0;
-      interrupt_raise(Interrupt::Serial);
-    }
-  }
-}
-
-void CPU::timer_4096hz() {
-  if(status.timer_enable && status.timer_clock == 0) {
-    if(++status.tima == 0) {
-      status.tima = status.tma;
-      interrupt_raise(Interrupt::Timer);
-    }
-  }
-}
-
-#endif