Upload 30 files

.gitattributes

@@ -82,3 +82,4 @@ UEExtractor/UEExtractor.dll filter=lfs diff=lfs merge=lfs -text
 UEExtractor/UEExtractor.exe filter=lfs diff=lfs merge=lfs -text
 gdre_tools/gdre_tools.exe filter=lfs diff=lfs merge=lfs -text
 gdre_tools/gdre_tools.pck filter=lfs diff=lfs merge=lfs -text
+renpy/rpaExtract.exe filter=lfs diff=lfs merge=lfs -text

renpy/UnRen_Island.7z

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c41c954b6da84dd9df80a78631b96983d34278745397a4e064870ae09d82e8fb
+size 2372523

renpy/rpaExtract.7z

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cefb9d0a732eb8d3561923113ccb8056f1173bd419ad5161b156de4f435e2c94
+size 6578002

renpy/rpaExtract.exe

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b5c07979238d1a2678e0121abdb043ec087261ff9d1b5bdb647160eb8cca51be
+size 6777710

renpy/rpaext.7z

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:248354fcec3d2adc2a0109692551912c9e79d2237bfea1f5b3007e658b2834fc
+size 24646

renpy/rpycdec.7z

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8513f7449091e1c27f6b2055c5307ed9b6a114c5051f13400c94fde023006978
+size 85068

renpy/rpycdec/rpycdec.bat

