IncludeCPP 3.9.2__tar.gz → 4.0.1__tar.gz

{includecpp-3.9.2 → includecpp-4.0.1}/IncludeCPP.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: IncludeCPP
-Version: 3.9.2
+Version: 4.0.1
 Summary: Professional C++ Python bindings with type-generic templates, pystubs and native threading
 Home-page: https://github.com/liliassg/IncludeCPP
 Author: Lilias Hatterscheidt
@@ -27,6 +27,7 @@ Requires-Dist: pybind11>=2.11.0
 Requires-Dist: click>=8.0.0
 Requires-Dist: typing-extensions>=4.0.0
 Requires-Dist: requests>=2.28.0
+Requires-Dist: colorama>=0.4.0
 Dynamic: author-email
 Dynamic: home-page
 Dynamic: license-file

{includecpp-3.9.2 → includecpp-4.0.1}/IncludeCPP.egg-info/requires.txt

@@ -2,3 +2,4 @@ pybind11>=2.11.0
 click>=8.0.0
 typing-extensions>=4.0.0
 requests>=2.28.0
+colorama>=0.4.0

{includecpp-3.9.2 → includecpp-4.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: IncludeCPP
-Version: 3.9.2
+Version: 4.0.1
 Summary: Professional C++ Python bindings with type-generic templates, pystubs and native threading
 Home-page: https://github.com/liliassg/IncludeCPP
 Author: Lilias Hatterscheidt
@@ -27,6 +27,7 @@ Requires-Dist: pybind11>=2.11.0
 Requires-Dist: click>=8.0.0
 Requires-Dist: typing-extensions>=4.0.0
 Requires-Dist: requests>=2.28.0
+Requires-Dist: colorama>=0.4.0
 Dynamic: author-email
 Dynamic: home-page
 Dynamic: license-file

{includecpp-3.9.2 → includecpp-4.0.1}/includecpp/__init__.py

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

{includecpp-3.9.2 → includecpp-4.0.1}/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-3.9.2 → includecpp-4.0.1}/includecpp/core/cssl/CSSL_DOCUMENTATION.md

@@ -1,6 +1,6 @@
 # CSSL - C-Style Scripting Language
 
-> Version 3.9.1 | A modern scripting language with C++-style syntax and unique features like CodeInfusion, BruteInjection, and Python Interop.
+> Version 4.0.0 | A modern scripting language with C++-style syntax and unique features like CodeInfusion, BruteInjection, and Python Interop.
 
 ---
 
