IncludeCPP 3.5.8__tar.gz → 3.6.0__tar.gz

{includecpp-3.5.8 → includecpp-3.6.0}/IncludeCPP.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: IncludeCPP
-Version: 3.5.8
+Version: 3.6.0
 Summary: Professional C++ Python bindings with type-generic templates, pystubs and native threading
 Home-page: https://github.com/liliassg/IncludeCPP
 Author: Lilias Hatterscheidt

{includecpp-3.5.8 → includecpp-3.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: IncludeCPP
-Version: 3.5.8
+Version: 3.6.0
 Summary: Professional C++ Python bindings with type-generic templates, pystubs and native threading
 Home-page: https://github.com/liliassg/IncludeCPP
 Author: Lilias Hatterscheidt

{includecpp-3.5.8 → includecpp-3.6.0}/includecpp/__init__.py

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

{includecpp-3.5.8 → includecpp-3.6.0}/includecpp/core/cssl/CSSL_DOCUMENTATION.md

@@ -1,6 +1,6 @@
 # CSSL - C-Style Scripting Language
 
-> Version 3.4.20 | A modern scripting language with C++-style syntax and unique features like CodeInfusion and BruteInjection.
+> Version 3.6.0 | A modern scripting language with C++-style syntax and unique features like CodeInfusion and BruteInjection.
 
 ---
 
@@ -15,16 +15,19 @@
 7. [Functions](#functions)
 8. [Function Keywords](#function-keywords)
 9. [String Methods](#string-methods)
-10. [Live Object Sharing](#live-object-sharing)
-11. [CodeInfusion](#codeinfusion)
-12. [BruteInjection](#bruteinjection)
-13. [Filter Syntax](#filter-syntax)
-14. [Module System](#module-system)
-15. [Parameter Bridge](#parameter-bridge)
-16. [Structures](#structures)
-17. [Error Handling](#error-handling)
-18. [CLI Commands](#cli-commands)
-19. [Examples](#examples)
+10. [File I/O](#file-io)
+11. [JSON Functions](#json-functions)
+12. [Live Object Sharing](#live-object-sharing)
+13. [CodeInfusion](#codeinfusion)
+14. [Value Capture](#value-capture)
+15. [BruteInjection](#bruteinjection)
+16. [Filter Syntax](#filter-syntax)
+17. [Module System](#module-system)
+18. [Parameter Bridge](#parameter-bridge)
+19. [Structures](#structures)
+20. [Error Handling](#error-handling)
+21. [CLI Commands](#cli-commands)
+22. [Examples](#examples)
 
 ---
 
@@ -336,14 +339,26 @@ int number = 42;
 // Declaration with 'global'
 global myGlobal = "visible everywhere";
 
-// Access with '@'
+// Access with '@' prefix
 printl(@myGlobal);
 
-// Alternative: r@ syntax
+// Or access directly without '@' (since v3.5.9)
+printl(myGlobal);  // Works the same!
+
+// Alternative: r@ syntax for declaration
 r@anotherGlobal = "also global";
 printl(@anotherGlobal);
+printl(anotherGlobal);  // Also works
 ```
 
+### Lookup Order
+
+When accessing a variable, CSSL checks in order:
+1. Local scope
+2. Global scope
+3. Promoted globals
+4. Built-in functions
+
 ### Usage in Functions
 
 ```cssl
@@ -539,6 +554,29 @@ string n = getName();
 int sum = add(5, 3);
 ```
 
+### Named Parameters
+
+Functions can be called with named parameters for clarity.
+
+```cssl
+// Define function
+int calculate(int base, int multiplier, int offset) {
+    return base * multiplier + offset;
+}
+
+// Call with positional arguments
+int r1 = calculate(10, 5, 3);  // 53
+
+// Call with named parameters
+int r2 = calculate(base=10, multiplier=5, offset=3);  // 53
+
+// Mix positional and named (positional must come first)
+int r3 = calculate(10, multiplier=5, offset=3);  // 53
+
+// Named parameters can be in any order
+int r4 = calculate(offset=3, base=10, multiplier=5);  // 53
+```
+
 ### Nested Functions
 
 ```cssl
@@ -798,6 +836,170 @@ string padded2 = num.padEnd(5, ".");    // "42..."
 
 ---
 
+## File I/O
+
+CSSL provides built-in functions for file operations.
+
+### Basic File Operations
+
+```cssl
+// Read entire file
+string content = read("/path/to/file.txt");
+printl(content);
+
+// Read specific line (1-indexed)
+string line5 = readline(5, "/path/to/file.txt");
+printl(line5);
+
+// Write to file (overwrites)
+write("/path/to/file.txt", "Hello World");
+
+// Write/replace specific line
+writeline(3, "New line content", "/path/to/file.txt");
+```
+
+### Extended File Functions
+
+```cssl
+// Read all lines as array
+stack<string> lines = readlines("/path/to/file.txt");
+
+// Append to file
+appendfile("/path/to/file.txt", "\nNew content");
+
+// File checks
+bool exists = pathexists("/path/to/file.txt");
+bool isFile = isfile("/path/to/file.txt");
+bool isDir = isdir("/path/to/folder");
+
+// File size
+int size = filesize("/path/to/file.txt");
+
+// Directory listing
+stack<string> files = listdir("/path/to/folder");
+```
+
+### Path Functions
+
+```cssl
+// Path manipulation
+string base = basename("/path/to/file.txt");    // "file.txt"
+string dir = dirname("/path/to/file.txt");       // "/path/to"
+string full = joinpath("/path", "to", "file.txt"); // "/path/to/file.txt"
+string abs = abspath("./file.txt");              // "/current/dir/file.txt"
+```
+
+### All File I/O Functions
+
+| Function | Description |
+|----------|-------------|
+| `read(path)` | Read entire file content |
+| `readline(line, path)` | Read specific line (1-indexed) |
+| `write(path, content)` | Write content to file |
+| `writeline(line, content, path)` | Write/replace specific line |
+| `readfile(path)` | Read file (alias for read) |
+| `writefile(path, content)` | Write file (alias for write) |
+| `readlines(path)` | Read all lines as array |
+| `appendfile(path, content)` | Append to file |
+| `pathexists(path)` | Check if path exists |
+| `isfile(path)` | Check if is file |
+| `isdir(path)` | Check if is directory |
+| `filesize(path)` | Get file size in bytes |
+| `listdir(path)` | List directory contents |
+| `makedirs(path)` | Create directories |
+| `removefile(path)` | Delete file |
+| `removedir(path)` | Delete empty directory |
+| `copyfile(src, dst)` | Copy file |
+| `movefile(src, dst)` | Move file |
+
+---
+
+## JSON Functions
+
+CSSL provides namespace-style JSON functions with the `json::` prefix.
+
+### Reading & Writing JSON Files
+
+```cssl
+// Read and parse JSON file
+json data = json::read("/path/to/config.json");
+printl(data.name);
+
+// Write data to JSON file
+json::write("/path/to/output.json", data);
+```
+
+### JSON Parsing & Stringifying
+
+```cssl
+// Parse JSON string
+string jsonStr = '{"name": "Alice", "age": 30}';
+json obj = json::parse(jsonStr);
+
+// Convert to JSON string
+string str = json::stringify(obj);
+
+// Pretty print with indentation
+string pretty = json::pretty(obj);
+printl(pretty);
+```
+
+### JSON Path Operations
+
+```cssl
+json data = json::read("config.json");
+
+// Get value by dot-path
+string name = json::get(data, "user.name");
+int age = json::get(data, "user.profile.age");
+string city = json::get(data, "address.city", "Unknown");  // with default
+
+// Set value by dot-path
+data = json::set(data, "user.name", "Bob");
+data = json::set(data, "settings.theme", "dark");
+
+// Check if path exists
+if (json::has(data, "user.email")) {
+    printl("Email exists");
+}
+```
+
+### JSON Object Operations
+
+```cssl
+json obj = json::read("data.json");
+
+// Get all keys
+stack<string> keys = json::keys(obj);
+foreach (key in keys) {
+    printl(key);
+}
+
+// Get all values
+stack<dynamic> values = json::values(obj);
+
+// Deep merge objects
+json merged = json::merge(obj1, obj2, obj3);
+```
+
+### All JSON Functions
+
+| Function | Description |
+|----------|-------------|
+| `json::read(path)` | Read and parse JSON file |
+| `json::write(path, data)` | Write data to JSON file |
+| `json::parse(str)` | Parse JSON string to object |
+| `json::stringify(data)` | Convert to JSON string |
+| `json::pretty(data)` | Pretty print JSON |
+| `json::get(data, path, default)` | Get value by dot-path |
+| `json::set(data, path, value)` | Set value by dot-path |
+| `json::has(data, path)` | Check if path exists |
+| `json::keys(data)` | Get all keys |
+| `json::values(data)` | Get all values |
+| `json::merge(obj1, obj2, ...)` | Deep merge objects |
+
+---
+
 ## Live Object Sharing
 
 Share Python objects with CSSL. Changes in CSSL reflect back to Python.
@@ -934,6 +1136,74 @@ exit();  // Executes injection
 
 ---
 
+## Value Capture
+
+The `%identifier` syntax captures values at registration time, useful for saving original functions before replacement.
+
+### Capturing Variables
+
+```cssl
+string version = "1.0.0";
+
+// Capture current value
+v <== { %version; }
+printl(v);  // "1.0.0"
+
+// Even if version changes later, v keeps captured value
+version = "2.0.0";
+printl(v);  // Still "1.0.0"
+```
+
+### Capturing Functions
+
+```cssl
+// Save original exit function before replacing
+originalExit <<== { %exit(); }
+
+// Replace exit with custom behavior
+exit() <<== {
+    printl("Custom cleanup...");
+    originalExit();  // Call saved original
+}
+
+exit();
+// Output:
+// Custom cleanup...
+// (original exit behavior)
+```
+
+### Use Cases
+
+```cssl
+// 1. Preserving original behavior
+void myFunc() {
+    printl("Original");
+}
+
+savedFunc <<== { %myFunc(); }
+
+myFunc() <<== {
+    printl("Modified");
+}
+
+myFunc();      // "Modified"
+savedFunc();   // "Original"
+
+// 2. Capturing configuration at startup
+global config = loadConfig();
+startupConfig <== { %config; }
+
+// 3. Snapshot values for later comparison
+int counter = 0;
+initial <== { %counter; }
+// ... operations ...
+if (counter != initial) {
+    printl("Counter changed!");
+}
+```
+
+---
+
 ## BruteInjection
 
 BruteInjection copies/moves data between containers.
@@ -981,6 +1251,26 @@ container ==> data;
 
 ---
 
+### ==>- (Receive Minus)
+
+Removes matching items from target.
+
+```cssl
+stack<string> names;
+names.push("Alice");
+names.push("Bob");
+names.push("Alice");
+
+stack<string> toRemove;
+toRemove.push("Alice");
+
+// Remove all "Alice" from names
+names ==>- toRemove;
+printl(names);  // ["Bob"]
+```
+
+---
+
 ## Filter Syntax
 
 Filters enable targeted data operations in BruteInjection.
@@ -1014,6 +1304,30 @@ result +<== [string::contains="App"] fruits;  // Apple, Apricot
 result +<== [string::length=5] fruits;  // Apple
 ```
 
+### String Cutting Filters
+
+Cut strings at specific positions or substrings.
+
+```cssl
+string version = "1.0.0-beta";
+
+// Cut at position (integer index)
+x = <==[string::cut=3] version;
+printl(x);  // "1.0" (first 3 chars)
+
+// Cut at substring position
+x = <==[string::cut="0-"] version;
+printl(x);  // "1.0." (before "0-")
+
+// Get everything after substring
+x = <==[string::cutAfter=".0."] version;
+printl(x);  // "0-beta" (after ".0.")
+
+// Cut after at position
+x = <==[string::cutAfter=4] version;
+printl(x);  // ".0-beta" (after index 4)
+```
+
 ### All Filters
 
 | Filter | Description |
@@ -1022,6 +1336,10 @@ result +<== [string::length=5] fruits;  // Apple
 | `string::not=VALUE` | Everything except this value |
 | `string::contains=VALUE` | Contains substring |
 | `string::length=LENGTH` | Exact string length |
+| `string::cut=INDEX` | Cut at index (returns first N chars) |
+| `string::cut="SUBSTR"` | Cut at substring position |
+| `string::cutAfter=INDEX` | Get everything after index |
+| `string::cutAfter="SUBSTR"` | Get everything after substring |
 | `integer::where=VALUE` | Exact int match |
 | `json::key=KEYNAME` | Filter by JSON key |
 | `json::value=VALUE` | Filter by JSON value |
@@ -1457,12 +1775,25 @@ print(result)  # ["Missing colon after def"]
 
 | Operator | Type | Description |
 |----------|------|-------------|
-| `<<==` | CodeInfusion | Replace |
-| `+<<==` | CodeInfusion | Add |
-| `-<<==` | CodeInfusion | Remove |
-| `+<==` | BruteInjection | Copy |
-| `-<==` | BruteInjection | Move |
-| `==>` | BruteInjection | Replace |
+| `<<==` | CodeInfusion | Replace function |
+| `+<<==` | CodeInfusion | Add code (before) |
+| `-<<==` | CodeInfusion | Remove code |
+| `<==` | ValueCapture | Capture/assign value |
+| `+<==` | BruteInjection | Copy data |
+| `-<==` | BruteInjection | Move data |
+| `==>` | BruteInjection | Replace data |
+| `==>-` | BruteInjection | Remove matching items |
+
+### Special Syntax
+
+| Syntax | Description |
+|--------|-------------|
+| `%identifier` | Capture value at registration time |
+| `json::func()` | Namespace function call |
+| `@name` | Access global variable |
+| `$name` | Access shared Python object |
+| `s@name` | Self-reference to struct |
+| `r@name` | Global variable declaration |
 
 ---
 
@@ -1479,4 +1810,4 @@ print(result)  # ["Missing colon after def"]
 
 ---
 
-*CSSL v3.4.20 - Developed as part of IncludeCPP*
+*CSSL v3.6.0 - Developed as part of IncludeCPP*

{includecpp-3.5.8 → includecpp-3.6.0}/includecpp/core/cssl/cssl_builtins.py

@@ -162,6 +162,10 @@ class CSSLBuiltins:
         self._functions['abspath'] = self.builtin_abspath
         self._functions['normpath'] = self.builtin_normpath
         # File I/O functions
+        self._functions['read'] = self.builtin_read
+        self._functions['readline'] = self.builtin_readline
+        self._functions['write'] = self.builtin_write
+        self._functions['writeline'] = self.builtin_writeline
         self._functions['readfile'] = self.builtin_readfile
         self._functions['writefile'] = self.builtin_writefile
         self._functions['appendfile'] = self.builtin_appendfile
@@ -177,6 +181,18 @@ class CSSLBuiltins:
         # JSON functions
         self._functions['tojson'] = self.builtin_tojson
         self._functions['fromjson'] = self.builtin_fromjson
+        # JSON namespace functions (json::read, json::write, etc.)
+        self._functions['json::read'] = self.builtin_json_read
+        self._functions['json::write'] = self.builtin_json_write
+        self._functions['json::parse'] = self.builtin_fromjson
+        self._functions['json::stringify'] = self.builtin_tojson
+        self._functions['json::pretty'] = self.builtin_json_pretty
+        self._functions['json::keys'] = self.builtin_json_keys
+        self._functions['json::values'] = self.builtin_json_values
+        self._functions['json::get'] = self.builtin_json_get
+        self._functions['json::set'] = self.builtin_json_set
+        self._functions['json::has'] = self.builtin_json_has
+        self._functions['json::merge'] = self.builtin_json_merge
 
         # Regex functions
         self._functions['match'] = self.builtin_match
@@ -801,6 +817,54 @@ class CSSLBuiltins:
 
     # ============= File I/O Functions =============
 
+    def builtin_read(self, path: str, encoding: str = 'utf-8') -> str:
+        """Read entire file content.
+        Usage: read('/path/to/file.txt')
+        """
+        with open(path, 'r', encoding=encoding) as f:
+            return f.read()
+
+    def builtin_readline(self, line: int, path: str, encoding: str = 'utf-8') -> str:
+        """Read specific line from file (1-indexed).
+        Usage: readline(5, '/path/to/file.txt')  -> returns line 5
+        """
+        with open(path, 'r', encoding=encoding) as f:
+            for i, file_line in enumerate(f, 1):
+                if i == line:
+                    return file_line.rstrip('\n\r')
+            return ""  # Line not found
+
+    def builtin_write(self, path: str, content: str, encoding: str = 'utf-8') -> int:
+        """Write content to file, returns chars written.
+        Usage: write('/path/to/file.txt', 'Hello World')
+        """
+        with open(path, 'w', encoding=encoding) as f:
+            return f.write(content)
+
+    def builtin_writeline(self, line: int, content: str, path: str, encoding: str = 'utf-8') -> bool:
+        """Write/replace specific line in file (1-indexed).
+        Usage: writeline(5, 'New content', '/path/to/file.txt')
+        """
+        # Read all lines
+        lines = []
+        if os.path.exists(path):
+            with open(path, 'r', encoding=encoding) as f:
+                lines = f.readlines()
+
+        # Ensure we have enough lines
+        while len(lines) < line:
+            lines.append('\n')
+
+        # Replace the specific line (1-indexed)
+        if not content.endswith('\n'):
+            content = content + '\n'
+        lines[line - 1] = content
+
+        # Write back
+        with open(path, 'w', encoding=encoding) as f:
+            f.writelines(lines)
+        return True
+
     def builtin_readfile(self, path: str, encoding: str = 'utf-8') -> str:
         """Read entire file content"""
         with open(path, 'r', encoding=encoding) as f:
@@ -862,6 +926,106 @@ class CSSLBuiltins:
     def builtin_fromjson(self, s: str) -> Any:
         return json.loads(s)
 
+    # JSON namespace functions (json::read, json::write, etc.)
+    def builtin_json_read(self, path: str, encoding: str = 'utf-8') -> Any:
+        """Read and parse JSON file.
+        Usage: json::read('/path/to/file.json')
+        """
+        with open(path, 'r', encoding=encoding) as f:
+            return json.load(f)
+
+    def builtin_json_write(self, path: str, data: Any, indent: int = 2, encoding: str = 'utf-8') -> bool:
+        """Write data to JSON file.
+        Usage: json::write('/path/to/file.json', data)
+        """
+        with open(path, 'w', encoding=encoding) as f:
+            json.dump(data, f, indent=indent, ensure_ascii=False)
+        return True
+
+    def builtin_json_pretty(self, value: Any, indent: int = 2) -> str:
+        """Pretty print JSON.
+        Usage: json::pretty(data)
+        """
+        return json.dumps(value, indent=indent, ensure_ascii=False)
+
+    def builtin_json_keys(self, data: Any) -> list:
+        """Get all keys from JSON object.
+        Usage: json::keys(data)
+        """
+        if isinstance(data, dict):
+            return list(data.keys())
+        return []
+
+    def builtin_json_values(self, data: Any) -> list:
+        """Get all values from JSON object.
+        Usage: json::values(data)
+        """
+        if isinstance(data, dict):
+            return list(data.values())
+        return []
+
+    def builtin_json_get(self, data: Any, path: str, default: Any = None) -> Any:
+        """Get value by dot-path from JSON.
+        Usage: json::get(data, 'user.name')
+        """
+        if not isinstance(data, dict):
+            return default
+        keys = path.split('.')
+        current = data
+        for key in keys:
+            if isinstance(current, dict) and key in current:
+                current = current[key]
+            elif isinstance(current, list):
+                try:
+                    current = current[int(key)]
+                except (ValueError, IndexError):
+                    return default
+            else:
+                return default
+        return current
+
+    def builtin_json_set(self, data: Any, path: str, value: Any) -> Any:
+        """Set value by dot-path in JSON object.
+        Usage: json::set(data, 'user.name', 'John')
+        """
+        if not isinstance(data, dict):
+            return data
+        data = dict(data)  # Copy
+        keys = path.split('.')
+        current = data
+        for i, key in enumerate(keys[:-1]):
+            if key not in current or not isinstance(current[key], dict):
+                current[key] = {}
+            current = current[key]
+        current[keys[-1]] = value
+        return data
+
+    def builtin_json_has(self, data: Any, path: str) -> bool:
+        """Check if path exists in JSON.
+        Usage: json::has(data, 'user.name')
+        """
+        result = self.builtin_json_get(data, path, _MISSING := object())
+        return result is not _MISSING
+
+    def builtin_json_merge(self, *dicts) -> dict:
+        """Deep merge multiple JSON objects.
+        Usage: json::merge(obj1, obj2, obj3)
+        """
+        def deep_merge(base, update):
+            result = dict(base)
+            for key, value in update.items():
+                if key in result and isinstance(result[key], dict) and isinstance(value, dict):
+                    result[key] = deep_merge(result[key], value)
+                else:
+                    result[key] = value
+            return result
+
+        result = {}
+        for d in dicts:
+            if isinstance(d, dict):
+                result = deep_merge(result, d)
+        return result
+
     # ============= Regex Functions =============
 
     def builtin_match(self, pattern: str, string: str) -> Optional[dict]:

{includecpp-3.5.8 → includecpp-3.6.0}/includecpp/core/cssl/cssl_parser.py

@@ -2178,9 +2178,48 @@ class CSSLParser:
 
         return node
 
+    def _parse_call_arguments(self) -> tuple:
+        """Parse function call arguments, supporting both positional and named (key=value).
+
+        Returns: (args, kwargs) where:
+            args = list of positional argument expressions
+            kwargs = dict of {name: expression} for named arguments
+        """
+        args = []
+        kwargs = {}
+
+        while not self._check(TokenType.PAREN_END) and not self._is_at_end():
+            # Check for named argument: identifier = expression
+            if self._check(TokenType.IDENTIFIER):
+                saved_pos = self._current
+                name_token = self._advance()
+
+                if self._check(TokenType.EQUALS):
+                    # Named argument: name=value
+                    self._advance()  # consume =
+                    value = self._parse_expression()
+                    kwargs[name_token.value] = value
+                else:
+                    # Not named, restore and parse as expression
+                    self._current = saved_pos
+                    args.append(self._parse_expression())
+            else:
+                args.append(self._parse_expression())
+
+            if not self._check(TokenType.PAREN_END):
+                self._expect(TokenType.COMMA)
+
+        return args, kwargs
+
     def _parse_identifier_or_call(self) -> ASTNode:
         name = self._advance().value
 
+        # Check for namespace syntax: json::read, string::cut, etc.
+        if self._match(TokenType.DOUBLE_COLON):
+            if self._check(TokenType.IDENTIFIER) or self._check(TokenType.KEYWORD):
+                namespace_member = self._advance().value
+                name = f"{name}::{namespace_member}"
+
         # Check for type generic instantiation: stack<string>, vector<int>, etc.
         # This creates a new instance of the type with the specified element type
         if name in TYPE_GENERICS and self._check(TokenType.COMPARE_LT):
@@ -2226,13 +2265,9 @@ class CSSLParser:
                 member = self._advance().value
                 node = ASTNode('member_access', value={'object': node, 'member': member})
             elif self._match(TokenType.PAREN_START):
-                args = []
-                while not self._check(TokenType.PAREN_END):
-                    args.append(self._parse_expression())
-                    if not self._check(TokenType.PAREN_END):
-                        self._expect(TokenType.COMMA)
+                args, kwargs = self._parse_call_arguments()
                 self._expect(TokenType.PAREN_END)
-                node = ASTNode('call', value={'callee': node, 'args': args})
+                node = ASTNode('call', value={'callee': node, 'args': args, 'kwargs': kwargs})
             elif self._match(TokenType.BRACKET_START):
                 index = self._parse_expression()
                 self._expect(TokenType.BRACKET_END)

{includecpp-3.5.8 → includecpp-3.6.0}/includecpp/core/cssl/cssl_runtime.py

@@ -775,11 +775,18 @@ class CSSLRuntime:
         # Fallback: execute normally
         return self._execute_node(inner)
 
-    def _call_function(self, func_node: ASTNode, args: List[Any]) -> Any:
-        """Call a function node with arguments"""
+    def _call_function(self, func_node: ASTNode, args: List[Any], kwargs: Dict[str, Any] = None) -> Any:
+        """Call a function node with arguments (positional and named)
+
+        Args:
+            func_node: The function AST node
+            args: List of positional arguments
+            kwargs: Dict of named arguments (param_name -> value)
+        """
         func_info = func_node.value
         params = func_info.get('params', [])
         modifiers = func_info.get('modifiers', [])
+        kwargs = kwargs or {}
 
         # Check for undefined modifier - suppress errors if present
         is_undefined = 'undefined' in modifiers
@@ -787,11 +794,16 @@ class CSSLRuntime:
         # Create new scope
         new_scope = Scope(parent=self.scope)
 
-        # Bind parameters - handle both string and dict formats
+        # Bind parameters - handle both positional and named arguments
         for i, param in enumerate(params):
             # Extract param name from dict format: {'name': 'a', 'type': 'int'}
             param_name = param['name'] if isinstance(param, dict) else param
-            if i < len(args):
+
+            if param_name in kwargs:
+                # Named argument takes priority
+                new_scope.set(param_name, kwargs[param_name])
+            elif i < len(args):
+                # Positional argument
                 new_scope.set(param_name, args[i])
             else:
                 new_scope.set(param_name, None)
@@ -1681,9 +1693,17 @@ class CSSLRuntime:
             return None
 
         if node.type == 'identifier':
-            value = self.scope.get(node.value)
-            if value is None and self.builtins.has_function(node.value):
-                return self.builtins.get_function(node.value)
+            name = node.value
+            value = self.scope.get(name)
+            # Fallback to global scope
+            if value is None:
+                value = self.global_scope.get(name)
+            # Fallback to promoted globals (from 'global' keyword)
+            if value is None:
+                value = self._promoted_globals.get(name)
+            # Fallback to builtins
+            if value is None and self.builtins.has_function(name):
+                return self.builtins.get_function(name)
             return value
 
         if node.type == 'module_ref':
@@ -2017,10 +2037,14 @@ class CSSLRuntime:
         return None
 
     def _eval_call(self, node: ASTNode) -> Any:
-        """Evaluate function call"""
+        """Evaluate function call with optional named arguments"""
         callee_node = node.value.get('callee')
         args = [self._evaluate(a) for a in node.value.get('args', [])]
 
+        # Evaluate named arguments (kwargs)
+        kwargs_raw = node.value.get('kwargs', {})
+        kwargs = {k: self._evaluate(v) for k, v in kwargs_raw.items()} if kwargs_raw else {}
+
         # Get function name for injection check FIRST (before evaluating callee)
         func_name = None
         if isinstance(callee_node, ASTNode):
@@ -2048,10 +2072,12 @@ class CSSLRuntime:
 
         # Execute original function
         if callable(callee):
+            if kwargs:
+                return callee(*args, **kwargs)
             return callee(*args)
 
         if isinstance(callee, ASTNode) and callee.type == 'function':
-            return self._call_function(callee, args)
+            return self._call_function(callee, args, kwargs)
 
         callee_name = callee_node.value if isinstance(callee_node, ASTNode) and hasattr(callee_node, 'value') else str(callee_node)
         raise CSSLRuntimeError(

{includecpp-3.5.8 → includecpp-3.6.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "IncludeCPP"
-version = "3.5.8"
+version = "3.6.0"
 description = "Professional C++ Python bindings with type-generic templates, pystubs and native threading"
 readme = "README.md"
 requires-python = ">=3.9"