@@ -0,0 +1,141 @@
+@echo off
+REM --------------------------------------------------------------------------------
+REM Configuration:
+REM   Set a Quick Save and Quick Load hotkey - http://www.pygame.org/docs/ref/key.html
+REM --------------------------------------------------------------------------------
+set "quicksavekey=K_F5"
+set "quickloadkey=K_F9"
+REM --------------------------------------------------------------------------------
+REM !! END CONFIG !!
+REM --------------------------------------------------------------------------------
+REM The following variables are Base64 encoded strings for unrpyc and rpatool
+REM Due to batch limitations on variable lengths, they need to be split into
+REM multiple variables, and joined later using powershell.
+REM --------------------------------------------------------------------------------
+REM unrpyc by CensoredUsername
+REM   https://github.com/CensoredUsername/unrpyc
+REM Edited to remove multiprocessing and adjust output spacing 44febb0 2019-10-07T07:06:47.000Z
+REM   https://github.com/F95Sam/unrpyc
+REM --------------------------------------------------------------------------------
+REM !! DO NOT EDIT BELOW THIS LINE !!
+REM --------------------------------------------------------------------------------
+set "version=0.91 (includes Gideon.v5 mods) (191007)"
+title UnRen.bat v%version%
+:init
+REM --------------------------------------------------------------------------------
+REM Splash screen
+REM --------------------------------------------------------------------------------
+cls
+echo.
+echo     __  __      ____               __          __
+echo    / / / /___  / __ \___  ____    / /_  ____ _/ /_
+echo   / / / / __ \/ /_/ / _ \/ __ \  / __ \/ __ ^`/ __/
+echo  / /_/ / / / / _^, _/  __/ / / / / /_/ / /_/ / /_
+echo  \____/_/ /_/_/ ^|_^|\___/_/ /_(_)_.___/\__^,_/\__/ v%version%
+echo.
+echo  ----------------------------------------------------
+echo.
+
+REM --------------------------------------------------------------------------------
+REM We need powershell for later, make sure it exists
+REM --------------------------------------------------------------------------------
+if not exist "%SystemRoot%\system32\WindowsPowerShell\v1.0\powershell.exe" (
+	echo    ! Error: Powershell is required, unable to continue.
+	echo             This is included in Windows 7, 8, 10. XP/Vista users can
+	echo             download it here: http://support.microsoft.com/kb/968929
+	echo.
+rem	pause>nul|set/p=.            Press any key to exit...
+	exit
+)
+
+REM --------------------------------------------------------------------------------
+REM Set our paths, and make sure we can find python exe
+REM --------------------------------------------------------------------------------
+set "currentdir=%~dp0%"
+set "pythondir=%currentdir%..\lib\windows-i686\"
+set "renpydir=%currentdir%..\renpy\"
+set "gamedir=%currentdir%"
+if exist "game" if exist "lib" if exist "renpy" (
+	set "pythondir=%currentdir%lib\windows-i686\"
+	set "renpydir=%currentdir%renpy\"
+	set "gamedir=%currentdir%game\"
+)
+
+if not exist "%pythondir%python.exe" (
+	set "pythondir=%currentdir%..\lib\windows-x86_64\"
+	set "renpydir=%currentdir%..\renpy\"
+	set "gamedir=%currentdir%"
+	if exist "game" if exist "lib" if exist "renpy" (
+		set "pythondir=%currentdir%lib\windows-x86_64\"
+		set "renpydir=%currentdir%renpy\"
+		set "gamedir=%currentdir%game\"
+	)
+)
+
+if not exist "%pythondir%python.exe" (
+	echo    ! Error: Cannot locate python.exe, unable to continue.
+	echo             Are you sure we're in the game's root or game directory?
+	echo.
+rem	pause>nul|set/p=.            Press any key to exit...
+	exit
+)
+
+:menu
+goto decompile
+
+:decompile
+REM --------------------------------------------------------------------------------
+REM Write to temporary file first, then convert. Needed due to binary file
+REM --------------------------------------------------------------------------------
+set "decompcab=%currentdir%rpycdecdata\_decomp.cab"
+set "decompilerdir=%currentdir%rpycdecdata\decompiler"
+set "unrpycpy=%currentdir%rpycdecdata\unrpyc.py"
+set "deobfuscate=%currentdir%rpycdecdata\deobfuscate.py"
+if not exist "%gamedir%*.rpyc" (
+	echo No .rpyc files found in %gamedir%!
+	echo.
+	goto finish
+)
+
+
+REM --------------------------------------------------------------------------------
+REM Decompile rpyc files
+REM --------------------------------------------------------------------------------
+echo   Searching for rpyc files...
+cd "%gamedir%"
+set "PYTHONPATH=%pythondir%Lib"
+for /r %%f in (*.rpyc) do (
+	if not %%~nf == un (
+		echo    + Decompiling "%%~nf%%~xf" - %%~zf bytes
+		"%pythondir%python.exe" -O "%unrpycpy%" -c --init-offset "%%f"
+	)
+)
+echo.
+
+REM --------------------------------------------------------------------------------
+REM Clean up
+REM --------------------------------------------------------------------------------
+echo   Cleaning up temporary files...
+del "%unrpycpy%"
+del "%unrpycpy%o"
+del "%decompcab%.tmp"
+del "%decompcab%"
+del "%deobfuscate%"
+del "%deobfuscate%o"
+rmdir /Q /S "%decompilerdir%"
+rmdir /Q /S "%currentdir%rpycdecdata\"
+echo.
+
+goto finish
+
+
+
+:finish
+REM --------------------------------------------------------------------------------
+REM We are done
+REM --------------------------------------------------------------------------------
+echo  ----------------------------------------------------
+echo    Finished!
+echo  ----------------------------------------------------
+
+exit

renpy/rpycdec/rpycdecdata/decompiler/__init__.py

@@ -0,0 +1,958 @@
+# Copyright (c) 2012 Yuri K. Schlesner
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+from __future__ import unicode_literals
+from util import DecompilerBase, First, WordConcatenator, reconstruct_paraminfo, \
+                 reconstruct_arginfo, string_escape, split_logical_lines, Dispatcher
+from util import say_get_code
+
+from operator import itemgetter
+from StringIO import StringIO
+
+import magic
+magic.fake_package(b"renpy")
+import renpy
+
+import screendecompiler
+import sl2decompiler
+import testcasedecompiler
+import codegen
+import astdump
+
+__all__ = ["astdump", "codegen", "magic", "screendecompiler", "sl2decompiler", "testcasedecompiler", "translate", "util", "pprint", "Decompiler"]
+
+# Main API
+
+def pprint(out_file, ast, indent_level=0,
+           decompile_python=False, printlock=None, translator=None, init_offset=False, tag_outside_block=False):
+    Decompiler(out_file, printlock=printlock,
+               decompile_python=decompile_python, translator=translator).dump(ast, indent_level, init_offset, tag_outside_block)
+
+# Implementation
+
+class Decompiler(DecompilerBase):
+    """
+    An object which hanldes the decompilation of renpy asts to a given stream
+    """
+
+    # This dictionary is a mapping of Class: unbount_method, which is used to determine
+    # what method to call for which ast class
+    dispatch = Dispatcher()
+
+    def __init__(self, out_file=None, decompile_python=False,
+                 indentation = '    ', printlock=None, translator=None):
+        super(Decompiler, self).__init__(out_file, indentation, printlock)
+        self.decompile_python = decompile_python
+        self.translator = translator
+
+        self.paired_with = False
+        self.say_inside_menu = None
+        self.label_inside_menu = None
+        self.in_init = False
+        self.missing_init = False
+        self.init_offset = 0
+        self.is_356c6e34_or_later = False
+        self.most_lines_behind = 0
+        self.last_lines_behind = 0
+        self.tag_outside_block = False
+
+    def advance_to_line(self, linenumber):
+        self.last_lines_behind = max(self.linenumber + (0 if self.skip_indent_until_write else 1) - linenumber, 0)
+        self.most_lines_behind = max(self.last_lines_behind, self.most_lines_behind)
+        super(Decompiler, self).advance_to_line(linenumber)
+
+    def save_state(self):
+        return (super(Decompiler, self).save_state(),
+                self.paired_with, self.say_inside_menu, self.label_inside_menu, self.in_init, self.missing_init, self.most_lines_behind, self.last_lines_behind)
+
+    def commit_state(self, state):
+        super(Decompiler, self).commit_state(state[0])
+
+    def rollback_state(self, state):
+        self.paired_with = state[1]
+        self.say_inside_menu = state[2]
+        self.label_inside_menu = state[3]
+        self.in_init = state[4]
+        self.missing_init = state[5]
+        self.most_lines_behind = state[6]
+        self.last_lines_behind = state[7]
+        super(Decompiler, self).rollback_state(state[0])
+
+    def dump(self, ast, indent_level=0, init_offset=False, tag_outside_block=False):
+        if (isinstance(ast, (tuple, list)) and len(ast) > 1 and
+            isinstance(ast[-1], renpy.ast.Return) and
+            (not hasattr(ast[-1], 'expression') or ast[-1].expression is None) and
+            ast[-1].linenumber == ast[-2].linenumber):
+            # A very crude version check, but currently the best we can do.
+            # Note that this commit first appears in the 6.99 release.
+            self.is_356c6e34_or_later = True
+
+        self.tag_outside_block = tag_outside_block
+
+        if self.translator:
+            self.translator.translate_dialogue(ast)
+
+        if init_offset and isinstance(ast, (tuple, list)):
+            self.set_best_init_offset(ast)
+
+        # skip_indent_until_write avoids an initial blank line
+        super(Decompiler, self).dump(ast, indent_level, skip_indent_until_write=True)
+        # if there's anything we wanted to write out but didn't yet, do it now
+        for m in self.blank_line_queue:
+            m(None)
+        self.write("\n# Decompiled by unrpyc: https://github.com/CensoredUsername/unrpyc\n")
+        assert not self.missing_init, "A required init, init label, or translate block was missing"
+
+    def print_node(self, ast):
+        # We special-case line advancement for some types in their print
+        # methods, so don't advance lines for them here.
+        if hasattr(ast, 'linenumber') and not isinstance(ast, (renpy.ast.TranslateString, renpy.ast.With, renpy.ast.Label, renpy.ast.Pass, renpy.ast.Return)):
+            self.advance_to_line(ast.linenumber)
+        # It doesn't matter what line "block:" is on. The loc of a RawBlock
+        # refers to the first statement inside the block, which we advance
+        # to from print_atl.
+        elif hasattr(ast, 'loc') and not isinstance(ast, renpy.atl.RawBlock):
+            self.advance_to_line(ast.loc[1])
+        self.dispatch.get(type(ast), type(self).print_unknown)(self, ast)
+
+    # ATL printing functions
+
+    def print_atl(self, ast):
+        with self.increase_indent():
+            self.advance_to_line(ast.loc[1])
+            if ast.statements:
+                self.print_nodes(ast.statements)
+            # If a statement ends with a colon but has no block after it, loc will
+            # get set to ('', 0). That isn't supposed to be valid syntax, but it's
+            # the only thing that can generate that.
+            elif ast.loc != ('', 0):
+                self.indent()
+                self.write("pass")
+
+    @dispatch(renpy.atl.RawMultipurpose)
+    def print_atl_rawmulti(self, ast):
+        warp_words = WordConcatenator(False)
+
+        # warpers
+        if ast.warp_function:
+            warp_words.append("warp", ast.warp_function, ast.duration)
+        elif ast.warper:
+            warp_words.append(ast.warper, ast.duration)
+        elif ast.duration != "0":
+            warp_words.append("pause", ast.duration)
+
+        warp = warp_words.join()
+        words = WordConcatenator(warp and warp[-1] != ' ', True)
+
+        # revolution
+        if ast.revolution:
+            words.append(ast.revolution)
+
+        # circles
+        if ast.circles != "0":
+            words.append("circles %s" % ast.circles)
+
+        # splines
+        spline_words = WordConcatenator(False)
+        for name, expressions in ast.splines:
+            spline_words.append(name, expressions[-1])
+            for expression in expressions[:-1]:
+                spline_words.append("knot", expression)
+        words.append(spline_words.join())
+
+        # properties
+        property_words = WordConcatenator(False)
+        for key, value in ast.properties:
+            property_words.append(key, value)
+        words.append(property_words.join())
+
+        # with
+        expression_words = WordConcatenator(False)
+        # TODO There's a lot of cases where pass isn't needed, since we could
+        # reorder stuff so there's never 2 expressions in a row. (And it's never
+        # necessary for the last one, but we don't know what the last one is
+        # since it could get reordered.)
+        needs_pass = len(ast.expressions) > 1
+        for (expression, with_expression) in ast.expressions:
+            expression_words.append(expression)
+            if with_expression:
+                expression_words.append("with", with_expression)
+            if needs_pass:
+                expression_words.append("pass")
+        words.append(expression_words.join())
+
+        to_write = warp + words.join()
+        if to_write:
+            self.indent()
+            self.write(to_write)
+        else:
+            # A trailing comma results in an empty RawMultipurpose being
+            # generated on the same line as the last real one.
+            self.write(",")
+
+    @dispatch(renpy.atl.RawBlock)
+    def print_atl_rawblock(self, ast):
+        self.indent()
+        self.write("block:")
+        self.print_atl(ast)
+
+    @dispatch(renpy.atl.RawChild)
+    def print_atl_rawchild(self, ast):
+        for child in ast.children:
+            self.indent()
+            self.write("contains:")
+            self.print_atl(child)
+
+    @dispatch(renpy.atl.RawChoice)
+    def print_atl_rawchoice(self, ast):
+        for chance, block in ast.choices:
+            self.indent()
+            self.write("choice")
+            if chance != "1.0":
+                self.write(" %s" % chance)
+            self.write(":")
+            self.print_atl(block)
+        if (self.index + 1 < len(self.block) and
+            isinstance(self.block[self.index + 1], renpy.atl.RawChoice)):
+            self.indent()
+            self.write("pass")
+
+    @dispatch(renpy.atl.RawContainsExpr)
+    def print_atl_rawcontainsexpr(self, ast):
+        self.indent()
+        self.write("contains %s" % ast.expression)
+
+    @dispatch(renpy.atl.RawEvent)
+    def print_atl_rawevent(self, ast):
+        self.indent()
+        self.write("event %s" % ast.name)
+
+    @dispatch(renpy.atl.RawFunction)
+    def print_atl_rawfunction(self, ast):
+        self.indent()
+        self.write("function %s" % ast.expr)
+
+    @dispatch(renpy.atl.RawOn)
+    def print_atl_rawon(self, ast):
+        for name, block in sorted(ast.handlers.items(),
+                                  key=lambda i: i[1].loc[1]):
+            self.indent()
+            self.write("on %s:" % name)
+            self.print_atl(block)
+
+    @dispatch(renpy.atl.RawParallel)
+    def print_atl_rawparallel(self, ast):
+        for block in ast.blocks:
+            self.indent()
+            self.write("parallel:")
+            self.print_atl(block)
+        if (self.index + 1 < len(self.block) and
+            isinstance(self.block[self.index + 1], renpy.atl.RawParallel)):
+            self.indent()
+            self.write("pass")
+
+    @dispatch(renpy.atl.RawRepeat)
+    def print_atl_rawrepeat(self, ast):
+        self.indent()
+        self.write("repeat")
+        if ast.repeats:
+            self.write(" %s" % ast.repeats) # not sure if this is even a string
+
+    @dispatch(renpy.atl.RawTime)
+    def print_atl_rawtime(self, ast):
+        self.indent()
+        self.write("time %s" % ast.time)
+
+    # Displayable related functions
+
+    def print_imspec(self, imspec):
+        if imspec[1] is not None:
+            begin = "expression %s" % imspec[1]
+        else:
+            begin = " ".join(imspec[0])
+
+        words = WordConcatenator(begin and begin[-1] != ' ', True)
+        if imspec[2] is not None:
+            words.append("as %s" % imspec[2])
+
+        if len(imspec[6]) > 0:
+            words.append("behind %s" % ', '.join(imspec[6]))
+
+        if isinstance(imspec[4], unicode):
+            words.append("onlayer %s" % imspec[4])
+
+        if imspec[5] is not None:
+            words.append("zorder %s" % imspec[5])
+
+        if len(imspec[3]) > 0:
+            words.append("at %s" % ', '.join(imspec[3]))
+
+        self.write(begin + words.join())
+        return words.needs_space
+
+    @dispatch(renpy.ast.Image)
+    def print_image(self, ast):
+        self.require_init()
+        self.indent()
+        self.write("image %s" % ' '.join(ast.imgname))
+        if ast.code is not None:
+            self.write(" = %s" % ast.code.source)
+        else:
+            if hasattr(ast, "atl") and ast.atl is not None:
+                self.write(":")
+                self.print_atl(ast.atl)
+
+    @dispatch(renpy.ast.Transform)
+    def print_transform(self, ast):
+        self.require_init()
+        self.indent()
+
+        # If we have an implicit init block with a non-default priority, we need to store the priority here.
+        priority = ""
+        if isinstance(self.parent, renpy.ast.Init):
+            init = self.parent
+            if init.priority != self.init_offset and len(init.block) == 1 and not self.should_come_before(init, ast):
+                priority = " %d" % (init.priority - self.init_offset)
+        self.write("transform%s %s" % (priority, ast.varname))
+        if ast.parameters is not None:
+            self.write(reconstruct_paraminfo(ast.parameters))
+
+        if hasattr(ast, "atl") and ast.atl is not None:
+            self.write(":")
+            self.print_atl(ast.atl)
+
+    # Directing related functions
+
+    @dispatch(renpy.ast.Show)
+    def print_show(self, ast):
+        self.indent()
+        self.write("show ")
+        needs_space = self.print_imspec(ast.imspec)
+
+        if self.paired_with:
+            if needs_space:
+                self.write(" ")
+            self.write("with %s" % self.paired_with)
+            self.paired_with = True
+
+        if hasattr(ast, "atl") and ast.atl is not None:
+            self.write(":")
+            self.print_atl(ast.atl)
+
+    @dispatch(renpy.ast.ShowLayer)
+    def print_showlayer(self, ast):
+        self.indent()
+        self.write("show layer %s" % ast.layer)
+
+        if ast.at_list:
+            self.write(" at %s" % ', '.join(ast.at_list))
+
+        if hasattr(ast, "atl") and ast.atl is not None:
+            self.write(":")
+            self.print_atl(ast.atl)
+
+    @dispatch(renpy.ast.Scene)
+    def print_scene(self, ast):
+        self.indent()
+        self.write("scene")
+
+        if ast.imspec is None:
+            if isinstance(ast.layer, unicode):
+                self.write(" onlayer %s" % ast.layer)
+            needs_space = True
+        else:
+            self.write(" ")
+            needs_space = self.print_imspec(ast.imspec)
+
+        if self.paired_with:
+            if needs_space:
+                self.write(" ")
+            self.write("with %s" % self.paired_with)
+            self.paired_with = True
+
+        if hasattr(ast, "atl") and ast.atl is not None:
+            self.write(":")
+            self.print_atl(ast.atl)
+
+    @dispatch(renpy.ast.Hide)
+    def print_hide(self, ast):
+        self.indent()
+        self.write("hide ")
+        needs_space = self.print_imspec(ast.imspec)
+        if self.paired_with:
+            if needs_space:
+                self.write(" ")
+            self.write("with %s" % self.paired_with)
+            self.paired_with = True
+
+    @dispatch(renpy.ast.With)
+    def print_with(self, ast):
+        # the 'paired' attribute indicates that this with
+        # and with node afterwards are part of a postfix
+        # with statement. detect this and process it properly
+        if hasattr(ast, "paired") and ast.paired is not None:
+            # Sanity check. check if there's a matching with statement two nodes further
+            if not(isinstance(self.block[self.index + 2], renpy.ast.With) and
+                   self.block[self.index + 2].expr == ast.paired):
+                raise Exception("Unmatched paired with {0} != {1}".format(
+                                repr(self.paired_with), repr(ast.expr)))
+
+            self.paired_with = ast.paired
+
+        elif self.paired_with:
+            # Check if it was consumed by a show/scene statement
+            if self.paired_with is not True:
+                self.write(" with %s" % ast.expr)
+            self.paired_with = False
+        else:
+            self.advance_to_line(ast.linenumber)
+            self.indent()
+            self.write("with %s" % ast.expr)
+            self.paired_with = False
+
+    # Flow control
+
+    @dispatch(renpy.ast.Label)
+    def print_label(self, ast):
+        # If a Call block preceded us, it printed us as "from"
+        if (self.index and isinstance(self.block[self.index - 1], renpy.ast.Call)):
+            return
+        remaining_blocks = len(self.block) - self.index
+        if remaining_blocks > 1:
+            next_ast = self.block[self.index + 1]
+            # See if we're the label for a menu, rather than a standalone label.
+            if (not ast.block and (not hasattr(ast, 'parameters') or ast.parameters is None) and
+                hasattr(next_ast, 'linenumber') and next_ast.linenumber == ast.linenumber and
+                (isinstance(next_ast, renpy.ast.Menu) or (remaining_blocks > 2 and
+                isinstance(next_ast, renpy.ast.Say) and
+                self.say_belongs_to_menu(next_ast, self.block[self.index + 2])))):
+                self.label_inside_menu = ast
+                return
+        self.advance_to_line(ast.linenumber)
+        self.indent()
+
+        # It's possible that we're an "init label", not a regular label. There's no way to know
+        # if we are until we parse our children, so temporarily redirect all of our output until
+        # that's done, so that we can squeeze in an "init " if we are.
+        out_file = self.out_file
+        self.out_file = StringIO()
+        missing_init = self.missing_init
+        self.missing_init = False
+        try:
+            self.write("label %s%s%s:" % (
+                ast.name,
+                reconstruct_paraminfo(ast.parameters) if hasattr(ast, 'parameters') else '',
+                " hide" if hasattr(ast, 'hide') and ast.hide else ""))
+            self.print_nodes(ast.block, 1)
+        finally:
+            if self.missing_init:
+                out_file.write("init ")
+            self.missing_init = missing_init
+            out_file.write(self.out_file.getvalue())
+            self.out_file = out_file
+
+    @dispatch(renpy.ast.Jump)
+    def print_jump(self, ast):
+        self.indent()
+        self.write("jump %s%s" % ("expression " if ast.expression else "", ast.target))
+
+    @dispatch(renpy.ast.Call)
+    def print_call(self, ast):
+        self.indent()
+        words = WordConcatenator(False)
+        words.append("call")
+        if ast.expression:
+            words.append("expression")
+        words.append(ast.label)
+
+        if hasattr(ast, 'arguments') and ast.arguments is not None:
+            if ast.expression:
+                words.append("pass")
+            words.append(reconstruct_arginfo(ast.arguments))
+
+        # We don't have to check if there's enough elements here,
+        # since a Label or a Pass is always emitted after a Call.
+        next_block = self.block[self.index + 1]
+        if isinstance(next_block, renpy.ast.Label):
+            words.append("from %s" % next_block.name)
+
+        self.write(words.join())
+
+    @dispatch(renpy.ast.Return)
+    def print_return(self, ast):
+        if ((not hasattr(ast, 'expression') or ast.expression is None) and self.parent is None and
+            self.index + 1 == len(self.block) and self.index and
+            ast.linenumber == self.block[self.index - 1].linenumber):
+            # As of Ren'Py commit 356c6e34, a return statement is added to
+            # the end of each rpyc file. Don't include this in the source.
+            return
+
+        self.advance_to_line(ast.linenumber)
+        self.indent()
+        self.write("return")
+
+        if hasattr(ast, 'expression') and ast.expression is not None:
+            self.write(" %s" % ast.expression)
+
+    @dispatch(renpy.ast.If)
+    def print_if(self, ast):
+        statement = First("if %s:", "elif %s:")
+
+        for i, (condition, block) in enumerate(ast.entries):
+            # The non-Unicode string "True" is the condition for else:.
+            if (i + 1) == len(ast.entries) and not isinstance(condition, unicode):
+                self.indent()
+                self.write("else:")
+            else:
+                if(hasattr(condition, 'linenumber')):
+                    self.advance_to_line(condition.linenumber)
+                self.indent()
+                self.write(statement() % condition)
+
+            self.print_nodes(block, 1)
+
+    @dispatch(renpy.ast.While)
+    def print_while(self, ast):
+        self.indent()
+        self.write("while %s:" % ast.condition)
+
+        self.print_nodes(ast.block, 1)
+
+    @dispatch(renpy.ast.Pass)
+    def print_pass(self, ast):
+        if (self.index and
+            isinstance(self.block[self.index - 1], renpy.ast.Call)):
+            return
+
+        if (self.index > 1 and
+            isinstance(self.block[self.index - 2], renpy.ast.Call) and
+            isinstance(self.block[self.index - 1], renpy.ast.Label) and
+            self.block[self.index - 2].linenumber == ast.linenumber):
+            return
+
+        self.advance_to_line(ast.linenumber)
+        self.indent()
+        self.write("pass")
+
+    def should_come_before(self, first, second):
+        return first.linenumber < second.linenumber
+
+    def require_init(self):
+        if not self.in_init:
+            self.missing_init = True
+
+    def set_best_init_offset(self, nodes):
+        votes = {}
+        for ast in nodes:
+            if not isinstance(ast, renpy.ast.Init):
+                continue
+            offset = ast.priority
+            # Keep this block in sync with print_init
+            if len(ast.block) == 1 and not self.should_come_before(ast, ast.block[0]):
+                if isinstance(ast.block[0], renpy.ast.Screen):
+                    offset -= -500
+                elif isinstance(ast.block[0], renpy.ast.Testcase):
+                    offset -= 500
+                elif isinstance(ast.block[0], renpy.ast.Image):
+                    offset -= 500 if self.is_356c6e34_or_later else 990
+            votes[offset] = votes.get(offset, 0) + 1
+        if votes:
+            winner = max(votes, key=votes.get)
+            # It's only worth setting an init offset if it would save
+            # more than one priority specification versus not setting one.
+            if votes.get(0, 0) + 1 < votes[winner]:
+                self.set_init_offset(winner)
+
+    def set_init_offset(self, offset):
+        def do_set_init_offset(linenumber):
+            # if we got to the end of the file and haven't emitted this yet,
+            # don't bother, since it only applies to stuff below it.
+            if linenumber is None or linenumber - self.linenumber <= 1 or self.indent_level:
+                return True
+            if offset != self.init_offset:
+                self.indent()
+                self.write("init offset = %s" % offset)
+                self.init_offset = offset
+            return False
+
+        self.do_when_blank_line(do_set_init_offset)
+
+    @dispatch(renpy.ast.Init)
+    def print_init(self, ast):
+        in_init = self.in_init
+        self.in_init = True
+        try:
+            # A bunch of statements can have implicit init blocks
+            # Define has a default priority of 0, screen of -500 and image of 990
+            # Keep this block in sync with set_best_init_offset
+            # TODO merge this and require_init into another decorator or something
+            if len(ast.block) == 1 and (
+                isinstance(ast.block[0], (renpy.ast.Define,
+                                          renpy.ast.Default,
+                                          renpy.ast.Transform)) or
+                (ast.priority == -500 + self.init_offset and isinstance(ast.block[0], renpy.ast.Screen)) or
+                (ast.priority == self.init_offset and isinstance(ast.block[0], renpy.ast.Style)) or
+                (ast.priority == 500 + self.init_offset and isinstance(ast.block[0], renpy.ast.Testcase)) or
+                (ast.priority == 0 + self.init_offset and isinstance(ast.block[0], renpy.ast.UserStatement) and ast.block[0].line.startswith("layeredimage ")) or
+                # Images had their default init priority changed in commit 679f9e31 (Ren'Py 6.99.10).
+                # We don't have any way of detecting this commit, though. The closest one we can
+                # detect is 356c6e34 (Ren'Py 6.99). For any versions in between these, we'll emit
+                # an unnecessary "init 990 " before image statements, but this doesn't affect the AST,
+                # and any other solution would result in incorrect code being generated in some cases.
+                (ast.priority == (500 if self.is_356c6e34_or_later else 990) + self.init_offset and isinstance(ast.block[0], renpy.ast.Image))) and not (
+                self.should_come_before(ast, ast.block[0])):
+                # If they fulfill this criteria we just print the contained statement
+                self.print_nodes(ast.block)
+
+            # translatestring statements are split apart and put in an init block.
+            elif (len(ast.block) > 0 and
+                    ast.priority == self.init_offset and
+                    all(isinstance(i, renpy.ast.TranslateString) for i in ast.block) and
+                    all(i.language == ast.block[0].language for i in ast.block[1:])):
+                self.print_nodes(ast.block)
+
+            else:
+                self.indent()
+                self.write("init")
+                if ast.priority != self.init_offset:
+                    self.write(" %d" % (ast.priority - self.init_offset))
+
+                if len(ast.block) == 1 and not self.should_come_before(ast, ast.block[0]):
+                    self.write(" ")
+                    self.skip_indent_until_write = True
+                    self.print_nodes(ast.block)
+                else:
+                    self.write(":")
+                    self.print_nodes(ast.block, 1)
+        finally:
+            self.in_init = in_init
+
+    def print_say_inside_menu(self):
+        self.print_say(self.say_inside_menu, inmenu=True)
+        self.say_inside_menu = None
+
+    def print_menu_item(self, label, condition, block, arguments):
+        self.indent()
+        self.write('"%s"' % string_escape(label))
+
+        if arguments is not None:
+            self.write(reconstruct_arginfo(arguments))
+
+        if block is not None:
+            if isinstance(condition, unicode):
+                self.write(" if %s" % condition)
+            self.write(":")
+            self.print_nodes(block, 1)
+
+    @dispatch(renpy.ast.Menu)
+    def print_menu(self, ast):
+        self.indent()
+        self.write("menu")
+        if self.label_inside_menu is not None:
+            self.write(" %s" % self.label_inside_menu.name)
+            self.label_inside_menu = None
+
+        if hasattr(ast, "arguments") and ast.arguments is not None:
+            self.write(reconstruct_arginfo(ast.arguments))
+
+        self.write(":")
+
+        with self.increase_indent():
+            if ast.with_ is not None:
+                self.indent()
+                self.write("with %s" % ast.with_)
+
+            if ast.set is not None:
+                self.indent()
+                self.write("set %s" % ast.set)
+
+            if hasattr(ast, "item_arguments"):
+                item_arguments = ast.item_arguments
+            else:
+                item_arguments = [None] * len(ast.items)
+
+            for (label, condition, block), arguments in zip(ast.items, item_arguments):
+                if self.translator:
+                    label = self.translator.strings.get(label, label)
+
+                state = None
+
+                # if the condition is a unicode subclass with a "linenumber" attribute it was script.
+                # If it isn't ren'py used to insert a "True" string. This string used to be of type str
+                # but nowadays it's of time unicode, just not of type PyExpr
+                if isinstance(condition, unicode) and hasattr(condition, "linenumber"):
+                    if self.say_inside_menu is not None and condition.linenumber > self.linenumber + 1:
+                        # The easy case: we know the line number that the menu item is on, because the condition tells us
+                        # So we put the say statement here if there's room for it, or don't if there's not
+                        self.print_say_inside_menu()
+                    self.advance_to_line(condition.linenumber)
+                elif self.say_inside_menu is not None:
+                    # The hard case: we don't know the line number that the menu item is on
+                    # So try to put it in, but be prepared to back it out if that puts us behind on the line number
+                    state = self.save_state()
+                    self.most_lines_behind = self.last_lines_behind
+                    self.print_say_inside_menu()
+
+                self.print_menu_item(label, condition, block, arguments)
+
+                if state is not None:
+                    if self.most_lines_behind > state[7]: # state[7] is the saved value of self.last_lines_behind
+                        # We tried to print the say statement that's inside the menu, but it didn't fit here
+                        # Undo it and print this item again without it. We'll fit it in later
+                        self.rollback_state(state)
+                        self.print_menu_item(label, condition, block, arguments)
+                    else:
+                        self.most_lines_behind = max(state[6], self.most_lines_behind) # state[6] is the saved value of self.most_lines_behind
+                        self.commit_state(state)
+
+            if self.say_inside_menu is not None:
+                # There was no room for this before any of the menu options, so it will just have to go after them all
+                self.print_say_inside_menu()
+
+    # Programming related functions
+
+    @dispatch(renpy.ast.Python)
+    def print_python(self, ast, early=False):
+        self.indent()
+
+        code = ast.code.source
+        if code[0] == '\n':
+            code = code[1:]
+            self.write("python")
+            if early:
+                self.write(" early")
+            if ast.hide:
+                self.write(" hide")
+            if hasattr(ast, "store") and ast.store != "store":
+                self.write(" in ")
+                # Strip prepended "store."
+                self.write(ast.store[6:])
+            self.write(":")
+
+            with self.increase_indent():
+                self.write_lines(split_logical_lines(code))
+
+        else:
+            self.write("$ %s" % code)
+
+    @dispatch(renpy.ast.EarlyPython)
+    def print_earlypython(self, ast):
+        self.print_python(ast, early=True)
+
+    @dispatch(renpy.ast.Define)
+    @dispatch(renpy.ast.Default)
+    def print_define(self, ast):
+        self.require_init()
+        self.indent()
+        if isinstance(ast, renpy.ast.Default):
+            name = "default"
+        else:
+            name = "define"
+
+        # If we have an implicit init block with a non-default priority, we need to store the priority here.
+        priority = ""
+        if isinstance(self.parent, renpy.ast.Init):
+            init = self.parent
+            if init.priority != self.init_offset and len(init.block) == 1 and not self.should_come_before(init, ast):
+                priority = " %d" % (init.priority - self.init_offset)
+        index = ""
+        if hasattr(ast, "index") and ast.index is not None:
+            index = "[%s]" % ast.index.source
+        if not hasattr(ast, "store") or ast.store == "store":
+            self.write("%s%s %s%s = %s" % (name, priority, ast.varname, index, ast.code.source))
+        else:
+            self.write("%s%s %s.%s%s = %s" % (name, priority, ast.store[6:], ast.varname, index, ast.code.source))
+
+    # Specials
+
+    # Returns whether a Say statement immediately preceding a Menu statement
+    # actually belongs inside of the Menu statement.
+    def say_belongs_to_menu(self, say, menu):
+        return (not say.interact and say.who is not None and
+            say.with_ is None and 
+            (not hasattr(say, "attributes") or say.attributes is None) and
+            isinstance(menu, renpy.ast.Menu) and
+            menu.items[0][2] is not None and
+            not self.should_come_before(say, menu))
+
+    @dispatch(renpy.ast.Say)
+    def print_say(self, ast, inmenu=False):
+        if (not inmenu and self.index + 1 < len(self.block) and
+            self.say_belongs_to_menu(ast, self.block[self.index + 1])):
+            self.say_inside_menu = ast
+            return
+        self.indent()
+        self.write(say_get_code(ast, inmenu))
+
+    @dispatch(renpy.ast.UserStatement)
+    def print_userstatement(self, ast):
+        self.indent()
+        self.write(ast.line)
+
+        if hasattr(ast, "block") and ast.block:
+            with self.increase_indent():
+                self.print_lex(ast.block)
+
+    def print_lex(self, lex):
+        for file, linenumber, content, block in lex:
+            self.advance_to_line(linenumber)
+            self.indent()
+            self.write(content)
+            if block:
+                with self.increase_indent():
+                    self.print_lex(block)
+
+    @dispatch(renpy.ast.Style)
+    def print_style(self, ast):
+        self.require_init()
+        keywords = {ast.linenumber: WordConcatenator(False, True)}
+
+        # These don't store a line number, so just put them on the first line
+        if ast.parent is not None:
+            keywords[ast.linenumber].append("is %s" % ast.parent)
+        if ast.clear:
+            keywords[ast.linenumber].append("clear")
+        if ast.take is not None:
+            keywords[ast.linenumber].append("take %s" % ast.take)
+        for delname in ast.delattr:
+            keywords[ast.linenumber].append("del %s" % delname)
+
+        # These do store a line number
+        if ast.variant is not None:
+            if ast.variant.linenumber not in keywords:
+                keywords[ast.variant.linenumber] = WordConcatenator(False)
+            keywords[ast.variant.linenumber].append("variant %s" % ast.variant)
+        for key, value in ast.properties.iteritems():
+            if value.linenumber not in keywords:
+                keywords[value.linenumber] = WordConcatenator(False)
+            keywords[value.linenumber].append("%s %s" % (key, value))
+
+        keywords = sorted([(k, v.join()) for k, v in keywords.items()],
+                          key=itemgetter(0))
+        self.indent()
+        self.write("style %s" % ast.style_name)
+        if keywords[0][1]:
+            self.write(" %s" % keywords[0][1])
+        if len(keywords) > 1:
+            self.write(":")
+            with self.increase_indent():
+                for i in keywords[1:]:
+                    self.advance_to_line(i[0])
+                    self.indent()
+                    self.write(i[1])
+
+    # Translation functions
+
+    @dispatch(renpy.ast.Translate)
+    def print_translate(self, ast):
+        self.indent()
+        self.write("translate %s %s:" % (ast.language or "None", ast.identifier))
+
+        self.print_nodes(ast.block, 1)
+
+    @dispatch(renpy.ast.EndTranslate)
+    def print_endtranslate(self, ast):
+        # an implicitly added node which does nothing...
+        pass
+
+    @dispatch(renpy.ast.TranslateString)
+    def print_translatestring(self, ast):
+        self.require_init()
+        # Was the last node a translatestrings node?
+        if not(self.index and
+               isinstance(self.block[self.index - 1], renpy.ast.TranslateString) and
+               self.block[self.index - 1].language == ast.language):
+            self.indent()
+            self.write("translate %s strings:" % ast.language or "None")
+
+        # TranslateString's linenumber refers to the line with "old", not to the
+        # line with "translate %s strings:"
+        with self.increase_indent():
+            self.advance_to_line(ast.linenumber)
+            self.indent()
+            self.write('old "%s"' % string_escape(ast.old))
+            if hasattr(ast, 'newloc'):
+                self.advance_to_line(ast.newloc[1])
+            self.indent()
+            self.write('new "%s"' % string_escape(ast.new))
+
+    @dispatch(renpy.ast.TranslateBlock)
+    @dispatch(renpy.ast.TranslateEarlyBlock)
+    def print_translateblock(self, ast):
+        self.indent()
+        self.write("translate %s " % (ast.language or "None"))
+
+        self.skip_indent_until_write = True
+
+        in_init = self.in_init
+        if len(ast.block) == 1 and isinstance(ast.block[0], (renpy.ast.Python, renpy.ast.Style)):
+            # Ren'Py counts the TranslateBlock from "translate python" and "translate style" as an Init.
+            self.in_init = True
+        try:
+            self.print_nodes(ast.block)
+        finally:
+            self.in_init = in_init
+
+    # Screens
+
+    @dispatch(renpy.ast.Screen)
+    def print_screen(self, ast):
+        self.require_init()
+        screen = ast.screen
+        if isinstance(screen, renpy.screenlang.ScreenLangScreen):
+            self.linenumber = screendecompiler.pprint(self.out_file, screen, self.indent_level,
+                                    self.linenumber,
+                                    self.decompile_python,
+                                    self.skip_indent_until_write,
+                                    self.printlock)
+            self.skip_indent_until_write = False
+
+        elif isinstance(screen, renpy.sl2.slast.SLScreen):
+            def print_atl_callback(linenumber, indent_level, atl):
+                old_linenumber = self.linenumber
+                self.linenumber = linenumber
+                with self.increase_indent(indent_level - self.indent_level):
+                    self.print_atl(atl)
+                new_linenumber = self.linenumber
+                self.linenumber = old_linenumber
+                return new_linenumber
+
+            self.linenumber = sl2decompiler.pprint(self.out_file, screen, print_atl_callback,
+                                    self.indent_level,
+                                    self.linenumber,
+                                    self.skip_indent_until_write,
+                                    self.printlock,
+                                    self.tag_outside_block)
+            self.skip_indent_until_write = False
+        else:
+            self.print_unknown(screen)
+
+    # Testcases
+
+    @dispatch(renpy.ast.Testcase)
+    def print_testcase(self, ast):
+        self.require_init()
+        self.indent()
+        self.write('testcase %s:' % ast.label)
+        self.linenumber = testcasedecompiler.pprint(self.out_file, ast.test.block, self.indent_level + 1,
+                                self.linenumber,
+                                self.skip_indent_until_write,
+                                self.printlock)
+        self.skip_indent_until_write = False

renpy/rpycdec/rpycdecdata/decompiler/astdump.py

@@ -0,0 +1,283 @@
+# Copyright (c) 2013 CensoredUsername
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+from __future__ import unicode_literals
+
+import sys
+import inspect
+import codegen
+import ast as py_ast
+import renpy
+
+def pprint(out_file, ast, decompile_python=False, comparable=False, no_pyexpr=False):
+    # The main function of this module, a wrapper which sets
+    # the config and creates the AstDumper instance
+    AstDumper(out_file, decompile_python=decompile_python, comparable=comparable, no_pyexpr=no_pyexpr).dump(ast)
+
+class AstDumper(object):
+    """
+    An object which handles the walking of a tree of python objects
+    it will create a human-readable representation of all interesting
+    attributes and write this to a given stream
+    """
+    MAP_OPEN = {list: '[', tuple: '(', set: '{', frozenset: 'frozenset({'}
+    MAP_CLOSE = {list: ']', tuple: ')', set: '}', frozenset: '})'}
+
+    def __init__(self, out_file=None, decompile_python=False, no_pyexpr=False,
+                 comparable=False, indentation=u'    '):
+        self.indentation = indentation
+        self.out_file = out_file or sys.stdout
+        self.decompile_python = decompile_python
+        self.comparable = comparable
+        self.no_pyexpr = no_pyexpr
+
+    def dump(self, ast):
+        self.linenumber = 1
+        self.indent = 0
+        self.passed = [] # We'll keep a stack of objects which we've traversed here so we don't recurse endlessly on circular references
+        self.passed_where = []
+        self.print_ast(ast)
+
+    def print_ast(self, ast):
+        # Decides which function should be used to print the given ast object.
+        try:
+            i = self.passed.index(ast)
+        except ValueError:
+            pass
+        else:
+            self.p('<circular reference to object on line %d>' % self.passed_where[i])
+            return
+        self.passed.append(ast)
+        self.passed_where.append(self.linenumber)
+        if isinstance(ast, (list, tuple, set, frozenset)):
+            self.print_list(ast)
+        elif isinstance(ast, renpy.ast.PyExpr):
+            self.print_pyexpr(ast)
+        elif isinstance(ast, dict):
+            self.print_dict(ast)
+        elif isinstance(ast, (str, unicode)):
+            self.print_string(ast)
+        elif isinstance(ast, (int, long, bool)) or ast is None:
+            self.print_other(ast)
+        elif inspect.isclass(ast):
+            self.print_class(ast)
+        elif isinstance(ast, object):
+            self.print_object(ast)
+        else:
+            self.print_other(ast)
+        self.passed_where.pop()
+        self.passed.pop()
+
+    def print_list(self, ast):
+        # handles the printing of simple containers of N elements.
+        if type(ast) not in (list, tuple, set, frozenset):
+            self.p(repr(type(ast)))
+
+            for k in (list, tuple, set, frozenset):
+                if isinstance(ast, k):
+                    klass = k
+
+        else:
+            klass = ast.__class__
+
+        self.p(self.MAP_OPEN[klass])
+
+        self.ind(1, ast)
+        for i, obj in enumerate(ast):
+            self.print_ast(obj)
+            if i+1 != len(ast):
+                self.p(',')
+                self.ind()
+        self.ind(-1, ast)
+        self.p(self.MAP_CLOSE[klass])
+
+    def print_dict(self, ast):
+        # handles the printing of dictionaries
+        if type(ast) != dict:
+            self.p(repr(type(ast)))
+
+        self.p('{')
+
+        self.ind(1, ast)
+        for i, key in enumerate(ast):
+            self.print_ast(key)
+            self.p(': ')
+            self.print_ast(ast[key])
+            if i+1 != len(ast):
+                self.p(',')
+                self.ind()
+        self.ind(-1, ast)
+        self.p('}')
+
+    def should_print_key(self, ast, key):
+        if key.startswith('_') or not hasattr(ast, key) or inspect.isroutine(getattr(ast, key)):
+            return False
+        elif not self.comparable:
+            return True
+        elif key == 'serial':
+            ast.serial = 0
+        elif key == 'col_offset':
+            ast.col_offset = 0 # TODO maybe make this match?
+        elif key == 'name' and type(ast.name) == tuple:
+            name = ast.name[0]
+            if isinstance(name, unicode):
+                name = name.encode('utf-8')
+            ast.name = (name.split(b'/')[-1], 0, 0)
+        elif key == 'location' and type(ast.location) == tuple:
+            if len(ast.location) == 4:
+                ast.location = (ast.location[0].split('/')[-1].split('\\')[-1], ast.location[1], ast.location[2], 0)
+            elif len(ast.location) == 3:
+                ast.location = (ast.location[0].split('/')[-1].split('\\')[-1], ast.location[1], 0)
+            elif len(ast.location) == 2:
+                ast.location = (ast.location[0].split('/')[-1].split('\\')[-1], ast.location[1])
+        elif key == 'loc' and type(ast.loc) == tuple:
+            ast.loc = (ast.loc[0].split('/')[-1].split('\\')[-1], ast.loc[1])
+        elif key == 'filename':
+            ast.filename = ast.filename.split('/')[-1].split('\\')[-1]
+        elif (key == 'parameters' and ast.parameters is None and
+            isinstance(ast, renpy.screenlang.ScreenLangScreen)):
+            # When no parameters exist, some versions of Ren'Py set parameters
+            # to None and some don't set it at all.
+            return False
+        elif (key == 'hide' and ast.hide == False and
+            (isinstance(ast, renpy.ast.Python) or
+            isinstance(ast, renpy.ast.Label))):
+            # When hide isn't set, some versions of Ren'Py set it to False and
+            # some don't set it at all.
+            return False
+        elif (key == 'attributes' and ast.attributes is None and
+            isinstance(ast, renpy.ast.Say)):
+            # When no attributes are set, some versions of Ren'Py set it to None
+            # and some don't set it at all.
+            return False
+        elif (key == 'temporary_attributes' and ast.temporary_attributes is None and
+            isinstance(ast, renpy.ast.Say)):
+            # When no temporary attributes are set, some versions of Ren'Py set
+            # it to None and some don't set it at all.
+            return False
+        elif (key == 'rollback' and ast.rollback == 'normal' and
+            isinstance(ast, renpy.ast.Say)):
+            # When rollback is normal, some versions of Ren'Py set it to 'normal'
+            # and some don't set it at all.
+            return False
+        elif (key == 'block' and ast.block == [] and
+            isinstance(ast, renpy.ast.UserStatement)):
+            # When there's no block, some versions of Ren'Py set it to None
+            # and some don't set it at all.
+            return False
+        elif (key == 'store' and ast.store == 'store' and
+            isinstance(ast, renpy.ast.Python)):
+            # When a store isn't specified, some versions of Ren'Py set it to
+            # "store" and some don't set it at all.
+            return False
+        elif key == 'translatable' and isinstance(ast, renpy.ast.UserStatement):
+            # Old versions of Ren'Py didn't have this attribute, and it's not
+            # controllable from the source.
+            return False
+        elif key == 'hotspot' and isinstance(ast, renpy.sl2.slast.SLDisplayable):
+            # Old versions of Ren'Py didn't have this attribute, and it's not
+            # controllable from the source.
+            return False
+        return True
+
+    def print_object(self, ast):
+        # handles the printing of anything unknown which inherts from object.
+        # prints the values of relevant attributes in a dictionary-like way
+        # it will not print anything which is a bound method or starts with a _
+        self.p('<')
+        self.p(str(ast.__class__)[8:-2] if hasattr(ast, '__class__')  else str(ast))
+
+        if isinstance(ast, py_ast.Module) and self.decompile_python:
+            self.p('.code = ')
+            self.print_ast(codegen.to_source(ast, unicode(self.indentation)))
+            self.p('>')
+            return
+
+        keys = list(i for i in dir(ast) if self.should_print_key(ast, i))
+        if keys:
+            self.p(' ')
+        self.ind(1, keys)
+        for i, key in enumerate(keys):
+            self.p('.')
+            self.p(str(key))
+            self.p(' = ')
+            self.print_ast(getattr(ast, key))
+            if i+1 != len(keys):
+                self.p(',')
+                self.ind()
+        self.ind(-1, keys)
+        self.p('>')
+
+    def print_pyexpr(self, ast):
+        if not self.no_pyexpr:
+            self.print_object(ast)
+            self.p(' = ')
+        self.print_string(ast)
+
+    def print_class(self, ast):
+        # handles the printing of classes
+        self.p('<class ')
+        self.p(str(ast)[8:-2])
+        self.p('>')
+
+    def print_string(self, ast):
+        # prints the representation of a string. If there are newlines in this string,
+        # it will print it as a docstring.
+        if b'\n' in ast:
+            astlist = ast.split(b'\n')
+            if isinstance(ast, unicode):
+                self.p('u')
+            self.p('"""')
+            self.p(self.escape_string(astlist.pop(0)))
+            for i, item in enumerate(astlist):
+                self.p('\n')
+                self.p(self.escape_string(item))
+            self.p('"""')
+            self.ind()
+
+        else:
+            self.p(repr(ast))
+
+    def escape_string(self, string):
+        # essentially the representation of a string without the surrounding quotes
+        if isinstance(string, unicode):
+            return repr(string)[2:-1]
+        elif isinstance(string, str):
+            return repr(string)[1:-1]
+        else:
+            return string
+
+    def print_other(self, ast):
+        # used as a last fallback
+        self.p(repr(ast))
+
+    def ind(self, diff_indent=0, ast=None):
+        # print a newline and indent. diff_indent represents the difference in indentation
+        # compared to the last line. it will chech the length of ast to determine if it
+        # shouldn't indent in case there's only one or zero objects in this object to print
+        if ast is None or len(ast) > 1:
+            self.indent += diff_indent
+            self.p(u'\n' + self.indentation * self.indent)
+
+    def p(self, string):
+        # write the string to the stream
+        string = unicode(string)
+        self.linenumber += string.count('\n')
+        self.out_file.write(string)

renpy/rpycdec/rpycdecdata/decompiler/codegen.py

@@ -0,0 +1,1102 @@
+# License
+# Copyright (c) 2008, Armin Ronacher
+# All rights reserved.
+
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+
+# - Redistributions of source code must retain the above copyright notice, this list of
+#   conditions and the following disclaimer.
+# - Redistributions in binary form must reproduce the above copyright notice, this list of
+#   conditions and the following disclaimer in the documentation and/or other materials
+#   provided with the distribution.
+# - Neither the name of the <ORGANIZATION> nor the names of its contributors may be used to
+#   endorse or promote products derived  from this software without specific prior written
+#   permission.
+
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
+# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+# FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
+# IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+# THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+# Taken from http://github.com/jonathaneunice/codegen
+
+"""
+    codegen
+    ~~~~~~~
+
+    Extension to ast that allow ast -> python code generation.
+
+    :copyright: Copyright 2008 by Armin Ronacher.
+    :license: BSD.
+"""
+
+import sys
+PY3 = sys.version_info >= (3, 0)
+# These might not exist, so we put them equal to NoneType
+Try = TryExcept = TryFinally = YieldFrom = MatMult = Await = type(None)
+
+from ast import *
+
+class Sep(object):
+    # Performs the common pattern of returning a different symbol the first
+    # time the object is called
+    def __init__(self, last, first=''):
+        self.last = last
+        self.first = first
+        self.begin = True
+    def __call__(self):
+        if self.begin:
+            self.begin = False
+            return self.first
+        return self.last
+
+def to_source(node, indent_with=' ' * 4, add_line_information=False, correct_line_numbers=False):
+    """This function can convert a node tree back into python sourcecode.
+    This is useful for debugging purposes, especially if you're dealing with
+    custom asts not generated by python itself.
+
+    It could be that the sourcecode is evaluable when the AST itself is not
+    compilable / evaluable.  The reason for this is that the AST contains some
+    more data than regular sourcecode does, which is dropped during
+    conversion.
+
+    Each level of indentation is replaced with `indent_with`.  Per default this
+    parameter is equal to four spaces as suggested by PEP 8, but it might be
+    adjusted to match the application's styleguide.
+
+    If `add_line_information` is set to `True` comments for the line numbers
+    of the nodes are added to the output.  This can be used to spot wrong line
+    number information of statement nodes.
+    """
+    if correct_line_numbers:
+        if hasattr(node, 'lineno'):
+            return SourceGenerator(indent_with, add_line_information, True, node.lineno).process(node)
+        else:
+            return SourceGenerator(indent_with, add_line_information, True).process(node)
+    else:
+        return SourceGenerator(indent_with, add_line_information).process(node)
+
+
+class SourceGenerator(NodeVisitor):
+    """This visitor is able to transform a well formed syntax tree into python
+    sourcecode.  For more details have a look at the docstring of the
+    `node_to_source` function.
+    """
+
+    COMMA = ', '
+    COLON = ': '
+    ASSIGN = ' = '
+    SEMICOLON = '; '
+    ARROW = ' -> '
+
+    BOOLOP_SYMBOLS = {
+        And:        (' and ', 5),
+        Or:         (' or ',  4)
+    }
+
+    BINOP_SYMBOLS = {
+        Add:        (' + ',  12),
+        Sub:        (' - ',  12),
+        Mult:       (' * ',  13),
+        MatMult:    (' @ ',  13),
+        Div:        (' / ',  13),
+        FloorDiv:   (' // ', 13),
+        Mod:        (' % ',  13),
+        Pow:        (' ** ', 15),
+        LShift:     (' << ', 11),
+        RShift:     (' >> ', 11),
+        BitOr:      (' | ',  8),
+        BitAnd:     (' & ',  10),
+        BitXor:     (' ^ ',  9)
+    }
+
+    CMPOP_SYMBOLS = {
+        Eq:         (' == ',     7),
+        Gt:         (' > ',      7),
+        GtE:        (' >= ',     7),
+        In:         (' in ',     7),
+        Is:         (' is ',     7),
+        IsNot:      (' is not ', 7),
+        Lt:         (' < ',      7),
+        LtE:        (' <= ',     7),
+        NotEq:      (' != ',     7),
+        NotIn:      (' not in ', 7)
+    }
+
+    UNARYOP_SYMBOLS = {
+        Invert:     ('~',    14),
+        Not:        ('not ', 6),
+        UAdd:       ('+',    14),
+        USub:       ('-',    14)
+    }
+
+    BLOCK_NODES = (If, For, While, With, Try, TryExcept, TryFinally,
+                   FunctionDef, ClassDef)
+
+    def __init__(self, indent_with, add_line_information=False, correct_line_numbers=False, line_number=1):
+        self.result = []
+        self.indent_with = indent_with
+        self.add_line_information = add_line_information
+        self.indentation = 0
+        self.new_lines = 0
+
+        # precedence_stack: what precedence level are we on, could we safely newline before and is this operator left-to-right
+        self.precedence_stack = [[0, False, None]]
+
+        self.correct_line_numbers = correct_line_numbers
+        # The current line number we *think* we are on. As in it's most likely
+        # the line number of the last node we passed which can differ when
+        # the ast is broken
+        self.line_number = line_number
+        # Can we insert a newline here without having to escape it?
+        # (are we between delimiting characters)
+        self.can_newline = False
+        # after a colon, we don't have to print a semi colon. set to 1 when self.body() is called,
+        # set to 2 or 0 when it's actually used. set to 0 at the end of the body
+        self.after_colon = 0
+        # reset by a call to self.newline, set by the first call to write() afterwards
+        # determines if we have to print the newlines and indent
+        self.indented = False
+        # the amount of newlines to be printed
+        self.newlines = 0
+        # force the printing of a proper newline (and not a semicolon)
+        self.force_newline = False
+
+    def process(self, node):
+        self.visit(node)
+        result = ''.join(self.result)
+        self.result = []
+        return result
+
+    # Precedence management
+
+    def prec_start(self, value, ltr=None):
+        newline = self.can_newline
+        if value < self.precedence_stack[-1][0]:
+            self.write('(')
+            self.can_newline = True
+        if ltr == False:
+            value += 1
+        self.precedence_stack.append([value, newline, ltr])
+
+    def prec_middle(self, level=None):
+        if level is not None:
+            self.precedence_stack[-1][0] = level
+        elif self.precedence_stack[-1][2]:
+            self.precedence_stack[-1][0] += 1
+        elif self.precedence_stack[-1][2] is False:
+            self.precedence_stack[-1][0] -= 1
+
+    def prec_end(self):
+        precedence, newline, ltr = self.precedence_stack.pop()
+        if ltr:
+            precedence -= 1
+        if precedence < self.precedence_stack[-1][0]:
+            self.write(')')
+            self.can_newline = newline
+
+    def paren_start(self, symbol='('):
+        self.precedence_stack.append([0, self.can_newline, None])
+        self.write(symbol)
+        self.can_newline = True
+
+    def paren_end(self, symbol=')'):
+        _, self.can_newline, _ = self.precedence_stack.pop()
+        self.write(symbol)
+
+    # convenience functions
+
+    def write(self, x):
+        # ignore empty writes
+        if not x:
+            return
+
+        # Before we write, we must check if newlines have been queued.
+        # If this is the case, we have to handle them properly
+        if self.correct_line_numbers:
+            if not self.indented:
+                self.new_lines = max(self.new_lines, 1 if self.force_newline else 0)
+                self.force_newline = False
+
+                if self.new_lines:
+                    # we have new lines to print
+                    if self.after_colon == 2:
+                        self.result.append(';'+'\\\n' * self.new_lines)
+                    else:
+                        self.after_colon = 0
+                        self.result.append('\n' * self.new_lines)
+                    self.result.append(self.indent_with * self.indentation)
+                elif self.after_colon == 1:
+                    # we're directly after a block-having statement and can write on the same line
+                    self.after_colon = 2
+                    self.result.append(' ')
+                elif self.result:
+                    # we're after any statement. or at the start of the file
+                    self.result.append(self.SEMICOLON)
+                self.indented = True
+            elif self.new_lines > 0:
+                if self.can_newline:
+                    self.result.append('\n' * self.new_lines)
+                    self.result.append(self.indent_with * (self.indentation + 1))
+                else:
+                    self.result.append('\\\n' * self.new_lines)
+                    self.result.append(self.indent_with * (self.indentation + 1))
+            self.new_lines = 0
+
+
+        elif self.new_lines:
+            # normal behaviour
+            self.result.append('\n' * self.new_lines)
+            self.result.append(self.indent_with * self.indentation)
+            self.new_lines = 0
+        self.result.append(x)
+
+    def newline(self, node=None, extra=0, force=False):
+        if not self.correct_line_numbers:
+            self.new_lines = max(self.new_lines, 1 + extra)
+            if not self.result:
+                self.new_lines = 0
+            if node is not None and self.add_line_information:
+                self.write('# line: %s' % node.lineno)
+                self.new_lines = 1
+        else:
+            if extra:
+                #Ignore extra
+                return
+
+            self.indented = False
+
+            if node is None:
+                # else/finally statement. insert one true newline. body is implicit
+                self.force_newline = True
+                self.new_lines += 1
+                self.line_number += 1
+
+            elif force:
+                # statement with a block: needs a true newline before it
+                self.force_newline = True
+                self.new_lines += node.lineno - self.line_number
+                self.line_number = node.lineno
+
+            else:
+                # block-less statement: needs a semicolon, colon, or newline in front of it
+                self.new_lines += node.lineno - self.line_number
+                self.line_number = node.lineno
+
+    def maybe_break(self, node):
+        if self.correct_line_numbers:
+            self.new_lines += node.lineno - self.line_number
+            self.line_number = node.lineno
+
+    def body(self, statements):
+        self.force_newline = any(isinstance(i, self.BLOCK_NODES) for i in statements)
+        self.indentation += 1
+        self.after_colon = 1
+        for stmt in statements:
+            self.visit(stmt)
+        self.indentation -= 1
+        self.force_newline = True
+        self.after_colon = 0 # do empty blocks even exist?
+
+    def body_or_else(self, node):
+        self.body(node.body)
+        if node.orelse:
+            self.newline()
+            self.write('else:')
+            self.body(node.orelse)
+
+    def visit_bare(self, node):
+        # this node is allowed to be a bare tuple
+        if isinstance(node, Tuple):
+            self.visit_Tuple(node, False)
+        else:
+            self.visit(node)
+
+    def visit_bareyield(self, node):
+        if isinstance(node, Yield):
+            self.visit_Yield(node, False)
+        elif isinstance(node, YieldFrom):
+            self.visit_YieldFrom(node, False)
+        else:
+            self.visit_bare(node)
+
+    def decorators(self, node):
+        for decorator in node.decorator_list:
+            self.newline(decorator, force=True)
+            self.write('@')
+            self.visit(decorator)
+        if node.decorator_list:
+            self.newline()
+        else:
+            self.newline(node, force=True)
+
+    # Module
+    def visit_Module(self, node):
+        self.generic_visit(node)
+        self.write('\n')
+        self.line_number += 1
+
+    # Statements
+
+    def visit_Assert(self, node):
+        self.newline(node)
+        self.write('assert ')
+        self.visit(node.test)
+        if node.msg:
+            self.write(self.COMMA)
+            self.visit(node.msg)
+
+    def visit_Assign(self, node):
+        self.newline(node)
+        for target in node.targets:
+            self.visit_bare(target)
+            self.write(self.ASSIGN)
+        self.visit_bareyield(node.value)
+
+    def visit_AugAssign(self, node):
+        self.newline(node)
+        self.visit_bare(node.target)
+        self.write(self.BINOP_SYMBOLS[type(node.op)][0].rstrip() + self.ASSIGN.lstrip())
+        self.visit_bareyield(node.value)
+
+    def visit_Await(self, node):
+        self.maybe_break(node)
+        self.prec_start(16, True)
+        self.prec_middle()
+        self.write('await ')
+        self.visit(node.value)
+        self.prec_end()
+
+    def visit_ImportFrom(self, node):
+        self.newline(node)
+        self.write('from ')
+        self.write('%s%s' % ('.' * node.level, node.module or ''))
+        self.write(' import ')
+        sep = Sep(self.COMMA)
+        for item in node.names:
+            self.write(sep())
+            self.visit(item)
+
+    def visit_Import(self, node):
+        self.newline(node)
+        self.write('import ')
+        sep = Sep(self.COMMA)
+        for item in node.names:
+            self.write(sep())
+            self.visit(item)
+
+    def visit_Exec(self, node):
+        self.newline(node)
+        self.write('exec ')
+        self.visit(node.body)
+        if node.globals:
+            self.write(' in ')
+            self.visit(node.globals)
+        if node.locals:
+            self.write(self.COMMA)
+            self.visit(node.locals)
+
+    def visit_Expr(self, node):
+        self.newline(node)
+        self.visit_bareyield(node.value)
+
+    def visit_AsyncFunctionDef(self, node):
+        self.visit_FunctionDef(node, True)
+
+    def visit_FunctionDef(self, node, async=False):
+        self.newline(extra=1)
+        # first decorator line number will be used
+        self.decorators(node)
+        if async:
+            self.write('async ')
+        self.write('def ')
+        self.write(node.name)
+        self.paren_start()
+        self.visit_arguments(node.args)
+        self.paren_end()
+        if hasattr(node, 'returns') and node.returns is not None:
+            self.write(self.ARROW)
+            self.visit(node.returns)
+        self.write(':')
+        self.body(node.body)
+
+    def visit_arguments(self, node):
+        sep = Sep(self.COMMA)
+        padding = [None] * (len(node.args) - len(node.defaults))
+        if hasattr(node, 'kwonlyargs'):
+            for arg, default in zip(node.args, padding + node.defaults):
+                self.write(sep())
+                self.visit(arg)
+                if default is not None:
+                    self.write('=')
+                    self.visit(default)
+            if node.vararg is not None:
+                self.write(sep())
+                if hasattr(node, 'varargannotation'):
+                    if node.varargannotation is None:
+                        self.write('*' + node.vararg)
+                    else:
+                        self.maybe_break(node.varargannotation)
+                        self.write('*' + node.vararg)
+                        self.write(self.COLON)
+                        self.visit(node.varargannotation)
+                else:
+                    self.maybe_break(node.vararg)
+                    self.write('*')
+                    self.visit(node.vararg)
+            elif node.kwonlyargs:
+                self.write(sep() + '*')
+
+            for arg, default in zip(node.kwonlyargs, node.kw_defaults):
+                self.write(sep())
+                self.visit(arg)
+                if default is not None:
+                    self.write('=')
+                    self.visit(default)
+            if node.kwarg is not None:
+                self.write(sep())
+                if hasattr(node, 'kwargannotation'):
+                    if node.kwargannotation is None:
+                        self.write('**' + node.kwarg)
+                    else:
+                        self.maybe_break(node.kwargannotation)
+                        self.write('**' + node.kwarg)
+                        self.write(self.COLON)
+                        self.visit(node.kwargannotation)
+                else:
+                    self.maybe_break(node.kwarg)
+                    self.write('**')
+                    self.visit(node.kwarg)
+        else:
+            for arg, default in zip(node.args, padding + node.defaults):
+                self.write(sep())
+                self.visit(arg)
+                if default is not None:
+                    self.write('=')
+                    self.visit(default)
+            if node.vararg is not None:
+                self.write(sep())
+                self.write('*' + node.vararg)
+            if node.kwarg is not None:
+                self.write(sep())
+                self.write('**' + node.kwarg)
+
+    def visit_arg(self, node):
+        # Py3 only
+        self.maybe_break(node)
+        self.write(node.arg)
+        if node.annotation is not None:
+            self.write(self.COLON)
+            self.visit(node.annotation)
+
+    def visit_keyword(self, node):
+        self.maybe_break(node.value)
+        if node.arg is not None:
+            self.write(node.arg + '=')
+        else:
+            self.write('**')
+        self.visit(node.value)
+
+    def visit_ClassDef(self, node):
+        self.newline(extra=2)
+        # first decorator line number will be used
+        self.decorators(node)
+        self.write('class %s' % node.name)
+
+        if (node.bases or (hasattr(node, 'keywords') and node.keywords) or
+                (hasattr(node, 'starargs') and (node.starargs or node.kwargs))):
+            self.paren_start()
+            sep = Sep(self.COMMA)
+
+            for base in node.bases:
+                self.write(sep())
+                self.visit(base)
+            # XXX: the if here is used to keep this module compatible
+            #      with python 2.6.
+            if hasattr(node, 'keywords'):
+                for keyword in node.keywords:
+                    self.write(sep())
+                    self.visit(keyword)
+                if hasattr(node, 'starargs'):
+                    if node.starargs is not None:
+                        self.write(sep())
+                        self.maybe_break(node.starargs)
+                        self.write('*')
+                        self.visit(node.starargs)
+                    if node.kwargs is not None:
+                        self.write(sep())
+                        self.maybe_break(node.kwargs)
+                        self.write('**')
+                        self.visit(node.kwargs)
+            self.paren_end()
+        self.write(':')
+        self.body(node.body)
+
+    def visit_If(self, node):
+        self.newline(node, force=True)
+        self.write('if ')
+        self.visit(node.test)
+        self.write(':')
+        self.body(node.body)
+        while True:
+            if len(node.orelse) == 1 and isinstance(node.orelse[0], If):
+                node = node.orelse[0]
+                self.newline(node.test, force=True)
+                self.write('elif ')
+                self.visit(node.test)
+                self.write(':')
+                self.body(node.body)
+            else:
+                if node.orelse:
+                    self.newline()
+                    self.write('else:')
+                    self.body(node.orelse)
+                break
+
+    def visit_AsyncFor(self, node):
+        self.visit_For(node, True)
+
+    def visit_For(self, node, async=False):
+        self.newline(node, force=True)
+        if async:
+            self.write('async ')
+        self.write('for ')
+        self.visit_bare(node.target)
+        self.write(' in ')
+        self.visit(node.iter)
+        self.write(':')
+        self.body_or_else(node)
+
+    def visit_While(self, node):
+        self.newline(node, force=True)
+        self.write('while ')
+        self.visit(node.test)
+        self.write(':')
+        self.body_or_else(node)
+
+    def visit_AsyncWith(self, node):
+        self.visit_With(node, True)
+
+    def visit_With(self, node, async=False):
+        self.newline(node, force=True)
+        if async:
+            self.write('async ')
+        self.write('with ')
+
+        if hasattr(node, 'items'):
+            sep = Sep(self.COMMA)
+            for item in node.items:
+                self.write(sep())
+                self.visit_withitem(item)
+        else:
+            # in python 2, similarly to the elif statement, multiple nested context managers
+            # are generally the multi-form of a single with statement
+            self.visit_withitem(node)
+            while len(node.body) == 1 and isinstance(node.body[0], With):
+                node = node.body[0]
+                self.write(self.COMMA)
+                self.visit_withitem(node)
+        self.write(':')
+        self.body(node.body)
+
+    def visit_withitem(self, node):
+        self.visit(node.context_expr)
+        if node.optional_vars is not None:
+            self.write(' as ')
+            self.visit(node.optional_vars)
+
+    def visit_Pass(self, node):
+        self.newline(node)
+        self.write('pass')
+
+    def visit_Print(self, node):
+        # XXX: python 2 only
+        self.newline(node)
+        self.write('print ')
+        sep = Sep(self.COMMA)
+        if node.dest is not None:
+            self.write(' >> ')
+            self.visit(node.dest)
+            sep()
+        for value in node.values:
+            self.write(sep())
+            self.visit(value)
+        if not node.nl:
+            self.write(',')
+
+    def visit_Delete(self, node):
+        self.newline(node)
+        self.write('del ')
+        sep = Sep(self.COMMA)
+        for target in node.targets:
+            self.write(sep())
+            self.visit(target)
+
+    def visit_Try(self, node):
+        # Python 3 only. exploits the fact that TryExcept uses the same attribute names
+        self.visit_TryExcept(node)
+        if node.finalbody:
+            self.newline()
+            self.write('finally:')
+            self.body(node.finalbody)
+
+    def visit_TryExcept(self, node):
+        self.newline(node, force=True)
+        self.write('try:')
+        self.body(node.body)
+        for handler in node.handlers:
+            self.visit(handler)
+        if node.orelse:
+            self.newline()
+            self.write('else:')
+            self.body(node.orelse)
+
+    def visit_TryFinally(self, node):
+        # Python 2 only
+        if len(node.body) == 1 and isinstance(node.body[0], TryExcept):
+            self.visit_TryExcept(node.body[0])
+        else:
+            self.newline(node, force=True)
+            self.write('try:')
+            self.body(node.body)
+        self.newline()
+        self.write('finally:')
+        self.body(node.finalbody)
+
+    def visit_ExceptHandler(self, node):
+        self.newline(node, force=True)
+        self.write('except')
+        if node.type:
+            self.write(' ')
+            self.visit(node.type)
+            if node.name:
+                self.write(' as ')
+                # Compatability
+                if isinstance(node.name, AST):
+                    self.visit(node.name)
+                else:
+                    self.write(node.name)
+        self.write(':')
+        self.body(node.body)
+
+    def visit_Global(self, node):
+        self.newline(node)
+        self.write('global ' + self.COMMA.join(node.names))
+
+    def visit_Nonlocal(self, node):
+        self.newline(node)
+        self.write('nonlocal ' + self.COMMA.join(node.names))
+
+    def visit_Return(self, node):
+        self.newline(node)
+        if node.value is not None:
+            self.write('return ')
+            self.visit(node.value)
+        else:
+            self.write('return')
+
+    def visit_Break(self, node):
+        self.newline(node)
+        self.write('break')
+
+    def visit_Continue(self, node):
+        self.newline(node)
+        self.write('continue')
+
+    def visit_Raise(self, node):
+        # XXX: Python 2.6 / 3.0 compatibility
+        self.newline(node)
+        if hasattr(node, 'exc') and node.exc is not None:
+            self.write('raise ')
+            self.visit(node.exc)
+            if node.cause is not None:
+                self.write(' from ')
+                self.visit(node.cause)
+        elif hasattr(node, 'type') and node.type is not None:
+            self.write('raise ')
+            self.visit(node.type)
+            if node.inst is not None:
+                self.write(self.COMMA)
+                self.visit(node.inst)
+            if node.tback is not None:
+                self.write(self.COMMA)
+                self.visit(node.tback)
+        else:
+            self.write('raise')
+
+    # Expressions
+
+    def visit_Attribute(self, node):
+        self.maybe_break(node)
+        # Edge case: due to the use of \d*[.]\d* for floats \d*[.]\w*, you have
+        # to put parenthesis around an integer literal do get an attribute from it
+        if isinstance(node.value, Num):
+            self.paren_start()
+            self.visit(node.value)
+            self.paren_end()
+        else:
+            self.prec_start(17)
+            self.visit(node.value)
+            self.prec_end()
+        self.write('.' + node.attr)
+
+    def visit_Call(self, node):
+        self.maybe_break(node)
+        #need to put parenthesis around numbers being called (this makes no sense)
+        if isinstance(node.func, Num):
+            self.paren_start()
+            self.visit_Num(node.func)
+            self.paren_end()
+        else:
+            self.prec_start(17)
+            self.visit(node.func)
+            self.prec_end()
+        # special case generator expressions as only argument
+        if (len(node.args) == 1 and isinstance(node.args[0], GeneratorExp) and
+                not node.keywords and hasattr(node, 'starargs') and 
+                not node.starargs and not node.kwargs):
+            self.visit_GeneratorExp(node.args[0])
+            return
+
+        self.paren_start()
+        sep = Sep(self.COMMA)
+        for arg in node.args:
+            self.write(sep())
+            self.maybe_break(arg)
+            self.visit(arg)
+        for keyword in node.keywords:
+            self.write(sep())
+            self.visit(keyword)
+        if hasattr(node, 'starargs'):
+            if node.starargs is not None:
+                self.write(sep())
+                self.maybe_break(node.starargs)
+                self.write('*')
+                self.visit(node.starargs)
+            if node.kwargs is not None:
+                self.write(sep())
+                self.maybe_break(node.kwargs)
+                self.write('**')
+                self.visit(node.kwargs)
+        self.paren_end()
+
+    def visit_Name(self, node):
+        self.maybe_break(node)
+        self.write(node.id)
+
+    def visit_NameConstant(self, node):
+        self.maybe_break(node)
+        self.write(repr(node.value))
+
+    def visit_Str(self, node, frombytes=False):
+        self.maybe_break(node)
+        if frombytes:
+            newline_count = node.s.count('\n'.encode('utf-8'))
+        else:
+            newline_count = node.s.count('\n')
+
+        # heuristic, expand when more than 1 newline and when at least 80%
+        # of the characters aren't newlines
+        expand = newline_count > 1 and len(node.s) > 5 * newline_count
+        if self.correct_line_numbers:
+            # Also check if we have enougn newlines to expand in if we're going for correct line numbers
+            if self.after_colon:
+                # Although this makes little sense just after a colon
+                expand = expand and self.new_lines > newline_count
+            else:
+                expand = expand and self.new_lines >= newline_count
+
+        if expand and (not self.correct_line_numbers or self.new_lines >= newline_count):
+            if self.correct_line_numbers:
+                self.new_lines -= newline_count
+
+            a = repr(node.s)
+            delimiter = a[-1]
+            header, content = a[:-1].split(delimiter, 1)
+            lines = []
+            chain = False
+            for i in content.split('\\n'):
+                if chain:
+                    i = lines.pop() + i
+                    chain = False
+                if (len(i) - len(i.rstrip('\\'))) % 2:
+                    i += '\\n'
+                    chain = True
+                lines.append(i)
+            assert newline_count + 1 == len(lines)
+            self.write(header)
+            self.write(delimiter * 3)
+            self.write('\n'.join(lines))
+            self.write(delimiter * 3)
+        else:
+            self.write(repr(node.s))
+
+    def visit_Bytes(self, node):
+        self.visit_Str(node, True)
+
+    def visit_Num(self, node):
+        self.maybe_break(node)
+
+        negative = (node.n.imag or node.n.real) < 0 and not PY3
+        if negative:
+            self.prec_start(self.UNARYOP_SYMBOLS[USub][1])
+
+        # 1e999 and related friends are parsed into inf
+        if abs(node.n) == 1e999:
+            if negative:
+                self.write('-')
+            self.write('1e999')
+            if node.n.imag:
+                self.write('j')
+        else:
+            self.write(repr(node.n))
+
+        if negative:
+            self.prec_end()
+
+    def visit_Tuple(self, node, guard=True):
+        if guard or not node.elts:
+            self.paren_start()
+        sep = Sep(self.COMMA)
+        for item in node.elts:
+            self.write(sep())
+            self.visit(item)
+        if len(node.elts) == 1:
+            self.write(',')
+        if guard or not node.elts:
+            self.paren_end()
+
+    def _sequence_visit(left, right): # pylint: disable=E0213
+        def visit(self, node):
+            self.maybe_break(node)
+            self.paren_start(left)
+            sep = Sep(self.COMMA)
+            for item in node.elts:
+                self.write(sep())
+                self.visit(item)
+            self.paren_end(right)
+        return visit
+
+    visit_List = _sequence_visit('[', ']')
+    visit_Set = _sequence_visit('{', '}')
+
+    def visit_Dict(self, node):
+        self.maybe_break(node)
+        self.paren_start('{')
+        sep = Sep(self.COMMA)
+        for key, value in zip(node.keys, node.values):
+            self.write(sep())
+            self.visit(key)
+            self.write(self.COLON)
+            self.visit(value)
+        self.paren_end('}')
+
+    def visit_BinOp(self, node):
+        self.maybe_break(node)
+        symbol, precedence = self.BINOP_SYMBOLS[type(node.op)]
+        self.prec_start(precedence, type(node.op) != Pow)
+
+        # work around python's negative integer literal optimization
+        if isinstance(node.op, Pow):
+            self.visit(node.left)
+            self.prec_middle(14)
+        else:
+            self.visit(node.left)
+            self.prec_middle()
+        self.write(symbol)
+        self.visit(node.right)
+        self.prec_end()
+
+    def visit_BoolOp(self, node):
+        self.maybe_break(node)
+        symbol, precedence = self.BOOLOP_SYMBOLS[type(node.op)]
+        self.prec_start(precedence, True)
+        self.prec_middle()
+        sep = Sep(symbol)
+        for value in node.values:
+            self.write(sep())
+            self.visit(value)
+        self.prec_end()
+
+    def visit_Compare(self, node):
+        self.maybe_break(node)
+        self.prec_start(7, True)
+        self.prec_middle()
+        self.visit(node.left)
+        for op, right in zip(node.ops, node.comparators):
+            self.write(self.CMPOP_SYMBOLS[type(op)][0])
+            self.visit(right)
+        self.prec_end()
+
+    def visit_UnaryOp(self, node):
+        self.maybe_break(node)
+        symbol, precedence = self.UNARYOP_SYMBOLS[type(node.op)]
+        self.prec_start(precedence)
+        self.write(symbol)
+        # workaround: in python 2, an explicit USub node around a number literal
+        # indicates the literal was surrounded by parenthesis
+        if (not PY3 and isinstance(node.op, USub) and isinstance(node.operand, Num) 
+                and (node.operand.n.real or node.operand.n.imag) >= 0):
+            self.paren_start()
+            self.visit(node.operand)
+            self.paren_end()
+        else:
+            self.visit(node.operand)
+        self.prec_end()
+
+    def visit_Subscript(self, node):
+        self.maybe_break(node)
+        # have to surround literals by parenthesis (at least in Py2)
+        if isinstance(node.value, Num):
+            self.paren_start()
+            self.visit_Num(node.value)
+            self.paren_end()
+        else:
+            self.prec_start(17)
+            self.visit(node.value)
+            self.prec_end()
+        self.paren_start('[')
+        self.visit(node.slice)
+        self.paren_end(']')
+
+    def visit_Index(self, node, guard=False):
+        # Index has no lineno information
+        # When a subscript includes a tuple directly, the parenthesis can be dropped
+        if not guard:
+            self.visit_bare(node.value)
+        else:
+            self.visit(node.value)
+
+    def visit_Slice(self, node):
+        # Slice has no lineno information
+        if node.lower is not None:
+            self.visit(node.lower)
+        self.write(':')
+        if node.upper is not None:
+            self.visit(node.upper)
+        if node.step is not None:
+            self.write(':')
+            if not (isinstance(node.step, Name) and node.step.id == 'None'):
+                self.visit(node.step)
+
+    def visit_Ellipsis(self, node):
+        # Ellipsis has no lineno information
+        self.write('...')
+
+    def visit_ExtSlice(self, node):
+        # Extslice has no lineno information
+        for idx, item in enumerate(node.dims):
+            if idx:
+                self.write(self.COMMA)
+            if isinstance(item, Index):
+                self.visit_Index(item, True)
+            else:
+                self.visit(item)
+
+    def visit_Yield(self, node, paren=True):
+        # yield can only be used in a statement context, or we're between parenthesis
+        self.maybe_break(node)
+        if paren:
+            self.paren_start()
+        if node.value is not None:
+            self.write('yield ')
+            self.visit_bare(node.value)
+        else:
+            self.write('yield')
+        if paren:
+            self.paren_end()
+
+    def visit_YieldFrom(self, node, paren=True):
+        # Even though yield and yield from technically occupy precedence level 1, certain code
+        # using them is illegal e.g. "return yield from a()" will not work unless you 
+        # put the yield from statement within parenthesis. 
+        self.maybe_break(node)
+        if paren:
+            self.paren_start()
+        self.write('yield from ')
+        self.visit(node.value)
+        if paren:
+            self.paren_end()
+
+    def visit_Lambda(self, node):
+        self.maybe_break(node)
+        self.prec_start(2)
+        self.write('lambda ')
+        self.visit_arguments(node.args)
+        self.write(self.COLON)
+        self.visit(node.body)
+        self.prec_end()
+
+    def _generator_visit(left, right):
+        def visit(self, node):
+            self.maybe_break(node)
+            self.paren_start(left)
+            self.visit(node.elt)
+            for comprehension in node.generators:
+                self.visit(comprehension)
+            self.paren_end(right)
+        return visit
+
+    visit_ListComp = _generator_visit('[', ']')
+    visit_GeneratorExp = _generator_visit('(', ')')
+    visit_SetComp = _generator_visit('{', '}')
+
+    def visit_DictComp(self, node):
+        self.maybe_break(node)
+        self.paren_start('{')
+        self.visit(node.key)
+        self.write(self.COLON)
+        self.visit(node.value)
+        for comprehension in node.generators:
+            self.visit(comprehension)
+        self.paren_end('}')
+
+    def visit_IfExp(self, node):
+        self.maybe_break(node)
+        self.prec_start(3, False)
+        self.visit(node.body)
+        self.write(' if ')
+        self.visit(node.test)
+        self.prec_middle(2)
+        self.write(' else ')
+        self.visit(node.orelse)
+        self.prec_end()
+
+    def visit_Starred(self, node):
+        self.maybe_break(node)
+        self.write('*')
+        self.visit(node.value)
+
+    def visit_Repr(self, node):
+        # XXX: python 2.6 only
+        self.maybe_break(node)
+        self.write('`')
+        self.visit(node.value)
+        self.write('`')
+
+    # Helper Nodes
+
+    def visit_alias(self, node):
+        # alias does not have line number information
+        self.write(node.name)
+        if node.asname is not None:
+            self.write(' as ' + node.asname)
+
+    def visit_comprehension(self, node):
+        self.maybe_break(node.target)
+        self.write(' for ')
+        self.visit_bare(node.target)
+        self.write(' in ')
+        # workaround: lambda and ternary need to be within parenthesis here
+        self.prec_start(4)
+        self.visit(node.iter)
+        self.prec_end()
+
+        for if_ in node.ifs:
+            self.write(' if ')
+            self.visit(if_)

