dtab (empty) → 1.0

raw patch · 13 files changed

+1637/−0 lines, 13 filesdep +arraydep +basedep +binarysetup-changed

Dependencies added: array, base, binary, bytestring, containers, data-binary-ieee754, dtab, pretty, transformers

Files

• LICENSE +674/−0
• Main.hs +51/−0
• Setup.lhs +4/−0
• dtab.cabal +55/−0
• src/Data/DTA.hs +64/−0
• src/Data/DTA/Base.hs +132/−0
• src/Data/DTA/Crypt.hs +123/−0
• src/Data/DTA/Lex.x +92/−0
• src/Data/DTA/Parse.y +69/−0
• src/Data/DTA/PrettyPrint.hs +57/−0
• src/Data/DTA/Serialize.hs +161/−0
• src/Data/DTA/Serialize/Magma.hs +103/−0
• src/Data/DTA/Serialize/RB3.hs +52/−0

@@ -0,0 +1,674 @@+                    GNU GENERAL PUBLIC LICENSE+                       Version 3, 29 June 2007++ Copyright (C) 2007 Free Software Foundation, Inc. <http://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 <http://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+<http://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+<http://www.gnu.org/philosophy/why-not-lgpl.html>.

@@ -0,0 +1,51 @@+-- | dtab application with two functions: binary <-> text, and decrypt/encrypt.+module Main where++import System.Environment (getArgs)+import qualified System.IO as IO+import Data.Version (showVersion)++import Data.DTA+import Data.DTA.Crypt+import Paths_dtab (version)++main :: IO ()+main = getArgs >>= \args ->+  case args of+    (mode : fin : fout : rest) ->+      withHandleIn fin $ \hin ->+        withHandleOut fout $ \hout -> case mode of+          "-a" -> hFromDTB hin >>= hToDTA hout+          "-b" -> hFromDTA hin >>= hToDTB hout+          "-d" -> decryptHandle newCrypt hin hout+          "-e" -> encryptHandle newCrypt key hin hout+          "-D" -> decryptHandle oldCrypt hin hout+          "-E" -> encryptHandle newCrypt key hin hout+          _ -> printUsage+          where key = case rest of+                  str : _ -> read str+                  _       -> 0x30171609+    _ -> printUsage++withHandleIn :: String -> (IO.Handle -> IO a) -> IO a+withHandleIn "-" f = f IO.stdin+withHandleIn fp  f = IO.withFile fp IO.ReadMode f++withHandleOut :: String -> (IO.Handle -> IO a) -> IO a+withHandleOut "-" f = f IO.stdout+withHandleOut fp  f = IO.withFile fp IO.WriteMode f++printUsage :: IO ()+printUsage = do+  let v = showVersion version+  mapM_ (IO.hPutStrLn IO.stderr)+    [ "dtab v"++v++", by onyxite. Built on earlier work by xorloser and deimos."+    , "Usage: dtab mode file-in file-out [encrypt-key]"+    , "Modes: -a converts DTB (binary) to DTA (text)"+    , "       -b converts DTA (text) to DTB (binary)"+    , "       -d decrypts new-style DTB"+    , "       -e encrypts new-style DTB, with optional key"+    , "       -D decrypts old-style DTB"+    , "       -E encrypts old-style DTB, with optional key"+    , "Old-style is used in early PS2 games, new-style otherwise."+    , "Use a hyphen (-) for stdin (file-in) or stdout (file-out)." ]

@@ -0,0 +1,4 @@+#!/usr/bin/env runhaskell++> import Distribution.Simple+> main = defaultMain

@@ -0,0 +1,55 @@+name:               dtab+version:            1.0+synopsis:           Harmonix (Guitar Hero, Rock Band) DTA/DTB metadata library+description:++  Read\/write\/encryption functions for the DTA\/DTB metadata format used by+  Harmonix Music Systems in their games, including the Guitar Hero, Rock Band,+  and Karaoke Revolution series. Provides both a library and executable.++license:            GPL+license-file:       LICENSE+author:             Michael Tolly+maintainer:         miketolly@gmail.com+build-type:         Simple+cabal-version:      >= 1.10+category:           Data++library+  build-depends:+    base                  >= 4.6      && < 4.8+    , bytestring          >= 0.10.4.0 && < 0.11+    , transformers        >= 0.3.0.0  && < 0.5+    , data-binary-ieee754 >= 0.4.4    && < 0.5+    , binary              >= 0.7.1.0  && < 0.8+    , array               >= 0.5.0.0  && < 0.6+    , pretty              >= 1.1.1.1  && < 1.2+    , containers          >= 0.5.5.1  && < 0.6+  exposed-modules:+    Data.DTA+    Data.DTA.Crypt+    Data.DTA.Serialize+    Data.DTA.Serialize.Magma+    Data.DTA.Serialize.RB3+  other-modules:+    Data.DTA.Base+    Data.DTA.Lex+    Data.DTA.Parse+    Data.DTA.PrettyPrint+  hs-source-dirs:     src+  ghc-options:        -Wall+  default-language:   Haskell2010++Executable dtab+  build-depends:+    base         >= 4.6      && < 4.8+    , bytestring >= 0.10.4.0 && < 0.11+    , dtab       == 1.0+  other-modules:      Paths_dtab+  Main-Is:            Main.hs+  ghc-options:        -Wall+  default-language:   Haskell2010++source-repository head+  type:               git+  location:           https://github.com/mtolly/dtab

@@ -0,0 +1,64 @@+-- | All functions that take a 'Handle' or 'FilePath' do their reading/writing+-- strictly.+module Data.DTA+( DTA(..), Tree(..), Chunk(..)+, lFromDTB, hFromDTB, fromDTB+, lToDTB, hToDTB, toDTB+, sFromDTA, hFromDTA, fromDTA+, sToDTA, hToDTA, toDTA+, renumberFrom+) where++import Control.Applicative ((<$>))+import System.IO (withFile, Handle, IOMode(ReadMode, WriteMode))++import Data.Binary (decode, encode)+import qualified Data.ByteString as B+import qualified Data.ByteString.Char8 as B8+import qualified Data.ByteString.Lazy as BL++import Data.DTA.Base+import Data.DTA.Lex+import Data.DTA.Parse+import Data.DTA.PrettyPrint++lFromDTB :: BL.ByteString -> DTA+lFromDTB = decode++lToDTB :: DTA -> BL.ByteString+lToDTB = encode++fromDTB :: FilePath -> IO DTA+fromDTB fp = withFile fp ReadMode hFromDTB++hFromDTB :: Handle -> IO DTA+hFromDTB h = decode . strictToLazy <$> B.hGetContents h+  where strictToLazy b = BL.fromChunks [b]++toDTB :: FilePath -> DTA -> IO ()+toDTB fp dta = withFile fp WriteMode $ \h -> hToDTB h dta++hToDTB :: Handle -> DTA -> IO ()+hToDTB h dta = B.hPutStr h $ lazyToStrict $ encode dta+  where lazyToStrict = B.concat . BL.toChunks++sFromDTA :: String -> DTA+sFromDTA = parse . scan++bFromDTA :: B8.ByteString -> DTA+bFromDTA = sFromDTA . B8.unpack++hFromDTA :: Handle -> IO DTA+hFromDTA h = bFromDTA <$> B8.hGetContents h++fromDTA :: FilePath -> IO DTA+fromDTA fp = withFile fp ReadMode hFromDTA++bToDTA :: DTA -> B8.ByteString+bToDTA = B8.pack . sToDTA++hToDTA :: Handle -> DTA -> IO ()+hToDTA h = B8.hPutStr h . bToDTA++toDTA :: FilePath -> DTA -> IO ()+toDTA fp dta = withFile fp WriteMode $ \h -> hToDTA h dta