@@ -513,10 +513,16 @@ define greet(string name) {
 | `closed` | Block external CodeInfusion |
 | `private` | Block all CodeInfusion |
 | `virtual` | Import-cycle safe |
-| `meta` | Source function (must return) |
+| `meta` | Source function (any return type allowed) |
 | `super` | Force execution (no exceptions) |
 | `open` | Accept any parameters |
 | `shuffled` | Return multiple values |
+| `const` | Immutable function (like C++) |
+| `static` | Static method/function |
+| `public` | Explicitly public (default) |
+| `global` | Makes function globally accessible |
+
+**Flexible Modifier Order**: Modifiers can appear in any order before the function declaration.
 
 ```cssl
 // Ignore errors
@@ -535,6 +541,45 @@ shuffled string getNames() {
 }
 
 a, b, c = getNames();
+
+// Any order of modifiers works
+private string *@Myfunc() {
+    println("Hello from global private non-null function!");
+    return "Hey";
+}
+
+// Const function
+const void immutableFunc() {
+    printl("I'm constant");
+}
+
+// Global private const
+global private const void @MyGlobalFunc() {
+    printl("Complex modifiers in any order");
+}
+```
+
+### Typed Functions (Enforced Returns)
+
+Functions with a return type (like `int`, `string`, `vector<T>`) MUST return that type:
+
+```cssl
+// MUST return string
+string getName() {
+    return "Alice";        // OK
+    // return 42;          // Error! Expected string
+}
+
+// MUST return int
+int getAge() {
+    return 30;             // OK
+}
+
+// meta modifier bypasses type checking
+meta datastruct<string> getData() {
+    return "just a string";  // OK despite declared type
+    return 42;               // Also OK - meta allows any type
+}
 ```
 
 ### Non-Null Functions (*)
@@ -1453,4 +1498,4 @@ assert(x > 0, "x must be positive");
 
 ---
 
-*CSSL v3.9.1 - Developed as part of IncludeCPP*
+*CSSL v4.0.0 - Developed as part of IncludeCPP*

{includecpp-3.9.2 → includecpp-4.0.1}/includecpp/core/cssl/cssl_parser.py

@@ -144,16 +144,25 @@ KEYWORDS = {
     'structure',    # Advanced C++/Py Class
     'openquote',    # SQL openquote container
     # CSSL Function Modifiers
+    'const',        # Immutable function (like C++)
     'meta',         # Source function (must return)
     'super',        # Force execution (no exceptions)
     'closed',       # Protect from external injection
     'private',      # Disable all injections
     'virtual',      # Import cycle safe
     'sqlbased',     # SQL-based function
+    'public',       # Explicitly public (default)
+    'static',       # Static method/function
     # CSSL Include Keywords
     'include', 'get',
 }
 
+# Function modifiers that can appear in any order before function name
+FUNCTION_MODIFIERS = {
+    'undefined', 'open', 'meta', 'super', 'closed', 'private', 'virtual',
+    'sqlbased', 'const', 'public', 'static', 'global', 'shuffled'
+}
+
 # Type literals that create empty instances
 TYPE_LITERALS = {'list', 'dict'}
 
@@ -719,7 +728,7 @@ class CSSLParser:
 
     def _is_function_modifier(self, value: str) -> bool:
         """Check if a keyword is a function modifier"""
-        return value in ('undefined', 'open', 'meta', 'super', 'closed', 'private', 'virtual', 'sqlbased')
+        return value in FUNCTION_MODIFIERS
 
     def _is_type_keyword(self, value: str) -> bool:
         """Check if a keyword is a type declaration"""
@@ -730,53 +739,98 @@ class CSSLParser:
     def _looks_like_function_declaration(self) -> bool:
         """Check if current position looks like a C-style function declaration.
 
+        Supports flexible ordering of modifiers, types, non-null (*), and global (@):
+
         Patterns:
         - int funcName(...)
         - undefined int funcName(...)
         - vector<string> funcName(...)
         - undefined void funcName(...)
-        - private super virtual meta FuncName(...)  <- modifiers without return type
+        - private super virtual meta FuncName(...)
+        - private string *@Myfunc(...)
+        - const define myFunc(...)
+        - global private const void @Func(...)
+        - shuffled *[string] getNumbers(...)
+        - datastruct<dynamic> HelloCode(...)
+        - datastruct<dynamic> HelloCode() : extends @MyFunc { }
+
+        Distinguishes functions from variables:
+        - datastruct<dynamic> MyVar;           <- variable (no () { })
+        - datastruct<dynamic> HelloCode() { }  <- function (has () { })
         """
         saved_pos = self.pos
         has_modifiers = False
+        has_type = False
 
-        # Skip modifiers (undefined, open, meta, super, closed, private, virtual)
-        while self._check(TokenType.KEYWORD) and self._is_function_modifier(self._current().value):
-            self._advance()
-            has_modifiers = True
+        try:
+            # Skip modifiers in any order (global, private, const, undefined, etc.)
+            while self._check(TokenType.KEYWORD) and self._is_function_modifier(self._current().value):
+                self._advance()
+                has_modifiers = True
 
-        # Check for type keyword (optional if modifiers present)
-        if self._check(TokenType.KEYWORD) and self._is_type_keyword(self._current().value):
-            self._advance()
+            # Check for 'define' keyword (special case: const define myFunc())
+            if self._check(TokenType.KEYWORD) and self._current().value == 'define':
+                self.pos = saved_pos
+                return False  # Let _parse_define handle this
 
-            # Skip generic type parameters <T>
-            if self._check(TokenType.COMPARE_LT):
-                depth = 1
+            # Check for type keyword (int, string, void, vector, datastruct, etc.)
+            if self._check(TokenType.KEYWORD) and self._is_type_keyword(self._current().value):
                 self._advance()
-                while depth > 0 and not self._is_at_end():
-                    if self._check(TokenType.COMPARE_LT):
-                        depth += 1
-                    elif self._check(TokenType.COMPARE_GT):
-                        depth -= 1
+                has_type = True
+
+                # Skip generic type parameters <T> or <T, U>
+                if self._check(TokenType.COMPARE_LT):
+                    depth = 1
                     self._advance()
+                    while depth > 0 and not self._is_at_end():
+                        if self._check(TokenType.COMPARE_LT):
+                            depth += 1
+                        elif self._check(TokenType.COMPARE_GT):
+                            depth -= 1
+                        self._advance()
+
+            # Check for * prefix (non-null) or *[type] (type exclusion)
+            if self._check(TokenType.MULTIPLY):
+                self._advance()
+                # Check for type exclusion: *[string], *[int], etc.
+                if self._check(TokenType.BRACKET_START):
+                    self._advance()  # [
+                    while not self._check(TokenType.BRACKET_END) and not self._is_at_end():
+                        self._advance()
+                    if self._check(TokenType.BRACKET_END):
+                        self._advance()  # ]
+
+            # Check for @ prefix (global function)
+            if self._check(TokenType.AT):
+                self._advance()
 
-            # Check for identifier followed by (
+            # Now we should be at the function name (identifier)
             if self._check(TokenType.IDENTIFIER):
                 self._advance()
-                is_func = self._check(TokenType.PAREN_START)
-                self.pos = saved_pos
-                return is_func
 
-        # If we have modifiers and the next token is an identifier followed by (
-        # This handles: private super virtual meta FuncName()
-        elif has_modifiers and self._check(TokenType.IDENTIFIER):
-            self._advance()
-            is_func = self._check(TokenType.PAREN_START)
+                # Check if followed by (
+                # IMPORTANT: Only a function declaration if we have modifiers OR type
+                # Plain identifier() is a function CALL, not a declaration
+                if self._check(TokenType.PAREN_START):
+                    if has_modifiers or has_type:
+                        self.pos = saved_pos
+                        return True
+                    else:
+                        # No modifiers/type = function call, not declaration
+                        self.pos = saved_pos
+                        return False
+
+                # If we have a type and identifier but no (, it's a variable
+                if has_type and not self._check(TokenType.PAREN_START):
+                    self.pos = saved_pos
+                    return False
+
             self.pos = saved_pos
-            return is_func
+            return False
 
-        self.pos = saved_pos
-        return False
+        except Exception:
+            self.pos = saved_pos
+            return False
 
     def _looks_like_typed_variable(self) -> bool:
         """Check if current position looks like a typed variable declaration.
@@ -817,69 +871,109 @@ class CSSLParser:
         return False
 
     def _parse_typed_function(self, is_global: bool = False) -> ASTNode:
-        """Parse C-style typed function declaration.
+        """Parse C-style typed function declaration with flexible modifier ordering.
+
+        Supports any order of modifiers, types, non-null (*), and global (@):
 
         Patterns:
-        - int Add(int a, int b) { }           // Local function
-        - global int Add(int a, int b) { }    // Global function
-        - int @Add(int a, int b) { }          // Global function (alternative)
+        - int Add(int a, int b) { }
+        - global int Add(int a, int b) { }
+        - int @Add(int a, int b) { }
         - undefined int Func() { }
         - open void Handler(open Params) { }
         - vector<string> GetNames() { }
+        - private string *@Myfunc() { }
+        - const define myFunc() { }
+        - global private const void @Func() { }
+        - shuffled *[string] getNumbers() { }
+        - datastruct<dynamic> HelloCode() { }
+        - meta datastruct<string> MyData() { }  // meta allows any returns
+        - datastruct<dynamic> HelloCode() : extends @MyFunc { }
+
+        Typed functions (with return type like int, string, void) MUST return that type.
+        Functions with 'meta' modifier can return any type regardless of declaration.
+        Functions with 'define' are dynamic (any return type allowed).
         """
         modifiers = []
         return_type = None
         generic_type = None
+        non_null = False
+        exclude_type = None
+        is_const = False
+
+        # Phase 1: Collect all modifiers, type, non-null, and global indicators
+        # These can appear in any order before the function name
+
+        parsing_prefix = True
+        while parsing_prefix and not self._is_at_end():
+            # Check for modifiers (global, private, const, undefined, etc.)
+            if self._check(TokenType.KEYWORD) and self._is_function_modifier(self._current().value):
+                mod = self._advance().value
+                if mod == 'global':
+                    is_global = True
+                elif mod == 'const':
+                    is_const = True
+                    modifiers.append(mod)
+                else:
+                    modifiers.append(mod)
+                continue
 
-        # Collect modifiers (undefined, open, meta, super, closed, private, virtual)
-        while self._check(TokenType.KEYWORD) and self._is_function_modifier(self._current().value):
-            modifiers.append(self._advance().value)
+            # Check for type keyword (int, string, void, vector, datastruct, etc.)
+            if self._check(TokenType.KEYWORD) and self._is_type_keyword(self._current().value) and return_type is None:
+                return_type = self._advance().value
 
-        # Get return type
-        if self._check(TokenType.KEYWORD) and self._is_type_keyword(self._current().value):
-            return_type = self._advance().value
+                # Check for generic type <T> or <T, U>
+                if self._check(TokenType.COMPARE_LT):
+                    self._advance()  # skip <
+                    generic_parts = []
+                    depth = 1
+                    while depth > 0 and not self._is_at_end():
+                        if self._check(TokenType.COMPARE_LT):
+                            depth += 1
+                            generic_parts.append('<')
+                        elif self._check(TokenType.COMPARE_GT):
+                            depth -= 1
+                            if depth > 0:
+                                generic_parts.append('>')
+                        elif self._check(TokenType.COMMA):
+                            generic_parts.append(',')
+                        else:
+                            generic_parts.append(str(self._current().value))
+                        self._advance()
+                    generic_type = ''.join(generic_parts)
+                continue
 
-            # Check for generic type <T>
-            if self._check(TokenType.COMPARE_LT):
-                self._advance()  # skip <
-                generic_parts = []
-                depth = 1
-                while depth > 0 and not self._is_at_end():
-                    if self._check(TokenType.COMPARE_LT):
-                        depth += 1
-                        generic_parts.append('<')
-                    elif self._check(TokenType.COMPARE_GT):
-                        depth -= 1
-                        if depth > 0:
-                            generic_parts.append('>')
-                    elif self._check(TokenType.COMMA):
-                        generic_parts.append(',')
-                    else:
-                        generic_parts.append(self._current().value)
-                    self._advance()
-                generic_type = ''.join(generic_parts)
+            # Check for * prefix (non-null) or *[type] (type exclusion)
+            if self._check(TokenType.MULTIPLY):
+                self._advance()
+                # Check for type exclusion filter: *[string], *[int], etc.
+                if self._check(TokenType.BRACKET_START):
+                    self._advance()  # consume [
+                    exclude_type = self._advance().value  # get type name
+                    self._expect(TokenType.BRACKET_END)
+                else:
+                    non_null = True
+                continue
 
-        # Check for * prefix (non-null function) or *[type] (type exclusion)
-        non_null = False
-        exclude_type = None
-        if self._match(TokenType.MULTIPLY):
-            # Check for type exclusion filter: *[string], *[int], etc.
-            if self._check(TokenType.BRACKET_START):
-                self._advance()  # consume [
-                exclude_type = self._advance().value  # get type name
-                self._expect(TokenType.BRACKET_END)
-            else:
-                non_null = True
+            # Check for @ prefix (global function)
+            if self._check(TokenType.AT):
+                self._advance()
+                is_global = True
+                continue
 
-        # Check for @ prefix (global function): void @FuncName()
-        if self._check(TokenType.AT):
-            self._advance()  # consume @
-            is_global = True
+            # If we've reached an identifier, we're at the function name
+            if self._check(TokenType.IDENTIFIER):
+                parsing_prefix = False
+            else:
+                # Unknown token in prefix, break out
+                parsing_prefix = False
 
-        # Get function name
+        # Phase 2: Get function name
+        if not self._check(TokenType.IDENTIFIER):
+            self.error(f"Expected function name, got {self._current().type.name}")
         name = self._advance().value
 
-        # Parse parameters
+        # Phase 3: Parse parameters
         params = []
         self._expect(TokenType.PAREN_START)
 
@@ -890,6 +984,10 @@ class CSSLParser:
             if self._match_keyword('open'):
                 param_info['open'] = True
 
+            # Handle const parameters
+            if self._match_keyword('const'):
+                param_info['const'] = True
+
             # Handle type annotations (builtin types like int, string, etc.)
             if self._check(TokenType.KEYWORD) and self._is_type_keyword(self._current().value):
                 param_info['type'] = self._advance().value
@@ -910,13 +1008,12 @@ class CSSLParser:
                         elif self._check(TokenType.COMMA):
                             generic_parts.append(',')
                         else:
-                            generic_parts.append(self._current().value)
+                            generic_parts.append(str(self._current().value))
                         self._advance()
                     param_info['generic'] = ''.join(generic_parts)
 
             # Handle custom class types (identifier followed by another identifier = type + name)
             elif self._check(TokenType.IDENTIFIER):
-                # Look ahead: if next token is also an identifier, current is the type
                 saved_pos = self.pos
                 potential_type = self._advance().value
 
@@ -936,7 +1033,7 @@ class CSSLParser:
                         elif self._check(TokenType.COMMA):
                             generic_parts.append(',')
                         else:
-                            generic_parts.append(self._current().value)
+                            generic_parts.append(str(self._current().value))
                         self._advance()
                     param_info['generic'] = ''.join(generic_parts)
 
@@ -947,6 +1044,10 @@ class CSSLParser:
                     # Not a type, restore position - this is just a param name
                     self.pos = saved_pos
 
+            # Handle * prefix for non-null parameters
+            if self._match(TokenType.MULTIPLY):
+                param_info['non_null'] = True
+
             # Handle reference operator &
             if self._match(TokenType.AMPERSAND):
                 param_info['ref'] = True
@@ -959,7 +1060,7 @@ class CSSLParser:
                 else:
                     params.append(param_name)
             elif self._check(TokenType.KEYWORD):
-                # Parameter name could be a keyword
+                # Parameter name could be a keyword like 'Params'
                 param_name = self._advance().value
                 if param_info:
                     params.append({'name': param_name, **param_info})
@@ -970,16 +1071,106 @@ class CSSLParser:
 
         self._expect(TokenType.PAREN_END)
 
-        # Parse function body
+        # Phase 4: Check for extends/overwrites and append mode
+        extends_func = None
+        extends_is_python = False
+        extends_class_ref = None
+        extends_method_ref = None
+        overwrites_func = None
+        overwrites_is_python = False
+        overwrites_class_ref = None
+        overwrites_method_ref = None
+        append_mode = False
+        append_ref_class = None
+        append_ref_member = None
+
+        # 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
+            elif self._check(TokenType.AT):
+                self._advance()
+                if self._check(TokenType.IDENTIFIER):
+                    append_ref_class = '@' + self._advance().value
+            elif self._check(TokenType.SHARED_REF):
+                append_ref_class = f'${self._advance().value}'
+
+            # 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
+
+        # Check for ++ append operator
+        if self._match(TokenType.PLUS_PLUS):
+            append_mode = True
+
+        # Check for : or :: extends/overwrites
+        if self._match(TokenType.DOUBLE_COLON) or self._match(TokenType.COLON):
+            while True:
+                if self._match_keyword('extends'):
+                    # Parse target: @ModuleName, $PythonObject, Parent::method, Parent.method
+                    if self._check(TokenType.AT):
+                        self._advance()
+                        extends_func = '@' + self._advance().value
+                    elif self._check(TokenType.SHARED_REF):
+                        extends_is_python = True
+                        extends_func = self._advance().value
+                    elif self._check(TokenType.IDENTIFIER):
+                        first_part = self._advance().value
+                        # 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:
+                            extends_func = first_part
+                    # Skip optional ()
+                    if self._match(TokenType.PAREN_START):
+                        self._expect(TokenType.PAREN_END)
+                elif self._match_keyword('overwrites'):
+                    if self._check(TokenType.AT):
+                        self._advance()
+                        overwrites_func = '@' + self._advance().value
+                    elif self._check(TokenType.SHARED_REF):
+                        overwrites_is_python = True
+                        overwrites_func = self._advance().value
+                    elif self._check(TokenType.IDENTIFIER):
+                        first_part = self._advance().value
+                        # 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:
+                            overwrites_func = first_part
+                    if self._match(TokenType.PAREN_START):
+                        self._expect(TokenType.PAREN_END)
+                else:
+                    break
+                if not (self._match(TokenType.DOUBLE_COLON) or self._match(TokenType.COLON)):
+                    break
+
+        # Phase 5: Parse function body
         node = ASTNode('function', value={
             'name': name,
             'is_global': is_global,
+            'is_const': is_const,
             'params': params,
             'return_type': return_type,
             'generic_type': generic_type,
             'modifiers': modifiers,
             'non_null': non_null,
-            'exclude_type': exclude_type  # *[type] - must NOT return this type
+            'exclude_type': exclude_type,
+            'extends': extends_func,
+            'extends_is_python': extends_is_python,
+            'extends_class': extends_class_ref,
+            'extends_method': extends_method_ref,
+            'overwrites': overwrites_func,
+            'overwrites_is_python': overwrites_is_python,
+            'overwrites_class': overwrites_class_ref,
+            'overwrites_method': overwrites_method_ref,
+            'append_mode': append_mode,
+            'append_ref_class': append_ref_class,
+            'append_ref_member': append_ref_member,
+            'enforce_return_type': return_type is not None and 'meta' not in modifiers
         }, children=[])
 
         self._expect(TokenType.BLOCK_START)

{includecpp-3.9.2 → includecpp-4.0.1}/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),
@@ -1431,9 +1586,63 @@ class CSSLRuntime:
                 if isinstance(return_value, tuple):
                     for val in return_value:
                         if excluded_py_type and isinstance(val, excluded_py_type):