renpy/rpycdec/rpycdecdata/decompiler/magic.py

@@ -0,0 +1,674 @@
+# Copyright (c) 2015 CensoredUsername
+
+# This module provides tools for safely analyizing pickle files programmatically
+
+import sys
+
+PY3 = sys.version_info >= (3, 0)
+PY2 = not PY3
+
+import types
+import pickle
+import struct
+
+if PY3:
+    from io import BytesIO as StringIO
+else:
+    from cStringIO import StringIO
+
+__all__ = [
+    "load", "loads", "safe_load", "safe_loads", "safe_dump", "safe_dumps",
+    "fake_package", "remove_fake_package",
+    "FakeModule", "FakePackage", "FakePackageLoader",
+    "FakeClassType", "FakeClassFactory",
+    "FakeClass", "FakeStrict", "FakeWarning", "FakeIgnore",
+    "FakeUnpicklingError", "FakeUnpickler", "SafeUnpickler",
+    "SafePickler"
+]
+
+# Fake class implementation
+
+class FakeClassType(type):
+    """
+    The metaclass used to create fake classes. To support comparisons between
+    fake classes and :class:`FakeModule` instances custom behaviour is defined
+    here which follows this logic:
+
+    If the other object does not have ``other.__name__`` set, they are not equal.
+
+    Else if it does not have ``other.__module__`` set, they are equal if
+    ``self.__module__ + "." + self.__name__ == other.__name__``.
+
+    Else, they are equal if
+    ``self.__module__ == other.__module__ and self.__name__ == other.__name__``
+
+    Using this behaviour, ``==``, ``!=``, ``hash()``, ``isinstance()`` and ``issubclass()``
+    are implemented allowing comparison between :class:`FakeClassType` instances
+    and :class:`FakeModule` instances to succeed if they are pretending to be in the same
+    place in the python module hierarchy.
+
+    To create a fake class using this metaclass, you can either use this metaclass directly or
+    inherit from the fake class base instances given below. When doing this, the module that
+    this fake class is pretending to be in should be specified using the *module* argument
+    when the metaclass is called directly or a :attr:``__module__`` class attribute in a class statement.
+
+    This is a subclass of :class:`type`.
+    """
+
+    # instance creation logic
+
+    def __new__(cls, name, bases, attributes, module=None):
+        # This would be a lie
+        attributes.pop("__qualname__", None)
+
+        # figure out what module we should say we're in
+        # note that if no module is explicitly passed, the current module will be chosen
+        # due to the class statement implicitly specifying __module__ as __name__
+        if module is not None:
+            attributes["__module__"] = module
+
+        if "__module__" not in attributes:
+            raise TypeError("No module has been specified for FakeClassType {0}".format(name))
+
+        # assemble instance
+        return type.__new__(cls, name, bases, attributes)
+
+    def __init__(self, name, bases, attributes, module=None):
+        type.__init__(self, name, bases, attributes)
+
+    # comparison logic
+
+    def __eq__(self, other):
+        if not hasattr(other, "__name__"):
+            return False
+        if hasattr(other, "__module__"):
+            return self.__module__ == other.__module__ and self.__name__ == other.__name__
+        else:
+            return self.__module__ + "." + self.__name__ == other.__name__
+
+    def __ne__(self, other):
+        return not self == other
+
+    def __hash__(self):
+        return hash(self.__module__ + "." + self.__name__)
+
+    def __instancecheck__(self, instance):
+        return self.__subclasscheck__(instance.__class__)
+
+    def __subclasscheck__(self, subclass):
+        return (self == subclass or
+                (bool(subclass.__bases__) and
+                 any(self.__subclasscheck__(base) for base in subclass.__bases__)))
+
+# PY2 doesn't like the PY3 way of metaclasses and PY3 doesn't support the PY2 way
+# so we call the metaclass directly
+FakeClass = FakeClassType("FakeClass", (), {"__doc__": """
+A barebones instance of :class:`FakeClassType`. Inherit from this to create fake classes.
+"""}, module=__name__)
+
+class FakeStrict(FakeClass, object):
+    def __new__(cls, *args, **kwargs):
+        self = FakeClass.__new__(cls)
+        if args or kwargs:
+            raise FakeUnpicklingError("{0} was instantiated with unexpected arguments {1}, {2}".format(cls, args, kwargs))
+        return self
+
+    def __setstate__(self, state):
+        slotstate = None
+
+        if (isinstance(state, tuple) and len(state) == 2 and
+            (state[0] is None or isinstance(state[0], dict)) and
+            (state[1] is None or isinstance(state[1], dict))):
+            state, slotstate = state
+
+        if state:
+            # Don't have to check for slotstate here since it's either None or a dict
+            if not isinstance(state, dict):
+                raise FakeUnpicklingError("{0}.__setstate__() got unexpected arguments {1}".format(self.__class__, state))
+            else:
+                self.__dict__.update(state)
+
+        if slotstate:
+            self.__dict__.update(slotstate)
+
+class FakeWarning(FakeClass, object):
+    def __new__(cls, *args, **kwargs):
+        self = FakeClass.__new__(cls)
+        if args or kwargs:
+            print("{0} was instantiated with unexpected arguments {1}, {2}".format(cls, args, kwargs))
+            self._new_args = args
+        return self
+
+    def __setstate__(self, state):
+        slotstate = None
+
+        if (isinstance(state, tuple) and len(state) == 2 and
+            (state[0] is None or isinstance(state[0], dict)) and
+            (state[1] is None or isinstance(state[1], dict))):
+            state, slotstate = state
+
+        if state:
+            # Don't have to check for slotstate here since it's either None or a dict
+            if not isinstance(state, dict):
+                print("{0}.__setstate__() got unexpected arguments {1}".format(self.__class__, state))
+                self._setstate_args = state
+            else:
+                self.__dict__.update(state)
+
+        if slotstate:
+            self.__dict__.update(slotstate)
+
+class FakeIgnore(FakeClass, object):
+    def __new__(cls, *args, **kwargs):
+        self = FakeClass.__new__(cls)
+        if args:
+            self._new_args = args
+        if kwargs:
+            self._new_kwargs = kwargs
+        return self
+
+    def __setstate__(self, state):
+        slotstate = None
+
+        if (isinstance(state, tuple) and len(state) == 2 and
+            (state[0] is None or isinstance(state[0], dict)) and
+            (state[1] is None or isinstance(state[1], dict))):
+            state, slotstate = state
+
+        if state:
+            # Don't have to check for slotstate here since it's either None or a dict
+            if not isinstance(state, dict):
+                self._setstate_args = state
+            else:
+                self.__dict__.update(state)
+
+        if slotstate:
+            self.__dict__.update(slotstate)
+
+class FakeClassFactory(object):
+    """
+    Factory of fake classses. It will create fake class definitions on demand
+    based on the passed arguments.
+    """
+
+    def __init__(self, special_cases=(), default_class=FakeStrict):
+        """
+        *special_cases* should be an iterable containing fake classes which should be treated
+        as special cases during the fake unpickling process. This way you can specify custom methods
+        and attributes on these classes as they're used during unpickling.
+
+        *default_class* should be a FakeClassType instance which will be subclassed to create the
+        necessary non-special case fake classes during unpickling. This should usually be set to
+        :class:`FakeStrict`, :class:`FakeWarning` or :class:`FakeIgnore`. These classes have
+        :meth:`__new__` and :meth:`__setstate__` methods which extract data from the pickle stream
+        and provide means of inspecting the stream when it is not clear how the data should be interpreted.
+
+        As an example, we can define the fake class generated for definition bar in module foo,
+        which has a :meth:`__str__` method which returns ``"baz"``::
+
+           class bar(FakeStrict, object):
+               def __str__(self):
+                   return "baz"
+
+           special_cases = [bar]
+
+        Alternatively they can also be instantiated using :class:`FakeClassType` directly::
+           special_cases = [FakeClassType(c.__name__, c.__bases__, c.__dict__, c.__module__)]
+        """
+        self.special_cases = dict(((i.__module__, i.__name__), i) for i in special_cases)
+        self.default = default_class
+
+        self.class_cache = {}
+
+    def __call__(self, name, module):
+        """
+        Return the right class for the specified *module* and *name*.
+
+        This class will either be one of the special cases in case the name and module match,
+        or a subclass of *default_class* will be created with the correct name and module.
+
+        Created class definitions are cached per factory instance.
+        """
+        # Check if we've got this class cached
+        klass = self.class_cache.get((module, name), None)
+        if klass is not None:
+            return klass
+
+        klass = self.special_cases.get((module, name), None)
+
+        if not klass:
+            # generate a new class def which inherits from the default fake class
+            klass = type(name, (self.default,), {"__module__": module})
+
+        self.class_cache[(module, name)] = klass
+        return klass
+
+# Fake module implementation
+
+class FakeModule(types.ModuleType):
+    """
+    An object which pretends to be a module.
+
+    *name* is the name of the module and should be a ``"."`` separated
+    alphanumeric string.
+
+    On initialization the module is added to sys.modules so it can be
+    imported properly. Further if *name* is a submodule and if its parent
+    does not exist, it will automatically create a parent :class:`FakeModule`.
+    This operates recursively until the parent is a top-level module or
+    when the parent is an existing module.
+
+    If any fake submodules are removed from this module they will
+    automatically be removed from :data:`sys.modules`.
+
+    Just as :class:`FakeClassType`, it supports comparison with
+    :class:`FakeClassType` instances, using the following logic:
+
+    If the object does not have ``other.__name__`` set, they are not equal.
+
+    Else if the other object does not have ``other.__module__`` set, they are equal if:
+    ``self.__name__ == other.__name__``
+
+    Else, they are equal if:
+    ``self.__name__ == other.__module__ + "." + other.__name__``
+
+    Using this behaviour, ``==``, ``!=``, ``hash()``, ``isinstance()`` and ``issubclass()``
+    are implemented allowing comparison between :class:`FakeClassType` instances
+    and :class:`FakeModule` instances to succeed if they are pretending to bein the same
+    place in the python module hierarchy.
+
+    It inherits from :class:`types.ModuleType`.
+    """
+    def __init__(self, name):
+        super(FakeModule, self).__init__(name)
+        sys.modules[name] = self
+
+        if "." in name:
+            parent_name, child_name = name.rsplit(".", 1)
+
+            try:
+                __import__(parent_name)
+                parent = sys.modules[parent_name]
+            except:
+                parent = FakeModule(parent_name)
+            setattr(parent, child_name, self)
+
+    def __repr__(self):
+        return "<module '{0}' (fake)>".format(self.__name__)
+
+    def __str__(self):
+        return self.__repr__()
+
+    def __setattr__(self, name, value):
+        # If a fakemodule is removed we need to remove its entry from sys.modules
+        if (name in self.__dict__ and
+            isinstance(self.__dict__[name], FakeModule) and not
+            isinstance(value, FakeModule)):
+
+            self.__dict__[name]._remove()
+        self.__dict__[name] = value
+
+    def __delattr__(self, name):
+        if isinstance(self.__dict__[name], FakeModule):
+            self.__dict__[name]._remove()
+        del self.__dict__[name]
+
+    def _remove(self):
+        """
+        Removes this module from :data:`sys.modules` and calls :meth:`_remove` on any
+        sub-FakeModules.
+        """
+        for i in tuple(self.__dict__.keys()):
+            if isinstance(self.__dict__[i], FakeModule):
+                self.__dict__[i]._remove()
+                del self.__dict__[i]
+        del sys.modules[self.__name__]
+
+    def __eq__(self, other):
+        if not hasattr(other, "__name__"):
+            return False
+        othername = other.__name__
+        if hasattr(other, "__module__"):
+            othername = other.__module__ + "." + other.__name__
+
+        return self.__name__ == othername
+
+    def __ne__(self, other):
+        return not self == other
+
+    def __hash__(self):
+        return hash(self.__name__)
+
+    def __instancecheck__(self, instance):
+        return self.__subclasscheck__(instance.__class__)
+
+    def __subclasscheck__(self, subclass):
+        return (self == subclass or
+                (bool(subclass.__bases__) and
+                 any(self.__subclasscheck__(base) for base in subclass.__bases__)))
+
+class FakePackage(FakeModule):
+    """
+    A :class:`FakeModule` subclass which lazily creates :class:`FakePackage`
+    instances on its attributes when they're requested.
+
+    This ensures that any attribute of this module is a valid FakeModule
+    which can be used to compare against fake classes.
+    """
+    __path__ = []
+
+    def __call__(self, *args, **kwargs):
+        # This mainly exists to print a nicer error message when
+        # someone tries to call a FakePackage instance
+        raise TypeError("'{0}' FakePackage object is not callable".format(self.__name__))
+
+    def __getattr__(self, name):
+        modname = self.__name__ + "." + name
+        mod = sys.modules.get(modname, None)
+        if mod is None:
+            try:
+                __import__(modname)
+            except:
+                mod = FakePackage(modname)
+            else:
+                mod = sys.modules[modname]
+        return mod
+
+class FakePackageLoader(object):
+    """
+    A :term:`loader` of :class:`FakePackage` modules. When added to
+    :data:`sys.meta_path` it will ensure that any attempt to import
+    module *root* or its submodules results in a FakePackage.
+
+    Together with the attribute creation from :class:`FakePackage`
+    this ensures that any attempt to get a submodule from module *root*
+    results in a FakePackage, creating the illusion that *root* is an
+    actual package tree.
+    """
+    def __init__(self, root):
+        self.root = root
+
+    def find_module(self, fullname, path=None):
+        if fullname == self.root or fullname.startswith(self.root + "."):
+            return self
+        else:
+            return None
+
+    def load_module(self, fullname):
+        return FakePackage(fullname)
+
+# Fake unpickler implementation
+
+class FakeUnpicklingError(pickle.UnpicklingError):
+    """
+    Error raised when there is not enough information to perform the fake
+    unpickling process completely. It inherits from :exc:`pickle.UnpicklingError`.
+    """
+    pass
+
+class FakeUnpickler(pickle.Unpickler if PY2 else pickle._Unpickler):
+    """
+    A forgiving unpickler. On uncountering references to class definitions
+    in the pickle stream which it cannot locate, it will create fake classes
+    and if necessary fake modules to house them in. Since it still allows access
+    to all modules and builtins, it should only be used to unpickle trusted data.
+
+    *file* is the :term:`binary file` to unserialize.
+
+    The optional keyword arguments are *class_factory*, *encoding and *errors*.
+    *class_factory* can be used to control how the missing class definitions are
+    created. If set to ``None``, ``FakeClassFactory((), FakeStrict)`` will be used.
+
+    In Python 3, the optional keyword arguments *encoding* and *errors* can be used
+    to indicate how the unpickler should deal with pickle streams generated in python
+    2, specifically how to deal with 8-bit string instances. If set to "bytes" it will
+    load them as bytes objects, otherwise it will attempt to decode them into unicode
+    using the given *encoding* and *errors* arguments.
+
+    It inherits from :class:`pickle.Unpickler`. (In Python 3 this is actually
+    ``pickle._Unpickler``)
+    """
+    if PY2:
+        def __init__(self, file, class_factory=None, encoding="bytes", errors="strict"):
+            pickle.Unpickler.__init__(self, file,)
+            self.class_factory = class_factory or FakeClassFactory()
+    else:
+        def __init__(self, file, class_factory=None, encoding="bytes", errors="strict"):
+            super().__init__(file, fix_imports=False, encoding=encoding, errors=errors)
+            self.class_factory = class_factory or FakeClassFactory()
+
+    def find_class(self, module, name):
+        mod = sys.modules.get(module, None)
+        if mod is None:
+            try:
+                __import__(module)
+            except:
+                mod = FakeModule(module)
+            else:
+                mod = sys.modules[module]
+
+        klass = getattr(mod, name, None)
+        if klass is None or isinstance(klass, FakeModule):
+            klass = self.class_factory(name, module)
+            setattr(mod, name, klass)
+
+        return klass
+
+class SafeUnpickler(FakeUnpickler):
+    """
+    A safe unpickler. It will create fake classes for any references to class
+    definitions in the pickle stream. Further it can block access to the extension
+    registry making this unpickler safe to use on untrusted data.
+
+    *file* is the :term:`binary file` to unserialize.
+
+    The optional keyword arguments are *class_factory*, *safe_modules*, *use_copyreg*,
+    *encoding* and *errors*. *class_factory* can be used to control how the missing class
+    definitions are created. If set to ``None``, ``FakeClassFactory((), FakeStrict)`` will be
+    used. *safe_modules* can be set to a set of strings of module names, which will be
+    regarded as safe by the unpickling process, meaning that it will import objects
+    from that module instead of generating fake classes (this does not apply to objects
+    in submodules). *use_copyreg* is a boolean value indicating if it's allowed to
+    use extensions from the pickle extension registry (documented in the :mod:`copyreg`
+    module).
+
+    In Python 3, the optional keyword arguments *encoding* and *errors* can be used
+    to indicate how the unpickler should deal with pickle streams generated in python
+    2, specifically how to deal with 8-bit string instances. If set to "bytes" it will
+    load them as bytes objects, otherwise it will attempt to decode them into unicode
+    using the given *encoding* and *errors* arguments.
+
+    This function can be used to unpickle untrusted data safely with the default
+    class_factory when *safe_modules* is empty and *use_copyreg* is False.
+    It inherits from :class:`pickle.Unpickler`. (In Python 3 this is actually
+    ``pickle._Unpickler``)
+
+    It should be noted though that when the unpickler tries to get a nonexistent
+    attribute of a safe module, an :exc:`AttributeError` will be raised.
+
+    This inherits from :class:`FakeUnpickler`
+    """
+    def __init__(self, file, class_factory=None, safe_modules=(),
+                 use_copyreg=False, encoding="bytes", errors="strict"):
+        FakeUnpickler.__init__(self, file, class_factory, encoding=encoding, errors=errors)
+        # A set of modules which are safe to load
+        self.safe_modules = set(safe_modules)
+        self.use_copyreg = use_copyreg
+
+    def find_class(self, module, name):
+        if module in self.safe_modules:
+            __import__(module)
+            mod = sys.modules[module]
+            klass = getattr(mod, name)
+            return klass
+
+        else:
+            return self.class_factory(name, module)
+
+    def get_extension(self, code):
+        if self.use_copyreg:
+            return FakeUnpickler.get_extension(self, code)
+        else:
+            return self.class_factory("extension_code_{0}".format(code), "copyreg")
+
+class SafePickler(pickle.Pickler if PY2 else pickle._Pickler):
+    """
+    A pickler which can repickle object hierarchies containing objects created by SafeUnpickler.
+    Due to reasons unknown, pythons pickle implementation will normally check if a given class
+    actually matches with the object specified at the __module__ and __name__ of the class. Since
+    this check is performed with object identity instead of object equality we cannot fake this from
+    the classes themselves, and we need to override the method used for normally saving classes.
+    """
+
+    def save_global(self, obj, name=None, pack=struct.pack):
+        if isinstance(obj, FakeClassType):
+            self.write(pickle.GLOBAL + obj.__module__ + '\n' + obj.__name__ + '\n')
+            self.memoize(obj)
+            return
+
+        pickle.Pickler.save_global(self, obj, name, pack)
+
+# the main API
+
+def load(file, class_factory=None, encoding="bytes", errors="errors"):
+    """
+    Read a pickled object representation from the open binary :term:`file object` *file*
+    and return the reconstitutded object hierarchy specified therein, generating
+    any missing class definitions at runtime. This is equivalent to
+    ``FakeUnpickler(file).load()``.
+
+    The optional keyword arguments are *class_factory*, *encoding* and *errors*.
+    *class_factory* can be used to control how the missing class definitions are
+    created. If set to ``None``, ``FakeClassFactory({}, 'strict')`` will be used.
+
+    In Python 3, the optional keyword arguments *encoding* and *errors* can be used
+    to indicate how the unpickler should deal with pickle streams generated in python
+    2, specifically how to deal with 8-bit string instances. If set to "bytes" it will
+    load them as bytes objects, otherwise it will attempt to decode them into unicode
+    using the given *encoding* and *errors* arguments.
+
+    This function should only be used to unpickle trusted data.
+    """
+    return FakeUnpickler(file, class_factory, encoding=encoding, errors=errors).load()
+
+def loads(string, class_factory=None, encoding="bytes", errors="errors"):
+    """
+    Simjilar to :func:`load`, but takes an 8-bit string (bytes in Python 3, str in Python 2)
+    as its first argument instead of a binary :term:`file object`.
+    """
+    return FakeUnpickler(StringIO(string), class_factory,
+                         encoding=encoding, errors=errors).load()
+
+def safe_load(file, class_factory=None, safe_modules=(), use_copyreg=False,
+              encoding="bytes", errors="errors"):
+    """
+    Read a pickled object representation from the open binary :term:`file object` *file*
+    and return the reconstitutded object hierarchy specified therein, substituting any
+    class definitions by fake classes, ensuring safety in the unpickling process.
+    This is equivalent to ``SafeUnpickler(file).load()``.
+
+    The optional keyword arguments are *class_factory*, *safe_modules*, *use_copyreg*,
+    *encoding* and *errors*. *class_factory* can be used to control how the missing class
+    definitions are created. If set to ``None``, ``FakeClassFactory({}, 'strict')`` will be
+    used. *safe_modules* can be set to a set of strings of module names, which will be
+    regarded as safe by the unpickling process, meaning that it will import objects
+    from that module instead of generating fake classes (this does not apply to objects
+    in submodules). *use_copyreg* is a boolean value indicating if it's allowed to
+    use extensions from the pickle extension registry (documented in the :mod:`copyreg`
+    module).
+
+    In Python 3, the optional keyword arguments *encoding* and *errors* can be used
+    to indicate how the unpickler should deal with pickle streams generated in python
+    2, specifically how to deal with 8-bit string instances. If set to "bytes" it will
+    load them as bytes objects, otherwise it will attempt to decode them into unicode
+    using the given *encoding* and *errors* arguments.
+
+    This function can be used to unpickle untrusted data safely with the default
+    class_factory when *safe_modules* is empty and *use_copyreg* is False.
+    """
+    return SafeUnpickler(file, class_factory, safe_modules, use_copyreg,
+                         encoding=encoding, errors=errors).load()
+
+def safe_loads(string, class_factory=None, safe_modules=(), use_copyreg=False,
+               encoding="bytes", errors="errors"):
+    """
+    Similar to :func:`safe_load`, but takes an 8-bit string (bytes in Python 3, str in Python 2)
+    as its first argument instead of a binary :term:`file object`.
+    """
+    return SafeUnpickler(StringIO(string), class_factory, safe_modules, use_copyreg,
+                         encoding=encoding, errors=errors).load()
+
+def safe_dump(obj, file, protocol=pickle.HIGHEST_PROTOCOL):
+    """
+    A convenience function wrapping SafePickler. It functions similarly to pickle.dump
+    """
+    SafePickler(file, protocol).dump(obj)
+
+def safe_dumps(obj, protocol=pickle.HIGHEST_PROTOCOL):
+    """
+    A convenience function wrapping SafePickler. It functions similarly to pickle.dumps
+    """
+    file = StringIO()
+    SafePickler(file, protocol).dump(obj)
+    return file.getvalue()
+
+def fake_package(name):
+    """
+    Mounts a fake package tree with the name *name*. This causes any attempt to import
+    module *name*, attributes of the module or submodules will return a :class:`FakePackage`
+    instance which implements the same behaviour. These :class:`FakePackage` instances compare
+    properly with :class:`FakeClassType` instances allowing you to code using FakePackages as
+    if the modules and their attributes actually existed.
+
+    This is implemented by creating a :class:`FakePackageLoader` instance with root *name*
+    and inserting it in the first spot in :data:`sys.meta_path`. This ensures that importing the
+    module and submodules will work properly. Further the :class:`FakePackage` instances take
+    care of generating submodules as attributes on request.
+
+    If a fake package tree with the same *name* is already registered, no new fake package
+    tree will be mounted.
+
+    This returns the :class:`FakePackage` instance *name*.
+    """
+    if name in sys.modules and isinstance(sys.modules[name], FakePackage):
+        return sys.modules[name]
+    else:
+        loader = FakePackageLoader(name)
+        sys.meta_path.insert(0, loader)
+        return __import__(name)
+
+def remove_fake_package(name):
+    """
+    Removes the fake package tree mounted at *name*.
+
+    This works by first looking for any FakePackageLoaders in :data:`sys.path`
+    with their root set to *name* and removing them from sys.path. Next it will
+    find the top-level :class:`FakePackage` instance *name* and from this point
+    traverse the tree of created submodules, removing them from :data:`sys.path`
+    and removing their attributes. After this the modules are not registered
+    anymore and if they are not referenced from user code anymore they will be
+    garbage collected.
+
+    If no fake package tree *name* exists a :exc:`ValueError` will be raised.
+    """
+
+    # Get the package entry via its entry in sys.modules
+    package = sys.modules.get(name, None)
+    if package is None:
+        raise ValueError("No fake package with the name {0} found".format(name))
+
+    if not isinstance(package, FakePackage):
+        raise ValueError("The module {0} is not a fake package".format(name))
+
+    # Attempt to remove the loader from sys.meta_path
+
+    loaders = [i for i in sys.meta_path if isinstance(i, FakePackageLoader) and i.root == name]
+    for loader in loaders:
+        sys.meta_path.remove(loader)
+
+    # Remove all module and submodule entries from sys.modules
+    package._remove()
+
+    # It is impossible to kill references to the modules, but all traces
+    # of it have been removed from the import machinery and the submodule
+    # tree structure has been broken up.

