An experiment in synthesis of C code from a functional language.

The basic idea of this very simple and naive Python program is to transform a nameless functional language that looks a bit like this:

int,bin:int;
(add (rotate_right bin 1) (rotate_left (bitwise_and bin 1) 15)))

Into C code that can be compiled using TinyC.

A specification file (.spec extension) is written in a nameless functional language with one function per file, with the function's name being the name of the file without extension. The basic structure of a specification file looks like this:

<return_type>,<param_name>:<param_type>;
<functional_code>

This includes the following:

• <return_type> - The return type of the C method to be generated.
• <param_name>:<param_type> - The name and type of each parameter to be included in the generated C method. Can be repeated arbitratily many times (comma-separated).
• <functional_code> - The functional code to compile as the body of the generated C method.

A primitive file (.pc extension) is written as a very small piece of C code with substitution placeholders for each argument of the function that corresponds to that primitive. For example add.pc contains this:

(%1 + %2)

Invoke the program on the command line like this:

python tiny-synth.py <function_name>

Where function_name is the name of the function you want to compile.

With functional programs being easier to reason about in general than imperative programs, I thought it'd a be a fun little experiment to try to synthesise some imperative code from functional code.

This isn't a serious development tool, and comes with some serious limitations and caveats. I'm sure there are a billion and one ways this could behave differently than expected.