-                            raise CSSLError(f"Type exclusion: function must NOT return '{exclude_type}' values")
+                            raise CSSLRuntimeError(f"Type exclusion: function must NOT return '{exclude_type}' values")
                 elif excluded_py_type and isinstance(return_value, excluded_py_type):
-                    raise CSSLError(f"Type exclusion: function must NOT return '{exclude_type}'")
+                    raise CSSLRuntimeError(f"Type exclusion: function must NOT return '{exclude_type}'")
+
+            # Enforce return type for typed functions (like C++)
+            # Typed functions MUST return the declared type
+            # Exception: 'meta' modifier allows any return type
+            enforce_return_type = func_info.get('enforce_return_type', False)
+            return_type = func_info.get('return_type')
+
+            if enforce_return_type and return_type and return_type != 'void':
+                # Type mapping from CSSL types to Python types
+                type_validate_map = {
+                    'string': str, 'int': int, 'float': (int, float), 'bool': bool,
+                    'list': list, 'array': list, 'dict': dict, 'json': dict,
+                    'dynamic': object,  # Any type
+                    'void': type(None),
+                }
+
+                # Generic container types - accept lists/tuples
+                container_types = {
+                    'vector', 'stack', 'datastruct', 'dataspace',
+                    'shuffled', 'iterator', 'combo', 'openquote', 'map'
+                }
+
+                if return_type in container_types:
+                    # Container types accept list, tuple, dict depending on type
+                    if return_type == 'map':
+                        expected = dict
+                    elif return_type == 'shuffled':
+                        expected = (list, tuple)
+                    else:
+                        expected = (list, tuple, object)
+
+                    if not isinstance(return_value, expected):
+                        func_name = func_info.get('name', 'unknown')
+                        actual_type = type(return_value).__name__
+                        raise CSSLRuntimeError(
+                            f"Type error in '{func_name}': declared return type '{return_type}' "
+                            f"but returned '{actual_type}'. Typed functions must return declared type."
+                        )
+                elif return_type in type_validate_map:
+                    expected = type_validate_map[return_type]
+                    if expected != object and return_value is not None:
+                        if not isinstance(return_value, expected):
+                            func_name = func_info.get('name', 'unknown')
+                            actual_type = type(return_value).__name__
+                            raise CSSLRuntimeError(
+                                f"Type error in '{func_name}': declared return type '{return_type}' "
+                                f"but returned '{actual_type}'. Typed functions must return declared type."
+                            )
+
+            # Check non_null: function must return a value (not None)
+            non_null = func_info.get('non_null', False)
+            if non_null and return_value is None:
+                func_name = func_info.get('name', 'unknown')
+                raise CSSLRuntimeError(f"Non-null function '{func_name}' returned null/None")
 
             return return_value
         except Exception as e:
@@ -3022,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,
@@ -3574,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
@@ -3799,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
@@ -3822,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-3.9.2 → includecpp-4.0.1}/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:
         """

{includecpp-3.9.2 → includecpp-4.0.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "IncludeCPP"
-version = "3.9.2"
+version = "4.0.1"
 description = "Professional C++ Python bindings with type-generic templates, pystubs and native threading"
 readme = "README.md"
 requires-python = ">=3.9"
@@ -31,6 +31,7 @@ dependencies = [
     "click>=8.0.0",
     "typing-extensions>=4.0.0",
     "requests>=2.28.0",
+    "colorama>=0.4.0",
 ]
 
 [project.urls]