renpy/rpycdec/rpycdecdata/decompiler/screendecompiler.py

@@ -0,0 +1,678 @@
+# Copyright (c) 2014 CensoredUsername
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+from __future__ import unicode_literals
+
+import re
+import ast
+from operator import itemgetter
+from contextlib import contextmanager
+
+from util import DecompilerBase, WordConcatenator, reconstruct_paraminfo, \
+                 simple_expression_guard, split_logical_lines, Dispatcher
+import codegen
+
+# Main API
+
+def pprint(out_file, ast, indent_level=0, linenumber=1,
+           decompile_python=False,
+           skip_indent_until_write=False, printlock=None):
+    return SLDecompiler(out_file, printlock=printlock,
+                 decompile_python=decompile_python).dump(
+                     ast, indent_level, linenumber, skip_indent_until_write)
+
+# implementation
+
+class SLDecompiler(DecompilerBase):
+    """
+    an object which handles the decompilation of renpy screen language 1 screens to a given stream
+    """
+
+    # This dictionary is a mapping of string: unbound_method, which is used to determine
+    # what method to call for which statement
+    dispatch = Dispatcher()
+
+    def __init__(self, out_file=None, decompile_python=False,
+                 indentation="    ", printlock=None):
+        super(SLDecompiler, self).__init__(out_file, indentation, printlock)
+        self.decompile_python = decompile_python
+        self.should_advance_to_line = True
+        self.is_root = True
+
+    def dump(self, ast, indent_level=0, linenumber=1, skip_indent_until_write=False):
+        self.indent_level = indent_level
+        self.linenumber = linenumber
+        self.skip_indent_until_write = skip_indent_until_write
+        self.print_screen(ast)
+        return self.linenumber
+
+    def advance_to_line(self, linenumber):
+        if self.should_advance_to_line:
+            super(SLDecompiler, self).advance_to_line(linenumber)
+
+    def save_state(self):
+        return (super(SLDecompiler, self).save_state(),
+                self.should_advance_to_line, self.is_root)
+
+    def commit_state(self, state):
+        super(SLDecompiler, self).commit_state(state[0])
+
+    def rollback_state(self, state):
+        self.should_advance_to_line = state[1]
+        self.is_root = state[2]
+        super(SLDecompiler, self).rollback_state(state[0])
+
+    def to_source(self, node):
+        return codegen.to_source(node, self.indentation, False, True)
+
+    @contextmanager
+    def not_root(self):
+        # Whenever anything except screen itself prints any child nodes, it
+        # should be inside a "with self.not_root()" block. It doesn't matter if
+        # you catch more inside of the with block than you need, as long as you
+        # don't fall back to calling print_python() from inside it.
+        is_root = self.is_root
+        self.is_root = False
+        try:
+            yield
+        finally:
+            self.is_root = is_root
+
+    # Entry point functions
+
+    def print_screen(self, ast):
+        # Here we do the processing of the screen statement, and we
+        # switch over to parsing of the python string representation
+
+        # Print the screen statement and create the block
+        self.indent()
+        self.write("screen %s" % ast.name)
+        # If we have parameters, print them.
+        if hasattr(ast, "parameters") and ast.parameters:
+            self.write(reconstruct_paraminfo(ast.parameters))
+
+        if ast.tag:
+            self.write(" tag %s" % ast.tag)
+
+        keywords = {ast.code.location[1]: WordConcatenator(False, True)}
+        for key in ('modal', 'zorder', 'variant', 'predict'):
+            value = getattr(ast, key)
+            # Non-Unicode strings are default values rather than user-supplied
+            # values, so we don't need to write them out.
+            if isinstance(value, unicode):
+                if value.linenumber not in keywords:
+                    keywords[value.linenumber] = WordConcatenator(False, True)
+                keywords[value.linenumber].append("%s %s" % (key, value))
+        keywords = sorted([(k, v.join()) for k, v in keywords.items()],
+                          key=itemgetter(0)) # so the first one is right
+        if self.decompile_python:
+            self.print_keywords_and_nodes(keywords, None, True)
+            with self.increase_indent():
+                self.indent()
+                self.write("python:")
+                with self.increase_indent():
+                    # The first line is always "_1 = (_name, 0)", which gets included
+                    # even if the python: block is the only thing in the screen. Don't
+                    # include ours, since if we do, it'll be included twice when
+                    # recompiled.
+                    self.write_lines(self.to_source(ast.code.source).splitlines()[1:])
+        else:
+            self.print_keywords_and_nodes(keywords, ast.code.source.body, False)
+
+    def split_nodes_at_headers(self, nodes):
+        if not nodes:
+            return []
+        rv = [nodes[:1]]
+        parent_id = self.parse_header(nodes[0])
+        if parent_id is None:
+            raise Exception(
+                "First node passed to split_nodes_at_headers was not a header")
+        for i in nodes[1:]:
+            if self.parse_header(i) == parent_id:
+                rv.append([i])
+                header = i
+            else:
+                rv[-1].append(i)
+        return rv
+
+    def print_nodes(self, nodes, extra_indent=0, has_block=False):
+        # Print a block of statements, splitting it up on one level.
+        # The screen language parser emits lines in the shape _0 = (_0, 0) from which indentation can be revealed.
+        # It translates roughly to "id = (parent_id, index_in_parent_children)". When parsing a block
+        # parse the first header line to find the parent_id, and then split around headers with the same parent id
+        # in this block.
+        if has_block and not nodes:
+            raise BadHasBlockException()
+        split = self.split_nodes_at_headers(nodes)
+        with self.increase_indent(extra_indent):
+            for i in split:
+                self.print_node(i[0], i[1:], has_block)
+
+    def get_first_line(self, nodes):
+        if self.get_dispatch_key(nodes[0]):
+            return nodes[0].value.lineno
+        elif self.is_renpy_for(nodes):
+            return nodes[1].target.lineno
+        elif self.is_renpy_if(nodes):
+            return nodes[0].test.lineno
+        else:
+            # We should never get here, but just in case...
+            return nodes[0].lineno
+
+    def make_printable_keywords(self, keywords, lineno):
+        keywords = [(i.arg, simple_expression_guard(self.to_source(i.value)),
+            i.value.lineno) for i in keywords if not (isinstance(
+            i.value, ast.Name) and (
+            (i.arg == 'id' and i.value.id.startswith('_')) or
+            (i.arg == 'scope' and i.value.id == '_scope')))]
+        # Sort the keywords according to what line they belong on
+        # The first element always exists for the line the block starts on,
+        # even if there's no keywords that go on it
+        keywords_by_line = []
+        current_line = []
+        for i in keywords:
+            if i[2] > lineno:
+                keywords_by_line.append((lineno, ' '.join(current_line)))
+                lineno = i[2]
+                current_line = []
+            current_line.extend(i[:2])
+        keywords_by_line.append((lineno, ' '.join(current_line)))
+        return keywords_by_line
+
+    def print_keywords_and_nodes(self, keywords, nodes, needs_colon):
+        # Keywords and child nodes can be mixed with each other, so they need
+        # to be printed at the same time. This function takes each list and
+        # combines them into one, then prints it.
+        #
+        # This function assumes line numbers of nodes before keywords are
+        # correct, which is the case for the "screen" statement itself.
+        if keywords:
+            if keywords[0][1]:
+                self.write(" %s" % keywords[0][1])
+            if len(keywords) != 1:
+                needs_colon = True
+        if nodes:
+            nodelists = [(self.get_first_line(i[1:]), i)
+                         for i in self.split_nodes_at_headers(nodes)]
+            needs_colon = True
+        else:
+            nodelists = []
+        if needs_colon:
+            self.write(":")
+        stuff_to_print = sorted(keywords[1:] + nodelists, key=itemgetter(0))
+        with self.increase_indent():
+            for i in stuff_to_print:
+                # Nodes are lists. Keywords are ready-to-print strings.
+                if type(i[1]) == list:
+                    self.print_node(i[1][0], i[1][1:])
+                else:
+                    self.advance_to_line(i[0])
+                    self.indent()
+                    self.write(i[1])
+
+    def get_lines_used_by_node(self, node):
+        state = self.save_state()
+        self.print_node(node[0], node[1:])
+        linenumber = self.linenumber
+        self.rollback_state(state)
+        return linenumber - self.linenumber
+
+    def print_buggy_keywords_and_nodes(self, keywords, nodes, needs_colon, has_block):
+        # Keywords and child nodes can be mixed with each other, so they need
+        # to be printed at the same time. This function takes each list and
+        # combines them into one, then prints it.
+        #
+        # This function assumes line numbers of nodes before keywords are
+        # incorrect, which is the case for everything except the "screen"
+        # statement itself.
+        last_keyword_lineno = None
+        if keywords:
+            if keywords[0][1]:
+                self.write(" %s" % keywords[0][1])
+            remaining_keywords = keywords[1:]
+            if remaining_keywords:
+                needs_colon = True
+                last_keyword_lineno = remaining_keywords[-1][0]
+        if nodes:
+            nodelists = [(self.get_first_line(i[1:]), i)
+                         for i in self.split_nodes_at_headers(nodes)]
+        else:
+            nodelists = []
+        for key, value in enumerate(nodelists):
+            if last_keyword_lineno is None or value[0] > last_keyword_lineno:
+                nodes_before_keywords = nodelists[:key]
+                nodes_after_keywords = nodelists[key:]
+                break
+        else:
+            nodes_before_keywords = nodelists
+            nodes_after_keywords = []
+        if nodes_before_keywords or (not has_block and nodes_after_keywords):
+            needs_colon = True
+        if needs_colon:
+            self.write(":")
+        with self.increase_indent():
+            should_advance_to_line = self.should_advance_to_line
+            self.should_advance_to_line = False
+            while nodes_before_keywords:
+                if not remaining_keywords:
+                    # Something went wrong. We already printed the last keyword,
+                    # yet there's still nodes left that should have been printed
+                    # before the last keyword. Just print them now.
+                    for i in nodes_before_keywords:
+                        self.print_node(i[1][0], i[1][1:])
+                    break
+                # subtract 1 line since .indent() uses 1
+                lines_to_go = remaining_keywords[0][0] - self.linenumber - 1
+                next_node = nodes_before_keywords[0][1]
+                if lines_to_go >= self.get_lines_used_by_node(next_node):
+                    self.print_node(next_node[0], next_node[1:])
+                    nodes_before_keywords.pop(0)
+                elif not should_advance_to_line or lines_to_go <= 0:
+                    self.indent()
+                    self.write(remaining_keywords.pop(0)[1])
+                else:
+                    self.write("\n" * lines_to_go)
+            self.should_advance_to_line = should_advance_to_line
+            for i in remaining_keywords:
+                self.advance_to_line(i[0])
+                self.indent()
+                self.write(i[1])
+        with self.increase_indent(1 if not has_block else 0):
+            for i in nodes_after_keywords:
+                self.print_node(i[1][0], i[1][1:])
+
+    def get_dispatch_key(self, node):
+        if (isinstance(node, ast.Expr) and
+                isinstance(node.value, ast.Call) and
+                isinstance(node.value.func, ast.Attribute) and
+                isinstance(node.value.func.value, ast.Name)):
+            return node.value.func.value.id, node.value.func.attr
+        else:
+            return None
+
+    def print_node(self, header, code, has_block=False):
+        # Here we derermine how to handle a statement.
+        # To do this we look at how the first line in the statement code starts, after the header.
+        # Then we call the appropriate function as specified in ui_function_dict.
+        # If the statement is unknown, we can still emit valid screen code by just
+        # stuffing it inside a python block.
+
+        # There's 3 categories of things that we can convert to screencode:
+        # if statements, for statements, and function calls of the
+        # form "first.second(...)". Anything else gets converted to Python.
+        dispatch_key = self.get_dispatch_key(code[0])
+        if dispatch_key:
+            func = self.dispatch.get(dispatch_key, self.print_python.__func__)
+            if has_block:
+                if func not in (self.print_onechild.__func__,
+                    self.print_manychildren.__func__):
+                    raise BadHasBlockException()
+                func(self, header, code, True)
+            else:
+                func(self, header, code)
+        elif has_block:
+            raise BadHasBlockException()
+        elif self.is_renpy_for(code):
+            self.print_for(header, code)
+        elif self.is_renpy_if(code):
+            self.print_if(header, code)
+        else:
+            self.print_python(header, code)
+    # Helper printing functions
+
+    def print_args(self, node):
+        if node.args:
+            self.write(" " + " ".join([simple_expression_guard(
+                self.to_source(i)) for i in node.args]))
+
+    # Node printing functions
+
+    def print_python(self, header, code):
+        # This function handles any statement which is a block but couldn't logically be
+        # Translated to a screen statement.
+        #
+        # Ren'Py's line numbers are really, really buggy. Here's a summary:
+        # If we're not directly under the root screen, and a keyword for our
+        # parent follows us, then all of our line numbers will be equal to the
+        # line number of that keyword.
+        # If we're not directly under the root screen, and no keywords for our
+        # parent follow us, then header.lineno is the line number of whatever
+        # it is that preceded us (which is completely useless).
+        # If we're directly under the root "screen", then header.lineno is the
+        # line that "$" or "python:" appeared on.
+        # If we're not a child followed by a keyword, and "$" was used, then
+        # code[0].lineno is the line that the code actually starts on, but if
+        # "python:" was used, then all of code's line numbers will be 1 greater
+        # than the line each one should be.
+        source = self.to_source(ast.Module(body=code,
+                                           lineno=code[0].lineno,
+                                           col_offset=0)).rstrip().lstrip('\n')
+        lines = source.splitlines()
+        if len(split_logical_lines(source)) == 1 and (
+                (not self.is_root and code[0].lineno < self.linenumber + 3) or
+                header.lineno >= code[0].lineno):
+            # This is only one logical line, so it's possible that it was $,
+            # and either it's not in the root (so we don't know what the
+            # original source used), or it is in the root and we know it used $.
+            # Also, if we don't know for sure what was used, but we have enough
+            # room to use a "python" block, then use it instead, since it'll
+            # result in everything taking up one fewer line (since it'll use
+            # one more, but start two sooner).
+            self.advance_to_line(code[0].lineno)
+            self.indent()
+            self.write("$ %s" % lines[0])
+            self.write_lines(lines[1:])
+        else:
+            # Either this is more than one logical line, so it has to be a
+            # python block, or it was in the root and we can tell that it was
+            # originally a python block.
+            if self.is_root:
+                self.advance_to_line(header.lineno)
+            self.indent()
+            self.write("python:")
+            self.advance_to_line(code[0].lineno - 1)
+            with self.increase_indent():
+                self.write_lines(lines)
+
+    def is_renpy_if(self, nodes):
+        return len(nodes) == 1 and isinstance(nodes[0], ast.If) and (
+            nodes[0].body and self.parse_header(nodes[0].body[0])) and (
+                not nodes[0].orelse or self.is_renpy_if(nodes[0].orelse) or
+                self.parse_header(nodes[0].orelse[0]))
+
+    def is_renpy_for(self, nodes):
+        return (len(nodes) == 2 and isinstance(nodes[0], ast.Assign) and
+            len(nodes[0].targets) == 1 and
+            isinstance(nodes[0].targets[0], ast.Name) and
+            re.match(r"_[0-9]+$", nodes[0].targets[0].id) and
+            isinstance(nodes[0].value, ast.Num) and nodes[0].value.n == 0 and
+            isinstance(nodes[1], ast.For) and not nodes[1].orelse and
+            nodes[1].body and self.parse_header(nodes[1].body[0]) and
+            isinstance(nodes[1].body[-1], ast.AugAssign) and
+            isinstance(nodes[1].body[-1].op, ast.Add) and
+            isinstance(nodes[1].body[-1].target, ast.Name) and
+            re.match(r"_[0-9]+$", nodes[1].body[-1].target.id) and
+            isinstance(nodes[1].body[-1].value, ast.Num) and
+            nodes[1].body[-1].value.n == 1)
+
+    def strip_parens(self, text):
+        if text and text[0] == '(' and text[-1] == ')':
+            return text[1:-1]
+        else:
+            return text
+
+    def print_if(self, header, code):
+        # Here we handle the if statement. It might be valid python but we can check for this by
+        # checking for the header that should normally occur within the if statement.
+        # The if statement parser might also generate a second header if there's more than one screen
+        # statement enclosed in the if/elif/else statements. We'll take care of that too.
+        self.advance_to_line(self.get_first_line(code))
+        self.indent()
+        self.write("if %s:" % self.strip_parens(self.to_source(code[0].test)))
+        if (len(code[0].body) >= 2 and self.parse_header(code[0].body[0]) and
+            self.parse_header(code[0].body[1])):
+            body = code[0].body[1:]
+        else:
+            body = code[0].body
+        with self.not_root():
+            self.print_nodes(body, 1)
+            if code[0].orelse:
+                if self.is_renpy_if(code[0].orelse):
+                    self.advance_to_line(code[0].orelse[0].test.lineno)
+                    self.indent()
+                    self.write("el") # beginning of "elif"
+                    self.skip_indent_until_write = True
+                    self.print_if(header, code[0].orelse)
+                else:
+                    self.indent()
+                    self.write("else:")
+                    if (len(code[0].orelse) >= 2 and
+                        self.parse_header(code[0].orelse[0]) and
+                        self.parse_header(code[0].orelse[1])):
+                        orelse = code[0].orelse[1:]
+                    else:
+                        orelse = code[0].orelse
+                    self.print_nodes(orelse, 1)
+
+    def print_for(self, header, code):
+        # Here we handle the for statement. Note that the for statement generates some extra python code to
+        # Keep track of it's header indices. The first one is ignored by the statement parser,
+        # the second line is just ingored here.
+        line = code[1]
+        self.advance_to_line(self.get_first_line(code))
+        self.indent()
+        self.write("for %s in %s:" % (
+            self.strip_parens(self.to_source(line.target)),
+            self.to_source(line.iter)))
+        if (len(line.body) >= 3 and self.parse_header(line.body[0]) and
+            self.parse_header(line.body[1])):
+            body = line.body[1:]
+        else:
+            body = line.body
+        with self.not_root():
+            self.print_nodes(body[:-1], 1)
+
+    @dispatch(('renpy', 'use_screen'))
+    def print_use(self, header, code):
+        # This function handles the use statement, which translates into a python expression "renpy.use_screen".
+        # It would technically be possible for this to be a python statement, but the odds of this are very small.
+        # renpy itself will insert some kwargs, we'll delete those and then parse the command here.
+        if (len(code) != 1 or not code[0].value.args or
+            not isinstance(code[0].value.args[0], ast.Str)):
+            return self.print_python(header, code)
+        args, kwargs, exargs, exkwargs = self.parse_args(code[0])
+        kwargs = [(key, value) for key, value in kwargs if not
+                  (key == '_scope' or key == '_name')]
+
+        self.advance_to_line(self.get_first_line(code))
+        self.indent()
+        self.write("use %s" % code[0].value.args[0].s)
+        args.pop(0)
+
+        arglist = []
+        if args or kwargs or exargs or exkwargs:
+            self.write("(")
+            arglist.extend(args)
+            arglist.extend("%s=%s" % i for i in kwargs)
+            if exargs:
+                arglist.append("*%s" % exargs)
+            if exkwargs:
+                arglist.append("**%s" % exkwargs)
+            self.write(", ".join(arglist))
+            self.write(")")
+
+    @dispatch(('_scope', 'setdefault'))
+    def print_default(self, header, code):
+        if (len(code) != 1 or code[0].value.keywords or code[0].value.kwargs or
+            len(code[0].value.args) != 2 or code[0].value.starargs or
+            not isinstance(code[0].value.args[0], ast.Str)):
+            return self.print_python(header, code)
+        self.advance_to_line(self.get_first_line(code))
+        self.indent()
+        self.write("default %s = %s" %
+            (code[0].value.args[0].s, self.to_source(code[0].value.args[1])))
+
+    # These never have a ui.close() at the end
+    @dispatch(('ui', 'add'))
+    @dispatch(('ui', 'imagebutton'))
+    @dispatch(('ui', 'input'))
+    @dispatch(('ui', 'key'))
+    @dispatch(('ui', 'label'))
+    @dispatch(('ui', 'text'))
+    @dispatch(('ui', 'null'))
+    @dispatch(('ui', 'mousearea'))
+    @dispatch(('ui', 'textbutton'))
+    @dispatch(('ui', 'timer'))
+    @dispatch(('ui', 'bar'))
+    @dispatch(('ui', 'vbar'))
+    @dispatch(('ui', 'hotbar'))
+    @dispatch(('ui', 'on'))
+    @dispatch(('ui', 'image'))
+    def print_nochild(self, header, code):
+        if len(code) != 1:
+            self.print_python(header, code)
+            return
+        line = code[0]
+        self.advance_to_line(self.get_first_line(code))
+        self.indent()
+        self.write(line.value.func.attr)
+        self.print_args(line.value)
+        with self.not_root():
+            self.print_buggy_keywords_and_nodes(
+                self.make_printable_keywords(line.value.keywords,
+                                             line.value.lineno),
+                None, False, False)
+
+    # These functions themselves don't have a ui.close() at the end, but
+    # they're always immediately followed by one that does (usually
+    # ui.child_or_fixed(), but also possibly one set with "has")
+    @dispatch(('ui', 'button'))
+    @dispatch(('ui', 'frame'))
+    @dispatch(('ui', 'transform'))
+    @dispatch(('ui', 'viewport'))
+    @dispatch(('ui', 'window'))
+    @dispatch(('ui', 'drag'))
+    @dispatch(('ui', 'hotspot_with_child'))
+    def print_onechild(self, header, code, has_block=False):
+        # We expect to have at least ourself, one child, and ui.close()
+        if len(code) < 3 or self.get_dispatch_key(code[-1]) != ('ui', 'close'):
+            if has_block:
+                raise BadHasBlockException()
+            self.print_python(header, code)
+            return
+        line = code[0]
+        name = line.value.func.attr
+        if name == 'hotspot_with_child':
+            name = 'hotspot'
+        if self.get_dispatch_key(code[1]) != ('ui', 'child_or_fixed'):
+            # Handle the case where a "has" statement was used
+            if has_block:
+                # Ren'Py lets users nest "has" blocks for some reason, and it
+                # puts the ui.close() statement in the wrong place when they do.
+                # Since we checked for ui.close() being in the right place
+                # before, the only way we could ever get here is if a user added
+                # one inside a python block at the end. If this happens, turn
+                # the whole outer block into Python instead of screencode.
+                raise BadHasBlockException()
+            if not self.parse_header(code[1]):
+                self.print_python(header, code)
+                return
+            block = code[1:]
+            state = self.save_state()
+            try:
+                self.advance_to_line(self.get_first_line(code))
+                self.indent()
+                self.write(name)
+                self.print_args(line.value)
+                with self.not_root():
+                    self.print_buggy_keywords_and_nodes(
+                        self.make_printable_keywords(line.value.keywords,
+                                                     line.value.lineno),
+                        None, True, False)
+                    with self.increase_indent():
+                        if len(block) > 1 and isinstance(block[1], ast.Expr):
+                            # If this isn't true, we'll get a BadHasBlockException
+                            # later anyway. This check is just to keep it from being
+                            # an exception that we can't handle.
+                            self.advance_to_line(block[1].value.lineno)
+                        self.indent()
+                        self.write("has ")
+                    self.skip_indent_until_write = True
+                    self.print_nodes(block, 1, True)
+            except BadHasBlockException as e:
+                self.rollback_state(state)
+                self.print_python(header, code)
+            else:
+                self.commit_state(state)
+        else:
+            # Remove ourself, ui.child_or_fixed(), and ui.close()
+            block = code[2:-1]
+            if block and not self.parse_header(block[0]):
+                if has_block:
+                    raise BadHasBlockException()
+                self.print_python(header, code)
+                return
+            if not has_block:
+                self.advance_to_line(self.get_first_line(code))
+            self.indent()
+            self.write(name)
+            self.print_args(line.value)
+            with self.not_root():
+                self.print_buggy_keywords_and_nodes(
+                    self.make_printable_keywords(line.value.keywords,
+                                                 line.value.lineno),
+                    block, False, has_block)
+
+    # These always have a ui.close() at the end
+    @dispatch(('ui', 'fixed'))
+    @dispatch(('ui', 'grid'))
+    @dispatch(('ui', 'hbox'))
+    @dispatch(('ui', 'side'))
+    @dispatch(('ui', 'vbox'))
+    @dispatch(('ui', 'imagemap'))
+    @dispatch(('ui', 'draggroup'))
+    def print_manychildren(self, header, code, has_block=False):
+        if (self.get_dispatch_key(code[-1]) != ('ui', 'close') or
+            (len(code) != 2 and not self.parse_header(code[1]))):
+            if has_block:
+                raise BadHasBlockException()
+            self.print_python(header, code)
+            return
+        line = code[0]
+        block = code[1:-1]
+        if not has_block:
+            self.advance_to_line(self.get_first_line(code))
+        self.indent()
+        self.write(line.value.func.attr)
+        self.print_args(line.value)
+        with self.not_root():
+            self.print_buggy_keywords_and_nodes(
+                self.make_printable_keywords(line.value.keywords,
+                                             line.value.lineno),
+                block, False, has_block)
+
+    # Parsing functions
+
+    def parse_header(self, header):
+        # Given a Python AST node, returns the parent ID if the node represents
+        # a header, or None otherwise.
+        if (isinstance(header, ast.Assign) and len(header.targets) == 1 and
+                isinstance(header.targets[0], ast.Name) and
+                re.match(r"_[0-9]+$", header.targets[0].id) and
+                isinstance(header.value, ast.Tuple) and
+                len(header.value.elts) == 2 and
+                isinstance(header.value.elts[0], ast.Name)):
+            parent_id = header.value.elts[0].id
+            index = header.value.elts[1]
+            if re.match(r"_([0-9]+|name)$", parent_id) and (
+                    isinstance(index, ast.Num) or
+                    (isinstance(index, ast.Name) and
+                    re.match(r"_[0-9]+$", index.id))):
+                return parent_id
+        return None
+
+    def parse_args(self, node):
+        return ([self.to_source(i) for i in node.value.args],
+            [(i.arg, self.to_source(i.value)) for i in node.value.keywords],
+            node.value.starargs and self.to_source(node.value.starargs),
+            node.value.kwargs and self.to_source(node.value.kwargs))
+
+class BadHasBlockException(Exception):
+    pass

