ben
/
func-smash
miroir de https://github.com/earwig/func-smash
1
1
Bifurcation 0
Code Versions 0 Activité
Generates random Python functions using Markov chains
Vous ne pouvez pas sélectionner plus de 25 sujets Les noms de sujets doivent commencer par une lettre ou un nombre, peuvent contenir des tirets ('-') et peuvent comporter jusqu'à 35 caractères.
26 Révisions
1 Branche
74 KiB
 
Aborescence: cc734344a8
Branches Tags
${ item.name }
Créer la branche ${ searchTerm }
de 'cc734344a8'
${ noResults }
func-smash/prettify.py

227 lignes
7.7 KiB
Brut Annotations Historique 

  1. import opcode

  2. import sys

  3. 

  4. import func_smash

  5. 

  6. OP_LOAD = {"LOAD_CONST": True, "LOAD_FAST": False, "LOAD_GLOBAL": False}

  7. OP_BINARY = {"BINARY_POWER": "**", "BINARY_MULTIPLY": "*",

  8.              "BINARY_DIVIDE": "/", "BINARY_MODULO": "%", "BINARY_ADD": "+",

  9.              "BINARY_SUBTRACT": "-", "BINARY_FLOOR_DIVIDE": "//",

  10.              "BINARY_TRUE_DIVIDE": "/", "BINARY_LSHIFT": "<<",

  11.              "BINARY_RSHIFT": ">>", "BINARY_AND": "&", "BINARY_XOR": "^",

  12.              "BINARY_OR": "|"}

  13. OP_INPLACE = {"INPLACE_FLOOR_DIVIDE": "//", "INPLACE_TRUE_DIVIDE": "/",

  14.               "INPLACE_ADD": "+", "INPLACE_SUBTRACT": "-",

  15.               "INPLACE_MULTIPLY": "*", "INPLACE_DIVIDE": "/",

  16.               "INPLACE_MODULO": "%", "INPLACE_POWER": "**",

  17.               "INPLACE_LSHIFT": "<<", "INPLACE_RSHIFT": ">>",

  18.               "INPLACE_AND": "&", "INPLACE_XOR": "^", "INPLACE_OR": "|"}

  19. OP_SUBSCR = ("BINARY_SUBSCR", "INPLACE_SUBSCR")

  20. OP_BUILD = {"BUILD_TUPLE": ("(", ")"), "BUILD_LIST": ("[", "]"),

  21.                "BUILD_SET": ("{", "}")}

  22. 

  23. TAB = 4

  24. 

  25. def prettify_function(func, indent=0):

  26.     args = _get_func_args(func)

  27.     _print(indent, "def {0}({1}):".format(func.func_name, args))

  28.     prettify_code(func.__code__, indent=indent+TAB)

  29. 

  30. def prettify_code(codeobj, indent=0):

  31.     codes = []

  32.     codestring = codeobj.co_code

  33.     length = len(codestring)

  34.     i = 0

  35.     while i < length:

  36.         code = ord(codestring[i])

  37.         i += 1

  38.         if code >= opcode.HAVE_ARGUMENT:

  39.             arg = func_smash._get_argument(codeobj, codestring, i, code)

  40.             i += 2

  41.             codes.append((code, arg))

  42.         else:

  43.             codes.append((code, None))

  44. 

  45.     skip_next_line = False

  46.     lines = _parse_codestring(codes)

  47.     for i, line in enumerate(lines):

  48.         if skip_next_line:

  49.             skip_next_line = False

  50.             continue

  51.         added_indent, code = line[0], line[1:]

  52.         if code[0] == "else:" and lines[i+2][0] >= added_indent:

  53.             # Remove the automatic "pass" after each "if" as it's not needed

  54.             skip_next_line = True

  55.         _print(indent + added_indent, *code)

  56. 

  57. def _parse_codestring(codes):

  58.     indent = 0

  59.     lines = []

  60.     stack = []

  61.     print_buffer = []

  62.     block_dedent_at = []

  63.     block_else_at = []

  64.     i = 0

  65.     for instruction in codes:

  66.         code, arg = instruction

  67.         opname = opcode.opname[code]

  68.         if code >= opcode.HAVE_ARGUMENT:

  69.             i += 3

  70.         else:

  71.             i += 1

  72.         for x in block_dedent_at:

  73.             if i >= x:

  74.                 indent -= TAB

  75.                 block_dedent_at.remove(x)

  76.         for x in block_else_at:

  77.             if i >= x:

  78.                 lines.append((indent, "else:"))

  79.                 indent += TAB

  80.                 lines.append((indent, "pass"))

  81.                 block_else_at.remove(x)

  82.         _print(indent, i, opname, arg, debug=True)

  83.         if opname in OP_LOAD:

  84.             _push(stack, arg, literal=OP_LOAD[opname])

  85.         elif opname in OP_BINARY:

  86.             tos, tos1 = _pop(stack), _pop(stack)

  87.             _push(stack, " ".join((tos1, OP_BINARY[opname], tos)))

  88.         elif opname in OP_INPLACE:  # Works, but doesn't use inplace op magic

  89.             tos, tos1 = _pop(stack), _pop(stack)

  90.             _push(stack, " ".join((tos1, OP_INPLACE[opname], tos)))

  91.         elif opname in OP_SUBSCR:

  92.             tos, tos1 = _pop(stack), _pop(stack)

  93.             _push(stack, "{0}[{1}]".format(tos1, tos))

  94.         elif opname in OP_BUILD:

  95.             args = []

  96.             for i in xrange(arg):

  97.                 args.append(_pop(stack))

  98.             args.reverse()

  99.             start, end = OP_BUILD[opname]

  100.             _push(stack, start + ", ".join(args) + end)

  101.         elif opname == "BUILD_MAP":

  102.             _push(stack, "{}")

  103.         elif opname == "STORE_FAST":

  104.             lines.append((indent, arg, "=", _pop(stack)))

  105.         elif opname == "STORE_MAP":

  106.             key, value = _pop(stack), _pop(stack)

  107.             pair = ": ".join((key, value))

  108.             oldmap = _pop(stack)

  109.             if oldmap == "{}":

  110.                 newmap = "{" + pair + "}"

  111.             else:

  112.                 newmap = oldmap[:-1] + ", " + pair + "}"

  113.             _push(stack, newmap)

  114.         elif opname == "LOAD_ATTR":

  115.             tos = _pop(stack)

  116.             new_tos = tos + "." + arg

  117.             _push(stack, new_tos)

  118.         elif opname == "POP_TOP":

  119.             lines.append((indent, _pop(stack)))

  120.         elif opname == "CALL_FUNCTION":

  121.             numargs, numkwargs = arg

  122.             args = []

  123.             for i in xrange(numkwargs):

  124.                 value = _pop(stack)

  125.                 key = _pop(stack, never_literal=True)

  126.                 args.append("=".join((key, value)))

  127.             for i in xrange(numargs):

  128.                 args.append(_pop(stack))

  129.             args.reverse()

  130.             funcname = _pop(stack)

  131.             _push(stack, "{0}({1})".format(funcname, ", ".join(args)))

  132.         elif opname == "PRINT_ITEM":

  133.             print_buffer.append(_pop(stack))

  134.         elif opname == "PRINT_NEWLINE":

  135.             lines.append((indent, "print", ", ".join(print_buffer)))

  136.             print_buffer = []

  137.         elif opname == "RETURN_VALUE":

  138.             lines.append((indent, "return", _pop(stack)))

  139.         elif opname == "COMPARE_OP":

  140.             tos, tos1 = _pop(stack), _pop(stack)

  141.             compare = " ".join((tos1, arg, tos))

  142.             _push(stack, compare)

  143.         elif opname == "POP_JUMP_IF_FALSE":

  144.             test = _pop(stack)

  145.             block_dedent_at.append(arg)

  146.             block_else_at.append(arg)

  147.             lines.append((indent, "if {0}:".format(test)))

  148.             indent += TAB

  149.             lines.append((indent, "pass".format(test)))

  150.         elif opname == "POP_JUMP_IF_TRUE":

  151.             test = _pop(stack)

  152.             block_dedent_at.append(arg)

  153.             block_else_at.append(arg)

  154.             lines.append((indent, "if not ({0}):".format(test)))

  155.             indent += TAB

  156.             lines.append((indent, "pass".format(test)))

  157.         elif opname == "JUMP_ABSOLUTE":

  158.             block_dedent_at.append(i)

  159.         elif opname == "JUMP_FORWARD":

  160.             block_dedent_at.append(i + arg)

  161.         else:

  162.             raise NotImplementedError(opname, arg, stack)

  163.     return lines

  164. 

  165. def _get_func_args(func):

  166.     codeobj = func.__code__

  167.     count = codeobj.co_argcount

  168.     if count == 0:

  169.         return ""

  170.     return ", ".join([arg for arg in codeobj.co_varnames[:count]])

  171. 

  172. def _push(stack, item, literal=False):

  173.     stack.append((item, literal))

  174. 

  175. def _pop(stack, never_literal=False):

  176.     item, literal = stack.pop()

  177.     return repr(item) if literal and not never_literal else item

  178. 

  179. def _print(indentation, *args, **kwargs):

  180.     argstring = " ".join([str(arg) for arg in args if str(arg)])

  181.     if kwargs.get("debug"):

  182.         # Ignore debug messages without -d flag

  183.         if len(sys.argv) > 1 and sys.argv[1] == "-d":

  184.             print " " * 50 + "#", argstring

  185.         return

  186.     print " " * indentation + argstring

  187. 

  188. if __name__ == "__main__":

  189.     def f1(a):

  190.         b = a + 10 / 7.0

  191.         d = long_func(a, b+9, c=42, d="43")

  192.         print b, d

  193.         ex_tuple = ("Hello", "world!", abcdef)

  194.         ex_list = [1, 2, 3] * 3 + [4, 5, 6]

  195.         ex_set = {99, 98, 97, 96, 95}

  196.         ex_dict = {d: e, f: False, "testing": g}

  197.         return ex_dict

  198. 

  199.     def f2(a, b, c):

  200.         if cmp1:

  201.             line1

  202.             if cmp2:

  203.                 line2

  204.             elif cmp3:

  205.                 line3

  206.             elif cmp4:

  207.                 line4

  208.             else:

  209.                 line5

  210.             line6

  211.         else:

  212.             line7

  213.         line8

  214.         if cmp4:

  215.             line9

  216.         if cmp5:

  217.             if cmp6:

  218.                 if cmp7:

  219.                     if cmp8:

  220.                         if cmp9:

  221.                             line10

  222.         return line11

  223. 

  224.     prettify_function(f1)

  225.     print

  226.     prettify_function(f2)