4 ms·
A funny anecdote: Some time ago, I was writing a C-to-Python translator. (Why? Just for fun, https://github.com/albertz/PyCParser https://github.com/albertz/Py
by albertzeyer 3y ago
A funny anecdote: Some time ago, I was writing a C-to-Python translator.
(Why? Just for fun, https://github.com/albertz/PyCParser https://github.com/albertz/PyCParser, even more just-for-fun goal was this: https://github.com/albertz/PyCPython https://github.com/albertz/PyCPython).
It literally would translate the C code in equivalent Python code, using ctypes heavily. It was mostly straight-forward, except for mapping goto (thus related to this control flow structuring problem).
Of course, there are some hacks to introduce goto in Python, which in many cases would operate on the Python bytecode, which actually has the JUMP_ABSOLUTE op, but there are also other ways (https://stackoverflow.com/questions/6959360/goto-in-python https://stackoverflow.com/questions/6959360/goto-in-python).
I could also have translated C directly to equivalent Python bytecode and not Python source code, but I really wanted to have Python source code.
My ugly solution worked basically like this: Whenever there was some goto in a function, it would translate it as follows:
First, we flatten any Python AST into a series of statements,
with even more goto's added for while/for loops, if's, etc.
(We can avoid doing this for all sub-ASTs where there are no
no goto-labels. The goal is to have all goto-labels at
the top-level, not inside a sub-AST.)
Only conditional goto's can stay.
All Gotos and Goto-labels are marked somehow as special elements.
So, we end up with sth like:
x()
y()
<goto-label "a">
z()
<goto-stmnt "a">
w()
if v(): <goto-stmnt "a">
q()
Now, we can implement the goto-handling based on this flattened code:
- Add a big endless loop around it. After the final statement, a break would leave the loop.
- Before the loop, we add the statement `goto = None`.
- The goto-labels will split the code into multiple part, where
we add some `if goto is None:` before each part
(excluding the goto-labels).
- For the goto-labels itself, we add this code:
if goto == <goto-label>: goto = None
- For every goto-statement, we add this code:
goto = <goto-stmnt>; continue
See here: https://github.com/albertz/PyCParser/blob/master/goto.py https://github.com/albertz/PyCParser/blob/master/goto.py
- mahaloz 3y agoThat's awesome! That's exactly how modern decompilers deal with a special type of goto occurrence. They reduce gotos (or completely eliminate them) by introducing a `while(true)` loop, followed by corresponding `continue` and `breaks`... we all, of course, know that `while(true)` did not exist in the source, but it's a nice hack! We even do this in the angr decompiler, found here: https://github.com/angr/angr/blob/8e48d001e18a913ecd4ed2e9955137c39d36c959/angr/analyses/decompiler/structuring/phoenix.py#L220C14-L220C14 https://github.com/angr/angr/blob/8e48d001e18a913ecd4ed2e995...
- edflsafoiewq 3y agoThis is the https://en.wikipedia.org/wiki/Structured_program_theorem https://en.wikipedia.org/wiki/Structured_program_theorem. You may also be interested in the Relooper and Stackifier algorithms, which produce more efficient programs than a simple loop/switch.