cpyte 3.3.2__tar.gz → 3.3.3__tar.gz

{cpyte-3.3.2 → cpyte-3.3.3}/MANIFEST.in

@@ -1 +1,2 @@
 include source/cpyte/*.c
+include source/cpyte/*.h

{cpyte-3.3.2/source/cpyte.egg-info → cpyte-3.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cpyte
-Version: 3.3.2
+Version: 3.3.3
 Summary: The Cpyte programming language compiler
 Author: Hoang Duy Tung
 License: MIT

{cpyte-3.3.2 → cpyte-3.3.3}/pyproject.toml

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

cpyte-3.3.3/source/cpyte/__init__.py

@@ -0,0 +1 @@
+__version__ = "3.3.3"

{cpyte-3.3.2 → cpyte-3.3.3}/source/cpyte/astparse.py

@@ -1245,10 +1245,10 @@ def parse_import(tokens: list[Token], pos: int):
         assert first is not None
         parts = [first]
         pos += 1
-        while pos < len(tokens) and tokens[pos].type == TokenType.DOT:
+        while pos < len(tokens) and tokens[pos].type in (TokenType.DOT, TokenType.SLASH):
             pos += 1
             if pos >= len(tokens) or tokens[pos].type != TokenType.IDENTIFIER:
-                raise ParseError('Expected identifier after . in package name', tokens[pos] if pos < len(tokens) else None)
+                raise ParseError('Expected identifier after package separator in package name', tokens[pos] if pos < len(tokens) else None)
             part = tokens[pos].value
             assert part is not None
             parts.append(part)

{cpyte-3.3.2 → cpyte-3.3.3}/source/cpyte/bytecoding.py

@@ -2050,7 +2050,10 @@ class LLVM:
             if parent_struct and parent_struct in self.struct_fields:
                 return self._field_type_name(parent_struct, node.name)
         if isinstance(node, Index):
-            return self._struct_name_from_node(node.obj)
+            base = self._struct_name_from_node(node.obj)
+            if base:
+                return self._base_type_name(base)
+            return None
         return None
 
     def _emit_lvalue_attr(self, node: Attr):

{cpyte-3.3.2 → cpyte-3.3.3}/source/cpyte/mainpie.py

@@ -7,14 +7,14 @@ if __package__:
     from .astparse import Import, ParseError, parse_file
     from .bytecoding import LLVM
     from .compiling import (
-        _RUNTIME_C,
         _GC_RUNTIME_C,
+        _RUNTIME_C,
         optimize,
         run_aot,
         run_jit,
         run_scorpion,
     )
-    from .extension_hooks import HookLoader, HookStage, get_global_hook_registry
+    from .extension_hooks import HookStage, get_global_hook_registry
     from .lexar import Lexer, LexerError, register_keywords
     from .linker import Linker
     from .package_manifest import (
@@ -32,14 +32,14 @@ else:
     from cpyte.astparse import Import, ParseError, parse_file
     from cpyte.bytecoding import LLVM
     from cpyte.compiling import (
-        _RUNTIME_C,
         _GC_RUNTIME_C,
+        _RUNTIME_C,
         optimize,
         run_aot,
         run_jit,
         run_scorpion,
     )
-    from cpyte.extension_hooks import HookLoader, HookStage, get_global_hook_registry
+    from cpyte.extension_hooks import HookStage, get_global_hook_registry
     from cpyte.lexar import Lexer, LexerError, register_keywords
     from cpyte.linker import Linker
     from cpyte.package_manifest import (
@@ -326,10 +326,26 @@ def _notify_deep_hook_usage() -> None:
     )
 
 
-def _compile(source, tab_size=4, strict=False, enable_extensions=True, no_gc=False):
+def _find_workspace_root(filepath: str | None) -> str:
+    if not filepath:
+        return os.getcwd()
+    path = os.path.abspath(filepath)
+    dirpath = os.path.dirname(path)
+    while True:
+        if os.path.isdir(os.path.join(dirpath, ".cpm")):
+            return dirpath
+        parent = os.path.dirname(dirpath)
+        if parent == dirpath:
+            return os.getcwd()
+        dirpath = parent
+
+
+def _compile(source, tab_size=4, strict=False, enable_extensions=True, no_gc=False, filepath=None):
+    workspace_root = _find_workspace_root(filepath)
+
     # Pre-load package manifests if extensions are enabled
     if enable_extensions:
-        _load_package_manifests_from_source(os.getcwd())
+        _load_package_manifests_from_source(workspace_root)
 
     lex = Lexer(source, tab_size=tab_size, enable_extensions=enable_extensions)
     tokens = lex.get_tokens()
@@ -342,7 +358,8 @@ def _compile(source, tab_size=4, strict=False, enable_extensions=True, no_gc=Fal
         source,
         parsed,
         strict=strict,
-        workspace_root=os.getcwd(),
+        workspace_root=workspace_root,
+        filepath=filepath,
         enable_extensions=enable_extensions,
         no_gc=no_gc,
     )
@@ -839,6 +856,7 @@ def _main():
         strict=strict,
         enable_extensions=not no_userspace,
         no_gc=no_gc,
+        filepath=os.path.abspath(args[0]),
     )
 
     if mode == "ast":

{cpyte-3.3.2 → cpyte-3.3.3}/source/cpyte/semantic_analasis.py

@@ -1125,6 +1125,18 @@ class SemanticAnalyzer:
                             node,
                             note="cannot divide integer by zero",
                         )
+                if left_t is not None and right_t is not None:
+                    left_ptr = left_t.endswith("*")
+                    right_ptr = right_t.endswith("*")
+                    if node.op.name in ("PLUS", "MINUS") and (
+                        (left_ptr and right_t == "int")
+                        or (right_ptr and left_t == "int")
+                    ):
+                        node.inferred_type = left_t if left_ptr else right_t
+                        return node.inferred_type
+                    if node.op.name == "MINUS" and left_ptr and right_ptr:
+                        node.inferred_type = "int"
+                        return "int"
                 if left_t is not None and right_t is not None and left_t != right_t:
                     # Usual arithmetic conversions: promote to the widest type
                     promoted = self._numeric_promote(left_t, right_t)
@@ -1996,21 +2008,33 @@ class SemanticAnalyzer:
         return None
 
     def _try_cpm_import(self, node: Import, module: str) -> bool:
-        # Check if package was already loaded via manifest
-        # Handle both @package.name and package.name formats
-        pkg_name = module.lstrip("@").rsplit("/", 1)[-1]
-        if pkg_name in self._loaded_packages:
-            # Package was loaded via manifest, register empty symbols and succeed
-            self._register_import_symbols({}, node)
-            return True
+        # Support both @scope.name and @scope/name import forms.
+        import_name = module[1:] if module.startswith("@") else module
+        pkg_name = import_name.replace("/", ".").split(".")[-1]
 
         cpm_root = None
         if self._workspace_root:
             cpm_root = os.path.join(self._workspace_root, ".cpm", "modules")
         elif self._filedir:
             cpm_root = os.path.join(self._filedir, "..", ".cpm", "modules")
+
+        # A package already loaded purely via its manifest (extension hooks only)
+        # has no real symbols; short-circuit only when no CPM directory exists to
+        # resolve a real entry from. A package that ships an entry file must still
+        # re-export its actual symbols below.
+        if pkg_name in self._loaded_packages and not (
+            cpm_root and os.path.isdir(cpm_root)
+        ):
+            self._register_import_symbols({}, node)
+            return True
+
         if cpm_root and os.path.isdir(cpm_root):
-            pkg_dir = os.path.join(cpm_root, module.lstrip("@"))
+            if module.startswith("@"):
+                scoped = module[1:].replace("/", ".").replace(".", os.sep)
+                pkg_dir = os.path.join(cpm_root, f"@{scoped.split(os.sep)[0]}", *scoped.split(os.sep)[1:])
+            else:
+                pkg_dir = os.path.join(cpm_root, *module.replace("/", ".").split("."))
+
             if os.path.isdir(pkg_dir):
                 versions = sorted(
                     [
@@ -2021,10 +2045,8 @@ class SemanticAnalyzer:
                     reverse=True,
                 )
                 if versions:
-                    pkg_name = module.lstrip("@").rsplit("/", 1)[-1]
                     version_dir = os.path.join(pkg_dir, versions[0])
 
-                    # Load package manifest if extensions are enabled
                     manifest_loaded = False
                     if self.enable_extensions:
                         manifest_loaded = self._load_package_manifest(
@@ -2041,12 +2063,12 @@ class SemanticAnalyzer:
                     if result:
                         return True
 
-                    # If no .cpy or prebuilt files but manifest was loaded, allow the import
-                    # This supports extension-only packages
                     if manifest_loaded:
-                        # Register empty symbols for extension-only packages
                         self._register_import_symbols({}, node)
                         return True
+        if self.enable_extensions and pkg_name in self._loaded_packages:
+            self._register_import_symbols({}, node)
+            return True
         return False
 
     def _import_cpy(self, module: str, node: Import | None = None):
@@ -2097,6 +2119,12 @@ class SemanticAnalyzer:
                     if fname not in symbols:
                         symbols[fname] = (ret_type, params, vararg)
 
+                # Preserve the sub-AST chain for re-exported imports so codegen
+                # can still reach the aggregated module's function definitions
+                # (emit_program recurses through Import sub_ast).
+                if getattr(ast_node, "sub_ast", None):
+                    sub_ast.append(ast_node)
+
         if node is not None:
             node.sub_ast = sub_ast
         return symbols, "cpy"
@@ -3335,11 +3363,13 @@ def analyze(
     nodes: list,
     strict: bool = False,
     workspace_root: str | None = None,
+    filepath: str | None = None,
     enable_extensions: bool = True,
     no_gc: bool = False,
 ):
     analyzer = SemanticAnalyzer(
         source,
+        filepath=filepath,
         strict=strict,
         workspace_root=workspace_root,
         enable_extensions=enable_extensions,

cpyte-3.3.3/source/cpyte/ugc.h

@@ -0,0 +1,426 @@
+#ifndef UGC_H
+#define UGC_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+#ifndef UGC_DECL
+#define UGC_DECL
+#endif
+
+#ifndef UGC_USE_TAGGED_POINTER
+#define UGC_USE_TAGGED_POINTER 1
+#endif
+
+typedef struct ugc_s ugc_t;
+typedef struct ugc_header_s ugc_header_t;
+
+/**
+ * @brief Callback function type.
+ * @see ugc_init
+ */
+typedef void(*ugc_visit_fn_t)(ugc_t* gc, ugc_header_t* obj);
+
+enum ugc_state_e
+{
+	UGC_IDLE,
+	UGC_MARK,
+	UGC_SWEEP
+};
+
+enum ugc_barrier_direction_e
+{
+	UGC_BARRIER_FORWARD,
+	UGC_BARRIER_BACKWARD,
+};
+
+/// Header for a managed object. All fields MUST NOT be accessed.
+struct ugc_header_s
+{
+	ugc_header_t* next;
+	ugc_header_t* prev;
+#if !UGC_USE_TAGGED_POINTER
+	unsigned color: 2;
+#endif
+};
+
+/**
+ * @brief Garbage collector data
+ *
+ * All fields MUST NOT be accessed unless stated otherwise.
+ */
+struct ugc_s
+{
+	ugc_header_t set1, set2;
+	ugc_header_t *from, *to, *iterator;
+	ugc_visit_fn_t scan_fn, release_fn;
+
+	/// Arbitrary userdata, not used by the library.
+	void* userdata;
+
+	/// Current state of the garbage collection. Read-only.
+	unsigned char state;
+	unsigned char white;
+};
+
+/**
+ * @brief Initialize a GC.
+ *
+ * Two callbacks are required: one for scanning and the other for releasing.
+ *
+ * The scan callback must do the following:
+ *
+ * - If `obj` is NULL, it must call ugc_visit on all root objects.
+ * - If `obj` is not NULL, it must call ugc_visit on all objects referenced by
+ *   the given object.
+ *
+ * The release callback will be invoked whenever the GC has determined that
+ * an object has become garbage.
+ */
+UGC_DECL void
+ugc_init(ugc_t* gc, ugc_visit_fn_t scan_fn, ugc_visit_fn_t release_fn);
+
+/**
+ * @brief Release all allocated objects.
+ *
+ * This is faster than clearing the root and forcing a full collection.
+ */
+UGC_DECL void
+ugc_release_all(ugc_t* gc);
+
+/// Register a new object to be managed by the GC.
+UGC_DECL void
+ugc_register(ugc_t* gc, ugc_header_t* obj);
+
+/**
+ * @brief Execute a write barrier.
+ *
+ * Whenever an object stores a reference to another object, this function MUST
+ * be called to ensure that the GC works correctly.
+ *
+ * Root objects (stack, globals) are treated differently so there is no need to
+ * call this function when a store to them occurs.
+ *
+ * @remarks Both objects MUST NOT be NULL.
+ */
+UGC_DECL void
+ugc_write_barrier(
+	ugc_t* gc,
+	enum ugc_barrier_direction_e direction,
+	ugc_header_t* parent,
+	ugc_header_t* child
+);
+
+/**
+ * @brief Make the GC perform one unit of work.
+ *
+ * What happens depends on the current GC's state.
+ *
+ * - In UGC_IDLE state, it will scan the root by calling the scan callback then
+ *   switch to UGC_MARK state.
+ * - In UGC_MARK state, it will mark one object and discover its children using
+ *   the scan callback. When there is no object left to mark, the GC will scan
+ *   the root once more to account for changes during the mark phase. When all
+ *   live objects are marked, it will switch to UGC_SWEEP state.
+ * - In UGC_SWEEP state, it will release one object. When all garbage are
+ *   released, it wil switch to UGC_IDLE state.
+ *
+ * @see ugc_init
+ */
+UGC_DECL void
+ugc_step(ugc_t* gc);
+
+
+/**
+ * @brief Perform a collection cycle.
+ *
+ * Start the GC if it's not already running and only return once the GC has
+ * finished collecting all garbage identified at the point of calling.
+ *
+ * @remarks If the GC is already in the UGC_SWEEP state, it will leave newly
+ * created garbage for the next cycle.
+ */
+UGC_DECL void
+ugc_collect(ugc_t* gc);
+
+/**
+ * @brief Inform the GC of a referred object during the mark phase.
+ *
+ * @remarks This function MUST ONLY be called inside the scan callback.
+ * @remarks The provided object MUST NOT be NULL.
+ * @see ugc_init
+ */
+UGC_DECL void
+ugc_visit(ugc_t* gc, ugc_header_t* obj);
+
+#ifdef UGC_IMPLEMENTATION
+
+#define UGC_GRAY 2
+
+#if UGC_USE_TAGGED_POINTER
+
+#define UGC_PTR(ptr) ((uintptr_t)ptr & (~0x03))
+#define UGC_TAG(ptr) ((uintptr_t)ptr & 0x03)
+#define UGC_SET_PTR(ptr, val) \
+	do { ptr = (ugc_header_t*)((uintptr_t)val | UGC_TAG(ptr)); } while(0)
+#define UGC_SET_TAG(ptr, val) \
+	do { ptr = (ugc_header_t*)(UGC_PTR(ptr) | (uintptr_t)val); } while(0)
+
+static inline void
+ugc_set_next(ugc_header_t* obj, ugc_header_t* value)
+{
+	UGC_SET_PTR(obj->next, value);
+}
+
+static inline ugc_header_t*
+ugc_next(ugc_header_t* obj)
+{
+	return (ugc_header_t*)UGC_PTR(obj->next);
+}
+
+static inline void
+ugc_set_prev(ugc_header_t* obj, ugc_header_t* value)
+{
+	UGC_SET_PTR(obj->prev, value);
+}
+
+static inline ugc_header_t*
+ugc_prev(ugc_header_t* obj)
+{
+	return (ugc_header_t*)UGC_PTR(obj->prev);
+}
+
+static inline void
+ugc_set_color(ugc_header_t* obj, unsigned char color)
+{
+	UGC_SET_TAG(obj->next, color);
+}
+
+static inline unsigned char
+ugc_color(ugc_header_t* obj)
+{
+	return (unsigned char)UGC_TAG(obj->next);
+}
+
+#else
+
+static inline void
+ugc_set_next(ugc_header_t* obj, ugc_header_t* value)
+{
+	obj->next = value;
+}
+
+static inline ugc_header_t*
+ugc_next(ugc_header_t* obj)
+{
+	return obj->next;
+}
+
+static inline void
+ugc_set_prev(ugc_header_t* obj, ugc_header_t* value)
+{
+	obj->prev = value;
+}
+
+static inline ugc_header_t*
+ugc_prev(ugc_header_t* obj)
+{
+	return obj->prev;
+}
+
+static inline void
+ugc_set_color(ugc_header_t* obj, unsigned char color)
+{
+	obj->color = color;
+}
+
+static unsigned char
+ugc_color(ugc_header_t* obj)
+{
+	return obj->color;
+}
+
+#endif
+
+static void
+ugc_push(ugc_header_t* list, ugc_header_t* element)
+{
+	ugc_set_next(element, list);
+	ugc_set_prev(element, list->prev);
+	ugc_set_next(list->prev, element);
+	ugc_set_prev(list, element);
+}
+
+static void
+ugc_unlink(ugc_header_t* element)
+{
+	ugc_header_t* next = ugc_next(element);
+	ugc_header_t* prev = ugc_prev(element);
+
+	ugc_set_prev(next, prev);
+	ugc_set_next(prev, next);
+}
+
+static void
+ugc_make_gray(ugc_t* gc, ugc_header_t* obj)
+{
+	// Move iterator back before moving obj
+	if(obj == gc->iterator) { gc->iterator = ugc_prev(obj); }
+
+	ugc_unlink(obj);
+	ugc_push(gc->to, obj);
+	ugc_set_color(obj, UGC_GRAY);
+}
+
+static void
+ugc_clear(ugc_header_t* list)
+{
+	list->next = list;
+	list->prev = list;
+}
+
+static void
+ugc_release_set(ugc_t* gc, ugc_header_t* set)
+{
+	for(ugc_header_t* itr = ugc_next(set); itr != set;)
+	{
+		ugc_header_t* next = ugc_next(itr);
+
+		gc->release_fn(gc, itr);
+
+		itr = next;
+	}
+}
+
+void
+ugc_init(ugc_t* gc, ugc_visit_fn_t scan_fn, ugc_visit_fn_t release_fn)
+{
+	ugc_clear(&gc->set1);
+	ugc_clear(&gc->set2);
+
+	gc->state = UGC_IDLE;
+	gc->scan_fn = scan_fn;
+	gc->release_fn = release_fn;
+	gc->white = 0;
+	gc->from = &gc->set1;
+	gc->to = &gc->set2;
+	gc->iterator = gc->to;
+	gc->userdata = NULL;
+}
+
+void
+ugc_register(ugc_t* gc, ugc_header_t* obj)
+{
+	ugc_push(gc->from, obj);
+	ugc_set_color(obj, gc->white);
+}
+
+void
+ugc_release_all(ugc_t* gc)
+{
+	ugc_release_set(gc, gc->from);
+	ugc_release_set(gc, gc->to);
+}
+
+void
+ugc_write_barrier(
+	ugc_t* gc,
+	enum ugc_barrier_direction_e direction,
+	ugc_header_t* parent,
+	ugc_header_t* child
+)
+{
+	unsigned char white = gc->white;
+	unsigned char black = !gc->white;
+
+	if(ugc_color(parent) == black && ugc_color(child) == white)
+	{
+		switch(direction)
+		{
+			case UGC_BARRIER_FORWARD:
+				ugc_make_gray(gc, child);
+				break;
+			case UGC_BARRIER_BACKWARD:
+				ugc_make_gray(gc, parent);
+				break;
+		}
+	}
+}
+
+void
+ugc_visit(ugc_t* gc, ugc_header_t* obj)
+{
+	if(ugc_color(obj) == gc->white)
+	{
+		ugc_make_gray(gc, obj);
+	}
+}
+
+void
+ugc_step(ugc_t* gc)
+{
+	ugc_header_t* obj;
+	ugc_header_t* to = gc->to;
+
+	switch((enum ugc_state_e)gc->state)
+	{
+		case UGC_IDLE:
+			gc->scan_fn(gc, NULL);
+			gc->state = UGC_MARK;
+			break;
+		case UGC_MARK:
+			{
+				obj = ugc_next(gc->iterator);
+				unsigned char white = gc->white;
+
+				if(obj != to)
+				{
+					gc->iterator = obj;
+					ugc_set_color(obj, !white);
+					gc->scan_fn(gc, obj);
+				}
+				else
+				{
+					gc->scan_fn(gc, NULL);
+					obj = ugc_next(gc->iterator);
+					if(obj == to)
+					{
+						// Since we can get interrupted during the sweep phase,
+						// swap "from" and "to" set, flip white color before
+						// starting the sweep phase.
+						ugc_header_t* from = gc->from;
+						gc->from = to;
+						gc->to = from;
+						gc->white = !white;
+						gc->iterator = from->next;
+						gc->state = UGC_SWEEP;
+					}
+				}
+			}
+			break;
+		case UGC_SWEEP:
+			obj = gc->iterator;
+			if(obj != to)
+			{
+				gc->iterator = ugc_next(obj);
+				gc->release_fn(gc, obj);
+			}
+			else
+			{
+				ugc_clear(to);
+				gc->state = UGC_IDLE;
+			}
+			break;
+	}
+}
+
+void
+ugc_collect(ugc_t* gc)
+{
+	if(gc->state == UGC_IDLE) { ugc_step(gc); }
+	while(gc->state != UGC_IDLE) { ugc_step(gc); }
+}
+
+#endif
+
+#endif

{cpyte-3.3.2 → cpyte-3.3.3/source/cpyte.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cpyte
-Version: 3.3.2
+Version: 3.3.3
 Summary: The Cpyte programming language compiler
 Author: Hoang Duy Tung
 License: MIT

{cpyte-3.3.2 → cpyte-3.3.3}/source/cpyte.egg-info/SOURCES.txt

@@ -23,6 +23,7 @@ source/cpyte/runtime.c
 source/cpyte/runtime_scorpion.c
 source/cpyte/sef.py
 source/cpyte/semantic_analasis.py
+source/cpyte/ugc.h
 source/cpyte/ui.py
 source/cpyte/update_check.py
 source/cpyte.egg-info/PKG-INFO

cpyte-3.3.2/source/cpyte/__init__.py

@@ -1 +0,0 @@
-__version__ = "3.3.2"