python-cc 0.0.2__py3-none-any.whl

pcc/util.py

@@ -0,0 +1,121 @@
+
+_contracts = {}
+
+
+class Contract:
+    @classmethod
+    def __init_subclass__(cls):
+        # Apply checked decorator
+        _contracts[cls.__name__] = cls
+
+    @classmethod
+    def check(cls, value):
+        pass
+
+    def __set__(self, instance, value):
+        print("setting")
+        self.check(value)
+        instance.__dict__[self.name] = value
+
+    def __set_name__(self, owner, name):
+        print("setting name")
+        self.name = name
+
+
+class Typed(Contract):
+    type = None
+
+    @classmethod
+    def check(cls, value):
+        assert isinstance(value, cls.type), f'Expected {cls.type}'
+        # does this super().check(value) is need?
+
+
+class Integer(Typed):
+    type = int
+
+    @classmethod
+    def check(cls, value):
+        print("check Int")
+        assert isinstance(value, int), 'Expect Int'
+        super().check(value)
+
+
+class Positive(Typed):
+    @classmethod
+    def check(cls, value):
+        print("check Positive is ", value)
+        assert value > 0, 'Must be > 0'
+        super().check(value)
+
+
+class PositiveInteger(Integer, Positive):
+    # the super in Inter , and Postivie why
+    # what if it super
+    pass
+
+
+from functools import wraps
+from inspect import signature
+
+
+def checked(func):
+    sig = signature(func)   # can be bind here
+    # ann = func.__annotations__
+    ann = ChainMap(
+        func.__annotations__,
+        func.__globals__.get('__annotations__', {})
+        # what the func :dx is __annotations__  in modu
+    )
+    print("ann is ", ann)
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        bound = sig.bind(*args, **kwargs)
+        for name, val in bound.arguments.items():
+            if name in ann:
+                print("check ", name)
+                ann[name].check(val)
+        return func(*args, **kwargs)
+    return wrapper
+
+from collections import ChainMap
+
+
+class BaseMeta(type):
+    @classmethod
+    def __prepare__(cls, *args):
+        return ChainMap({}, _contracts)
+
+    def __new__(meta, name, bases, methods):
+        methods = methods.maps[0]  # the origin dict
+        return super().__new__(meta, name, bases, methods)
+
+
+class Base(metaclass=BaseMeta):
+    @classmethod
+    def __init_subclass__(cls):
+        # Apply checked decorator
+        for name, val in cls.__dict__.items():
+            if callable(val):
+                setattr(cls, name, checked(val))
+
+        for name, val in cls.__annotations__.items():
+            contract = val()
+            contract.__set_name__(cls, name)
+            setattr(cls, name, contract)
+
+    def __init__(self, *args):
+        ann = self.__annotations__
+        assert len(args) == len(ann), f"Expect"
+
+        # 3.6 Order
+        for name, val in zip(ann, args):
+            setattr(self, name, val)
+
+
+    def __repr__(self):
+        args = ",".join(repr(getattr(self, name)) for name in self.__annotations__)
+        return f'{type(self).__name__}({args})'
+
+
+print("__contracts ", _contracts)

python_cc-0.0.2.dist-info/METADATA

