cpyte 2.0.2__tar.gz → 2.2.0__tar.gz

{cpyte-2.0.2 → cpyte-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cpyte
-Version: 2.0.2
+Version: 2.2.0
 Summary: The Cpyte programming language compiler
 Author: Hoang Duy Tung
 License: MIT
@@ -81,3 +81,9 @@ python source/mainpie.py --jit examples/<filename>.cpy
 Cpyte is experimental software. The compiler is continuously tested with fuzzing, and we're still discovering and fixing correctness bugs. While many programs compile and run correctly, I can't make any guarantees about correctness or stability.
 
 If you decide to use Cpyte, always use the latest version — older versions have bugs that are pretty easy to run into.
+
+## Memory Management
+
+Cpyte uses **Boehm GC** (bdw-gc) for automatic garbage collection. Heap-allocated objects (via `new`) are managed automatically — no manual `free` needed.
+
+**Note:** Boehm GC adds a small runtime overhead (~5-10%) compared to manual `malloc/free`. For performance-critical ecosystem projects or embedded use cases, this trade-off may be significant. The GC is required for safety but will slow down programs that do heavy heap allocation.

{cpyte-2.0.2 → cpyte-2.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "cpyte"
-version = "2.0.2"
+version = "2.2.0"
 description = "The Cpyte programming language compiler"
 readme = "readme.md"
 requires-python = ">=3.11"

{cpyte-2.0.2 → cpyte-2.2.0}/readme.md

@@ -69,4 +69,10 @@ python source/mainpie.py --jit examples/<filename>.cpy
 ## Note
 Cpyte is experimental software. The compiler is continuously tested with fuzzing, and we're still discovering and fixing correctness bugs. While many programs compile and run correctly, I can't make any guarantees about correctness or stability.
 
-If you decide to use Cpyte, always use the latest version — older versions have bugs that are pretty easy to run into.
+If you decide to use Cpyte, always use the latest version — older versions have bugs that are pretty easy to run into.
+
+## Memory Management
+
+Cpyte uses **Boehm GC** (bdw-gc) for automatic garbage collection. Heap-allocated objects (via `new`) are managed automatically — no manual `free` needed.
+
+**Note:** Boehm GC adds a small runtime overhead (~5-10%) compared to manual `malloc/free`. For performance-critical ecosystem projects or embedded use cases, this trade-off may be significant. The GC is required for safety but will slow down programs that do heavy heap allocation.

{cpyte-2.0.2 → cpyte-2.2.0}/source/cpyte/astparse.py

@@ -116,11 +116,12 @@ class Index:
         return f'Index({self.obj}, {self.index})'
 
 class Attr:
-    __slots__ = ('obj', 'name', '_token')
+    __slots__ = ('obj', 'name', '_token', '_enum_member_value')
     def __init__(self, obj, name: str, token=None):
         self.obj = obj
         self.name = name
         self._token = token
+        self._enum_member_value = None
     def __repr__(self):
         return f'Attr({self.obj}, {self.name})'
 
@@ -426,6 +427,10 @@ def _parse_standard_statement(tokens: list[Token], pos: int):
         node, pos = parse_try(tokens, pos)
     elif tok.type == TokenType.KEYWORD and tok.value == 'raise':
         node, pos = parse_raise(tokens, pos)
+    elif tok.type == TokenType.KEYWORD and tok.value == 'enum':
+        node, pos = parse_enum(tokens, pos)
+    elif tok.type == TokenType.KEYWORD and tok.value == 'type':
+        node, pos = parse_type_alias(tokens, pos)
     elif tok.type == TokenType.IDENTIFIER and pos + 1 < len(tokens):
         if tok.value in _TYPE_NAMES or _looks_like_type(tokens, pos):
             try:
@@ -1158,8 +1163,8 @@ def parse_statement(tokens: list[Token], pos: int):
     if tok.type == TokenType.KEYWORD and tok.value == 'switch':
         return parse_switch(tokens, pos)
 
-    if tok.type == TokenType.KEYWORD and tok.value in ('while', 'for', 'class', 'struct', 'import'):
-        handler = {'while': parse_while, 'for': parse_for, 'class': parse_class, 'struct': parse_struct_def, 'import': parse_import}[tok.value]
+    if tok.type == TokenType.KEYWORD and tok.value in ('while', 'for', 'class', 'struct', 'import', 'enum', 'type'):
+        handler = {'while': parse_while, 'for': parse_for, 'class': parse_class, 'struct': parse_struct_def, 'import': parse_import, 'enum': parse_enum, 'type': parse_type_alias}[tok.value]
         return handler(tokens, pos)
 
     if tok.type == TokenType.KEYWORD and tok.value == 'try':
@@ -1268,8 +1273,26 @@ class Switch:
         self._token = token
     def __repr__(self):
         return f'Switch({self.value}, {self.cases})'
+
+
+class EnumDef:
+    __slots__ = ('name', 'members', '_token')
+    def __init__(self, name: str, members: list, token=None):
+        self.name = name
+        self.members = members
+        self._token = token
     def __repr__(self):
-        return f'Switch({self.value}, {self.cases})'
+        return f'EnumDef({self.name}, {self.members})'
+
+
+class TypeAlias:
+    __slots__ = ('name', 'target_type', '_token')
+    def __init__(self, name: str, target_type, token=None):
+        self.name = name
+        self.target_type = target_type
+        self._token = token
+    def __repr__(self):
+        return f'TypeAlias({self.name}, {self.target_type})'
 
 
 def parse_switch(tokens: list[Token], pos: int):
@@ -1348,6 +1371,61 @@ def parse_generic_params(tokens: list[Token], pos: int):
     return params, pos + 1
 
 
+def parse_enum(tokens: list[Token], pos: int):
+    tok = tokens[pos]
+    pos += 1
+    if pos >= len(tokens) or tokens[pos].type != TokenType.IDENTIFIER:
+        raise ParseError('Expected enum name', tokens[pos] if pos < len(tokens) else None)
+    name = tokens[pos].value
+    pos += 1
+    if pos >= len(tokens) or tokens[pos].type != TokenType.COLON:
+        raise ParseError('Expected ":" after enum name', tokens[pos] if pos < len(tokens) else None)
+    pos += 1
+    if pos >= len(tokens) or tokens[pos].type != TokenType.NEWLINE:
+        raise ParseError('Expected newline after ":"', tokens[pos] if pos < len(tokens) else None)
+    pos += 1
+    if pos >= len(tokens) or tokens[pos].type != TokenType.INDENT:
+        raise ParseError('Expected indented block', tokens[pos] if pos < len(tokens) else None)
+    pos += 1
+
+    members = []
+    while pos < len(tokens) and tokens[pos].type not in (TokenType.DEDENT, TokenType.EOF):
+        if tokens[pos].type != TokenType.IDENTIFIER:
+            raise ParseError('Expected enum member name', tokens[pos])
+        member_name = tokens[pos].value
+        pos += 1
+        member_value = None
+        if pos < len(tokens) and tokens[pos].type == TokenType.KEYWORD and tokens[pos].value == '=':
+            pos += 1
+            member_value, pos = parse_expression(tokens, pos)
+        members.append({'name': member_name, 'value': member_value, '_token': tokens[pos - 1]})
+        if pos < len(tokens) and tokens[pos].type == TokenType.NEWLINE:
+            pos += 1
+
+    if pos < len(tokens) and tokens[pos].type == TokenType.DEDENT:
+        pos += 1
+
+    return EnumDef(name, members, token=tok), pos
+
+
+def parse_type_alias(tokens: list[Token], pos: int):
+    tok = tokens[pos]
+    pos += 1
+    if pos >= len(tokens) or tokens[pos].type != TokenType.IDENTIFIER:
+        raise ParseError('Expected type alias name', tokens[pos] if pos < len(tokens) else None)
+    name = tokens[pos].value
+    pos += 1
+    if pos >= len(tokens) or tokens[pos].type != TokenType.EQUAL:
+        raise ParseError('Expected "="', tokens[pos] if pos < len(tokens) else None)
+    pos += 1
+    target_type, pos = parse_type(tokens, pos)
+    target_type_str = _type_to_str(target_type) if isinstance(target_type, tuple) else target_type
+    _expect_newline(tokens, pos, tok)
+    if pos < len(tokens) and tokens[pos].type == TokenType.NEWLINE:
+        pos += 1
+    return TypeAlias(name, target_type_str, token=tok), pos
+
+
 def parse_def(tokens: list[Token], pos: int):
     tok = tokens[pos]
     pos += 1

{cpyte-2.0.2 → cpyte-2.2.0}/source/cpyte/bytecoding.py

@@ -107,6 +107,15 @@ class LLVM:
 
     def __init__(self, no_userspace=False, enable_extensions=True):
         self.module = ir.Module("main")
+        try:
+            import llvmlite.binding as _binding
+            _binding.initialize_native_target()
+            _target = _binding.Target.from_default_triple()
+            _tm = _target.create_target_machine()
+            self.module.triple = _tm.triple
+            self.module.data_layout = _tm.target_data.get_data_layout()
+        except Exception:
+            pass
         self.builder = None
         self.functions = {}
         self.global_vars = {}
@@ -122,6 +131,9 @@ class LLVM:
         self.loop_stack = []
         self._malloc_fn = None
         self._free_fn = None
+        self._gc_alloc_fn = None
+        self._gc_mark_fn = None
+        self._gc_root_register_fn = None
         self._strlen_fn = None
         self._memcpy_fn = None
         self.no_userspace = no_userspace
@@ -171,6 +183,24 @@ class LLVM:
             fn = ir.Function(self.module, ir.FunctionType(ret, args), name=name)
             self.functions[name] = fn
 
+        # Boehm GC runtime functions
+        gc_fns = [
+            ('GC_init', _void, []),
+            ('GC_malloc', _i8ptr, [_i64]),
+            ('GC_realloc', _i8ptr, [_i8ptr, _i64]),
+            ('GC_free', _void, [_i8ptr]),
+            ('GC_gcollect', _void, []),
+            ('GC_get_heap_size', _i64, []),
+            ('GC_get_free_bytes', _i64, []),
+            ('GC_disable', _void, []),
+            ('GC_enable', _void, []),
+            ('GC_add_roots', _void, [_i8ptr, _i8ptr]),
+            ('GC_remove_roots', _void, [_i8ptr, _i8ptr]),
+        ]
+        for name, ret, args in gc_fns:
+            fn = ir.Function(self.module, ir.FunctionType(ret, args), name=name)
+            self.functions[name] = fn
+
         # Exception handling globals
         self._exc_buf_ptr = ir.GlobalVariable(self.module, _i8ptr, "_exc_buf_ptr")
         self._exc_buf_ptr.initializer = ir.Constant(_i8ptr, None)
@@ -413,6 +443,10 @@ class LLVM:
 
         if wrapper_builder is not None:
             self.builder = wrapper_builder
+            # Initialize Boehm GC at program start
+            gc_init_fn = self.functions.get('GC_init')
+            if gc_init_fn:
+                self.builder.call(gc_init_fn, [])
             for node in toplevel:
                 self.emit(node)
             self.builder.ret(ir.Constant(ir.IntType(32), 0))
@@ -547,19 +581,21 @@ class LLVM:
         return ptr
 
     def _get_malloc_fn(self):
-        fn = self._malloc_fn
+        # Use Boehm GC allocator instead of malloc
+        fn = self._gc_alloc_fn
         if fn is not None:
             return fn
         for f in self.module.functions:
-            if f.name == 'malloc':
-                self._malloc_fn = f
+            if f.name == 'GC_malloc':
+                self._gc_alloc_fn = f
                 return f
         fnty = ir.FunctionType(_i8ptr, [_i64])
-        fn = ir.Function(self.module, fnty, 'malloc')
-        self._malloc_fn = fn
+        fn = ir.Function(self.module, fnty, 'GC_malloc')
+        self._gc_alloc_fn = fn
         return fn
 
     def _get_free_fn(self):
+        # Boehm GC manages memory - free is a no-op but keep for compatibility
         fn = self._free_fn
         if fn is not None:
             return fn
@@ -674,6 +710,9 @@ class LLVM:
         return self.builder.gep(obj, [idx], inbounds=True)
 
     def emit_attr(self, node: Attr):
+        enum_val = getattr(node, '_enum_member_value', None)
+        if enum_val is not None:
+            return ir.Constant(ir.IntType(32), enum_val)
         ptr = self._emit_lvalue_attr(node)
         return self.builder.load(ptr)
 
@@ -801,6 +840,12 @@ class LLVM:
         self.builder = ir.IRBuilder(entry)
         self.builder.position_at_end(entry)
 
+        # Initialize Boehm GC in main function
+        if node.name == 'main':
+            gc_init_fn = self.functions.get('GC_init')
+            if gc_init_fn:
+                self.builder.call(gc_init_fn, [])
+
         old_locals = self.locals
         old_local_types = self.local_types
         self.locals = {}
@@ -1067,6 +1112,18 @@ class LLVM:
                     cmp = self.builder.call(self.functions['bigint_cmp'], [left, right])
                     return self.builder.icmp_signed('>=', cmp, ir.Constant(_i64, 0))
 
+        # String equality via strcmp (content, not pointer comparison)
+        if node.op in (TokenType.EQ_EQ, TokenType.NOT_EQ):
+            left_str = getattr(node.left, 'inferred_type', None) == 'str'
+            right_str = getattr(node.right, 'inferred_type', None) == 'str'
+            if left_str and right_str:
+                cmp = self.builder.call(self._strcmp_fn, [left, right])
+                zero = ir.Constant(_i32, 0)
+                if node.op == TokenType.EQ_EQ:
+                    return self.builder.icmp_signed('==', cmp, zero)
+                else:
+                    return self.builder.icmp_signed('!=', cmp, zero)
+
         left, right = self._promote(left, right)
         is_float = isinstance(left.type, ir.DoubleType) or isinstance(right.type, ir.DoubleType)
         if is_float:
@@ -1096,20 +1153,6 @@ class LLVM:
                 case TokenType.NOT_EQ:
                     return self.builder.fcmp_ordered('!=', left, right)
 
-        # String equality via strcmp (content, not pointer comparison)
-        if node.op in (TokenType.EQ_EQ, TokenType.NOT_EQ):
-            left_str = getattr(node.left, 'inferred_type', None) == 'str'
-            right_str = getattr(node.right, 'inferred_type', None) == 'str'
-            if left_str and right_str:
-                fnty = ir.FunctionType(_i32, [_i8ptr, _i8ptr])
-                fn = ir.Function(self.module, fnty, '__cpy_strcmp')
-                cmp = self.builder.call(fn, [left, right])
-                zero = ir.Constant(_i32, 0)
-                if node.op == TokenType.EQ_EQ:
-                    return self.builder.icmp_signed('==', cmp, zero)
-                else:
-                    return self.builder.icmp_signed('!=', cmp, zero)
-
         match node.op:
             case TokenType.PLUS:
                 return self.builder.add(left, right)

{cpyte-2.0.2 → cpyte-2.2.0}/source/cpyte/compiling.py

@@ -82,13 +82,15 @@ def optimize(mod, opt_level=3):
     npm.run(mod, pb)
 
 
-def _compile_sources_object(src_files, target_triple=None):
+def _compile_sources_object(src_files, target_triple=None, pic=False):
     objs = []
     for src in src_files:
         obj = src.rsplit('.', 1)[0] + '.o'
         cmd = ['clang', '-c', '-O3', '-o', obj, src]
         if target_triple:
             cmd.extend(['-target', target_triple])
+        if pic:
+            cmd.append('-fPIC')
         r = subprocess.run(cmd, capture_output=True, text=True)
         if r.returncode != 0:
             print(f'error compiling {src}: {r.stderr}', file=__import__('sys').stderr)
@@ -110,7 +112,7 @@ def _maybe_compile(module):
         return prog, src_files
     return module, None
 
-def run_jit(module, opt_level=3, src_files=None, no_userspace=False):
+def run_jit(module, opt_level=3, src_files=None, no_userspace=False, pic=False):
     module, src_files_auto = _maybe_compile(module)
     if src_files_auto is not None:
         src_files = src_files_auto
@@ -128,16 +130,15 @@ def run_jit(module, opt_level=3, src_files=None, no_userspace=False):
                 with open(src) as f:
                     src_ir = f.read()
             else:
-                ll = src.rsplit('.', 1)[0] + '.ll'
                 r = subprocess.run(
                     ['clang', '-S', '-emit-llvm', '-O0', '-target', target.triple,
-                     '-fno-stack-protector', '-o', ll, src],
-                    capture_output=True, text=True
-                )
+                     '-fno-stack-protector', '-o', '-', src],
+                    capture_output=True, text=True)
+
                 if r.returncode != 0:
                     print(f'error compiling {src}: {r.stderr}', file=__import__('sys').stderr)
                     raise SystemExit(1)
