File size: 17,481 Bytes
b8e81f8 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 |
# 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)
|