IncludeCPP 4.0.0__py3-none-any.whl → 4.0.2__py3-none-any.whl

includecpp/__init__.py

@@ -2,7 +2,7 @@ from .core.cpp_api import CppApi
 from .core import cssl_bridge as CSSL
 import warnings
 
-__version__ = "4.0.0"
+__version__ = "4.0.2"
 __all__ = ["CppApi", "CSSL"]
 
 # Module-level cache for C++ modules

includecpp/cli/commands.py

@@ -9,8 +9,12 @@ import re
 import urllib.request
 import urllib.error
 from pathlib import Path
+from colorama import init as colorama_init, Fore, Style
 from .config_parser import CppProjectConfig
 
+# Initialize colorama for Windows ANSI color support
+colorama_init()
+
 
 def _is_experimental_enabled() -> bool:
     """Check if experimental features (cppy, ai) are enabled."""
@@ -7320,7 +7324,6 @@ def exec_repl(lang, path, import_all):
     code_lines = imports + [''] + lines if imports else lines
 
     click.echo()
-    click.secho("--- Output ---", fg='green')
 
     if is_python:
         # Execute Python code
@@ -7443,9 +7446,6 @@ def exec_repl(lang, path, import_all):
             except Exception:
                 pass
 
-    click.echo()
-    click.secho("--------------", fg='green')
-
 
 # ============================================================================
 # CSSL - Hidden Command Group
@@ -7526,19 +7526,12 @@ def _cssl_execute(path, code):
         source = '\n'.join(lines)
 
     # Execute
-    click.secho("--- Output ---", fg='green')
     try:
         result = cssl_lang.run(source)
-
-        # Output is already printed to stdout during execution via runtime.output()
-        # Don't print "Result:" automatically - users should use printl() for output
-        # This prevents unwanted output for function calls like: Function();
-        pass
-
     except Exception as e:
-        click.secho(f"CSSL Error: {e}", fg='red')
-
-    click.secho("--------------", fg='green')
+        error_msg = str(e)
+        # Clean display - single CSSL Error: prefix with colorama
+        click.echo(f"{Fore.RED}CSSL Error: {error_msg}{Style.RESET_ALL}")
 
 
 @cssl.command(name='makemodule')

includecpp/core/cssl/cssl_parser.py

@@ -1084,7 +1084,7 @@ class CSSLParser:
         append_ref_class = None
         append_ref_member = None
 
-        # Check for &ClassName::member reference
+        # Check for &ClassName::member or &ClassName.member or &function reference
         if self._match(TokenType.AMPERSAND):
             if self._check(TokenType.IDENTIFIER):
                 append_ref_class = self._advance().value
@@ -1095,8 +1095,8 @@ class CSSLParser:
             elif self._check(TokenType.SHARED_REF):
                 append_ref_class = f'${self._advance().value}'
 
-            # Check for ::member
-            if self._match(TokenType.DOUBLE_COLON):
+            # Check for ::member or .member (support both syntaxes)
+            if self._match(TokenType.DOUBLE_COLON) or self._match(TokenType.DOT):
                 if self._check(TokenType.IDENTIFIER) or self._check(TokenType.KEYWORD):
                     append_ref_member = self._advance().value
 
@@ -1108,7 +1108,7 @@ class CSSLParser:
         if self._match(TokenType.DOUBLE_COLON) or self._match(TokenType.COLON):
             while True:
                 if self._match_keyword('extends'):
-                    # Parse target: @ModuleName, $PythonObject, Parent::method
+                    # Parse target: @ModuleName, $PythonObject, Parent::method, Parent.method
                     if self._check(TokenType.AT):
                         self._advance()
                         extends_func = '@' + self._advance().value
@@ -1117,7 +1117,8 @@ class CSSLParser:
                         extends_func = self._advance().value
                     elif self._check(TokenType.IDENTIFIER):
                         first_part = self._advance().value
-                        if self._match(TokenType.DOUBLE_COLON):
+                        # Support both :: and . for class method access
+                        if self._match(TokenType.DOUBLE_COLON) or self._match(TokenType.DOT):
                             extends_class_ref = first_part
                             extends_method_ref = self._advance().value
                         else:
@@ -1134,7 +1135,8 @@ class CSSLParser:
                         overwrites_func = self._advance().value
                     elif self._check(TokenType.IDENTIFIER):
                         first_part = self._advance().value