@@ -0,0 +1,132 @@+{-# LANGUAGE DeriveDataTypeable #-}+module Data.DTA.Base+( DTA(..), Tree(..), Chunk(..)+, renumberFrom+) where++import Control.Applicative ((<$>), liftA2)+import Control.Monad (replicateM)+import qualified Data.ByteString as B+import Data.Data (Data)+import Data.Int (Int32)+import Data.Typeable (Typeable)+import Data.Word (Word32, Word8)++import qualified Control.Monad.Trans.State as S+import Data.Binary (Binary(..), Put, Get)+import Data.Binary.Get (getWord32le, getWord16le, getByteString, skip)+import Data.Binary.IEEE754 (putFloat32le, getFloat32le)+import Data.Binary.Put (putWord32le, putWord16le, putByteString)++--+-- Type definitions+--++-- | A top-level file.+data DTA = DTA { byteZero :: Word8, topTree :: Tree }+  deriving (Eq, Ord, Show, Read, Typeable, Data)++-- | A list of chunks, for either the top-level tree or a subtree.+data Tree = Tree { nodeID :: Word32, treeChunks :: [Chunk] }+  deriving (Eq, Ord, Show, Read, Typeable, Data)++-- | A data value, which may be a subtree. The constructors are ordered by their+-- chunk identification tag in the binary format.+data Chunk+  = Int Int32+  | Float Float+  | Var B.ByteString+  | Key B.ByteString+  | Unhandled+  | IfDef B.ByteString+  | Else+  | EndIf+  | Parens Tree+  | Braces Tree+  | String B.ByteString+  | Brackets Tree+  | Define B.ByteString+  | Include B.ByteString+  | Merge B.ByteString+  | IfNDef B.ByteString+  deriving (Eq, Ord, Show, Read, Typeable, Data)++--+-- Binary (DTB) instances+--++-- Single byte, then a tree.+instance Binary DTA where+  put (DTA b t) = put b >> put t+  get = liftA2 DTA get get++-- 2-byte length, 4-byte node ID, then each element in sequence.+instance Binary Tree where+  put (Tree nid chks) = do+    putWord16le $ fromIntegral $ length chks+    putWord32le nid+    mapM_ put chks+  get = do+    len <- getWord16le+    liftA2 Tree getWord32le $ replicateM (fromIntegral len) get++-- 4-byte chunk type ID, then at least 4 bytes of chunk data.+instance Binary Chunk where+  put c = case c of+    Int i       -> putWord32le 0x0  >> putWord32le (fromIntegral i)+    Float f     -> putWord32le 0x1  >> putFloat32le f+    Var b       -> putWord32le 0x2  >> putLenStr b+    Key b       -> putWord32le 0x5  >> putLenStr b+    Unhandled   -> putWord32le 0x6  >> putWord32le 0+    IfDef b     -> putWord32le 0x7  >> putLenStr b+    Else        -> putWord32le 0x8  >> putWord32le 0+    EndIf       -> putWord32le 0x9  >> putWord32le 0+    Parens tr   -> putWord32le 0x10 >> put tr+    Braces tr   -> putWord32le 0x11 >> put tr+    String b    -> putWord32le 0x12 >> putLenStr b+    Brackets tr -> putWord32le 0x13 >> put tr+    Define b    -> putWord32le 0x20 >> putLenStr b+    Include b   -> putWord32le 0x21 >> putLenStr b+    Merge b     -> putWord32le 0x22 >> putLenStr b+    IfNDef b    -> putWord32le 0x23 >> putLenStr b+  get = getWord32le >>= \cid -> case cid of+    0x0  -> Int . fromIntegral <$> getWord32le+    0x1  -> Float <$> getFloat32le+    0x2  -> Var <$> getLenStr+    0x5  -> Key <$> getLenStr+    0x6  -> skip 4 >> return Unhandled+    0x7  -> IfDef <$> getLenStr+    0x8  -> skip 4 >> return Else+    0x9  -> skip 4 >> return EndIf+    0x10 -> Parens <$> get+    0x11 -> Braces <$> get+    0x12 -> String <$> getLenStr+    0x13 -> Brackets <$> get+    0x20 -> Define <$> getLenStr+    0x21 -> Include <$> getLenStr+    0x22 -> Merge <$> getLenStr+    0x23 -> IfNDef <$> getLenStr+    _    -> fail $ "Unidentified DTB chunk with ID " ++ show cid++-- | DTB string format: 4-byte length, then a string in latin-1.+putLenStr :: B.ByteString -> Put+putLenStr b = putWord32le (fromIntegral $ B.length b) >> putByteString b++-- | DTB string format: 4-byte length, then a string in latin-1.+getLenStr :: Get B.ByteString+getLenStr = getWord32le >>= getByteString . fromIntegral++-- | Assign new sequential node IDs to each tree in a DTA, starting with the+-- top-level tree.+renumberFrom :: Word32 -> DTA -> DTA+renumberFrom w (DTA b t) = DTA b $ S.evalState (renumberTree t) w where+  renumberTree :: Tree -> S.State Word32 Tree+  renumberTree (Tree _ sub) = liftA2 Tree S.get $+    S.modify (+ 1) >> mapM renumberChunk sub+  renumberChunk :: Chunk -> S.State Word32 Chunk+  renumberChunk c = case c of+    Parens tr -> Parens <$> renumberTree tr+    Braces tr -> Braces <$> renumberTree tr+    Brackets tr -> Brackets <$> renumberTree tr+    _ -> return c+  -- alternately, with uniplate: renumberChunk = descendBiM renumberTree

@@ -0,0 +1,123 @@+-- | The encryption scheme used for DTB files found on game discs.+module Data.DTA.Crypt+( oldCrypt, newCrypt+, decrypt, encrypt+, decryptFile, encryptFile+, decryptHandle, encryptHandle+, Key, Crypt+) where++import Control.Monad (forM_, liftM2, liftM3)+import Control.Monad.ST.Lazy (ST, runST)+import Data.Array.ST (STArray, newArray, readArray, writeArray)+import Data.Bits (shiftR, (.&.), (.|.), xor)+import Data.STRef.Lazy (STRef, newSTRef, readSTRef, writeSTRef)+import Data.Word (Word8, Word32)+import System.IO (Handle)++import Data.Binary.Get (runGet, getWord32le, getRemainingLazyByteString)+import Data.Binary.Put (runPut, putWord32le, putLazyByteString)+import qualified Data.ByteString.Lazy as BL++-- | An encryption/decryption key.+type Key = Word32++-- | Using a key to generate an infinite stream of crypt bytes.+type Crypt = Key -> [Word8]++{- |+The way both the new and old DTB encryption algorithms work is by using the key+to generate a stream of bytes. Each of these bytes is then XOR'd with the+corresponding bytes in the source file. The same algorithm is both the+decryption and encryption; this is because @(A xor B) xor B == A@.+-}+crypt :: Crypt -> Key -> BL.ByteString -> BL.ByteString+crypt cry key = BL.pack . zipWith xor (cry key) . BL.unpack++-- | Take the first four bytes of the string as the key, and decrypt the rest of+-- the file.+decrypt :: Crypt -> BL.ByteString -> BL.ByteString+decrypt cry = runGet $ liftM2 (crypt cry) getWord32le getRemainingLazyByteString++-- | Encrypt a string with a key, and append the key to the encrypted string.+encrypt :: Crypt -> Key -> BL.ByteString -> BL.ByteString+encrypt cry key input+  = runPut $ putWord32le key >> putLazyByteString (crypt cry key input)++-- | Decrypt an encrypted DTB file using the given crypt method.+decryptFile :: Crypt -> FilePath -> FilePath -> IO ()+decryptFile cry fi fo = BL.readFile fi >>= BL.writeFile fo . decrypt cry++-- | Encrypt an unencrypted DTB file using the given crypt method and key.+encryptFile :: Crypt -> Key -> FilePath -> FilePath -> IO ()+encryptFile cry key fi fo = BL.readFile fi >>= BL.writeFile fo . encrypt cry key++-- | Decrypt an encrypted DTB file across two handles.+decryptHandle :: Crypt -> Handle -> Handle -> IO ()+decryptHandle cry hi ho = BL.hGetContents hi >>= BL.hPutStr ho . decrypt cry++-- | Encrypt an unencrypted DTB files across two handles.+encryptHandle :: Crypt -> Key -> Handle -> Handle -> IO ()+encryptHandle cry key hi ho = BL.hGetContents hi >>= BL.hPutStr ho . encrypt cry key++-- New (Rock Band) encryption++{-+From xorloser's dtbcrypt:+unsigned int dtb_xor_x360(unsigned int data)+{+  int val1 = (data / 0x1F31D) * 0xB14;+  int val2 = (data - ((data / 0x1F31D) * 0x1F31D)) * 0x41A7;+  val2 = val2 - val1;+  if(val2 <= 0)+    val2 += 0x7FFFFFFF;+  return val2;+}+-}++-- | The key iteration function for new DTB encryption/decryption.+dtbXor360 :: Word32 -> Word32+dtbXor360 d = let+  q = quot d 0x1F31D+  v = (d - (q * 0x1F31D)) * 0x41A7 - q * 0xB14 in+    if v > 0x7FFFFFFF then v + 0x7FFFFFFF else v++-- | The lazy infinite list of crypt bytes for new-style encryption.+newCrypt :: Crypt+newCrypt key = fmap fromIntegral $ tail $ iterate dtbXor360 key++-- Old (PS2 Guitar Hero) encryption+-- This algorithm uses a large table to produce the XOR bytes, which is+-- implemented using an STArray in the lazy ST monad.++data CryptTable s = CryptTable+  { idx1  :: STRef s Word8+  , idx2  :: STRef s Word8+  , table :: STArray s Word8 Word32 }++cryptTable :: Key -> ST s (CryptTable s)+cryptTable key = do+  v1ref <- newSTRef key+  tbl <- newArray (0, 0xF8) 0+  forM_ [0..0xF8] $ \i -> do+    v1 <- readSTRef v1ref+    let v2 = (v1 * 0x41C64E6D) + 0x3039+    let v1' = (v2 * 0x41C64E6D) + 0x3039+    writeSTRef v1ref v1'+    writeArray tbl i $ (v1' .&. 0x7FFF0000) .|. (v2 `shiftR` 16)+  liftM3 CryptTable (newSTRef 0) (newSTRef 0x67) (return tbl)++oldNext :: CryptTable s -> ST s Word8+oldNext (CryptTable { idx1 = i1ref, idx2 = i2ref, table = tbl }) = do+  i1 <- readSTRef i1ref+  i2 <- readSTRef i2ref+  next <- liftM2 xor (readArray tbl i1) (readArray tbl i2)+  writeArray tbl i1 next+  writeSTRef i1ref $ if i1 == 0xF8 then 0 else i1 + 1+  writeSTRef i2ref $ if i2 == 0xF8 then 0 else i2 + 1+  return $ fromIntegral next+  -- The fromIntegral chops each Word32 down to the least significant byte.++-- | The lazy infinite list of crypt bytes for old-style encryption.+oldCrypt :: Crypt+oldCrypt key = runST $ cryptTable key >>= sequence . repeat . oldNext

@@ -0,0 +1,92 @@+{+-- | Generated lexer for text @.dta@ files.+{-# OPTIONS_GHC -w #-}+module Data.DTA.Lex (scan, Token(..), AlexPosn(..)) where++import qualified Data.ByteString.Char8 as B8+import Data.Int (Int32)+}++%wrapper "posn"++$digit = 0-9+$alpha = [a-zA-Z]++tokens :-++-- Whitespace and line comments.+$white+ ;+\; [^\n]* ;++-- Numbers. Longest match rule means N.N is float, not int.+\-? $digit+ { \pn str -> (pn, Int $ read str) }+\-? $digit+ (\. $digit+)? (e \-? $digit+)? { \pn str -> (pn, Float $ read str) }++-- Variable names.+\$ ($alpha | $digit | _)+ { \pn str -> (pn, Var $ B8.pack $ tail str) }++-- This reserved word needs to come before the general keyword rule.+"kDataUnhandled" { \pn _ -> (pn, Unhandled) }+-- Raw keywords. Note: these can start with digits, like "3sand7s", as long as+-- they also have letters in them.+($alpha | $digit | _ | \/ | \.)+ { \pn str -> (pn, Key $ B8.pack str) }+-- Quoted keywords.+' ([^'] | \\')* ' { \pn str -> (pn, Key $ B8.pack $ getKeyword str) }++-- Quoted strings.+\" ([^\"] | \\\")* \" { \pn str -> (pn, String $ B8.pack $ read str) }++-- Preprocessor commands.+\#ifdef { \pn _ -> (pn, IfDef) }+\#else { \pn _ -> (pn, Else) }+\#endif { \pn _ -> (pn, EndIf) }+\#define { \pn _ -> (pn, Define) }+\#include { \pn _ -> (pn, Include) }+\#merge { \pn _ -> (pn, Merge) }+\#ifndef { \pn _ -> (pn, IfNDef) }++-- Subtrees.+\( { \pn _ -> (pn, LParen) }+\) { \pn _ -> (pn, RParen) }+\{ { \pn _ -> (pn, LBrace) }+\} { \pn _ -> (pn, RBrace) }+\[ { \pn _ -> (pn, LBracket) }+\] { \pn _ -> (pn, RBracket) }++{++data Token+  = Int Int32+  | Float Float+  | Var B8.ByteString+  | Key B8.ByteString+  | Unhandled+  | IfDef+  | Else+  | EndIf+  | LParen+  | RParen+  | LBrace+  | RBrace+  | String B8.ByteString+  | LBracket+  | RBracket+  | Define+  | Include+  | Merge+  | IfNDef+  deriving (Eq, Ord, Show, Read)++-- | Reads a single-quoted string, by converting it to a double-quoted one.+getKeyword :: String -> String+getKeyword = read . go where+  go ('\'':xs) = '"' : go xs        -- string begin/end -> double-quote+  go ('"':xs) = '\\' : '"' : go xs  -- double-quote gets escaped+  go ('\\':x:xs) = '\\' : x : go xs -- any escaped char can remain escaped+  go (x:xs) = x : go xs             -- all other chars are unchanged+  go [] = []++scan :: String -> [(AlexPosn, Token)]+scan = alexScanTokens++}

@@ -0,0 +1,69 @@+{+-- | Generated parser for text @.dta@ files.+module Data.DTA.Parse (parse) where++import Data.DTA.Base+import qualified Data.DTA.Lex as L+}++%name parse+%tokentype { (L.AlexPosn, L.Token) }+%error { parseError }++%token+  int { (_, L.Int $$) }+  float { (_, L.Float $$) }+  var { (_, L.Var $$) }+  key { (_, L.Key $$) }+  unhandled { (_, L.Unhandled) }+  ifdef { (_, L.IfDef) }+  else { (_, L.Else) }+  endif { (_, L.EndIf) }+  '(' { (_, L.LParen) }+  ')' { (_, L.RParen) }+  '{' { (_, L.LBrace) }+  '}' { (_, L.RBrace) }+  string { (_, L.String $$) }+  '[' { (_, L.LBracket) }+  ']' { (_, L.RBracket) }+  define { (_, L.Define) }+  include { (_, L.Include) }+  merge { (_, L.Merge) }+  ifndef { (_, L.IfNDef) }++%%++File : Tree { DTA 0 $1 }++Tree : Chunks { Tree 0 $1 }++Chunks : Chunk Chunks { $1 : $2 }+       | { [] }++Chunk : int { Int $1 }+      | float { Float $1 }+      | var { Var $1 }+      | key { Key $1 }+      | unhandled { Unhandled }+      | ifdef key { IfDef $2 }+      | else { Else }+      | endif { EndIf }+      | '(' Tree ')' { Parens $2 }+      | '{' Tree '}' { Braces $2 }+      | string { String $1 }+      | '[' Tree ']' { Brackets $2 }+      | define key { Define $2 }+      | include key { Include $2 }+      | merge key { Merge $2 }+      | ifndef key { IfNDef $2 }++{++-- | If instead of this error, "Internal Happy error" is sometimes printed, make+-- sure you are using Happy 1.18.7 or later.+parseError :: [(L.AlexPosn, L.Token)] -> a+parseError [] = error "Parse error at EOF"+parseError ((L.AlexPn _ ln col, tok) : _) = error $+  "Parse error at " ++ show ln ++ ":" ++ show col ++ ", token " ++ show tok++}

@@ -0,0 +1,57 @@+-- | Pretty-print text (DTA) files with the HughesPJ library.+module Data.DTA.PrettyPrint (sToDTA) where++import qualified Data.ByteString.Char8 as B8+import qualified Text.PrettyPrint.HughesPJ as PP++import Data.DTA.Base++ppChunk :: Chunk -> PP.Doc+ppChunk c = case c of+  Int i -> PP.text $ show i+  Float f -> PP.text $ show f+  Var t -> PP.hcat [PP.char '$', ppText t]+  Key t -> ppKey $ B8.unpack t+  Unhandled -> PP.text "kDataUnhandled"+  IfDef t -> PP.hsep [PP.text "#ifdef", ppText t]+  Else -> PP.text "#else"+  EndIf -> PP.text "#endif"+  Parens tr -> PP.parens $ ppTree tr+  Braces tr -> PP.braces $ ppTree tr+  String t -> PP.text $ show $ B8.unpack t+  Brackets tr -> PP.brackets $ ppTree tr+  Define t -> PP.hsep [PP.text "#define", ppText t]+  Include t -> PP.hsep [PP.text "#include", ppText t]+  Merge t -> PP.hsep [PP.text "#merge", ppText t]+  IfNDef t -> PP.hsep [PP.text "#ifndef", ppText t]+  where ppText = PP.text . B8.unpack++-- | Automatically chooses between horizontal and vertical arrangements,+-- depending on what kind of chunks are in the tree.+ppTree :: Tree -> PP.Doc+ppTree (Tree _ chks)+  | all simpleChunk chks = PP.hsep $ map ppChunk chks+  | otherwise            = PP.vcat $ map ppChunk chks+  where simpleChunk c = case c of+          Int _ -> True+          Float _ -> True+          Var _ -> True+          Key _ -> True+          Unhandled -> True+          _ -> False++-- | Produces a single-quoted string literal.+ppKey :: String -> PP.Doc+ppKey = PP.text . f . show where+  -- simply convert a double-quoted string to single-quoted string+  f "" = ""+  f ('"':xs) = '\'' : f xs+  f ('\'':xs) = '\\' : '\'' : f xs+  f ('\\':x:xs) = '\\' : x : f xs+  f (x:xs) = x : f xs++ppDTA :: DTA -> PP.Doc+ppDTA = PP.vcat . map ppChunk . treeChunks . topTree++sToDTA :: DTA -> String+sToDTA = PP.render . ppDTA

@@ -0,0 +1,161 @@+{-# LANGUAGE GeneralizedNewtypeDeriving, DeriveTraversable, OverloadedStrings #-}+module Data.DTA.Serialize where++import Data.DTA.Base+import qualified Data.ByteString.Char8 as B8+import Control.Applicative (liftA2)+import qualified Data.Map as Map+import qualified Data.Foldable as F+import qualified Data.Traversable as T++unserialize :: (FromChunks a) => DTA -> Either String a+unserialize (DTA _ (Tree _ cs)) = fromChunks cs++serialize :: (ToChunks a) => a -> DTA+serialize = DTA 0 . Tree 0 . toChunks++-- | Values which are stored as one or many chunks. Scalar types become one+-- chunk, while lists and record types can make more.+class ToChunks a where+  toChunks :: a -> [Chunk]++-- | Values which can be read from one or many chunks.+class FromChunks a where+  fromChunks :: [Chunk] -> Either String a++instance ToChunks DTA where+  toChunks = treeChunks . topTree++instance FromChunks DTA where+  fromChunks = Right . DTA 0 . Tree 0++instance ToChunks Chunk where+  toChunks x = [x]++instance FromChunks Chunk where+  fromChunks [x] = Right x+  fromChunks cs = Left $ "Expected 1 chunk, got: " ++ show cs++-- | A key-value structure which is stored as a sequence of @(tag rest...)@+-- chunks.+newtype Dict a = Dict { fromDict :: Map.Map B8.ByteString a }+  deriving (Eq, Ord, Show, Read, Functor, F.Foldable, T.Traversable)++instance (ToChunks a) => ToChunks (Dict a) where+  toChunks = makeDict . fmap toChunks++instance (FromChunks a) => FromChunks (Dict a) where+  fromChunks cs = getDict cs >>= T.mapM fromChunks++getDict :: [Chunk] -> Either String (Dict [Chunk])+getDict cs = let+  toPair c = case c of+    Parens (Tree _ (Key k : rest)) -> Right (k, rest)+    _ -> Left $ "Expected (tag rest...), got: " ++ show c+  in fmap (Dict . Map.fromList) $ mapM toPair cs++makeDict :: Dict [Chunk] -> [Chunk]+makeDict (Dict m) =+  [ Parens $ Tree 0 $ Key k : v | (k, v) <- Map.toList m ]++dictLookup :: B8.ByteString -> Dict v -> Either String v+dictLookup k (Dict m) = case Map.lookup k m of+  Nothing -> Left $ "Couldn't find key " ++ show k+  Just v  -> Right v++-- | A value which is DTA-stored as a parenthesized subtree around the normal+-- representation.+newtype InParens a = InParens { fromInParens :: a }+  deriving (Eq, Ord, Show, Read)++instance (ToChunks a) => ToChunks (InParens a) where+  toChunks (InParens xs) = [Parens $ Tree 0 $ toChunks xs]++instance (FromChunks a) => FromChunks (InParens a) where+  fromChunks [Parens (Tree _ cs)] = fmap InParens $ fromChunks cs+  fromChunks cs = Left $ "Couldn't read as InParens: " ++ show cs++-- | An integer 0 or 1.+instance ToChunks Bool where+  toChunks True = [Int 1]+  toChunks False = [Int 0]++-- | An integer 0 or 1, or keyword TRUE or FALSE.+instance FromChunks Bool where+  fromChunks [Int 1      ] = Right True+  fromChunks [Int 0      ] = Right False+  fromChunks [Key "TRUE" ] = Right True+  fromChunks [Key "FALSE"] = Right False+  fromChunks cs = Left $ "Couldn't read as Bool: " ++ show cs++instance ToChunks Integer where+  toChunks i = [Int $ fromIntegral i]++instance FromChunks Integer where+  fromChunks [Int i] = Right $ fromIntegral i+  fromChunks cs = Left $ "Couldn't read as Integer: " ++ show cs++instance ToChunks Float where+  toChunks f = [Float f]++instance FromChunks Float where+  fromChunks [Float f] = Right f+  fromChunks cs = Left $ "Couldn't read as Float: " ++ show cs++-- | A String, not a 'Key'.+instance ToChunks B8.ByteString where+  toChunks bs = [String bs]++-- | A String, not a 'Key'.+instance FromChunks B8.ByteString where+  fromChunks [String bs] = Right bs+  fromChunks cs = Left $ "Couldn't read as ByteString: " ++ show cs++-- | Stored as two chunks. Each subtype should be a single chunk.+instance (ToChunks a, ToChunks b) => ToChunks (a, b) where+  toChunks (x, y) = toChunks x ++ toChunks y++-- | Stored as two chunks. Each subtype should be a single chunk.+instance (FromChunks a, FromChunks b) => FromChunks (a, b) where+  fromChunks [x, y] = liftA2 (,) (fromChunks [x]) (fromChunks [y])+  fromChunks cs = Left $ "Couldn't read as pair: " ++ show cs++-- | Represents 'Nothing' with an empty chunk list.+instance (ToChunks a) => ToChunks (Maybe a) where+  toChunks Nothing = []+  toChunks (Just x) = toChunks x++-- | Represents 'Nothing' with an empty chunk list.+instance (FromChunks a) => FromChunks (Maybe a) where+  fromChunks [] = Right Nothing+  fromChunks cs = fmap Just $ fromChunks cs++-- | Each value is stored as one chunk in the list.+instance (ToChunks a) => ToChunks [a] where+  toChunks = concatMap toChunks++-- | Each value is stored as one chunk in the list.+instance (FromChunks a) => FromChunks [a] where+  fromChunks = mapM $ \x -> fromChunks [x]++-- | Stored as a 'Key', unlike the 'ByteString' instance which is a String.+newtype Keyword = Keyword { fromKeyword :: B8.ByteString }+  deriving (Eq, Ord, Show, Read)++instance ToChunks Keyword where+  toChunks (Keyword k) = [Key k]++instance FromChunks Keyword where+  fromChunks [Key k] = Right $ Keyword k+  fromChunks cs = Left $ "Couldn't read as Keyword: " ++ show cs++-- | Uses whichever 'toChunks' is applicable. Does not tag which type is used.+instance (ToChunks a, ToChunks b) => ToChunks (Either a b) where+  toChunks = either toChunks toChunks++-- | First tries to read the 'Left' type, then 'Right' if that fails.+instance (FromChunks a, FromChunks b) => FromChunks (Either a b) where+  fromChunks cs = case (fromChunks cs, fromChunks cs) of+    (Right l, _      ) -> Right $ Left l+    (_      , Right r) -> Right $ Right r+    (Left  _, Left  _) -> Left $ "Couldn't read as Either: " ++ show cs

@@ -0,0 +1,103 @@+{-# LANGUAGE OverloadedStrings #-}+module Data.DTA.Serialize.Magma where++import Control.Applicative ((<$>), (<*>))+import Control.Monad ((>=>))++import qualified Data.ByteString.Char8 as B8+import qualified Data.Map as Map++import Data.DTA+import Data.DTA.Serialize++++data RBProj = RBProj { project :: Project } deriving (Eq, Ord, Read, Show)++instance ToChunks RBProj where { toChunks x = makeDict $ Dict $ Map.fromList $ [("project", toChunks $ project x)] }++instance FromChunks RBProj where { fromChunks = getDict >=> \d -> RBProj <$> (dictLookup "project" d >>= fromChunks) }++data Project = Project { toolVersion :: B8.ByteString, projectVersion :: Integer, metadata :: Metadata, gamedata :: Gamedata, languages :: Languages, destinationFile :: B8.ByteString, midi :: Midi, dryVox :: DryVox, albumArt :: AlbumArt, tracks :: Tracks } deriving (Eq, Ord, Read, Show)++instance ToChunks Project where { toChunks x = makeDict $ Dict $ Map.fromList $ [("tool_version", toChunks $ toolVersion x)] ++ [("project_version", toChunks $ projectVersion x)] ++ [("metadata", toChunks $ metadata x)] ++ [("gamedata", toChunks $ gamedata x)] ++ [("languages", toChunks $ languages x)] ++ [("destination_file", toChunks $ destinationFile x)] ++ [("midi", toChunks $ midi x)] ++ [("dry_vox", toChunks $ dryVox x)] ++ [("album_art", toChunks $ albumArt x)] ++ [("tracks", toChunks $ tracks x)] }++instance FromChunks Project where { fromChunks = getDict >=> \d -> Project <$> (dictLookup "tool_version" d >>= fromChunks) <*> (dictLookup "project_version" d >>= fromChunks) <*> (dictLookup "metadata" d >>= fromChunks) <*> (dictLookup "gamedata" d >>= fromChunks) <*> (dictLookup "languages" d >>= fromChunks) <*> (dictLookup "destination_file" d >>= fromChunks) <*> (dictLookup "midi" d >>= fromChunks) <*> (dictLookup "dry_vox" d >>= fromChunks) <*> (dictLookup "album_art" d >>= fromChunks) <*> (dictLookup "tracks" d >>= fromChunks) }++data AlbumArt = AlbumArt { albumArtFile :: B8.ByteString } deriving (Eq, Ord, Read, Show)++instance ToChunks AlbumArt where { toChunks x = makeDict $ Dict $ Map.fromList $ [("file", toChunks $ albumArtFile x)] }++instance FromChunks AlbumArt where { fromChunks = getDict >=> \d -> AlbumArt <$> (dictLookup "file" d >>= fromChunks) }++data Languages = Languages { english :: Bool, french :: Bool, italian :: Bool, spanish :: Bool, german :: Bool, japanese :: Bool } deriving (Eq, Ord, Read, Show)++instance ToChunks Languages where { toChunks x = makeDict $ Dict $ Map.fromList $ [("english", toChunks $ english x)] ++ [("french", toChunks $ french x)] ++ [("italian", toChunks $ italian x)] ++ [("spanish", toChunks $ spanish x)] ++ [("german", toChunks $ german x)] ++ [("japanese", toChunks $ japanese x)] }++instance FromChunks Languages where { fromChunks = getDict >=> \d -> Languages <$> (dictLookup "english" d >>= fromChunks) <*> (dictLookup "french" d >>= fromChunks) <*> (dictLookup "italian" d >>= fromChunks) <*> (dictLookup "spanish" d >>= fromChunks) <*> (dictLookup "german" d >>= fromChunks) <*> (dictLookup "japanese" d >>= fromChunks) }++data Gamedata = Gamedata { previewStartMs :: Integer, rankGuitar :: Integer {- ^ 1 is no dots, 7 is devils. -}, rankBass :: Integer, rankDrum :: Integer, rankVocals :: Integer, rankKeys :: Integer, rankProKeys :: Integer, rankBand :: Integer, vocalScrollSpeed :: Integer {- ^ Normal = 2300. Fast = 2000. -}, animTempo :: Integer {- ^ Slow (under 100bpm) = 16. Medium (100-160bpm) = 32. Fast (over 160bpm) = 64. -}, vocalGender :: Gender, vocalPercussion :: Percussion, vocalParts :: Integer, guidePitchVolume :: Float } deriving (Eq, Ord, Read, Show)++instance ToChunks Gamedata where { toChunks x = makeDict $ Dict $ Map.fromList $ [("preview_start_ms", toChunks $ previewStartMs x)] ++ [("rank_guitar", toChunks $ rankGuitar x)] ++ [("rank_bass", toChunks $ rankBass x)] ++ [("rank_drum", toChunks $ rankDrum x)] ++ [("rank_vocals", toChunks $ rankVocals x)] ++ [("rank_keys", toChunks $ rankKeys x)] ++ [("rank_pro_keys", toChunks $ rankProKeys x)] ++ [("rank_band", toChunks $ rankBand x)] ++ [("vocal_scroll_speed", toChunks $ vocalScrollSpeed x)] ++ [("anim_tempo", toChunks $ animTempo x)] ++ [("vocal_gender", toChunks $ vocalGender x)] ++ [("vocal_percussion", toChunks $ vocalPercussion x)] ++ [("vocal_parts", toChunks $ vocalParts x)] ++ [("guide_pitch_volume", toChunks $ guidePitchVolume x)] }++instance FromChunks Gamedata where { fromChunks = getDict >=> \d -> Gamedata <$> (dictLookup "preview_start_ms" d >>= fromChunks) <*> (dictLookup "rank_guitar" d >>= fromChunks) <*> (dictLookup "rank_bass" d >>= fromChunks) <*> (dictLookup "rank_drum" d >>= fromChunks) <*> (dictLookup "rank_vocals" d >>= fromChunks) <*> (dictLookup "rank_keys" d >>= fromChunks) <*> (dictLookup "rank_pro_keys" d >>= fromChunks) <*> (dictLookup "rank_band" d >>= fromChunks) <*> (dictLookup "vocal_scroll_speed" d >>= fromChunks) <*> (dictLookup "anim_tempo" d >>= fromChunks) <*> (dictLookup "vocal_gender" d >>= fromChunks) <*> (dictLookup "vocal_percussion" d >>= fromChunks) <*> (dictLookup "vocal_parts" d >>= fromChunks) <*> (dictLookup "guide_pitch_volume" d >>= fromChunks) }++data Gender = Male | Female deriving (Eq, Ord, Read, Show, Enum, Bounded)++instance ToChunks Gender where { toChunks Male = [Key "male"]; toChunks Female = [Key "female"] }++instance FromChunks Gender where { fromChunks [Key "male"] = Right Male; fromChunks [Key "female"] = Right Female; fromChunks cs = Left $ "Couldn't read as Gender: " ++ show cs }++data Percussion = Tambourine | Cowbell | Handclap deriving (Eq, Ord, Read, Show, Enum, Bounded)++instance ToChunks Percussion where { toChunks Tambourine = [Key "tambourine"]; toChunks Cowbell = [Key "cowbell"]; toChunks Handclap = [Key "handclap"] }++instance FromChunks Percussion where { fromChunks [Key "tambourine"] = Right Tambourine; fromChunks [Key "cowbell"] = Right Cowbell; fromChunks [Key "handclap"] = Right Handclap; fromChunks cs = Left $ "Couldn't read as Percussion: " ++ show cs }++data Metadata = Metadata { songName :: B8.ByteString, artistName :: B8.ByteString, genre :: Keyword, subGenre :: Keyword, yearReleased :: Integer, albumName :: B8.ByteString, author :: B8.ByteString, releaseLabel :: B8.ByteString, country :: Keyword, price :: Integer, trackNumber :: Integer, hasAlbum :: Bool } deriving (Eq, Ord, Read, Show)++instance ToChunks Metadata where { toChunks x = makeDict $ Dict $ Map.fromList $ [("song_name", toChunks $ songName x)] ++ [("artist_name", toChunks $ artistName x)] ++ [("genre", toChunks $ genre x)] ++ [("sub_genre", toChunks $ subGenre x)] ++ [("year_released", toChunks $ yearReleased x)] ++ [("album_name", toChunks $ albumName x)] ++ [("author", toChunks $ author x)] ++ [("release_label", toChunks $ releaseLabel x)] ++ [("country", toChunks $ country x)] ++ [("price", toChunks $ price x)] ++ [("track_number", toChunks $ trackNumber x)] ++ [("has_album", toChunks $ hasAlbum x)] }++instance FromChunks Metadata where { fromChunks = getDict >=> \d -> Metadata <$> (dictLookup "song_name" d >>= fromChunks) <*> (dictLookup "artist_name" d >>= fromChunks) <*> (dictLookup "genre" d >>= fromChunks) <*> (dictLookup "sub_genre" d >>= fromChunks) <*> (dictLookup "year_released" d >>= fromChunks) <*> (dictLookup "album_name" d >>= fromChunks) <*> (dictLookup "author" d >>= fromChunks) <*> (dictLookup "release_label" d >>= fromChunks) <*> (dictLookup "country" d >>= fromChunks) <*> (dictLookup "price" d >>= fromChunks) <*> (dictLookup "track_number" d >>= fromChunks) <*> (dictLookup "has_album" d >>= fromChunks) }++data Midi = Midi { midiFile :: B8.ByteString, autogenTheme :: Either AutogenTheme B8.ByteString } deriving (Eq, Ord, Read, Show)++instance ToChunks Midi where { toChunks x = makeDict $ Dict $ Map.fromList $ [("file", toChunks $ midiFile x)] ++ [("autogen_theme", toChunks $ autogenTheme x)] }++instance FromChunks Midi where { fromChunks = getDict >=> \d -> Midi <$> (dictLookup "file" d >>= fromChunks) <*> (dictLookup "autogen_theme" d >>= fromChunks) }++data AutogenTheme = DefaultTheme | AggressiveMetal | ArenaRock | DarkHeavyRock | DustyVintage | EdgyProgRock | FeelGoodPopRock | GaragePunkRock | PsychJamRock | SlowJam | SynthPop deriving (Eq, Ord, Read, Show, Enum, Bounded)++instance ToChunks AutogenTheme where { toChunks DefaultTheme = [String ""]; toChunks AggressiveMetal = [String "AggressiveMetal.rbtheme"]; toChunks ArenaRock = [String "ArenaRock.rbtheme"]; toChunks DarkHeavyRock = [String "DarkHeavyRock.rbtheme"]; toChunks DustyVintage = [String "DustyVintage.rbtheme"]; toChunks EdgyProgRock = [String "EdgyProgRock.rbtheme"]; toChunks FeelGoodPopRock = [String "FeelGoodPopRock.rbtheme"]; toChunks GaragePunkRock = [String "GaragePunkRock.rbtheme"]; toChunks PsychJamRock = [String "PsychJamRock.rbtheme"]; toChunks SlowJam = [String "SlowJam.rbtheme"]; toChunks SynthPop = [String "SynthPop.rbtheme"] }++instance FromChunks AutogenTheme where { fromChunks [String ""] = Right DefaultTheme; fromChunks [String "AggressiveMetal.rbtheme"] = Right AggressiveMetal; fromChunks [String "ArenaRock.rbtheme"] = Right ArenaRock; fromChunks [String "DarkHeavyRock.rbtheme"] = Right DarkHeavyRock; fromChunks [String "DustyVintage.rbtheme"] = Right DustyVintage; fromChunks [String "EdgyProgRock.rbtheme"] = Right EdgyProgRock; fromChunks [String "FeelGoodPopRock.rbtheme"] = Right FeelGoodPopRock; fromChunks [String "GaragePunkRock.rbtheme"] = Right GaragePunkRock; fromChunks [String "PsychJamRock.rbtheme"] = Right PsychJamRock; fromChunks [String "SlowJam.rbtheme"] = Right SlowJam; fromChunks [String "SynthPop.rbtheme"] = Right SynthPop; fromChunks cs = Left $ "Couldn't read as AutogenTheme: " ++ show cs }++data DryVox = DryVox { part0 :: DryVoxPart, part1 :: DryVoxPart, part2 :: DryVoxPart, tuningOffsetCents :: Float } deriving (Eq, Ord, Read, Show)++instance ToChunks DryVox where { toChunks x = makeDict $ Dict $ Map.fromList $ [("part0", toChunks $ part0 x)] ++ [("part1", toChunks $ part1 x)] ++ [("part2", toChunks $ part2 x)] ++ [("tuning_offset_cents", toChunks $ tuningOffsetCents x)] }++instance FromChunks DryVox where { fromChunks = getDict >=> \d -> DryVox <$> (dictLookup "part0" d >>= fromChunks) <*> (dictLookup "part1" d >>= fromChunks) <*> (dictLookup "part2" d >>= fromChunks) <*> (dictLookup "tuning_offset_cents" d >>= fromChunks) }++data DryVoxPart = DryVoxPart { dryVoxFile :: B8.ByteString, dryVoxEnabled :: Bool } deriving (Eq, Ord, Read, Show)++instance ToChunks DryVoxPart where { toChunks x = makeDict $ Dict $ Map.fromList $ [("file", toChunks $ dryVoxFile x)] ++ [("enabled", toChunks $ dryVoxEnabled x)] }++instance FromChunks DryVoxPart where { fromChunks = getDict >=> \d -> DryVoxPart <$> (dictLookup "file" d >>= fromChunks) <*> (dictLookup "enabled" d >>= fromChunks) }++data Tracks = Tracks { drumLayout :: DrumLayout, drumKit :: AudioFile, drumKick :: AudioFile, drumSnare :: AudioFile, bass :: AudioFile, guitar :: AudioFile, vocals :: AudioFile, keys :: AudioFile, backing :: AudioFile } deriving (Eq, Ord, Read, Show)++instance ToChunks Tracks where { toChunks x = makeDict $ Dict $ Map.fromList $ [("drum_layout", toChunks $ drumLayout x)] ++ [("drum_kit", toChunks $ drumKit x)] ++ [("drum_kick", toChunks $ drumKick x)] ++ [("drum_snare", toChunks $ drumSnare x)] ++ [("bass", toChunks $ bass x)] ++ [("guitar", toChunks $ guitar x)] ++ [("vocals", toChunks $ vocals x)] ++ [("keys", toChunks $ keys x)] ++ [("backing", toChunks $ backing x)] }++instance FromChunks Tracks where { fromChunks = getDict >=> \d -> Tracks <$> (dictLookup "drum_layout" d >>= fromChunks) <*> (dictLookup "drum_kit" d >>= fromChunks) <*> (dictLookup "drum_kick" d >>= fromChunks) <*> (dictLookup "drum_snare" d >>= fromChunks) <*> (dictLookup "bass" d >>= fromChunks) <*> (dictLookup "guitar" d >>= fromChunks) <*> (dictLookup "vocals" d >>= fromChunks) <*> (dictLookup "keys" d >>= fromChunks) <*> (dictLookup "backing" d >>= fromChunks) }++data DrumLayout = Kit | KitSnare | KitKick | KitKickSnare deriving (Eq, Ord, Read, Show, Enum, Bounded)++instance ToChunks DrumLayout where { toChunks Kit = [Key "drum_layout_kit"]; toChunks KitSnare = [Key "drum_layout_kit_snare"]; toChunks KitKick = [Key "drum_layout_kit_kick"]; toChunks KitKickSnare = [Key "drum_layout_kit_kick_snare"] }++instance FromChunks DrumLayout where { fromChunks [Key "drum_layout_kit"] = Right Kit; fromChunks [Key "drum_layout_kit_snare"] = Right KitSnare; fromChunks [Key "drum_layout_kit_kick"] = Right KitKick; fromChunks [Key "drum_layout_kit_kick_snare"] = Right KitKickSnare; fromChunks cs = Left $ "Couldn't read as DrumLayout: " ++ show cs }++data AudioFile = AudioFile { audioEnabled :: Bool, channels :: Integer, pan :: [Float], vol :: [Float], audioFile :: B8.ByteString } deriving (Eq, Ord, Read, Show)++instance ToChunks AudioFile where { toChunks x = makeDict $ Dict $ Map.fromList $ [("enabled", toChunks $ audioEnabled x)] ++ [("channels", toChunks $ channels x)] ++ [("pan", toChunks $ pan x)] ++ [("vol", toChunks $ vol x)] ++ [("file", toChunks $ audioFile x)] }++instance FromChunks AudioFile where { fromChunks = getDict >=> \d -> AudioFile <$> (dictLookup "enabled" d >>= fromChunks) <*> (dictLookup "channels" d >>= fromChunks) <*> (dictLookup "pan" d >>= fromChunks) <*> (dictLookup "vol" d >>= fromChunks) <*> (dictLookup "file" d >>= fromChunks) }

@@ -0,0 +1,52 @@+{-# LANGUAGE OverloadedStrings #-}+module Data.DTA.Serialize.RB3 where++import Control.Applicative ((<$>), (<*>))+import Control.Monad ((>=>))++import qualified Data.ByteString.Char8 as B8+import qualified Data.Map as Map++import Data.DTA+import Data.DTA.Serialize+import Data.DTA.Serialize.Magma (Gender(..))++++type Path = Either B8.ByteString Keyword++data SongPackage = SongPackage { name :: B8.ByteString, artist :: B8.ByteString, master :: Bool, songId :: Either Integer Keyword, song :: Song, bank :: Maybe (Path), drumBank :: Maybe (Path), animTempo :: Either AnimTempo Integer, bandFailCue :: Maybe (Path), songScrollSpeed :: Integer, preview :: (Integer, Integer), songLength :: Integer, rank :: Dict Integer, solo :: Maybe (InParens [Keyword]), format :: Integer, version :: Integer, gameOrigin :: Keyword, rating :: Integer, genre :: Keyword, subGenre :: Maybe (Keyword), vocalGender :: Gender, shortVersion :: Maybe (Integer), yearReleased :: Integer, albumArt :: Maybe (Bool), albumName :: Maybe (B8.ByteString), albumTrackNumber :: Maybe (Integer), vocalTonicNote :: Maybe (Pitch), songTonality :: Maybe (Tonality), tuningOffsetCents :: Maybe (Float), realGuitarTuning :: Maybe (InParens [Integer]), realBassTuning :: Maybe (InParens [Integer]), guidePitchVolume :: Maybe (Float), encoding :: Maybe (Keyword) } deriving (Eq, Ord, Read, Show)++instance ToChunks SongPackage where { toChunks x = makeDict $ Dict $ Map.fromList $ [("name", toChunks $ name x)] ++ [("artist", toChunks $ artist x)] ++ [("master", toChunks $ master x)] ++ [("song_id", toChunks $ songId x)] ++ [("song", toChunks $ song x)] ++ (case bank x of { Nothing -> []; Just v -> [("bank", toChunks v)] }) ++ (case drumBank x of { Nothing -> []; Just v -> [("drum_bank", toChunks v)] }) ++ [("anim_tempo", toChunks $ animTempo x)] ++ (case bandFailCue x of { Nothing -> []; Just v -> [("band_fail_cue", toChunks v)] }) ++ [("song_scroll_speed", toChunks $ songScrollSpeed x)] ++ [("preview", toChunks $ preview x)] ++ [("song_length", toChunks $ songLength x)] ++ [("rank", toChunks $ rank x)] ++ (case solo x of { Nothing -> []; Just v -> [("solo", toChunks v)] }) ++ [("format", toChunks $ format x)] ++ [("version", toChunks $ version x)] ++ [("game_origin", toChunks $ gameOrigin x)] ++ [("rating", toChunks $ rating x)] ++ [("genre", toChunks $ genre x)] ++ (case subGenre x of { Nothing -> []; Just v -> [("sub_genre", toChunks v)] }) ++ [("vocal_gender", toChunks $ vocalGender x)] ++ (case shortVersion x of { Nothing -> []; Just v -> [("short_version", toChunks v)] }) ++ [("year_released", toChunks $ yearReleased x)] ++ (case albumArt x of { Nothing -> []; Just v -> [("album_art", toChunks v)] }) ++ (case albumName x of { Nothing -> []; Just v -> [("album_name", toChunks v)] }) ++ (case albumTrackNumber x of { Nothing -> []; Just v -> [("album_track_number", toChunks v)] }) ++ (case vocalTonicNote x of { Nothing -> []; Just v -> [("vocal_tonic_note", toChunks v)] }) ++ (case songTonality x of { Nothing -> []; Just v -> [("song_tonality", toChunks v)] }) ++ (case tuningOffsetCents x of { Nothing -> []; Just v -> [("tuning_offset_cents", toChunks v)] }) ++ (case realGuitarTuning x of { Nothing -> []; Just v -> [("real_guitar_tuning", toChunks v)] }) ++ (case realBassTuning x of { Nothing -> []; Just v -> [("real_bass_tuning", toChunks v)] }) ++ (case guidePitchVolume x of { Nothing -> []; Just v -> [("guide_pitch_volume", toChunks v)] }) ++ (case encoding x of { Nothing -> []; Just v -> [("encoding", toChunks v)] }) }++instance FromChunks SongPackage where { fromChunks = getDict >=> \d -> SongPackage <$> (dictLookup "name" d >>= fromChunks) <*> (dictLookup "artist" d >>= fromChunks) <*> (dictLookup "master" d >>= fromChunks) <*> (dictLookup "song_id" d >>= fromChunks) <*> (dictLookup "song" d >>= fromChunks) <*> (case dictLookup "bank" d of { Left _ -> Right Nothing; Right v -> fmap Just $ fromChunks v }) <*> (case dictLookup "drum_bank" d of { Left _ -> Right Nothing; Right v -> fmap Just $ fromChunks v }) <*> (dictLookup "anim_tempo" d >>= fromChunks) <*> (case dictLookup "band_fail_cue" d of { Left _ -> Right Nothing; Right v -> fmap Just $ fromChunks v }) <*> (dictLookup "song_scroll_speed" d >>= fromChunks) <*> (dictLookup "preview" d >>= fromChunks) <*> (dictLookup "song_length" d >>= fromChunks) <*> (dictLookup "rank" d >>= fromChunks) <*> (case dictLookup "solo" d of { Left _ -> Right Nothing; Right v -> fmap Just $ fromChunks v }) <*> (dictLookup "format" d >>= fromChunks) <*> (dictLookup "version" d >>= fromChunks) <*> (dictLookup "game_origin" d >>= fromChunks) <*> (dictLookup "rating" d >>= fromChunks) <*> (dictLookup "genre" d >>= fromChunks) <*> (case dictLookup "sub_genre" d of { Left _ -> Right Nothing; Right v -> fmap Just $ fromChunks v }) <*> (dictLookup "vocal_gender" d >>= fromChunks) <*> (case dictLookup "short_version" d of { Left _ -> Right Nothing; Right v -> fmap Just $ fromChunks v }) <*> (dictLookup "year_released" d >>= fromChunks) <*> (case dictLookup "album_art" d of { Left _ -> Right Nothing; Right v -> fmap Just $ fromChunks v }) <*> (case dictLookup "album_name" d of { Left _ -> Right Nothing; Right v -> fmap Just $ fromChunks v }) <*> (case dictLookup "album_track_number" d of { Left _ -> Right Nothing; Right v -> fmap Just $ fromChunks v }) <*> (case dictLookup "vocal_tonic_note" d of { Left _ -> Right Nothing; Right v -> fmap Just $ fromChunks v }) <*> (case dictLookup "song_tonality" d of { Left _ -> Right Nothing; Right v -> fmap Just $ fromChunks v }) <*> (case dictLookup "tuning_offset_cents" d of { Left _ -> Right Nothing; Right v -> fmap Just $ fromChunks v }) <*> (case dictLookup "real_guitar_tuning" d of { Left _ -> Right Nothing; Right v -> fmap Just $ fromChunks v }) <*> (case dictLookup "real_bass_tuning" d of { Left _ -> Right Nothing; Right v -> fmap Just $ fromChunks v }) <*> (case dictLookup "guide_pitch_volume" d of { Left _ -> Right Nothing; Right v -> fmap Just $ fromChunks v }) <*> (case dictLookup "encoding" d of { Left _ -> Right Nothing; Right v -> fmap Just $ fromChunks v }) }++data Pitch = C | CSharp | D | DSharp | E | F | FSharp | G | GSharp | A | ASharp | B deriving (Eq, Ord, Read, Show, Enum, Bounded)++instance ToChunks Pitch where { toChunks C = [Int 0]; toChunks CSharp = [Int 1]; toChunks D = [Int 2]; toChunks DSharp = [Int 3]; toChunks E = [Int 4]; toChunks F = [Int 5]; toChunks FSharp = [Int 6]; toChunks G = [Int 7]; toChunks GSharp = [Int 8]; toChunks A = [Int 9]; toChunks ASharp = [Int 10]; toChunks B = [Int 11] }++instance FromChunks Pitch where { fromChunks [Int 0] = Right C; fromChunks [Int 1] = Right CSharp; fromChunks [Int 2] = Right D; fromChunks [Int 3] = Right DSharp; fromChunks [Int 4] = Right E; fromChunks [Int 5] = Right F; fromChunks [Int 6] = Right FSharp; fromChunks [Int 7] = Right G; fromChunks [Int 8] = Right GSharp; fromChunks [Int 9] = Right A; fromChunks [Int 10] = Right ASharp; fromChunks [Int 11] = Right B; fromChunks cs = Left $ "Couldn't read as Pitch: " ++ show cs }++data Tonality = Major | Minor deriving (Eq, Ord, Read, Show, Enum, Bounded)++instance ToChunks Tonality where { toChunks Major = [Int 0]; toChunks Minor = [Int 1] }++instance FromChunks Tonality where { fromChunks [Int 0] = Right Major; fromChunks [Int 1] = Right Minor; fromChunks cs = Left $ "Couldn't read as Tonality: " ++ show cs }++data AnimTempo = KTempoSlow | KTempoMedium | KTempoFast deriving (Eq, Ord, Read, Show, Enum, Bounded)++instance ToChunks AnimTempo where { toChunks KTempoSlow = [Key "kTempoSlow"]; toChunks KTempoMedium = [Key "kTempoMedium"]; toChunks KTempoFast = [Key "kTempoFast"] }++instance FromChunks AnimTempo where { fromChunks [Key "kTempoSlow"] = Right KTempoSlow; fromChunks [Key "kTempoMedium"] = Right KTempoMedium; fromChunks [Key "kTempoFast"] = Right KTempoFast; fromChunks cs = Left $ "Couldn't read as AnimTempo: " ++ show cs }++data Song = Song { songName :: B8.ByteString, tracksCount :: Maybe (InParens [Integer]), tracks :: InParens (Dict (Either Integer (InParens [Integer]))), vocalParts :: Integer, pans :: InParens [Float], vols :: InParens [Float], cores :: InParens [Integer], drumSolo :: DrumSounds, drumFreestyle :: DrumSounds } deriving (Eq, Ord, Read, Show)++instance ToChunks Song where { toChunks x = makeDict $ Dict $ Map.fromList $ [("name", toChunks $ songName x)] ++ (case tracksCount x of { Nothing -> []; Just v -> [("tracks_count", toChunks v)] }) ++ [("tracks", toChunks $ tracks x)] ++ [("vocal_parts", toChunks $ vocalParts x)] ++ [("pans", toChunks $ pans x)] ++ [("vols", toChunks $ vols x)] ++ [("cores", toChunks $ cores x)] ++ [("drum_solo", toChunks $ drumSolo x)] ++ [("drum_freestyle", toChunks $ drumFreestyle x)] }++instance FromChunks Song where { fromChunks = getDict >=> \d -> Song <$> (dictLookup "name" d >>= fromChunks) <*> (case dictLookup "tracks_count" d of { Left _ -> Right Nothing; Right v -> fmap Just $ fromChunks v }) <*> (dictLookup "tracks" d >>= fromChunks) <*> (dictLookup "vocal_parts" d >>= fromChunks) <*> (dictLookup "pans" d >>= fromChunks) <*> (dictLookup "vols" d >>= fromChunks) <*> (dictLookup "cores" d >>= fromChunks) <*> (dictLookup "drum_solo" d >>= fromChunks) <*> (dictLookup "drum_freestyle" d >>= fromChunks) }++data DrumSounds = DrumSounds { seqs :: InParens [Keyword] } deriving (Eq, Ord, Read, Show)++instance ToChunks DrumSounds where { toChunks x = makeDict $ Dict $ Map.fromList $ [("seqs", toChunks $ seqs x)] }++instance FromChunks DrumSounds where { fromChunks = getDict >=> \d -> DrumSounds <$> (dictLookup "seqs" d >>= fromChunks) }