Skip to main content

The Loosey Goosey C Parser and Interpreter

Rationale

I love programming with a REPL (Read-Eval-Print-Loop).

So for instance, I'm one of those people who's always at the CLI, instead of in an IDE.

And I love Python, and iPython; my favourite style of Python programming is where I'm typing stuff into the REPL, seeing what works, and when I find it, I copy-paste it into a .py file as code and/or tests.

Now, I'm also a C programmer, and C is in many ways a terrible language to work with. It certainly doesn't lend itself well to programming in a REPL. I can read through a large C codebase, like SQLite or PostgreSQL or CPython or the Linux kernel, and come to some understanding of what it's doing, but I can't easily try it out. It's not like Python, where I'm at the REPL, and I can import a class, instantiate it, and poke at it.

So, that's the goal here: what if you could "import" (or even just copy-paste) C code, and play with it at a REPL?

The idea will be to map the runtime semantics of C onto some Python classes, then have a C parser which is intentionally loosey-goosey, so it can parse even fragments of C code without having to #include all the proper stuff, and then you can instantiate the types and call the functions and so on, and have things fail at runtime instead of compile-time, for instance if you call some function which attempts to call another function which hasn't been defined. And you should be able to mock out missing functions and things quickly in Python, so you can re-run the thing you were actually interested in, and have it succeed this time.

Last thing in this rationale, I'm going to breathe to you a secret word... doctests. Imagine doctests for your C code.

Existing C interpreters

Here are some projects I've played with or looked at, but didn't quite get what I needed from:

Installation

pip install loosey-goosey-c

See also:

The C preprocessor

Implemented in pure Python! It's actually fairly complete.

See its documentation here:

Example usage:

$ echo -e '#define M(X) [X]\nM(M(1))' | python -m loosey.pp
[ [ 1 ] ]

Mini C Interpreter

Work in progress.

Allows C code to be run dynamically, using Python values. Functions and values can be freely exchanged between C and Python.

It's very dynamic: it ignores the C type system entirely, using Python objects as values, including a custom Pointer class. If you refer to uninitialized memory, you generally get an instance of Struct, which is a custom Python class which secretly adds fields to itself whenever you try to refer to them.

The parser uses a heavily tweaked version of the ANSI C yacc grammar available online:

...which is parsed and interpreted with a custom grammar library, which is probably a packrat parser:

The interpreter's code lives here:

Example usage:

>>> from loosey.mini import MiniC
>>> mini = MiniC()

>>> mini.eval('1 + 2')
3

>>> mini.eval('1 + 2 * 10 + 3')
24

# The C preprocessor is available, with all its foibles... remember to add
# lots of parentheses ;)
>>> mini.eval('#define DOUBLE(X) X + X')
>>> mini.eval('10 * DOUBLE(2)')
22

>>> add = mini.eval('int add(int x, int y) { int z = x + y; return z; }')
>>> add
add(x, y)

# Calling a mini-C function directly from Python:
>>> add(3, 4)
7

# Calling a mini-C function within mini-C:
>>> mini.eval('int x = 3, total = add(x, 5);')
{'x': 3, 'total': 8}

# Using a Python function from within mini-C:
>>> import math
>>> mini.globals['sqrt'] = math.sqrt
>>> mini.eval('sqrt(20 + 5)')
5.0

# Using Python objects, methods, etc from within mini-C:
# (NOTE: all C types are currently ignored, so the "struct t *" here could
# just as easily have been "int" or whatever)
>>> add_dict_keys = mini.eval("""
... int add_dict_keys(struct t *obj) {
...     return obj->get("x") + obj->get("y");
... }""")
>>> add_dict_keys({'x': 1, 'y': 2})
3

# Creating a pointer in Python and passing it to C code:
>>> ptr = mini.malloc()
>>> ptr.contents.x = 3
>>> ptr_test = mini.eval('void ptr_test(void *ptr) { ptr->x += 1; }')
>>> ptr_test(ptr)
>>> ptr.contents.x
4

# Creating a pointer in C code and returning it to Python:
>>> mkptr = mini.eval('''
... void *mkptr() {
...     void *ptr = malloc(1);
...     ptr->x = 3;
...     return ptr;
... }''')
>>> ptr = mkptr()
>>> ptr.contents.x
3

Metadata

Release files for loosey-goosey-c 0.0.6

For a detailed explanation of source distributions (sdists) and built distributions (wheels), please see the package formats documentation.

Source distribution (sdist)

Source distribution for loosey-goosey-c 0.0.6
File Size Uploaded Provenance Actions
loosey_goosey_c-0.0.6.tar.gz 50.0 kB Without provenance Details for loosey_goosey_c-0.0.6.tar.gz

Built distribution (wheel)

Table of built distributions (wheels) for loosey-goosey-c 0.0.6
File Interpreter ABI Platform Actions
loosey_goosey_c-0.0.6-py3-none-any.whl Python 3 none any Details for loosey_goosey_c-0.0.6-py3-none-any.whl

Total release size: 101.8 kB

Release files / loosey_goosey_c-0.0.6.tar.gz

Download URL loosey_goosey_c-0.0.6.tar.gz
Size 50.0 kB
Tags Source
SHA-256 checksum
How to use checksums
3b25bea701a04e7c822a7a72f5d1f81d6d0c30ab7891bc47c441b860aa7826b7
BLAKE2b-256 checksum
How to use checksums
1875236d70c5402a63e0a25bf7066cf55d23a615fc606e92865e694a1c439e73
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/7.0.0 CPython/3.12.3

Release files / loosey_goosey_c-0.0.6-py3-none-any.whl

Download URL loosey_goosey_c-0.0.6-py3-none-any.whl
Size 51.8 kB
Tags Python 3
SHA-256 checksum
How to use checksums
ee9729fafc828b3a55d0ed135e45d9188684ea03f1f5b8184bd707bf03c15e45
BLAKE2b-256 checksum
How to use checksums
3dfebc6ac8581cfb3229fc564918bffc4bfdcd771e0b4b13cd56e2ca634286a7
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/7.0.0 CPython/3.12.3

Security for loosey-goosey-c 0.0.6

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

No provenance found

None of the files in this release were uploaded with provenance metadata.

A note on package security

PyPI is a repository for distributing packages, not a service for auditing them. While third-party security researchers and our staff do their best to detect and remove malicious packages, PyPI cannot guarantee the quality, security or suitability of any given package.

To learn more about protecting yourself from malicious actors, visit our package security documentation.

Anthropic, PBC Visionary sponsor Bloomberg Visionary sponsor Hudson River Trading Visionary sponsor Meta Visionary sponsor NVIDIA Visionary sponsor Microsoft Sustainability sponsor Depot Continuous Integration AWS Cloud computing and Security Sponsor Datadog Monitoring Fastly CDN Google Download Analytics Sentry Error logging StatusPage Status page