renpy/rpycdec/rpycdecdata/decompiler/sl2decompiler.py

@@ -0,0 +1,374 @@
+# Copyright (c) 2014 CensoredUsername
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+from __future__ import unicode_literals
+import sys
+from operator import itemgetter
+
+from util import DecompilerBase, First, reconstruct_paraminfo, \
+                 reconstruct_arginfo, split_logical_lines, Dispatcher
+
+from renpy import ui, sl2
+from renpy.ast import PyExpr
+from renpy.text import text
+from renpy.sl2 import sldisplayables as sld
+from renpy.display import layout, behavior, im, motion, dragdrop
+
+# Main API
+
+def pprint(out_file, ast, print_atl_callback, indent_level=0, linenumber=1,
+           skip_indent_until_write=False, printlock=None, tag_outside_block=False):
+    return SL2Decompiler(print_atl_callback, out_file, printlock=printlock, tag_outside_block=tag_outside_block).dump(
+        ast, indent_level, linenumber, skip_indent_until_write)
+
+# Implementation
+
+class SL2Decompiler(DecompilerBase):
+    """
+    An object which handles the decompilation of renpy screen language 2 screens to a given stream
+    """
+
+    def __init__(self, print_atl_callback, out_file=None, indentation = '    ', printlock=None, tag_outside_block=False):
+        super(SL2Decompiler, self).__init__(out_file, indentation, printlock)
+        self.print_atl_callback = print_atl_callback
+        self.tag_outside_block = tag_outside_block
+
+    # This dictionary is a mapping of Class: unbound_method, which is used to determine
+    # what method to call for which slast class
+    dispatch = Dispatcher()
+
+    def print_node(self, ast):
+        self.advance_to_line(ast.location[1])
+        self.dispatch.get(type(ast), type(self).print_unknown)(self, ast)
+
+    @dispatch(sl2.slast.SLScreen)
+    def print_screen(self, ast):
+
+        # Print the screen statement and create the block
+        self.indent()
+        self.write("screen %s" % ast.name)
+        # If we have parameters, print them.
+        if ast.parameters:
+            self.write(reconstruct_paraminfo(ast.parameters))
+
+        # If we're decompiling screencode, print it. Else, insert a pass statement
+        self.print_keywords_and_children(ast.keyword,
+            ast.children, ast.location[1], tag=ast.tag, atl_transform=getattr(ast, 'atl_transform', None))
+
+    @dispatch(sl2.slast.SLIf)
+    def print_if(self, ast):
+        # if and showif share a lot of the same infrastructure
+        self._print_if(ast, "if")
+
+    @dispatch(sl2.slast.SLShowIf)
+    def print_showif(self, ast):
+        # so for if and showif we just call an underlying function with an extra argument
+        self._print_if(ast, "showif")
+
+    def _print_if(self, ast, keyword):
+        # the first condition is named if or showif, the rest elif
+        keyword = First(keyword, "elif")
+        for condition, block in ast.entries:
+            self.advance_to_line(block.location[1])
+            self.indent()
+            # if condition is None, this is the else clause
+            if condition is None:
+                self.write("else:")
+            else:
+                self.write("%s %s:" % (keyword(), condition))
+
+            # Every condition has a block of type slast.SLBlock
+            if block.keyword or block.children or getattr(block, 'atl_transform', None):
+                self.print_block(block)
+            else:
+                with self.increase_indent():
+                    self.indent()
+                    self.write("pass")
+
+    @dispatch(sl2.slast.SLBlock)
+    def print_block(self, ast):
+        # A block contains possible keyword arguments and a list of child nodes
+        # this is the reason if doesn't keep a list of children but special Blocks
+        self.print_keywords_and_children(ast.keyword, ast.children, None, atl_transform=getattr(ast, 'atl_transform', None))
+
+    @dispatch(sl2.slast.SLFor)
+    def print_for(self, ast):
+        # Since tuple unpickling is hard, renpy just gives up and inserts a
+        # $ a,b,c = _sl2_i after the for statement if any tuple unpacking was
+        # attempted in the for statement. Detect this and ignore this slast.SLPython entry
+        if ast.variable == "_sl2_i":
+            variable = ast.children[0].code.source[:-9]
+            children = ast.children[1:]
+        else:
+            variable = ast.variable.strip() + " "
+            children = ast.children
+
+        self.indent()
+        if hasattr(ast, "index_expression") and ast.index_expression is not None:
+            self.write("for %sindex %s in %s:" % (variable, ast.index_expression, ast.expression))
+
+        else:
+            self.write("for %sin %s:" % (variable, ast.expression))
+
+        # Interestingly, for doesn't contain a block, but just a list of child nodes
+        self.print_nodes(children, 1)
+
+    @dispatch(sl2.slast.SLPython)
+    def print_python(self, ast):
+        self.indent()
+
+        # Extract the source code from the slast.SLPython object. If it starts with a
+        # newline, print it as a python block, else, print it as a $ statement
+        code = ast.code.source
+        if code.startswith("\n"):
+            code = code[1:]
+            self.write("python:")
+            with self.increase_indent():
+                self.write_lines(split_logical_lines(code))
+        else:
+            self.write("$ %s" % code)
+
+    @dispatch(sl2.slast.SLPass)
+    def print_pass(self, ast):
+        # A pass statement
+        self.indent()
+        self.write("pass")
+
+    @dispatch(sl2.slast.SLUse)
+    def print_use(self, ast):
+        # A use statement requires reconstructing the arguments it wants to pass
+        self.indent()
+        self.write("use ")
+        args = reconstruct_arginfo(ast.args)
+        if isinstance(ast.target, PyExpr):
+            self.write("expression %s" % ast.target)
+            if args:
+                self.write(" pass ")
+        else:
+            self.write("%s" % ast.target)
+
+        self.write("%s" % reconstruct_arginfo(ast.args))
+        if hasattr(ast, 'id') and ast.id is not None:
+            self.write(" id %s" % ast.id)
+
+        if hasattr(ast, 'block') and ast.block:
+            self.write(":")
+            self.print_block(ast.block)
+
+    @dispatch(sl2.slast.SLTransclude)
+    def print_transclude(self, ast):
+        self.indent()
+        self.write("transclude")
+
+    @dispatch(sl2.slast.SLDefault)
+    def print_default(self, ast):
+        # A default statement
+        self.indent()
+        self.write("default %s = %s" % (ast.variable, ast.expression))
+
+    @dispatch(sl2.slast.SLDisplayable)
+    def print_displayable(self, ast, has_block=False):
+        # slast.SLDisplayable represents a variety of statements. We can figure out
+        # what statement it represents by analyzing the called displayable and style
+        # attributes.
+        key = (ast.displayable, ast.style)
+        nameAndChildren = self.displayable_names.get(key)
+        if nameAndChildren is None:
+            # This is either a displayable we don't know about, or a user-defined displayable
+
+            # workaround: assume the name of the displayable matches the given style
+            # this is rather often the case. However, as it may be wrong we have to
+            # print a debug message
+            nameAndChildren = (ast.style, 'many')
+            self.print_debug(
+ """Warning: Encountered a user-defined displayable of type '{}'.
+    Unfortunately, the name of user-defined displayables is not recorded in the compiled file.
+    For now the style name '{}' will be substituted.
+    To check if this is correct, find the corresponding renpy.register_sl_displayable call.""".format(
+                    ast.displayable, ast.style
+                )
+            )
+        (name, children) = nameAndChildren
+        self.indent()
+        self.write(name)
+        if ast.positional:
+            self.write(" " + " ".join(ast.positional))
+        if hasattr(ast, 'variable'):
+            variable = ast.variable
+        else:
+            variable = None
+        atl_transform = getattr(ast, 'atl_transform', None)
+        # The AST contains no indication of whether or not "has" blocks
+        # were used. We'll use one any time it's possible (except for
+        # directly nesting them, or if they wouldn't contain any children),
+        # since it results in cleaner code.
+        if (not has_block and children == 1 and len(ast.children) == 1 and
+            isinstance(ast.children[0], sl2.slast.SLDisplayable) and
+            ast.children[0].children and (not ast.keyword or
+                ast.children[0].location[1] > ast.keyword[-1][1].linenumber) and
+            (atl_transform is None or ast.children[0].location[1] > atl_transform.loc[1])):
+            self.print_keywords_and_children(ast.keyword, [],
+                ast.location[1], needs_colon=True, variable=variable, atl_transform=atl_transform)
+            self.advance_to_line(ast.children[0].location[1])
+            with self.increase_indent():
+                self.indent()
+                self.write("has ")
+                self.skip_indent_until_write = True
+                self.print_displayable(ast.children[0], True)
+        else:
+            self.print_keywords_and_children(ast.keyword, ast.children,
+                 ast.location[1], has_block=has_block, variable=variable, atl_transform=atl_transform)
+
+    displayable_names = {
+        (behavior.OnEvent, None):          ("on", 0),
+        (behavior.OnEvent, 0):             ("on", 0),
+        (behavior.MouseArea, 0):           ("mousearea", 0),
+        (behavior.MouseArea, None):        ("mousearea", 0),
+        (ui._add, None):                   ("add", 0),
+        (sld.sl2add, None):                ("add", 0),
+        (ui._hotbar, "hotbar"):            ("hotbar", 0),
+        (sld.sl2vbar, None):               ("vbar", 0),
+        (sld.sl2bar, None):                ("bar", 0),
+        (ui._label, "label"):              ("label", 0),
+        (ui._textbutton, 0):               ("textbutton", 0),
+        (ui._textbutton, "button"):               ("textbutton", 0),
+        (ui._imagebutton, "image_button"): ("imagebutton", 0),
+        (im.image, "default"):             ("image", 0),
+        (behavior.Input, "input"):         ("input", 0),
+        (behavior.Timer, "default"):       ("timer", 0),
+        (ui._key, None):                   ("key", 0),
+        (text.Text, "text"):               ("text", 0),
+        (layout.Null, "default"):          ("null", 0),
+        (dragdrop.Drag, None):             ("drag", 1),
+        (dragdrop.Drag, "drag"):           ("drag", 1),
+        (motion.Transform, "transform"):   ("transform", 1),
+        (ui._hotspot, "hotspot"):          ("hotspot", 1),
+        (sld.sl2viewport, "viewport"):     ("viewport", 1),
+        (behavior.Button, "button"):       ("button", 1),
+        (layout.Window, "frame"):          ("frame", 1),
+        (layout.Window, "window"):         ("window", 1),
+        (dragdrop.DragGroup, None):        ("draggroup", 'many'),
+        (ui._imagemap, "imagemap"):        ("imagemap", 'many'),
+        (layout.Side, "side"):             ("side", 'many'),
+        (layout.Grid, "grid"):             ("grid", 'many'),
+        (sld.sl2vpgrid, "vpgrid"):         ("vpgrid", 'many'),
+        (layout.MultiBox, "fixed"):        ("fixed", 'many'),
+        (layout.MultiBox, "vbox"):         ("vbox", 'many'),
+        (layout.MultiBox, "hbox"):         ("hbox", 'many')
+    }
+
+    def print_keywords_and_children(self, keywords, children, lineno, needs_colon=False, has_block=False, tag=None, variable=None, atl_transform=None):
+        # This function prints the keyword arguments and child nodes
+        # Used in a displayable screen statement
+
+        # If lineno is None, we're already inside of a block.
+        # Otherwise, we're on the line that could start a block.
+        wrote_colon = False
+        keywords_by_line = []
+        current_line = (lineno, [])
+        keywords_somewhere = [] # These can go anywhere inside the block that there's room.
+        if variable is not None:
+            if current_line[0] is None:
+                keywords_somewhere.extend(("as", variable))
+            else:
+                current_line[1].extend(("as", variable))
+        if tag is not None:
+            if current_line[0] is None or not self.tag_outside_block:
+                keywords_somewhere.extend(("tag", tag))
+            else:
+                current_line[1].extend(("tag", tag))
+        for key, value in keywords:
+            if value is None:
+                value = ""
+                if current_line[0] is None:
+                    keywords_by_line.append(current_line)
+                    current_line = (0, [])
+            elif current_line[0] is None or value.linenumber > current_line[0]:
+                keywords_by_line.append(current_line)
+                current_line = (value.linenumber, [])
+            current_line[1].extend((key, value))
+        if keywords_by_line:
+            # Easy case: we have at least one line inside the block that already has keywords.
+            # Just put the ones from keywords_somewhere with them.
+            current_line[1].extend(keywords_somewhere)
+            keywords_somewhere = []
+        keywords_by_line.append(current_line)
+        last_keyword_line = keywords_by_line[-1][0]
+        children_with_keywords = []
+        children_after_keywords = []
+        for i in children:
+            if i.location[1] > last_keyword_line:
+                children_after_keywords.append(i)
+            else:
+                children_with_keywords.append((i.location[1], i))
+        # the keywords in keywords_by_line[0] go on the line that starts the
+        # block, not in it
+        block_contents = sorted(keywords_by_line[1:] + children_with_keywords,
+                                key=itemgetter(0))
+        if keywords_by_line[0][1]: # this never happens if lineno was None
+            self.write(" %s" % ' '.join(keywords_by_line[0][1]))
+        if keywords_somewhere: # this never happens if there's anything in block_contents
+            # Hard case: we need to put a keyword somewhere inside the block, but we have no idea which line to put it on.
+            if lineno is not None:
+                self.write(":")
+                wrote_colon = True
+            for index, child in enumerate(children_after_keywords):
+                if child.location[1] > self.linenumber + 1:
+                    # We have at least one blank line before the next child. Put the keywords here.
+                    with self.increase_indent():
+                        self.indent()
+                        self.write(' '.join(keywords_somewhere))
+                    self.print_nodes(children_after_keywords[index:], 0 if has_block else 1)
+                    break
+                with self.increase_indent():
+                    # Even if we're in a "has" block, we need to indent this child since there will be a keyword line after it.
+                    self.print_node(child)
+            else:
+                # No blank lines before any children, so just put the remaining keywords at the end.
+                with self.increase_indent():
+                    self.indent()
+                    self.write(' '.join(keywords_somewhere))
+        else:
+            if block_contents or (not has_block and children_after_keywords):
+                if lineno is not None:
+                    self.write(":")
+                    wrote_colon = True
+                with self.increase_indent():
+                    for i in block_contents:
+                        if isinstance(i[1], list):
+                            self.advance_to_line(i[0])
+                            self.indent()
+                            self.write(' '.join(i[1]))
+                        else:
+                            self.print_node(i[1])
+            elif needs_colon:
+                self.write(":")
+                wrote_colon = True
+            self.print_nodes(children_after_keywords, 0 if has_block else 1)
+        if atl_transform is not None:
+            # "at transform:", possibly preceded by other keywords, and followed by an ATL block
+            # TODO this doesn't always go at the end. Use line numbers to figure out where it goes
+            if not wrote_colon and lineno is not None:
+                self.write(":")
+                wrote_colon = True
+            with self.increase_indent():
+                self.indent()
+                self.write("at transform:")
+                self.linenumber = self.print_atl_callback(self.linenumber, self.indent_level, atl_transform)