@@ -0,0 +1,182 @@
+Metadata-Version: 2.4
+Name: python-cc
+Version: 0.0.2
+Summary: Pcc is a c compiler built on python and llvm.
+Project-URL: Homepage, http://pypi.python.org/pypi/pcc/
+License-Expression: BSD-3-Clause
+License-File: LICENSE
+Keywords: c,compiler,llvm,ply
+Requires-Python: >=3.10
+Requires-Dist: click
+Requires-Dist: llvmlite==0.46.0
+Description-Content-Type: text/markdown
+
+Pcc
+====================
+
+What is this?
+--------------------
+Pcc is a C compiler based on ply + pycparser + llvmlite + llvm.
+We can run C programs like Python: `pcc test.c` to run C code.
+Pcc was inspired by: https://github.com/eliben/pykaleidoscope.
+
+Notice
+--------------------
+1. Some code skeleton comes from pykaleidoscope.
+2. ply and pycparser are embedded into this project for debug use.
+
+Development
+--------------------
+
+Requires Python 3.13+ and [uv](https://docs.astral.sh/uv/).
+
+```bash
+uv sync          # install dependencies
+uv run pytest    # run all 400+ tests (~10s parallel)
+```
+
+Run pcc
+--------------------
+
+```bash
+# Single file
+uv run pcc hello.c
+
+# Multi-file project (auto-collects all .c files, resolves .h includes)
+uv run pcc myproject/
+
+# Dump LLVM IR
+uv run pcc --llvmdump test.c
+```
+
+Multi-file projects: put `.c` and `.h` files in a directory, one `.c` must contain `main()`. Pcc auto-discovers all `.c` files, merges them, and compiles.
+
+Lua Compilation Goal
+--------------------
+
+The target is to compile and run [Lua 5.5.0](https://github.com/lua/lua) using pcc.
+
+```
+projects/lua-5.5.0/         - Lua 5.5.0 source code + Makefile
+projects/lua-5.5.0/testes/  - Lua test suite
+```
+
+### Test Structure
+
+Tests in `tests/test_lua.py` compare three builds:
+
+| Build | Method |
+|-------|--------|
+| **pcc** | `onelua.c` → pcc preprocess/parse/codegen → LLVM IR → cc compile+link |
+| **native** | `onelua.c` → `cc -O0` single-file compile |
+| **makefile** | `make` with project Makefile (separate compilation of each .c, static lib + link) |
+
+```bash
+# Run all Lua tests (slow marker, ~5 min with 4 workers)
+uv run pytest tests/test_lua.py -m slow -v -n 4
+
+# Individual file compilation through pcc pipeline
+uv run pytest tests/test_lua.py::test_lua_source_compile -v
+# pcc vs native (same onelua.c, test pcc as C compiler)
+uv run pytest tests/test_lua.py::test_pcc_runtime_matches_native -v
+# pcc vs Makefile-built lua (official reference)
+uv run pytest tests/test_lua.py::test_pcc_runtime_matches_makefile -v
+# Lua test suite with Makefile-built binary (baseline)
+uv run pytest tests/test_lua.py::test_makefile_lua_test_suite -v```
+
+Note: `heavy.lua` is excluded from automated tests (runs ~2 min+, may timeout). Run manually:
+```bash
+# Build Makefile lua, then run heavy.lua directly
+cd projects/lua-5.5.0 && make CC=cc CWARNS= MYCFLAGS="-std=c99 -DLUA_USE_MACOSX" MYLDFLAGS= MYLIBS=
+./lua testes/heavy.lua
+```
+
+Add C test cases
+--------------------
+
+```bash
+# Single file: add to c_tests/ with expected return value
+echo '// EXPECT: 42
+int main(){ return 42; }' > c_tests/mytest.c
+
+# Multi-file project: create a directory with main.c
+mkdir c_tests/myproject
+# ... add .c and .h files, main.c must have: // EXPECT: N
+
+# Run all C file tests
+uv run pytest tests/test_c_files.py -v
+```
+
+Preprocessor
+--------------------
+
+```c
+#include <stdio.h>          // system headers: 133 libc functions auto-declared
+#include "mylib.h"          // user headers: read and inline file content
+#define MAX_SIZE 100        // object-like macro
+#define MAX(a,b) ((a)>(b)?(a):(b))  // function-like macro
+#define DEBUG               // flag for conditional compilation
+#ifdef / #ifndef / #if / #elif / #else / #endif  // conditional compilation
+#if defined(X) && (VERSION >= 3)  // expression evaluation with defined()
+#undef NAME                 // undefine macro
+```
+
+Built-in macros: `NULL`, `EOF`, `EXIT_SUCCESS`, `EXIT_FAILURE`, `RAND_MAX`, `INT_MAX`, `INT_MIN`, `LLONG_MAX`, `CHAR_BIT`, `true`, `false`, `__STDC__`
+
+Built-in typedefs: `size_t`, `ssize_t`, `ptrdiff_t`, `va_list`, `FILE`, `time_t`, `clock_t`, `pid_t`
+
+Supported C Features
+--------------------
+
+### Types
+`int`, `double`, `float`, `char`, `void`, `unsigned`/`signed`/`long`/`short` (all combinations),
+`size_t`, `int8_t`..`uint64_t`,
+pointers (multi-level), arrays (multi-dim),
+structs (named, anonymous, nested, with array/pointer/function-pointer members, pointer-to-struct),
+unions, enums (with constant expressions), typedef (scalar, struct, pointer, function pointer),
+`static` local variables, `const`/`volatile` qualifiers
+
+### Operators
+- Arithmetic: `+` `-` `*` `/` `%`
+- Bitwise: `&` `|` `^` `<<` `>>`
+- Comparison: `<` `>` `<=` `>=` `==` `!=` (including pointer comparison)
+- Logical: `&&` `||` (short-circuit evaluation)
+- Unary: `-x` `+x` `!x` `~x` `sizeof` `&x` `*p`
+- Increment/Decrement: `++x` `x++` `--x` `x--` (int and pointer, including struct members)
+- Assignment: `=` `+=` `-=` `*=` `/=` `%=` `<<=` `>>=` `&=` `|=` `^=` (including pointer `+=`/`-=`)
+- Ternary: `a ? b : c`
+- Pointer: `p + n`, `p - n`, `p - q`, `p++`, `p[i]`
+- Struct access: `.` and `->` (including nested `a.b.c` and `s->fn(args)`)
+- Chained: `a = b = c = 5`
+
+### Control Flow
+`if` / `else` / `else if`, `while`, `do-while`, `for` (all variants including `for(;;)`),
+`switch` / `case` / `default`, `goto` / `label`, `break`, `continue`, `return`
+
+### Functions
+Definitions, forward declarations, mutual recursion, void functions, variadic (`...`),
+pointer/array arguments, `static` local variables, function pointers (declaration, assignment,
+calling, as parameters, in structs, typedef'd), callback patterns
+
+### Libc Functions (133 total, auto-declared on first use)
+
+| Header | Functions |
+|--------|-----------|
+| stdio.h | printf, fprintf, sprintf, snprintf, puts, putchar, getchar, fopen, fclose, fread, fwrite, fseek, ftell, fgets, fputs, scanf, sscanf, ... |
+| stdlib.h | malloc, calloc, realloc, free, abs, labs, atoi, atol, atof, strtol, strtod, rand, srand, exit, abort, qsort, bsearch, getenv, system, ... |
+| string.h | strlen, strcmp, strncmp, strcpy, strncpy, strcat, strncat, strchr, strrchr, strstr, memset, memcpy, memmove, memcmp, memchr, strtok, ... |
+| ctype.h | isalpha, isdigit, isalnum, isspace, isupper, islower, isprint, ispunct, isxdigit, toupper, tolower, ... |
+| math.h | sin, cos, tan, asin, acos, atan, atan2, exp, log, log2, log10, pow, sqrt, cbrt, hypot, ceil, floor, round, trunc, fmod, fabs, ... |
+| time.h | time, clock, difftime |
+| unistd.h | sleep, usleep, read, write, open, close, getpid, getppid |
+| setjmp.h | setjmp, longjmp |
+| signal.h | signal, raise |
+
+### Literals
+Decimal, hex (`0xFF`), octal (`077`), char (`'a'`, `'\n'`), string (`"hello\n"`), double (`3.14`)
+
+### Other
+C comments (`/* */`, `//`), array initializer lists (1D and multi-dim),
+string escape sequences (`\n \t \\ \0 \r`), implicit type promotion (int/char/double/pointer),
+array-to-pointer decay, `NULL` pointer support, opaque/forward-declared structs,
+two-pass codegen (types first, functions second)

python_cc-0.0.2.dist-info/RECORD

@@ -0,0 +1,36 @@
+pcc/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pcc/__main__.py,sha256=3YkyRxX4BusheQG4ZPjRQeizi-JtQm47PJ4Gjg4hN2Q,63
+pcc/pcc.py,sha256=2Br8aTR4FJOWRUnYzJyFYcb2eCGeydZj0A4TfcPBHJg,1263
+pcc/preprocessor.py,sha256=Oyo4jHljOU2keRr_pc3EFkwwBgOyYt22mqTdnf3KjG8,16950
+pcc/project.py,sha256=aftpOUbU4Fdiu4GFddq4imV1LFkaxnZBh4Er79I7qOg,2244
+pcc/util.py,sha256=IY8wvUIYKN1ghueiFZ0p0MaeLsoRk9NfVpK7qX6Ui6w,2925
+pcc/ast/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pcc/ast/ast.py,sha256=4KnKPR_jTCyQooR7Tp41oRuPkG-pxcon_vFRNQlS23I,5139
+pcc/ast/ast_transforms.py,sha256=Vif7WwLpdQJURrH4Boq9wE65S0j126_3ytFT7q6gDac,3569
+pcc/ast/c_ast.py,sha256=wWtyQlfVOn9GwWx2-5sr7VZdcmhNH2t0MJYMiAxct98,23457
+pcc/codegen/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pcc/codegen/c_codegen.py,sha256=E68pyr8emmSu382HLBkM2czYHT1808q4eR1nghLGLKA,174177
+pcc/evaluater/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pcc/evaluater/c_evaluator.py,sha256=C_tRzh41YypZ5KP-z47TjKfl-w5OW1syLWvJYdzvolI,7962
+pcc/generator/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pcc/generator/c_generator.py,sha256=9JxBzfePRt2ftmPLaw6xi1gOFGQ8jBgQo2r_9xJl0eA,13574
+pcc/lex/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pcc/lex/c_lexer.py,sha256=AV_n9-i2mQG3KTJyPZFTp4JUUxHvFA7swPg1oOiWZc4,14686
+pcc/lex/lexer.py,sha256=r2yyDfjAY4sAjRKEEi37oLDfairo7ywInoNblFHh5XU,2384
+pcc/lex/token.py,sha256=Zpk7ZJwVM2RU0pRdWMzcg7uxH_XmTXcP4Y1CrlB9Xoc,486
+pcc/parse/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pcc/parse/c_parser.py,sha256=VrDrNCbHWnRFRHBH6rjTnkuz5WL6JtE9vEEEiphITRQ,62187
+pcc/parse/file_parser.py,sha256=KM2f_kMGHtm4RqHs-m-BGgpYmmPsoIYAcOYYjSXn0oA,2531
+pcc/parse/parser.py,sha256=DCyHmsZ754LvwhN70yMAgAe-i8rTRUWogbP35Pwpm4Q,11289
+pcc/parse/plyparser.py,sha256=N6VLwCNfOcyCGJLHoI4MYQB1UCfeW3sXm5w4fLy_g88,1595
+pcc/ply/__init__.py,sha256=aj21cSa-ByoZ6VI8MvmvvBKSeK9-N5HDZzGkzXnRboo,102
+pcc/ply/cpp.py,sha256=ayTgot4U4VqnOU7T0V-JP76JknMr-CdAIRc_IsxXafE,33368
+pcc/ply/ctokens.py,sha256=MKksnN40TehPhgVfxCJhjj_BjL943apreABKYz-bl0Y,3177
+pcc/ply/lex.py,sha256=vNquS8ghLQV8zIUUiXDGgCHiru_UONIvAQulELYuFdU,42889
+pcc/ply/yacc.py,sha256=bfaaw5G1TlmyBFie8eaW9xciGHHPn7LxYDQd6MXDeOA,135805
+pcc/ply/ygen.py,sha256=2JYNeYtrPz1JzLSLO3d4GsS8zJU8jY_I_CR1VI9gWrA,2251
+python_cc-0.0.2.dist-info/METADATA,sha256=IjtRZR_v0qt3ve6bt_MeOx8dHas78x3jsXiJnErE5SE,6971
+python_cc-0.0.2.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+python_cc-0.0.2.dist-info/entry_points.txt,sha256=uU4oElC1UO58fXUT-dudsgAkE9T_db34M5L0LYrwUP0,37
+python_cc-0.0.2.dist-info/licenses/LICENSE,sha256=YNLCjRnSvfe7qlmCnnpZUjQmXoERoBzLdNJdbE0tATo,1211
+python_cc-0.0.2.dist-info/RECORD,,

python_cc-0.0.2.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

python_cc-0.0.2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pcc = pcc.pcc:main

python_cc-0.0.2.dist-info/licenses/LICENSE

@@ -0,0 +1,25 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+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 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.
+
+For more information, please refer to <http://unlicense.org>
+