-                src_ir = open(ll).read()
+                src_ir = r.stdout
             src_ir = _remove_probe_stack_ir(src_ir)
             src_mod = binding.parse_assembly(src_ir)
             binding.link_modules(mod, src_mod)
@@ -228,10 +229,20 @@ def run_jit(module, opt_level=3, src_files=None, no_userspace=False):
             pass
 
     _map_libc_fn(engine, mod, 'malloc', ctypes.c_size_t, ctypes.c_void_p)
+    _map_libc_fn(engine, mod, 'free', None, None, argtypes=[ctypes.c_void_p])
     _map_libc_fn(engine, mod, 'strlen', ctypes.c_char_p, ctypes.c_int)
     _map_libc_fn(engine, mod, 'memcpy', None, ctypes.c_void_p,
                  argtypes=[ctypes.c_void_p, ctypes.c_void_p, ctypes.c_int])
 
+    try:
+        fn = mod.get_function('strcmp')
+        cfunctype = ctypes.CFUNCTYPE(ctypes.c_int, ctypes.c_char_p, ctypes.c_char_p)
+        cfn = cfunctype(_libc.strcmp)
+        _callbacks.append(cfn)
+        engine.add_global_mapping(fn, ctypes.cast(cfn, ctypes.c_void_p).value)
+    except NameError:
+        pass
+
     try:
         fn = mod.get_function('__cpy_strcmp')
         cfunctype = ctypes.CFUNCTYPE(ctypes.c_int, ctypes.c_char_p, ctypes.c_char_p)