renpy/rpycdec/rpycdecdata/decompiler/testcasedecompiler.py

@@ -0,0 +1,142 @@
+# Copyright (c) 2016 Jackmcbarn
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+from __future__ import unicode_literals
+from util import DecompilerBase, split_logical_lines, Dispatcher, string_escape
+from renpy.test import testast
+
+# Main API
+
+def pprint(out_file, ast, indent_level=0, linenumber=1,
+           skip_indent_until_write=False, printlock=None):
+    return TestcaseDecompiler(out_file, printlock=printlock).dump(
+        ast, indent_level, linenumber, skip_indent_until_write)
+
+# Implementation
+
+class TestcaseDecompiler(DecompilerBase):
+    """
+    An object which handles the decompilation of renpy testcase statements
+    """
+
+    # This dictionary is a mapping of Class: unbound_method, which is used to determine
+    # what method to call for which testast class
+    dispatch = Dispatcher()
+
+    def print_node(self, ast):
+        if hasattr(ast, 'linenumber'):
+            self.advance_to_line(ast.linenumber)
+        self.dispatch.get(type(ast), type(self).print_unknown)(self, ast)
+
+    @dispatch(testast.Python)
+    def print_python(self, ast):
+        self.indent()
+        code = ast.code.source
+        if code[0] == '\n':
+            self.write("python:")
+            with self.increase_indent():
+                self.write_lines(split_logical_lines(code[1:]))
+        else:
+            self.write("$ %s" % code)
+
+    @dispatch(testast.Assert)
+    def print_assert(self, ast):
+        self.indent()
+        self.write('assert %s' % ast.expr)
+
+    @dispatch(testast.Jump)
+    def print_jump(self, ast):
+        self.indent()
+        self.write('jump %s' % ast.target)
+
+    @dispatch(testast.Call)
+    def print_call(self, ast):
+        self.indent()
+        self.write('call %s' % ast.target)
+
+    @dispatch(testast.Action)
+    def print_action(self, ast):
+        self.indent()
+        self.write('run %s' % ast.expr)
+
+    @dispatch(testast.Pause)
+    def print_pause(self, ast):
+        self.indent()
+        self.write('pause %s' % ast.expr)
+
+    @dispatch(testast.Label)
+    def print_label(self, ast):
+        self.indent()
+        self.write('label %s' % ast.name)
+
+    @dispatch(testast.Type)
+    def print_type(self, ast):
+        self.indent()
+        if len(ast.keys[0]) == 1:
+            self.write('type "%s"' % string_escape(''.join(ast.keys)))
+        else:
+            self.write('type %s' % ast.keys[0])
+        if ast.pattern is not None:
+            self.write(' pattern "%s"' % string_escape(ast.pattern))
+        if hasattr(ast, 'position') and ast.position is not None:
+            self.write(' pos %s' % ast.position)
+
+    @dispatch(testast.Drag)
+    def print_drag(self, ast):
+        self.indent()
+        self.write('drag %s' % ast.points)
+        if ast.button != 1:
+            self.write(' button %d' % ast.button)
+        if ast.pattern is not None:
+            self.write(' pattern "%s"' % string_escape(ast.pattern))
+        if ast.steps != 10:
+            self.write(' steps %d' % ast.steps)
+
+    @dispatch(testast.Move)
+    def print_move(self, ast):
+        self.indent()
+        self.write('move %s' % ast.position)
+        if ast.pattern is not None:
+            self.write(' pattern "%s"' % string_escape(ast.pattern))
+
+    @dispatch(testast.Click)
+    def print_click(self, ast):
+        self.indent()
+        if ast.pattern is not None:
+            self.write('"%s"' % string_escape(ast.pattern))
+        else:
+            self.write('click')
+        if hasattr(ast, 'button') and ast.button != 1:
+            self.write(' button %d' % ast.button)
+        if hasattr(ast, 'position') and ast.position is not None:
+            self.write(' pos %s' % ast.position)
+        if hasattr(ast, 'always') and ast.always:
+            self.write(' always')
+
+    @dispatch(testast.Until)
+    def print_until(self, ast):
+        if hasattr(ast.right, 'linenumber'):
+            # We don't have our own line number, and it's not guaranteed that left has a line number.
+            # Go to right's line number now since we can't go to it after we print left.
+            self.advance_to_line(ast.right.linenumber)
+        self.print_node(ast.left)
+        self.write(' until ')
+        self.skip_indent_until_write = True
+        self.print_node(ast.right)

renpy/rpycdec/rpycdecdata/decompiler/translate.py

@@ -0,0 +1,158 @@
+# Copyright (c) 2016 Jackmcbarn
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+from util import say_get_code
+import renpy
+
+import hashlib
+import re
+from copy import copy
+
+class Translator(object):
+    def __init__(self, language, saving_translations=False):
+        self.language = language
+        self.saving_translations = saving_translations
+        self.strings = {}
+        self.dialogue = {}
+        self.identifiers = set()
+        self.alternate = None
+
+    # Adapted from Ren'Py's Restructurer.unique_identifier
+    def unique_identifier(self, label, digest):
+        if label is None:
+            base = digest
+        else:
+            base = label.replace(".", "_") + "_" + digest
+
+        i = 0
+        suffix = ""
+
+        while True:
+
+            identifier = base + suffix
+
+            if identifier not in self.identifiers:
+                break
+
+            i += 1
+            suffix = "_{0}".format(i)
+
+        return identifier
+
+    # Adapted from Ren'Py's Restructurer.create_translate
+    def create_translate(self, block):
+        if self.saving_translations:
+            return [] # Doesn't matter, since we're throwing this away in this case
+
+        md5 = hashlib.md5()
+
+        for i in block:
+            if isinstance(i, renpy.ast.Say):
+                code = say_get_code(i)
+            elif isinstance(i, renpy.ast.UserStatement):
+                code = i.line
+            else:
+                raise Exception("Don't know how to get canonical code for a %s" % str(type(i)))
+            md5.update(code.encode("utf-8") + b"\r\n")
+
+        digest = md5.hexdigest()[:8]
+
+        identifier = self.unique_identifier(self.label, digest)
+        self.identifiers.add(identifier)
+
+        if self.alternate is not None:
+            alternate = self.unique_identifier(self.alternate, digest)
+            self.identifiers.add(alternate)
+        else:
+            alternate = None
+
+        translated_block = self.dialogue.get(identifier)
+        if (translated_block is None) and alternate:
+            translated_block = self.dialogue.get(alternate)
+        if translated_block is None:
+            return block
+
+        new_block = []
+        old_linenumber = block[0].linenumber
+        for ast in translated_block:
+            new_ast = copy(ast)
+            new_ast.linenumber = old_linenumber
+            new_block.append(new_ast)
+        return new_block
+
+    def walk(self, ast, f):
+        if isinstance(ast, (renpy.ast.Init, renpy.ast.Label, renpy.ast.While, renpy.ast.Translate, renpy.ast.TranslateBlock)):
+            f(ast.block)
+        elif isinstance(ast, renpy.ast.Menu):
+            for i in ast.items:
+                if i[2] is not None:
+                    f(i[2])
+        elif isinstance(ast, renpy.ast.If):
+            for i in ast.entries:
+                f(i[1])
+
+    # Adapted from Ren'Py's Restructurer.callback
+    def translate_dialogue(self, children):
+        new_children = [ ]
+        group = [ ]
+
+        for i in children:
+
+            if isinstance(i, renpy.ast.Label):
+                if not (hasattr(i, 'hide') and i.hide):
+                    if i.name.startswith("_"):
+                        self.alternate = i.name
+                    else:
+                        self.label = i.name
+                        self.alternate = None
+
+            if self.saving_translations and isinstance(i, renpy.ast.TranslateString) and i.language == self.language:
+                self.strings[i.old] = i.new
+
+            if not isinstance(i, renpy.ast.Translate):
+                self.walk(i, self.translate_dialogue)
+            elif self.saving_translations and i.language == self.language:
+                self.dialogue[i.identifier] = i.block
+                if hasattr(i, 'alternate') and i.alternate is not None:
+                    self.dialogue[i.alternate] = i.block
+
+            if isinstance(i, renpy.ast.Say):
+                group.append(i)
+                tl = self.create_translate(group)
+                new_children.extend(tl)
+                group = [ ]
+
+            elif hasattr(i, 'translatable') and i.translatable:
+                group.append(i)
+
+            else:
+                if group:
+                    tl = self.create_translate(group)
+                    new_children.extend(tl)
+                    group = [ ]
+
+                new_children.append(i)
+
+        if group:
+            nodes = self.create_translate(group)
+            new_children.extend(nodes)
+            group = [ ]
+
+        children[:] = new_children

renpy/rpycdec/rpycdecdata/decompiler/util.py

@@ -0,0 +1,502 @@
+from __future__ import unicode_literals
+import sys
+import re
+from StringIO import StringIO
+from contextlib import contextmanager
+
+class DecompilerBase(object):
+    def __init__(self, out_file=None, indentation='    ', printlock=None):
+        self.out_file = out_file or sys.stdout
+        self.indentation = indentation
+        self.skip_indent_until_write = False
+        self.printlock = printlock
+
+        self.linenumber = 0
+
+        self.block_stack = []
+        self.index_stack = []
+        self.blank_line_queue = []
+
+    def dump(self, ast, indent_level=0, linenumber=1, skip_indent_until_write=False):
+        """
+        Write the decompiled representation of `ast` into the opened file given in the constructor
+        """
+        self.indent_level = indent_level
+        self.linenumber = linenumber
+        self.skip_indent_until_write = skip_indent_until_write
+        if not isinstance(ast, (tuple, list)):
+            ast = [ast]
+        self.print_nodes(ast)
+        return self.linenumber
+
+    @contextmanager
+    def increase_indent(self, amount=1):
+        self.indent_level += amount
+        try:
+            yield
+        finally:
+            self.indent_level -= amount
+
+    def write(self, string):
+        """
+        Shorthand method for writing `string` to the file
+        """
+        string = unicode(string)
+        self.linenumber += string.count('\n')
+        self.skip_indent_until_write = False
+        self.out_file.write(string)
+
+    def write_lines(self, lines):
+        """
+        Write each line in lines to the file without writing whitespace-only lines
+        """
+        for line in lines:
+            if line == '':
+                self.write('\n')
+            else:
+                self.indent()
+                self.write(line)
+
+    def save_state(self):
+        """
+        Save our current state.
+        """
+        state = (self.out_file, self.skip_indent_until_write, self.linenumber,
+            self.block_stack, self.index_stack, self.indent_level, self.blank_line_queue)
+        self.out_file = StringIO()
+        return state
+
+    def commit_state(self, state):
+        """
+        Commit changes since a saved state.
+        """
+        out_file = state[0]
+        out_file.write(self.out_file.getvalue())
+        self.out_file = out_file
+
+    def rollback_state(self, state):
+        """
+        Roll back to a saved state.
+        """
+        (self.out_file, self.skip_indent_until_write, self.linenumber,
+            self.block_stack, self.index_stack, self.indent_level, self.blank_line_queue) = state
+
+    def advance_to_line(self, linenumber):
+        # If there was anything that we wanted to do as soon as we found a blank line,
+        # try to do it now.
+        self.blank_line_queue = filter(lambda m: m(linenumber), self.blank_line_queue)
+        if self.linenumber < linenumber:
+            # Stop one line short, since the call to indent() will advance the last line.
+            # Note that if self.linenumber == linenumber - 1, this will write the empty string.
+            # This is to make sure that skip_indent_until_write is cleared in that case.
+            self.write("\n" * (linenumber - self.linenumber - 1))
+
+    def do_when_blank_line(self, m):
+        """
+        Do something the next time we find a blank line. m should be a method that takes one
+        parameter (the line we're advancing to), and returns whether or not it needs to run
+        again.
+        """
+        self.blank_line_queue.append(m)
+
+    def indent(self):
+        """
+        Shorthand method for pushing a newline and indenting to the proper indent level
+        Setting skip_indent_until_write causes calls to this method to be ignored until something
+        calls the write method
+        """
+        if not self.skip_indent_until_write:
+            self.write('\n' + self.indentation * self.indent_level)
+
+    def print_nodes(self, ast, extra_indent=0):
+        # This node is a list of nodes
+        # Print every node
+        with self.increase_indent(extra_indent):
+            self.block_stack.append(ast)
+            self.index_stack.append(0)
+
+            for i, node in enumerate(ast):
+                self.index_stack[-1] = i
+                self.print_node(node)
+
+            self.block_stack.pop()
+            self.index_stack.pop()
+
+    @property
+    def block(self):
+        return self.block_stack[-1]
+
+    @property
+    def index(self):
+        return self.index_stack[-1]
+
+    @property
+    def parent(self):
+        if len(self.block_stack) < 2:
+            return None
+        return self.block_stack[-2][self.index_stack[-2]]
+
+    def print_debug(self, message):
+        if self.printlock:
+            self.printlock.acquire()
+        try:
+            print(message)
+        finally:
+            if self.printlock:
+                self.printlock.release()
+
+    def write_failure(self, message):
+        self.print_debug(message)
+        self.indent()
+        self.write("pass # <<<COULD NOT DECOMPILE: %s>>>" % message)
+
+    def print_unknown(self, ast):
+        # If we encounter a placeholder note, print a warning and insert a placeholder
+        self.write_failure("Unknown AST node: %s" % str(type(ast)))
+
+    def print_node(self, ast):
+        raise NotImplementedError()
+
+class First(object):
+    # An often used pattern is that on the first item
+    # of a loop something special has to be done. This class
+    # provides an easy object which on the first access
+    # will return True, but any subsequent accesses False
+    def __init__(self, yes_value=True, no_value=False):
+        self.yes_value = yes_value
+        self.no_value = no_value
+        self.first = True
+
+    def __call__(self):
+        if self.first:
+            self.first = False
+            return self.yes_value
+        else:
+            return self.no_value
+
+def reconstruct_paraminfo(paraminfo):
+    if paraminfo is None:
+        return ""
+
+    rv = ["("]
+
+    sep = First("", ", ")
+    positional = [i for i in paraminfo.parameters if i[0] in paraminfo.positional]
+    nameonly = [i for i in paraminfo.parameters if i not in positional]
+    for parameter in positional:
+        rv.append(sep())
+        rv.append(parameter[0])
+        if parameter[1] is not None:
+            rv.append("=%s" % parameter[1])
+    if paraminfo.extrapos:
+        rv.append(sep())
+        rv.append("*%s" % paraminfo.extrapos)
+    if nameonly:
+        if not paraminfo.extrapos:
+            rv.append(sep())
+            rv.append("*")
+        for parameter in nameonly:
+            rv.append(sep())
+            rv.append(parameter[0])
+            if parameter[1] is not None:
+                rv.append("=%s" % parameter[1])
+    if paraminfo.extrakw:
+        rv.append(sep())
+        rv.append("**%s" % paraminfo.extrakw)
+
+    rv.append(")")
+
+    return "".join(rv)
+
+def reconstruct_arginfo(arginfo):
+    if arginfo is None:
+        return ""
+
+    rv = ["("]
+    sep = First("", ", ")
+    for (name, val) in arginfo.arguments:
+        rv.append(sep())
+        if name is not None:
+            rv.append("%s=" % name)
+        rv.append(val)
+    if arginfo.extrapos:
+        rv.append(sep())
+        rv.append("*%s" % arginfo.extrapos)
+    if arginfo.extrakw:
+        rv.append(sep())
+        rv.append("**%s" % arginfo.extrakw)
+    rv.append(")")
+
+    return "".join(rv)
+
+def string_escape(s): # TODO see if this needs to work like encode_say_string elsewhere
+    s = s.replace('\\', '\\\\')
+    s = s.replace('"', '\\"')
+    s = s.replace('\n', '\\n')
+    s = s.replace('\t', '\\t')
+    return s
+
+# keywords used by ren'py's parser
+KEYWORDS = set(['$', 'as', 'at', 'behind', 'call', 'expression', 'hide',
+                'if', 'in', 'image', 'init', 'jump', 'menu', 'onlayer',
+                'python', 'return', 'scene', 'set', 'show', 'with',
+                'while', 'zorder', 'transform'])
+
+word_regexp = '[a-zA-Z_\u00a0-\ufffd][0-9a-zA-Z_\u00a0-\ufffd]*'
+
+def simple_expression_guard(s):
+    # Some things we deal with are supposed to be parsed by
+    # ren'py's Lexer.simple_expression but actually cannot
+    # be parsed by it. figure out if this is the case
+    # a slightly more naive approach woudl be to check
+    # for spaces in it and surround it with () if necessary
+    # but we're not naive
+    s = s.strip()
+
+    if Lexer(s).simple_expression():
+        return s
+    else:
+        return "(%s)" % s
+
+def split_logical_lines(s):
+    return Lexer(s).split_logical_lines()
+
+class Lexer(object):
+    # special lexer for simple_expressions the ren'py way
+    # false negatives aren't dangerous. but false positives are
+    def __init__(self, string):
+        self.pos = 0
+        self.length = len(string)
+        self.string = string
+
+    def re(self, regexp):
+        # see if regexp matches at self.string[self.pos].
+        # if it does, increment self.pos
+        if self.length == self.pos:
+            return None
+
+        match = re.compile(regexp, re.DOTALL).match(self.string, self.pos)
+        if not match:
+            return None
+
+        self.pos = match.end()
+        return match.group(0)
+
+    def eol(self):
+        # eat the next whitespace and check for the end of this simple_expression
+        self.re(r"(\s+|\\\n)+")
+        return self.pos >= self.length
+
+    def match(self, regexp):
+        # strip whitespace and match regexp
+        self.re(r"(\s+|\\\n)+")
+        return self.re(regexp)
+
+    def python_string(self, clear_whitespace=True):
+        # parse strings the ren'py way (don't parse docstrings, no b/r in front allowed)
+        # edit: now parses docstrings correctly. There was a degenerate case where '''string'string''' would
+        # result in issues
+        if clear_whitespace:
+            return self.match(r"""(u?(?P<a>"(?:"")?|'(?:'')?).*?(?<=[^\\])(?:\\\\)*(?P=a))""")
+        else:
+            return self.re(r"""(u?(?P<a>"(?:"")?|'(?:'')?).*?(?<=[^\\])(?:\\\\)*(?P=a))""")
+
+
+    def container(self):
+        # parses something enclosed by [], () or {}'s. keyword something
+        containers = {"{": "}", "[": "]", "(": ")"}
+        if self.eol():
+            return None
+
+        c = self.string[self.pos]
+        if c not in containers:
+            return None
+        self.pos += 1
+
+        c = containers[c]
+
+        while not self.eol():
+            if c == self.string[self.pos]:
+                self.pos += 1
+                return True
+
+            if self.python_string() or self.container():
+                continue
+
+            self.pos += 1
+
+        return None
+
+    def number(self):
+        # parses a number, float or int (but not forced long)
+        return self.match(r'(\+|\-)?(\d+\.?\d*|\.\d+)(?:[eE][-+]?\d+)?')
+
+    def word(self):
+        # parses a word
+        return self.match(word_regexp)
+
+    def name(self):
+        # parses a word unless it's in KEYWORDS.
+        pos = self.pos
+        word = self.word()
+
+        if word in KEYWORDS:
+            self.pos = pos
+            return None
+
+        return word
+
+    def simple_expression(self):
+        # test if the start string was a simple expression
+        start = self.pos
+
+        # check if there's anything in here acctually
+        if self.eol():
+            return False
+
+        # parse anything which can be called or have attributes requested
+        if not(self.python_string() or
+               self.number() or
+               self.container() or
+               self.name()):
+            return False
+
+        while not self.eol():
+
+            # if the previous was followed by a dot, there should be a word after it
+            if self.match(r'\.'):
+                if not self.name():
+                    # ren'py errors here. I just stop caring
+                    return False
+
+                continue
+
+            # parses slices, function calls, and postfix {}
+            if self.container():
+                continue
+
+            break
+
+            # are we at the end of the simple expression?
+        return self.eol()
+
+    def split_logical_lines(self):
+        # split a sequence in logical lines
+        # this behaves similarly to .splitlines() which will ignore
+        # a trailing \n
+        lines = []
+
+        contained = 0
+
+        startpos = self.pos
+
+        while self.pos < self.length:
+            c = self.string[self.pos]
+
+            if c == '\n' and not contained and (not self.pos or self.string[self.pos - 1] != '\\'):
+                lines.append(self.string[startpos:self.pos])
+                # the '\n' is not included in the emitted line
+                self.pos += 1
+                startpos = self.pos
+                continue
+
+            if c in ('(', '[', '{'):
+                contained += 1
+                self.pos += 1
+                continue
+
+            if c in (')', ']', '}') and contained:
+                contained -= 1
+                self.pos += 1
+                continue
+
+            if c == '#':
+                self.re("[^\n]*")
+                continue
+
+            if self.python_string(False):
+                continue
+
+            self.re(r'\w+| +|.') # consume a word, whitespace or one symbol
+
+        if self.pos != startpos:
+            lines.append(self.string[startpos:])
+        return lines
+
+# Versions of Ren'Py prior to 6.17 put trailing whitespace on the end of
+# simple_expressions. This class attempts to preserve the amount of
+# whitespace if possible.
+class WordConcatenator(object):
+    def __init__(self, needs_space, reorderable=False):
+        self.words = []
+        self.needs_space = needs_space
+        self.reorderable = reorderable
+
+    def append(self, *args):
+        self.words.extend(filter(None, args))
+
+    def join(self):
+        if not self.words:
+            return ''
+        if self.reorderable and self.words[-1][-1] == ' ':
+            for i in xrange(len(self.words) - 1, -1, -1):
+                if self.words[i][-1] != ' ':
+                    self.words.append(self.words.pop(i))
+                    break
+        last_word = self.words[-1]
+        self.words = map(lambda x: x[:-1] if x[-1] == ' ' else x, self.words[:-1])
+        self.words.append(last_word)
+        rv = (' ' if self.needs_space else '') + ' '.join(self.words)
+        self.needs_space = rv[-1] != ' '
+        return rv
+
+# Dict subclass for aesthetic dispatching. use @Dispatcher(data) to dispatch
+class Dispatcher(dict):
+    def __call__(self, name):
+        def closure(func):
+            self[name] = func
+            return func
+        return closure
+
+# ren'py string handling
+def encode_say_string(s):
+    """
+    Encodes a string in the format used by Ren'Py say statements.
+    """
+
+    s = s.replace("\\", "\\\\")
+    s = s.replace("\n", "\\n")
+    s = s.replace("\"", "\\\"")
+    s = re.sub(r'(?<= ) ', '\\ ', s)
+
+    return "\"" + s + "\""
+
+# Adapted from Ren'Py's Say.get_code
+def say_get_code(ast, inmenu=False):
+    rv = [ ]
+
+    if ast.who:
+        rv.append(ast.who)
+
+    if hasattr(ast, 'attributes') and ast.attributes is not None:
+        rv.extend(ast.attributes)
+
+    if hasattr(ast, 'temporary_attributes') and ast.temporary_attributes is not None:
+        rv.append("@")
+        rv.extend(ast.temporary_attributes)
+
+    # no dialogue_filter applies to us
+
+    rv.append(encode_say_string(ast.what))
+
+    if not ast.interact and not inmenu:
+        rv.append("nointeract")
+
+    if ast.with_:
+        rv.append("with")
+        rv.append(ast.with_)
+
+    if hasattr(ast, 'arguments') and ast.arguments is not None:
+        rv.append(reconstruct_arginfo(ast.arguments))
+
+    return " ".join(rv)