-                        if self._match(TokenType.DOUBLE_COLON):
+                        # Support both :: and . for class method access
+                        if self._match(TokenType.DOUBLE_COLON) or self._match(TokenType.DOT):
                             overwrites_class_ref = first_part
                             overwrites_method_ref = self._advance().value
                         else:

includecpp/core/cssl/cssl_runtime.py

@@ -68,11 +68,11 @@ class CSSLRuntimeError(Exception):
         # Build detailed error message
         error_parts = []
 
-        # Main error message
+        # Main error message (no "Error:" prefix - CLI handles that)
         if line:
-            error_parts.append(f"Error at line {line}: {message}")
+            error_parts.append(f"Line {line}: {message}")
         else:
-            error_parts.append(f"Error: {message}")
+            error_parts.append(message)
 
         # Add context if available
         if context:
@@ -363,11 +363,11 @@ class CSSLRuntime:
         """Format a detailed error with source context"""
         error_parts = []
 
-        # Main error header
+        # Main error header (no "Error:" prefix - CLI handles that)
         if line and line > 0:
-            error_parts.append(f"Error at line {line} in {self._current_file}:")
+            error_parts.append(f"Line {line} in {self._current_file}:")
         else:
-            error_parts.append(f"Error in {self._current_file}:")
+            error_parts.append(f"In {self._current_file}:")
 
         # Extract message without existing line info
         clean_msg = message
@@ -1005,13 +1005,29 @@ class CSSLRuntime:
         overwrites_func = func_info.get('overwrites')
         overwrites_is_python = func_info.get('overwrites_is_python', False)
 
+        # Get append/overwrite reference info (&Class::method syntax)
+        append_mode = func_info.get('append_mode', False)
+        append_ref_class = func_info.get('append_ref_class')
+        append_ref_member = func_info.get('append_ref_member')
+
         # Store function extends info for runtime use
         if extends_func:
             node.value['_extends_resolved'] = self._resolve_function_target(
                 extends_func, extends_is_python
             )
 
-        # Handle overwrites - replace the target function
+        # Handle &Class::method syntax
+        # Without ++ = full replacement
+        # With ++ = append (run original first, then new code)
+        if append_ref_class:
+            if append_mode:
+                # Append mode: wrap original to run original + new
+                self._append_to_target(append_ref_class, append_ref_member, node)
+            else:
+                # Full replacement
+                self._overwrite_target(append_ref_class, append_ref_member, node)
+
+        # Handle overwrites keyword - replace the target function
         if overwrites_func:
             target = self._resolve_function_target(overwrites_func, overwrites_is_python)
             if target is not None:
@@ -1054,6 +1070,142 @@ class CSSLRuntime:
             return self._call_function(func_node, list(args), kwargs)
         return wrapper
 
