1.1 --- a/.hgignore	Sat Mar 03 12:06:10 2012 -0600
     1.2 +++ b/.hgignore	Sun Mar 04 14:33:52 2012 -0600
     1.3 @@ -10,4 +10,5 @@
     1.4  configure.scan
     1.5  *Makefile.in*
     1.6  config.h.in
     1.7 -build/*
     1.8 \ No newline at end of file
     1.9 +build/*
    1.10 +build-aux/*
    1.11 \ No newline at end of file

     2.1 --- a/COPYING	Sat Mar 03 12:06:10 2012 -0600
     2.2 +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
     2.3 @@ -1,674 +0,0 @@
     2.4 -                    GNU GENERAL PUBLIC LICENSE
     2.5 -                       Version 3, 29 June 2007
     2.6 -
     2.7 - Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
     2.8 - Everyone is permitted to copy and distribute verbatim copies
     2.9 - of this license document, but changing it is not allowed.
    2.10 -
    2.11 -                            Preamble
    2.12 -
    2.13 -  The GNU General Public License is a free, copyleft license for
    2.14 -software and other kinds of works.
    2.15 -
    2.16 -  The licenses for most software and other practical works are designed
    2.17 -to take away your freedom to share and change the works.  By contrast,
    2.18 -the GNU General Public License is intended to guarantee your freedom to
    2.19 -share and change all versions of a program--to make sure it remains free
    2.20 -software for all its users.  We, the Free Software Foundation, use the
    2.21 -GNU General Public License for most of our software; it applies also to
    2.22 -any other work released this way by its authors.  You can apply it to
    2.23 -your programs, too.
    2.24 -
    2.25 -  When we speak of free software, we are referring to freedom, not
    2.26 -price.  Our General Public Licenses are designed to make sure that you
    2.27 -have the freedom to distribute copies of free software (and charge for
    2.28 -them if you wish), that you receive source code or can get it if you
    2.29 -want it, that you can change the software or use pieces of it in new
    2.30 -free programs, and that you know you can do these things.
    2.31 -
    2.32 -  To protect your rights, we need to prevent others from denying you
    2.33 -these rights or asking you to surrender the rights.  Therefore, you have
    2.34 -certain responsibilities if you distribute copies of the software, or if
    2.35 -you modify it: responsibilities to respect the freedom of others.
    2.36 -
    2.37 -  For example, if you distribute copies of such a program, whether
    2.38 -gratis or for a fee, you must pass on to the recipients the same
    2.39 -freedoms that you received.  You must make sure that they, too, receive
    2.40 -or can get the source code.  And you must show them these terms so they
    2.41 -know their rights.
    2.42 -
    2.43 -  Developers that use the GNU GPL protect your rights with two steps:
    2.44 -(1) assert copyright on the software, and (2) offer you this License
    2.45 -giving you legal permission to copy, distribute and/or modify it.
    2.46 -
    2.47 -  For the developers' and authors' protection, the GPL clearly explains
    2.48 -that there is no warranty for this free software.  For both users' and
    2.49 -authors' sake, the GPL requires that modified versions be marked as
    2.50 -changed, so that their problems will not be attributed erroneously to
    2.51 -authors of previous versions.
    2.52 -
    2.53 -  Some devices are designed to deny users access to install or run
    2.54 -modified versions of the software inside them, although the manufacturer
    2.55 -can do so.  This is fundamentally incompatible with the aim of
    2.56 -protecting users' freedom to change the software.  The systematic
    2.57 -pattern of such abuse occurs in the area of products for individuals to
    2.58 -use, which is precisely where it is most unacceptable.  Therefore, we
    2.59 -have designed this version of the GPL to prohibit the practice for those
    2.60 -products.  If such problems arise substantially in other domains, we
    2.61 -stand ready to extend this provision to those domains in future versions
    2.62 -of the GPL, as needed to protect the freedom of users.
    2.63 -
    2.64 -  Finally, every program is threatened constantly by software patents.
    2.65 -States should not allow patents to restrict development and use of
    2.66 -software on general-purpose computers, but in those that do, we wish to
    2.67 -avoid the special danger that patents applied to a free program could
    2.68 -make it effectively proprietary.  To prevent this, the GPL assures that
    2.69 -patents cannot be used to render the program non-free.
    2.70 -
    2.71 -  The precise terms and conditions for copying, distribution and
    2.72 -modification follow.
    2.73 -
    2.74 -                       TERMS AND CONDITIONS
    2.75 -
    2.76 -  0. Definitions.
    2.77 -
    2.78 -  "This License" refers to version 3 of the GNU General Public License.
    2.79 -
    2.80 -  "Copyright" also means copyright-like laws that apply to other kinds of
    2.81 -works, such as semiconductor masks.
    2.82 -
    2.83 -  "The Program" refers to any copyrightable work licensed under this
    2.84 -License.  Each licensee is addressed as "you".  "Licensees" and
    2.85 -"recipients" may be individuals or organizations.
    2.86 -
    2.87 -  To "modify" a work means to copy from or adapt all or part of the work
    2.88 -in a fashion requiring copyright permission, other than the making of an
    2.89 -exact copy.  The resulting work is called a "modified version" of the
    2.90 -earlier work or a work "based on" the earlier work.
    2.91 -
    2.92 -  A "covered work" means either the unmodified Program or a work based
    2.93 -on the Program.
    2.94 -
    2.95 -  To "propagate" a work means to do anything with it that, without
    2.96 -permission, would make you directly or secondarily liable for
    2.97 -infringement under applicable copyright law, except executing it on a
    2.98 -computer or modifying a private copy.  Propagation includes copying,
    2.99 -distribution (with or without modification), making available to the
   2.100 -public, and in some countries other activities as well.
   2.101 -
   2.102 -  To "convey" a work means any kind of propagation that enables other
   2.103 -parties to make or receive copies.  Mere interaction with a user through
   2.104 -a computer network, with no transfer of a copy, is not conveying.
   2.105 -
   2.106 -  An interactive user interface displays "Appropriate Legal Notices"
   2.107 -to the extent that it includes a convenient and prominently visible
   2.108 -feature that (1) displays an appropriate copyright notice, and (2)
   2.109 -tells the user that there is no warranty for the work (except to the
   2.110 -extent that warranties are provided), that licensees may convey the
   2.111 -work under this License, and how to view a copy of this License.  If
   2.112 -the interface presents a list of user commands or options, such as a
   2.113 -menu, a prominent item in the list meets this criterion.
   2.114 -
   2.115 -  1. Source Code.
   2.116 -
   2.117 -  The "source code" for a work means the preferred form of the work
   2.118 -for making modifications to it.  "Object code" means any non-source
   2.119 -form of a work.
   2.120 -
   2.121 -  A "Standard Interface" means an interface that either is an official
   2.122 -standard defined by a recognized standards body, or, in the case of
   2.123 -interfaces specified for a particular programming language, one that
   2.124 -is widely used among developers working in that language.
   2.125 -
   2.126 -  The "System Libraries" of an executable work include anything, other
   2.127 -than the work as a whole, that (a) is included in the normal form of
   2.128 -packaging a Major Component, but which is not part of that Major
   2.129 -Component, and (b) serves only to enable use of the work with that
   2.130 -Major Component, or to implement a Standard Interface for which an
   2.131 -implementation is available to the public in source code form.  A
   2.132 -"Major Component", in this context, means a major essential component
   2.133 -(kernel, window system, and so on) of the specific operating system
   2.134 -(if any) on which the executable work runs, or a compiler used to
   2.135 -produce the work, or an object code interpreter used to run it.
   2.136 -
   2.137 -  The "Corresponding Source" for a work in object code form means all
   2.138 -the source code needed to generate, install, and (for an executable
   2.139 -work) run the object code and to modify the work, including scripts to
   2.140 -control those activities.  However, it does not include the work's
   2.141 -System Libraries, or general-purpose tools or generally available free
   2.142 -programs which are used unmodified in performing those activities but
   2.143 -which are not part of the work.  For example, Corresponding Source
   2.144 -includes interface definition files associated with source files for
   2.145 -the work, and the source code for shared libraries and dynamically
   2.146 -linked subprograms that the work is specifically designed to require,
   2.147 -such as by intimate data communication or control flow between those
   2.148 -subprograms and other parts of the work.
   2.149 -
   2.150 -  The Corresponding Source need not include anything that users
   2.151 -can regenerate automatically from other parts of the Corresponding
   2.152 -Source.
   2.153 -
   2.154 -  The Corresponding Source for a work in source code form is that
   2.155 -same work.
   2.156 -
   2.157 -  2. Basic Permissions.
   2.158 -
   2.159 -  All rights granted under this License are granted for the term of
   2.160 -copyright on the Program, and are irrevocable provided the stated
   2.161 -conditions are met.  This License explicitly affirms your unlimited
   2.162 -permission to run the unmodified Program.  The output from running a
   2.163 -covered work is covered by this License only if the output, given its
   2.164 -content, constitutes a covered work.  This License acknowledges your
   2.165 -rights of fair use or other equivalent, as provided by copyright law.
   2.166 -
   2.167 -  You may make, run and propagate covered works that you do not
   2.168 -convey, without conditions so long as your license otherwise remains
   2.169 -in force.  You may convey covered works to others for the sole purpose
   2.170 -of having them make modifications exclusively for you, or provide you
   2.171 -with facilities for running those works, provided that you comply with
   2.172 -the terms of this License in conveying all material for which you do
   2.173 -not control copyright.  Those thus making or running the covered works
   2.174 -for you must do so exclusively on your behalf, under your direction
   2.175 -and control, on terms that prohibit them from making any copies of
   2.176 -your copyrighted material outside their relationship with you.
   2.177 -
   2.178 -  Conveying under any other circumstances is permitted solely under
   2.179 -the conditions stated below.  Sublicensing is not allowed; section 10
   2.180 -makes it unnecessary.
   2.181 -
   2.182 -  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
   2.183 -
   2.184 -  No covered work shall be deemed part of an effective technological
   2.185 -measure under any applicable law fulfilling obligations under article
   2.186 -11 of the WIPO copyright treaty adopted on 20 December 1996, or
   2.187 -similar laws prohibiting or restricting circumvention of such
   2.188 -measures.
   2.189 -
   2.190 -  When you convey a covered work, you waive any legal power to forbid
   2.191 -circumvention of technological measures to the extent such circumvention
   2.192 -is effected by exercising rights under this License with respect to
   2.193 -the covered work, and you disclaim any intention to limit operation or
   2.194 -modification of the work as a means of enforcing, against the work's
   2.195 -users, your or third parties' legal rights to forbid circumvention of
   2.196 -technological measures.
   2.197 -
   2.198 -  4. Conveying Verbatim Copies.
   2.199 -
   2.200 -  You may convey verbatim copies of the Program's source code as you
   2.201 -receive it, in any medium, provided that you conspicuously and
   2.202 -appropriately publish on each copy an appropriate copyright notice;
   2.203 -keep intact all notices stating that this License and any
   2.204 -non-permissive terms added in accord with section 7 apply to the code;
   2.205 -keep intact all notices of the absence of any warranty; and give all
   2.206 -recipients a copy of this License along with the Program.
   2.207 -
   2.208 -  You may charge any price or no price for each copy that you convey,
   2.209 -and you may offer support or warranty protection for a fee.
   2.210 -
   2.211 -  5. Conveying Modified Source Versions.
   2.212 -
   2.213 -  You may convey a work based on the Program, or the modifications to
   2.214 -produce it from the Program, in the form of source code under the
   2.215 -terms of section 4, provided that you also meet all of these conditions:
   2.216 -
   2.217 -    a) The work must carry prominent notices stating that you modified
   2.218 -    it, and giving a relevant date.
   2.219 -
   2.220 -    b) The work must carry prominent notices stating that it is
   2.221 -    released under this License and any conditions added under section
   2.222 -    7.  This requirement modifies the requirement in section 4 to
   2.223 -    "keep intact all notices".
   2.224 -
   2.225 -    c) You must license the entire work, as a whole, under this
   2.226 -    License to anyone who comes into possession of a copy.  This
   2.227 -    License will therefore apply, along with any applicable section 7
   2.228 -    additional terms, to the whole of the work, and all its parts,
   2.229 -    regardless of how they are packaged.  This License gives no
   2.230 -    permission to license the work in any other way, but it does not
   2.231 -    invalidate such permission if you have separately received it.
   2.232 -
   2.233 -    d) If the work has interactive user interfaces, each must display
   2.234 -    Appropriate Legal Notices; however, if the Program has interactive
   2.235 -    interfaces that do not display Appropriate Legal Notices, your
   2.236 -    work need not make them do so.
   2.237 -
   2.238 -  A compilation of a covered work with other separate and independent
   2.239 -works, which are not by their nature extensions of the covered work,
   2.240 -and which are not combined with it such as to form a larger program,
   2.241 -in or on a volume of a storage or distribution medium, is called an
   2.242 -"aggregate" if the compilation and its resulting copyright are not
   2.243 -used to limit the access or legal rights of the compilation's users
   2.244 -beyond what the individual works permit.  Inclusion of a covered work
   2.245 -in an aggregate does not cause this License to apply to the other
   2.246 -parts of the aggregate.
   2.247 -
   2.248 -  6. Conveying Non-Source Forms.
   2.249 -
   2.250 -  You may convey a covered work in object code form under the terms
   2.251 -of sections 4 and 5, provided that you also convey the
   2.252 -machine-readable Corresponding Source under the terms of this License,
   2.253 -in one of these ways:
   2.254 -
   2.255 -    a) Convey the object code in, or embodied in, a physical product
   2.256 -    (including a physical distribution medium), accompanied by the
   2.257 -    Corresponding Source fixed on a durable physical medium
   2.258 -    customarily used for software interchange.
   2.259 -
   2.260 -    b) Convey the object code in, or embodied in, a physical product
   2.261 -    (including a physical distribution medium), accompanied by a
   2.262 -    written offer, valid for at least three years and valid for as
   2.263 -    long as you offer spare parts or customer support for that product
   2.264 -    model, to give anyone who possesses the object code either (1) a
   2.265 -    copy of the Corresponding Source for all the software in the
   2.266 -    product that is covered by this License, on a durable physical
   2.267 -    medium customarily used for software interchange, for a price no
   2.268 -    more than your reasonable cost of physically performing this
   2.269 -    conveying of source, or (2) access to copy the
   2.270 -    Corresponding Source from a network server at no charge.
   2.271 -
   2.272 -    c) Convey individual copies of the object code with a copy of the
   2.273 -    written offer to provide the Corresponding Source.  This
   2.274 -    alternative is allowed only occasionally and noncommercially, and
   2.275 -    only if you received the object code with such an offer, in accord
   2.276 -    with subsection 6b.
   2.277 -
   2.278 -    d) Convey the object code by offering access from a designated
   2.279 -    place (gratis or for a charge), and offer equivalent access to the
   2.280 -    Corresponding Source in the same way through the same place at no
   2.281 -    further charge.  You need not require recipients to copy the
   2.282 -    Corresponding Source along with the object code.  If the place to
   2.283 -    copy the object code is a network server, the Corresponding Source
   2.284 -    may be on a different server (operated by you or a third party)
   2.285 -    that supports equivalent copying facilities, provided you maintain
   2.286 -    clear directions next to the object code saying where to find the
   2.287 -    Corresponding Source.  Regardless of what server hosts the
   2.288 -    Corresponding Source, you remain obligated to ensure that it is
   2.289 -    available for as long as needed to satisfy these requirements.
   2.290 -
   2.291 -    e) Convey the object code using peer-to-peer transmission, provided
   2.292 -    you inform other peers where the object code and Corresponding
   2.293 -    Source of the work are being offered to the general public at no
   2.294 -    charge under subsection 6d.
   2.295 -
   2.296 -  A separable portion of the object code, whose source code is excluded
   2.297 -from the Corresponding Source as a System Library, need not be
   2.298 -included in conveying the object code work.
   2.299 -
   2.300 -  A "User Product" is either (1) a "consumer product", which means any
   2.301 -tangible personal property which is normally used for personal, family,
   2.302 -or household purposes, or (2) anything designed or sold for incorporation
   2.303 -into a dwelling.  In determining whether a product is a consumer product,
   2.304 -doubtful cases shall be resolved in favor of coverage.  For a particular
   2.305 -product received by a particular user, "normally used" refers to a
   2.306 -typical or common use of that class of product, regardless of the status
   2.307 -of the particular user or of the way in which the particular user
   2.308 -actually uses, or expects or is expected to use, the product.  A product
   2.309 -is a consumer product regardless of whether the product has substantial
   2.310 -commercial, industrial or non-consumer uses, unless such uses represent
   2.311 -the only significant mode of use of the product.
   2.312 -
   2.313 -  "Installation Information" for a User Product means any methods,
   2.314 -procedures, authorization keys, or other information required to install
   2.315 -and execute modified versions of a covered work in that User Product from
   2.316 -a modified version of its Corresponding Source.  The information must
   2.317 -suffice to ensure that the continued functioning of the modified object
   2.318 -code is in no case prevented or interfered with solely because
   2.319 -modification has been made.
   2.320 -
   2.321 -  If you convey an object code work under this section in, or with, or
   2.322 -specifically for use in, a User Product, and the conveying occurs as
   2.323 -part of a transaction in which the right of possession and use of the
   2.324 -User Product is transferred to the recipient in perpetuity or for a
   2.325 -fixed term (regardless of how the transaction is characterized), the
   2.326 -Corresponding Source conveyed under this section must be accompanied
   2.327 -by the Installation Information.  But this requirement does not apply
   2.328 -if neither you nor any third party retains the ability to install
   2.329 -modified object code on the User Product (for example, the work has
   2.330 -been installed in ROM).
   2.331 -
   2.332 -  The requirement to provide Installation Information does not include a
   2.333 -requirement to continue to provide support service, warranty, or updates
   2.334 -for a work that has been modified or installed by the recipient, or for
   2.335 -the User Product in which it has been modified or installed.  Access to a
   2.336 -network may be denied when the modification itself materially and
   2.337 -adversely affects the operation of the network or violates the rules and
   2.338 -protocols for communication across the network.
   2.339 -
   2.340 -  Corresponding Source conveyed, and Installation Information provided,
   2.341 -in accord with this section must be in a format that is publicly
   2.342 -documented (and with an implementation available to the public in
   2.343 -source code form), and must require no special password or key for
   2.344 -unpacking, reading or copying.
   2.345 -
   2.346 -  7. Additional Terms.
   2.347 -
   2.348 -  "Additional permissions" are terms that supplement the terms of this
   2.349 -License by making exceptions from one or more of its conditions.
   2.350 -Additional permissions that are applicable to the entire Program shall
   2.351 -be treated as though they were included in this License, to the extent
   2.352 -that they are valid under applicable law.  If additional permissions
   2.353 -apply only to part of the Program, that part may be used separately
   2.354 -under those permissions, but the entire Program remains governed by
   2.355 -this License without regard to the additional permissions.
   2.356 -
   2.357 -  When you convey a copy of a covered work, you may at your option
   2.358 -remove any additional permissions from that copy, or from any part of
   2.359 -it.  (Additional permissions may be written to require their own
   2.360 -removal in certain cases when you modify the work.)  You may place
   2.361 -additional permissions on material, added by you to a covered work,
   2.362 -for which you have or can give appropriate copyright permission.
   2.363 -
   2.364 -  Notwithstanding any other provision of this License, for material you
   2.365 -add to a covered work, you may (if authorized by the copyright holders of
   2.366 -that material) supplement the terms of this License with terms:
   2.367 -
   2.368 -    a) Disclaiming warranty or limiting liability differently from the
   2.369 -    terms of sections 15 and 16 of this License; or
   2.370 -
   2.371 -    b) Requiring preservation of specified reasonable legal notices or
   2.372 -    author attributions in that material or in the Appropriate Legal
   2.373 -    Notices displayed by works containing it; or
   2.374 -
   2.375 -    c) Prohibiting misrepresentation of the origin of that material, or
   2.376 -    requiring that modified versions of such material be marked in
   2.377 -    reasonable ways as different from the original version; or
   2.378 -
   2.379 -    d) Limiting the use for publicity purposes of names of licensors or
   2.380 -    authors of the material; or
   2.381 -
   2.382 -    e) Declining to grant rights under trademark law for use of some
   2.383 -    trade names, trademarks, or service marks; or
   2.384 -
   2.385 -    f) Requiring indemnification of licensors and authors of that
   2.386 -    material by anyone who conveys the material (or modified versions of
   2.387 -    it) with contractual assumptions of liability to the recipient, for
   2.388 -    any liability that these contractual assumptions directly impose on
   2.389 -    those licensors and authors.
   2.390 -
   2.391 -  All other non-permissive additional terms are considered "further
   2.392 -restrictions" within the meaning of section 10.  If the Program as you
   2.393 -received it, or any part of it, contains a notice stating that it is
   2.394 -governed by this License along with a term that is a further
   2.395 -restriction, you may remove that term.  If a license document contains
   2.396 -a further restriction but permits relicensing or conveying under this
   2.397 -License, you may add to a covered work material governed by the terms
   2.398 -of that license document, provided that the further restriction does
   2.399 -not survive such relicensing or conveying.
   2.400 -
   2.401 -  If you add terms to a covered work in accord with this section, you
   2.402 -must place, in the relevant source files, a statement of the
   2.403 -additional terms that apply to those files, or a notice indicating
   2.404 -where to find the applicable terms.
   2.405 -
   2.406 -  Additional terms, permissive or non-permissive, may be stated in the
   2.407 -form of a separately written license, or stated as exceptions;
   2.408 -the above requirements apply either way.
   2.409 -
   2.410 -  8. Termination.
   2.411 -
   2.412 -  You may not propagate or modify a covered work except as expressly
   2.413 -provided under this License.  Any attempt otherwise to propagate or
   2.414 -modify it is void, and will automatically terminate your rights under
   2.415 -this License (including any patent licenses granted under the third
   2.416 -paragraph of section 11).
   2.417 -
   2.418 -  However, if you cease all violation of this License, then your
   2.419 -license from a particular copyright holder is reinstated (a)
   2.420 -provisionally, unless and until the copyright holder explicitly and
   2.421 -finally terminates your license, and (b) permanently, if the copyright
   2.422 -holder fails to notify you of the violation by some reasonable means
   2.423 -prior to 60 days after the cessation.
   2.424 -
   2.425 -  Moreover, your license from a particular copyright holder is
   2.426 -reinstated permanently if the copyright holder notifies you of the
   2.427 -violation by some reasonable means, this is the first time you have
   2.428 -received notice of violation of this License (for any work) from that
   2.429 -copyright holder, and you cure the violation prior to 30 days after
   2.430 -your receipt of the notice.
   2.431 -
   2.432 -  Termination of your rights under this section does not terminate the
   2.433 -licenses of parties who have received copies or rights from you under
   2.434 -this License.  If your rights have been terminated and not permanently
   2.435 -reinstated, you do not qualify to receive new licenses for the same
   2.436 -material under section 10.
   2.437 -
   2.438 -  9. Acceptance Not Required for Having Copies.
   2.439 -
   2.440 -  You are not required to accept this License in order to receive or
   2.441 -run a copy of the Program.  Ancillary propagation of a covered work
   2.442 -occurring solely as a consequence of using peer-to-peer transmission
   2.443 -to receive a copy likewise does not require acceptance.  However,
   2.444 -nothing other than this License grants you permission to propagate or
   2.445 -modify any covered work.  These actions infringe copyright if you do
   2.446 -not accept this License.  Therefore, by modifying or propagating a
   2.447 -covered work, you indicate your acceptance of this License to do so.
   2.448 -
   2.449 -  10. Automatic Licensing of Downstream Recipients.
   2.450 -
   2.451 -  Each time you convey a covered work, the recipient automatically
   2.452 -receives a license from the original licensors, to run, modify and
   2.453 -propagate that work, subject to this License.  You are not responsible
   2.454 -for enforcing compliance by third parties with this License.
   2.455 -
   2.456 -  An "entity transaction" is a transaction transferring control of an
   2.457 -organization, or substantially all assets of one, or subdividing an
   2.458 -organization, or merging organizations.  If propagation of a covered
   2.459 -work results from an entity transaction, each party to that
   2.460 -transaction who receives a copy of the work also receives whatever
   2.461 -licenses to the work the party's predecessor in interest had or could
   2.462 -give under the previous paragraph, plus a right to possession of the
   2.463 -Corresponding Source of the work from the predecessor in interest, if
   2.464 -the predecessor has it or can get it with reasonable efforts.
   2.465 -
   2.466 -  You may not impose any further restrictions on the exercise of the
   2.467 -rights granted or affirmed under this License.  For example, you may
   2.468 -not impose a license fee, royalty, or other charge for exercise of
   2.469 -rights granted under this License, and you may not initiate litigation
   2.470 -(including a cross-claim or counterclaim in a lawsuit) alleging that
   2.471 -any patent claim is infringed by making, using, selling, offering for
   2.472 -sale, or importing the Program or any portion of it.
   2.473 -
   2.474 -  11. Patents.
   2.475 -
   2.476 -  A "contributor" is a copyright holder who authorizes use under this
   2.477 -License of the Program or a work on which the Program is based.  The
   2.478 -work thus licensed is called the contributor's "contributor version".
   2.479 -
   2.480 -  A contributor's "essential patent claims" are all patent claims
   2.481 -owned or controlled by the contributor, whether already acquired or
   2.482 -hereafter acquired, that would be infringed by some manner, permitted
   2.483 -by this License, of making, using, or selling its contributor version,
   2.484 -but do not include claims that would be infringed only as a
   2.485 -consequence of further modification of the contributor version.  For
   2.486 -purposes of this definition, "control" includes the right to grant
   2.487 -patent sublicenses in a manner consistent with the requirements of
   2.488 -this License.
   2.489 -
   2.490 -  Each contributor grants you a non-exclusive, worldwide, royalty-free
   2.491 -patent license under the contributor's essential patent claims, to
   2.492 -make, use, sell, offer for sale, import and otherwise run, modify and
   2.493 -propagate the contents of its contributor version.
   2.494 -
   2.495 -  In the following three paragraphs, a "patent license" is any express
   2.496 -agreement or commitment, however denominated, not to enforce a patent
   2.497 -(such as an express permission to practice a patent or covenant not to
   2.498 -sue for patent infringement).  To "grant" such a patent license to a
   2.499 -party means to make such an agreement or commitment not to enforce a
   2.500 -patent against the party.
   2.501 -
   2.502 -  If you convey a covered work, knowingly relying on a patent license,
   2.503 -and the Corresponding Source of the work is not available for anyone
   2.504 -to copy, free of charge and under the terms of this License, through a
   2.505 -publicly available network server or other readily accessible means,
   2.506 -then you must either (1) cause the Corresponding Source to be so
   2.507 -available, or (2) arrange to deprive yourself of the benefit of the
   2.508 -patent license for this particular work, or (3) arrange, in a manner
   2.509 -consistent with the requirements of this License, to extend the patent
   2.510 -license to downstream recipients.  "Knowingly relying" means you have
   2.511 -actual knowledge that, but for the patent license, your conveying the
   2.512 -covered work in a country, or your recipient's use of the covered work
   2.513 -in a country, would infringe one or more identifiable patents in that
   2.514 -country that you have reason to believe are valid.
   2.515 -
   2.516 -  If, pursuant to or in connection with a single transaction or
   2.517 -arrangement, you convey, or propagate by procuring conveyance of, a
   2.518 -covered work, and grant a patent license to some of the parties
   2.519 -receiving the covered work authorizing them to use, propagate, modify
   2.520 -or convey a specific copy of the covered work, then the patent license
   2.521 -you grant is automatically extended to all recipients of the covered
   2.522 -work and works based on it.
   2.523 -
   2.524 -  A patent license is "discriminatory" if it does not include within
   2.525 -the scope of its coverage, prohibits the exercise of, or is
   2.526 -conditioned on the non-exercise of one or more of the rights that are
   2.527 -specifically granted under this License.  You may not convey a covered
   2.528 -work if you are a party to an arrangement with a third party that is
   2.529 -in the business of distributing software, under which you make payment
   2.530 -to the third party based on the extent of your activity of conveying
   2.531 -the work, and under which the third party grants, to any of the
   2.532 -parties who would receive the covered work from you, a discriminatory
   2.533 -patent license (a) in connection with copies of the covered work
   2.534 -conveyed by you (or copies made from those copies), or (b) primarily
   2.535 -for and in connection with specific products or compilations that
   2.536 -contain the covered work, unless you entered into that arrangement,
   2.537 -or that patent license was granted, prior to 28 March 2007.
   2.538 -
   2.539 -  Nothing in this License shall be construed as excluding or limiting
   2.540 -any implied license or other defenses to infringement that may
   2.541 -otherwise be available to you under applicable patent law.
   2.542 -
   2.543 -  12. No Surrender of Others' Freedom.
   2.544 -
   2.545 -  If conditions are imposed on you (whether by court order, agreement or
   2.546 -otherwise) that contradict the conditions of this License, they do not
   2.547 -excuse you from the conditions of this License.  If you cannot convey a
   2.548 -covered work so as to satisfy simultaneously your obligations under this
   2.549 -License and any other pertinent obligations, then as a consequence you may
   2.550 -not convey it at all.  For example, if you agree to terms that obligate you
   2.551 -to collect a royalty for further conveying from those to whom you convey
   2.552 -the Program, the only way you could satisfy both those terms and this
   2.553 -License would be to refrain entirely from conveying the Program.
   2.554 -
   2.555 -  13. Use with the GNU Affero General Public License.
   2.556 -
   2.557 -  Notwithstanding any other provision of this License, you have
   2.558 -permission to link or combine any covered work with a work licensed
   2.559 -under version 3 of the GNU Affero General Public License into a single
   2.560 -combined work, and to convey the resulting work.  The terms of this
   2.561 -License will continue to apply to the part which is the covered work,
   2.562 -but the special requirements of the GNU Affero General Public License,
   2.563 -section 13, concerning interaction through a network will apply to the
   2.564 -combination as such.
   2.565 -
   2.566 -  14. Revised Versions of this License.
   2.567 -
   2.568 -  The Free Software Foundation may publish revised and/or new versions of
   2.569 -the GNU General Public License from time to time.  Such new versions will
   2.570 -be similar in spirit to the present version, but may differ in detail to
   2.571 -address new problems or concerns.
   2.572 -
   2.573 -  Each version is given a distinguishing version number.  If the
   2.574 -Program specifies that a certain numbered version of the GNU General
   2.575 -Public License "or any later version" applies to it, you have the
   2.576 -option of following the terms and conditions either of that numbered
   2.577 -version or of any later version published by the Free Software
   2.578 -Foundation.  If the Program does not specify a version number of the
   2.579 -GNU General Public License, you may choose any version ever published
   2.580 -by the Free Software Foundation.
   2.581 -
   2.582 -  If the Program specifies that a proxy can decide which future
   2.583 -versions of the GNU General Public License can be used, that proxy's
   2.584 -public statement of acceptance of a version permanently authorizes you
   2.585 -to choose that version for the Program.
   2.586 -
   2.587 -  Later license versions may give you additional or different
   2.588 -permissions.  However, no additional obligations are imposed on any
   2.589 -author or copyright holder as a result of your choosing to follow a
   2.590 -later version.
   2.591 -
   2.592 -  15. Disclaimer of Warranty.
   2.593 -
   2.594 -  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
   2.595 -APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
   2.596 -HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
   2.597 -OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
   2.598 -THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   2.599 -PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
   2.600 -IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
   2.601 -ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
   2.602 -
   2.603 -  16. Limitation of Liability.
   2.604 -
   2.605 -  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
   2.606 -WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
   2.607 -THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
   2.608 -GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
   2.609 -USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
   2.610 -DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
   2.611 -PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
   2.612 -EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
   2.613 -SUCH DAMAGES.
   2.614 -
   2.615 -  17. Interpretation of Sections 15 and 16.
   2.616 -
   2.617 -  If the disclaimer of warranty and limitation of liability provided
   2.618 -above cannot be given local legal effect according to their terms,
   2.619 -reviewing courts shall apply local law that most closely approximates
   2.620 -an absolute waiver of all civil liability in connection with the
   2.621 -Program, unless a warranty or assumption of liability accompanies a
   2.622 -copy of the Program in return for a fee.
   2.623 -
   2.624 -                     END OF TERMS AND CONDITIONS
   2.625 -
   2.626 -            How to Apply These Terms to Your New Programs
   2.627 -
   2.628 -  If you develop a new program, and you want it to be of the greatest
   2.629 -possible use to the public, the best way to achieve this is to make it
   2.630 -free software which everyone can redistribute and change under these terms.
   2.631 -
   2.632 -  To do so, attach the following notices to the program.  It is safest
   2.633 -to attach them to the start of each source file to most effectively
   2.634 -state the exclusion of warranty; and each file should have at least
   2.635 -the "copyright" line and a pointer to where the full notice is found.
   2.636 -
   2.637 -    <one line to give the program's name and a brief idea of what it does.>
   2.638 -    Copyright (C) <year>  <name of author>
   2.639 -
   2.640 -    This program is free software: you can redistribute it and/or modify
   2.641 -    it under the terms of the GNU General Public License as published by
   2.642 -    the Free Software Foundation, either version 3 of the License, or
   2.643 -    (at your option) any later version.
   2.644 -
   2.645 -    This program is distributed in the hope that it will be useful,
   2.646 -    but WITHOUT ANY WARRANTY; without even the implied warranty of
   2.647 -    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   2.648 -    GNU General Public License for more details.
   2.649 -
   2.650 -    You should have received a copy of the GNU General Public License
   2.651 -    along with this program.  If not, see <http://www.gnu.org/licenses/>.
   2.652 -
   2.653 -Also add information on how to contact you by electronic and paper mail.
   2.654 -
   2.655 -  If the program does terminal interaction, make it output a short
   2.656 -notice like this when it starts in an interactive mode:
   2.657 -
   2.658 -    <program>  Copyright (C) <year>  <name of author>
   2.659 -    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
   2.660 -    This is free software, and you are welcome to redistribute it
   2.661 -    under certain conditions; type `show c' for details.
   2.662 -
   2.663 -The hypothetical commands `show w' and `show c' should show the appropriate
   2.664 -parts of the General Public License.  Of course, your program's commands
   2.665 -might be different; for a GUI interface, you would use an "about box".
   2.666 -
   2.667 -  You should also get your employer (if you work as a programmer) or school,
   2.668 -if any, to sign a "copyright disclaimer" for the program, if necessary.
   2.669 -For more information on this, and how to apply and follow the GNU GPL, see
   2.670 -<http://www.gnu.org/licenses/>.
   2.671 -
   2.672 -  The GNU General Public License does not permit incorporating your program
   2.673 -into proprietary programs.  If your program is a subroutine library, you
   2.674 -may consider it more useful to permit linking proprietary applications with
   2.675 -the library.  If this is what you want to do, use the GNU Lesser General
   2.676 -Public License instead of this License.  But first, please read
   2.677 -<http://www.gnu.org/philosophy/why-not-lgpl.html>.

     3.1 --- a/INSTALL	Sat Mar 03 12:06:10 2012 -0600
     3.2 +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
     3.3 @@ -1,365 +0,0 @@
     3.4 -Installation Instructions
     3.5 -*************************
     3.6 -
     3.7 -Copyright (C) 1994, 1995, 1996, 1999, 2000, 2001, 2002, 2004, 2005,
     3.8 -2006, 2007, 2008, 2009 Free Software Foundation, Inc.
     3.9 -
    3.10 -   Copying and distribution of this file, with or without modification,
    3.11 -are permitted in any medium without royalty provided the copyright
    3.12 -notice and this notice are preserved.  This file is offered as-is,
    3.13 -without warranty of any kind.
    3.14 -
    3.15 -Basic Installation
    3.16 -==================
    3.17 -
    3.18 -   Briefly, the shell commands `./configure; make; make install' should
    3.19 -configure, build, and install this package.  The following
    3.20 -more-detailed instructions are generic; see the `README' file for
    3.21 -instructions specific to this package.  Some packages provide this
    3.22 -`INSTALL' file but do not implement all of the features documented
    3.23 -below.  The lack of an optional feature in a given package is not
    3.24 -necessarily a bug.  More recommendations for GNU packages can be found
    3.25 -in *note Makefile Conventions: (standards)Makefile Conventions.
    3.26 -
    3.27 -   The `configure' shell script attempts to guess correct values for
    3.28 -various system-dependent variables used during compilation.  It uses
    3.29 -those values to create a `Makefile' in each directory of the package.
    3.30 -It may also create one or more `.h' files containing system-dependent
    3.31 -definitions.  Finally, it creates a shell script `config.status' that
    3.32 -you can run in the future to recreate the current configuration, and a
    3.33 -file `config.log' containing compiler output (useful mainly for
    3.34 -debugging `configure').
    3.35 -
    3.36 -   It can also use an optional file (typically called `config.cache'
    3.37 -and enabled with `--cache-file=config.cache' or simply `-C') that saves
    3.38 -the results of its tests to speed up reconfiguring.  Caching is
    3.39 -disabled by default to prevent problems with accidental use of stale
    3.40 -cache files.
    3.41 -
    3.42 -   If you need to do unusual things to compile the package, please try
    3.43 -to figure out how `configure' could check whether to do them, and mail
    3.44 -diffs or instructions to the address given in the `README' so they can
    3.45 -be considered for the next release.  If you are using the cache, and at
    3.46 -some point `config.cache' contains results you don't want to keep, you
    3.47 -may remove or edit it.
    3.48 -
    3.49 -   The file `configure.ac' (or `configure.in') is used to create
    3.50 -`configure' by a program called `autoconf'.  You need `configure.ac' if
    3.51 -you want to change it or regenerate `configure' using a newer version
    3.52 -of `autoconf'.
    3.53 -
    3.54 -   The simplest way to compile this package is:
    3.55 -
    3.56 -  1. `cd' to the directory containing the package's source code and type
    3.57 -     `./configure' to configure the package for your system.
    3.58 -
    3.59 -     Running `configure' might take a while.  While running, it prints
    3.60 -     some messages telling which features it is checking for.
    3.61 -
    3.62 -  2. Type `make' to compile the package.
    3.63 -
    3.64 -  3. Optionally, type `make check' to run any self-tests that come with
    3.65 -     the package, generally using the just-built uninstalled binaries.
    3.66 -
    3.67 -  4. Type `make install' to install the programs and any data files and
    3.68 -     documentation.  When installing into a prefix owned by root, it is
    3.69 -     recommended that the package be configured and built as a regular
    3.70 -     user, and only the `make install' phase executed with root
    3.71 -     privileges.
    3.72 -
    3.73 -  5. Optionally, type `make installcheck' to repeat any self-tests, but
    3.74 -     this time using the binaries in their final installed location.
    3.75 -     This target does not install anything.  Running this target as a
    3.76 -     regular user, particularly if the prior `make install' required
    3.77 -     root privileges, verifies that the installation completed
    3.78 -     correctly.
    3.79 -
    3.80 -  6. You can remove the program binaries and object files from the
    3.81 -     source code directory by typing `make clean'.  To also remove the
    3.82 -     files that `configure' created (so you can compile the package for
    3.83 -     a different kind of computer), type `make distclean'.  There is
    3.84 -     also a `make maintainer-clean' target, but that is intended mainly
    3.85 -     for the package's developers.  If you use it, you may have to get
    3.86 -     all sorts of other programs in order to regenerate files that came
    3.87 -     with the distribution.
    3.88 -
    3.89 -  7. Often, you can also type `make uninstall' to remove the installed
    3.90 -     files again.  In practice, not all packages have tested that
    3.91 -     uninstallation works correctly, even though it is required by the
    3.92 -     GNU Coding Standards.
    3.93 -
    3.94 -  8. Some packages, particularly those that use Automake, provide `make
    3.95 -     distcheck', which can by used by developers to test that all other
    3.96 -     targets like `make install' and `make uninstall' work correctly.
    3.97 -     This target is generally not run by end users.
    3.98 -
    3.99 -Compilers and Options
   3.100 -=====================
   3.101 -
   3.102 -   Some systems require unusual options for compilation or linking that
   3.103 -the `configure' script does not know about.  Run `./configure --help'
   3.104 -for details on some of the pertinent environment variables.
   3.105 -
   3.106 -   You can give `configure' initial values for configuration parameters
   3.107 -by setting variables in the command line or in the environment.  Here
   3.108 -is an example:
   3.109 -
   3.110 -     ./configure CC=c99 CFLAGS=-g LIBS=-lposix
   3.111 -
   3.112 -   *Note Defining Variables::, for more details.
   3.113 -
   3.114 -Compiling For Multiple Architectures
   3.115 -====================================
   3.116 -
   3.117 -   You can compile the package for more than one kind of computer at the
   3.118 -same time, by placing the object files for each architecture in their
   3.119 -own directory.  To do this, you can use GNU `make'.  `cd' to the
   3.120 -directory where you want the object files and executables to go and run
   3.121 -the `configure' script.  `configure' automatically checks for the
   3.122 -source code in the directory that `configure' is in and in `..'.  This
   3.123 -is known as a "VPATH" build.
   3.124 -
   3.125 -   With a non-GNU `make', it is safer to compile the package for one
   3.126 -architecture at a time in the source code directory.  After you have
   3.127 -installed the package for one architecture, use `make distclean' before
   3.128 -reconfiguring for another architecture.
   3.129 -
   3.130 -   On MacOS X 10.5 and later systems, you can create libraries and
   3.131 -executables that work on multiple system types--known as "fat" or
   3.132 -"universal" binaries--by specifying multiple `-arch' options to the
   3.133 -compiler but only a single `-arch' option to the preprocessor.  Like
   3.134 -this:
   3.135 -
   3.136 -     ./configure CC="gcc -arch i386 -arch x86_64 -arch ppc -arch ppc64" \
   3.137 -                 CXX="g++ -arch i386 -arch x86_64 -arch ppc -arch ppc64" \
   3.138 -                 CPP="gcc -E" CXXCPP="g++ -E"
   3.139 -
   3.140 -   This is not guaranteed to produce working output in all cases, you
   3.141 -may have to build one architecture at a time and combine the results
   3.142 -using the `lipo' tool if you have problems.
   3.143 -
   3.144 -Installation Names
   3.145 -==================
   3.146 -
   3.147 -   By default, `make install' installs the package's commands under
   3.148 -`/usr/local/bin', include files under `/usr/local/include', etc.  You
   3.149 -can specify an installation prefix other than `/usr/local' by giving
   3.150 -`configure' the option `--prefix=PREFIX', where PREFIX must be an
   3.151 -absolute file name.
   3.152 -
   3.153 -   You can specify separate installation prefixes for
   3.154 -architecture-specific files and architecture-independent files.  If you
   3.155 -pass the option `--exec-prefix=PREFIX' to `configure', the package uses
   3.156 -PREFIX as the prefix for installing programs and libraries.
   3.157 -Documentation and other data files still use the regular prefix.
   3.158 -
   3.159 -   In addition, if you use an unusual directory layout you can give
   3.160 -options like `--bindir=DIR' to specify different values for particular
   3.161 -kinds of files.  Run `configure --help' for a list of the directories
   3.162 -you can set and what kinds of files go in them.  In general, the
   3.163 -default for these options is expressed in terms of `${prefix}', so that
   3.164 -specifying just `--prefix' will affect all of the other directory
   3.165 -specifications that were not explicitly provided.
   3.166 -
   3.167 -   The most portable way to affect installation locations is to pass the
   3.168 -correct locations to `configure'; however, many packages provide one or
   3.169 -both of the following shortcuts of passing variable assignments to the
   3.170 -`make install' command line to change installation locations without
   3.171 -having to reconfigure or recompile.
   3.172 -
   3.173 -   The first method involves providing an override variable for each
   3.174 -affected directory.  For example, `make install
   3.175 -prefix=/alternate/directory' will choose an alternate location for all
   3.176 -directory configuration variables that were expressed in terms of
   3.177 -`${prefix}'.  Any directories that were specified during `configure',
   3.178 -but not in terms of `${prefix}', must each be overridden at install
   3.179 -time for the entire installation to be relocated.  The approach of
   3.180 -makefile variable overrides for each directory variable is required by
   3.181 -the GNU Coding Standards, and ideally causes no recompilation.
   3.182 -However, some platforms have known limitations with the semantics of
   3.183 -shared libraries that end up requiring recompilation when using this
   3.184 -method, particularly noticeable in packages that use GNU Libtool.
   3.185 -
   3.186 -   The second method involves providing the `DESTDIR' variable.  For
   3.187 -example, `make install DESTDIR=/alternate/directory' will prepend
   3.188 -`/alternate/directory' before all installation names.  The approach of
   3.189 -`DESTDIR' overrides is not required by the GNU Coding Standards, and
   3.190 -does not work on platforms that have drive letters.  On the other hand,
   3.191 -it does better at avoiding recompilation issues, and works well even
   3.192 -when some directory options were not specified in terms of `${prefix}'
   3.193 -at `configure' time.
   3.194 -
   3.195 -Optional Features
   3.196 -=================
   3.197 -
   3.198 -   If the package supports it, you can cause programs to be installed
   3.199 -with an extra prefix or suffix on their names by giving `configure' the
   3.200 -option `--program-prefix=PREFIX' or `--program-suffix=SUFFIX'.
   3.201 -
   3.202 -   Some packages pay attention to `--enable-FEATURE' options to
   3.203 -`configure', where FEATURE indicates an optional part of the package.
   3.204 -They may also pay attention to `--with-PACKAGE' options, where PACKAGE
   3.205 -is something like `gnu-as' or `x' (for the X Window System).  The
   3.206 -`README' should mention any `--enable-' and `--with-' options that the
   3.207 -package recognizes.
   3.208 -
   3.209 -   For packages that use the X Window System, `configure' can usually
   3.210 -find the X include and library files automatically, but if it doesn't,
   3.211 -you can use the `configure' options `--x-includes=DIR' and
   3.212 -`--x-libraries=DIR' to specify their locations.
   3.213 -
   3.214 -   Some packages offer the ability to configure how verbose the
   3.215 -execution of `make' will be.  For these packages, running `./configure
   3.216 ---enable-silent-rules' sets the default to minimal output, which can be
   3.217 -overridden with `make V=1'; while running `./configure
   3.218 ---disable-silent-rules' sets the default to verbose, which can be
   3.219 -overridden with `make V=0'.
   3.220 -
   3.221 -Particular systems
   3.222 -==================
   3.223 -
   3.224 -   On HP-UX, the default C compiler is not ANSI C compatible.  If GNU
   3.225 -CC is not installed, it is recommended to use the following options in
   3.226 -order to use an ANSI C compiler:
   3.227 -
   3.228 -     ./configure CC="cc -Ae -D_XOPEN_SOURCE=500"
   3.229 -
   3.230 -and if that doesn't work, install pre-built binaries of GCC for HP-UX.
   3.231 -
   3.232 -   On OSF/1 a.k.a. Tru64, some versions of the default C compiler cannot
   3.233 -parse its `<wchar.h>' header file.  The option `-nodtk' can be used as
   3.234 -a workaround.  If GNU CC is not installed, it is therefore recommended
   3.235 -to try
   3.236 -
   3.237 -     ./configure CC="cc"
   3.238 -
   3.239 -and if that doesn't work, try
   3.240 -
   3.241 -     ./configure CC="cc -nodtk"
   3.242 -
   3.243 -   On Solaris, don't put `/usr/ucb' early in your `PATH'.  This
   3.244 -directory contains several dysfunctional programs; working variants of
   3.245 -these programs are available in `/usr/bin'.  So, if you need `/usr/ucb'
   3.246 -in your `PATH', put it _after_ `/usr/bin'.
   3.247 -
   3.248 -   On Haiku, software installed for all users goes in `/boot/common',
   3.249 -not `/usr/local'.  It is recommended to use the following options:
   3.250 -
   3.251 -     ./configure --prefix=/boot/common
   3.252 -
   3.253 -Specifying the System Type
   3.254 -==========================
   3.255 -
   3.256 -   There may be some features `configure' cannot figure out
   3.257 -automatically, but needs to determine by the type of machine the package
   3.258 -will run on.  Usually, assuming the package is built to be run on the
   3.259 -_same_ architectures, `configure' can figure that out, but if it prints
   3.260 -a message saying it cannot guess the machine type, give it the
   3.261 -`--build=TYPE' option.  TYPE can either be a short name for the system
   3.262 -type, such as `sun4', or a canonical name which has the form:
   3.263 -
   3.264 -     CPU-COMPANY-SYSTEM
   3.265 -
   3.266 -where SYSTEM can have one of these forms:
   3.267 -
   3.268 -     OS
   3.269 -     KERNEL-OS
   3.270 -
   3.271 -   See the file `config.sub' for the possible values of each field.  If
   3.272 -`config.sub' isn't included in this package, then this package doesn't
   3.273 -need to know the machine type.
   3.274 -
   3.275 -   If you are _building_ compiler tools for cross-compiling, you should
   3.276 -use the option `--target=TYPE' to select the type of system they will
   3.277 -produce code for.
   3.278 -
   3.279 -   If you want to _use_ a cross compiler, that generates code for a
   3.280 -platform different from the build platform, you should specify the
   3.281 -"host" platform (i.e., that on which the generated programs will
   3.282 -eventually be run) with `--host=TYPE'.
   3.283 -
   3.284 -Sharing Defaults
   3.285 -================
   3.286 -
   3.287 -   If you want to set default values for `configure' scripts to share,
   3.288 -you can create a site shell script called `config.site' that gives
   3.289 -default values for variables like `CC', `cache_file', and `prefix'.
   3.290 -`configure' looks for `PREFIX/share/config.site' if it exists, then
   3.291 -`PREFIX/etc/config.site' if it exists.  Or, you can set the
   3.292 -`CONFIG_SITE' environment variable to the location of the site script.
   3.293 -A warning: not all `configure' scripts look for a site script.
   3.294 -
   3.295 -Defining Variables
   3.296 -==================
   3.297 -
   3.298 -   Variables not defined in a site shell script can be set in the
   3.299 -environment passed to `configure'.  However, some packages may run
   3.300 -configure again during the build, and the customized values of these
   3.301 -variables may be lost.  In order to avoid this problem, you should set
   3.302 -them in the `configure' command line, using `VAR=value'.  For example:
   3.303 -
   3.304 -     ./configure CC=/usr/local2/bin/gcc
   3.305 -
   3.306 -causes the specified `gcc' to be used as the C compiler (unless it is
   3.307 -overridden in the site shell script).
   3.308 -
   3.309 -Unfortunately, this technique does not work for `CONFIG_SHELL' due to
   3.310 -an Autoconf bug.  Until the bug is fixed you can use this workaround:
   3.311 -
   3.312 -     CONFIG_SHELL=/bin/bash /bin/bash ./configure CONFIG_SHELL=/bin/bash
   3.313 -
   3.314 -`configure' Invocation
   3.315 -======================
   3.316 -
   3.317 -   `configure' recognizes the following options to control how it
   3.318 -operates.
   3.319 -
   3.320 -`--help'
   3.321 -`-h'
   3.322 -     Print a summary of all of the options to `configure', and exit.
   3.323 -
   3.324 -`--help=short'
   3.325 -`--help=recursive'
   3.326 -     Print a summary of the options unique to this package's
   3.327 -     `configure', and exit.  The `short' variant lists options used
   3.328 -     only in the top level, while the `recursive' variant lists options
   3.329 -     also present in any nested packages.
   3.330 -
   3.331 -`--version'
   3.332 -`-V'
   3.333 -     Print the version of Autoconf used to generate the `configure'
   3.334 -     script, and exit.
   3.335 -
   3.336 -`--cache-file=FILE'
   3.337 -     Enable the cache: use and save the results of the tests in FILE,
   3.338 -     traditionally `config.cache'.  FILE defaults to `/dev/null' to
   3.339 -     disable caching.
   3.340 -
   3.341 -`--config-cache'
   3.342 -`-C'
   3.343 -     Alias for `--cache-file=config.cache'.
   3.344 -
   3.345 -`--quiet'
   3.346 -`--silent'
   3.347 -`-q'
   3.348 -     Do not print messages saying which checks are being made.  To
   3.349 -     suppress all normal output, redirect it to `/dev/null' (any error
   3.350 -     messages will still be shown).
   3.351 -
   3.352 -`--srcdir=DIR'
   3.353 -     Look for the package's source code in directory DIR.  Usually
   3.354 -     `configure' can determine that directory automatically.
   3.355 -
   3.356 -`--prefix=DIR'
   3.357 -     Use DIR as the installation prefix.  *note Installation Names::
   3.358 -     for more details, including other options available for fine-tuning
   3.359 -     the installation locations.
   3.360 -
   3.361 -`--no-create'
   3.362 -`-n'
   3.363 -     Run the configure checks, but stop before creating any output
   3.364 -     files.
   3.365 -
   3.366 -`configure' also accepts some other, not widely useful, options.  Run
   3.367 -`configure --help' for more details.
   3.368 -

     4.1 --- a/configure.ac	Sat Mar 03 12:06:10 2012 -0600
     4.2 +++ b/configure.ac	Sun Mar 04 14:33:52 2012 -0600
     4.3 @@ -2,6 +2,10 @@
     4.4  
     4.5  AC_INIT([vba-rlm], [1.0])
     4.6  
     4.7 +AC_CONFIG_AUX_DIR([build-aux])
     4.8 +
     4.9 +AM_INIT_AUTOMAKE([foreign dist-bzip2])
    4.10 +
    4.11  dnl TODO: change this to gba.cpp or something
    4.12  AC_CONFIG_SRCDIR([src/lua/lopcodes.c])
    4.13  AC_CONFIG_HEADERS([config.h])
    4.14 @@ -12,6 +16,17 @@
    4.15  AC_PROG_CC
    4.16  AC_PROG_RANLIB
    4.17  
    4.18 +
    4.19 +
    4.20 +# SDL stuff 
    4.21 +SDL_VERSION=1.2.2
    4.22 +AM_PATH_SDL($SDL_VERSION,[
    4.23 +],[
    4.24 +AC_MSG_ERROR([*** Couldn't find SDL library (version >= $SDL_VERSION).])
    4.25 +])
    4.26 +
    4.27 +
    4.28 +
    4.29  # Checks for header files.
    4.30  AC_CHECK_HEADERS([limits.h locale.h stddef.h stdlib.h string.h unistd.h])
    4.31  
    4.32 @@ -35,9 +50,11 @@
    4.33  AC_CONFIG_FILES([Makefile 
    4.34  	         src/Makefile
    4.35                   src/lua/Makefile
    4.36 -		 src/gb/Makefile])
    4.37 +		 src/gb/Makefile
    4.38 +		 src/gba/Makefile
    4.39 +		 src/common/Makefile])
    4.40  
    4.41 -AM_INIT_AUTOMAKE([dist-bzip2])
    4.42 +
    4.43  
    4.44  AC_OUTPUT
    4.45  

     5.1 --- a/src/Makefile.am	Sat Mar 03 12:06:10 2012 -0600
     5.2 +++ b/src/Makefile.am	Sun Mar 04 14:33:52 2012 -0600
     5.3 @@ -1,1 +1,1 @@
     5.4 -SUBDIRS = lua gb
     5.5 +SUBDIRS = lua gb gba common

     6.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     6.2 +++ b/src/NLS.h	Sun Mar 04 14:33:52 2012 -0600
     6.3 @@ -0,0 +1,52 @@
     6.4 +#ifndef VBS_NLS_H
     6.5 +#define VBA_NLS_H
     6.6 +
     6.7 +#if _MSC_VER > 1000
     6.8 +#pragma once
     6.9 +#endif // _MSC_VER > 1000
    6.10 +
    6.11 +#define N_(String) (String)
    6.12 +
    6.13 +#define MSG_UNSUPPORTED_VBA_SGM             1
    6.14 +#define MSG_CANNOT_LOAD_SGM                 2
    6.15 +#define MSG_SAVE_GAME_NOT_USING_BIOS        3
    6.16 +#define MSG_SAVE_GAME_USING_BIOS            4
    6.17 +#define MSG_UNSUPPORTED_SAVE_TYPE           5
    6.18 +#define MSG_CANNOT_OPEN_FILE                6
    6.19 +#define MSG_BAD_ZIP_FILE                    7
    6.20 +#define MSG_NO_IMAGE_ON_ZIP                 8
    6.21 +#define MSG_ERROR_OPENING_IMAGE             9
    6.22 +#define MSG_ERROR_READING_IMAGE            10
    6.23 +#define MSG_UNSUPPORTED_BIOS_FUNCTION      11
    6.24 +#define MSG_INVALID_BIOS_FILE_SIZE         12
    6.25 +#define MSG_INVALID_CHEAT_CODE             13
    6.26 +#define MSG_UNKNOWN_ARM_OPCODE             14
    6.27 +#define MSG_UNKNOWN_THUMB_OPCODE           15
    6.28 +#define MSG_ERROR_CREATING_FILE            16
    6.29 +#define MSG_FAILED_TO_READ_SGM             17
    6.30 +#define MSG_FAILED_TO_READ_RTC             18
    6.31 +#define MSG_UNSUPPORTED_VB_SGM             19
    6.32 +#define MSG_CANNOT_LOAD_SGM_FOR            20
    6.33 +#define MSG_ERROR_OPENING_IMAGE_FROM       21
    6.34 +#define MSG_ERROR_READING_IMAGE_FROM       22
    6.35 +#define MSG_UNSUPPORTED_ROM_SIZE           23
    6.36 +#define MSG_UNSUPPORTED_RAM_SIZE           24
    6.37 +#define MSG_UNKNOWN_CARTRIDGE_TYPE         25
    6.38 +#define MSG_MAXIMUM_NUMBER_OF_CHEATS       26
    6.39 +#define MSG_INVALID_GAMESHARK_CODE         27
    6.40 +#define MSG_INVALID_GAMEGENIE_CODE         28
    6.41 +#define MSG_INVALID_CHEAT_TO_REMOVE        29
    6.42 +#define MSG_INVALID_CHEAT_CODE_ADDRESS     30
    6.43 +#define MSG_UNSUPPORTED_CHEAT_LIST_VERSION 31
    6.44 +#define MSG_UNSUPPORTED_CHEAT_LIST_TYPE    32
    6.45 +#define MSG_INVALID_GSA_CODE               33
    6.46 +#define MSG_CANNOT_IMPORT_SNAPSHOT_FOR     34
    6.47 +#define MSG_UNSUPPORTED_SNAPSHOT_FILE      35
    6.48 +#define MSG_UNSUPPORTED_ARM_MODE           36
    6.49 +#define MSG_UNSUPPORTED_CODE_FILE          37
    6.50 +#define MSG_GBA_CODE_WARNING               38
    6.51 +#define MSG_INVALID_CBA_CODE               39
    6.52 +#define MSG_CBA_CODE_WARNING               40
    6.53 +#define MSG_OUT_OF_MEMORY                  41
    6.54 +
    6.55 +#endif // VBA_NLS_H

     7.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     7.2 +++ b/src/Port.h	Sun Mar 04 14:33:52 2012 -0600
     7.3 @@ -0,0 +1,178 @@
     7.4 +#ifndef VBA_PORT_H
     7.5 +#define VBA_PORT_H
     7.6 +
     7.7 +#if _MSC_VER > 1000
     7.8 +#pragma once
     7.9 +#endif // _MSC_VER > 1000
    7.10 +
    7.11 +#include <ctime>
    7.12 +
    7.13 +#ifndef NULL
    7.14 +#define NULL 0
    7.15 +#endif
    7.16 +
    7.17 +typedef unsigned char bool8;
    7.18 +
    7.19 +#ifdef HAVE_STDINT_H
    7.20 +#include <stdint.h>
    7.21 +
    7.22 +typedef int8_t   int8;
    7.23 +typedef uint8_t  uint8;
    7.24 +typedef int16_t  int16;
    7.25 +typedef uint16_t uint16;
    7.26 +typedef int32_t  int32;
    7.27 +typedef uint32_t uint32;
    7.28 +typedef int64_t  int64;
    7.29 +typedef uint64_t uint64;
    7.30 +typedef intptr_t pint;
    7.31 +
    7.32 +#else /* Don't have stdint.h */
    7.33 +
    7.34 +#ifdef PTR_NOT_INT
    7.35 +typedef long pint;
    7.36 +#else /* pointer is int */
    7.37 +typedef int pint;
    7.38 +#endif /* PTR_NOT_INT */
    7.39 +
    7.40 +/* FIXME: Refactor this by moving out the BORLAND part and unifying typedefs */
    7.41 +#ifndef WIN32
    7.42 +typedef unsigned char  uint8;
    7.43 +typedef unsigned short uint16;
    7.44 +typedef signed char    int8;
    7.45 +typedef short          int16;
    7.46 +typedef int            int32;
    7.47 +typedef unsigned int   uint32;
    7.48 +# ifdef __GNUC__  /* long long is not part of ISO C++ */
    7.49 +__extension__ typedef long long          int64;
    7.50 +__extension__ typedef unsigned long long uint64;
    7.51 +# else
    7.52 +typedef long long          int64;
    7.53 +typedef unsigned long long uint64;
    7.54 +# endif
    7.55 +#else /* WIN32 */
    7.56 +
    7.57 +# ifdef __BORLANDC__
    7.58 +#   include <systypes.h>
    7.59 +# else
    7.60 +
    7.61 +typedef unsigned char  uint8;
    7.62 +typedef unsigned short uint16;
    7.63 +typedef signed char    int8;
    7.64 +typedef short          int16;
    7.65 +
    7.66 +# ifndef WSAAPI
    7.67 +/* winsock2.h typedefs int32 as well. */
    7.68 +typedef long int32;
    7.69 +# endif
    7.70 +
    7.71 +typedef unsigned int uint32;
    7.72 +
    7.73 +# endif /* __BORLANDC__ */
    7.74 +
    7.75 +typedef __int64          int64;
    7.76 +typedef unsigned __int64 uint64;
    7.77 +
    7.78 +#endif /* WIN32 */
    7.79 +#endif /* HAVE_STDINT_H */
    7.80 +
    7.81 +#ifndef WIN32
    7.82 +
    7.83 +#ifndef PATH_MAX
    7.84 +#define PATH_MAX 1024
    7.85 +#endif
    7.86 +
    7.87 +#define _MAX_DIR PATH_MAX
    7.88 +#define _MAX_DRIVE 1
    7.89 +#define _MAX_FNAME PATH_MAX
    7.90 +#define _MAX_EXT PATH_MAX
    7.91 +#define _MAX_PATH PATH_MAX
    7.92 +
    7.93 +#define ZeroMemory(a, b) memset((a), 0, (b))
    7.94 +
    7.95 +void _makepath(char *path, const char *drive, const char *dir,
    7.96 +               const char *fname, const char *ext);
    7.97 +void _splitpath(const char *path, char *drive, char *dir, char *fname,
    7.98 +                char *ext);
    7.99 +#else /* WIN32 */
   7.100 +#define strcasecmp stricmp
   7.101 +#define strncasecmp strnicmp
   7.102 +#endif
   7.103 +
   7.104 +typedef uint8  u8;
   7.105 +typedef uint16 u16;
   7.106 +typedef uint32 u32;
   7.107 +typedef uint64 u64;
   7.108 +typedef int8   s8;
   7.109 +typedef int16  s16;
   7.110 +typedef int32  s32;
   7.111 +typedef int64  s64;
   7.112 +
   7.113 +// for consistency
   7.114 +static inline u8 swap8(u8 v)
   7.115 +{
   7.116 +	return v;
   7.117 +}
   7.118 +
   7.119 +// swaps a 16-bit value
   7.120 +static inline u16 swap16(u16 v)
   7.121 +{
   7.122 +	return (v<<8)|(v>>8);
   7.123 +}
   7.124 +
   7.125 +// swaps a 32-bit value
   7.126 +static inline u32 swap32(u32 v)
   7.127 +{
   7.128 +	return (v<<24)|((v<<8)&0xff0000)|((v>>8)&0xff00)|(v>>24);
   7.129 +}
   7.130 +
   7.131 +#define READ8LE(x) \
   7.132 +    *((u8 *)x)
   7.133 +
   7.134 +#define WRITE8LE(x, v) \
   7.135 +    *((u8 *)x) = (v)
   7.136 +
   7.137 +#ifdef WORDS_BIGENDIAN
   7.138 +#if defined(__GNUC__) && defined(__ppc__)
   7.139 +
   7.140 +#define READ16LE(base) \
   7.141 +    ({ unsigned short lhbrxResult;       \
   7.142 +       __asm__("lhbrx %0, 0, %1" : "=r" (lhbrxResult) : "r" (base) : "memory"); \
   7.143 +       lhbrxResult; })
   7.144 +
   7.145 +#define READ32LE(base) \
   7.146 +    ({ unsigned long lwbrxResult; \
   7.147 +       __asm__("lwbrx %0, 0, %1" : "=r" (lwbrxResult) : "r" (base) : "memory"); \
   7.148 +       lwbrxResult; })
   7.149 +
   7.150 +#define WRITE16LE(base, value) \
   7.151 +    __asm__("sthbrx %0, 0, %1" : : "r" (value), "r" (base) : "memory")
   7.152 +
   7.153 +#define WRITE32LE(base, value) \
   7.154 +    __asm__("stwbrx %0, 0, %1" : : "r" (value), "r" (base) : "memory")
   7.155 +
   7.156 +#else
   7.157 +#define READ16LE(x) \
   7.158 +    swap16(*((u16 *)(x)))
   7.159 +#define READ32LE(x) \
   7.160 +    swap32(*((u32 *)(x)))
   7.161 +#define WRITE16LE(x, v) \
   7.162 +    *((u16 *)x) = swap16((v))
   7.163 +#define WRITE32LE(x, v) \
   7.164 +    *((u32 *)x) = swap32((v))
   7.165 +#endif
   7.166 +#else
   7.167 +#define READ16LE(x) \
   7.168 +    *((u16 *)x)
   7.169 +#define READ32LE(x) \
   7.170 +    *((u32 *)x)
   7.171 +#define WRITE16LE(x, v) \
   7.172 +    *((u16 *)x) = (v)
   7.173 +#define WRITE32LE(x, v) \
   7.174 +    *((u32 *)x) = (v)
   7.175 +#endif
   7.176 +
   7.177 +#ifndef CTASSERT
   7.178 +#define CTASSERT(x)  typedef char __assert ## y[(x) ? 1 : -1];
   7.179 +#endif
   7.180 +
   7.181 +#endif // VBA_PORT_H

     8.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     8.2 +++ b/src/common/CheatSearch.cpp	Sun Mar 04 14:33:52 2012 -0600
     8.3 @@ -0,0 +1,371 @@
     8.4 +#include <cstdlib>
     8.5 +#include <cstring>
     8.6 +
     8.7 +#include "CheatSearch.h"
     8.8 +
     8.9 +CheatSearchBlock cheatSearchBlocks[4];
    8.10 +
    8.11 +CheatSearchData cheatSearchData = {
    8.12 +	0,
    8.13 +	cheatSearchBlocks
    8.14 +};
    8.15 +
    8.16 +static bool cheatSearchEQ(u32 a, u32 b)
    8.17 +{
    8.18 +	return a == b;
    8.19 +}
    8.20 +
    8.21 +static bool cheatSearchNE(u32 a, u32 b)
    8.22 +{
    8.23 +	return a != b;
    8.24 +}
    8.25 +
    8.26 +static bool cheatSearchLT(u32 a, u32 b)
    8.27 +{
    8.28 +	return a < b;
    8.29 +}
    8.30 +
    8.31 +static bool cheatSearchLE(u32 a, u32 b)
    8.32 +{
    8.33 +	return a <= b;
    8.34 +}
    8.35 +
    8.36 +static bool cheatSearchGT(u32 a, u32 b)
    8.37 +{
    8.38 +	return a > b;
    8.39 +}
    8.40 +
    8.41 +static bool cheatSearchGE(u32 a, u32 b)
    8.42 +{
    8.43 +	return a >= b;
    8.44 +}
    8.45 +
    8.46 +static bool cheatSearchSignedEQ(s32 a, s32 b)
    8.47 +{
    8.48 +	return a == b;
    8.49 +}
    8.50 +
    8.51 +static bool cheatSearchSignedNE(s32 a, s32 b)
    8.52 +{
    8.53 +	return a != b;
    8.54 +}
    8.55 +
    8.56 +static bool cheatSearchSignedLT(s32 a, s32 b)
    8.57 +{
    8.58 +	return a < b;
    8.59 +}
    8.60 +
    8.61 +static bool cheatSearchSignedLE(s32 a, s32 b)
    8.62 +{
    8.63 +	return a <= b;
    8.64 +}
    8.65 +
    8.66 +static bool cheatSearchSignedGT(s32 a, s32 b)
    8.67 +{
    8.68 +	return a > b;
    8.69 +}
    8.70 +
    8.71 +static bool cheatSearchSignedGE(s32 a, s32 b)
    8.72 +{
    8.73 +	return a >= b;
    8.74 +}
    8.75 +
    8.76 +static bool (*cheatSearchFunc[])(u32, u32) = {
    8.77 +	cheatSearchEQ,
    8.78 +	cheatSearchNE,
    8.79 +	cheatSearchLT,
    8.80 +	cheatSearchLE,
    8.81 +	cheatSearchGT,
    8.82 +	cheatSearchGE
    8.83 +};
    8.84 +
    8.85 +static bool (*cheatSearchSignedFunc[])(s32, s32) = {
    8.86 +	cheatSearchSignedEQ,
    8.87 +	cheatSearchSignedNE,
    8.88 +	cheatSearchSignedLT,
    8.89 +	cheatSearchSignedLE,
    8.90 +	cheatSearchSignedGT,
    8.91 +	cheatSearchSignedGE
    8.92 +};
    8.93 +
    8.94 +void cheatSearchSetSavedAndBits(CheatSearchBlock *block)
    8.95 +{
    8.96 +	if (!block->saved)
    8.97 +	{
    8.98 +		block->saved = (u8 *)malloc(block->size);
    8.99 +		memcpy(block->saved, block->data, block->size);
   8.100 +	}
   8.101 +	if (!block->bits)
   8.102 +	{
   8.103 +		block->bits  = (u8 *)malloc(block->size >> 3);
   8.104 +		memset(block->bits, 0xff, block->size >> 3);
   8.105 +	}
   8.106 +}
   8.107 +
   8.108 +void cheatSearchZeroBlock(CheatSearchBlock *block)
   8.109 +{
   8.110 +	block->data	  = 0;
   8.111 +	block->offset = 0;
   8.112 +	block->size	  = 0;
   8.113 +	free(block->saved);
   8.114 +	free(block->bits);
   8.115 +	block->saved  = 0;
   8.116 +	block->bits	  = 0;
   8.117 +}
   8.118 +
   8.119 +void cheatSearchCleanup(CheatSearchData *cs)
   8.120 +{
   8.121 +	int count = cs->count;
   8.122 +
   8.123 +	for (int i = 0; i < count; i++)
   8.124 +	{
   8.125 +		CheatSearchBlock &block = cs->blocks[i];
   8.126 +		free(block.saved);
   8.127 +		free(block.bits);
   8.128 +		block.saved = 0;
   8.129 +		block.bits  = 0;
   8.130 +	}
   8.131 +	cs->count = 0;
   8.132 +}
   8.133 +
   8.134 +void cheatSearchStart(const CheatSearchData *cs)
   8.135 +{
   8.136 +	int count = cs->count;
   8.137 +
   8.138 +	for (int i = 0; i < count; i++)
   8.139 +	{
   8.140 +		CheatSearchBlock *block = &cs->blocks[i];
   8.141 +
   8.142 +		memset(block->bits, 0xff, block->size >> 3);
   8.143 +		memcpy(block->saved, block->data, block->size);
   8.144 +	}
   8.145 +}
   8.146 +
   8.147 +s32 cheatSearchSignedRead(u8 *data, int off, int size)
   8.148 +{
   8.149 +	u32 res = data[off++];
   8.150 +
   8.151 +	switch (size)
   8.152 +	{
   8.153 +	case BITS_8:
   8.154 +		res <<= 24;
   8.155 +		return ((s32)res) >> 24;
   8.156 +	case BITS_16:
   8.157 +		res  |= ((u32)data[off++])<<8;
   8.158 +		res <<= 16;
   8.159 +		return ((s32)res) >> 16;
   8.160 +	case BITS_32:
   8.161 +		res |= ((u32)data[off++])<<8;
   8.162 +		res |= ((u32)data[off++])<<16;
   8.163 +		res |= ((u32)data[off++])<<24;
   8.164 +		return (s32)res;
   8.165 +	}
   8.166 +	return (s32)res;
   8.167 +}
   8.168 +
   8.169 +u32 cheatSearchRead(u8 *data, int off, int size)
   8.170 +{
   8.171 +	u32 res = data[off++];
   8.172 +	if (size == BITS_16)
   8.173 +		res |= ((u32)data[off++])<<8;
   8.174 +	else if (size == BITS_32)
   8.175 +	{
   8.176 +		res |= ((u32)data[off++])<<8;
   8.177 +		res |= ((u32)data[off++])<<16;
   8.178 +		res |= ((u32)data[off++])<<24;
   8.179 +	}
   8.180 +	return res;
   8.181 +}
   8.182 +
   8.183 +void cheatSearch(const CheatSearchData *cs, int compare, int size,
   8.184 +                 bool isSigned)
   8.185 +{
   8.186 +	if (compare < 0 || compare > SEARCH_GE)
   8.187 +		return;
   8.188 +	int inc = 1;
   8.189 +	if (size == BITS_16)
   8.190 +		inc = 2;
   8.191 +	else if (size == BITS_32)
   8.192 +		inc = 4;
   8.193 +
   8.194 +	if (isSigned)
   8.195 +	{
   8.196 +		bool (*func)(s32, s32) = cheatSearchSignedFunc[compare];
   8.197 +
   8.198 +		for (int i = 0; i < cs->count; i++)
   8.199 +		{
   8.200 +			CheatSearchBlock *block = &cs->blocks[i];
   8.201 +			int size2 = block->size;
   8.202 +			u8 *bits  = block->bits;
   8.203 +			u8 *data  = block->data;
   8.204 +			u8 *saved = block->saved;
   8.205 +
   8.206 +			for (int j = 0; j < size2; j += inc)
   8.207 +			{
   8.208 +				if (IS_BIT_SET(bits, j))
   8.209 +				{
   8.210 +					s32 a = cheatSearchSignedRead(data, j, size);
   8.211 +					s32 b = cheatSearchSignedRead(saved, j, size);
   8.212 +
   8.213 +					if (!func(a, b))
   8.214 +					{
   8.215 +						CLEAR_BIT(bits, j);
   8.216 +						if (size == BITS_16)
   8.217 +							CLEAR_BIT(bits, j+1);
   8.218 +						if (size == BITS_32)
   8.219 +						{
   8.220 +							CLEAR_BIT(bits, j+2);
   8.221 +							CLEAR_BIT(bits, j+3);
   8.222 +						}
   8.223 +					}
   8.224 +				}
   8.225 +			}
   8.226 +		}
   8.227 +	}
   8.228 +	else
   8.229 +	{
   8.230 +		bool (*func)(u32, u32) = cheatSearchFunc[compare];
   8.231 +
   8.232 +		for (int i = 0; i < cs->count; i++)
   8.233 +		{
   8.234 +			CheatSearchBlock *block = &cs->blocks[i];
   8.235 +			int size2 = block->size;
   8.236 +			u8 *bits  = block->bits;
   8.237 +			u8 *data  = block->data;
   8.238 +			u8 *saved = block->saved;
   8.239 +
   8.240 +			for (int j = 0; j < size2; j += inc)
   8.241 +			{
   8.242 +				if (IS_BIT_SET(bits, j))
   8.243 +				{
   8.244 +					u32 a = cheatSearchRead(data, j, size);
   8.245 +					u32 b = cheatSearchRead(saved, j, size);
   8.246 +
   8.247 +					if (!func(a, b))
   8.248 +					{
   8.249 +						CLEAR_BIT(bits, j);
   8.250 +						if (size == BITS_16)
   8.251 +							CLEAR_BIT(bits, j+1);
   8.252 +						if (size == BITS_32)
   8.253 +						{
   8.254 +							CLEAR_BIT(bits, j+2);
   8.255 +							CLEAR_BIT(bits, j+3);
   8.256 +						}
   8.257 +					}
   8.258 +				}
   8.259 +			}
   8.260 +		}
   8.261 +	}
   8.262 +}
   8.263 +
   8.264 +void cheatSearchValue(const CheatSearchData *cs, int compare, int size,
   8.265 +                      bool isSigned, u32 value)
   8.266 +{
   8.267 +	if (compare < 0 || compare > SEARCH_GE)
   8.268 +		return;
   8.269 +	int inc = 1;
   8.270 +	if (size == BITS_16)
   8.271 +		inc = 2;
   8.272 +	else if (size == BITS_32)
   8.273 +		inc = 4;
   8.274 +
   8.275 +	if (isSigned)
   8.276 +	{
   8.277 +		bool (*func)(s32, s32) = cheatSearchSignedFunc[compare];
   8.278 +
   8.279 +		for (int i = 0; i < cs->count; i++)
   8.280 +		{
   8.281 +			CheatSearchBlock *block = &cs->blocks[i];
   8.282 +			int size2 = block->size;
   8.283 +			u8 *bits  = block->bits;
   8.284 +			u8 *data  = block->data;
   8.285 +
   8.286 +			for (int j = 0; j < size2; j += inc)
   8.287 +			{
   8.288 +				if (IS_BIT_SET(bits, j))
   8.289 +				{
   8.290 +					s32 a = cheatSearchSignedRead(data, j, size);
   8.291 +					s32 b = (s32)value;
   8.292 +
   8.293 +					if (!func(a, b))
   8.294 +					{
   8.295 +						CLEAR_BIT(bits, j);
   8.296 +						if (size == BITS_16)
   8.297 +							CLEAR_BIT(bits, j+1);
   8.298 +						if (size == BITS_32)
   8.299 +						{
   8.300 +							CLEAR_BIT(bits, j+2);
   8.301 +							CLEAR_BIT(bits, j+3);
   8.302 +						}
   8.303 +					}
   8.304 +				}
   8.305 +			}
   8.306 +		}
   8.307 +	}
   8.308 +	else
   8.309 +	{
   8.310 +		bool (*func)(u32, u32) = cheatSearchFunc[compare];
   8.311 +
   8.312 +		for (int i = 0; i < cs->count; i++)
   8.313 +		{
   8.314 +			CheatSearchBlock *block = &cs->blocks[i];
   8.315 +			int size2 = block->size;
   8.316 +			u8 *bits  = block->bits;
   8.317 +			u8 *data  = block->data;
   8.318 +
   8.319 +			for (int j = 0; j < size2; j += inc)
   8.320 +			{
   8.321 +				if (IS_BIT_SET(bits, j))
   8.322 +				{
   8.323 +					u32 a = cheatSearchRead(data, j, size);
   8.324 +
   8.325 +					if (!func(a, value))
   8.326 +					{
   8.327 +						CLEAR_BIT(bits, j);
   8.328 +						if (size == BITS_16)
   8.329 +							CLEAR_BIT(bits, j+1);
   8.330 +						if (size == BITS_32)
   8.331 +						{
   8.332 +							CLEAR_BIT(bits, j+2);
   8.333 +							CLEAR_BIT(bits, j+3);
   8.334 +						}
   8.335 +					}
   8.336 +				}
   8.337 +			}
   8.338 +		}
   8.339 +	}
   8.340 +}
   8.341 +
   8.342 +int cheatSearchGetCount(const CheatSearchData *cs, int size)
   8.343 +{
   8.344 +	int res = 0;
   8.345 +	int inc = 1;
   8.346 +	if (size == BITS_16)
   8.347 +		inc = 2;
   8.348 +	else if (size == BITS_32)
   8.349 +		inc = 4;
   8.350 +
   8.351 +	for (int i = 0; i < cs->count; i++)
   8.352 +	{
   8.353 +		CheatSearchBlock *block = &cs->blocks[i];
   8.354 +
   8.355 +		int size2 = block->size;
   8.356 +		u8 *bits  = block->bits;
   8.357 +		for (int j = 0; j < size2; j += inc)
   8.358 +		{
   8.359 +			if (IS_BIT_SET(bits, j))
   8.360 +				res++;
   8.361 +		}
   8.362 +	}
   8.363 +	return res;
   8.364 +}
   8.365 +
   8.366 +void cheatSearchUpdateValues(const CheatSearchData *cs)
   8.367 +{
   8.368 +	for (int i = 0; i < cs->count; i++)
   8.369 +	{
   8.370 +		CheatSearchBlock *block = &cs->blocks[i];
   8.371 +
   8.372 +		memcpy(block->saved, block->data, block->size);
   8.373 +	}
   8.374 +}

     9.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     9.2 +++ b/src/common/CheatSearch.h	Sun Mar 04 14:33:52 2012 -0600
     9.3 @@ -0,0 +1,65 @@
     9.4 +#ifndef VBA_CHEATSEARCH_H
     9.5 +#define VBA_CHEATSEARCH_H
     9.6 +
     9.7 +#if _MSC_VER > 1000
     9.8 +#pragma once
     9.9 +#endif // _MSC_VER > 1000
    9.10 +
    9.11 +#include "../Port.h"
    9.12 +
    9.13 +struct CheatSearchBlock
    9.14 +{
    9.15 +	u8 *data;
    9.16 +	int size;
    9.17 +	u32 offset;
    9.18 +	u8 *saved;
    9.19 +	u8 *bits;
    9.20 +};
    9.21 +
    9.22 +struct CheatSearchData
    9.23 +{
    9.24 +	int count;
    9.25 +	CheatSearchBlock *blocks;
    9.26 +};
    9.27 +
    9.28 +enum
    9.29 +{
    9.30 +	SEARCH_EQ,
    9.31 +	SEARCH_NE,
    9.32 +	SEARCH_LT,
    9.33 +	SEARCH_LE,
    9.34 +	SEARCH_GT,
    9.35 +	SEARCH_GE
    9.36 +};
    9.37 +
    9.38 +enum
    9.39 +{
    9.40 +	BITS_8,
    9.41 +	BITS_16,
    9.42 +	BITS_32
    9.43 +};
    9.44 +
    9.45 +#define SET_BIT(bits, off) \
    9.46 +    (bits)[(off) >> 3] |= (1 << ((off) & 7))
    9.47 +
    9.48 +#define CLEAR_BIT(bits, off) \
    9.49 +    (bits)[(off) >> 3] &= ~(1 << ((off) & 7))
    9.50 +
    9.51 +#define IS_BIT_SET(bits, off) \
    9.52 +    (bits)[(off) >> 3] & (1 << ((off) & 7))
    9.53 +
    9.54 +extern CheatSearchData cheatSearchData;
    9.55 +extern void cheatSearchSetSavedAndBits(CheatSearchBlock *block);
    9.56 +extern void cheatSearchZeroBlock(CheatSearchBlock *block);
    9.57 +extern void cheatSearchCleanup(CheatSearchData *cs);
    9.58 +extern void cheatSearchStart(const CheatSearchData *cs);
    9.59 +extern void cheatSearch(const CheatSearchData *cs, int compare, int size,
    9.60 +                        bool isSigned);
    9.61 +extern void cheatSearchValue(const CheatSearchData *cs, int compare, int size,
    9.62 +                             bool isSigned, u32 value);
    9.63 +extern int cheatSearchGetCount(const CheatSearchData *cs, int size);
    9.64 +extern void cheatSearchUpdateValues(const CheatSearchData *cs);
    9.65 +extern s32 cheatSearchSignedRead(u8 *data, int off, int size);
    9.66 +extern u32 cheatSearchRead(u8 *data, int off, int size);
    9.67 +
    9.68 +#endif // VBA_CHEATSEARCH_H

    10.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    10.2 +++ b/src/common/Makefile.am	Sun Mar 04 14:33:52 2012 -0600
    10.3 @@ -0,0 +1,31 @@
    10.4 +noinst_LIBRARIES = libgbcom.a
    10.5 +
    10.6 +libgbcom_a_SOURCES = \
    10.7 +	CheatSearch.h		\
    10.8 +	inputGlobal.h		\
    10.9 +	memgzio.h		\
   10.10 +	movie.h			\
   10.11 +	nesvideos-piece.h	\
   10.12 +	System.h		\
   10.13 +	Text.h			\
   10.14 +	unzip.h			\
   10.15 +	Util.h			\
   10.16 +	vbalua.h		\
   10.17 +				\
   10.18 +	CheatSearch.cpp		\
   10.19 +	lua-engine.cpp		\
   10.20 +	memgzio.c		\
   10.21 +	movie.cpp		\
   10.22 +	nesvideos-piece.cpp	\
   10.23 +	Text.cpp		\
   10.24 +	unzip.cpp		\
   10.25 +	Util.cpp		
   10.26 +
   10.27 +
   10.28 +
   10.29 +AM_CPPFLAGS = \
   10.30 +	-I$(top_srcdir)/src		\
   10.31 +	-DSDL				\
   10.32 +	-DSYSCONFDIR=\"$(sysconfdir)\"
   10.33 +
   10.34 +AM_CXXFLAGS = -fno-exceptions @SDL_CFLAGS@

    11.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    11.2 +++ b/src/common/System.h	Sun Mar 04 14:33:52 2012 -0600
    11.3 @@ -0,0 +1,137 @@
    11.4 +#ifndef VBA_SYSTEM_H
    11.5 +#define VBA_SYSTEM_H
    11.6 +
    11.7 +#if _MSC_VER > 1000
    11.8 +#pragma once
    11.9 +#endif // _MSC_VER > 1000
   11.10 +
   11.11 +#include "zlib.h"
   11.12 +#include "../Port.h"
   11.13 +
   11.14 +// c++ lacks a way to implement Smart Referrences or Delphi-Style Properties
   11.15 +// in order to maintain consistency, value-copied things should not be modified too often
   11.16 +struct EmulatedSystem
   11.17 +{
   11.18 +	// main emulation function
   11.19 +	void (*emuMain)(int);
   11.20 +	// reset emulator
   11.21 +	void (*emuReset)(bool);
   11.22 +	// clean up memory
   11.23 +	void (*emuCleanUp)();
   11.24 +	// load battery file
   11.25 +	bool (*emuReadBattery)(const char *);
   11.26 +	// write battery file
   11.27 +	bool (*emuWriteBattery)(const char *);
   11.28 +	// load battery file from stream
   11.29 +	bool (*emuReadBatteryFromStream)(gzFile);
   11.30 +	// write battery file to stream
   11.31 +	bool (*emuWriteBatteryToStream)(gzFile);
   11.32 +	// load state
   11.33 +	bool (*emuReadState)(const char *);
   11.34 +	// save state
   11.35 +	bool (*emuWriteState)(const char *);
   11.36 +	// load state from stream
   11.37 +	bool (*emuReadStateFromStream)(gzFile);
   11.38 +	// save state to stream
   11.39 +	bool (*emuWriteStateToStream)(gzFile);
   11.40 +	// load memory state (rewind)
   11.41 +	bool (*emuReadMemState)(char *, int);
   11.42 +	// write memory state (rewind)
   11.43 +	bool (*emuWriteMemState)(char *, int);
   11.44 +	// write PNG file
   11.45 +	bool (*emuWritePNG)(const char *);
   11.46 +	// write BMP file
   11.47 +	bool (*emuWriteBMP)(const char *);
   11.48 +	// emulator update CPSR (ARM only)
   11.49 +	void (*emuUpdateCPSR)();
   11.50 +	// emulator has debugger
   11.51 +	bool emuHasDebugger;
   11.52 +	// clock ticks to emulate
   11.53 +	int emuCount;
   11.54 +};
   11.55 +
   11.56 +// why not convert the value type only when doing I/O?
   11.57 +struct EmulatedSystemCounters
   11.58 +{
   11.59 +	int32 frameCount;
   11.60 +	int32 lagCount;
   11.61 +	int32 extraCount;
   11.62 +	bool8 lagged;
   11.63 +	bool8 laggedLast;
   11.64 +};
   11.65 +
   11.66 +extern struct EmulatedSystem theEmulator;
   11.67 +extern struct EmulatedSystemCounters systemCounters;
   11.68 +
   11.69 +extern void log(const char *, ...);
   11.70 +
   11.71 +extern void systemGbPrint(u8 *, int, int, int, int);
   11.72 +extern int  systemScreenCapture(int);
   11.73 +extern void systemRefreshScreen();
   11.74 +extern void systemRenderFrame();
   11.75 +extern void systemRedrawScreen();
   11.76 +extern void systemUpdateListeners();
   11.77 +// updates the joystick data
   11.78 +extern void systemSetSensorX(int32);
   11.79 +extern void systemSetSensorY(int32);
   11.80 +extern void systemResetSensor();
   11.81 +extern int32 systemGetSensorX();
   11.82 +extern int32 systemGetSensorY();
   11.83 +extern void systemUpdateMotionSensor(int);
   11.84 +extern int  systemGetDefaultJoypad();
   11.85 +extern void systemSetDefaultJoypad(int);
   11.86 +extern bool systemReadJoypads();
   11.87 +// return information about the given joystick, -1 for default joystick... the bool is for if motion sensor should be handled
   11.88 +// too
   11.89 +extern u32  systemGetOriginalJoypad(int, bool);
   11.90 +extern u32  systemGetJoypad(int, bool);
   11.91 +extern void systemSetJoypad(int, u32);
   11.92 +extern void systemClearJoypads();
   11.93 +extern void systemMessage(int, const char *, ...);
   11.94 +extern void systemScreenMessage(const char *msg, int slot = 0, int duration = 3000, const char *colorList = NULL);
   11.95 +extern bool systemSoundInit();
   11.96 +extern void systemSoundShutdown();
   11.97 +extern void systemSoundPause();
   11.98 +extern void systemSoundResume();
   11.99 +extern bool systemSoundIsPaused();
  11.100 +extern void systemSoundReset();
  11.101 +extern void systemSoundWriteToBuffer();
  11.102 +extern void systemSoundClearBuffer();
  11.103 +extern bool systemSoundCanChangeQuality();
  11.104 +extern bool systemSoundSetQuality(int quality);
  11.105 +extern u32  systemGetClock();
  11.106 +extern void systemSetTitle(const char *);
  11.107 +extern void systemShowSpeed(int);
  11.108 +extern void systemIncreaseThrottle();
  11.109 +extern void systemDecreaseThrottle();
  11.110 +extern void systemSetThrottle(int);
  11.111 +extern int  systemGetThrottle();
  11.112 +extern void systemFrame();
  11.113 +extern int  systemFramesToSkip();
  11.114 +extern bool systemIsEmulating();
  11.115 +extern void systemGbBorderOn();
  11.116 +extern bool systemIsRunningGBA();
  11.117 +extern bool systemIsSpedUp();
  11.118 +extern bool systemIsPaused();
  11.119 +extern void systemSetPause(bool pause);
  11.120 +extern bool systemPauseOnFrame();
  11.121 +
  11.122 +extern int	systemCartridgeType;
  11.123 +extern int  systemSpeed;
  11.124 +extern bool systemSoundOn;
  11.125 +extern u16  systemColorMap16[0x10000];
  11.126 +extern u32  systemColorMap32[0x10000];
  11.127 +extern u16  systemGbPalette[24];
  11.128 +extern int  systemRedShift;
  11.129 +extern int  systemGreenShift;
  11.130 +extern int  systemBlueShift;
  11.131 +extern int  systemColorDepth;
  11.132 +extern int  systemDebug;
  11.133 +extern int  systemVerbose;
  11.134 +extern int  systemFrameSkip;
  11.135 +extern int  systemSaveUpdateCounter;
  11.136 +
  11.137 +#define SYSTEM_SAVE_UPDATED 30
  11.138 +#define SYSTEM_SAVE_NOT_UPDATED 0
  11.139 +
  11.140 +#endif // VBA_SYSTEM_H

    12.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    12.2 +++ b/src/common/Text.cpp	Sun Mar 04 14:33:52 2012 -0600
    12.3 @@ -0,0 +1,496 @@
    12.4 +/* FCE Ultra - NES/Famicom Emulator
    12.5 + *
    12.6 + * Copyright notice for this file:
    12.7 + *  Copyright (C) 2002 Ben Parnell
    12.8 + *
    12.9 + * This program is free software; you can redistribute it and/or modify
   12.10 + * it under the terms of the GNU General Public License as published by
   12.11 + * the Free Software Foundation; either version 2 of the License, or
   12.12 + * (at your option) any later version.
   12.13 + *
   12.14 + * This program is distributed in the hope that it will be useful,
   12.15 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
   12.16 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   12.17 + * GNU General Public License for more details.
   12.18 + *
   12.19 + * You should have received a copy of the GNU General Public License
   12.20 + * along with this program; if not, write to the Free Software
   12.21 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   12.22 + */
   12.23 +
   12.24 +/* Code originally from fceu/drawing.h file, adapted by Forgotten
   12.25 + */
   12.26 +#include "System.h"
   12.27 +
   12.28 +bool outlinedText = true, transparentText = false;
   12.29 +int  textColor    = 0, textMethod = 1;
   12.30 +
   12.31 +extern u32 RGB_LOW_BITS_MASK;
   12.32 +
   12.33 +static const u8 fontdata2[2048] = {
   12.34 +	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7e, 0x81, 0xa5, 0x81, 0xbd, 0x99, 0x81, 0x7e, 0x7e, 0xff,  0xdb, 0xff,
   12.35 +	0xc3, 0xe7, 0xff, 0x7e, 0x36, 0x7f, 0x7f, 0x7f, 0x3e, 0x1c, 0x08, 0x00, 0x08, 0x1c, 0x3e, 0x7f, 0x3e, 0x1c, 0x08, 0x00,
   12.36 +	0x1c,
   12.37 +	0x3e, 0x1c, 0x7f, 0x7f, 0x3e, 0x1c, 0x3e, 0x08, 0x08, 0x1c, 0x3e, 0x7f, 0x3e, 0x1c, 0x3e, 0x00, 0x00, 0x18, 0x3c, 0x3c,
   12.38 +	0x18,
   12.39 +	0x00, 0x00, 0xff, 0xff, 0xe7, 0xc3, 0xc3, 0xe7, 0xff, 0xff, 0x00, 0x3c, 0x66, 0x42, 0x42, 0x66, 0x3c, 0x00,  0xff, 0xc3,
   12.40 +	0x99, 0xbd, 0xbd, 0x99, 0xc3, 0xff, 0xf0, 0xe0, 0xf0, 0xbe, 0x33, 0x33, 0x33, 0x1e, 0x3c, 0x66, 0x66, 0x66, 0x3c, 0x18,
   12.41 +	0x7e,
   12.42 +	0x18, 0xfc, 0xcc, 0xfc, 0x0c, 0x0c, 0x0e, 0x0f, 0x07, 0xfe, 0xc6, 0xfe, 0xc6, 0xc6, 0xe6, 0x67, 0x03, 0x99, 0x5a, 0x3c,
   12.43 +	0xe7,
   12.44 +	0xe7, 0x3c, 0x5a, 0x99, 0x01, 0x07, 0x1f, 0x7f, 0x1f, 0x07, 0x01, 0x00, 0x40, 0x70, 0x7c, 0x7f, 0x7c, 0x70, 0x40, 0x00,
   12.45 +	0x18,
   12.46 +	0x3c, 0x7e, 0x18, 0x18, 0x7e, 0x3c, 0x18, 0x66, 0x66, 0x66, 0x66, 0x66, 0x00, 0x66, 0x00, 0xfe, 0xdb, 0xdb, 0xde, 0xd8,
   12.47 +	0xd8,
   12.48 +	0xd8, 0x00, 0x7c, 0xc6, 0x1c, 0x36, 0x36, 0x1c, 0x33, 0x1e, 0x00, 0x00, 0x00, 0x00, 0x7e, 0x7e, 0x7e, 0x00, 0x18, 0x3c,
   12.49 +	0x7e,
   12.50 +	0x18, 0x7e, 0x3c, 0x18, 0xff, 0x18, 0x3c, 0x7e, 0x18, 0x18, 0x18, 0x18, 0x00, 0x18, 0x18, 0x18, 0x18, 0x7e, 0x3c, 0x18,
   12.51 +	0x00,
   12.52 +	0x00, 0x18, 0x30, 0x7f, 0x30, 0x18, 0x00, 0x00, 0x00, 0x0c, 0x06, 0x7f, 0x06, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03,
   12.53 +	0x03,
   12.54 +	0x7f, 0x00, 0x00, 0x00, 0x24, 0x66, 0xff, 0x66, 0x24, 0x00, 0x00, 0x00, 0x18, 0x3c, 0x7e, 0xff, 0xff, 0x00, 0x00, 0x00,
   12.55 +	0xff,
   12.56 +	0xff, 0x7e, 0x3c, 0x18, 0x00, 0x00,
   12.57 +	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x1e, 0x1e, 0x0c, 0x0c, 0x00, 0x0c, 0x00, 0x36, 0x36, 0x36, 0x00,
   12.58 +	0x00, 0x00, 0x00, 0x00, 0x36, 0x36, 0x7f, 0x36, 0x7f, 0x36, 0x36, 0x00, 0x0c, 0x3e, 0x03, 0x1e, 0x30, 0x1f, 0x0c, 0x00,
   12.59 +	0x00,
   12.60 +	0x63, 0x33, 0x18, 0x0c, 0x66, 0x63, 0x00, 0x1c, 0x36, 0x1c, 0x6e, 0x3b, 0x33, 0x6e, 0x00, 0x06, 0x06, 0x03, 0x00, 0x00,
   12.61 +	0x00,
   12.62 +	0x00, 0x00, 0x18, 0x0c, 0x06, 0x06, 0x06, 0x0c, 0x18, 0x00, 0x06, 0x0c, 0x18, 0x18, 0x18, 0x0c, 0x06, 0x00, 0x00, 0x66,
   12.63 +	0x3c, 0xff, 0x3c, 0x66, 0x00, 0x00, 0x00, 0x0c, 0x0c, 0x3f, 0x0c, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c,
   12.64 +	0x0c,
   12.65 +	0x06, 0x00, 0x00, 0x00, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x0c, 0x00, 0x60, 0x30, 0x18,
   12.66 +	0x0c,
   12.67 +	0x06, 0x03, 0x01, 0x00, 0x3e, 0x63, 0x73, 0x7b, 0x6f, 0x67, 0x3e, 0x00, 0x0c, 0x0e, 0x0c, 0x0c, 0x0c, 0x0c, 0x3f, 0x00,
   12.68 +	0x1e,
   12.69 +	0x33, 0x30, 0x1c, 0x06, 0x33, 0x3f, 0x00, 0x1e, 0x33, 0x30, 0x1c, 0x30, 0x33, 0x1e, 0x00, 0x38, 0x3c, 0x36, 0x33, 0x7f,
   12.70 +	0x30,
   12.71 +	0x78, 0x00, 0x3f, 0x03, 0x1f, 0x30, 0x30, 0x33, 0x1e, 0x00, 0x1c, 0x06, 0x03, 0x1f, 0x33, 0x33, 0x1e, 0x00, 0x3f, 0x33,
   12.72 +	0x30,
   12.73 +	0x18, 0x0c, 0x0c, 0x0c, 0x00, 0x1e, 0x33, 0x33, 0x1e, 0x33, 0x33, 0x1e, 0x00, 0x1e, 0x33, 0x33, 0x3e, 0x30, 0x18, 0x0e,
   12.74 +	0x00,
   12.75 +	0x00, 0x0c, 0x0c, 0x00, 0x00, 0x0c, 0x0c, 0x00, 0x00, 0x0c, 0x0c, 0x00, 0x00, 0x0c, 0x0c, 0x06, 0x18, 0x0c, 0x06, 0x03,
   12.76 +	0x06,
   12.77 +	0x0c, 0x18, 0x00, 0x00, 0x00, 0x3f, 0x00, 0x00, 0x3f, 0x00, 0x00, 0x06, 0x0c, 0x18, 0x30, 0x18, 0x0c, 0x06, 0x00, 0x1e,
   12.78 +	0x33,
   12.79 +	0x30, 0x18, 0x0c, 0x00, 0x0c, 0x00,
   12.80 +	0x3e, 0x63, 0x7b, 0x7b, 0x7b, 0x03, 0x1e, 0x00, 0x0c, 0x1e, 0x33, 0x33, 0x3f, 0x33, 0x33, 0x00, 0x3f, 0x66, 0x66, 0x3e,
   12.81 +	0x66, 0x66, 0x3f, 0x00, 0x3c, 0x66, 0x03, 0x03, 0x03, 0x66, 0x3c, 0x00, 0x1f, 0x36, 0x66, 0x66, 0x66, 0x36, 0x1f, 0x00,
   12.82 +	0x7f,
   12.83 +	0x46, 0x16, 0x1e, 0x16, 0x46, 0x7f, 0x00, 0x7f, 0x46, 0x16, 0x1e, 0x16, 0x06, 0x0f, 0x00, 0x3c, 0x66, 0x03, 0x03, 0x73,
   12.84 +	0x66,
   12.85 +	0x7c, 0x00, 0x33, 0x33, 0x33, 0x3f, 0x33, 0x33, 0x33, 0x00, 0x1e, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x1e, 0x00, 0x78, 0x30,
   12.86 +	0x30, 0x30, 0x33, 0x33, 0x1e, 0x00, 0x67, 0x66, 0x36, 0x1e, 0x36, 0x66, 0x67, 0x00, 0x0f, 0x06, 0x06, 0x06, 0x46, 0x66,
   12.87 +	0x7f,
   12.88 +	0x00, 0x63, 0x77, 0x7f, 0x7f, 0x6b, 0x63, 0x63, 0x00, 0x63, 0x67, 0x6f, 0x7b, 0x73, 0x63, 0x63, 0x00, 0x1c, 0x36, 0x63,
   12.89 +	0x63,
   12.90 +	0x63, 0x36, 0x1c, 0x00, 0x3f, 0x66, 0x66, 0x3e, 0x06, 0x06, 0x0f, 0x00, 0x1e, 0x33, 0x33, 0x33, 0x3b, 0x1e, 0x38, 0x00,
   12.91 +	0x3f,
   12.92 +	0x66, 0x66, 0x3e, 0x36, 0x66, 0x67, 0x00, 0x1e, 0x33, 0x07, 0x0e, 0x38, 0x33, 0x1e, 0x00, 0x3f, 0x2d, 0x0c, 0x0c, 0x0c,
   12.93 +	0x0c,
   12.94 +	0x1e, 0x00, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x3f, 0x00, 0x33, 0x33, 0x33, 0x33, 0x33, 0x1e, 0x0c, 0x00, 0x63, 0x63,
   12.95 +	0x63,
   12.96 +	0x6b, 0x7f, 0x77, 0x63, 0x00, 0x63, 0x63, 0x36, 0x1c, 0x1c, 0x36, 0x63, 0x00, 0x33, 0x33, 0x33, 0x1e, 0x0c, 0x0c, 0x1e,
   12.97 +	0x00,
   12.98 +	0x7f, 0x63, 0x31, 0x18, 0x4c, 0x66, 0x7f, 0x00, 0x1e, 0x06, 0x06, 0x06, 0x06, 0x06, 0x1e, 0x00, 0x03, 0x06, 0x0c, 0x18,
   12.99 +	0x30,
  12.100 +	0x60, 0x40, 0x00, 0x1e, 0x18, 0x18, 0x18, 0x18, 0x18, 0x1e, 0x00, 0x08, 0x1c, 0x36, 0x63, 0x00, 0x00, 0x00, 0x00, 0x00,
  12.101 +	0x00,
  12.102 +	0x00, 0x00, 0x00, 0x00, 0x00, 0xff,
  12.103 +	0x0c, 0x0c, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1e, 0x30, 0x3e, 0x33, 0x6e, 0x00, 0x07, 0x06, 0x06, 0x3e,
  12.104 +	0x66, 0x66, 0x3b, 0x00, 0x00, 0x00, 0x1e, 0x33, 0x03, 0x33, 0x1e, 0x00, 0x38, 0x30, 0x30, 0x3e, 0x33, 0x33, 0x6e, 0x00,
  12.105 +	0x00,
  12.106 +	0x00, 0x1e, 0x33, 0x3f, 0x03, 0x1e, 0x00, 0x1c, 0x36, 0x06, 0x0f, 0x06, 0x06, 0x0f, 0x00, 0x00, 0x00, 0x6e, 0x33, 0x33,
  12.107 +	0x3e,
  12.108 +	0x30, 0x1f, 0x07, 0x06, 0x36, 0x6e, 0x66, 0x66, 0x67, 0x00, 0x0c, 0x00, 0x0e, 0x0c, 0x0c, 0x0c, 0x1e, 0x00, 0x30, 0x00,
  12.109 +	0x30, 0x30, 0x30, 0x33, 0x33, 0x1e, 0x07, 0x06, 0x66, 0x36, 0x1e, 0x36, 0x67, 0x00, 0x0e, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
  12.110 +	0x1e,
  12.111 +	0x00, 0x00, 0x00, 0x33, 0x7f, 0x7f, 0x6b, 0x63, 0x00, 0x00, 0x00, 0x1f, 0x33, 0x33, 0x33, 0x33, 0x00, 0x00, 0x00, 0x1e,
  12.112 +	0x33,
  12.113 +	0x33, 0x33, 0x1e, 0x00, 0x00, 0x00, 0x3b, 0x66, 0x66, 0x3e, 0x06, 0x0f, 0x00, 0x00, 0x6e, 0x33, 0x33, 0x3e, 0x30, 0x78,
  12.114 +	0x00,
  12.115 +	0x00, 0x3b, 0x6e, 0x66, 0x06, 0x0f, 0x00, 0x00, 0x00, 0x3e, 0x03, 0x1e, 0x30, 0x1f, 0x00, 0x08, 0x0c, 0x3e, 0x0c, 0x0c,
  12.116 +	0x2c,
  12.117 +	0x18, 0x00, 0x00, 0x00, 0x33, 0x33, 0x33, 0x33, 0x6e, 0x00, 0x00, 0x00, 0x33, 0x33, 0x33, 0x1e, 0x0c, 0x00, 0x00, 0x00,
  12.118 +	0x63,
  12.119 +	0x6b, 0x7f, 0x7f, 0x36, 0x00, 0x00, 0x00, 0x63, 0x36, 0x1c, 0x36, 0x63, 0x00, 0x00, 0x00, 0x33, 0x33, 0x33, 0x3e, 0x30,
  12.120 +	0x1f,
  12.121 +	0x00, 0x00, 0x3f, 0x19, 0x0c, 0x26, 0x3f, 0x00, 0x38, 0x0c, 0x0c, 0x07, 0x0c, 0x0c, 0x38, 0x00, 0x18, 0x18, 0x18, 0x00,
  12.122 +	0x18,
  12.123 +	0x18, 0x18, 0x00, 0x07, 0x0c, 0x0c, 0x38, 0x0c, 0x0c, 0x07, 0x00, 0x6e, 0x3b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  12.124 +	0x08,
  12.125 +	0x1c, 0x36, 0x63, 0x63, 0x7f, 0x00,
  12.126 +	0x1e, 0x33, 0x03, 0x33, 0x1e, 0x18, 0x30, 0x1e, 0x00, 0x33, 0x00, 0x33, 0x33, 0x33, 0x7e, 0x00, 0x38, 0x00, 0x1e, 0x33,
  12.127 +	0x3f, 0x03, 0x1e, 0x00, 0x7e, 0xc3, 0x3c, 0x60, 0x7c, 0x66, 0xfc, 0x00, 0x33, 0x00, 0x1e, 0x30, 0x3e, 0x33, 0x7e, 0x00,
  12.128 +	0x07,
  12.129 +	0x00, 0x1e, 0x30, 0x3e, 0x33, 0x7e, 0x00, 0x0c, 0x0c, 0x1e, 0x30, 0x3e, 0x33, 0x7e, 0x00, 0x00, 0x00, 0x1e, 0x03, 0x03,
  12.130 +	0x1e,
  12.131 +	0x30, 0x1c, 0x7e, 0xc3, 0x3c, 0x66, 0x7e, 0x06, 0x3c, 0x00, 0x33, 0x00, 0x1e, 0x33, 0x3f, 0x03, 0x1e, 0x00, 0x07, 0x00,
  12.132 +	0x1e, 0x33, 0x3f, 0x03, 0x1e, 0x00, 0x33, 0x00, 0x0e, 0x0c, 0x0c, 0x0c, 0x1e, 0x00, 0x3e, 0x63, 0x1c, 0x18, 0x18, 0x18,
  12.133 +	0x3c,
  12.134 +	0x00, 0x07, 0x00, 0x0e, 0x0c, 0x0c, 0x0c, 0x1e, 0x00, 0x63, 0x1c, 0x36, 0x63, 0x7f, 0x63, 0x63, 0x00, 0x0c, 0x0c, 0x00,
  12.135 +	0x1e,
  12.136 +	0x33, 0x3f, 0x33, 0x00, 0x38, 0x00, 0x3f, 0x06, 0x1e, 0x06, 0x3f, 0x00, 0x00, 0x00, 0xfe, 0x30, 0xfe, 0x33, 0xfe, 0x00,
  12.137 +	0x7c,
  12.138 +	0x36, 0x33, 0x7f, 0x33, 0x33, 0x73, 0x00, 0x1e, 0x33, 0x00, 0x1e, 0x33, 0x33, 0x1e, 0x00, 0x00, 0x33, 0x00, 0x1e, 0x33,
  12.139 +	0x33,
  12.140 +	0x1e, 0x00, 0x00, 0x07, 0x00, 0x1e, 0x33, 0x33, 0x1e, 0x00, 0x1e, 0x33, 0x00, 0x33, 0x33, 0x33, 0x7e, 0x00, 0x00, 0x07,
  12.141 +	0x00,
  12.142 +	0x33, 0x33, 0x33, 0x7e, 0x00, 0x00, 0x33, 0x00, 0x33, 0x33, 0x3e, 0x30, 0x1f, 0xc3, 0x18, 0x3c, 0x66, 0x66, 0x3c, 0x18,
  12.143 +	0x00,
  12.144 +	0x33, 0x00, 0x33, 0x33, 0x33, 0x33, 0x1e, 0x00, 0x18, 0x18, 0x7e, 0x03, 0x03, 0x7e, 0x18, 0x18, 0x1c, 0x36, 0x26, 0x0f,
  12.145 +	0x06,
  12.146 +	0x67, 0x3f, 0x00, 0x33, 0x33, 0x1e, 0x3f, 0x0c, 0x3f, 0x0c, 0x0c, 0x1f, 0x33, 0x33, 0x5f, 0x63, 0xf3, 0x63, 0xe3, 0x70,
  12.147 +	0xd8,
  12.148 +	0x18, 0x3c, 0x18, 0x18, 0x1b, 0x0e,
  12.149 +	0x38, 0x00, 0x1e, 0x30, 0x3e, 0x33, 0x7e, 0x00, 0x1c, 0x00, 0x0e, 0x0c, 0x0c, 0x0c, 0x1e, 0x00, 0x00, 0x38, 0x00, 0x1e,
  12.150 +	0x33, 0x33, 0x1e, 0x00, 0x00, 0x38, 0x00, 0x33, 0x33, 0x33, 0x7e, 0x00, 0x00, 0x1f, 0x00, 0x1f, 0x33, 0x33, 0x33, 0x00,
  12.151 +	0x3f,
  12.152 +	0x00, 0x33, 0x37, 0x3f, 0x3b, 0x33, 0x00, 0x3c, 0x36, 0x36, 0x7c, 0x00, 0x7e, 0x00, 0x00, 0x1c, 0x36, 0x36, 0x1c, 0x00,
  12.153 +	0x3e,
  12.154 +	0x00, 0x00, 0x0c, 0x00, 0x0c, 0x06, 0x03, 0x33, 0x1e, 0x00, 0x00, 0x00, 0x00, 0x3f, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00,
  12.155 +	0x00, 0x3f, 0x30, 0x30, 0x00, 0x00, 0xc3, 0x63, 0x33, 0x7b, 0xcc, 0x66, 0x33, 0xf0, 0xc3, 0x63, 0x33, 0xdb, 0xec, 0xf6,
  12.156 +	0xf3,
  12.157 +	0xc0, 0x18, 0x18, 0x00, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00, 0xcc, 0x66, 0x33, 0x66, 0xcc, 0x00, 0x00, 0x00, 0x33, 0x66,
  12.158 +	0xcc,
  12.159 +	0x66, 0x33, 0x00, 0x00, 0x44, 0x11, 0x44, 0x11, 0x44, 0x11, 0x44, 0x11, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55,
  12.160 +	0xdb,
  12.161 +	0xee, 0xdb, 0x77, 0xdb, 0xee, 0xdb, 0x77, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x1f,
  12.162 +	0x18,
  12.163 +	0x18, 0x18, 0x18, 0x18, 0x1f, 0x18, 0x1f, 0x18, 0x18, 0x18, 0x6c, 0x6c, 0x6c, 0x6c, 0x6f, 0x6c, 0x6c, 0x6c, 0x00, 0x00,
  12.164 +	0x00,
  12.165 +	0x00, 0x7f, 0x6c, 0x6c, 0x6c, 0x00, 0x00, 0x1f, 0x18, 0x1f, 0x18, 0x18, 0x18, 0x6c, 0x6c, 0x6f, 0x60, 0x6f, 0x6c, 0x6c,
  12.166 +	0x6c,
  12.167 +	0x6c, 0x6c, 0x6c, 0x6c, 0x6c, 0x6c, 0x6c, 0x6c, 0x00, 0x00, 0x7f, 0x60, 0x6f, 0x6c, 0x6c, 0x6c, 0x6c, 0x6c, 0x6f, 0x60,
  12.168 +	0x7f,
  12.169 +	0x00, 0x00, 0x00, 0x6c, 0x6c, 0x6c, 0x6c, 0x7f, 0x00, 0x00, 0x00, 0x18, 0x18, 0x1f, 0x18, 0x1f, 0x00, 0x00, 0x00, 0x00,
  12.170 +	0x00,
  12.171 +	0x00, 0x00, 0x1f, 0x18, 0x18, 0x18,
  12.172 +	0x18, 0x18, 0x18, 0x18, 0xf8, 0x00, 0x00, 0x00, 0x18, 0x18, 0x18, 0x18, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  12.173 +	0xff, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xf8, 0x18, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00,
  12.174 +	0x18,
  12.175 +	0x18, 0x18, 0x18, 0xff, 0x18, 0x18, 0x18, 0x18, 0x18, 0xf8, 0x18, 0xf8, 0x18, 0x18, 0x18, 0x6c, 0x6c, 0x6c, 0x6c, 0xec,
  12.176 +	0x6c,
  12.177 +	0x6c, 0x6c, 0x6c, 0x6c, 0xec, 0x0c, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x0c, 0xec, 0x6c, 0x6c, 0x6c, 0x6c, 0x6c,
  12.178 +	0xef, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xef, 0x6c, 0x6c, 0x6c, 0x6c, 0x6c, 0xec, 0x0c, 0xec, 0x6c,
  12.179 +	0x6c,
  12.180 +	0x6c, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x6c, 0x6c, 0xef, 0x00, 0xef, 0x6c, 0x6c, 0x6c, 0x18, 0x18, 0xff,
  12.181 +	0x00,
  12.182 +	0xff, 0x00, 0x00, 0x00, 0x6c, 0x6c, 0x6c, 0x6c, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x18, 0x18, 0x18,
  12.183 +	0x00,
  12.184 +	0x00, 0x00, 0x00, 0xff, 0x6c, 0x6c, 0x6c, 0x6c, 0x6c, 0x6c, 0x6c, 0xfc, 0x00, 0x00, 0x00, 0x18, 0x18, 0xf8, 0x18, 0xf8,
  12.185 +	0x00,
  12.186 +	0x00, 0x00, 0x00, 0x00, 0xf8, 0x18, 0xf8, 0x18, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x6c, 0x6c, 0x6c, 0x6c, 0x6c,
  12.187 +	0x6c,
  12.188 +	0x6c, 0xff, 0x6c, 0x6c, 0x6c, 0x18, 0x18, 0xff, 0x18, 0xff, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x1f, 0x00, 0x00,
  12.189 +	0x00,
  12.190 +	0x00, 0x00, 0x00, 0x00, 0xf8, 0x18, 0x18, 0x18, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
  12.191 +	0xff,
  12.192 +	0xff, 0xff, 0xff, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xff,
  12.193 +	0xff,
  12.194 +	0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
  12.195 +	0x00, 0x00, 0x6e, 0x3b, 0x13, 0x3b, 0x6e, 0x00, 0x00, 0x1e, 0x33, 0x1f, 0x33, 0x1f, 0x03, 0x03, 0x00, 0x3f, 0x33, 0x03,
  12.196 +	0x03, 0x03, 0x03, 0x00, 0x00, 0x7f, 0x36, 0x36, 0x36, 0x36, 0x36, 0x00, 0x3f, 0x33, 0x06, 0x0c, 0x06, 0x33, 0x3f, 0x00,
  12.197 +	0x00,
  12.198 +	0x00, 0x7e, 0x1b, 0x1b, 0x1b, 0x0e, 0x00, 0x00, 0x66, 0x66, 0x66, 0x66, 0x3e, 0x06, 0x03, 0x00, 0x6e, 0x3b, 0x18, 0x18,
  12.199 +	0x18,
  12.200 +	0x18, 0x00, 0x3f, 0x0c, 0x1e, 0x33, 0x33, 0x1e, 0x0c, 0x3f, 0x1c, 0x36, 0x63, 0x7f, 0x63, 0x36, 0x1c, 0x00, 0x1c, 0x36,
  12.201 +	0x63, 0x63, 0x36, 0x36, 0x77, 0x00, 0x38, 0x0c, 0x18, 0x3e, 0x33, 0x33, 0x1e, 0x00, 0x00, 0x00, 0x7e, 0xdb, 0xdb, 0x7e,
  12.202 +	0x00,
  12.203 +	0x00, 0x60, 0x30, 0x7e, 0xdb, 0xdb, 0x7e, 0x06, 0x03, 0x1c, 0x06, 0x03, 0x1f, 0x03, 0x06, 0x1c, 0x00, 0x1e, 0x33, 0x33,
  12.204 +	0x33,
  12.205 +	0x33, 0x33, 0x33, 0x00, 0x00, 0x3f, 0x00, 0x3f, 0x00, 0x3f, 0x00, 0x00, 0x0c, 0x0c, 0x3f, 0x0c, 0x0c, 0x00, 0x3f, 0x00,
  12.206 +	0x06,
  12.207 +	0x0c, 0x18, 0x0c, 0x06, 0x00, 0x3f, 0x00, 0x18, 0x0c, 0x06, 0x0c, 0x18, 0x00, 0x3f, 0x00, 0x70, 0xd8, 0xd8, 0x18, 0x18,
  12.208 +	0x18,
  12.209 +	0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x1b, 0x1b, 0x0e, 0x0c, 0x0c, 0x00, 0x3f, 0x00, 0x0c, 0x0c, 0x00, 0x00, 0x6e,
  12.210 +	0x3b,
  12.211 +	0x00, 0x6e, 0x3b, 0x00, 0x00, 0x1c, 0x36, 0x36, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00,
  12.212 +	0x00,
  12.213 +	0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0xf0, 0x30, 0x30, 0x30, 0x37, 0x36, 0x3c, 0x38, 0x1e, 0x36, 0x36, 0x36,
  12.214 +	0x36,
  12.215 +	0x00, 0x00, 0x00, 0x0e, 0x18, 0x0c, 0x06, 0x1e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x3c, 0x3c, 0x3c, 0x00, 0x00, 0x00,
  12.216 +	0x00,
  12.217 +	0x00, 0x00, 0x00, 0x00, 0x00, 0x00
  12.218 +};
  12.219 +
  12.220 +static void calcColors(const int colorNum, int & lo, int & hi, int & out)
  12.221 +{
  12.222 +	int redLo, redHi, greenLo, greenHi, blueLo, blueHi;
  12.223 +
  12.224 +	if (colorNum == 0 || colorNum == 1 || colorNum == 2 || colorNum == 6) // white, red, yellow, or magenta
  12.225 +		redLo = (0xf) << systemRedShift, redHi = (0x1f) << systemRedShift;
  12.226 +	else
  12.227 +		redLo = redHi = 0;
  12.228 +
  12.229 +	if (colorNum == 0 || colorNum == 2 || colorNum == 3 || colorNum == 4) // white, yellow, green, or cyan
  12.230 +		greenLo = (0xf) << systemGreenShift, greenHi = (0x1f) << systemGreenShift;
  12.231 +	else
  12.232 +		greenLo = greenHi = 0;
  12.233 +
  12.234 +	if (colorNum == 0 || colorNum == 4 || colorNum == 5 || colorNum == 6) // white, cyan, blue, or magenta
  12.235 +		blueLo = (0xf) << systemBlueShift, blueHi = (0x1f) << systemBlueShift;
  12.236 +	else
  12.237 +		blueLo = blueHi = 0;
  12.238 +
  12.239 +	lo = redLo + greenLo + blueLo;
  12.240 +	hi = redHi + greenHi + blueHi;
  12.241 +
  12.242 +	if (colorNum == 7) // black
  12.243 +		out = 0xffffffff; // white border
  12.244 +	else
  12.245 +		out = 0;  // black border
  12.246 +}
  12.247 +
  12.248 +int lastColID = 0;
  12.249 +static void progressColorList(const char *& colorList, int & lo, int & hi, int & out)
  12.250 +{
  12.251 +	if (*colorList)
  12.252 +	{
  12.253 +		if (*colorList != lastColID)
  12.254 +		{
  12.255 +			calcColors((int)(*colorList)-1, lo, hi, out);
  12.256 +			lastColID = *colorList;
  12.257 +		}
  12.258 +		colorList++;
  12.259 +	}
  12.260 +	else
  12.261 +	{
  12.262 +		colorList = NULL;
  12.263 +	}
  12.264 +}
  12.265 +
  12.266 +static void drawTextInternal(u8 *screen, int pitch, int x, int y,
  12.267 +                             const char *string, bool trans, const char *colorList = NULL)
  12.268 +{
  12.269 +	if (colorList && !*colorList)
  12.270 +		colorList = NULL;
  12.271 +
  12.272 +	int loCol, hiCol, outCol;
  12.273 +	calcColors(textColor, loCol, hiCol, outCol);
  12.274 +
  12.275 +	lastColID = 0;
  12.276 +
  12.277 +	const static int xd [8] = {-1, 0, 1, 1, 1, 0, -1, -1};
  12.278 +	const static int yd [8] = {-1, -1, -1, 0, 1, 1, 1, 0};
  12.279 +
  12.280 +	screen += y*pitch;
  12.281 +	int inc = 2;
  12.282 +	switch (systemColorDepth)
  12.283 +	{
  12.284 +	case 24:
  12.285 +		inc = 3;
  12.286 +		break;
  12.287 +	case 32:
  12.288 +		inc = 4;
  12.289 +		break;
  12.290 +	}
  12.291 +	screen += x*inc;
  12.292 +
  12.293 +	int xpos = x;
  12.294 +	switch (systemColorDepth)
  12.295 +	{
  12.296 +	case 16:
  12.297 +	{
  12.298 +		while (*string)
  12.299 +		{
  12.300 +			char c   = *string++;
  12.301 +			u8 * scr = screen;
  12.302 +
  12.303 +			if (colorList)
  12.304 +				progressColorList(colorList, loCol, hiCol, outCol);
  12.305 +
  12.306 +			u16  mask = u16(~RGB_LOW_BITS_MASK);
  12.307 +			u16 *s = (u16 *)scr;
  12.308 +			for (int h = 0-1; h < 8+1; h++)
  12.309 +			{
  12.310 +				for (int w = 0-1; w < 8+1; w++, s++)
  12.311 +				{
  12.312 +					int on = (h < 0 || w < 0 || h >= 8 || w >= 8) ? 0 : (fontdata2[(c<<3)+h]>>w)&1;
  12.313 +
  12.314 +					int border = 0;
  12.315 +					if (outlinedText)
  12.316 +						for (int i = 0; i < 8; i++)
  12.317 +						{
  12.318 +							int h2 = h+yd[i], w2 = w+xd[i];
  12.319 +							border = (h2 < 0 || w2 < 0 || h2 >= 8 || w2 >= 8) ? 0 : (fontdata2[(c<<3)+h2]>>w2)&1;
  12.320 +							if (border)
  12.321 +								break;
  12.322 +						}
  12.323 +
  12.324 +					if (trans)
  12.325 +					{
  12.326 +						if (on)
  12.327 +							*s = loCol +
  12.328 +							     ((*s & mask) >>1);
  12.329 +						else if (border)
  12.330 +						{
  12.331 +							*s = outCol +
  12.332 +							     ((*s & mask) >>1);
  12.333 +						}
  12.334 +					}
  12.335 +					else
  12.336 +					{
  12.337 +						if (on)
  12.338 +							*s = hiCol;
  12.339 +						else if (border)
  12.340 +							*s = outCol;
  12.341 +					}
  12.342 +				}
  12.343 +				scr += pitch;
  12.344 +				s    = (u16 *)scr;
  12.345 +			}
  12.346 +			screen += inc*8;
  12.347 +
  12.348 +			xpos += 8;
  12.349 +			if (xpos+8 > pitch>>1) // cut off text at right boundary
  12.350 +				break;
  12.351 +		}
  12.352 +		break;
  12.353 +	}
  12.354 +	case 24: // TODO: verify this code's correctness
  12.355 +	{
  12.356 +		while (*string)
  12.357 +		{
  12.358 +			char c   = *string++;
  12.359 +			u8 * scr = screen;
  12.360 +
  12.361 +			if (colorList)
  12.362 +				progressColorList(colorList, loCol, hiCol, outCol);
  12.363 +
  12.364 +			int h, w;
  12.365 +			u8 *s = (u8 *)scr;
  12.366 +			for (h = 0-1; h < 8+1; h++)
  12.367 +			{
  12.368 +				for (w = 0-1; w < 8+1; w++, s++)
  12.369 +				{
  12.370 +					int on = (h < 0 || w < 0 || h >= 8 || w >= 8) ? 0 : (fontdata2[(c<<3)+h]>>w)&1;
  12.371 +
  12.372 +					int border = 0;
  12.373 +					if (outlinedText)
  12.374 +						for (int i = 0; i < 8; i++)
  12.375 +						{
  12.376 +							int h2 = h+yd[i], w2 = w+xd[i];
  12.377 +							border = (h2 < 0 || w2 < 0 || h2 >= 8 || w2 >= 8) ? 0 : (fontdata2[(c<<3)+h2]>>w2)&1;
  12.378 +							if (border)
  12.379 +								break;
  12.380 +						}
  12.381 +
  12.382 +					if (trans)
  12.383 +					{
  12.384 +						if (on)
  12.385 +						{
  12.386 +							u32 color = hiCol;
  12.387 +							*s     = ((color & 255)>>1)+(*s>>1);
  12.388 +							*(s+1) = (((color >> 8) & 255)>>1)+(*(s+1)>>1);
  12.389 +							*(s+2) = (((color >> 16) & 255)>>1)+(*(s+2)>>1);
  12.390 +						}
  12.391 +						else if (border)
  12.392 +						{
  12.393 +							u32 color = outCol;
  12.394 +							*s     = ((color & 255)>>1)+(*s>>1);
  12.395 +							*(s+1) = (((color >> 8) & 255)>>1)+(*(s+1)>>1);
  12.396 +							*(s+2) = (((color >> 16) & 255)>>1)+(*(s+2)>>1);
  12.397 +						}
  12.398 +					}
  12.399 +					else
  12.400 +					{
  12.401 +						if (on)
  12.402 +						{
  12.403 +							u32 color = hiCol;
  12.404 +							*s     = (color & 255);
  12.405 +							*(s+1) = (color >> 8) & 255;
  12.406 +							*(s+2) = (color >> 16) & 255;
  12.407 +						}
  12.408 +						else if (border)
  12.409 +						{
  12.410 +							u32 color = outCol;
  12.411 +							*s     = (color & 255);
  12.412 +							*(s+1) = (color >> 8) & 255;
  12.413 +							*(s+2) = (color >> 16) & 255;
  12.414 +						}
  12.415 +					}
  12.416 +				}
  12.417 +				scr += pitch;
  12.418 +				s    = (u8 *)scr;
  12.419 +			}
  12.420 +			screen += inc*8;
  12.421 +
  12.422 +			xpos += 8;
  12.423 +			if (xpos+8 > pitch/3) // cut off text at right boundary
  12.424 +				break;
  12.425 +		}
  12.426 +		break;
  12.427 +	}
  12.428 +	case 32:
  12.429 +	{
  12.430 +		while (*string)
  12.431 +		{
  12.432 +			char c   = *string++;
  12.433 +			u8 * scr = screen;
  12.434 +
  12.435 +			if (colorList)
  12.436 +				progressColorList(colorList, loCol, hiCol, outCol);
  12.437 +
  12.438 +			int  h, w;
  12.439 +			u32  mask = 0xfefefe;
  12.440 +			u32 *s    = (u32 *)scr;
  12.441 +			for (h = 0-1; h < 8+1; h++)
  12.442 +			{
  12.443 +				for (w = 0-1; w < 8+1; w++, s++)
  12.444 +				{
  12.445 +					int on = (h < 0 || w < 0 || h >= 8 || w >= 8) ? 0 : (fontdata2[(c<<3)+h]>>w)&1;
  12.446 +
  12.447 +					int border = 0;
  12.448 +					if (outlinedText)
  12.449 +						for (int i = 0; i < 8; i++)
  12.450 +						{
  12.451 +							int h2 = h+yd[i], w2 = w+xd[i];
  12.452 +							border = (h2 < 0 || w2 < 0 || h2 >= 8 || w2 >= 8) ? 0 : (fontdata2[(c<<3)+h2]>>w2)&1;
  12.453 +							if (border)
  12.454 +								break;
  12.455 +						}
  12.456 +
  12.457 +					if (trans)
  12.458 +					{
  12.459 +						if (on)
  12.460 +							*s = loCol +
  12.461 +							     ((*s & mask)>>1);
  12.462 +						else if (border)
  12.463 +						{
  12.464 +							*s = outCol +
  12.465 +							     ((*s & mask)>>1);
  12.466 +						}
  12.467 +					}
  12.468 +					else
  12.469 +					{
  12.470 +						if (on)
  12.471 +							*s = hiCol;
  12.472 +						else if (border)
  12.473 +							*s = outCol;
  12.474 +					}
  12.475 +				}
  12.476 +				scr += pitch;
  12.477 +				s    = (u32 *)scr;
  12.478 +			}
  12.479 +			screen += inc*8;
  12.480 +
  12.481 +			xpos += 8;
  12.482 +			if (xpos+8 > pitch>>2) // cut off text at right boundary
  12.483 +				break;
  12.484 +		}
  12.485 +		break;
  12.486 +	}
  12.487 +	}
  12.488 +}
  12.489 +
  12.490 +void drawText(u8 *screen, int pitch, int x, int y, const char *string, const char *colorList)
  12.491 +{
  12.492 +	drawTextInternal(screen, pitch, x, y, string, transparentText, colorList);
  12.493 +}
  12.494 +
  12.495 +void drawTextTransp(u8 *screen, int pitch, int x, int y, const char *string, const char *colorList)
  12.496 +{
  12.497 +	drawTextInternal(screen, pitch, x, y, string, true, colorList);
  12.498 +}
  12.499 +

    13.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    13.2 +++ b/src/common/Text.h	Sun Mar 04 14:33:52 2012 -0600
    13.3 @@ -0,0 +1,14 @@
    13.4 +#ifndef VBA_TEXT_H
    13.5 +#define VBA_TEXT_H
    13.6 +
    13.7 +#if _MSC_VER > 1000
    13.8 +#pragma once
    13.9 +#endif // _MSC_VER > 1000
   13.10 +
   13.11 +extern void drawText(u8 *, int, int, int, const char *, const char*cl = NULL);
   13.12 +extern void drawTextTransp(u8 *, int, int, int, const char *, const char*cl = NULL);
   13.13 +
   13.14 +extern bool outlinedText, transparentText;
   13.15 +extern int  textColor, textMethod;
   13.16 +
   13.17 +#endif // VBA_TEXT_H

    14.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    14.2 +++ b/src/common/Util.cpp	Sun Mar 04 14:33:52 2012 -0600
    14.3 @@ -0,0 +1,1400 @@
    14.4 +#include <cstdio>
    14.5 +#include <cstdlib>
    14.6 +#include <cstring>
    14.7 +#include <zlib.h>
    14.8 +
    14.9 +extern "C" {
   14.10 +#include <png.h>
   14.11 +}
   14.12 +
   14.13 +#if 0
   14.14 +#include "unrarlib.h"
   14.15 +#endif
   14.16 +
   14.17 +#include "unzip.h"
   14.18 +
   14.19 +#include "../NLS.h"
   14.20 +#include "System.h"
   14.21 +#include "Util.h"
   14.22 +#include "../gba/Flash.h"
   14.23 +#include "../gba/RTC.h"
   14.24 +
   14.25 +extern "C" {
   14.26 +#include "memgzio.h"
   14.27 +}
   14.28 +
   14.29 +#ifndef _MSC_VER
   14.30 +#define _stricmp strcasecmp
   14.31 +#endif // ! _MSC_VER
   14.32 +
   14.33 +extern int32 cpuSaveType;
   14.34 +
   14.35 +extern int systemColorDepth;
   14.36 +extern int systemRedShift;
   14.37 +extern int systemGreenShift;
   14.38 +extern int systemBlueShift;
   14.39 +
   14.40 +extern u16 systemColorMap16[0x10000];
   14.41 +extern u32 systemColorMap32[0x10000];
   14.42 +
   14.43 +static int	   (ZEXPORT *utilGzWriteFunc)(gzFile, voidp, unsigned int) = NULL;
   14.44 +static int	   (ZEXPORT *utilGzReadFunc)(gzFile, voidp, unsigned int)  = NULL;
   14.45 +static int	   (ZEXPORT *utilGzCloseFunc)(gzFile) = NULL;
   14.46 +static z_off_t (ZEXPORT *utilGzSeekFunc)(gzFile, z_off_t, int) = NULL;
   14.47 +static z_off_t (ZEXPORT *utilGzTellFunc)(gzFile) = NULL;
   14.48 +
   14.49 +//Kludge to get it to compile in Linux, GCC cannot convert
   14.50 +//gzwrite function pointer to the type of utilGzWriteFunc
   14.51 +//due to void* and const void* differences
   14.52 +//--Felipe 
   14.53 +int gzWrite(gzFile file, void* buf, unsigned len){
   14.54 +	return gzwrite(file,buf,len);
   14.55 +}
   14.56 +
   14.57 +void utilPutDword(u8 *p, u32 value)
   14.58 +{
   14.59 +	*p++ = value & 255;
   14.60 +	*p++ = (value >> 8) & 255;
   14.61 +	*p++ = (value >> 16) & 255;
   14.62 +	*p	 = (value >> 24) & 255;
   14.63 +}
   14.64 +
   14.65 +void utilPutWord(u8 *p, u16 value)
   14.66 +{
   14.67 +	*p++ = value & 255;
   14.68 +	*p	 = (value >> 8) & 255;
   14.69 +}
   14.70 +
   14.71 +void utilWriteBMP(u8 *b, int w, int h, int dstDepth, u8 *pix)
   14.72 +{
   14.73 +	int sizeX = w;
   14.74 +	int sizeY = h;
   14.75 +
   14.76 +	switch (dstDepth > 0 ? dstDepth : systemColorDepth)
   14.77 +	{
   14.78 +	case 16:
   14.79 +	{
   14.80 +		u16 *p = (u16 *)(pix + (w + 2) * (h) * 2); // skip first black line
   14.81 +		for (int y = 0; y < sizeY; y++)
   14.82 +		{
   14.83 +			for (int x = 0; x < sizeX; x++)
   14.84 +			{
   14.85 +				u16 v = *p++;
   14.86 +
   14.87 +				*b++ = ((v >> systemBlueShift) & 0x01f) << 3; // B
   14.88 +				*b++ = ((v >> systemGreenShift) & 0x001f) << 3; // G
   14.89 +				*b++ = ((v >> systemRedShift) & 0x001f) << 3; // R
   14.90 +			}
   14.91 +			p++; // skip black pixel for filters
   14.92 +			p++; // skip black pixel for filters
   14.93 +			p -= 2 * (w + 2);
   14.94 +		}
   14.95 +		break;
   14.96 +	}
   14.97 +	case 24:
   14.98 +	{
   14.99 +		u8 *pixU8 = (u8 *)pix + 3 * w * (h - 1);
  14.100 +		for (int y = 0; y < sizeY; y++)
  14.101 +		{
  14.102 +			for (int x = 0; x < sizeX; x++)
  14.103 +			{
  14.104 +				if (systemRedShift > systemBlueShift)
  14.105 +				{
  14.106 +					*b++ = *pixU8++; // B
  14.107 +					*b++ = *pixU8++; // G
  14.108 +					*b++ = *pixU8++; // R
  14.109 +				}
  14.110 +				else
  14.111 +				{
  14.112 +					int red	  = *pixU8++;
  14.113 +					int green = *pixU8++;
  14.114 +					int blue  = *pixU8++;
  14.115 +
  14.116 +					*b++ = blue;
  14.117 +					*b++ = green;
  14.118 +					*b++ = red;
  14.119 +				}
  14.120 +			}
  14.121 +			pixU8 -= 2 * 3 * w;
  14.122 +		}
  14.123 +		break;
  14.124 +	}
  14.125 +	case 32:
  14.126 +	{
  14.127 +		u32 *pixU32 = (u32 *)(pix + 4 * (w + 1) * (h));
  14.128 +		for (int y = 0; y < sizeY; y++)
  14.129 +		{
  14.130 +			for (int x = 0; x < sizeX; x++)
  14.131 +			{
  14.132 +				u32 v = *pixU32++;
  14.133 +
  14.134 +				*b++ = ((v >> systemBlueShift) & 0x001f) << 3; // B
  14.135 +				*b++ = ((v >> systemGreenShift) & 0x001f) << 3; // G
  14.136 +				*b++ = ((v >> systemRedShift) & 0x001f) << 3; // R
  14.137 +			}
  14.138 +			pixU32++;
  14.139 +			pixU32 -= 2 * (w + 1);
  14.140 +		}
  14.141 +		break;
  14.142 +	}
  14.143 +	}
  14.144 +}
  14.145 +
  14.146 +bool utilWriteBMPFile(const char *fileName, int w, int h, u8 *pix)
  14.147 +{
  14.148 +	u8 writeBuffer[256 * 3];
  14.149 +
  14.150 +	FILE *fp = fopen(fileName, "wb");
  14.151 +
  14.152 +	if (!fp)
  14.153 +	{
  14.154 +		systemMessage(MSG_ERROR_CREATING_FILE, N_("Error creating file %s"), fileName);
  14.155 +		return false;
  14.156 +	}
  14.157 +
  14.158 +	struct
  14.159 +	{
  14.160 +		u8 ident[2];
  14.161 +		u8 filesize[4];
  14.162 +		u8 reserved[4];
  14.163 +		u8 dataoffset[4];
  14.164 +		u8 headersize[4];
  14.165 +		u8 width[4];
  14.166 +		u8 height[4];
  14.167 +		u8 planes[2];
  14.168 +		u8 bitsperpixel[2];
  14.169 +		u8 compression[4];
  14.170 +		u8 datasize[4];
  14.171 +		u8 hres[4];
  14.172 +		u8 vres[4];
  14.173 +		u8 colors[4];
  14.174 +		u8 importantcolors[4];
  14.175 +		//    u8 pad[2];
  14.176 +	} bmpheader;
  14.177 +	memset(&bmpheader, 0, sizeof(bmpheader));
  14.178 +
  14.179 +	bmpheader.ident[0] = 'B';
  14.180 +	bmpheader.ident[1] = 'M';
  14.181 +
  14.182 +	u32 fsz = sizeof(bmpheader) + w * h * 3;
  14.183 +	utilPutDword(bmpheader.filesize, fsz);
  14.184 +	utilPutDword(bmpheader.dataoffset, 0x36);
  14.185 +	utilPutDword(bmpheader.headersize, 0x28);
  14.186 +	utilPutDword(bmpheader.width, w);
  14.187 +	utilPutDword(bmpheader.height, h);
  14.188 +	utilPutDword(bmpheader.planes, 1);
  14.189 +	utilPutDword(bmpheader.bitsperpixel, 24);
  14.190 +	utilPutDword(bmpheader.datasize, 3 * w * h);
  14.191 +
  14.192 +	fwrite(&bmpheader, 1, sizeof(bmpheader), fp);
  14.193 +
  14.194 +#if 0
  14.195 +	// FIXME: need sufficient buffer
  14.196 +	utilWriteBMP(writeBuffer, w, h, systemColorDepth, pix);
  14.197 +#else
  14.198 +	u8 *b = writeBuffer;
  14.199 +
  14.200 +	int sizeX = w;
  14.201 +	int sizeY = h;
  14.202 +
  14.203 +	switch (systemColorDepth)
  14.204 +	{
  14.205 +	case 16:
  14.206 +	{
  14.207 +		u16 *p = (u16 *)(pix + (w + 2) * (h) * 2); // skip first black line
  14.208 +		for (int y = 0; y < sizeY; y++)
  14.209 +		{
  14.210 +			for (int x = 0; x < sizeX; x++)
  14.211 +			{
  14.212 +				u16 v = *p++;
  14.213 +
  14.214 +				*b++ = ((v >> systemBlueShift) & 0x01f) << 3; // B
  14.215 +				*b++ = ((v >> systemGreenShift) & 0x001f) << 3; // G
  14.216 +				*b++ = ((v >> systemRedShift) & 0x001f) << 3; // R
  14.217 +			}
  14.218 +			p++; // skip black pixel for filters
  14.219 +			p++; // skip black pixel for filters
  14.220 +			p -= 2 * (w + 2);
  14.221 +			fwrite(writeBuffer, 1, 3 * w, fp);
  14.222 +
  14.223 +			b = writeBuffer;
  14.224 +		}
  14.225 +		break;
  14.226 +	}
  14.227 +	case 24:
  14.228 +	{
  14.229 +		u8 *pixU8 = (u8 *)pix + 3 * w * (h - 1);
  14.230 +		for (int y = 0; y < sizeY; y++)
  14.231 +		{
  14.232 +			for (int x = 0; x < sizeX; x++)
  14.233 +			{
  14.234 +				if (systemRedShift > systemBlueShift)
  14.235 +				{
  14.236 +					*b++ = *pixU8++; // B
  14.237 +					*b++ = *pixU8++; // G
  14.238 +					*b++ = *pixU8++; // R
  14.239 +				}
  14.240 +				else
  14.241 +				{
  14.242 +					int red	  = *pixU8++;
  14.243 +					int green = *pixU8++;
  14.244 +					int blue  = *pixU8++;
  14.245 +
  14.246 +					*b++ = blue;
  14.247 +					*b++ = green;
  14.248 +					*b++ = red;
  14.249 +				}
  14.250 +			}
  14.251 +			pixU8 -= 2 * 3 * w;
  14.252 +			fwrite(writeBuffer, 1, 3 * w, fp);
  14.253 +
  14.254 +			b = writeBuffer;
  14.255 +		}
  14.256 +		break;
  14.257 +	}
  14.258 +	case 32:
  14.259 +	{
  14.260 +		u32 *pixU32 = (u32 *)(pix + 4 * (w + 1) * (h));
  14.261 +		for (int y = 0; y < sizeY; y++)
  14.262 +		{
  14.263 +			for (int x = 0; x < sizeX; x++)
  14.264 +			{
  14.265 +				u32 v = *pixU32++;
  14.266 +
  14.267 +				*b++ = ((v >> systemBlueShift) & 0x001f) << 3; // B
  14.268 +				*b++ = ((v >> systemGreenShift) & 0x001f) << 3; // G
  14.269 +				*b++ = ((v >> systemRedShift) & 0x001f) << 3; // R
  14.270 +			}
  14.271 +			pixU32++;
  14.272 +			pixU32 -= 2 * (w + 1);
  14.273 +
  14.274 +			fwrite(writeBuffer, 1, 3 * w, fp);
  14.275 +
  14.276 +			b = writeBuffer;
  14.277 +		}
  14.278 +		break;
  14.279 +	}
  14.280 +	}
  14.281 +#endif
  14.282 +
  14.283 +	fclose(fp);
  14.284 +
  14.285 +	return true;
  14.286 +}
  14.287 +
  14.288 +bool utilWritePNGFile(const char *fileName, int w, int h, u8 *pix)
  14.289 +{
  14.290 +	u8 writeBuffer[256 * 3];
  14.291 +
  14.292 +	FILE *fp = fopen(fileName, "wb");
  14.293 +
  14.294 +	if (!fp)
  14.295 +	{
  14.296 +		systemMessage(MSG_ERROR_CREATING_FILE, N_("Error creating file %s"), fileName);
  14.297 +		return false;
  14.298 +	}
  14.299 +
  14.300 +	png_structp png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING,
  14.301 +	                                              NULL,
  14.302 +	                                              NULL,
  14.303 +	                                              NULL);
  14.304 +	if (!png_ptr)
  14.305 +	{
  14.306 +		fclose(fp);
  14.307 +		return false;
  14.308 +	}
  14.309 +
  14.310 +	png_infop info_ptr = png_create_info_struct(png_ptr);
  14.311 +
  14.312 +	if (!info_ptr)
  14.313 +	{
  14.314 +		png_destroy_write_struct(&png_ptr, NULL);
  14.315 +		fclose(fp);
  14.316 +		return false;
  14.317 +	}
  14.318 +
  14.319 +	if (setjmp(png_ptr->jmpbuf))
  14.320 +	{
  14.321 +		png_destroy_write_struct(&png_ptr, NULL);
  14.322 +		fclose(fp);
  14.323 +		return false;
  14.324 +	}
  14.325 +
  14.326 +	png_init_io(png_ptr, fp);
  14.327 +
  14.328 +	png_set_IHDR(png_ptr,
  14.329 +	             info_ptr,
  14.330 +	             w,
  14.331 +	             h,
  14.332 +	             8,
  14.333 +	             PNG_COLOR_TYPE_RGB,
  14.334 +	             PNG_INTERLACE_NONE,
  14.335 +	             PNG_COMPRESSION_TYPE_DEFAULT,
  14.336 +	             PNG_FILTER_TYPE_DEFAULT);
  14.337 +
  14.338 +	png_write_info(png_ptr, info_ptr);
  14.339 +
  14.340 +	u8 *b = writeBuffer;
  14.341 +
  14.342 +	int sizeX = w;
  14.343 +	int sizeY = h;
  14.344 +
  14.345 +	switch (systemColorDepth)
  14.346 +	{
  14.347 +	case 16:
  14.348 +	{
  14.349 +		u16 *p = (u16 *)(pix + (w + 2) * 2); // skip first black line
  14.350 +		for (int y = 0; y < sizeY; y++)
  14.351 +		{
  14.352 +			for (int x = 0; x < sizeX; x++)
  14.353 +			{
  14.354 +				u16 v = *p++;
  14.355 +
  14.356 +				*b++ = ((v >> systemRedShift) & 0x001f) << 3; // R
  14.357 +				*b++ = ((v >> systemGreenShift) & 0x001f) << 3; // G
  14.358 +				*b++ = ((v >> systemBlueShift) & 0x01f) << 3; // B
  14.359 +			}
  14.360 +			p++; // skip black pixel for filters
  14.361 +			p++; // skip black pixel for filters
  14.362 +			png_write_row(png_ptr, writeBuffer);
  14.363 +
  14.364 +			b = writeBuffer;
  14.365 +		}
  14.366 +		break;
  14.367 +	}
  14.368 +	case 24:
  14.369 +	{
  14.370 +		u8 *pixU8 = (u8 *)pix;
  14.371 +		for (int y = 0; y < sizeY; y++)
  14.372 +		{
  14.373 +			for (int x = 0; x < sizeX; x++)
  14.374 +			{
  14.375 +				if (systemRedShift < systemBlueShift)
  14.376 +				{
  14.377 +					*b++ = *pixU8++; // R
  14.378 +					*b++ = *pixU8++; // G
  14.379 +					*b++ = *pixU8++; // B
  14.380 +				}
  14.381 +				else
  14.382 +				{
  14.383 +					int blue  = *pixU8++;
  14.384 +					int green = *pixU8++;
  14.385 +					int red	  = *pixU8++;
  14.386 +
  14.387 +					*b++ = red;
  14.388 +					*b++ = green;
  14.389 +					*b++ = blue;
  14.390 +				}
  14.391 +			}
  14.392 +			png_write_row(png_ptr, writeBuffer);
  14.393 +
  14.394 +			b = writeBuffer;
  14.395 +		}
  14.396 +		break;
  14.397 +	}
  14.398 +	case 32:
  14.399 +	{
  14.400 +		u32 *pixU32 = (u32 *)(pix + 4 * (w + 1));
  14.401 +		for (int y = 0; y < sizeY; y++)
  14.402 +		{
  14.403 +			for (int x = 0; x < sizeX; x++)
  14.404 +			{
  14.405 +				u32 v = *pixU32++;
  14.406 +
  14.407 +				*b++ = ((v >> systemRedShift) & 0x001f) << 3; // R
  14.408 +				*b++ = ((v >> systemGreenShift) & 0x001f) << 3; // G
  14.409 +				*b++ = ((v >> systemBlueShift) & 0x001f) << 3; // B
  14.410 +			}
  14.411 +			pixU32++;
  14.412 +
  14.413 +			png_write_row(png_ptr, writeBuffer);
  14.414 +
  14.415 +			b = writeBuffer;
  14.416 +		}
  14.417 +		break;
  14.418 +	}
  14.419 +	}
  14.420 +
  14.421 +	png_write_end(png_ptr, info_ptr);
  14.422 +
  14.423 +	png_destroy_write_struct(&png_ptr, &info_ptr);
  14.424 +
  14.425 +	fclose(fp);
  14.426 +
  14.427 +	return true;
  14.428 +}
  14.429 +
  14.430 +static int utilReadInt2(FILE *f)
  14.431 +{
  14.432 +	int res = 0;
  14.433 +	int c	= fgetc(f);
  14.434 +	if (c == EOF)
  14.435 +		return -1;
  14.436 +	res = c;
  14.437 +	c	= fgetc(f);
  14.438 +	if (c == EOF)
  14.439 +		return -1;
  14.440 +	return c + (res << 8);
  14.441 +}
  14.442 +
  14.443 +static int utilReadInt3(FILE *f)
  14.444 +{
  14.445 +	int res = 0;
  14.446 +	int c	= fgetc(f);
  14.447 +	if (c == EOF)
  14.448 +		return -1;
  14.449 +	res = c;
  14.450 +	c	= fgetc(f);
  14.451 +	if (c == EOF)
  14.452 +		return -1;
  14.453 +	res = c + (res << 8);
  14.454 +	c	= fgetc(f);
  14.455 +	if (c == EOF)
  14.456 +		return -1;
  14.457 +	return c + (res << 8);
  14.458 +}
  14.459 +
  14.460 +void utilApplyIPS(const char *ips, u8 * *r, int *s)
  14.461 +{
  14.462 +	// from the IPS spec at http://zerosoft.zophar.net/ips.htm
  14.463 +	FILE *f = fopen(ips, "rb");
  14.464 +	if (!f)
  14.465 +		return;
  14.466 +	u8 *rom	 = *r;
  14.467 +	int size = *s;
  14.468 +	if (fgetc(f) == 'P' &&
  14.469 +	    fgetc(f) == 'A' &&
  14.470 +	    fgetc(f) == 'T' &&
  14.471 +	    fgetc(f) == 'C' &&
  14.472 +	    fgetc(f) == 'H')
  14.473 +	{
  14.474 +		int b;
  14.475 +		int offset;
  14.476 +		int len;
  14.477 +		for (;; )
  14.478 +		{
  14.479 +			// read offset
  14.480 +			offset = utilReadInt3(f);
  14.481 +			// if offset == EOF, end of patch
  14.482 +			if (offset == 0x454f46)
  14.483 +				break;
  14.484 +			// read length
  14.485 +			len = utilReadInt2(f);
  14.486 +			if (!len)
  14.487 +			{
  14.488 +				// len == 0, RLE block
  14.489 +				len = utilReadInt2(f);
  14.490 +				// byte to fill
  14.491 +				int c = fgetc(f);
  14.492 +				if (c == -1)
  14.493 +					break;
  14.494 +				b = (u8)c;
  14.495 +			}
  14.496 +			else
  14.497 +				b = -1;
  14.498 +			// check if we need to reallocate our ROM
  14.499 +			if ((offset + len) >= size)
  14.500 +			{
  14.501 +				size *= 2;
  14.502 +				rom	  = (u8 *)realloc(rom, size);
  14.503 +				*r	  = rom;
  14.504 +				*s	  = size;
  14.505 +			}
  14.506 +			if (b == -1)
  14.507 +			{
  14.508 +				// normal block, just read the data
  14.509 +				if (fread(&rom[offset], 1, len, f) != (size_t)len)
  14.510 +					break;
  14.511 +			}
  14.512 +			else
  14.513 +			{
  14.514 +				// fill the region with the given byte
  14.515 +				while (len--)
  14.516 +				{
  14.517 +					rom[offset++] = b;
  14.518 +				}
  14.519 +			}
  14.520 +		}
  14.521 +	}
  14.522 +	// close the file
  14.523 +	fclose(f);
  14.524 +}
  14.525 +
  14.526 +extern bool8 cpuIsMultiBoot;
  14.527 +
  14.528 +bool utilIsGBAImage(const char *file)
  14.529 +{
  14.530 +	cpuIsMultiBoot = false;
  14.531 +	if (strlen(file) > 4)
  14.532 +	{
  14.533 +		const char *p = strrchr(file, '.');
  14.534 +
  14.535 +		if (p != NULL)
  14.536 +		{
  14.537 +			if (_stricmp(p, ".gba") == 0)
  14.538 +				return true;
  14.539 +			if (_stricmp(p, ".agb") == 0)
  14.540 +				return true;
  14.541 +			if (_stricmp(p, ".bin") == 0)
  14.542 +				return true;
  14.543 +			if (_stricmp(p, ".elf") == 0)
  14.544 +				return true;
  14.545 +			if (_stricmp(p, ".mb") == 0)
  14.546 +			{
  14.547 +				cpuIsMultiBoot = true;
  14.548 +				return true;
  14.549 +			}
  14.550 +		}
  14.551 +	}
  14.552 +
  14.553 +	return false;
  14.554 +}
  14.555 +
  14.556 +bool utilIsGBImage(const char *file)
  14.557 +{
  14.558 +	if (strlen(file) > 4)
  14.559 +	{
  14.560 +		const char *p = strrchr(file, '.');
  14.561 +
  14.562 +		if (p != NULL)
  14.563 +		{
  14.564 +			if (_stricmp(p, ".gb") == 0)
  14.565 +				return true;
  14.566 +			if (_stricmp(p, ".gbc") == 0)
  14.567 +				return true;
  14.568 +			if (_stricmp(p, ".cgb") == 0)
  14.569 +				return true;
  14.570 +			if (_stricmp(p, ".sgb") == 0)
  14.571 +				return true;
  14.572 +		}
  14.573 +	}
  14.574 +
  14.575 +	return false;
  14.576 +}
  14.577 +
  14.578 +bool utilIsGBABios(const char *file)
  14.579 +{
  14.580 +	if (strlen(file) > 4)
  14.581 +	{
  14.582 +		const char *p = strrchr(file, '.');
  14.583 +
  14.584 +		if (p != NULL)
  14.585 +		{
  14.586 +			if (_stricmp(p, ".gba") == 0)
  14.587 +				return true;
  14.588 +			if (_stricmp(p, ".agb") == 0)
  14.589 +				return true;
  14.590 +			if (_stricmp(p, ".bin") == 0)
  14.591 +				return true;
  14.592 +			if (_stricmp(p, ".bios") == 0)
  14.593 +				return true;
  14.594 +			if (_stricmp(p, ".rom") == 0)
  14.595 +				return true;
  14.596 +		}
  14.597 +	}
  14.598 +
  14.599 +	return false;
  14.600 +}
  14.601 +
  14.602 +bool utilIsGBBios(const char *file)
  14.603 +{
  14.604 +	if (strlen(file) > 4)
  14.605 +	{
  14.606 +		const char *p = strrchr(file, '.');
  14.607 +
  14.608 +		if (p != NULL)
  14.609 +		{
  14.610 +			if (_stricmp(p, ".gb") == 0)
  14.611 +				return true;
  14.612 +			if (_stricmp(p, ".bin") == 0)
  14.613 +				return true;
  14.614 +			if (_stricmp(p, ".bios") == 0)
  14.615 +				return true;
  14.616 +			if (_stricmp(p, ".rom") == 0)
  14.617 +				return true;
  14.618 +		}
  14.619 +	}
  14.620 +
  14.621 +	return false;
  14.622 +}
  14.623 +
  14.624 +bool utilIsELF(const char *file)
  14.625 +{
  14.626 +	if (strlen(file) > 4)
  14.627 +	{
  14.628 +		const char *p = strrchr(file, '.');
  14.629 +
  14.630 +		if (p != NULL)
  14.631 +		{
  14.632 +			if (_stricmp(p, ".elf") == 0)
  14.633 +				return true;
  14.634 +		}
  14.635 +	}
  14.636 +	return false;
  14.637 +}
  14.638 +
  14.639 +bool utilIsZipFile(const char *file)
  14.640 +{
  14.641 +	if (strlen(file) > 4)
  14.642 +	{
  14.643 +		const char *p = strrchr(file, '.');
  14.644 +
  14.645 +		if (p != NULL)
  14.646 +		{
  14.647 +			if (_stricmp(p, ".zip") == 0)
  14.648 +				return true;
  14.649 +		}
  14.650 +	}
  14.651 +
  14.652 +	return false;
  14.653 +}
  14.654 +
  14.655 +#if 0
  14.656 +bool utilIsRarFile(const char *file)
  14.657 +{
  14.658 +	if (strlen(file) > 4)
  14.659 +	{
  14.660 +		char *p = strrchr(file, '.');
  14.661 +
  14.662 +		if (p != NULL)
  14.663 +		{
  14.664 +			if (_stricmp(p, ".rar") == 0)
  14.665 +				return true;
  14.666 +		}
  14.667 +	}
  14.668 +
  14.669 +	return false;
  14.670 +}
  14.671 +
  14.672 +#endif
  14.673 +
  14.674 +bool utilIsGzipFile(const char *file)
  14.675 +{
  14.676 +	if (strlen(file) > 3)
  14.677 +	{
  14.678 +		const char *p = strrchr(file, '.');
  14.679 +
  14.680 +		if (p != NULL)
  14.681 +		{
  14.682 +			if (_stricmp(p, ".gz") == 0)
  14.683 +				return true;
  14.684 +			if (_stricmp(p, ".z") == 0)
  14.685 +				return true;
  14.686 +		}
  14.687 +	}
  14.688 +
  14.689 +	return false;
  14.690 +}
  14.691 +
  14.692 +void utilGetBaseName(const char *file, char *buffer)
  14.693 +{
  14.694 +	strcpy(buffer, file);
  14.695 +
  14.696 +	if (utilIsGzipFile(file))
  14.697 +	{
  14.698 +		char *p = strrchr(buffer, '.');
  14.699 +
  14.700 +		if (p)
  14.701 +			*p = 0;
  14.702 +	}
  14.703 +}
  14.704 +
  14.705 +IMAGE_TYPE utilFindType(const char *file)
  14.706 +{
  14.707 +	char buffer[2048];
  14.708 +
  14.709 +	if (utilIsZipFile(file))
  14.710 +	{
  14.711 +		unzFile unz = unzOpen(file);
  14.712 +
  14.713 +		if (unz == NULL)
  14.714 +		{
  14.715 +			systemMessage(MSG_CANNOT_OPEN_FILE, N_("Cannot open file %s"), file);
  14.716 +			return IMAGE_UNKNOWN;
  14.717 +		}
  14.718 +
  14.719 +		int r = unzGoToFirstFile(unz);
  14.720 +
  14.721 +		if (r != UNZ_OK)
  14.722 +		{
  14.723 +			unzClose(unz);
  14.724 +			systemMessage(MSG_BAD_ZIP_FILE, N_("Bad ZIP file %s"), file);
  14.725 +			return IMAGE_UNKNOWN;
  14.726 +		}
  14.727 +
  14.728 +		IMAGE_TYPE found = IMAGE_UNKNOWN;
  14.729 +
  14.730 +		unz_file_info info;
  14.731 +
  14.732 +		while (true)
  14.733 +		{
  14.734 +			r = unzGetCurrentFileInfo(unz,
  14.735 +			                          &info,
  14.736 +			                          buffer,
  14.737 +			                          sizeof(buffer),
  14.738 +			                          NULL,
  14.739 +			                          0,
  14.740 +			                          NULL,
  14.741 +			                          0);
  14.742 +
  14.743 +			if (r != UNZ_OK)
  14.744 +			{
  14.745 +				unzClose(unz);
  14.746 +				systemMessage(MSG_BAD_ZIP_FILE, N_("Bad ZIP file %s"), file);
  14.747 +				return IMAGE_UNKNOWN;
  14.748 +			}
  14.749 +
  14.750 +			if (utilIsGBAImage(buffer))
  14.751 +			{
  14.752 +				found = IMAGE_GBA;
  14.753 +				break;
  14.754 +			}
  14.755 +
  14.756 +			if (utilIsGBImage(buffer))
  14.757 +			{
  14.758 +				found = IMAGE_GB;
  14.759 +				break;
  14.760 +			}
  14.761 +
  14.762 +			r = unzGoToNextFile(unz);
  14.763 +
  14.764 +			if (r != UNZ_OK)
  14.765 +				break;
  14.766 +		}
  14.767 +		unzClose(unz);
  14.768 +
  14.769 +		if (found == IMAGE_UNKNOWN)
  14.770 +		{
  14.771 +			systemMessage(MSG_NO_IMAGE_ON_ZIP,
  14.772 +			              N_("No image found on ZIP file %s"), file);
  14.773 +			return found;
  14.774 +		}
  14.775 +		return found;
  14.776 +#if 0
  14.777 +	}
  14.778 +	else if (utilIsRarFile(file))
  14.779 +	{
  14.780 +		IMAGE_TYPE found = IMAGE_UNKNOWN;
  14.781 +
  14.782 +		ArchiveList_struct *rarList = NULL;
  14.783 +		if (urarlib_list((void *)file, (ArchiveList_struct *)&rarList))
  14.784 +		{
  14.785 +			ArchiveList_struct *p = rarList;
  14.786 +
  14.787 +			while (p)
  14.788 +			{
  14.789 +				if (utilIsGBAImage(p->item.Name))
  14.790 +				{
  14.791 +					found = IMAGE_GBA;
  14.792 +					break;
  14.793 +				}
  14.794 +
  14.795 +				if (utilIsGBImage(p->item.Name))
  14.796 +				{
  14.797 +					found = IMAGE_GB;
  14.798 +					break;
  14.799 +				}
  14.800 +				p = p->next;
  14.801 +			}
  14.802 +
  14.803 +			urarlib_freelist(rarList);
  14.804 +		}
  14.805 +		return found;
  14.806 +#endif
  14.807 +	}
  14.808 +	else
  14.809 +	{
  14.810 +		if (utilIsGzipFile(file))
  14.811 +			utilGetBaseName(file, buffer);
  14.812 +		else
  14.813 +			strcpy(buffer, file);
  14.814 +
  14.815 +		if (utilIsGBAImage(buffer))
  14.816 +			return IMAGE_GBA;
  14.817 +		if (utilIsGBImage(buffer))
  14.818 +			return IMAGE_GB;
  14.819 +	}
  14.820 +	return IMAGE_UNKNOWN;
  14.821 +}
  14.822 +
  14.823 +static int utilGetSize(int size)
  14.824 +{
  14.825 +	int res = 1;
  14.826 +	while (res < size)
  14.827 +		res <<= 1;
  14.828 +	return res;
  14.829 +}
  14.830 +
  14.831 +static u8 *utilLoadFromZip(const char *file,
  14.832 +                           bool (*accept)(const char *),
  14.833 +                           u8 *data,
  14.834 +                           int &size)
  14.835 +{
  14.836 +	char buffer[2048];
  14.837 +
  14.838 +	unzFile unz = unzOpen(file);
  14.839 +
  14.840 +	if (unz == NULL)
  14.841 +	{
  14.842 +		systemMessage(MSG_CANNOT_OPEN_FILE, N_("Cannot open file %s"), file);
  14.843 +		return NULL;
  14.844 +	}
  14.845 +	int r = unzGoToFirstFile(unz);
  14.846 +
  14.847 +	if (r != UNZ_OK)
  14.848 +	{
  14.849 +		unzClose(unz);
  14.850 +		systemMessage(MSG_BAD_ZIP_FILE, N_("Bad ZIP file %s"), file);
  14.851 +		return NULL;
  14.852 +	}
  14.853 +
  14.854 +	bool found = false;
  14.855 +
  14.856 +	unz_file_info info;
  14.857 +
  14.858 +	while (true)
  14.859 +	{
  14.860 +		r = unzGetCurrentFileInfo(unz,
  14.861 +		                          &info,
  14.862 +		                          buffer,
  14.863 +		                          sizeof(buffer),
  14.864 +		                          NULL,
  14.865 +		                          0,
  14.866 +		                          NULL,
  14.867 +		                          0);
  14.868 +
  14.869 +		if (r != UNZ_OK)
  14.870 +		{
  14.871 +			unzClose(unz);
  14.872 +			systemMessage(MSG_BAD_ZIP_FILE, N_("Bad ZIP file %s"), file);
  14.873 +			return NULL;
  14.874 +		}
  14.875 +
  14.876 +		if (accept(buffer))
  14.877 +		{
  14.878 +			found = true;
  14.879 +			break;
  14.880 +		}
  14.881 +
  14.882 +		r = unzGoToNextFile(unz);
  14.883 +
  14.884 +		if (r != UNZ_OK)
  14.885 +			break;
  14.886 +	}
  14.887 +
  14.888 +	if (!found)
  14.889 +	{
  14.890 +		unzClose(unz);
  14.891 +		systemMessage(MSG_NO_IMAGE_ON_ZIP,
  14.892 +		              N_("No image found on ZIP file %s"), file);
  14.893 +		return NULL;
  14.894 +	}
  14.895 +
  14.896 +	int fileSize = info.uncompressed_size;
  14.897 +	if (size == 0)
  14.898 +		size = fileSize;
  14.899 +	r = unzOpenCurrentFile(unz);
  14.900 +
  14.901 +	if (r != UNZ_OK)
  14.902 +	{
  14.903 +		unzClose(unz);
  14.904 +		systemMessage(MSG_ERROR_OPENING_IMAGE, N_("Error opening image %s"), buffer);
  14.905 +		return NULL;
  14.906 +	}
  14.907 +
  14.908 +	u8 *image = data;
  14.909 +
  14.910 +	if (image == NULL)
  14.911 +	{
  14.912 +		image = (u8 *)malloc(utilGetSize(size));
  14.913 +		if (image == NULL)
  14.914 +		{
  14.915 +			unzCloseCurrentFile(unz);
  14.916 +			unzClose(unz);
  14.917 +			systemMessage(MSG_OUT_OF_MEMORY, N_("Failed to allocate memory for %s"),
  14.918 +			              "data");
  14.919 +			return NULL;
  14.920 +		}
  14.921 +		size = fileSize;
  14.922 +	}
  14.923 +	int read = fileSize <= size ? fileSize : size;
  14.924 +	r = unzReadCurrentFile(unz,
  14.925 +	                       image,
  14.926 +	                       read);
  14.927 +
  14.928 +	unzCloseCurrentFile(unz);
  14.929 +	unzClose(unz);
  14.930 +
  14.931 +	if (r != (int)read)
  14.932 +	{
  14.933 +		systemMessage(MSG_ERROR_READING_IMAGE,
  14.934 +		              N_("Error reading image %s"), buffer);
  14.935 +		if (data == NULL)
  14.936 +			free(image);
  14.937 +		return NULL;
  14.938 +	}
  14.939 +
  14.940 +	size = fileSize;
  14.941 +
  14.942 +	return image;
  14.943 +}
  14.944 +
  14.945 +static u8 *utilLoadGzipFile(const char *file,
  14.946 +                            bool (*accept)(const char *),
  14.947 +                            u8 *data,
  14.948 +                            int &size)
  14.949 +{
  14.950 +	FILE *f = fopen(file, "rb");
  14.951 +
  14.952 +	if (f == NULL)
  14.953 +	{
  14.954 +		systemMessage(MSG_ERROR_OPENING_IMAGE, N_("Error opening image %s"), file);
  14.955 +		return NULL;
  14.956 +	}
  14.957 +
  14.958 +	fseek(f, -4, SEEK_END);
  14.959 +	int fileSize = fgetc(f) | (fgetc(f) << 8) | (fgetc(f) << 16) | (fgetc(f) << 24);
  14.960 +	fclose(f);
  14.961 +	if (size == 0)
  14.962 +		size = fileSize;
  14.963 +
  14.964 +	gzFile gz = gzopen(file, "rb");
  14.965 +
  14.966 +	if (gz == NULL)
  14.967 +	{
  14.968 +		// should not happen, but who knows?
  14.969 +		systemMessage(MSG_ERROR_OPENING_IMAGE, N_("Error opening image %s"), file);
  14.970 +		return NULL;
  14.971 +	}
  14.972 +
  14.973 +	u8 *image = data;
  14.974 +
  14.975 +	if (image == NULL)
  14.976 +	{
  14.977 +		image = (u8 *)malloc(utilGetSize(size));
  14.978 +		if (image == NULL)
  14.979 +		{
  14.980 +			systemMessage(MSG_OUT_OF_MEMORY, N_("Failed to allocate memory for %s"),
  14.981 +			              "data");
  14.982 +			fclose(f);
  14.983 +			return NULL;
  14.984 +		}
  14.985 +		size = fileSize;
  14.986 +	}
  14.987 +	int read = fileSize <= size ? fileSize : size;
  14.988 +	int r	 = gzread(gz, image, read);
  14.989 +	gzclose(gz);
  14.990 +
  14.991 +	if (r != (int)read)
  14.992 +	{
  14.993 +		systemMessage(MSG_ERROR_READING_IMAGE,
  14.994 +		              N_("Error reading image %s"), file);
  14.995 +		if (data == NULL)
  14.996 +			free(image);
  14.997 +		return NULL;
  14.998 +	}
  14.999 +
 14.1000 +	size = fileSize;
 14.1001 +
 14.1002 +	return image;
 14.1003 +}
 14.1004 +
 14.1005 +#if 0
 14.1006 +static u8 *utilLoadRarFile(const char *file,
 14.1007 +                           bool (*accept)(const char *),
 14.1008 +                           u8 *data,
 14.1009 +                           int &size)
 14.1010 +{
 14.1011 +	char buffer[2048];
 14.1012 +
 14.1013 +	ArchiveList_struct *rarList = NULL;
 14.1014 +	if (urarlib_list((void *)file, (ArchiveList_struct *)&rarList))
 14.1015 +	{
 14.1016 +		ArchiveList_struct *p = rarList;
 14.1017 +
 14.1018 +		bool found = false;
 14.1019 +		while (p)
 14.1020 +		{
 14.1021 +			if (accept(p->item.Name))
 14.1022 +			{
 14.1023 +				strcpy(buffer, p->item.Name);
 14.1024 +				found = true;
 14.1025 +				break;
 14.1026 +			}
 14.1027 +			p = p->next;
 14.1028 +		}
 14.1029 +		if (found)
 14.1030 +		{
 14.1031 +			void *memory		= NULL;
 14.1032 +			unsigned long lsize = 0;
 14.1033 +			size = p->item.UnpSize;
 14.1034 +			int r = urarlib_get((void *)&memory, &lsize, buffer, (void *)file, "");
 14.1035 +			if (!r)
 14.1036 +			{
 14.1037 +				systemMessage(MSG_ERROR_READING_IMAGE,
 14.1038 +				              N_("Error reading image %s"), buffer);
 14.1039 +				urarlib_freelist(rarList);
 14.1040 +				return NULL;
 14.1041 +			}
 14.1042 +			u8 *image = (u8 *)memory;
 14.1043 +			if (data != NULL)
 14.1044 +			{
 14.1045 +				memcpy(image, data, size);
 14.1046 +			}
 14.1047 +			urarlib_freelist(rarList);
 14.1048 +			return image;
 14.1049 +		}
 14.1050 +		systemMessage(MSG_NO_IMAGE_ON_ZIP,
 14.1051 +		              N_("No image found on RAR file %s"), file);
 14.1052 +		urarlib_freelist(rarList);
 14.1053 +		return NULL;
 14.1054 +	}
 14.1055 +	// nothing found
 14.1056 +	return NULL;
 14.1057 +}
 14.1058 +
 14.1059 +#endif
 14.1060 +
 14.1061 +// the caller is responsible for caling free(return value) to release the memory
 14.1062 +u8 *utilLoad(const char *file,
 14.1063 +             bool (*accept)(const char *),
 14.1064 +             u8 *data,
 14.1065 +             int &size)
 14.1066 +{
 14.1067 +	if (utilIsZipFile(file))
 14.1068 +	{
 14.1069 +		return utilLoadFromZip(file, accept, data, size);
 14.1070 +	}
 14.1071 +	if (utilIsGzipFile(file))
 14.1072 +	{
 14.1073 +		return utilLoadGzipFile(file, accept, data, size);
 14.1074 +	}
 14.1075 +#if 0
 14.1076 +	if (utilIsRarFile(file))
 14.1077 +	{
 14.1078 +		return utilLoadRarFile(file, accept, data, size);
 14.1079 +	}
 14.1080 +#endif
 14.1081 +
 14.1082 +	u8 *image = data;
 14.1083 +
 14.1084 +	FILE *f = fopen(file, "rb");
 14.1085 +
 14.1086 +	if (!f)
 14.1087 +	{
 14.1088 +		systemMessage(MSG_ERROR_OPENING_IMAGE, N_("Error opening image %s"), file);
 14.1089 +		return NULL;
 14.1090 +	}
 14.1091 +
 14.1092 +	fseek(f, 0, SEEK_END);
 14.1093 +	int fileSize = ftell(f);
 14.1094 +	fseek(f, 0, SEEK_SET);
 14.1095 +	if (size == 0)
 14.1096 +		size = fileSize;
 14.1097 +
 14.1098 +	if (image == NULL)
 14.1099 +	{
 14.1100 +		image = (u8 *)malloc(utilGetSize(size));
 14.1101 +		if (image == NULL)
 14.1102 +		{
 14.1103 +			systemMessage(MSG_OUT_OF_MEMORY, N_("Failed to allocate memory for %s"),
 14.1104 +			              "data");
 14.1105 +			fclose(f);
 14.1106 +			return NULL;
 14.1107 +		}
 14.1108 +		size = fileSize;
 14.1109 +	}
 14.1110 +	int read = fileSize <= size ? fileSize : size;
 14.1111 +	int r	 = fread(image, 1, read, f);
 14.1112 +	fclose(f);
 14.1113 +
 14.1114 +	if (r != (int)read)
 14.1115 +	{
 14.1116 +		systemMessage(MSG_ERROR_READING_IMAGE,
 14.1117 +		              N_("Error reading image %s"), file);
 14.1118 +		if (data == NULL)
 14.1119 +			free(image);
 14.1120 +		return NULL;
 14.1121 +	}
 14.1122 +
 14.1123 +	size = fileSize;
 14.1124 +
 14.1125 +	return image;
 14.1126 +}
 14.1127 +
 14.1128 +void utilWriteInt(gzFile gzFile, int32 i)
 14.1129 +{
 14.1130 +	utilGzWrite(gzFile, &i, sizeof(int32));
 14.1131 +}
 14.1132 +
 14.1133 +int32 utilReadInt(gzFile gzFile)
 14.1134 +{
 14.1135 +	int32 i = 0;
 14.1136 +	utilGzRead(gzFile, &i, sizeof(int32));
 14.1137 +	return i;
 14.1138 +}
 14.1139 +
 14.1140 +void utilReadData(gzFile gzFile, variable_desc *data)
 14.1141 +{
 14.1142 +	while (data->address)
 14.1143 +	{
 14.1144 +		utilGzRead(gzFile, data->address, data->size);
 14.1145 +		data++;
 14.1146 +	}
 14.1147 +}
 14.1148 +
 14.1149 +void utilWriteData(gzFile gzFile, variable_desc *data)
 14.1150 +{
 14.1151 +	while (data->address)
 14.1152 +	{
 14.1153 +		utilGzWrite(gzFile, data->address, data->size);
 14.1154 +		data++;
 14.1155 +	}
 14.1156 +}
 14.1157 +
 14.1158 +gzFile utilGzOpen(const char *file, const char *mode)
 14.1159 +{
 14.1160 +	utilGzWriteFunc = gzWrite;
 14.1161 +	utilGzReadFunc	= gzread;
 14.1162 +	utilGzCloseFunc = gzclose;
 14.1163 +	utilGzSeekFunc	= gzseek;
 14.1164 +	utilGzTellFunc	= gztell;
 14.1165 +
 14.1166 +	return gzopen(file, mode);
 14.1167 +}
 14.1168 +
 14.1169 +gzFile utilGzReopen(int id, const char *mode)
 14.1170 +{
 14.1171 +	utilGzWriteFunc = gzWrite;
 14.1172 +	utilGzReadFunc	= gzread;
 14.1173 +	utilGzCloseFunc = gzclose;
 14.1174 +	utilGzSeekFunc	= gzseek;
 14.1175 +	utilGzTellFunc	= gztell;
 14.1176 +
 14.1177 +	return gzdopen(id, mode);
 14.1178 +}
 14.1179 +
 14.1180 +gzFile utilMemGzOpen(char *memory, int available, char *mode)
 14.1181 +{
 14.1182 +	utilGzWriteFunc = memgzwrite;
 14.1183 +	utilGzReadFunc	= memgzread;
 14.1184 +	utilGzCloseFunc = memgzclose;
 14.1185 +	utilGzSeekFunc	= NULL;	// FIXME: not implemented...
 14.1186 +	utilGzTellFunc	= memtell;
 14.1187 +
 14.1188 +	return memgzopen(memory, available, mode);
 14.1189 +}
 14.1190 +
 14.1191 +int utilGzWrite(gzFile file, voidp buffer, unsigned int len)
 14.1192 +{
 14.1193 +	return utilGzWriteFunc(file, buffer, len);
 14.1194 +}
 14.1195 +
 14.1196 +int utilGzRead(gzFile file, voidp buffer, unsigned int len)
 14.1197 +{
 14.1198 +	return utilGzReadFunc(file, buffer, len);
 14.1199 +}
 14.1200 +
 14.1201 +int utilGzClose(gzFile file)
 14.1202 +{
 14.1203 +	return utilGzCloseFunc(file);
 14.1204 +}
 14.1205 +
 14.1206 +z_off_t utilGzSeek(gzFile file, z_off_t offset, int whence)
 14.1207 +{
 14.1208 +	return utilGzSeekFunc(file, offset, whence);
 14.1209 +}
 14.1210 +
 14.1211 +z_off_t utilGzTell(gzFile file)
 14.1212 +{
 14.1213 +	return utilGzTellFunc(file);
 14.1214 +}
 14.1215 +
 14.1216 +void utilGBAFindSave(const u8 *data, const int size)
 14.1217 +{
 14.1218 +	u32 *p		   = (u32 *)data;
 14.1219 +	u32 *end	   = (u32 *)(data + size);
 14.1220 +	int	 saveType  = 0;
 14.1221 +	int	 flashSize = 0x10000;
 14.1222 +	bool rtcFound  = false;
 14.1223 +
 14.1224 +	while (p  < end)
 14.1225 +	{
 14.1226 +		u32 d = READ32LE(p);
 14.1227 +
 14.1228 +		if (d == 0x52504545)
 14.1229 +		{
 14.1230 +			if (memcmp(p, "EEPROM_", 7) == 0)
 14.1231 +			{
 14.1232 +				if (saveType == 0)
 14.1233 +					saveType = 1;
 14.1234 +			}
 14.1235 +		}
 14.1236 +		else if (d == 0x4D415253)
 14.1237 +		{
 14.1238 +			if (memcmp(p, "SRAM_", 5) == 0)
 14.1239 +			{
 14.1240 +				if (saveType == 0)
 14.1241 +					saveType = 2;
 14.1242 +			}
 14.1243 +		}
 14.1244 +		else if (d == 0x53414C46)
 14.1245 +		{
 14.1246 +			if (memcmp(p, "FLASH1M_", 8) == 0)
 14.1247 +			{
 14.1248 +				if (saveType == 0)
 14.1249 +				{
 14.1250 +					saveType  = 3;
 14.1251 +					flashSize = 0x20000;
 14.1252 +				}
 14.1253 +			}
 14.1254 +			else if (memcmp(p, "FLASH", 5) == 0)
 14.1255 +			{
 14.1256 +				if (saveType == 0)
 14.1257 +				{
 14.1258 +					saveType  = 3;
 14.1259 +					flashSize = 0x10000;
 14.1260 +				}
 14.1261 +			}
 14.1262 +		}
 14.1263 +		else if (d == 0x52494953)
 14.1264 +		{
 14.1265 +			if (memcmp(p, "SIIRTC_V", 8) == 0)
 14.1266 +				rtcFound = true;
 14.1267 +		}
 14.1268 +		p++;
 14.1269 +	}
 14.1270 +	// if no matches found, then set it to NONE
 14.1271 +	if (saveType == 0)
 14.1272 +	{
 14.1273 +		saveType = 5;
 14.1274 +	}
 14.1275 +	rtcEnable(rtcFound);
 14.1276 +	cpuSaveType = saveType;
 14.1277 +	flashSetSize(flashSize);
 14.1278 +}
 14.1279 +
 14.1280 +void utilUpdateSystemColorMaps()
 14.1281 +{
 14.1282 +	switch (systemColorDepth)
 14.1283 +	{
 14.1284 +	case 16:
 14.1285 +	{
 14.1286 +		for (int i = 0; i < 0x10000; i++)
 14.1287 +		{
 14.1288 +			systemColorMap16[i] = ((i & 0x1f) << systemRedShift) |
 14.1289 +			                      (((i & 0x3e0) >> 5) << systemGreenShift) |
 14.1290 +			                      (((i & 0x7c00) >> 10) << systemBlueShift);
 14.1291 +		}
 14.1292 +		break;
 14.1293 +	}
 14.1294 +	case 24:
 14.1295 +	case 32:
 14.1296 +	{
 14.1297 +		for (int i = 0; i < 0x10000; i++)
 14.1298 +		{
 14.1299 +			systemColorMap32[i] = ((i & 0x1f) << systemRedShift) |
 14.1300 +			                      (((i & 0x3e0) >> 5) << systemGreenShift) |
 14.1301 +			                      (((i & 0x7c00) >> 10) << systemBlueShift);
 14.1302 +		}
 14.1303 +		break;
 14.1304 +	}
 14.1305 +	}
 14.1306 +}
 14.1307 +
 14.1308 +//// BIOS stuff
 14.1309 +// systemType uses the same enum values as gbEmulatorType does
 14.1310 +
 14.1311 +bool utilLoadBIOS(u8 *bios, const char *biosFileName, int systemType)
 14.1312 +{
 14.1313 +	if (bios == NULL || strlen(biosFileName) == 0)
 14.1314 +		return false;
 14.1315 +
 14.1316 +	if (systemType == 4)
 14.1317 +	{
 14.1318 +		int biosSize = 0x4000;
 14.1319 +		if (utilLoad(biosFileName, utilIsGBABios, bios, biosSize))
 14.1320 +		{
 14.1321 +			if (biosSize == 0x4000)
 14.1322 +				return true;
 14.1323 +		}
 14.1324 +	}
 14.1325 +	else
 14.1326 +	{
 14.1327 +		int biosSize = 0x100;
 14.1328 +		if (utilLoad(biosFileName, utilIsGBBios, bios, biosSize))
 14.1329 +		{
 14.1330 +			if (biosSize == 0x100)
 14.1331 +				return true;
 14.1332 +		}
 14.1333 +	}
 14.1334 +
 14.1335 +	return false;
 14.1336 +}
 14.1337 +
 14.1338 +bool utilCheckBIOS(const char *biosFileName, int systemType)
 14.1339 +{
 14.1340 +	if (strlen(biosFileName) == 0)
 14.1341 +		return false;
 14.1342 +
 14.1343 +	u8 * tempBIOS = (u8 *)malloc(systemType == 4 ? 0x4000 : 0x100);
 14.1344 +	bool result	  = utilLoadBIOS(tempBIOS, biosFileName, systemType);
 14.1345 +	free(tempBIOS);
 14.1346 +
 14.1347 +	return result;
 14.1348 +}
 14.1349 +
 14.1350 +#if 0
 14.1351 +// returns the checksum of the BIOS that will be loaded after the next restart
 14.1352 +u16 utilCalcBIOSChecksum(const u8 *bios, int systemType)
 14.1353 +{
 14.1354 +	u32	biosChecksum = 0;
 14.1355 +	if (bios)
 14.1356 +	{
 14.1357 +		int biosSize	= (systemType == 4 ? 0x4000 : 0x100);
 14.1358 +		const u16 *data = reinterpret_cast<const u16 *>(bios);
 14.1359 +		for (int i = biosSize; i > 0; i -= 2)
 14.1360 +			biosChecksum += *data++;
 14.1361 +	}
 14.1362 +
 14.1363 +	while ((biosChecksum >> 16) & 0xFFFF)
 14.1364 +		biosChecksum = (biosChecksum &0xFFFF) + ((biosChecksum >> 16) & 0xFFFF);
 14.1365 +
 14.1366 +	return biosChecksum & 0xFFFF;
 14.1367 +}
 14.1368 +#else
 14.1369 +// returns the checksum of the BIOS that will be loaded after the next restart
 14.1370 +u16 utilCalcBIOSChecksum(const u8 *bios, int systemType)
 14.1371 +{
 14.1372 +	u32	biosChecksum = 0;
 14.1373 +	if (bios)
 14.1374 +	{
 14.1375 +		int biosSize	= (systemType == 4 ? 0x4000 : 0x100);
 14.1376 +		const u32 *data = reinterpret_cast<const u32 *>(bios);
 14.1377 +		for (int i = biosSize; i > 0; i -= 4)
 14.1378 +			biosChecksum += *data++;
 14.1379 +	}
 14.1380 +
 14.1381 +	return biosChecksum & 0xFFFF;
 14.1382 +}
 14.1383 +#endif
 14.1384 +
 14.1385 +// returns the checksum of the BIOS file
 14.1386 +u16 utilCalcBIOSFileChecksum(const char *biosFileName, int systemType)
 14.1387 +{
 14.1388 +	if (strlen(biosFileName) == 0)
 14.1389 +		return 0;
 14.1390 +
 14.1391 +	u16		  biosChecksum = 0;
 14.1392 +	const int biosSize	   = (systemType == 4 ? 0x4000 : 0x100);
 14.1393 +	u8 *	  tempBIOS	   = (u8 *)malloc(biosSize);
 14.1394 +	bool	  hasBIOS	   = utilLoadBIOS(tempBIOS, biosFileName, systemType);
 14.1395 +	if (hasBIOS)
 14.1396 +	{
 14.1397 +		biosChecksum = utilCalcBIOSChecksum(tempBIOS, systemType);
 14.1398 +	}
 14.1399 +	free(tempBIOS);
 14.1400 +
 14.1401 +	return biosChecksum;
 14.1402 +}
 14.1403 +