renpy/rpycdec/rpycdecdata/deobfuscate.py

@@ -0,0 +1,347 @@
+# Copyright (c) 2021 CensoredUsername
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+
+
+# This file contains documented strategies used against known obfuscation techniques and some machinery
+# to test them against.
+
+# Architecture is pretty simple. There's at least two steps in unpacking the rpyc format.
+# RPYC2 is an archive format that can contain multiple streams (referred to as slots)
+# The first step is extracting the slot from it, which is done by one of the extractors.
+# These all give a blob that's either still zlib-compressed or just the raw slot
+# (some methods rely on the zlib compression to figure out the slot length)
+# Then, there's 0 or more steps of decrypting the data in that slot. This ends up often
+# being layers of base64, string-escape, hex-encoding, zlib-compression, etc.
+# We handle this by just trying these by checking if they fit.
+
+import os
+import zlib
+import struct
+import base64
+from collections import Counter
+from decompiler import magic
+import unrpyc
+
+
+# Extractors are simple functions of (fobj, slotno) -> bytes
+# They raise ValueError if they fail
+EXTRACTORS = []
+def extractor(f):
+    EXTRACTORS.append(f)
+    return f
+
+# Decryptors are simple functions of (bytes, Counter) ->bytes
+# They return None if they fail. If they return their input they're also considered to have failed.
+DECRYPTORS = []
+def decryptor(f):
+    DECRYPTORS.append(f)
+    return f
+
+
+# Add game-specific custom extraction / decryption logic here
+
+# End of custom extraction/decryption logic
+
+
+@extractor
+def extract_slot_rpyc(f, slot):
+    """
+    Slot extractor for a file that's in the actual rpyc format
+    """
+    f.seek(0)
+    data = f.read()
+    if data[:10] != "RENPY RPYC":
+        raise ValueError("Incorrect Header")
+
+    position = 10
+    slots = {}
+
+    while position + 12 <= len(data):
+        slotid, start, length = struct.unpack("<III", data[position : position + 12])
+        if (slotid, start, length) == (0, 0, 0):
+            break
+
+        if start + length >= len(data):
+            raise ValueError("Broken slot entry")
+
+        slots[slotid] = (start, length)
+        position += 12
+    else:
+        raise ValueError("Broken slot header structure")
+
+    if slot not in slots:
+        raise ValueError("Unknown slot id")
+
+    start, length = slots[slot]
+    return data[start : start + length]
+
+@extractor
+def extract_slot_legacy(f, slot):
+    """
+    Slot extractor for the legacy format
+    """
+    if slot != 1:
+        raise ValueError("Legacy format only supports 1 slot")
+
+    f.seek(0)
+    data = f.read()
+
+    try:
+        data = zlib.decompress(data)
+    except zlib.error:
+        raise ValueError("Legacy format did not contain a zlib blob")
+
+    return data
+
+@extractor
+def extract_slot_headerscan(f, slot):
+    """
+    Slot extractor for things that changed the magic and so moved the header around.
+    """
+    f.seek(0)
+    data = f.read()
+
+    position = 0
+    while position + 36 < len(data):
+        a,b,c,d,e,f,g,h,i = struct.unpack("<IIIIIIIII", data[position : position + 36])
+        if a == 1 and d == 2 and g == 0 and b + c == e:
+            break;
+        position += 1
+
+    else:
+        raise ValueError("Couldn't find a header")
+
+    slots = {}
+    while position + 12 <= len(data):
+        slotid, start, length = struct.unpack("<III", data[position : position + 12])
+        if (slotid, start, length) == (0, 0, 0):
+            break
+
+        if start + length >= len(data):
+            raise ValueError("Broken slot entry")
+
+        slots[slotid] = (start, length)
+        position += 12
+    else:
+        raise ValueError("Broken slot header structure")
+
+    if slot not in slots:
+        raise ValueError("Unknown slot id")
+
+    start, length = slots[slot]
+    return data[start : start + length]
+
+@extractor
+def extract_slot_zlibscan(f, slot):
+    """
+    Slot extractor for things that fucked with the header structure to the point where it's easier
+    to just not bother with it and instead we just look for valid zlib chunks directly.
+    """
+    f.seek(0)
+    data = f.read()
+
+    start_positions = []
+
+    for i in range(len(data) - 1):
+        if data[i] != "\x78":
+            continue
+
+        if (ord(data[i]) * 256 + ord(data[i + 1])) % 31 != 0:
+            continue
+
+        start_positions.append(i)
+
+    chunks = []
+    for position in start_positions:
+        try:
+            chunk = zlib.decompress(data[position:])
+        except zlib.error:
+            continue
+        chunks.append(chunk)
+
+    if slot > len(chunks):
+        raise ValueError("Zlibscan did not find enough chunks")
+
+    return chunks[slot - 1]
+
+
+@decryptor
+def decrypt_zlib(data, count):
+    try:
+        return zlib.decompress(data)
+    except zlib.error:
+        return None
+
+@decryptor
+def decrypt_hex(data, count):
+    if not all(i in "abcdefABCDEF0123456789" for i in count.keys()):
+        return None
+    try:
+        return data.decode("hex")
+    except Exception:
+        return None
+
+@decryptor
+def decrypt_base64(data, count):
+    if not all(i in "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+/=\n" for i in count.keys()):
+        return None
+    try:
+        return base64.b64decode(data)
+    except Exception:
+        return None
+
+@decryptor
+def decrypt_string_escape(data, count):
+    if not all(ord(i) >= 0x20 and ord(i) < 0x80 for i in count.keys()):
+        return None
+    try:
+        newdata = data.decode("string-escape")
+    except Exception:
+        return None
+    if newdata == data:
+        return None
+    return newdata
+
+
+def assert_is_normal_rpyc(f):
+    """
+    Analyze the structure of a single rpyc file object for correctness.
+    Does not actually say anything about the _contents_ of that section, just that we were able
+    to slice it out of there.
+
+    If succesful, returns the uncompressed contents of the first storage slot.
+    """
+
+    diagnosis = []
+
+    f.seek(0)
+    header = f.read(1024)
+    f.seek(0)
+
+    if header_data[:10] != "RENPY RPC2":
+        # either legacy, or someone messed with the header
+
+        # assuming legacy, see if this thing is a valid zlib blob
+        raw_data = f.read()
+        f.seek(0)
+
+        try:
+            uncompressed = zlib.decompress(raw_data)
+        except zlib.error:
+            raise ValueError("Did not find RENPY RPC2 header, but interpretation as legacy file failed")
+
+        return uncompressed
+
+
+    else:
+        if len(header) < 46:
+            # 10 bytes header + 4 * 9 bytes content table
+            return ValueError("File too short")
+
+        a,b,c,d,e,f,g,h,i = struct.unpack("<IIIIIIIII", raw_contents[header + 10 : header + 46])
+
+        # does the header format match default ren'py generated files?
+        if not (a == 1 and b == 46 and d == 2 and (g, h, i) == (0, 0, 0) and b + c == e):
+            return ValueError("Header data is abnormal, did the format gain extra fields?")
+
+        f.seek(b)
+        raw_data = f.read(c)
+        f.seek(0)
+        if len(raw_data) != c:
+            return ValueError("Header data is incompatible with file length")
+
+        try:
+            uncompressed = zlib.decompress(raw_data)
+        except zlib.error:
+            return ValueError("Slot 1 did not contain a zlib blob")
+
+        if not uncompressed.endswith("."):
+            return ValueError("Slot 1 did not contain a simple pickle")
+
+        return uncompressed
+
+
+def read_ast(f):
+    diagnosis = ["Attempting to deobfuscate file:"]
+
+    raw_datas = set()
+
+    for extractor in EXTRACTORS:
+        try:
+            data = extractor(f, 1)
+        except ValueError as e:
+            diagnosis.append("strategy %s failed: %s" % (extractor.__name__, e.message))
+        else:
+            diagnosis.append("strategy %s success" % extractor.__name__)
+            raw_datas.add(data)
+
+    if not raw_datas:
+        diagnosis.append("All strategies failed. Unable to extract data")
+        raise ValueError("\n".join(diagnosis))
+
+    if len(raw_datas) != 1:
+        diagnosis.append("Strategies produced different results. Trying all options")
+
+    data = None
+    for raw_data in raw_datas:
+        try:
+            data, stmts, d = try_decrypt_section(raw_data)
+        except ValueError as e:
+            diagnosis.append(e.message)
+        else:
+            diagnosis.extend(d)
+            with unrpyc.printlock:
+                print("\n".join(diagnosis))
+            return stmts
+
+    diagnosis.append("All strategies failed. Unable to deobfuscate data")
+    raise ValueError("\n".join(diagnosis))
+
+
+def try_decrypt_section(raw_data):
+    diagnosis = []
+
+    layers = 0
+    while layers < 10:
+        # can we load it yet?
+        try:
+            data, stmts = magic.safe_loads(raw_data, unrpyc.class_factory, {"_ast", "collections"})
+        except Exception:
+            pass
+        else:
+            return data, stmts, diagnosis
+
+        layers += 1
+        count = Counter(raw_data)
+
+        for decryptor in DECRYPTORS:
+            newdata = decryptor(raw_data, count)
+            if newdata is None:
+                continue
+            else:
+                raw_data = newdata
+                diagnosis.append("performed a round of %s" % decryptor.__name__)
+                break
+        else:
+            break
+
+    diagnosis.append("Did not know how to decrypt data.")
+    raise ValueError("\n".join(diagnosis))

renpy/rpycdec/rpycdecdata/unrpyc.py

@@ -0,0 +1,301 @@
+#!/usr/bin/env python2
+
+# Copyright (c) 2012 Yuri K. Schlesner
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+import argparse
+import os
+from os import path, walk
+import codecs
+import glob
+import itertools
+import traceback
+import struct
+from operator import itemgetter
+import sys
+sys.path.append(os.path.join(sys.path[0], '../'))
+import decompiler
+from decompiler import magic, astdump, translate
+
+# special definitions for special classes
+
+class PyExpr(magic.FakeStrict, unicode):
+    __module__ = "renpy.ast"
+    def __new__(cls, s, filename, linenumber):
+        self = unicode.__new__(cls, s)
+        self.filename = filename
+        self.linenumber = linenumber
+        return self
+
+    def __getnewargs__(self):
+        return unicode(self), self.filename, self.linenumber
+
+class PyCode(magic.FakeStrict):
+    __module__ = "renpy.ast"
+    def __setstate__(self, state):
+        (_, self.source, self.location, self.mode) = state
+        self.bytecode = None
+
+class RevertableList(magic.FakeStrict, list):
+    __module__ = "renpy.python"
+    def __new__(cls):
+        return list.__new__(cls)
+
+class RevertableDict(magic.FakeStrict, dict):
+    __module__ = "renpy.python"
+    def __new__(cls):
+        return dict.__new__(cls)
+
+class RevertableSet(magic.FakeStrict, set):
+    __module__ = "renpy.python"
+    def __new__(cls):
+        return set.__new__(cls)
+
+    def __setstate__(self, state):
+        if isinstance(state, tuple):
+            self.update(state[0].keys())
+        else:
+            self.update(state)
+
+class Sentinel(magic.FakeStrict, object):
+    __module__ = "renpy.object"
+    def __new__(cls, name):
+        obj = object.__new__(cls)
+        obj.name = name
+        return obj
+
+class_factory = magic.FakeClassFactory((PyExpr, PyCode, RevertableList, RevertableDict, RevertableSet, Sentinel), magic.FakeStrict)
+
+# needs class_factory
+import deobfuscate
+
+# API
+
+def read_ast_from_file(in_file):
+    # .rpyc files are just zlib compressed pickles of a tuple of some data and the actual AST of the file
+    raw_contents = in_file.read()
+    if raw_contents.startswith("RENPY RPC2"):
+        # parse the archive structure
+        position = 10
+        chunks = {}
+        while True:
+            slot, start, length = struct.unpack("III", raw_contents[position: position + 12])
+            if slot == 0:
+                break
+            position += 12
+
+            chunks[slot] = raw_contents[start: start + length]
+
+        raw_contents = chunks[1]
+
+    raw_contents = raw_contents.decode('zlib')
+    data, stmts = magic.safe_loads(raw_contents, class_factory, {"_ast", "collections"})
+    return stmts
+
+
+def decompile_rpyc(input_filename, overwrite=False, dump=False, decompile_python=False,
+                   comparable=False, no_pyexpr=False, translator=None, tag_outside_block=False,
+                   init_offset=False, try_harder=False):
+    # Output filename is input filename but with .rpy extension
+    filepath, ext = path.splitext(input_filename)
+    if dump:
+        out_filename = filepath + ".txt"
+    elif ext == ".rpymc":
+        out_filename = filepath + ".rpym"
+    else:
+        out_filename = filepath + ".rpy"
+
+    print("Decompiling %s to %s..." % (input_filename, out_filename))
+
+    if not overwrite and path.exists(out_filename):
+        print("Output file already exists. Pass --clobber to overwrite.")
+        return False # Don't stop decompiling if one file already exists
+
+    with open(input_filename, 'rb') as in_file:
+        if try_harder:
+            ast = deobfuscate.read_ast(in_file)
+        else:
+            ast = read_ast_from_file(in_file)
+
+    with codecs.open(out_filename, 'w', encoding='utf-8') as out_file:
+        if dump:
+            astdump.pprint(out_file, ast, decompile_python=decompile_python, comparable=comparable,
+                                          no_pyexpr=no_pyexpr)
+        else:
+            decompiler.pprint(out_file, ast, decompile_python=decompile_python, printlock=False,
+                                             translator=translator, tag_outside_block=tag_outside_block,
+                                             init_offset=init_offset)
+    return True
+
+def extract_translations(input_filename, language):
+    print("Extracting translations from %s..." % input_filename)
+
+    with open(input_filename, 'rb') as in_file:
+        ast = read_ast_from_file(in_file)
+
+    translator = translate.Translator(language, True)
+    translator.translate_dialogue(ast)
+    # we pickle and unpickle this manually because the regular unpickler will choke on it
+    return magic.safe_dumps(translator.dialogue), translator.strings
+
+def worker(t):
+    (args, filename, filesize) = t
+    try:
+        if args.write_translation_file:
+            return extract_translations(filename, args.language)
+        else:
+            if args.translation_file is not None:
+                translator = translate.Translator(None)
+                translator.language, translator.dialogue, translator.strings = magic.loads(args.translations, class_factory)
+            else:
+                translator = None
+            return decompile_rpyc(filename, args.clobber, args.dump, decompile_python=args.decompile_python,
+                                  no_pyexpr=args.no_pyexpr, comparable=args.comparable, translator=translator,
+                                  tag_outside_block=args.tag_outside_block, init_offset=args.init_offset, try_harder=args.try_harder)
+    except Exception as e:
+        print("Error while decompiling %s:" % filename)
+        print(traceback.format_exc())
+        return False
+
+def main():
+    # python27 unrpyc.py [-c] [-d] [--python-screens|--ast-screens|--no-screens] file [file ...]
+    parser = argparse.ArgumentParser(description="Decompile .rpyc/.rpymc files")
+
+    parser.add_argument('-c', '--clobber', dest='clobber', action='store_true',
+                        help="overwrites existing output files")
+
+    parser.add_argument('-d', '--dump', dest='dump', action='store_true',
+                        help="instead of decompiling, pretty print the ast to a file")
+
+    parser.add_argument('-p', '--processes', dest='processes', action='store', default=1,
+                        help="use the specified number of processes to decompile")
+
+    parser.add_argument('-t', '--translation-file', dest='translation_file', action='store', default=None,
+                        help="use the specified file to translate during decompilation")
+
+    parser.add_argument('-T', '--write-translation-file', dest='write_translation_file', action='store', default=None,
+                        help="store translations in the specified file instead of decompiling")
+
+    parser.add_argument('-l', '--language', dest='language', action='store', default='english',
+                        help="if writing a translation file, the language of the translations to write")
+
+    parser.add_argument('--sl1-as-python', dest='decompile_python', action='store_true',
+                        help="Only dumping and for decompiling screen language 1 screens. "
+                        "Convert SL1 Python AST to Python code instead of dumping it or converting it to screenlang.")
+
+    parser.add_argument('--comparable', dest='comparable', action='store_true',
+                        help="Only for dumping, remove several false differences when comparing dumps. "
+                        "This suppresses attributes that are different even when the code is identical, such as file modification times. ")
+
+    parser.add_argument('--no-pyexpr', dest='no_pyexpr', action='store_true',
+                        help="Only for dumping, disable special handling of PyExpr objects, instead printing them as strings. "
+                        "This is useful when comparing dumps from different versions of Ren'Py. "
+                        "It should only be used if necessary, since it will cause loss of information such as line numbers.")
+
+    parser.add_argument('--tag-outside-block', dest='tag_outside_block', action='store_true',
+                        help="Always put SL2 'tag's on the same line as 'screen' rather than inside the block. "
+                        "This will break compiling with Ren'Py 7.3 and above, but is needed to get correct line numbers "
+                        "from some files compiled with older Ren'Py versions.")
+
+    parser.add_argument('--init-offset', dest='init_offset', action='store_true',
+                        help="Attempt to guess when init offset statements were used and insert them. "
+                        "This is always safe to enable if the game's Ren'Py version supports init offset statements, "
+                        "and the generated code is exactly equivalent, only less cluttered.")
+
+    parser.add_argument('file', type=str, nargs='+',
+                        help="The filenames to decompile. "
+                        "All .rpyc files in any directories passed or their subdirectories will also be decompiled.")
+
+    parser.add_argument('--try-harder', dest="try_harder", action="store_true",
+                        help="Tries some workarounds against common obfuscation methods. This is a lot slower.")
+
+    args = parser.parse_args()
+
+    if args.write_translation_file and not args.clobber and path.exists(args.write_translation_file):
+        # Fail early to avoid wasting time going through the files
+        print("Output translation file already exists. Pass --clobber to overwrite.")
+        return
+
+    if args.translation_file:
+        with open(args.translation_file, 'rb') as in_file:
+            args.translations = in_file.read()
+
+    # Expand wildcards
+    def glob_or_complain(s):
+        retval = glob.glob(s)
+        if not retval:
+            print("File not found: " + s)
+        return retval
+    filesAndDirs = map(glob_or_complain, args.file)
+    # Concatenate lists
+    filesAndDirs = list(itertools.chain(*filesAndDirs))
+
+    # Recursively add .rpyc files from any directories passed
+    files = []
+    for i in filesAndDirs:
+        if path.isdir(i):
+            for dirpath, dirnames, filenames in walk(i):
+                files.extend(path.join(dirpath, j) for j in filenames if len(j) >= 5 and j.endswith(('.rpyc', '.rpymc')))
+        else:
+            files.append(i)
+
+    # Check if we actually have files. Don't worry about
+    # no parameters passed, since ArgumentParser catches that
+    if len(files) == 0:
+        print("No script files to decompile.")
+        return
+
+    files = map(lambda x: (args, x, path.getsize(x)), files)
+    processes = int(args.processes)
+
+    # Decompile in the order Ren'Py loads in
+    files.sort(key=itemgetter(1))
+    results = map(worker, files)
+
+    if args.write_translation_file:
+        print("Writing translations to %s..." % args.write_translation_file)
+        translated_dialogue = {}
+        translated_strings = {}
+        good = 0
+        bad = 0
+        for result in results:
+            if not result:
+                bad += 1
+                continue
+            good += 1
+            translated_dialogue.update(magic.loads(result[0], class_factory))
+            translated_strings.update(result[1])
+        with open(args.write_translation_file, 'wb') as out_file:
+            magic.safe_dump((args.language, translated_dialogue, translated_strings), out_file)
+
+    else:
+        # Check per file if everything went well and report back
+        good = results.count(True)
+        bad = results.count(False)
+
+    if bad == 0:
+        print("Decompilation of %d script file%s successful" % (good, 's' if good>1 else ''))
+    elif good == 0:
+        print("Decompilation of %d file%s failed" % (bad, 's' if bad>1 else ''))
+    else:
+        print("Decompilation of %d file%s successful, but decompilation of %d file%s failed" % (good, 's' if good>1 else '', bad, 's' if bad>1 else ''))
+
+if __name__ == '__main__':
+    main()