@@ -241,6 +252,49 @@ def run_jit(module, opt_level=3, src_files=None, no_userspace=False):
     except NameError:
         pass
 
+    # Map Boehm GC functions
+    # NOTE: Boehm GC cannot safely scan JIT'd code stacks on ARM64 macOS
+    # because JIT'd frames lack DWARF unwind info. For JIT, GC_malloc
+    # falls back to malloc (no collection needed - process exits immediately).
+    # For AOT, Boehm GC works normally via libgc linkage (-lgc).
+    try:
+        _libgc = ctypes.CDLL('/opt/homebrew/lib/libgc.dylib')
+        _gc_fns = {
+            'GC_init': (None, []),
+            'GC_realloc': (ctypes.c_void_p, [ctypes.c_void_p, ctypes.c_size_t]),
+            'GC_free': (None, [ctypes.c_void_p]),
+            'GC_gcollect': (None, []),
+            'GC_get_heap_size': (ctypes.c_size_t, []),
+            'GC_get_free_bytes': (ctypes.c_size_t, []),
+            'GC_disable': (None, []),
+            'GC_enable': (None, []),
+            'GC_add_roots': (None, [ctypes.c_void_p, ctypes.c_void_p]),
+            'GC_remove_roots': (None, [ctypes.c_void_p, ctypes.c_void_p]),
+        }
+        for gc_name, (gc_restype, gc_argtypes) in _gc_fns.items():
+            try:
+                fn = mod.get_function(gc_name)
+                if gc_argtypes:
+                    cfunctype = ctypes.CFUNCTYPE(gc_restype, *gc_argtypes)
+                else:
+                    cfunctype = ctypes.CFUNCTYPE(gc_restype)
+                cfn = cfunctype(getattr(_libgc, gc_name))
+                _callbacks.append(cfn)
+                engine.add_global_mapping(fn, ctypes.cast(cfn, ctypes.c_void_p).value)
+            except (NameError, AttributeError):
+                pass
+        # For JIT: map GC_malloc to malloc (avoids Boehm stack scanning crashes)
+        try:
+            fn = mod.get_function('GC_malloc')
+            cfunctype = ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_size_t)
+            cfn = cfunctype(_libc.malloc)
+            _callbacks.append(cfn)
+            engine.add_global_mapping(fn, ctypes.cast(cfn, ctypes.c_void_p).value)
+        except (NameError, AttributeError):
+            pass
+    except OSError:
+        pass
+
     engine.finalize_object()
     engine.run_static_constructors()
 
@@ -271,7 +325,7 @@ def _map_libc_fn(engine, mod, name, argtype, restype, argtypes=None):
         pass
 
 
-def run_aot(module, output="program.o", opt_level=3, src_files=None, no_userspace=False):
+def run_aot(module, output="program.o", opt_level=3, src_files=None, no_userspace=False, pic=False):
     llvm_ir = str(module)
     import llvmlite.binding as binding
     binding.initialize_native_target()
@@ -285,7 +339,10 @@ def run_aot(module, output="program.o", opt_level=3, src_files=None, no_userspac
     mod.verify()
 
     target = binding.Target.from_default_triple()
-    target_machine = target.create_target_machine()
+    if pic:
+        target_machine = target.create_target_machine(reloc='pic')
+    else:
+        target_machine = target.create_target_machine()
 
     obj = target_machine.emit_object(mod)
 
@@ -295,8 +352,11 @@ def run_aot(module, output="program.o", opt_level=3, src_files=None, no_userspac
     objs = [output]
     for src in (src_files or []):
         src_obj = src.rsplit('.', 1)[0] + '.o'
+        cmd = ['clang', '-c', '-O3', '-o', src_obj, src]
+        if pic:
+            cmd.append('-fPIC')
         r = subprocess.run(
-            ['clang', '-c', '-O3', '-o', src_obj, src],
+            cmd,
             capture_output=True, text=True
         )
         if r.returncode != 0:
@@ -306,8 +366,11 @@ def run_aot(module, output="program.o", opt_level=3, src_files=None, no_userspac
     
     if not no_userspace:
         runtime_obj = output + '.runtime.o'
+        cmd = ['clang', '-c', '-O3', '-o', runtime_obj, _RUNTIME_C]
+        if pic:
+            cmd.append('-fPIC')
         r = subprocess.run(
-            ['clang', '-c', '-O3', '-o', runtime_obj, _RUNTIME_C],
+            cmd,
             capture_output=True, text=True
         )
         if r.returncode == 0:
@@ -315,7 +378,8 @@ def run_aot(module, output="program.o", opt_level=3, src_files=None, no_userspac
 
     out_name = output.rsplit('.', 1)[0] if '.' in output else output
     r = subprocess.run(
-        ['clang', '-O3', '-o', out_name] + objs + ['-lm'],
+        ['clang', '-O3', '-o', out_name] + objs + ['-lgc', '-lm',
+         '-L/opt/homebrew/opt/bdw-gc/lib', '-I/opt/homebrew/opt/bdw-gc/include'],
         capture_output=True, text=True
     )
     if r.returncode != 0:

{cpyte-2.0.2 → cpyte-2.2.0}/source/cpyte/extension_hooks.py

@@ -209,8 +209,13 @@ class HookRegistry:
         """Get the current compiler context."""
         return self._context.copy()
     
+    def _is_duplicate(self, existing_list, package_name, hook_path) -> bool:
+        return any(r.package_name == package_name and r.hook_path == hook_path for r in existing_list)
+
     def register_lexer_hook(self, hook: LexerHook, priority: int = 0) -> None:
         """Register a lexer hook."""
+        if self._is_duplicate(self._lexer_hooks, hook.package_name, hook.hook_path):
+            return
         registration = HookRegistration(
             hook=hook,
             priority=priority,
@@ -219,9 +224,11 @@ class HookRegistry:
         )
         self._lexer_hooks.append(registration)
         self._lexer_hooks.sort(key=lambda r: r.priority, reverse=True)
-    
+
     def register_parser_hook(self, hook: ParserHook, priority: int = 0) -> None:
         """Register a parser hook."""
+        if self._is_duplicate(self._parser_hooks, hook.package_name, hook.hook_path):
+            return
         registration = HookRegistration(
             hook=hook,
             priority=priority,
@@ -230,9 +237,11 @@ class HookRegistry:
         )
         self._parser_hooks.append(registration)
         self._parser_hooks.sort(key=lambda r: r.priority, reverse=True)
-    
+
     def register_semantic_hook(self, hook: SemanticHook, priority: int = 0) -> None:
         """Register a semantic analysis hook."""
+        if self._is_duplicate(self._semantic_hooks, hook.package_name, hook.hook_path):
+            return
         registration = HookRegistration(
             hook=hook,
             priority=priority,
@@ -244,6 +253,8 @@ class HookRegistry:
     
     def register_codegen_hook(self, hook: CodegenHook, priority: int = 0) -> None:
         """Register a code generation hook."""
+        if self._is_duplicate(self._codegen_hooks, hook.package_name, hook.hook_path):
+            return
         registration = HookRegistration(
             hook=hook,
             priority=priority,
@@ -252,9 +263,11 @@ class HookRegistry:
         )
         self._codegen_hooks.append(registration)
         self._codegen_hooks.sort(key=lambda r: r.priority, reverse=True)
-    
+
     def register_runtime_hook(self, hook: RuntimeHook, priority: int = 0) -> None:
         """Register a runtime hook."""
+        if self._is_duplicate(self._runtime_hooks, hook.package_name, hook.hook_path):
+            return
         registration = HookRegistration(
             hook=hook,
             priority=priority,

{cpyte-2.0.2 → cpyte-2.2.0}/source/cpyte/lexar.py

@@ -72,6 +72,7 @@ _BASE_KEYWORDS = {
     'let',
     'try', 'except', 'raise',
     'asm',
+    'enum', 'type',
 }
 
 # Additional keywords registered by packages

{cpyte-2.0.2 → cpyte-2.2.0}/source/cpyte/linker.py

@@ -35,13 +35,15 @@ class Linker:
     def cc(self):
         return self._cc
 
-    def compile_c(self, src, output=None, opt_level=3, debug=False):
+    def compile_c(self, src, output=None, opt_level=3, debug=False, pic=False):
         if output is None:
             base = src.rsplit('.', 1)[0] if '.' in src else src
             output = base + '.o'
         cmd = [self._cc, '-c']
         if debug:
             cmd.append('-g')
+        if pic:
+            cmd.append('-fPIC')
         if opt_level is not None:
             cmd.append(f'-O{opt_level}')
         cmd.extend(['-o', output, src])
@@ -52,10 +54,12 @@ class Linker:
         return output
 
     def link(self, objects, output, libraries=None, library_paths=None,
-             shared=False, debug=False, opt_level=3, frameworks=None):
+             shared=False, debug=False, opt_level=3, frameworks=None, pic=False):
         cmd = [self._cc]
         if shared:
             cmd.append('-shared')
+        if pic:
+            cmd.append('-fPIC')
         if debug:
             cmd.append('-g')
         if opt_level is not None:
@@ -77,13 +81,13 @@ class Linker:
 
 
 def build(objects, output=None, libraries=None, library_paths=None,
-          shared=False, debug=False, opt_level=3, cc=None, frameworks=None):
+          shared=False, debug=False, opt_level=3, cc=None, frameworks=None, pic=False):
     linker = Linker(cc)
 
     final_objects = []
     for src in objects:
         if src.endswith('.c'):
-            obj = linker.compile_c(src, opt_level=opt_level, debug=debug)
+            obj = linker.compile_c(src, opt_level=opt_level, debug=debug, pic=pic)
             final_objects.append(obj)
         else:
             final_objects.append(src)
@@ -100,5 +104,5 @@ def build(objects, output=None, libraries=None, library_paths=None,
         libraries=libraries, library_paths=library_paths,
         shared=shared,
         debug=debug, opt_level=opt_level,
-        frameworks=frameworks,
+        frameworks=frameworks, pic=pic,
     )

{cpyte-2.0.2 → cpyte-2.2.0}/source/cpyte/mainpie.py

@@ -283,9 +283,9 @@ def _collect_frameworks(nodes):
     return list(set(frameworks))
 
 
-def cmd_build(args, tab_size=4, strict=False, no_userspace=False):
+def cmd_build(args, tab_size=4, strict=False, no_userspace=False, pic=False):
     if not args:
-        print('Usage: cpy build [--output O] [--debug] [--opt N] [--no-userspace] <source.cpy>', file=sys.stderr)
+        print('Usage: cpy build [--output O] [--debug] [--opt N] [--no-userspace] [--pic] <source.cpy>', file=sys.stderr)
         sys.exit(1)
 
     output = None
@@ -308,6 +308,9 @@ def cmd_build(args, tab_size=4, strict=False, no_userspace=False):
         elif a == '--no-userspace':
             no_userspace = True
             i += 1
+        elif a == '--pic':
+            pic = True
+            i += 1
         elif a == '--opt' and i + 1 < len(args):
             opt = int(args[i + 1])
             i += 2
@@ -319,7 +322,7 @@ def cmd_build(args, tab_size=4, strict=False, no_userspace=False):
             sys.exit(1)
 
     if not src_file:
-        print('Usage: cpy build [--output O] [--debug] [--opt N] <source.cpy>', file=sys.stderr)
+        print('Usage: cpy build [--output O] [--debug] [--opt N] [--pic] <source.cpy>', file=sys.stderr)
         sys.exit(1)
 
     with open(src_file) as f:
@@ -345,7 +348,10 @@ def cmd_build(args, tab_size=4, strict=False, no_userspace=False):
     mod.verify()
 
     target = binding.Target.from_default_triple()
-    target_machine = target.create_target_machine()
+    if pic:
+        target_machine = target.create_target_machine(reloc='pic')
+    else:
+        target_machine = target.create_target_machine()
     obj = target_machine.emit_object(mod)
     with open(obj_file, 'wb') as f:
         f.write(obj)
@@ -354,16 +360,17 @@ def cmd_build(args, tab_size=4, strict=False, no_userspace=False):
     objs = [obj_file]
     for src in (src_files or []):
         src_obj = src.rsplit('.', 1)[0] + '.o'
-        l.compile_c(src, output=src_obj, opt_level=opt, debug=debug)
+        l.compile_c(src, output=src_obj, opt_level=opt, debug=debug, pic=pic)
         objs.append(src_obj)
 
     if not no_userspace:
         runtime_obj = out_base + '.runtime.o'
-        l.compile_c(_RUNTIME_C, output=runtime_obj, opt_level=opt, debug=debug)
+        l.compile_c(_RUNTIME_C, output=runtime_obj, opt_level=opt, debug=debug, pic=pic)
         objs.append(runtime_obj)
 
     executable = output or out_base
-    l.link(objs, executable, opt_level=opt, debug=debug, frameworks=frameworks)
+    l.link(objs, executable, libraries=['gc'], library_paths=['/opt/homebrew/opt/bdw-gc/lib'],
+           opt_level=opt, debug=debug, frameworks=frameworks, pic=pic)
     print(f'Wrote {executable}')
 
 
@@ -374,6 +381,7 @@ def main():
 
     strict = False
     no_userspace = False
+    pic = False
     while args and args[0].startswith('--'):
         flag = args.pop(0)
         if flag == '--tab-size':
@@ -382,6 +390,8 @@ def main():
             strict = True
         elif flag == '--no-userspace':
             no_userspace = True
+        elif flag == '--pic':
+            pic = True
         elif flag == '--ast':
             mode = 'ast'
         elif flag == '--emit-llvm':
@@ -395,12 +405,12 @@ def main():
             sys.exit(1)
 
     if not args:
-        print('Usage: cpy [--tab-size N] [--strict] [--no-userspace] [--ast|--emit-llvm|--jit|--aot] <source file>', file=sys.stderr)
-        print('       cpy build [--output O] [--debug] [--opt N] [--no-userspace] <source.cpy>', file=sys.stderr)
+        print('Usage: cpy [--tab-size N] [--strict] [--no-userspace] [--pic] [--ast|--emit-llvm|--jit|--aot] <source file>', file=sys.stderr)
+        print('       cpy build [--output O] [--debug] [--opt N] [--no-userspace] [--pic] <source.cpy>', file=sys.stderr)
         sys.exit(1)
 
     if args[0] == 'build':
-        cmd_build(args[1:], tab_size=tab_size, strict=strict, no_userspace=no_userspace)
+        cmd_build(args[1:], tab_size=tab_size, strict=strict, no_userspace=no_userspace, pic=pic)
         return
 
     with open(args[0]) as f:
@@ -419,10 +429,10 @@ def main():
     elif mode == 'aot':
         out_base = args[0].rsplit('.', 1)[0] if '.' in args[0] else 'program'
         obj_file = 'program.o'
-        run_aot(prog, output=obj_file, src_files=src_files, no_userspace=no_userspace)
+        run_aot(prog, output=obj_file, src_files=src_files, no_userspace=no_userspace, pic=pic)
         print(f'Wrote {out_base}')
     else:
-        run_jit(prog, src_files=src_files, no_userspace=no_userspace)
+        run_jit(prog, src_files=src_files, no_userspace=no_userspace, pic=pic)
 
 
 if __name__ == '__main__':

{cpyte-2.0.2 → cpyte-2.2.0}/source/cpyte/semantic_analasis.py

@@ -27,6 +27,7 @@ from .astparse import (
     VarDecl, Break, Continue, Switch, Import, While,
     NewExpr, Deref, AddrOf, SizeOf, StructDef, Field, Input,
     InputStr, Signed67, Try, Raise, ExceptHandler, InlineAsm,
+    EnumDef, TypeAlias,
     parse_file, ParseError,
 )
 from .clib import resolve_library, parse_header_file, parse_c_source
@@ -360,6 +361,12 @@ class SemanticAnalyzer:
                 return None
             if sym.const_value is not None:
                 node.const_value = sym.const_value
+            if sym.kind in ('enum', 'struct'):
+                node.inferred_type = node.name
+                return node.name
+            if sym.kind == 'type_alias':
+                node.inferred_type = sym.type
+                return sym.type
             node.inferred_type = sym.type
             return sym.type
 
@@ -581,6 +588,17 @@ class SemanticAnalyzer:
             obj_t = self._infer_type(node.obj)
             if obj_t:
                 lookup_t = obj_t[:-1] if obj_t.endswith('*') else obj_t
+                sym = self.current_scope.lookup(lookup_t)
+                if sym and sym.kind == 'enum':
+                    member_sym = self.current_scope.lookup(f'{lookup_t}.{node.name}')
+                    if member_sym and member_sym.kind == 'enum_member':
+                        node._enum_member_value = member_sym.const_value
+                        return 'int'
+                    self.error(
+                        f'enum `{lookup_t}` has no member `{node.name}`',
+                        node
+                    )
+                    return None
                 struct_sym = self.current_scope.lookup(lookup_t)
                 if struct_sym and struct_sym.kind == 'struct' and struct_sym.node:
                     for field in struct_sym.node.fields:
@@ -707,6 +725,10 @@ class SemanticAnalyzer:
             self._visit_import(node)
         elif isinstance(node, StructDef):
             self._visit_struct(node, scope)
+        elif isinstance(node, EnumDef):
+            self._visit_enum(node, scope)
+        elif isinstance(node, TypeAlias):
+            self._visit_type_alias(node, scope)
         elif isinstance(node, Try):
             self._visit_try(node, scope)
         elif isinstance(node, Raise):
@@ -1160,7 +1182,8 @@ class SemanticAnalyzer:
             self._infer_type(node.target)
 
     def _visit_vardecl(self, node: VarDecl, scope: Scope | None = None):
-        val_type = node.var_type
+        val_type = self._resolve_type_alias(node.var_type)
+        node.var_type = val_type
         s = scope or self.current_scope
         existing = s.lookup_local(node.name)
         if existing:
@@ -1283,6 +1306,54 @@ class SemanticAnalyzer:
         for field in node.fields:
             struct_scope.define(field.name, Symbol('field', field.type_expr, node))
 
+    def _visit_enum(self, node: EnumDef, scope: Scope | None = None):
+        s = scope or self.globals
+        existing = s.lookup_local(node.name)
+        if existing:
+            self.error(f'redefinition of enum `{node.name}`', node)
+            return
+        s.define(node.name, Symbol('enum', None, node))
+        for i, member in enumerate(node.members):
+            if member['value'] is not None:
+                val = self._eval_const_expr(member['value'])
+                member['_const_value'] = val
+            else:
+                member['_const_value'] = i
+                member['_auto_index'] = i
+            sym = Symbol('enum_member', node.name, node)
+            sym.const_value = member['_const_value']
+            s.define(f'{node.name}.{member["name"]}', sym)
+
+    def _visit_type_alias(self, node: TypeAlias, scope: Scope | None = None):
+        s = scope or self.globals
+        existing = s.lookup_local(node.name)
+        if existing:
+            self.error(f'redefinition of type alias `{node.name}`', node)
+            return
+        s.define(node.name, Symbol('type_alias', node.target_type, node))
+
+    def _eval_const_expr(self, node):
+        if isinstance(node, Number):
+            return node.value
+        if isinstance(node, UnaryOp):
+            val = self._eval_const_expr(node.operand)
+            if node.op.name == 'MINUS':
+                return -val
+            if node.op.name == 'NOT':
+                return not val
+        if isinstance(node, BinOp):
+            left = self._eval_const_expr(node.left)
+            right = self._eval_const_expr(node.right)
+            match node.op.name:
+                case 'PLUS': return left + right
+                case 'MINUS': return left - right
+                case 'STAR': return left * right
+                case 'SLASH': return left // right
+                case 'PERCENT': return left % right
+        if isinstance(node, Variable):
+            return node.const_value
+        return None
+
     def _visit_while(self, node, scope: Scope | None = None):
         if isinstance(node, While):
             self._infer_type(node.cond)
@@ -1314,6 +1385,14 @@ class SemanticAnalyzer:
         self._loop_depth -= 1
         self.locals = old_locals
 
+    def _resolve_type_alias(self, type_name):
+        if type_name is None:
+            return None
+        sym = self.current_scope.lookup(type_name)
+        if sym and sym.kind == 'type_alias':
+            return self._resolve_type_alias(sym.type)
+        return type_name
+
 
 def analyze(source: str, nodes: list, strict: bool = False, workspace_root: str | None = None, enable_extensions: bool = True) -> str | None:
     analyzer = SemanticAnalyzer(source, strict=strict, workspace_root=workspace_root, enable_extensions=enable_extensions)

{cpyte-2.0.2 → cpyte-2.2.0}/source/cpyte.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cpyte
-Version: 2.0.2
+Version: 2.2.0
 Summary: The Cpyte programming language compiler
 Author: Hoang Duy Tung
 License: MIT
@@ -81,3 +81,9 @@ python source/mainpie.py --jit examples/<filename>.cpy
 Cpyte is experimental software. The compiler is continuously tested with fuzzing, and we're still discovering and fixing correctness bugs. While many programs compile and run correctly, I can't make any guarantees about correctness or stability.
 
 If you decide to use Cpyte, always use the latest version — older versions have bugs that are pretty easy to run into.
+
+## Memory Management
+
+Cpyte uses **Boehm GC** (bdw-gc) for automatic garbage collection. Heap-allocated objects (via `new`) are managed automatically — no manual `free` needed.
+
+**Note:** Boehm GC adds a small runtime overhead (~5-10%) compared to manual `malloc/free`. For performance-critical ecosystem projects or embedded use cases, this trade-off may be significant. The GC is required for safety but will slow down programs that do heavy heap allocation.