renpy/rpycdec/rpycdecdata/decompiler/sl2decompiler.py

# 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)