+    def _overwrite_target(self, ref_class: str, ref_member: str, replacement_node: ASTNode):
+        """Overwrite a class method or function with the replacement.
+
+        Handles:
+        - &ClassName::method - Overwrite method in CSSL class
+        - &$PyObject.method - Overwrite method in Python shared object
+        - &functionName - Overwrite standalone function
+        """
+        from ..cssl_bridge import _live_objects, SharedObjectProxy
+
+        # Handle Python shared objects
+        if ref_class.startswith('$'):
+            var_name = ref_class[1:]
+            ref_obj = _live_objects.get(var_name)
+            if ref_obj is None:
+                ref_obj = self.scope.get(var_name) or self.global_scope.get(var_name)
+
+            if ref_obj is None:
+                return
+
+            # Unwrap SharedObjectProxy
+            if isinstance(ref_obj, SharedObjectProxy):
+                ref_obj = ref_obj._obj
+
+            # Overwrite Python object method
+            if ref_member and hasattr(ref_obj, ref_member):
+                wrapper = self._create_python_wrapper(replacement_node)
+                try:
+                    setattr(ref_obj, ref_member, wrapper)
+                except (AttributeError, TypeError):
+                    pass  # Can't overwrite (immutable or builtin)
+            return
+
+        # Handle CSSL class method overwrite
+        target_class = self.scope.get(ref_class) or self.global_scope.get(ref_class)
+        if target_class is None:
+            # Maybe it's a standalone function reference (no ::member)
+            if ref_member is None:
+                # &functionName - overwrite the function
+                self.scope.set(ref_class, replacement_node)
+                self.global_scope.set(ref_class, replacement_node)
+            return
+
+        if isinstance(target_class, CSSLClass) and ref_member:
+            # Overwrite method in the class
+            if hasattr(target_class, 'methods') and isinstance(target_class.methods, dict):
+                target_class.methods[ref_member] = replacement_node
+            # Also check members list
+            if hasattr(target_class, 'members'):
+                for i, member in enumerate(target_class.members):
+                    if member.type in ('function', 'FUNCTION') and member.value.get('name') == ref_member:
+                        target_class.members[i] = replacement_node
+                        break
+
+    def _append_to_target(self, ref_class: str, ref_member: str, append_node: ASTNode):
+        """Append new code to an existing class method or function.
+
+        Creates a wrapper that runs original first, then the appended code.
+        Handles:
+        - &ClassName::method ++ - Append to method in CSSL class
+        - &$PyObject.method ++ - Append to method in Python shared object
+        - &functionName ++ - Append to standalone function
+        """
+        from ..cssl_bridge import _live_objects, SharedObjectProxy
+
+        # Handle Python shared objects
+        if ref_class.startswith('$'):
+            var_name = ref_class[1:]
+            ref_obj = _live_objects.get(var_name)
+            if ref_obj is None:
+                ref_obj = self.scope.get(var_name) or self.global_scope.get(var_name)
+
+            if ref_obj is None:
+                return
+
+            if isinstance(ref_obj, SharedObjectProxy):
+                ref_obj = ref_obj._obj
+
+            # Create wrapper that calls original + new
+            if ref_member and hasattr(ref_obj, ref_member):
+                original_method = getattr(ref_obj, ref_member)
+                runtime = self
+                def appended_wrapper(*args, **kwargs):
+                    # Run original first
+                    result = None
+                    if callable(original_method):
+                        try:
+                            result = original_method(*args, **kwargs)
+                        except:
+                            pass
+                    # Then run appended code
+                    return runtime._call_function(append_node, list(args), kwargs)
+                try:
+                    setattr(ref_obj, ref_member, appended_wrapper)
+                except (AttributeError, TypeError):
+                    pass
+            return
+
+        # Handle CSSL class method append
+        target_class = self.scope.get(ref_class) or self.global_scope.get(ref_class)
+        if target_class is None:
+            # Standalone function append
+            if ref_member is None:
+                original_func = self.scope.get(ref_class) or self.global_scope.get(ref_class)
+                if original_func:
+                    # Store original in append_node so it can run first
+                    append_node.value['_original_func'] = original_func
+                self.scope.set(ref_class, append_node)
+                self.global_scope.set(ref_class, append_node)
+            return
+
+        if isinstance(target_class, CSSLClass) and ref_member:
+            # Find original method
+            original_method = None
+            if hasattr(target_class, 'methods') and isinstance(target_class.methods, dict):
+                original_method = target_class.methods.get(ref_member)
+
+            if original_method is None and hasattr(target_class, 'members'):
+                for member in target_class.members:
+                    if member.type in ('function', 'FUNCTION') and member.value.get('name') == ref_member:
+                        original_method = member
+                        break
+
+            # Store original in append_node for runtime execution
+            if original_method:
+                append_node.value['_original_method'] = original_method
+
+            # Replace with append_node (which will call original first via _call_function)
+            if hasattr(target_class, 'methods') and isinstance(target_class.methods, dict):
+                target_class.methods[ref_member] = append_node
+            if hasattr(target_class, 'members'):
+                for i, member in enumerate(target_class.members):
+                    if member.type in ('function', 'FUNCTION') and member.value.get('name') == ref_member:
+                        target_class.members[i] = append_node
+                        break
+
     def _exec_typed_declaration(self, node: ASTNode) -> Any:
         """Execute typed variable declaration: type<T> varName = value;
 
@@ -1352,12 +1504,15 @@ class CSSLRuntime:
                         if not self._running:
                             break
                         self._execute_node(child)
-                    # Copy all local vars to new scope
-                    for name, value in temp_scope._vars.items():
-                        new_scope.set(name, value)
+                except CSSLReturn:
+                    # Parent returned - that's fine, we just want the local vars
+                    pass
                 except:
                     pass
                 finally:
+                    # ALWAYS copy local vars (even if parent returned)
+                    for name, value in temp_scope.variables.items():
+                        new_scope.set(name, value)
                     self.scope = old_scope
 
         # Bind parameters - handle both positional and named arguments
@@ -1420,7 +1575,7 @@ class CSSLRuntime:
 
             # Check exclude_type: *[type] - must NOT return excluded type
             exclude_type = func_info.get('exclude_type')
-            if exclude_type:
+            if exclude_type and isinstance(exclude_type, str):
                 type_map = {
                     'string': str, 'int': int, 'float': float, 'bool': bool,
                     'null': type(None), 'none': type(None),
@@ -3076,7 +3231,7 @@ class CSSLRuntime:
                 'json': dict,
             }
 
-            excluded_py_type = type_map.get(exclude_type.lower())
+            excluded_py_type = type_map.get(exclude_type.lower() if isinstance(exclude_type, str) else exclude_type)
             if excluded_py_type and isinstance(value, excluded_py_type):
                 raise self._format_error(
                     node.line if hasattr(node, 'line') else 0,
@@ -3628,12 +3783,34 @@ class CSSLRuntime:
 
         # Resolve the class/instance reference
         if ref_class.startswith('$'):
-            # Dynamic instance reference: &$instanceVar::member
+            # Dynamic instance reference: &$instanceVar::member or &$PyObject.method
             var_name = ref_class[1:]
-            ref_obj = self.scope.get(var_name) or self.global_scope.get(var_name)
+
+            # First check in _live_objects for Python shared objects
+            from ..cssl_bridge import _live_objects, SharedObjectProxy
+            ref_obj = _live_objects.get(var_name)
+            if ref_obj is None:
+                ref_obj = self.scope.get(var_name) or self.global_scope.get(var_name)
+
             if ref_obj is None:
                 return  # Instance not found, skip silently
 
+            # Handle Python shared objects
+            if isinstance(ref_obj, SharedObjectProxy):
+                ref_obj = ref_obj._obj
+
+            # If it's a Python object (not CSSL), call the method directly
+            if not isinstance(ref_obj, (CSSLInstance, CSSLClass)):
+                if ref_member and hasattr(ref_obj, ref_member):
+                    method = getattr(ref_obj, ref_member)
+                    if callable(method):
+                        try:
+                            method(*args, **kwargs)
+                        except TypeError:
+                            # Try without args
+                            method()
+                return
+
             if isinstance(ref_obj, CSSLInstance):
                 # Get the class definition from the instance
                 target_class = ref_obj.class_def
@@ -3853,9 +4030,19 @@ class CSSLRuntime:
         self.scope = new_scope
         self._current_instance = instance
 
+        original_return = None
         try:
+            # Handle append mode via _append_to_target (stored original)
+            original_method = func_info.get('_original_method')
+            if original_method:
+                # Execute original method first - capture return for fallback
+                try:
+                    original_return = self._call_method(instance, original_method, args, kwargs)
+                except CSSLReturn as ret:
+                    original_return = ret.value
+
             # Handle append mode (++) - execute referenced parent method first
-            if append_mode and append_ref_class:
+            elif append_mode and append_ref_class:
                 self._execute_append_reference(
                     instance, append_ref_class, append_ref_member,
                     args, kwargs, {}, is_constructor=False
@@ -3876,7 +4063,8 @@ class CSSLRuntime:
             self.scope = old_scope
             self._current_instance = old_instance
 
-        return None
+        # If no return in appended code, use original's return
+        return original_return
 
     def _eval_member_access(self, node: ASTNode) -> Any:
         """Evaluate member access"""

includecpp/core/cssl_bridge.py

@@ -455,12 +455,12 @@ class CsslLang:
 
             return result
         except Exception as e:
-            # Format error message nicely
+            # Format error message nicely - don't add prefixes, let CLI handle that
             error_msg = str(e)
-            # Don't double-wrap error messages
+            # Strip any existing CSSL Error: prefix to avoid duplication
             if error_msg.startswith("CSSL Error:"):
-                raise RuntimeError(error_msg) from e
-            raise RuntimeError(f"CSSL Error:\n{error_msg}") from e
+                error_msg = error_msg[11:].strip()
+            raise RuntimeError(error_msg) from e
 
     def exec(self, path_or_code: str, *args) -> Any:
         """