python-cc 0.1.1__py3-none-any.whl → 0.1.2__py3-none-any.whl

pcc/cli_bootstrap.py

@@ -1,7 +1,7 @@
 import os
 import sys
 
-from .py_frontend import pipeline as _py_pipeline
+from .py_frontend.pipeline import compile_python as _compile_python
 
 
 _DEFAULT_EMIT_LL = "__PCC_DEFAULT_LL__"
@@ -280,7 +280,7 @@ def bootstrap_cli_main(argv=None) -> int:
             ll_out = output_path if output_path else path[:-3] + ".ll"
         else:
             ll_out = output_path if output_path else emit_llvm
-        _py_pipeline.compile_python(
+        _compile_python(
             path,
             ll_out,
             verbose=verbose,
@@ -291,7 +291,7 @@ def bootstrap_cli_main(argv=None) -> int:
             recursive_stdlib=False,
         )
     else:
-        _py_pipeline.compile_python(
+        _compile_python(
             path,
             output_path,
             verbose=verbose,

pcc/cli_core.py

@@ -1166,3 +1166,18 @@ def cli_main_sys_argv_exit() -> None:
         from sys import exit as _exit
 
         _exit(code)
+
+
+def cli_main_strict_sys_argv_exit() -> None:
+    """Entry point for the ``pcc-static`` console script.
+
+    Same as ``pcc`` but with the no-libpython flag combination
+    (``--python-libpython=off`` + ``--ir-scaffold=on``) wired in as
+    the default. An explicitly-passed ``--python-libpython`` /
+    ``--ir-scaffold`` CLI flag, or a pre-set ``PCC_PYTHON_LIBPYTHON``
+    / ``PCC_IR_SCAFFOLD`` env var, still takes precedence.
+    """
+    import os
+    os.environ.setdefault("PCC_PYTHON_LIBPYTHON", "off")
+    os.environ.setdefault("PCC_IR_SCAFFOLD", "on")
+    cli_main_sys_argv_exit()

pcc/llvm_capi/ir.py

@@ -799,11 +799,11 @@ class Function:
         # stay clean.
         self._name_counter = len(self.args)
         self._block_counter = 0
-        # Track all named locals that have been emitted so far —
-        # collisions get a ``.N`` suffix appended. Matches llvmlite's
-        # auto-deduplication; without it, code like
-        # ``builder.call(..., name="m.int_unbox")`` in a loop would
-        # emit conflicting SSA names.
+        # Track explicit names used by blocks and the small number of
+        # callers that require llvmlite-style stable deduplication. SSA
+        # instruction names are allocated from ``_name_counter`` instead;
+        # pcc-Python's dict is too expensive for per-instruction use in
+        # self-hosted codegen.
         self._name_registry: dict[str, int] = {}
         self.linkage = ""
         self.attributes = FunctionAttributes()
@@ -1209,25 +1209,15 @@ class IRBuilder:
         fn = self._fn
         if fn is None:
             raise ValueError("IRBuilder has no current function")
+        fn._name_counter += 1
         if name == "":
-            fn._name_counter += 1
             return f".{fn._name_counter}"
-        n = fn._name_registry.get(name, 0)
-        fn._name_registry[name] = n + 1
-        if n == 0:
-            return name
-        candidate = f"{name}.{n}"
-        while candidate in fn._name_registry:
-            n += 1
-            candidate = f"{name}.{n}"
-        fn._name_registry[candidate] = 1
-        return candidate
+        return f"{name}.{fn._name_counter}"
 
     def _next(self, name: str, ty: Type) -> Value:
         """Produce a new local SSA value with ``name`` (or a fresh temp
-        if empty). Uniqueifies against the function's name registry
-        so repeated ``name="x"`` calls get ``%x``, ``%x.1``, ``%x.2``
-        — same as llvmlite."""
+        if empty). Named temporaries use a function-wide serial suffix,
+        trading llvmlite text parity for O(1) self-hosted codegen."""
         return Value(ty, f"%{self._next_name(name)}")
 
     # ------------- return / branch / terminator -------------
@@ -1924,7 +1914,7 @@ def Module___init___named(name):
     return Module(name=name)
 
 
-def Module___init__():
+def scaffold_Module___init__():
     return Module(name="")
 
 

pcc/parse/py_lex.py

@@ -43,6 +43,65 @@ _OPS_MULTI = (
 _OPS_SINGLE = "+-*/%@&|^~<>=()[]{},:.;"
 
 
+def _is_digit_code(c: int) -> bool:
+    return c >= 48 and c <= 57
+
+
+def _is_alpha_code(c: int) -> bool:
+    return (c >= 65 and c <= 90) or (c >= 97 and c <= 122)
+
+
+def _is_alnum_code(c: int) -> bool:
+    return _is_alpha_code(c) or _is_digit_code(c)
+
+
+def _lower_code(c: int) -> int:
+    if c >= 65 and c <= 90:
+        return c + 32
+    return c
+
+
+def _is_prefix_code(c: int) -> bool:
+    lc = _lower_code(c)
+    return lc == 98 or lc == 102 or lc == 114 or lc == 117
+
+
+def _is_quote_code(c: int) -> bool:
+    return c == 34 or c == 39
+
+
+def _is_single_op_code(c: int) -> bool:
+    return (
+        c == 37 or c == 38 or c == 40 or c == 41 or c == 42
+        or c == 43 or c == 44 or c == 45 or c == 46 or c == 47
+        or c == 58 or c == 59 or c == 60 or c == 61 or c == 62
+        or c == 64 or c == 91 or c == 93 or c == 94 or c == 123
+        or c == 124 or c == 125 or c == 126
+    )
+
+
+def _is_open_paren_code(c: int) -> bool:
+    return c == 40 or c == 91 or c == 123
+
+
+def _is_close_paren_code(c: int) -> bool:
+    return c == 41 or c == 93 or c == 125
+
+
+def _pcc_str_byte_len(s: str) -> int:
+    return len(s)
+
+
+def _pcc_str_byte_at(s: str, pos: int) -> int:
+    if pos < len(s):
+        return ord(s[pos])
+    return -1
+
+
+def _pcc_str_byte_slice(s: str, lo: int, hi: int) -> str:
+    return s[lo:hi]
+
+
 @dataclass(frozen=True)
 class Token:
     kind: str
@@ -70,6 +129,7 @@ class Lexer:
 
     def __init__(self, src: str, filename: str = "<input>") -> None:
         self.src = src
+        self._src_len = _pcc_str_byte_len(src)
         self.filename = filename
         self.pos = 0
         self.line = 1
@@ -84,51 +144,51 @@ class Lexer:
         """Run the lexer to completion, returning all tokens."""
         out: list[Token] = []
         indent_stack: list[int] = self._indent_stack
-        while self.pos < len(self.src):
+        while self.pos < self._src_len:
             if self._at_line_start and self._paren_depth == 0:
                 self._emit_indent(out)
                 self._at_line_start = False
-                if self.pos >= len(self.src):
+                if self.pos >= self._src_len:
                     break
-            ch = self.src[self.pos]
-            if ch == "\n":
+            ch = self._peek_code(0)
+            if ch == 10:
                 self._emit_newline(out)
                 continue
-            if ch in " \t":
+            if ch == 32 or ch == 9:
                 self.pos += 1
                 self.col += 1
                 continue
-            if ch == "#":
-                while self.pos < len(self.src) and self.src[self.pos] != "\n":
+            if ch == 35:
+                while self.pos < self._src_len and self._peek_code(0) != 10:
                     self.pos += 1
                 continue
-            if ch == "\\" and self._peek(1) == "\n":
+            if ch == 92 and self._peek_code(1) == 10:
                 self.pos += 2
                 self.line += 1
                 self.col = 1
                 continue
             if (
-                ch.lower() in "bfru"
-                and self._peek(1) in ('"', "'")
+                _is_prefix_code(ch)
+                and _is_quote_code(self._peek_code(1))
             ):
                 out.append(self._read_string())
                 continue
             if (
-                ch.lower() in "bfru"
-                and self._peek(1).lower() in "bfru"
-                and self._peek(2) in ('"', "'")
+                _is_prefix_code(ch)
+                and _is_prefix_code(self._peek_code(1))
+                and _is_quote_code(self._peek_code(2))
             ):
                 out.append(self._read_string())
                 continue
-            if ch.isalpha() or ch == "_":
+            if _is_alpha_code(ch) or ch == 95:
                 out.append(self._read_name())
                 continue
-            if ch.isdigit() or (
-                ch == "." and self._peek(1).isdigit()
+            if _is_digit_code(ch) or (
+                ch == 46 and _is_digit_code(self._peek_code(1))
             ):
                 out.append(self._read_number())
                 continue
-            if ch in ('"', "'"):
+            if _is_quote_code(ch):
                 out.append(self._read_string())
                 continue
             out.append(self._read_op())
@@ -142,18 +202,31 @@ class Lexer:
 
     # ------------------------------------------------------ helpers
 
+    def _code_at(self, pos: int) -> int:
+        if pos < self._src_len:
+            return _pcc_str_byte_at(self.src, pos)
+        return -1
+
+    def _slice(self, lo: int, hi: int) -> str:
+        return _pcc_str_byte_slice(self.src, lo, hi)
+
+    def _peek_code(self, off: int) -> int:
+        return self._code_at(self.pos + off)
+
     def _peek(self, off: int) -> str:
         p = self.pos + off
-        return self.src[p] if p < len(self.src) else ""
+        return self._slice(p, p + 1) if p < self._src_len else ""
 
     def _emit_indent(self, out: list[Token]) -> None:
         indent_stack: list[int] = self._indent_stack
         depth = 0
         p = self.pos
-        while p < len(self.src) and self.src[p] in " \t":
-            depth += 1 if self.src[p] == " " else 8
+        pc = self._code_at(p)
+        while p < self._src_len and (pc == 32 or pc == 9):
+            depth += 1 if pc == 32 else 8
             p += 1
-        if p >= len(self.src) or self.src[p] in ("\n", "#"):
+            pc = self._code_at(p)
+        if p >= self._src_len or pc == 10 or pc == 35:
             self.pos = p
             self.col = depth + 1
             return
@@ -183,12 +256,15 @@ class Lexer:
         start = self.pos
         start_col = self.col
         while (
-            self.pos < len(self.src)
-            and (self.src[self.pos].isalnum() or self.src[self.pos] == "_")
+            self.pos < self._src_len
+            and (
+                _is_alnum_code(self._peek_code(0))
+                or self._peek_code(0) == 95
+            )
         ):
             self.pos += 1
             self.col += 1
-        text = self.src[start:self.pos]
+        text = self._slice(start, self.pos)
         kind = TK_KEYWORD if text in KEYWORDS else TK_NAME
         return Token(kind, text, self.line, start_col)
 
@@ -197,47 +273,62 @@ class Lexer:
         start_col = self.col
         # Hex / octal / binary: ``0x…`` / ``0o…`` / ``0b…`` (PEP 3127).
         if (
-            self.src[self.pos] == "0"
-            and self.pos + 1 < len(self.src)
-            and self.src[self.pos + 1] in "xXoObB"
+            self._peek_code(0) == 48
+            and self.pos + 1 < self._src_len
+            and (
+                _lower_code(self._code_at(self.pos + 1)) == 98
+                or _lower_code(self._code_at(self.pos + 1)) == 111
+                or _lower_code(self._code_at(self.pos + 1)) == 120
+            )
         ):
-            base = self.src[self.pos + 1].lower()
+            base = _lower_code(self._code_at(self.pos + 1))
             self.pos += 2
             self.col += 2
-            if base == "x":
-                valid = "0123456789abcdefABCDEF_"
-            elif base == "o":
-                valid = "01234567_"
-            else:
-                valid = "01_"
-            while self.pos < len(self.src) and self.src[self.pos] in valid:
+            while self.pos < self._src_len:
+                c = self._peek_code(0)
+                valid = False
+                if c == 95:
+                    valid = True
+                elif base == 120:
+                    valid = (
+                        _is_digit_code(c)
+                        or (c >= 65 and c <= 70)
+                        or (c >= 97 and c <= 102)
+                    )
+                elif base == 111:
+                    valid = c >= 48 and c <= 55
+                else:
+                    valid = c == 48 or c == 49
+                if not valid:
+                    break
                 self.pos += 1
                 self.col += 1
             return Token(
-                TK_NUMBER, self.src[start:self.pos], self.line, start_col,
+                TK_NUMBER, self._slice(start, self.pos), self.line, start_col,
             )
         has_dot = False
         has_exp = False
-        while self.pos < len(self.src):
-            ch = self.src[self.pos]
-            if ch.isdigit():
+        while self.pos < self._src_len:
+            ch = self._peek_code(0)
+            if _is_digit_code(ch):
                 self.pos += 1
                 self.col += 1
-            elif ch == "." and not has_dot and not has_exp:
+            elif ch == 46 and not has_dot and not has_exp:
                 has_dot = True
                 self.pos += 1
                 self.col += 1
-            elif ch in ("e", "E") and not has_exp:
+            elif (ch == 101 or ch == 69) and not has_exp:
                 has_exp = True
                 self.pos += 1
                 self.col += 1
-                if self.pos < len(self.src) and self.src[self.pos] in "+-":
+                nxt = self._peek_code(0)
+                if self.pos < self._src_len and (nxt == 43 or nxt == 45):
                     self.pos += 1
                     self.col += 1
-            elif ch in ("_",):
+            elif ch == 95:
                 self.pos += 1
                 self.col += 1
-            elif ch in ("j", "J"):
+            elif ch == 106 or ch == 74:
                 # Imaginary literal suffix — we accept the char so the
                 # tokenizer doesn't choke, the frontend doesn't use them.
                 self.pos += 1
@@ -245,7 +336,7 @@ class Lexer:
                 break
             else:
                 break
-        return Token(TK_NUMBER, self.src[start:self.pos], self.line, start_col)
+        return Token(TK_NUMBER, self._slice(start, self.pos), self.line, start_col)
 
     def _read_string(self) -> Token:
         start = self.pos
@@ -253,31 +344,34 @@ class Lexer:
         # Consume the optional prefix chars (``b``, ``r``, ``f``, ``u``
         # and their 2-char combinations).
         while (
-            self.pos < len(self.src)
-            and self.src[self.pos].lower() in "bfru"
-            and self._peek(0) not in ('"', "'")
+            self.pos < self._src_len
+            and _is_prefix_code(self._peek_code(0))
+            and not _is_quote_code(self._peek_code(0))
         ):
             self.pos += 1
             self.col += 1
-        quote = self.src[self.pos]
+        quote_code = self._peek_code(0)
         # Handle triple-quoted.
-        triple = self._peek(1) == quote and self._peek(2) == quote
+        triple = (
+            self._peek_code(1) == quote_code
+            and self._peek_code(2) == quote_code
+        )
         if triple:
             self.pos += 3
             self.col += 3
-            while self.pos < len(self.src):
+            while self.pos < self._src_len:
                 if (
-                    self.src[self.pos] == quote
-                    and self._peek(1) == quote
-                    and self._peek(2) == quote
+                    self._peek_code(0) == quote_code
+                    and self._peek_code(1) == quote_code
+                    and self._peek_code(2) == quote_code
                 ):
                     self.pos += 3
                     self.col += 3
                     return Token(
-                        TK_STRING, self.src[start:self.pos],
+                        TK_STRING, self._slice(start, self.pos),
                         self.line, start_col,
                     )
-                if self.src[self.pos] == "\n":
+                if self._peek_code(0) == 10:
                     self.line += 1
                     self.col = 1
                 else:
@@ -289,20 +383,20 @@ class Lexer:
         # Single-line.
         self.pos += 1
         self.col += 1
-        while self.pos < len(self.src):
-            ch = self.src[self.pos]
-            if ch == "\\":
+        while self.pos < self._src_len:
+            ch = self._peek_code(0)
+            if ch == 92:
                 self.pos += 2
                 self.col += 2
                 continue
-            if ch == quote:
+            if ch == quote_code:
                 self.pos += 1
                 self.col += 1
                 return Token(
-                    TK_STRING, self.src[start:self.pos],
+                    TK_STRING, self._slice(start, self.pos),
                     self.line, start_col,
                 )
-            if ch == "\n":
+            if ch == 10:
                 raise LexError(
                     f"{self.filename}:{self.line}: unterminated string"
                 )
@@ -317,19 +411,21 @@ class Lexer:
         # Try 3-, 2-, then 1-char operators.
         for op in _OPS_MULTI:
             op_len = len(op)
-            if src[pos:pos + op_len] == op:
+            if self._slice(pos, pos + op_len) == op:
                 self.pos = pos + op_len
                 self.col += op_len
                 return Token(TK_OP, op, self.line, start_col)
-        ch = self.src[self.pos]
-        if ch in _OPS_SINGLE:
-            if ch in "([{":
+        ch_code = self._peek_code(0)
+        if _is_single_op_code(ch_code):
+            ch = self._slice(self.pos, self.pos + 1)
+            if _is_open_paren_code(ch_code):
                 self._paren_depth += 1
-            elif ch in ")]}":
+            elif _is_close_paren_code(ch_code):
                 self._paren_depth = max(0, self._paren_depth - 1)
             self.pos += 1
             self.col += 1
             return Token(TK_OP, ch, self.line, start_col)
+        ch = self._slice(self.pos, self.pos + 1)
         raise LexError(
             f"{self.filename}:{self.line}:{self.col}: stray character {ch!r}"
         )

pcc/parse/py_lift.py

@@ -34,6 +34,42 @@ class LiftError(Exception):
     """Raised when a parser node has no py_ast equivalent yet."""
 
 
+def _pow10f_lift(exp: int) -> float:
+    out = float(int("1", 10))
+    ten = float(int("10", 10))
+    i = 0
+    while i < exp:
+        out = out * ten
+        i += 1
+    return out
+
+
+def _parse_float_literal_lift(text: str) -> float:
+    exp = 0
+    mantissa = text
+    lower = text.lower()
+    e_idx = lower.find("e")
+    if e_idx >= 0:
+        mantissa = text[:e_idx]
+        exp = int(text[e_idx + 1:], 10)
+    dot_idx = mantissa.find(".")
+    frac_len = 0
+    digits = mantissa
+    if dot_idx >= 0:
+        frac_len = len(mantissa) - dot_idx - 1
+        digits = mantissa[:dot_idx] + mantissa[dot_idx + 1:]
+    if not digits:
+        digits = "0"
+    value = float(int(digits, 10))
+    if frac_len > 0:
+        value = value / _pow10f_lift(frac_len)
+    if exp > 0:
+        value = value * _pow10f_lift(exp)
+    elif exp < 0:
+        value = value / _pow10f_lift(-exp)
+    return value
+
+
 def lift_module(mod: pp._Module, filename: str, module_name: str) -> pa.Module:
     L = _Lifter(filename)
     body = tuple(L.lift_stmt(s) for s in mod.body)
@@ -355,12 +391,12 @@ class _Lifter:
             return pa.IntLit(
                 span=span,
                 ty=pa.IntType(name="int", width=64, signed=True),
-                value=e.value,
+                value=int(e.text, 0),
             )
         return pa.FloatLit(
             span=span,
             ty=pa.FloatType(name="float", width=64),
-            value=e.value,
+            value=_parse_float_literal_lift(e.text),
         )
 
     def _e_Str(self, e: pp._Str) -> pa.StrLit:
@@ -686,6 +722,8 @@ def _lift_type(node) -> pa.Type:
                         key=_lift_type(inner.elems[0]),
                         value=_lift_type(inner.elems[1]),
                     )
+            if base.ident in ("set", "frozenset"):
+                return pa.DynType(name="set")
         return _DYN
     if isinstance(node, pp._BinOp) and node.op == "|":
         # PEP 604 union — pcc has no Union type, fall back to Dyn.

pcc/parse/py_parse.py

@@ -49,10 +49,11 @@ def _join_strings(parts: list[str], sep: str) -> str:
 
 
 def _pow10f(exp: int) -> float:
-    out = 1.0
+    out = float(int("1", 10))
+    ten = float(int("10", 10))
     i = 0
     while i < exp:
-        out = out * 10.0
+        out = out * ten
         i += 1
     return out
 
@@ -107,7 +108,7 @@ class _Expr:
 
 @dataclass
 class _Num:
-    value: "int | float"
+    text: str
     line: int
     is_int: bool
 
@@ -1193,8 +1194,11 @@ class Parser:
 
     def _parse_compare(self):
         lhs = self._parse_bitor()
+        comparisons = []
+        prev = lhs
         while True:
             t = self._peek()
+            line = t.line
             if t.kind == TK_OP and t.text in (
                 "<", ">", "<=", ">=", "==", "!=",
             ):
@@ -1220,8 +1224,13 @@ class Parser:
             else:
                 break
             rhs = self._parse_bitor()
-            lhs = _Compare(op=op, lhs=lhs, rhs=rhs, line=self._peek().line)
-        return lhs
+            comparisons.append(_Compare(op=op, lhs=prev, rhs=rhs, line=line))
+            prev = rhs
+        if not comparisons:
+            return lhs
+        if len(comparisons) == 1:
+            return comparisons[0]
+        return _BoolOp(op="and", values=comparisons, line=comparisons[0].line)
 
     def _parse_bitor(self):
         lhs = self._parse_bitxor()
@@ -1596,8 +1605,8 @@ class Parser:
             self._advance()
             clean = t.text.replace("_", "")
             if "." in clean or "e" in clean.lower():
-                return _Num(_parse_float_literal(clean), t.line, False)
-            return _Num(int(clean, 0), t.line, True)
+                return _Num(clean, t.line, False)
+            return _Num(clean, t.line, True)
         if t.kind == TK_STRING:
             self._advance()
             strings = [t]

pcc/py_frontend/codegen/class_gen.py

@@ -138,6 +138,11 @@ class ClassInfo:
         # call-site lookups (e.g. ``_find_method_def``) see synthetic
         # methods, not just what the user wrote.
         self.expanded_cd: "ClassDef | None" = None
+        # Cross-module extern classes synthesize FuncDef stubs from export
+        # metadata so kwargs/default resolution can use normal method
+        # lowering. Keep this as a declared pcc field; dynamic post-init
+        # attributes are not reliable in the native object layout.
+        self.extern_method_defs: dict[str, FuncDef] = {}
 
 
 class ClassLowering: