[Scummvm-cvs-logs] SF.net SVN: scummvm: [32706] residual/trunk/tools
aquadran at users.sourceforge.net
aquadran at users.sourceforge.net
Sun Jun 15 13:09:22 CEST 2008
Revision: 32706
http://scummvm.svn.sourceforge.net/scummvm/?rev=32706&view=rev
Author: aquadran
Date: 2008-06-15 04:09:22 -0700 (Sun, 15 Jun 2008)
Log Message:
-----------
cleanup filename extensions
Added Paths:
-----------
residual/trunk/tools/bmtoppm.cpp
residual/trunk/tools/delua.cpp
residual/trunk/tools/imc2wav.cpp
residual/trunk/tools/int2flt.cpp
residual/trunk/tools/mat2ppm.cpp
residual/trunk/tools/set2fig.cpp
residual/trunk/tools/unlab.cpp
residual/trunk/tools/util.cpp
residual/trunk/tools/vima.cpp
Removed Paths:
-------------
residual/trunk/tools/COPYING.lib
residual/trunk/tools/bmtoppm.c
residual/trunk/tools/delua.cc
residual/trunk/tools/imc2wav.cc
residual/trunk/tools/int2flt.c
residual/trunk/tools/mat2ppm.c
residual/trunk/tools/set2fig.cc
residual/trunk/tools/unlab.c
residual/trunk/tools/util.c
residual/trunk/tools/vima.cc
Deleted: residual/trunk/tools/COPYING.lib
===================================================================
--- residual/trunk/tools/COPYING.lib 2008-06-15 07:15:58 UTC (rev 32705)
+++ residual/trunk/tools/COPYING.lib 2008-06-15 11:09:22 UTC (rev 32706)
@@ -1,510 +0,0 @@
-
- GNU LESSER GENERAL PUBLIC LICENSE
- Version 2.1, February 1999
-
- Copyright (C) 1991, 1999 Free Software Foundation, Inc.
- 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-[This is the first released version of the Lesser GPL. It also counts
- as the successor of the GNU Library Public License, version 2, hence
- the version number 2.1.]
-
- Preamble
-
- The licenses for most software are designed to take away your
-freedom to share and change it. By contrast, the GNU General Public
-Licenses are intended to guarantee your freedom to share and change
-free software--to make sure the software is free for all its users.
-
- This license, the Lesser General Public License, applies to some
-specially designated software packages--typically libraries--of the
-Free Software Foundation and other authors who decide to use it. You
-can use it too, but we suggest you first think carefully about whether
-this license or the ordinary General Public License is the better
-strategy to use in any particular case, based on the explanations
-below.
-
- When we speak of free software, we are referring to freedom of use,
-not price. Our General Public Licenses are designed to make sure that
-you have the freedom to distribute copies of free software (and charge
-for this service if you wish); that you receive source code or can get
-it if you want it; that you can change the software and use pieces of
-it in new free programs; and that you are informed that you can do
-these things.
-
- To protect your rights, we need to make restrictions that forbid
-distributors to deny you these rights or to ask you to surrender these
-rights. These restrictions translate to certain responsibilities for
-you if you distribute copies of the library or if you modify it.
-
- For example, if you distribute copies of the library, whether gratis
-or for a fee, you must give the recipients all the rights that we gave
-you. You must make sure that they, too, receive or can get the source
-code. If you link other code with the library, you must provide
-complete object files to the recipients, so that they can relink them
-with the library after making changes to the library and recompiling
-it. And you must show them these terms so they know their rights.
-
- We protect your rights with a two-step method: (1) we copyright the
-library, and (2) we offer you this license, which gives you legal
-permission to copy, distribute and/or modify the library.
-
- To protect each distributor, we want to make it very clear that
-there is no warranty for the free library. Also, if the library is
-modified by someone else and passed on, the recipients should know
-that what they have is not the original version, so that the original
-author's reputation will not be affected by problems that might be
-introduced by others.
-
- Finally, software patents pose a constant threat to the existence of
-any free program. We wish to make sure that a company cannot
-effectively restrict the users of a free program by obtaining a
-restrictive license from a patent holder. Therefore, we insist that
-any patent license obtained for a version of the library must be
-consistent with the full freedom of use specified in this license.
-
- Most GNU software, including some libraries, is covered by the
-ordinary GNU General Public License. This license, the GNU Lesser
-General Public License, applies to certain designated libraries, and
-is quite different from the ordinary General Public License. We use
-this license for certain libraries in order to permit linking those
-libraries into non-free programs.
-
- When a program is linked with a library, whether statically or using
-a shared library, the combination of the two is legally speaking a
-combined work, a derivative of the original library. The ordinary
-General Public License therefore permits such linking only if the
-entire combination fits its criteria of freedom. The Lesser General
-Public License permits more lax criteria for linking other code with
-the library.
-
- We call this license the "Lesser" General Public License because it
-does Less to protect the user's freedom than the ordinary General
-Public License. It also provides other free software developers Less
-of an advantage over competing non-free programs. These disadvantages
-are the reason we use the ordinary General Public License for many
-libraries. However, the Lesser license provides advantages in certain
-special circumstances.
-
- For example, on rare occasions, there may be a special need to
-encourage the widest possible use of a certain library, so that it
-becomes a de-facto standard. To achieve this, non-free programs must
-be allowed to use the library. A more frequent case is that a free
-library does the same job as widely used non-free libraries. In this
-case, there is little to gain by limiting the free library to free
-software only, so we use the Lesser General Public License.
-
- In other cases, permission to use a particular library in non-free
-programs enables a greater number of people to use a large body of
-free software. For example, permission to use the GNU C Library in
-non-free programs enables many more people to use the whole GNU
-operating system, as well as its variant, the GNU/Linux operating
-system.
-
- Although the Lesser General Public License is Less protective of the
-users' freedom, it does ensure that the user of a program that is
-linked with the Library has the freedom and the wherewithal to run
-that program using a modified version of the Library.
-
- The precise terms and conditions for copying, distribution and
-modification follow. Pay close attention to the difference between a
-"work based on the library" and a "work that uses the library". The
-former contains code derived from the library, whereas the latter must
-be combined with the library in order to run.
-
- GNU LESSER GENERAL PUBLIC LICENSE
- TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-
- 0. This License Agreement applies to any software library or other
-program which contains a notice placed by the copyright holder or
-other authorized party saying it may be distributed under the terms of
-this Lesser General Public License (also called "this License").
-Each licensee is addressed as "you".
-
- A "library" means a collection of software functions and/or data
-prepared so as to be conveniently linked with application programs
-(which use some of those functions and data) to form executables.
-
- The "Library", below, refers to any such software library or work
-which has been distributed under these terms. A "work based on the
-Library" means either the Library or any derivative work under
-copyright law: that is to say, a work containing the Library or a
-portion of it, either verbatim or with modifications and/or translated
-straightforwardly into another language. (Hereinafter, translation is
-included without limitation in the term "modification".)
-
- "Source code" for a work means the preferred form of the work for
-making modifications to it. For a library, complete source code means
-all the source code for all modules it contains, plus any associated
-interface definition files, plus the scripts used to control
-compilation and installation of the library.
-
- Activities other than copying, distribution and modification are not
-covered by this License; they are outside its scope. The act of
-running a program using the Library is not restricted, and output from
-such a program is covered only if its contents constitute a work based
-on the Library (independent of the use of the Library in a tool for
-writing it). Whether that is true depends on what the Library does
-and what the program that uses the Library does.
-
- 1. You may copy and distribute verbatim copies of the Library's
-complete source code as you receive it, in any medium, provided that
-you conspicuously and appropriately publish on each copy an
-appropriate copyright notice and disclaimer of warranty; keep intact
-all the notices that refer to this License and to the absence of any
-warranty; and distribute a copy of this License along with the
-Library.
-
- You may charge a fee for the physical act of transferring a copy,
-and you may at your option offer warranty protection in exchange for a
-fee.
-
- 2. You may modify your copy or copies of the Library or any portion
-of it, thus forming a work based on the Library, and copy and
-distribute such modifications or work under the terms of Section 1
-above, provided that you also meet all of these conditions:
-
- a) The modified work must itself be a software library.
-
- b) You must cause the files modified to carry prominent notices
- stating that you changed the files and the date of any change.
-
- c) You must cause the whole of the work to be licensed at no
- charge to all third parties under the terms of this License.
-
- d) If a facility in the modified Library refers to a function or a
- table of data to be supplied by an application program that uses
- the facility, other than as an argument passed when the facility
- is invoked, then you must make a good faith effort to ensure that,
- in the event an application does not supply such function or
- table, the facility still operates, and performs whatever part of
- its purpose remains meaningful.
-
- (For example, a function in a library to compute square roots has
- a purpose that is entirely well-defined independent of the
- application. Therefore, Subsection 2d requires that any
- application-supplied function or table used by this function must
- be optional: if the application does not supply it, the square
- root function must still compute square roots.)
-
-These requirements apply to the modified work as a whole. If
-identifiable sections of that work are not derived from the Library,
-and can be reasonably considered independent and separate works in
-themselves, then this License, and its terms, do not apply to those
-sections when you distribute them as separate works. But when you
-distribute the same sections as part of a whole which is a work based
-on the Library, the distribution of the whole must be on the terms of
-this License, whose permissions for other licensees extend to the
-entire whole, and thus to each and every part regardless of who wrote
-it.
-
-Thus, it is not the intent of this section to claim rights or contest
-your rights to work written entirely by you; rather, the intent is to
-exercise the right to control the distribution of derivative or
-collective works based on the Library.
-
-In addition, mere aggregation of another work not based on the Library
-with the Library (or with a work based on the Library) on a volume of
-a storage or distribution medium does not bring the other work under
-the scope of this License.
-
- 3. You may opt to apply the terms of the ordinary GNU General Public
-License instead of this License to a given copy of the Library. To do
-this, you must alter all the notices that refer to this License, so
-that they refer to the ordinary GNU General Public License, version 2,
-instead of to this License. (If a newer version than version 2 of the
-ordinary GNU General Public License has appeared, then you can specify
-that version instead if you wish.) Do not make any other change in
-these notices.
-
- Once this change is made in a given copy, it is irreversible for
-that copy, so the ordinary GNU General Public License applies to all
-subsequent copies and derivative works made from that copy.
-
- This option is useful when you wish to copy part of the code of
-the Library into a program that is not a library.
-
- 4. You may copy and distribute the Library (or a portion or
-derivative of it, under Section 2) in object code or executable form
-under the terms of Sections 1 and 2 above provided that you accompany
-it with the complete corresponding machine-readable source code, which
-must be distributed under the terms of Sections 1 and 2 above on a
-medium customarily used for software interchange.
-
- If distribution of object code is made by offering access to copy
-from a designated place, then offering equivalent access to copy the
-source code from the same place satisfies the requirement to
-distribute the source code, even though third parties are not
-compelled to copy the source along with the object code.
-
- 5. A program that contains no derivative of any portion of the
-Library, but is designed to work with the Library by being compiled or
-linked with it, is called a "work that uses the Library". Such a
-work, in isolation, is not a derivative work of the Library, and
-therefore falls outside the scope of this License.
-
- However, linking a "work that uses the Library" with the Library
-creates an executable that is a derivative of the Library (because it
-contains portions of the Library), rather than a "work that uses the
-library". The executable is therefore covered by this License.
-Section 6 states terms for distribution of such executables.
-
- When a "work that uses the Library" uses material from a header file
-that is part of the Library, the object code for the work may be a
-derivative work of the Library even though the source code is not.
-Whether this is true is especially significant if the work can be
-linked without the Library, or if the work is itself a library. The
-threshold for this to be true is not precisely defined by law.
-
- If such an object file uses only numerical parameters, data
-structure layouts and accessors, and small macros and small inline
-functions (ten lines or less in length), then the use of the object
-file is unrestricted, regardless of whether it is legally a derivative
-work. (Executables containing this object code plus portions of the
-Library will still fall under Section 6.)
-
- Otherwise, if the work is a derivative of the Library, you may
-distribute the object code for the work under the terms of Section 6.
-Any executables containing that work also fall under Section 6,
-whether or not they are linked directly with the Library itself.
-
- 6. As an exception to the Sections above, you may also combine or
-link a "work that uses the Library" with the Library to produce a
-work containing portions of the Library, and distribute that work
-under terms of your choice, provided that the terms permit
-modification of the work for the customer's own use and reverse
-engineering for debugging such modifications.
-
- You must give prominent notice with each copy of the work that the
-Library is used in it and that the Library and its use are covered by
-this License. You must supply a copy of this License. If the work
-during execution displays copyright notices, you must include the
-copyright notice for the Library among them, as well as a reference
-directing the user to the copy of this License. Also, you must do one
-of these things:
-
- a) Accompany the work with the complete corresponding
- machine-readable source code for the Library including whatever
- changes were used in the work (which must be distributed under
- Sections 1 and 2 above); and, if the work is an executable linked
- with the Library, with the complete machine-readable "work that
- uses the Library", as object code and/or source code, so that the
- user can modify the Library and then relink to produce a modified
- executable containing the modified Library. (It is understood
- that the user who changes the contents of definitions files in the
- Library will not necessarily be able to recompile the application
- to use the modified definitions.)
-
- b) Use a suitable shared library mechanism for linking with the
- Library. A suitable mechanism is one that (1) uses at run time a
- copy of the library already present on the user's computer system,
- rather than copying library functions into the executable, and (2)
- will operate properly with a modified version of the library, if
- the user installs one, as long as the modified version is
- interface-compatible with the version that the work was made with.
-
- c) Accompany the work with a written offer, valid for at least
- three years, to give the same user the materials specified in
- Subsection 6a, above, for a charge no more than the cost of
- performing this distribution.
-
- d) If distribution of the work is made by offering access to copy
- from a designated place, offer equivalent access to copy the above
- specified materials from the same place.
-
- e) Verify that the user has already received a copy of these
- materials or that you have already sent this user a copy.
-
- For an executable, the required form of the "work that uses the
-Library" must include any data and utility programs needed for
-reproducing the executable from it. However, as a special exception,
-the materials to be distributed need not include anything that is
-normally distributed (in either source or binary form) with the major
-components (compiler, kernel, and so on) of the operating system on
-which the executable runs, unless that component itself accompanies
-the executable.
-
- It may happen that this requirement contradicts the license
-restrictions of other proprietary libraries that do not normally
-accompany the operating system. Such a contradiction means you cannot
-use both them and the Library together in an executable that you
-distribute.
-
- 7. You may place library facilities that are a work based on the
-Library side-by-side in a single library together with other library
-facilities not covered by this License, and distribute such a combined
-library, provided that the separate distribution of the work based on
-the Library and of the other library facilities is otherwise
-permitted, and provided that you do these two things:
-
- a) Accompany the combined library with a copy of the same work
- based on the Library, uncombined with any other library
- facilities. This must be distributed under the terms of the
- Sections above.
-
- b) Give prominent notice with the combined library of the fact
- that part of it is a work based on the Library, and explaining
- where to find the accompanying uncombined form of the same work.
-
- 8. You may not copy, modify, sublicense, link with, or distribute
-the Library except as expressly provided under this License. Any
-attempt otherwise to copy, modify, sublicense, link with, or
-distribute the Library is void, and will automatically terminate your
-rights under this License. However, parties who have received copies,
-or rights, from you under this License will not have their licenses
-terminated so long as such parties remain in full compliance.
-
- 9. You are not required to accept this License, since you have not
-signed it. However, nothing else grants you permission to modify or
-distribute the Library or its derivative works. These actions are
-prohibited by law if you do not accept this License. Therefore, by
-modifying or distributing the Library (or any work based on the
-Library), you indicate your acceptance of this License to do so, and
-all its terms and conditions for copying, distributing or modifying
-the Library or works based on it.
-
- 10. Each time you redistribute the Library (or any work based on the
-Library), the recipient automatically receives a license from the
-original licensor to copy, distribute, link with or modify the Library
-subject to these terms and conditions. You may not impose any further
-restrictions on the recipients' exercise of the rights granted herein.
-You are not responsible for enforcing compliance by third parties with
-this License.
-
- 11. If, as a consequence of a court judgment or allegation of patent
-infringement or for any other reason (not limited to patent issues),
-conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License. If you cannot
-distribute so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you
-may not distribute the Library at all. For example, if a patent
-license would not permit royalty-free redistribution of the Library by
-all those who receive copies directly or indirectly through you, then
-the only way you could satisfy both it and this License would be to
-refrain entirely from distribution of the Library.
-
-If any portion of this section is held invalid or unenforceable under
-any particular circumstance, the balance of the section is intended to
-apply, and the section as a whole is intended to apply in other
-circumstances.
-
-It is not the purpose of this section to induce you to infringe any
-patents or other property right claims or to contest validity of any
-such claims; this section has the sole purpose of protecting the
-integrity of the free software distribution system which is
-implemented by public license practices. Many people have made
-generous contributions to the wide range of software distributed
-through that system in reliance on consistent application of that
-system; it is up to the author/donor to decide if he or she is willing
-to distribute software through any other system and a licensee cannot
-impose that choice.
-
-This section is intended to make thoroughly clear what is believed to
-be a consequence of the rest of this License.
-
- 12. If the distribution and/or use of the Library is restricted in
-certain countries either by patents or by copyrighted interfaces, the
-original copyright holder who places the Library under this License
-may add an explicit geographical distribution limitation excluding those
-countries, so that distribution is permitted only in or among
-countries not thus excluded. In such case, this License incorporates
-the limitation as if written in the body of this License.
-
- 13. The Free Software Foundation may publish revised and/or new
-versions of the Lesser General Public License from time to time.
-Such new versions will be similar in spirit to the present version,
-but may differ in detail to address new problems or concerns.
-
-Each version is given a distinguishing version number. If the Library
-specifies a version number of this License which applies to it and
-"any later version", you have the option of following the terms and
-conditions either of that version or of any later version published by
-the Free Software Foundation. If the Library does not specify a
-license version number, you may choose any version ever published by
-the Free Software Foundation.
-
- 14. If you wish to incorporate parts of the Library into other free
-programs whose distribution conditions are incompatible with these,
-write to the author to ask for permission. For software which is
-copyrighted by the Free Software Foundation, write to the Free
-Software Foundation; we sometimes make exceptions for this. Our
-decision will be guided by the two goals of preserving the free status
-of all derivatives of our free software and of promoting the sharing
-and reuse of software generally.
-
- NO WARRANTY
-
- 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
-WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
-EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
-OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
-KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
-LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
-THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
-
- 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
-WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
-AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
-FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
-CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
-LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
-RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
-FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
-SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
-DAMAGES.
-
- END OF TERMS AND CONDITIONS
-
- How to Apply These Terms to Your New Libraries
-
- If you develop a new library, and you want it to be of the greatest
-possible use to the public, we recommend making it free software that
-everyone can redistribute and change. You can do so by permitting
-redistribution under these terms (or, alternatively, under the terms
-of the ordinary General Public License).
-
- To apply these terms, attach the following notices to the library.
-It is safest to attach them to the start of each source file to most
-effectively convey the exclusion of warranty; and each file should
-have at least the "copyright" line and a pointer to where the full
-notice is found.
-
-
- <one line to give the library's name and a brief idea of what it does.>
- Copyright (C) <year> <name of author>
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-
-Also add information on how to contact you by electronic and paper mail.
-
-You should also get your employer (if you work as a programmer) or
-your school, if any, to sign a "copyright disclaimer" for the library,
-if necessary. Here is a sample; alter the names:
-
- Yoyodyne, Inc., hereby disclaims all copyright interest in the
- library `Frob' (a library for tweaking knobs) written by James
- Random Hacker.
-
- <signature of Ty Coon>, 1 April 1990
- Ty Coon, President of Vice
-
-That's all there is to it!
-
-
Deleted: residual/trunk/tools/bmtoppm.c
===================================================================
--- residual/trunk/tools/bmtoppm.c 2008-06-15 07:15:58 UTC (rev 32705)
+++ residual/trunk/tools/bmtoppm.c 2008-06-15 11:09:22 UTC (rev 32706)
@@ -1,246 +0,0 @@
-/* Residual - Virtual machine to run LucasArts' 3D adventure games
- * Copyright (C) 2003-2006 The ScummVM-Residual Team (www.scummvm.org)
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
-
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
-
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
- *
- * $URL$
- * $Id$
- *
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sys/types.h>
-#include <assert.h>
-
-#include <ppm.h>
-
-int32_t read_LEint32(FILE *f) {
- unsigned char c[4];
-
- fread(c, 1, 4, f);
- return (c[0]) | (c[1] << 8) | (c[2] << 16) | (c[3] << 24);
-}
-
-void read_header(FILE *in, int *codec, int *num_images, int *format) {
- char magic[8];
-
- fread(magic, 1, 8, in);
- if (memcmp(magic, "BM F\0\0\0", 8) != 0) {
- fprintf(stderr, "not a bitmap file\n");
- exit(1);
- }
- *codec = read_LEint32(in);
-
- read_LEint32(in);
- *num_images = read_LEint32(in);
- read_LEint32(in); /* ignore x offset */
- read_LEint32(in); /* ignore y offset */
- read_LEint32(in);
- *format = read_LEint32(in);
- fseek(in, 128, SEEK_SET);
-}
-
-void read_data_codec0(FILE *in, int width, int height, unsigned char *result) {
- fread(result, 1, width * height * 2, in);
-}
-
-void read_data_codec3(FILE *in, int size, unsigned char *result) {
- unsigned char *data;
- const unsigned char *data_ptr;
- int bitstr_val, bitstr_len;
- int offset, len;
-
- data = malloc(size);
- fread(data, 1, size, in);
-
- bitstr_val = data[0] | (data[1] << 8);
- bitstr_len = 16;
- data_ptr = data + 2;
-
-#define GET_BIT ({ \
- int bit_result = bitstr_val & 1; \
- bitstr_val >>= 1; \
- bitstr_len--; \
- if (bitstr_len == 0) { \
- bitstr_val = data_ptr[0] | (data_ptr[1] << 8); \
- bitstr_len = 16; \
- data_ptr += 2; \
- } \
- bit_result; \
- })
-
- for (;;) {
- if (GET_BIT == 1)
- *result++ = *data_ptr++;
- else {
- if (GET_BIT == 0) {
- len = GET_BIT * 2;
- len += GET_BIT;
- len += 3;
- offset = *data_ptr - 0x100;
- data_ptr++;
- }
- else {
- offset = data_ptr[0] | ((data_ptr[1] & 0xf0) << 4);
- offset -= 0x1000;
- len = (data_ptr[1] & 0xf) + 3;
- data_ptr += 2;
- if (len == 3) {
- len = *data_ptr++;
- len++;
- if (len == 1) {
- free(data);
- return;
- }
- }
- }
- while (len > 0) {
- *result = result[offset];
- result++;
- len--;
- }
- }
- }
-}
-
-void write_img(pixel **img, const char *fname, int img_num,
- int width, int height, int maxval) {
- const char *basename;
- char newname[1024];
- FILE *out;
-
- basename = strrchr(fname, '/');
- if (basename != NULL)
- basename++;
- else
- basename = fname;
- strcpy(newname, basename);
- if (strlen(newname) > 3 &&
- strcasecmp(newname + strlen(newname) - 3, ".bm") == 0)
- newname[strlen(newname) - 3] = '\0';
- else if (strlen(newname) > 4 &&
- strcasecmp(newname + strlen(newname) - 4, ".zbm") == 0) {
- newname[strlen(newname) - 4] = '\0';
- strcat(newname, "_z");
- }
- sprintf(newname + strlen(newname), "_%d.ppm", img_num);
-
- out = fopen(newname, "wb");
- if (out == NULL) {
- perror(newname);
- exit(1);
- }
-
- ppm_writeppm(out, img, width, height, maxval, 0);
- fclose(out);
-}
-
-pixel **toimg_fmt1(const unsigned char *data, int width, int height) {
- pixel **result;
- int x, y;
- int r, g, b;
-
- result = ppm_allocarray(width, height);
- for (y = 0; y < height; y++)
- for (x = 0; x < width; x++) {
- r = data[1] >> 3;
- r = (r << 3) | (r >> 2);
- g = ((data[1] & 7) << 3) | (data[0] >> 5);
- g = (g << 2) | (g >> 4);
- b = data[0] & 0x1f;
- b = (b << 3) | (b >> 2);
- PPM_ASSIGN(result[y][x], r, g, b);
- data += 2;
- }
- return result;
-}
-
-pixel **toimg_fmt5(const unsigned char *data, int width, int height) {
- pixel **result;
- int x, y;
- unsigned short gray;
-
- result = ppm_allocarray(width, height);
- for (y = 0; y < height; y++)
- for (x = 0; x < width; x++) {
- /* gray = data[0] | (data[1] << 8); */
- gray = data[1];
- PPM_ASSIGN(result[y][x], gray, gray, gray);
- data += 2;
- }
- return result;
-}
-
-void process_file(const char *fname) {
- FILE *in;
- int codec, num_images, format;
- int i;
- int width, height, size, maxval;
- unsigned char *data;
- pixel **img;
-
- in = fopen(fname, "rb");
- if (in == NULL) {
- perror(fname);
- exit(1);
- }
- read_header(in, &codec, &num_images, &format);
-
- for (i = 0; i < num_images; i++) {
- width = read_LEint32(in);
- height = read_LEint32(in);
- data = malloc(width * height * 2);
-
- if (codec == 0)
- read_data_codec0(in, width, height, data);
- else if (codec == 3) {
- size = read_LEint32(in);
- read_data_codec3(in, size, data);
- }
- else {
- fprintf(stderr, "%s: unsupported codec %d\n", fname, codec);
- exit(1);
- }
-
- if (format == 1) {
- img = toimg_fmt1(data, width, height);
- maxval = 255;
- }
- else if (format == 5) {
- img = toimg_fmt5(data, width, height);
- maxval = 255;
- }
- else {
- fprintf(stderr, "%s: unsupported format %d\n", fname, format);
- exit(1);
- }
-
- write_img(img, fname, i, width, height, maxval);
- free(data);
- ppm_freearray(img, height);
- }
- fclose(in);
-}
-
-int main(int argc, char **argv) {
- int i;
-
- ppm_init(&argc, argv);
- for (i = 1; i < argc; i++)
- process_file(argv[i]);
- return 0;
-}
Copied: residual/trunk/tools/bmtoppm.cpp (from rev 32691, residual/trunk/tools/bmtoppm.c)
===================================================================
--- residual/trunk/tools/bmtoppm.cpp (rev 0)
+++ residual/trunk/tools/bmtoppm.cpp 2008-06-15 11:09:22 UTC (rev 32706)
@@ -0,0 +1,246 @@
+/* Residual - Virtual machine to run LucasArts' 3D adventure games
+ * Copyright (C) 2003-2006 The ScummVM-Residual Team (www.scummvm.org)
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+ *
+ * $URL$
+ * $Id$
+ *
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+#include <assert.h>
+
+#include <ppm.h>
+
+int32_t read_LEint32(FILE *f) {
+ unsigned char c[4];
+
+ fread(c, 1, 4, f);
+ return (c[0]) | (c[1] << 8) | (c[2] << 16) | (c[3] << 24);
+}
+
+void read_header(FILE *in, int *codec, int *num_images, int *format) {
+ char magic[8];
+
+ fread(magic, 1, 8, in);
+ if (memcmp(magic, "BM F\0\0\0", 8) != 0) {
+ fprintf(stderr, "not a bitmap file\n");
+ exit(1);
+ }
+ *codec = read_LEint32(in);
+
+ read_LEint32(in);
+ *num_images = read_LEint32(in);
+ read_LEint32(in); /* ignore x offset */
+ read_LEint32(in); /* ignore y offset */
+ read_LEint32(in);
+ *format = read_LEint32(in);
+ fseek(in, 128, SEEK_SET);
+}
+
+void read_data_codec0(FILE *in, int width, int height, unsigned char *result) {
+ fread(result, 1, width * height * 2, in);
+}
+
+void read_data_codec3(FILE *in, int size, unsigned char *result) {
+ unsigned char *data;
+ const unsigned char *data_ptr;
+ int bitstr_val, bitstr_len;
+ int offset, len;
+
+ data = malloc(size);
+ fread(data, 1, size, in);
+
+ bitstr_val = data[0] | (data[1] << 8);
+ bitstr_len = 16;
+ data_ptr = data + 2;
+
+#define GET_BIT ({ \
+ int bit_result = bitstr_val & 1; \
+ bitstr_val >>= 1; \
+ bitstr_len--; \
+ if (bitstr_len == 0) { \
+ bitstr_val = data_ptr[0] | (data_ptr[1] << 8); \
+ bitstr_len = 16; \
+ data_ptr += 2; \
+ } \
+ bit_result; \
+ })
+
+ for (;;) {
+ if (GET_BIT == 1)
+ *result++ = *data_ptr++;
+ else {
+ if (GET_BIT == 0) {
+ len = GET_BIT * 2;
+ len += GET_BIT;
+ len += 3;
+ offset = *data_ptr - 0x100;
+ data_ptr++;
+ }
+ else {
+ offset = data_ptr[0] | ((data_ptr[1] & 0xf0) << 4);
+ offset -= 0x1000;
+ len = (data_ptr[1] & 0xf) + 3;
+ data_ptr += 2;
+ if (len == 3) {
+ len = *data_ptr++;
+ len++;
+ if (len == 1) {
+ free(data);
+ return;
+ }
+ }
+ }
+ while (len > 0) {
+ *result = result[offset];
+ result++;
+ len--;
+ }
+ }
+ }
+}
+
+void write_img(pixel **img, const char *fname, int img_num,
+ int width, int height, int maxval) {
+ const char *basename;
+ char newname[1024];
+ FILE *out;
+
+ basename = strrchr(fname, '/');
+ if (basename != NULL)
+ basename++;
+ else
+ basename = fname;
+ strcpy(newname, basename);
+ if (strlen(newname) > 3 &&
+ strcasecmp(newname + strlen(newname) - 3, ".bm") == 0)
+ newname[strlen(newname) - 3] = '\0';
+ else if (strlen(newname) > 4 &&
+ strcasecmp(newname + strlen(newname) - 4, ".zbm") == 0) {
+ newname[strlen(newname) - 4] = '\0';
+ strcat(newname, "_z");
+ }
+ sprintf(newname + strlen(newname), "_%d.ppm", img_num);
+
+ out = fopen(newname, "wb");
+ if (out == NULL) {
+ perror(newname);
+ exit(1);
+ }
+
+ ppm_writeppm(out, img, width, height, maxval, 0);
+ fclose(out);
+}
+
+pixel **toimg_fmt1(const unsigned char *data, int width, int height) {
+ pixel **result;
+ int x, y;
+ int r, g, b;
+
+ result = ppm_allocarray(width, height);
+ for (y = 0; y < height; y++)
+ for (x = 0; x < width; x++) {
+ r = data[1] >> 3;
+ r = (r << 3) | (r >> 2);
+ g = ((data[1] & 7) << 3) | (data[0] >> 5);
+ g = (g << 2) | (g >> 4);
+ b = data[0] & 0x1f;
+ b = (b << 3) | (b >> 2);
+ PPM_ASSIGN(result[y][x], r, g, b);
+ data += 2;
+ }
+ return result;
+}
+
+pixel **toimg_fmt5(const unsigned char *data, int width, int height) {
+ pixel **result;
+ int x, y;
+ unsigned short gray;
+
+ result = ppm_allocarray(width, height);
+ for (y = 0; y < height; y++)
+ for (x = 0; x < width; x++) {
+ /* gray = data[0] | (data[1] << 8); */
+ gray = data[1];
+ PPM_ASSIGN(result[y][x], gray, gray, gray);
+ data += 2;
+ }
+ return result;
+}
+
+void process_file(const char *fname) {
+ FILE *in;
+ int codec, num_images, format;
+ int i;
+ int width, height, size, maxval;
+ unsigned char *data;
+ pixel **img;
+
+ in = fopen(fname, "rb");
+ if (in == NULL) {
+ perror(fname);
+ exit(1);
+ }
+ read_header(in, &codec, &num_images, &format);
+
+ for (i = 0; i < num_images; i++) {
+ width = read_LEint32(in);
+ height = read_LEint32(in);
+ data = malloc(width * height * 2);
+
+ if (codec == 0)
+ read_data_codec0(in, width, height, data);
+ else if (codec == 3) {
+ size = read_LEint32(in);
+ read_data_codec3(in, size, data);
+ }
+ else {
+ fprintf(stderr, "%s: unsupported codec %d\n", fname, codec);
+ exit(1);
+ }
+
+ if (format == 1) {
+ img = toimg_fmt1(data, width, height);
+ maxval = 255;
+ }
+ else if (format == 5) {
+ img = toimg_fmt5(data, width, height);
+ maxval = 255;
+ }
+ else {
+ fprintf(stderr, "%s: unsupported format %d\n", fname, format);
+ exit(1);
+ }
+
+ write_img(img, fname, i, width, height, maxval);
+ free(data);
+ ppm_freearray(img, height);
+ }
+ fclose(in);
+}
+
+int main(int argc, char **argv) {
+ int i;
+
+ ppm_init(&argc, argv);
+ for (i = 1; i < argc; i++)
+ process_file(argv[i]);
+ return 0;
+}
Property changes on: residual/trunk/tools/bmtoppm.cpp
___________________________________________________________________
Name: svn:mime-type
+ text/plain
Name: svn:keywords
+ Date Revision Author URL Id
Name: svn:eol-style
+ native
Deleted: residual/trunk/tools/delua.cc
===================================================================
--- residual/trunk/tools/delua.cc 2008-06-15 07:15:58 UTC (rev 32705)
+++ residual/trunk/tools/delua.cc 2008-06-15 11:09:22 UTC (rev 32706)
@@ -1,1313 +0,0 @@
-/* Residual - Virtual machine to run LucasArts' 3D adventure games
- * Copyright (C) 2003-2006 The ScummVM-Residual Team (www.scummvm.org)
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
-
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
-
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
- *
- * $URL$
- * $Id$
- *
- */
-
-#include "lua.h"
-#include "lundump.h"
-#include "lopcodes.h"
-#include "lzio.h"
-#include <stdio.h>
-#include <stdlib.h>
-#include <stdarg.h>
-#include <ctype.h>
-#include <iostream>
-#include <sstream>
-#include <map>
-#include <queue>
-#include <stack>
-#include <list>
-#include <set>
-
-#include "localize.h"
-
-// Provide debug.cpp functions which don't call SDL_Quit.
-void warning(const char *fmt, ...) {
- fprintf(stderr, "WARNING: ");
- va_list va;
- va_start(va, fmt);
- vfprintf(stderr, fmt, va);
- va_end(va);
- fprintf(stderr, "\n");
-}
-
-void error(const char *fmt, ...) {
- fprintf(stderr, "ERROR: ");
- va_list va;
- va_start(va, fmt);
- vfprintf(stderr, fmt, va);
- va_end(va);
- fprintf(stderr, "\n");
- exit(1);
-}
-
-static bool translateStrings = false;
-
-class Expression;
-
-void decompile(std::ostream &os, TProtoFunc *tf, std::string indent_str,
- Expression **upvals, int num_upvals);
-
-std::string localname(TProtoFunc *tf, int n) {
- LocVar *l = tf->locvars;
- if (l != NULL)
- for (int i = 0; i < n; i++, l++)
- if (l->varname == NULL) {
- l = NULL;
- break;
- }
- if (l != NULL)
- return l->varname->str;
- else {
- std::ostringstream s;
- if (n < tf->code[1])
- s << "arg" << n + 1;
- else
- s << "local" << n - tf->code[1] + 1;
- return s.str();
- }
-}
-
-class Expression {
-public:
- Expression(Byte *p) : pos(p) { }
- Byte *pos; // Position just after the expression
- // is pushed onto the stack
- virtual void print(std::ostream &os) const = 0;
- virtual int precedence() const { return 100; }
- virtual ~Expression() { }
-};
-
-inline std::ostream& operator <<(std::ostream &os, const Expression &e) {
- e.print(os);
- return os;
-}
-
-class NumberExpr : public Expression {
-public:
- NumberExpr(Byte *p, float val) : Expression(p), value(val) { }
- float value;
- void print(std::ostream &os) const { os << value; }
-};
-
-class VarExpr : public Expression {
-public:
- VarExpr(Byte *p, std::string varname) : Expression(p), name(varname) { }
- std::string name;
- void print(std::ostream &os) const { os << name; }
-};
-
-class StringExpr : public Expression {
-public:
- StringExpr(Byte *p, TaggedString *txt) : Expression(p), text(txt) { }
- TaggedString *text;
- bool validIdentifier() const {
- if (text->u.s.len == 0)
- return false;
- if (isdigit(text->str[0]))
- return false;
- if (text->str[0] >= '0' && text->str[0] <= '9')
- return false;
- for (int i = 0; i < text->u.s.len; i++) {
- char c = text->str[i];
- if ((! isalnum(text->str[0])) && c != '_')
- return false;
- }
- return true;
- }
- void print(std::ostream &os) const {
- static char *specials = "\a\b\f\n\r\t\v\\\"";
- static char *special_text[] = {
- "\\a", "\\b", "\\f", "\\n", "\\r", "\\t", "\\v", "\\\\", "\\\""
- };
-
- os << "\"";
- std::string str(text->str, text->u.s.len);
- if (translateStrings)
- str = g_localizer->localize(str.c_str());
- for (std::string::iterator i = str.begin(); i != str.end(); i++) {
- unsigned char c = *i;
- if (strchr(specials, c)) {
- int i = strchr(specials, c) - specials;
- os << special_text[i];
- }
- else if (! isprint(c))
- os << "\\" << int(c >> 6) << int((c >> 3) & 7) << int(c & 7);
- else
- os << c;
- }
- os << "\"";
- }
-};
-
-class FuncExpr : public Expression {
-public:
- FuncExpr(Byte *p, TProtoFunc *tf0, std::string is) :
- Expression(p), indent_str(is), tf(tf0), upvals(NULL), num_upvals(0) { }
- std::string indent_str;
- TProtoFunc *tf;
- Expression **upvals;
- int num_upvals;
-
- void print(std::ostream &os) const {
- os << "function(";
- for (int i = 0; i < tf->code[1]; i++) {
- os << localname(tf, i);
- if (i + 1 < tf->code[1])
- os << ", ";
- }
- os << ") -- line " << tf->lineDefined << std::endl;
- decompile(os, tf, indent_str + std::string(4, ' '),
- upvals, num_upvals);
- os << indent_str << "end";
- }
- ~FuncExpr() {
- for (int i = 0; i < num_upvals; i++)
- delete upvals[i];
- delete[] upvals;
- }
-};
-
-class IndexExpr : public Expression {
-public:
- IndexExpr(Byte *p, Expression *tbl, Expression *i)
- : Expression(p), table(tbl), index(i) { }
- Expression *table, *index;
- void print(std::ostream &os) const {
- table->print(os);
- StringExpr *field = dynamic_cast<StringExpr *>(index);
- if (field != NULL && field->validIdentifier())
- os << "." << field->text->str;
- else
- os << "[" << *index << "]";
- }
- ~IndexExpr() {
- delete table;
- delete index;
- }
-};
-
-class SelfExpr : public IndexExpr {
-public:
- SelfExpr(Byte *p, Expression *tbl, StringExpr *i) : IndexExpr(p, tbl, i) { }
- void print(std::ostream &os) const {
- StringExpr *field = static_cast<StringExpr *>(index);
- os << *table << ":" << field->text->str;
- }
-};
-
-class FuncCallExpr : public Expression {
-public:
- FuncCallExpr(Byte *p) : Expression(p) { }
- int num_args;
- Expression **args;
- Expression *func;
- void print(std::ostream &os) const {
- os << *func << "(";
- int i = 0;
-
- // Skip implicit self argument in a:b(c)
- if (dynamic_cast<SelfExpr *>(func) != NULL)
- i = 1;
- for (; i < num_args; i++) {
- args[i]->print(os);
- if (i + 1 < num_args)
- os << ", ";
- }
- os << ")";
- }
- ~FuncCallExpr() {
- for (int i = 0; i < num_args; i++)
- delete args[i];
- delete args;
- delete func;
- }
-};
-
-class ArrayExpr : public Expression {
-public:
- ArrayExpr(Byte *p) : Expression(p) { }
- typedef std::pair<Expression *, Expression *> mapping;
- typedef std::list<mapping> mapping_list;
- mapping_list mappings;
- void print(std::ostream &os) const {
- os << "{";
- mapping_list::const_iterator i = mappings.begin();
- while (i != mappings.end()) {
- if (i->first != NULL) {
- StringExpr *field = dynamic_cast<StringExpr *>(i->first);
- if (field != NULL && field->validIdentifier())
- os << " " << field->text->str;
- else
- os << " [" << *i->first << "]";
- os << " =";
- }
- os << " " << *i->second;
- i++;
- if (i != mappings.end())
- os << ",";
- }
- os << " }";
- }
- ~ArrayExpr() {
- for (mapping_list::iterator i = mappings.begin();
- i != mappings.end(); i++) {
- delete i->first;
- delete i->second;
- }
- }
-};
-
-class BinaryExpr : public Expression {
-public:
- BinaryExpr(Byte *ps, Expression *l, Expression *r, int p, bool ra,
- std::string o) :
- Expression(ps), left(l), right(r), prec(p), right_assoc(ra), op(o) { }
- Expression *left, *right;
- int prec;
- bool right_assoc;
- std::string op;
- int precedence() const { return prec; }
- void print(std::ostream &os) const {
- if (left->precedence() < prec ||
- (left->precedence() == prec && right_assoc))
- os << "(" << *left << ")";
- else
- os << *left;
- os << op;
- if (right->precedence() < prec ||
- (right->precedence() == prec && ! right_assoc))
- os << "(" << *right << ")";
- else
- os << *right;
- }
- ~BinaryExpr() { delete left; delete right; }
-};
-
-class UnaryExpr : public Expression {
-public:
- UnaryExpr(Byte *ps, Expression *a, int p, std::string o) :
- Expression(ps), arg(a), prec(p), op(o) { }
- Expression *arg;
- int prec;
- std::string op;
- int precedence() const { return prec; }
- void print(std::ostream &os) const {
- os << op;
- if (arg->precedence() < prec)
- os << "(" << *arg << ")";
- else
- os << *arg;
- }
- ~UnaryExpr() { delete arg; }
-};
-
-typedef std::stack<Expression *> ExprStack;
-
-class Decompiler {
-public:
- void decompileRange(Byte *start, Byte *end);
-
- std::ostream *os;
- ExprStack *stk;
- TProtoFunc *tf;
- std::string indent_str;
- Byte *break_pos;
- Expression **upvals; int num_upvals;
- std::multiset<Byte *> *local_var_defs;
-
-private:
- void do_multi_assign(Byte *&start);
- void do_binary_op(Byte *pos, int prec, bool right_assoc, std::string op);
- void do_unary_op(Byte *pos, int prec, std::string op);
- static bool is_expr_opc(Byte opc);
- void get_else_part(Byte *start, Byte *&if_part_end,
- bool &has_else, Byte *&else_part_end);
-};
-
-// Scan for a series of assignments
-void Decompiler::do_multi_assign(Byte *&start) {
- std::queue<Expression *> results;
- ExprStack values;
-
- bool done;
- int num_tables = 0;
- do {
- int aux, opc;
- done = false;
-
- opc = *start++;
- switch (opc) {
- case SETLOCAL:
- aux = *start++;
- goto setlocal;
-
- case SETLOCAL0:
- case SETLOCAL1:
- case SETLOCAL2:
- case SETLOCAL3:
- case SETLOCAL4:
- case SETLOCAL5:
- case SETLOCAL6:
- case SETLOCAL7:
- aux = opc - SETLOCAL0;
- setlocal:
- results.push(new VarExpr(start, localname(tf, aux)));
- break;
-
- case SETGLOBAL:
- aux = *start++;
- goto setglobal;
-
- case SETGLOBAL0:
- case SETGLOBAL1:
- case SETGLOBAL2:
- case SETGLOBAL3:
- case SETGLOBAL4:
- case SETGLOBAL5:
- case SETGLOBAL6:
- case SETGLOBAL7:
- aux = opc - SETGLOBAL0;
- goto setglobal;
-
- case SETGLOBALW:
- aux = start[0] | (start[1] << 8);
- start += 2;
- setglobal:
- results.push(new VarExpr(start, svalue(tf->consts + aux)));
- break;
-
- case SETTABLE:
- start++; // assume offset is correct
- case SETTABLE0:
- results.push(new IndexExpr(start, NULL, NULL));
- num_tables++;
- // this needs stuff from farther up the stack, wait until
- // it's available
- break;
-
- default:
- start--;
- done = true;
- }
-
- if (! done) {
- Expression *e = stk->top();
- // Check for fake result from function calls with multiple return values
- VarExpr *v = dynamic_cast<VarExpr *>(e);
- if (v != NULL && v->name == "<extra result>")
- delete e;
- else
- values.push(e);
- stk->pop();
- }
- } while (! done);
-
- // Check for popping tables and indices
- if (num_tables > 0 && (*start == POP || *start == POP0 || *start == POP1)) {
- start++;
- if (start[-1] == POP)
- start++;
- }
-
- // Now get actual tables and indices from the stack, reversing
- // the list to the right order at the same time
-
- ExprStack results2;
- while (! results.empty()) {
- Expression *var = results.front(); results.pop();
- IndexExpr *tbl = dynamic_cast<IndexExpr *>(var);
- if (tbl != NULL) {
- tbl->index = stk->top(); stk->pop();
- tbl->table = stk->top(); stk->pop();
- }
- results2.push(var);
- }
-
- *os << indent_str;
- while (! results2.empty()) {
- Expression *var = results2.top(); results2.pop();
- *os << *var;
- delete var;
- if (! results2.empty())
- *os << ", ";
- }
- *os << " = ";
- while (! values.empty()) {
- Expression *val = values.top(); values.pop();
- *os << *val;
- delete val;
- if (! values.empty())
- *os << ", ";
- }
- *os << std::endl;
-}
-
-void Decompiler::do_binary_op(Byte *pos, int prec, bool right_assoc,
- std::string op) {
- Expression *right = stk->top(); stk->pop();
- Expression *left = stk->top(); stk->pop();
- stk->push(new BinaryExpr(pos, left, right, prec, right_assoc, op));
-}
-
-void Decompiler::do_unary_op(Byte *pos, int prec, std::string op) {
- Expression *arg = stk->top(); stk->pop();
- stk->push(new UnaryExpr(pos, arg, prec, op));
-}
-
-// Provide instruction lengths to make it easy to scan through instructions
-int instr_lens[] = {
- 1, // ENDCODE
- 2, // PUSHNIL
- 1, // PUSHNIL0
- 2, // PUSHNUMBER
- 1, 1, 1, // PUSHNUMBER0..2
- 3, // PUSHNUMBERW
- 2, // PUSHCONSTANT
- 1, 1, 1, 1, 1, 1, 1, 1, // PUSHCONSTANT0..7
- 3, // PUSHCONSTANTW
- 2, // PUSHUPVALUE
- 1, 1, // PUSHUPVALUE0,1
- 2, // PUSHLOCAL
- 1, 1, 1, 1, 1, 1, 1, 1, // PUSHLOCAL0..7
- 2, // GETGLOBAL
- 1, 1, 1, 1, 1, 1, 1, 1, // GETGLOBAL0..7
- 3, // GETGLOBALW
- 1, // GETTABLE
- 2, // GETDOTTED
- 1, 1, 1, 1, 1, 1, 1, 1, // GETDOTTED0..7
- 3, // GETDOTTEDW
- 2, // PUSHSELF
- 1, 1, 1, 1, 1, 1, 1, 1, // PUSHSELF0..7
- 3, // PUSHSELFW
- 2, // CREATEARRAY
- 1, 1, // CREATEARRAY0,1
- 3, // CREATEARRAYW
- 2, // SETLOCAL
- 1, 1, 1, 1, 1, 1, 1, 1, // SETLOCAL0..7
- 2, // SETGLOBAL
- 1, 1, 1, 1, 1, 1, 1, 1, // SETGLOBAL0..7
- 3, // SETGLOBALW
- 1, // SETTABLE0
- 2, // SETTABLE
- 3, // SETLIST
- 2, // SETLIST0
- 4, // SETLISTW
- 2, // SETMAP
- 1, // SETMAP0
- 1, // EQOP
- 1, // NEQOP
- 1, // LTOP
- 1, // LEOP
- 1, // GTOP
- 1, // GEOP
- 1, // ADDOP
- 1, // SUBOP
- 1, // MULTOP
- 1, // DIVOP
- 1, // POWOP
- 1, // CONCOP
- 1, // MINUSOP
- 1, // NOTOP
- 2, 3, // ONTJMP, ONTJMPW
- 2, 3, // ONFJMP, ONFJMPW
- 2, 3, // JMP, JMPW
- 2, 3, // IFFJMP, IFFJMPW
- 2, 3, // IFTUPJMP, IFTUPJMPW
- 2, 3, // IFFUPJMP, IFFUPJMPW
- 2, // CLOSURE
- 1, 1, // CLOSURE0,1
- 3, // CALLFUNC
- 2, 2, // CALLFUNC0,1
- 2, // RETCODE
- 2, // SETLINE
- 3, // SETLINEW
- 2, // POP
- 1, 1 // POP0,1
-};
-
-bool Decompiler::is_expr_opc(Byte opc) {
- if (opc >= PUSHNIL && opc <= CREATEARRAYW)
- return true;
- if (opc == SETLIST0)
- return true;
- if (opc >= SETMAP && opc <= ONFJMPW)
- return true;
- if (opc >= CLOSURE && opc <= CLOSURE1)
- return true;
- if (opc == CALLFUNC1 || opc == SETLINE || opc == SETLINEW)
- return true;
- return false;
-}
-
-// Check for JMP or JMPW at end of "if" part
-void Decompiler::get_else_part(Byte *start, Byte *&if_part_end,
- bool &has_else, Byte *&else_part_end) {
- Byte *last_instr = NULL;
- has_else = false;
- else_part_end = NULL;
-
- for (Byte *instr_scan = start; instr_scan < if_part_end;
- instr_scan += instr_lens[*instr_scan])
- last_instr = instr_scan;
- if (last_instr != NULL &&
- (*last_instr == JMP || *last_instr == JMPW)) {
- has_else = true;
- else_part_end = if_part_end + last_instr[1];
- if (*last_instr == JMPW)
- else_part_end += (last_instr[2] << 8);
- if_part_end = last_instr;
- }
-}
-
-void Decompiler::decompileRange(Byte *start, Byte *end) {
- // First, scan for IFFUPJMP, which is used for repeat/until, so
- // we can recognize the start of such loops. We only keep the
- // last value to match each address, which represents the outermost
- // repeat/until loop starting at that point.
- std::map<Byte *, Byte *> rev_iffupjmp_map;
-
- for (Byte *scan = start; end == NULL || scan < end;
- scan += instr_lens[*scan]) {
- if (*scan == IFFUPJMP)
- rev_iffupjmp_map[scan + 2 - scan[1]] = scan;
- else if (*scan == IFFUPJMPW)
- rev_iffupjmp_map[scan + 3 - (scan[1] | (scan[2] << 8))] = scan;
- else if (*scan == ENDCODE)
- break;
- }
-
- while (end == NULL || start < end) {
- int locs_here = local_var_defs->count(start);
- if (locs_here > 0) {
- // There were local variable slots just pushed onto the stack
- // Print them out (in the second pass)
-
- // First, if there are multiple defined, it must be from
- // local x, y, z = f() or local a, b. So just ignore the extra
- // entries.
- for (int i = 1; i < locs_here; i++) {
- delete stk->top(); stk->pop();
- }
- Expression *def = stk->top(); stk->pop();
-
- // Print the local variable names, and at the same time push
- // fake values onto the stack
- *os << indent_str << "local ";
- for (int i = 0; i < locs_here; i++) {
- std::string locname = localname(tf, tf->code[1] + stk->size());
- *os << locname;
- if (i + 1 < locs_here)
- *os << ", ";
- stk->push(new VarExpr(start, "<" + locname + " stack slot>"));
- }
-
- // Print the definition, unless it's nil
- VarExpr *v = dynamic_cast<VarExpr *>(def);
- if (v == NULL || v->name != "nil")
- *os << " = " << *def;
- *os << std::endl;
- }
-
- if (rev_iffupjmp_map.find(start) != rev_iffupjmp_map.end()) {
- // aha, do a repeat/until loop
- *os << indent_str << "repeat\n";
- Decompiler indented_dc = *this;
- indented_dc.indent_str += std::string(4, ' ');
- indented_dc.break_pos = rev_iffupjmp_map[start];
- indented_dc.break_pos += instr_lens[*indented_dc.break_pos];
- indented_dc.decompileRange(start, rev_iffupjmp_map[start]);
-
- Expression *e = stk->top(); stk->pop();
- *os << indent_str << "until " << *e << std::endl;
- delete e;
-
- start = indented_dc.break_pos;
- continue;
- }
-
- Byte opc = *start++;
- int aux;
-
- switch (opc) {
- case ENDCODE:
- return;
-
- case PUSHNIL:
- aux = *start++;
- goto pushnil;
-
- case PUSHNIL0:
- aux = 0;
- pushnil:
- for (int i = 0; i <= aux; i++)
- stk->push(new VarExpr(start, "nil")); // Cheat a little :)
- break;
-
- case PUSHNUMBER:
- aux = *start++;
- goto pushnumber;
-
- case PUSHNUMBER0:
- case PUSHNUMBER1:
- case PUSHNUMBER2:
- aux = opc - PUSHNUMBER0;
- goto pushnumber;
-
- case PUSHNUMBERW:
- aux = start[0] | (start[1] << 8);
- start += 2;
- pushnumber:
- stk->push(new NumberExpr(start, aux));
- break;
-
- case PUSHCONSTANT:
- aux = *start++;
- goto pushconst;
-
- case PUSHCONSTANT0:
- case PUSHCONSTANT1:
- case PUSHCONSTANT2:
- case PUSHCONSTANT3:
- case PUSHCONSTANT4:
- case PUSHCONSTANT5:
- case PUSHCONSTANT6:
- case PUSHCONSTANT7:
- aux = opc - PUSHCONSTANT0;
- goto pushconst;
-
- case PUSHCONSTANTW:
- aux = start[0] | (start[1] << 8);
- start += 2;
- pushconst:
- switch (ttype(tf->consts + aux)) {
- case LUA_T_STRING:
- stk->push(new StringExpr(start, tsvalue(tf->consts + aux)));
- break;
- case LUA_T_NUMBER:
- stk->push(new NumberExpr(start, nvalue(tf->consts + aux)));
- break;
- case LUA_T_PROTO:
- stk->push(new FuncExpr(start, tfvalue(tf->consts + aux), indent_str));
- break;
- default:
- *os << indent_str << "error: invalid constant type "
- << int(ttype(tf->consts + aux)) << std::endl;
- }
- break;
-
- case PUSHUPVALUE:
- aux = *start++;
- goto pushupvalue;
-
- case PUSHUPVALUE0:
- case PUSHUPVALUE1:
- aux = opc - PUSHUPVALUE0;
- pushupvalue:
- {
- if (aux >= num_upvals) {
- *os << indent_str << "error: invalid upvalue #"
- << aux << std::endl;
- }
-
- std::ostringstream s;
- s << "%" << *upvals[aux];
- stk->push(new VarExpr(start, s.str()));
- }
- break;
-
- case PUSHLOCAL:
- aux = *start++;
- goto pushlocal;
-
- case PUSHLOCAL0:
- case PUSHLOCAL1:
- case PUSHLOCAL2:
- case PUSHLOCAL3:
- case PUSHLOCAL4:
- case PUSHLOCAL5:
- case PUSHLOCAL6:
- case PUSHLOCAL7:
- aux = opc - PUSHLOCAL0;
- pushlocal:
- stk->push(new VarExpr(start, localname(tf, aux)));
- break;
-
- case GETGLOBAL:
- aux = *start++;
- goto getglobal;
-
- case GETGLOBAL0:
- case GETGLOBAL1:
- case GETGLOBAL2:
- case GETGLOBAL3:
- case GETGLOBAL4:
- case GETGLOBAL5:
- case GETGLOBAL6:
- case GETGLOBAL7:
- aux = opc - GETGLOBAL0;
- goto getglobal;
-
- case GETGLOBALW:
- aux = start[0] | (start[1] << 8);
- start += 2;
- getglobal:
- stk->push(new VarExpr(start, svalue(tf->consts + aux)));
- break;
-
- case GETTABLE:
- {
- Expression *index = stk->top(); stk->pop();
- Expression *table = stk->top(); stk->pop();
-
- stk->push(new IndexExpr(start, table, index));
- }
- break;
-
- case GETDOTTED:
- aux = *start++;
- goto getdotted;
-
- case GETDOTTED0:
- case GETDOTTED1:
- case GETDOTTED2:
- case GETDOTTED3:
- case GETDOTTED4:
- case GETDOTTED5:
- case GETDOTTED6:
- case GETDOTTED7:
- aux = opc - GETDOTTED0;
- goto getdotted;
-
- case GETDOTTEDW:
- aux = start[0] | (start[1] << 8);
- start += 2;
- getdotted:
- {
- Expression *tbl = stk->top(); stk->pop();
- stk->push(new IndexExpr(start, tbl, new StringExpr
- (start, tsvalue(tf->consts + aux))));
- }
- break;
-
- case PUSHSELF:
- aux = *start++;
- goto pushself;
-
- case PUSHSELF0:
- case PUSHSELF1:
- case PUSHSELF2:
- case PUSHSELF3:
- case PUSHSELF4:
- case PUSHSELF5:
- case PUSHSELF6:
- case PUSHSELF7:
- aux = opc - PUSHSELF0;
- goto pushself;
-
- case PUSHSELFW:
- aux = start[0] | (start[1] << 8);
- start += 2;
- pushself:
- {
- Expression *tbl = stk->top(); stk->pop();
- stk->push(new SelfExpr(start, tbl, new StringExpr
- (start, tsvalue(tf->consts + aux))));
- stk->push(new VarExpr(start, "<self>"));
- // Fake value, FuncCallExpr will handle it
- }
- break;
-
- case CREATEARRAY:
- start++;
- goto createarray;
-
- case CREATEARRAY0:
- case CREATEARRAY1:
- goto createarray;
-
- case CREATEARRAYW:
- start += 2;
- createarray:
- stk->push(new ArrayExpr(start));
- break;
-
- case SETLOCAL:
- case SETLOCAL0:
- case SETLOCAL1:
- case SETLOCAL2:
- case SETLOCAL3:
- case SETLOCAL4:
- case SETLOCAL5:
- case SETLOCAL6:
- case SETLOCAL7:
- case SETGLOBAL:
- case SETGLOBAL0:
- case SETGLOBAL1:
- case SETGLOBAL2:
- case SETGLOBAL3:
- case SETGLOBAL4:
- case SETGLOBAL5:
- case SETGLOBAL6:
- case SETGLOBAL7:
- case SETGLOBALW:
- case SETTABLE0:
- case SETTABLE:
- start--;
- do_multi_assign(start);
- break;
-
- case SETLIST:
- start++; // assume offset is correct
- goto setlist;
-
- case SETLISTW:
- start += 2;
-
- case SETLIST0:
- setlist:
- aux = *start++;
- {
- ArrayExpr::mapping_list new_mappings;
- for (int i = 0; i < aux; i++) {
- Expression *val = stk->top(); stk->pop();
- new_mappings.push_front(std::make_pair((Expression *) NULL, val));
- }
- ArrayExpr *a = dynamic_cast<ArrayExpr *>(stk->top());
- if (a == NULL) {
- *os << indent_str
- << "error: attempt to setlist a non-array object\n";
- }
- // Append the new list
- a->mappings.splice(a->mappings.end(), new_mappings);
- a->pos = start;
- }
- break;
-
- case SETMAP:
- aux = *start++;
- goto setmap;
-
- case SETMAP0:
- aux = 0;
- setmap:
- {
- ArrayExpr::mapping_list new_mappings;
- for (int i = 0; i <= aux; i++) {
- Expression *val = stk->top(); stk->pop();
- Expression *key = stk->top(); stk->pop();
- new_mappings.push_front(std::make_pair(key, val));
- }
- ArrayExpr *a = dynamic_cast<ArrayExpr *>(stk->top());
- if (a == NULL) {
- *os << indent_str
- << "error: attempt to setmap a non-array object\n";
- }
- // Append the new list
- a->mappings.splice(a->mappings.end(), new_mappings);
- a->pos = start;
- }
- break;
-
- case EQOP:
- do_binary_op(start, 1, false, " == ");
- break;
-
- case NEQOP:
- do_binary_op(start, 1, false, " ~= ");
- break;
-
- case LTOP:
- do_binary_op(start, 1, false, " < ");
- break;
-
- case LEOP:
- do_binary_op(start, 1, false, " <= ");
- break;
-
- case GTOP:
- do_binary_op(start, 1, false, " > ");
- break;
-
- case GEOP:
- do_binary_op(start, 1, false, " >= ");
- break;
-
- case ADDOP:
- do_binary_op(start, 3, false, " + ");
- break;
-
- case SUBOP:
- do_binary_op(start, 3, false, " - ");
- break;
-
- case MULTOP:
- do_binary_op(start, 4, false, " * ");
- break;
-
- case DIVOP:
- do_binary_op(start, 4, false, " / ");
- break;
-
- case POWOP:
- do_binary_op(start, 6, true, " ^ ");
- break;
-
- case CONCOP:
- do_binary_op(start, 2, false, "..");
- break;
-
- case MINUSOP:
- do_unary_op(start, 5, "-");
- break;
-
- case NOTOP:
- do_unary_op(start, 5, "not ");
- break;
-
- case ONTJMP:
- aux = *start++;
- goto ontjmp;
-
- case ONTJMPW:
- aux = start[0] | (start[1] << 8);
- start += 2;
- ontjmp:
- // push_expr_1 ontjmp(label) push_expr_2 label: -> expr_1 || expr_2
- decompileRange(start, start + aux);
- do_binary_op(start + aux, 0, false, " or ");
- start = start + aux;
- break;
-
- case ONFJMP:
- aux = *start++;
- goto onfjmp;
-
- case ONFJMPW:
- aux = start[0] | (start[1] << 8);
- start += 2;
- onfjmp:
- // push_expr_1 onfjmp(label) push_expr_2 label: -> expr_2 && expr_2
- decompileRange(start, start + aux);
- do_binary_op(start + aux, 0, false, " and ");
- start = start + aux;
- break;
-
- case JMP:
- aux = *start++;
- goto jmp;
-
- case JMPW:
- aux = start[0] | (start[1] << 8);
- start += 2;
- jmp:
- {
- Byte *dest = start + aux;
- if (dest == break_pos) {
- *os << indent_str << "break\n";
- break;
- }
-
- // otherwise, must be the start of a while statement
- Byte *while_cond_end;
- for (while_cond_end = dest; end == NULL || while_cond_end < end;
- while_cond_end += instr_lens[*while_cond_end])
- if (*while_cond_end == IFTUPJMP || *while_cond_end == IFTUPJMPW)
- break;
- if (end != NULL && while_cond_end >= end) {
- *os << indent_str
- << "error: JMP not in break, while, if/else\n";
- }
-
- // push the while condition onto the stack
- decompileRange(dest, while_cond_end);
-
- *os << indent_str << "while " << *stk->top()
- << " do\n";
- delete stk->top();
- stk->pop();
-
- // decompile the while body
- Decompiler indented_dc = *this;
- indented_dc.indent_str += std::string(4, ' ');
- indented_dc.break_pos = while_cond_end + instr_lens[*while_cond_end];
- indented_dc.decompileRange(start, dest);
-
- *os << indent_str << "end\n";
- start = indented_dc.break_pos;
- }
- break;
-
- case IFFJMP:
- aux = *start++;
- goto iffjmp;
-
- case IFFJMPW:
- aux = start[0] | (start[1] << 8);
- start += 2;
- iffjmp:
- {
- // Output an if/end, if/else/end, if/elseif/else/end, ... statement
- Byte *if_part_end = start + aux;
- Decompiler indented_dc = *this;
- indented_dc.indent_str += std::string(4, ' ');
-
- *os << indent_str << "if " << *stk->top();
- delete stk->top();
- stk->pop();
- *os << " then\n";
-
- bool has_else;
- Byte *else_part_end;
- get_else_part(start, if_part_end, has_else, else_part_end);
-
- // Output the if part
- output_if:
- indented_dc.decompileRange(start, if_part_end);
- start = start + aux;
-
- if (has_else) {
- // Check whether the entire else part is a single
- // if or if/else statement
- Byte *instr_scan = start;
- while (is_expr_opc(*instr_scan) &&
- (end == NULL || instr_scan < else_part_end))
- instr_scan += instr_lens[*instr_scan];
- if ((end == NULL || instr_scan < else_part_end) &&
- (*instr_scan == IFFJMP || *instr_scan == IFFJMPW)) {
- // OK, first line will be if, check if it will go all
- // the way through
- Byte *new_start, *new_if_part_end, *new_else_part_end;
- bool new_has_else;
- if (*instr_scan == IFFJMP) {
- aux = instr_scan[1];
- new_start = instr_scan + 2;
- }
- else {
- aux = instr_scan[1] | (instr_scan[2] << 8);
- new_start = instr_scan + 3;
- }
- new_if_part_end = new_start + aux;
- get_else_part(new_start, new_if_part_end, new_has_else,
- new_else_part_end);
- if (new_if_part_end == else_part_end ||
- (new_has_else && new_else_part_end == else_part_end)) {
- // Yes, output an elseif
- decompileRange(start, instr_scan); // push condition
- *os << indent_str << "elseif " << *stk->top() << " then\n";
- delete stk->top();
- stk->pop();
-
- start = new_start;
- if_part_end = new_if_part_end;
- has_else = new_has_else;
- else_part_end = new_else_part_end;
- goto output_if;
- }
- }
- *os << indent_str << "else\n";
- indented_dc.decompileRange(start, else_part_end);
- start = else_part_end;
- }
- *os << indent_str << "end\n";
- }
- break;
-
- case CLOSURE:
- aux = *start++;
- goto closure;
-
- case CLOSURE0:
- case CLOSURE1:
- aux = opc - CLOSURE0;
- closure:
- {
- FuncExpr *f = dynamic_cast<FuncExpr *>(stk->top());
- if (f == NULL) {
- *os << indent_str
- << "error: closure requires a function\n";
- }
- stk->pop();
- f->num_upvals = aux;
- f->upvals = new Expression*[aux];
- for (int i = aux - 1; i >= 0; i--) {
- f->upvals[i] = stk->top(); stk->pop();
- }
- stk->push(f);
- }
- break;
-
- case CALLFUNC:
- aux = *start++;
- goto callfunc;
-
- case CALLFUNC0:
- case CALLFUNC1:
- aux = opc - CALLFUNC0;
- callfunc:
- {
- int num_args = *start++;
- FuncCallExpr *e = new FuncCallExpr(start);
- e->num_args = num_args;
- e->args = new Expression*[num_args];
- for (int i = num_args - 1; i >= 0; i--) {
- e->args[i] = stk->top();
- stk->pop();
- }
- e->func = stk->top();
- stk->pop();
- if (aux == 0) {
- *os << indent_str << *e << std::endl;
- delete e;
- }
- else if (aux == 1 || aux == 255) // 255 for return f()
- stk->push(e);
- else {
- stk->push(e);
- for (int i = 1; i < aux; i++)
- stk->push(new VarExpr(start, "<extra result>"));
- }
- }
- break;
-
- case RETCODE:
- {
- int num_rets = stk->size() + tf->code[1] - *start++;
- ExprStack rets;
-
- for (int i = 0; i < num_rets; i++) {
- rets.push(stk->top());
- stk->pop();
- }
- *os << indent_str << "return";
- for (int i = 0; i < num_rets; i++) {
- *os << " " << *rets.top();
- delete rets.top();
- rets.pop();
- if (i + 1 < num_rets)
- *os << ",";
- }
- *os << std::endl;
- }
- break;
-
- case SETLINE:
- aux = *start++;
- goto setline;
-
- case SETLINEW:
- aux = start[0] | (start[1] << 8);
- start += 2;
- setline:
- break; // ignore line info
-
- case POP:
- aux = *start++;
- goto pop;
-
- case POP0:
- case POP1:
- aux = opc - POP0;
- pop:
- for (int i = 0; i <= aux; i++) {
- local_var_defs->insert(stk->top()->pos);
- delete stk->top(); stk->pop();
- }
- break;
-
- default:
- *os << indent_str << "error: unrecognized opcode "
- << int(opc) << std::endl;
- return;
- }
- }
-}
-
-// Decompile the body of a function.
-void decompile(std::ostream &os, TProtoFunc *tf, std::string indent_str,
- Expression **upvals, int num_upvals) {
- Byte *instr = tf->code + 2;
- ExprStack s;
- std::ostringstream first_time;
- std::multiset<Byte *> loc_vars;
-
- // First, do a preliminary pass to see where local variables are defined
- Decompiler dc;
- dc.os = &first_time;
- dc.stk = &s;
- dc.tf = tf;
- dc.indent_str = indent_str;
- dc.break_pos = NULL;
- dc.upvals = upvals;
- dc.num_upvals = num_upvals;
- dc.local_var_defs = &loc_vars;
- dc.decompileRange(instr, NULL);
-
- if (s.empty() && loc_vars.empty()) {
- // OK, it didn't actually have any local variables. Just output
- // the results right now.
- os << first_time.str();
- return;
- }
-
- // See where the local variables were defined.
- while (! s.empty()) {
- loc_vars.insert(s.top()->pos);
- delete s.top(); s.pop();
- }
-
- // Now do the real decompilation
- dc.os = &os;
- dc.decompileRange(instr, NULL);
-
- while (! s.empty()) {
- delete s.top(); s.pop();
- }
-}
-
-int main(int argc, char *argv[]) {
- int filename_pos = 1;
-
- if (argc > 1 && strcmp(argv[1], "-t") == 0) {
- translateStrings = true;
- filename_pos = 2;
- }
- if (argc != filename_pos + 1) {
- fprintf(stderr, "Usage: delua [-t] file.lua\n");
- exit(1);
- }
- char *filename = argv[filename_pos];
- FILE *f = fopen(filename, "rb");
- if (f == NULL) {
- perror(filename);
- exit(1);
- }
-
- lua_open();
- ZIO z;
- luaZ_Fopen(&z, f, filename);
- TProtoFunc *tf = luaU_undump1(&z);
- fclose(f);
-
- decompile(std::cout, tf, "", NULL, 0);
-
- lua_close();
- return 0;
-}
Copied: residual/trunk/tools/delua.cpp (from rev 32691, residual/trunk/tools/delua.cc)
===================================================================
--- residual/trunk/tools/delua.cpp (rev 0)
+++ residual/trunk/tools/delua.cpp 2008-06-15 11:09:22 UTC (rev 32706)
@@ -0,0 +1,1313 @@
+/* Residual - Virtual machine to run LucasArts' 3D adventure games
+ * Copyright (C) 2003-2006 The ScummVM-Residual Team (www.scummvm.org)
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+ *
+ * $URL$
+ * $Id$
+ *
+ */
+
+#include "lua.h"
+#include "lundump.h"
+#include "lopcodes.h"
+#include "lzio.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <ctype.h>
+#include <iostream>
+#include <sstream>
+#include <map>
+#include <queue>
+#include <stack>
+#include <list>
+#include <set>
+
+#include "localize.h"
+
+// Provide debug.cpp functions which don't call SDL_Quit.
+void warning(const char *fmt, ...) {
+ fprintf(stderr, "WARNING: ");
+ va_list va;
+ va_start(va, fmt);
+ vfprintf(stderr, fmt, va);
+ va_end(va);
+ fprintf(stderr, "\n");
+}
+
+void error(const char *fmt, ...) {
+ fprintf(stderr, "ERROR: ");
+ va_list va;
+ va_start(va, fmt);
+ vfprintf(stderr, fmt, va);
+ va_end(va);
+ fprintf(stderr, "\n");
+ exit(1);
+}
+
+static bool translateStrings = false;
+
+class Expression;
+
+void decompile(std::ostream &os, TProtoFunc *tf, std::string indent_str,
+ Expression **upvals, int num_upvals);
+
+std::string localname(TProtoFunc *tf, int n) {
+ LocVar *l = tf->locvars;
+ if (l != NULL)
+ for (int i = 0; i < n; i++, l++)
+ if (l->varname == NULL) {
+ l = NULL;
+ break;
+ }
+ if (l != NULL)
+ return l->varname->str;
+ else {
+ std::ostringstream s;
+ if (n < tf->code[1])
+ s << "arg" << n + 1;
+ else
+ s << "local" << n - tf->code[1] + 1;
+ return s.str();
+ }
+}
+
+class Expression {
+public:
+ Expression(Byte *p) : pos(p) { }
+ Byte *pos; // Position just after the expression
+ // is pushed onto the stack
+ virtual void print(std::ostream &os) const = 0;
+ virtual int precedence() const { return 100; }
+ virtual ~Expression() { }
+};
+
+inline std::ostream& operator <<(std::ostream &os, const Expression &e) {
+ e.print(os);
+ return os;
+}
+
+class NumberExpr : public Expression {
+public:
+ NumberExpr(Byte *p, float val) : Expression(p), value(val) { }
+ float value;
+ void print(std::ostream &os) const { os << value; }
+};
+
+class VarExpr : public Expression {
+public:
+ VarExpr(Byte *p, std::string varname) : Expression(p), name(varname) { }
+ std::string name;
+ void print(std::ostream &os) const { os << name; }
+};
+
+class StringExpr : public Expression {
+public:
+ StringExpr(Byte *p, TaggedString *txt) : Expression(p), text(txt) { }
+ TaggedString *text;
+ bool validIdentifier() const {
+ if (text->u.s.len == 0)
+ return false;
+ if (isdigit(text->str[0]))
+ return false;
+ if (text->str[0] >= '0' && text->str[0] <= '9')
+ return false;
+ for (int i = 0; i < text->u.s.len; i++) {
+ char c = text->str[i];
+ if ((! isalnum(text->str[0])) && c != '_')
+ return false;
+ }
+ return true;
+ }
+ void print(std::ostream &os) const {
+ static char *specials = "\a\b\f\n\r\t\v\\\"";
+ static char *special_text[] = {
+ "\\a", "\\b", "\\f", "\\n", "\\r", "\\t", "\\v", "\\\\", "\\\""
+ };
+
+ os << "\"";
+ std::string str(text->str, text->u.s.len);
+ if (translateStrings)
+ str = g_localizer->localize(str.c_str());
+ for (std::string::iterator i = str.begin(); i != str.end(); i++) {
+ unsigned char c = *i;
+ if (strchr(specials, c)) {
+ int i = strchr(specials, c) - specials;
+ os << special_text[i];
+ }
+ else if (! isprint(c))
+ os << "\\" << int(c >> 6) << int((c >> 3) & 7) << int(c & 7);
+ else
+ os << c;
+ }
+ os << "\"";
+ }
+};
+
+class FuncExpr : public Expression {
+public:
+ FuncExpr(Byte *p, TProtoFunc *tf0, std::string is) :
+ Expression(p), indent_str(is), tf(tf0), upvals(NULL), num_upvals(0) { }
+ std::string indent_str;
+ TProtoFunc *tf;
+ Expression **upvals;
+ int num_upvals;
+
+ void print(std::ostream &os) const {
+ os << "function(";
+ for (int i = 0; i < tf->code[1]; i++) {
+ os << localname(tf, i);
+ if (i + 1 < tf->code[1])
+ os << ", ";
+ }
+ os << ") -- line " << tf->lineDefined << std::endl;
+ decompile(os, tf, indent_str + std::string(4, ' '),
+ upvals, num_upvals);
+ os << indent_str << "end";
+ }
+ ~FuncExpr() {
+ for (int i = 0; i < num_upvals; i++)
+ delete upvals[i];
+ delete[] upvals;
+ }
+};
+
+class IndexExpr : public Expression {
+public:
+ IndexExpr(Byte *p, Expression *tbl, Expression *i)
+ : Expression(p), table(tbl), index(i) { }
+ Expression *table, *index;
+ void print(std::ostream &os) const {
+ table->print(os);
+ StringExpr *field = dynamic_cast<StringExpr *>(index);
+ if (field != NULL && field->validIdentifier())
+ os << "." << field->text->str;
+ else
+ os << "[" << *index << "]";
+ }
+ ~IndexExpr() {
+ delete table;
+ delete index;
+ }
+};
+
+class SelfExpr : public IndexExpr {
+public:
+ SelfExpr(Byte *p, Expression *tbl, StringExpr *i) : IndexExpr(p, tbl, i) { }
+ void print(std::ostream &os) const {
+ StringExpr *field = static_cast<StringExpr *>(index);
+ os << *table << ":" << field->text->str;
+ }
+};
+
+class FuncCallExpr : public Expression {
+public:
+ FuncCallExpr(Byte *p) : Expression(p) { }
+ int num_args;
+ Expression **args;
+ Expression *func;
+ void print(std::ostream &os) const {
+ os << *func << "(";
+ int i = 0;
+
+ // Skip implicit self argument in a:b(c)
+ if (dynamic_cast<SelfExpr *>(func) != NULL)
+ i = 1;
+ for (; i < num_args; i++) {
+ args[i]->print(os);
+ if (i + 1 < num_args)
+ os << ", ";
+ }
+ os << ")";
+ }
+ ~FuncCallExpr() {
+ for (int i = 0; i < num_args; i++)
+ delete args[i];
+ delete args;
+ delete func;
+ }
+};
+
+class ArrayExpr : public Expression {
+public:
+ ArrayExpr(Byte *p) : Expression(p) { }
+ typedef std::pair<Expression *, Expression *> mapping;
+ typedef std::list<mapping> mapping_list;
+ mapping_list mappings;
+ void print(std::ostream &os) const {
+ os << "{";
+ mapping_list::const_iterator i = mappings.begin();
+ while (i != mappings.end()) {
+ if (i->first != NULL) {
+ StringExpr *field = dynamic_cast<StringExpr *>(i->first);
+ if (field != NULL && field->validIdentifier())
+ os << " " << field->text->str;
+ else
+ os << " [" << *i->first << "]";
+ os << " =";
+ }
+ os << " " << *i->second;
+ i++;
+ if (i != mappings.end())
+ os << ",";
+ }
+ os << " }";
+ }
+ ~ArrayExpr() {
+ for (mapping_list::iterator i = mappings.begin();
+ i != mappings.end(); i++) {
+ delete i->first;
+ delete i->second;
+ }
+ }
+};
+
+class BinaryExpr : public Expression {
+public:
+ BinaryExpr(Byte *ps, Expression *l, Expression *r, int p, bool ra,
+ std::string o) :
+ Expression(ps), left(l), right(r), prec(p), right_assoc(ra), op(o) { }
+ Expression *left, *right;
+ int prec;
+ bool right_assoc;
+ std::string op;
+ int precedence() const { return prec; }
+ void print(std::ostream &os) const {
+ if (left->precedence() < prec ||
+ (left->precedence() == prec && right_assoc))
+ os << "(" << *left << ")";
+ else
+ os << *left;
+ os << op;
+ if (right->precedence() < prec ||
+ (right->precedence() == prec && ! right_assoc))
+ os << "(" << *right << ")";
+ else
+ os << *right;
+ }
+ ~BinaryExpr() { delete left; delete right; }
+};
+
+class UnaryExpr : public Expression {
+public:
+ UnaryExpr(Byte *ps, Expression *a, int p, std::string o) :
+ Expression(ps), arg(a), prec(p), op(o) { }
+ Expression *arg;
+ int prec;
+ std::string op;
+ int precedence() const { return prec; }
+ void print(std::ostream &os) const {
+ os << op;
+ if (arg->precedence() < prec)
+ os << "(" << *arg << ")";
+ else
+ os << *arg;
+ }
+ ~UnaryExpr() { delete arg; }
+};
+
+typedef std::stack<Expression *> ExprStack;
+
+class Decompiler {
+public:
+ void decompileRange(Byte *start, Byte *end);
+
+ std::ostream *os;
+ ExprStack *stk;
+ TProtoFunc *tf;
+ std::string indent_str;
+ Byte *break_pos;
+ Expression **upvals; int num_upvals;
+ std::multiset<Byte *> *local_var_defs;
+
+private:
+ void do_multi_assign(Byte *&start);
+ void do_binary_op(Byte *pos, int prec, bool right_assoc, std::string op);
+ void do_unary_op(Byte *pos, int prec, std::string op);
+ static bool is_expr_opc(Byte opc);
+ void get_else_part(Byte *start, Byte *&if_part_end,
+ bool &has_else, Byte *&else_part_end);
+};
+
+// Scan for a series of assignments
+void Decompiler::do_multi_assign(Byte *&start) {
+ std::queue<Expression *> results;
+ ExprStack values;
+
+ bool done;
+ int num_tables = 0;
+ do {
+ int aux, opc;
+ done = false;
+
+ opc = *start++;
+ switch (opc) {
+ case SETLOCAL:
+ aux = *start++;
+ goto setlocal;
+
+ case SETLOCAL0:
+ case SETLOCAL1:
+ case SETLOCAL2:
+ case SETLOCAL3:
+ case SETLOCAL4:
+ case SETLOCAL5:
+ case SETLOCAL6:
+ case SETLOCAL7:
+ aux = opc - SETLOCAL0;
+ setlocal:
+ results.push(new VarExpr(start, localname(tf, aux)));
+ break;
+
+ case SETGLOBAL:
+ aux = *start++;
+ goto setglobal;
+
+ case SETGLOBAL0:
+ case SETGLOBAL1:
+ case SETGLOBAL2:
+ case SETGLOBAL3:
+ case SETGLOBAL4:
+ case SETGLOBAL5:
+ case SETGLOBAL6:
+ case SETGLOBAL7:
+ aux = opc - SETGLOBAL0;
+ goto setglobal;
+
+ case SETGLOBALW:
+ aux = start[0] | (start[1] << 8);
+ start += 2;
+ setglobal:
+ results.push(new VarExpr(start, svalue(tf->consts + aux)));
+ break;
+
+ case SETTABLE:
+ start++; // assume offset is correct
+ case SETTABLE0:
+ results.push(new IndexExpr(start, NULL, NULL));
+ num_tables++;
+ // this needs stuff from farther up the stack, wait until
+ // it's available
+ break;
+
+ default:
+ start--;
+ done = true;
+ }
+
+ if (! done) {
+ Expression *e = stk->top();
+ // Check for fake result from function calls with multiple return values
+ VarExpr *v = dynamic_cast<VarExpr *>(e);
+ if (v != NULL && v->name == "<extra result>")
+ delete e;
+ else
+ values.push(e);
+ stk->pop();
+ }
+ } while (! done);
+
+ // Check for popping tables and indices
+ if (num_tables > 0 && (*start == POP || *start == POP0 || *start == POP1)) {
+ start++;
+ if (start[-1] == POP)
+ start++;
+ }
+
+ // Now get actual tables and indices from the stack, reversing
+ // the list to the right order at the same time
+
+ ExprStack results2;
+ while (! results.empty()) {
+ Expression *var = results.front(); results.pop();
+ IndexExpr *tbl = dynamic_cast<IndexExpr *>(var);
+ if (tbl != NULL) {
+ tbl->index = stk->top(); stk->pop();
+ tbl->table = stk->top(); stk->pop();
+ }
+ results2.push(var);
+ }
+
+ *os << indent_str;
+ while (! results2.empty()) {
+ Expression *var = results2.top(); results2.pop();
+ *os << *var;
+ delete var;
+ if (! results2.empty())
+ *os << ", ";
+ }
+ *os << " = ";
+ while (! values.empty()) {
+ Expression *val = values.top(); values.pop();
+ *os << *val;
+ delete val;
+ if (! values.empty())
+ *os << ", ";
+ }
+ *os << std::endl;
+}
+
+void Decompiler::do_binary_op(Byte *pos, int prec, bool right_assoc,
+ std::string op) {
+ Expression *right = stk->top(); stk->pop();
+ Expression *left = stk->top(); stk->pop();
+ stk->push(new BinaryExpr(pos, left, right, prec, right_assoc, op));
+}
+
+void Decompiler::do_unary_op(Byte *pos, int prec, std::string op) {
+ Expression *arg = stk->top(); stk->pop();
+ stk->push(new UnaryExpr(pos, arg, prec, op));
+}
+
+// Provide instruction lengths to make it easy to scan through instructions
+int instr_lens[] = {
+ 1, // ENDCODE
+ 2, // PUSHNIL
+ 1, // PUSHNIL0
+ 2, // PUSHNUMBER
+ 1, 1, 1, // PUSHNUMBER0..2
+ 3, // PUSHNUMBERW
+ 2, // PUSHCONSTANT
+ 1, 1, 1, 1, 1, 1, 1, 1, // PUSHCONSTANT0..7
+ 3, // PUSHCONSTANTW
+ 2, // PUSHUPVALUE
+ 1, 1, // PUSHUPVALUE0,1
+ 2, // PUSHLOCAL
+ 1, 1, 1, 1, 1, 1, 1, 1, // PUSHLOCAL0..7
+ 2, // GETGLOBAL
+ 1, 1, 1, 1, 1, 1, 1, 1, // GETGLOBAL0..7
+ 3, // GETGLOBALW
+ 1, // GETTABLE
+ 2, // GETDOTTED
+ 1, 1, 1, 1, 1, 1, 1, 1, // GETDOTTED0..7
+ 3, // GETDOTTEDW
+ 2, // PUSHSELF
+ 1, 1, 1, 1, 1, 1, 1, 1, // PUSHSELF0..7
+ 3, // PUSHSELFW
+ 2, // CREATEARRAY
+ 1, 1, // CREATEARRAY0,1
+ 3, // CREATEARRAYW
+ 2, // SETLOCAL
+ 1, 1, 1, 1, 1, 1, 1, 1, // SETLOCAL0..7
+ 2, // SETGLOBAL
+ 1, 1, 1, 1, 1, 1, 1, 1, // SETGLOBAL0..7
+ 3, // SETGLOBALW
+ 1, // SETTABLE0
+ 2, // SETTABLE
+ 3, // SETLIST
+ 2, // SETLIST0
+ 4, // SETLISTW
+ 2, // SETMAP
+ 1, // SETMAP0
+ 1, // EQOP
+ 1, // NEQOP
+ 1, // LTOP
+ 1, // LEOP
+ 1, // GTOP
+ 1, // GEOP
+ 1, // ADDOP
+ 1, // SUBOP
+ 1, // MULTOP
+ 1, // DIVOP
+ 1, // POWOP
+ 1, // CONCOP
+ 1, // MINUSOP
+ 1, // NOTOP
+ 2, 3, // ONTJMP, ONTJMPW
+ 2, 3, // ONFJMP, ONFJMPW
+ 2, 3, // JMP, JMPW
+ 2, 3, // IFFJMP, IFFJMPW
+ 2, 3, // IFTUPJMP, IFTUPJMPW
+ 2, 3, // IFFUPJMP, IFFUPJMPW
+ 2, // CLOSURE
+ 1, 1, // CLOSURE0,1
+ 3, // CALLFUNC
+ 2, 2, // CALLFUNC0,1
+ 2, // RETCODE
+ 2, // SETLINE
+ 3, // SETLINEW
+ 2, // POP
+ 1, 1 // POP0,1
+};
+
+bool Decompiler::is_expr_opc(Byte opc) {
+ if (opc >= PUSHNIL && opc <= CREATEARRAYW)
+ return true;
+ if (opc == SETLIST0)
+ return true;
+ if (opc >= SETMAP && opc <= ONFJMPW)
+ return true;
+ if (opc >= CLOSURE && opc <= CLOSURE1)
+ return true;
+ if (opc == CALLFUNC1 || opc == SETLINE || opc == SETLINEW)
+ return true;
+ return false;
+}
+
+// Check for JMP or JMPW at end of "if" part
+void Decompiler::get_else_part(Byte *start, Byte *&if_part_end,
+ bool &has_else, Byte *&else_part_end) {
+ Byte *last_instr = NULL;
+ has_else = false;
+ else_part_end = NULL;
+
+ for (Byte *instr_scan = start; instr_scan < if_part_end;
+ instr_scan += instr_lens[*instr_scan])
+ last_instr = instr_scan;
+ if (last_instr != NULL &&
+ (*last_instr == JMP || *last_instr == JMPW)) {
+ has_else = true;
+ else_part_end = if_part_end + last_instr[1];
+ if (*last_instr == JMPW)
+ else_part_end += (last_instr[2] << 8);
+ if_part_end = last_instr;
+ }
+}
+
+void Decompiler::decompileRange(Byte *start, Byte *end) {
+ // First, scan for IFFUPJMP, which is used for repeat/until, so
+ // we can recognize the start of such loops. We only keep the
+ // last value to match each address, which represents the outermost
+ // repeat/until loop starting at that point.
+ std::map<Byte *, Byte *> rev_iffupjmp_map;
+
+ for (Byte *scan = start; end == NULL || scan < end;
+ scan += instr_lens[*scan]) {
+ if (*scan == IFFUPJMP)
+ rev_iffupjmp_map[scan + 2 - scan[1]] = scan;
+ else if (*scan == IFFUPJMPW)
+ rev_iffupjmp_map[scan + 3 - (scan[1] | (scan[2] << 8))] = scan;
+ else if (*scan == ENDCODE)
+ break;
+ }
+
+ while (end == NULL || start < end) {
+ int locs_here = local_var_defs->count(start);
+ if (locs_here > 0) {
+ // There were local variable slots just pushed onto the stack
+ // Print them out (in the second pass)
+
+ // First, if there are multiple defined, it must be from
+ // local x, y, z = f() or local a, b. So just ignore the extra
+ // entries.
+ for (int i = 1; i < locs_here; i++) {
+ delete stk->top(); stk->pop();
+ }
+ Expression *def = stk->top(); stk->pop();
+
+ // Print the local variable names, and at the same time push
+ // fake values onto the stack
+ *os << indent_str << "local ";
+ for (int i = 0; i < locs_here; i++) {
+ std::string locname = localname(tf, tf->code[1] + stk->size());
+ *os << locname;
+ if (i + 1 < locs_here)
+ *os << ", ";
+ stk->push(new VarExpr(start, "<" + locname + " stack slot>"));
+ }
+
+ // Print the definition, unless it's nil
+ VarExpr *v = dynamic_cast<VarExpr *>(def);
+ if (v == NULL || v->name != "nil")
+ *os << " = " << *def;
+ *os << std::endl;
+ }
+
+ if (rev_iffupjmp_map.find(start) != rev_iffupjmp_map.end()) {
+ // aha, do a repeat/until loop
+ *os << indent_str << "repeat\n";
+ Decompiler indented_dc = *this;
+ indented_dc.indent_str += std::string(4, ' ');
+ indented_dc.break_pos = rev_iffupjmp_map[start];
+ indented_dc.break_pos += instr_lens[*indented_dc.break_pos];
+ indented_dc.decompileRange(start, rev_iffupjmp_map[start]);
+
+ Expression *e = stk->top(); stk->pop();
+ *os << indent_str << "until " << *e << std::endl;
+ delete e;
+
+ start = indented_dc.break_pos;
+ continue;
+ }
+
+ Byte opc = *start++;
+ int aux;
+
+ switch (opc) {
+ case ENDCODE:
+ return;
+
+ case PUSHNIL:
+ aux = *start++;
+ goto pushnil;
+
+ case PUSHNIL0:
+ aux = 0;
+ pushnil:
+ for (int i = 0; i <= aux; i++)
+ stk->push(new VarExpr(start, "nil")); // Cheat a little :)
+ break;
+
+ case PUSHNUMBER:
+ aux = *start++;
+ goto pushnumber;
+
+ case PUSHNUMBER0:
+ case PUSHNUMBER1:
+ case PUSHNUMBER2:
+ aux = opc - PUSHNUMBER0;
+ goto pushnumber;
+
+ case PUSHNUMBERW:
+ aux = start[0] | (start[1] << 8);
+ start += 2;
+ pushnumber:
+ stk->push(new NumberExpr(start, aux));
+ break;
+
+ case PUSHCONSTANT:
+ aux = *start++;
+ goto pushconst;
+
+ case PUSHCONSTANT0:
+ case PUSHCONSTANT1:
+ case PUSHCONSTANT2:
+ case PUSHCONSTANT3:
+ case PUSHCONSTANT4:
+ case PUSHCONSTANT5:
+ case PUSHCONSTANT6:
+ case PUSHCONSTANT7:
+ aux = opc - PUSHCONSTANT0;
+ goto pushconst;
+
+ case PUSHCONSTANTW:
+ aux = start[0] | (start[1] << 8);
+ start += 2;
+ pushconst:
+ switch (ttype(tf->consts + aux)) {
+ case LUA_T_STRING:
+ stk->push(new StringExpr(start, tsvalue(tf->consts + aux)));
+ break;
+ case LUA_T_NUMBER:
+ stk->push(new NumberExpr(start, nvalue(tf->consts + aux)));
+ break;
+ case LUA_T_PROTO:
+ stk->push(new FuncExpr(start, tfvalue(tf->consts + aux), indent_str));
+ break;
+ default:
+ *os << indent_str << "error: invalid constant type "
+ << int(ttype(tf->consts + aux)) << std::endl;
+ }
+ break;
+
+ case PUSHUPVALUE:
+ aux = *start++;
+ goto pushupvalue;
+
+ case PUSHUPVALUE0:
+ case PUSHUPVALUE1:
+ aux = opc - PUSHUPVALUE0;
+ pushupvalue:
+ {
+ if (aux >= num_upvals) {
+ *os << indent_str << "error: invalid upvalue #"
+ << aux << std::endl;
+ }
+
+ std::ostringstream s;
+ s << "%" << *upvals[aux];
+ stk->push(new VarExpr(start, s.str()));
+ }
+ break;
+
+ case PUSHLOCAL:
+ aux = *start++;
+ goto pushlocal;
+
+ case PUSHLOCAL0:
+ case PUSHLOCAL1:
+ case PUSHLOCAL2:
+ case PUSHLOCAL3:
+ case PUSHLOCAL4:
+ case PUSHLOCAL5:
+ case PUSHLOCAL6:
+ case PUSHLOCAL7:
+ aux = opc - PUSHLOCAL0;
+ pushlocal:
+ stk->push(new VarExpr(start, localname(tf, aux)));
+ break;
+
+ case GETGLOBAL:
+ aux = *start++;
+ goto getglobal;
+
+ case GETGLOBAL0:
+ case GETGLOBAL1:
+ case GETGLOBAL2:
+ case GETGLOBAL3:
+ case GETGLOBAL4:
+ case GETGLOBAL5:
+ case GETGLOBAL6:
+ case GETGLOBAL7:
+ aux = opc - GETGLOBAL0;
+ goto getglobal;
+
+ case GETGLOBALW:
+ aux = start[0] | (start[1] << 8);
+ start += 2;
+ getglobal:
+ stk->push(new VarExpr(start, svalue(tf->consts + aux)));
+ break;
+
+ case GETTABLE:
+ {
+ Expression *index = stk->top(); stk->pop();
+ Expression *table = stk->top(); stk->pop();
+
+ stk->push(new IndexExpr(start, table, index));
+ }
+ break;
+
+ case GETDOTTED:
+ aux = *start++;
+ goto getdotted;
+
+ case GETDOTTED0:
+ case GETDOTTED1:
+ case GETDOTTED2:
+ case GETDOTTED3:
+ case GETDOTTED4:
+ case GETDOTTED5:
+ case GETDOTTED6:
+ case GETDOTTED7:
+ aux = opc - GETDOTTED0;
+ goto getdotted;
+
+ case GETDOTTEDW:
+ aux = start[0] | (start[1] << 8);
+ start += 2;
+ getdotted:
+ {
+ Expression *tbl = stk->top(); stk->pop();
+ stk->push(new IndexExpr(start, tbl, new StringExpr
+ (start, tsvalue(tf->consts + aux))));
+ }
+ break;
+
+ case PUSHSELF:
+ aux = *start++;
+ goto pushself;
+
+ case PUSHSELF0:
+ case PUSHSELF1:
+ case PUSHSELF2:
+ case PUSHSELF3:
+ case PUSHSELF4:
+ case PUSHSELF5:
+ case PUSHSELF6:
+ case PUSHSELF7:
+ aux = opc - PUSHSELF0;
+ goto pushself;
+
+ case PUSHSELFW:
+ aux = start[0] | (start[1] << 8);
+ start += 2;
+ pushself:
+ {
+ Expression *tbl = stk->top(); stk->pop();
+ stk->push(new SelfExpr(start, tbl, new StringExpr
+ (start, tsvalue(tf->consts + aux))));
+ stk->push(new VarExpr(start, "<self>"));
+ // Fake value, FuncCallExpr will handle it
+ }
+ break;
+
+ case CREATEARRAY:
+ start++;
+ goto createarray;
+
+ case CREATEARRAY0:
+ case CREATEARRAY1:
+ goto createarray;
+
+ case CREATEARRAYW:
+ start += 2;
+ createarray:
+ stk->push(new ArrayExpr(start));
+ break;
+
+ case SETLOCAL:
+ case SETLOCAL0:
+ case SETLOCAL1:
+ case SETLOCAL2:
+ case SETLOCAL3:
+ case SETLOCAL4:
+ case SETLOCAL5:
+ case SETLOCAL6:
+ case SETLOCAL7:
+ case SETGLOBAL:
+ case SETGLOBAL0:
+ case SETGLOBAL1:
+ case SETGLOBAL2:
+ case SETGLOBAL3:
+ case SETGLOBAL4:
+ case SETGLOBAL5:
+ case SETGLOBAL6:
+ case SETGLOBAL7:
+ case SETGLOBALW:
+ case SETTABLE0:
+ case SETTABLE:
+ start--;
+ do_multi_assign(start);
+ break;
+
+ case SETLIST:
+ start++; // assume offset is correct
+ goto setlist;
+
+ case SETLISTW:
+ start += 2;
+
+ case SETLIST0:
+ setlist:
+ aux = *start++;
+ {
+ ArrayExpr::mapping_list new_mappings;
+ for (int i = 0; i < aux; i++) {
+ Expression *val = stk->top(); stk->pop();
+ new_mappings.push_front(std::make_pair((Expression *) NULL, val));
+ }
+ ArrayExpr *a = dynamic_cast<ArrayExpr *>(stk->top());
+ if (a == NULL) {
+ *os << indent_str
+ << "error: attempt to setlist a non-array object\n";
+ }
+ // Append the new list
+ a->mappings.splice(a->mappings.end(), new_mappings);
+ a->pos = start;
+ }
+ break;
+
+ case SETMAP:
+ aux = *start++;
+ goto setmap;
+
+ case SETMAP0:
+ aux = 0;
+ setmap:
+ {
+ ArrayExpr::mapping_list new_mappings;
+ for (int i = 0; i <= aux; i++) {
+ Expression *val = stk->top(); stk->pop();
+ Expression *key = stk->top(); stk->pop();
+ new_mappings.push_front(std::make_pair(key, val));
+ }
+ ArrayExpr *a = dynamic_cast<ArrayExpr *>(stk->top());
+ if (a == NULL) {
+ *os << indent_str
+ << "error: attempt to setmap a non-array object\n";
+ }
+ // Append the new list
+ a->mappings.splice(a->mappings.end(), new_mappings);
+ a->pos = start;
+ }
+ break;
+
+ case EQOP:
+ do_binary_op(start, 1, false, " == ");
+ break;
+
+ case NEQOP:
+ do_binary_op(start, 1, false, " ~= ");
+ break;
+
+ case LTOP:
+ do_binary_op(start, 1, false, " < ");
+ break;
+
+ case LEOP:
+ do_binary_op(start, 1, false, " <= ");
+ break;
+
+ case GTOP:
+ do_binary_op(start, 1, false, " > ");
+ break;
+
+ case GEOP:
+ do_binary_op(start, 1, false, " >= ");
+ break;
+
+ case ADDOP:
+ do_binary_op(start, 3, false, " + ");
+ break;
+
+ case SUBOP:
+ do_binary_op(start, 3, false, " - ");
+ break;
+
+ case MULTOP:
+ do_binary_op(start, 4, false, " * ");
+ break;
+
+ case DIVOP:
+ do_binary_op(start, 4, false, " / ");
+ break;
+
+ case POWOP:
+ do_binary_op(start, 6, true, " ^ ");
+ break;
+
+ case CONCOP:
+ do_binary_op(start, 2, false, "..");
+ break;
+
+ case MINUSOP:
+ do_unary_op(start, 5, "-");
+ break;
+
+ case NOTOP:
+ do_unary_op(start, 5, "not ");
+ break;
+
+ case ONTJMP:
+ aux = *start++;
+ goto ontjmp;
+
+ case ONTJMPW:
+ aux = start[0] | (start[1] << 8);
+ start += 2;
+ ontjmp:
+ // push_expr_1 ontjmp(label) push_expr_2 label: -> expr_1 || expr_2
+ decompileRange(start, start + aux);
+ do_binary_op(start + aux, 0, false, " or ");
+ start = start + aux;
+ break;
+
+ case ONFJMP:
+ aux = *start++;
+ goto onfjmp;
+
+ case ONFJMPW:
+ aux = start[0] | (start[1] << 8);
+ start += 2;
+ onfjmp:
+ // push_expr_1 onfjmp(label) push_expr_2 label: -> expr_2 && expr_2
+ decompileRange(start, start + aux);
+ do_binary_op(start + aux, 0, false, " and ");
+ start = start + aux;
+ break;
+
+ case JMP:
+ aux = *start++;
+ goto jmp;
+
+ case JMPW:
+ aux = start[0] | (start[1] << 8);
+ start += 2;
+ jmp:
+ {
+ Byte *dest = start + aux;
+ if (dest == break_pos) {
+ *os << indent_str << "break\n";
+ break;
+ }
+
+ // otherwise, must be the start of a while statement
+ Byte *while_cond_end;
+ for (while_cond_end = dest; end == NULL || while_cond_end < end;
+ while_cond_end += instr_lens[*while_cond_end])
+ if (*while_cond_end == IFTUPJMP || *while_cond_end == IFTUPJMPW)
+ break;
+ if (end != NULL && while_cond_end >= end) {
+ *os << indent_str
+ << "error: JMP not in break, while, if/else\n";
+ }
+
+ // push the while condition onto the stack
+ decompileRange(dest, while_cond_end);
+
+ *os << indent_str << "while " << *stk->top()
+ << " do\n";
+ delete stk->top();
+ stk->pop();
+
+ // decompile the while body
+ Decompiler indented_dc = *this;
+ indented_dc.indent_str += std::string(4, ' ');
+ indented_dc.break_pos = while_cond_end + instr_lens[*while_cond_end];
+ indented_dc.decompileRange(start, dest);
+
+ *os << indent_str << "end\n";
+ start = indented_dc.break_pos;
+ }
+ break;
+
+ case IFFJMP:
+ aux = *start++;
+ goto iffjmp;
+
+ case IFFJMPW:
+ aux = start[0] | (start[1] << 8);
+ start += 2;
+ iffjmp:
+ {
+ // Output an if/end, if/else/end, if/elseif/else/end, ... statement
+ Byte *if_part_end = start + aux;
+ Decompiler indented_dc = *this;
+ indented_dc.indent_str += std::string(4, ' ');
+
+ *os << indent_str << "if " << *stk->top();
+ delete stk->top();
+ stk->pop();
+ *os << " then\n";
+
+ bool has_else;
+ Byte *else_part_end;
+ get_else_part(start, if_part_end, has_else, else_part_end);
+
+ // Output the if part
+ output_if:
+ indented_dc.decompileRange(start, if_part_end);
+ start = start + aux;
+
+ if (has_else) {
+ // Check whether the entire else part is a single
+ // if or if/else statement
+ Byte *instr_scan = start;
+ while (is_expr_opc(*instr_scan) &&
+ (end == NULL || instr_scan < else_part_end))
+ instr_scan += instr_lens[*instr_scan];
+ if ((end == NULL || instr_scan < else_part_end) &&
+ (*instr_scan == IFFJMP || *instr_scan == IFFJMPW)) {
+ // OK, first line will be if, check if it will go all
+ // the way through
+ Byte *new_start, *new_if_part_end, *new_else_part_end;
+ bool new_has_else;
+ if (*instr_scan == IFFJMP) {
+ aux = instr_scan[1];
+ new_start = instr_scan + 2;
+ }
+ else {
+ aux = instr_scan[1] | (instr_scan[2] << 8);
+ new_start = instr_scan + 3;
+ }
+ new_if_part_end = new_start + aux;
+ get_else_part(new_start, new_if_part_end, new_has_else,
+ new_else_part_end);
+ if (new_if_part_end == else_part_end ||
+ (new_has_else && new_else_part_end == else_part_end)) {
+ // Yes, output an elseif
+ decompileRange(start, instr_scan); // push condition
+ *os << indent_str << "elseif " << *stk->top() << " then\n";
+ delete stk->top();
+ stk->pop();
+
+ start = new_start;
+ if_part_end = new_if_part_end;
+ has_else = new_has_else;
+ else_part_end = new_else_part_end;
+ goto output_if;
+ }
+ }
+ *os << indent_str << "else\n";
+ indented_dc.decompileRange(start, else_part_end);
+ start = else_part_end;
+ }
+ *os << indent_str << "end\n";
+ }
+ break;
+
+ case CLOSURE:
+ aux = *start++;
@@ Diff output truncated at 100000 characters. @@
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
More information about the Scummvm-git-logs
mailing list