IncludeCPP 3.4.10__py3-none-any.whl → 3.4.21__py3-none-any.whl

includecpp/core/cssl_bridge.py

@@ -3,11 +3,125 @@ CSSL Bridge - Python API for CSSL Language
 Provides CsslLang class for executing CSSL code from Python.
 """
 
+import os
+import pickle
+import random
 import threading
 from pathlib import Path
 from typing import Any, List, Optional, Callable, Dict
 
 
+def _get_share_directory() -> Path:
+    """Get the directory for shared objects."""
+    # Use APPDATA on Windows, ~/.config on Unix
+    if os.name == 'nt':
+        base = Path(os.environ.get('APPDATA', Path.home() / 'AppData' / 'Roaming'))
+    else:
+        base = Path(os.environ.get('XDG_CONFIG_HOME', Path.home() / '.config'))
+
+    share_dir = base / 'IncludeCPP' / 'shared_objects'
+    share_dir.mkdir(parents=True, exist_ok=True)
+    return share_dir
+
+
+# Global live object registry - holds actual object references for live sharing
+_live_objects: Dict[str, Any] = {}
+
+
+class SharedObjectProxy:
+    """
+    Live proxy for accessing a shared Python object from CSSL.
+    Changes made through this proxy are reflected in the original object.
+    """
+
+    def __init__(self, name: str, obj: Any = None):
+        object.__setattr__(self, '_name', name)
+        object.__setattr__(self, '_direct_object', obj)
+
+    def _get_object(self):
+        """Get the live object reference."""
+        # First check direct object (same-instance sharing)
+        direct = object.__getattribute__(self, '_direct_object')
+        if direct is not None:
+            return direct
+
+        # Fall back to global registry
+        name = object.__getattribute__(self, '_name')
+        if name in _live_objects:
+            return _live_objects[name]
+
+        return None
+
+    def __getattr__(self, name: str):
+        """Access attributes/methods on the shared object."""
+        obj = self._get_object()
+        if obj is None:
+            obj_name = object.__getattribute__(self, '_name')
+            raise AttributeError(f"Shared object '${obj_name}' not available")
+
+        return getattr(obj, name)
+
+    def __setattr__(self, name: str, value: Any):
+        """Set attributes on the shared object (live update)."""
+        if name.startswith('_'):
+            object.__setattr__(self, name, value)
+            return
+
+        obj = self._get_object()
+        if obj is None:
+            obj_name = object.__getattribute__(self, '_name')
+            raise AttributeError(f"Shared object '${obj_name}' not available")
+
+        setattr(obj, name, value)
+
+    def __repr__(self):
+        obj = self._get_object()
+        name = object.__getattribute__(self, '_name')
+        return f"<SharedObject ${name} type={type(obj).__name__ if obj else 'None'}>"
+
+    def __call__(self, *args, **kwargs):
+        """Allow calling the object if it's callable."""
+        obj = self._get_object()
+        if obj is None:
+            name = object.__getattribute__(self, '_name')
+            raise TypeError(f"Shared object '${name}' not available")
+        if callable(obj):
+            return obj(*args, **kwargs)
+        name = object.__getattribute__(self, '_name')
+        raise TypeError(f"Shared object '${name}' is not callable")
+
+    def __getitem__(self, key):
+        """Allow indexing on the shared object."""
+        obj = self._get_object()
+        if obj is None:
+            name = object.__getattribute__(self, '_name')
+            raise KeyError(f"Shared object '${name}' not available")
+        return obj[key]
+
+    def __setitem__(self, key, value):
+        """Allow setting items on the shared object (live update)."""
+        obj = self._get_object()
+        if obj is None:
+            name = object.__getattribute__(self, '_name')
+            raise KeyError(f"Shared object '${name}' not available")
+        obj[key] = value
+
+    def __iter__(self):
+        """Allow iterating over the shared object."""
+        obj = self._get_object()
+        if obj is None:
+            name = object.__getattribute__(self, '_name')
+            raise TypeError(f"Shared object '${name}' not available")
+        return iter(obj)
+
+    def __len__(self):
+        """Get length of the shared object."""
+        obj = self._get_object()
+        if obj is None:
+            return 0
+        return len(obj)
+
+
 class CSSLModule:
     """
     A callable CSSL module that executes code with arguments.
@@ -276,6 +390,255 @@ class CsslLang:
         """
         return CSSLFunctionModule(self, code)
 
+    def code(self, name: str, code: str) -> None:
+        """
+        Register inline CSSL code as a payload that can be loaded via payload().
+
+        This allows creating payloads from Python code without external files.
+
+        Usage:
+            from includecpp import CSSL
+            cssl = CSSL.CsslLang()
+
+            # Register a helper payload
+            cssl.code("helpers", '''
+                global version = "1.0.0";
+                void log(string msg) {
+                    printl("[LOG] " + msg);
+                }
+            ''')
+
+            # Use it in CSSL code
+            cssl.exec('''
+                payload("helpers");  // Load the inline payload
+                @log("Hello!");      // Call the helper function
+                printl(@version);    // Access the global
+            ''')
+
+        Args:
+            name: Name to register the payload under (used in payload("name"))
+            code: CSSL code string
+        """
+        runtime = self._get_runtime()
+        if not hasattr(runtime, '_inline_payloads'):
+            runtime._inline_payloads = {}
+        runtime._inline_payloads[name] = code
+
+    def share(self, instance: Any, name: str) -> str:
+        """
+        Share a Python object instance with CSSL scripts (LIVE sharing).
+
+        The object is stored as a LIVE reference - changes made in CSSL
+        will be reflected in the original Python object immediately.
+        Call share() again with the same name to update the shared object.
+
+        Usage in Python:
+            from includecpp import CSSL
+            cssl = CSSL.CsslLang()
+
+            # Share a Python object
+            class MyAPI:
+                def __init__(self):
+                    self.counter = 0
+                def greet(self, name):
+                    return f"Hello, {name}!"
+                def increment(self):
+                    self.counter += 1
+
+            api = MyAPI()
+            cssl.share(api, "myapi")
+
+            # Use in CSSL - changes are LIVE!
+            cssl.exec('''
+                ob <== $myapi;
+                printl(ob.greet("World"));
+                ob.increment();
+                printl(ob.counter);  // 1
+            ''')
+
+            # Changes reflect back to Python!
+            print(api.counter)  # 1
+
+        Args:
+            instance: Python object to share
+            name: Name for the shared object (accessed as $name in CSSL)
+
+        Returns:
+            Path to the shared object marker file
+        """
+        global _live_objects
+        runtime = self._get_runtime()
+
+        # Initialize shared objects registry
+        if not hasattr(runtime, '_shared_objects'):
+            runtime._shared_objects = {}
+
+        # Generate unique filename: <name>.shareobj<7digits>
+        random_suffix = ''.join([str(random.randint(0, 9)) for _ in range(7)])
+        share_dir = _get_share_directory()
+        filepath = share_dir / f"{name}.shareobj{random_suffix}"
+
+        # Remove old file if updating
+        if name in runtime._shared_objects:
+            old_path = runtime._shared_objects[name]['path']
+            try:
+                Path(old_path).unlink(missing_ok=True)
+            except Exception:
+                pass
+
+        # Store LIVE object reference in global registry
+        _live_objects[name] = instance
+
+        # Write marker file with metadata (not the actual object)
+        import json
+        metadata = {
+            'name': name,
+            'type': type(instance).__name__,
+            'live': True,
+            'id': id(instance)
+        }
+        with open(filepath, 'w', encoding='utf-8') as f:
+            json.dump(metadata, f)
+
+        # Register in runtime
+        runtime._shared_objects[name] = {
+            'path': str(filepath),
+            'type': type(instance).__name__,
+            'live': True
+        }
+
+        # Also register the live proxy in the runtime's scope for $name access
+        proxy = SharedObjectProxy(name, instance)
+        runtime.global_scope.set(f'${name}', proxy)
+
+        return str(filepath)
+
+    def unshare(self, name: str) -> bool:
+        """
+        Remove a shared object.
+
+        Args:
+            name: Name of the shared object to remove
+
+        Returns:
+            True if removed, False if not found
+        """
+        global _live_objects
+        runtime = self._get_runtime()
+
+        if not hasattr(runtime, '_shared_objects'):
+            return False
+
+        if name not in runtime._shared_objects:
+            return False
+
+        # Remove from live objects registry
+        if name in _live_objects:
+            del _live_objects[name]
+
+        # Remove from runtime scope
+        try:
+            runtime.global_scope.delete(f'${name}')
+        except Exception:
+            pass
+
+        # Remove marker file
+        filepath = runtime._shared_objects[name]['path']
+        try:
+            Path(filepath).unlink(missing_ok=True)
+        except Exception:
+            pass
+
+        del runtime._shared_objects[name]
+        return True
+
+    def get_shared(self, name: str) -> Optional[Any]:
+        """
+        Get a shared object by name (for Python-side access).
+
+        Returns the actual live object reference, not a copy.
+
+        Args:
+            name: Name of the shared object
+
+        Returns:
+            The live shared object or None if not found
+        """
+        global _live_objects
+
+        # Return live object if available
+        if name in _live_objects:
+            return _live_objects[name]
+
+        return None
+
+
+# Global shared objects registry (for cross-instance sharing)
+_global_shared_objects: Dict[str, str] = {}
+
+
+def share(instance: Any, name: str) -> str:
+    """
+    Share a Python object globally for all CSSL instances (LIVE sharing).
+
+    Changes made through CSSL will reflect back to the original object.
+    """
+    global _live_objects
+
+    random_suffix = ''.join([str(random.randint(0, 9)) for _ in range(7)])
+    share_dir = _get_share_directory()
+    filepath = share_dir / f"{name}.shareobj{random_suffix}"
+
+    # Remove old file if updating
+    if name in _global_shared_objects:
+        try:
+            Path(_global_shared_objects[name]).unlink(missing_ok=True)
+        except Exception:
+            pass
+
+    # Store LIVE object reference
+    _live_objects[name] = instance
+
+    # Write marker file with metadata
+    import json
+    metadata = {
+        'name': name,
+        'type': type(instance).__name__,
+        'live': True,
+        'id': id(instance)
+    }
+    with open(filepath, 'w', encoding='utf-8') as f:
+        json.dump(metadata, f)
+
+    _global_shared_objects[name] = str(filepath)
+    return str(filepath)
+
+
+def unshare(name: str) -> bool:
+    """Remove a globally shared object."""
+    global _live_objects
+
+    if name not in _global_shared_objects:
+        return False
+
+    # Remove from live objects
+    if name in _live_objects:
+        del _live_objects[name]
+
+    try:
+        Path(_global_shared_objects[name]).unlink(missing_ok=True)
+    except Exception:
+        pass
+
+    del _global_shared_objects[name]
+    return True
+
+
+def get_shared(name: str) -> Optional[Any]:
+    """Get a globally shared object by name."""
+    global _live_objects
+    return _live_objects.get(name)
+
 
 # Singleton for convenience
 _default_instance: Optional[CsslLang] = None

includecpp/generator/parser.cpp

@@ -705,7 +705,7 @@ ModuleDescriptor API::parse_cp_file(const std::string& filepath) {
         std::ifstream source_file(desc.source_path);
         if (source_file.is_open()) {
             std::string line;
-            std::regex include_regex(R"(^\s*#include\s*"([^"]+\.h(?:pp)?)")");
+            std::regex include_regex(R"re(^\s*#include\s*"([^"]+\.h(?:pp)?)")re");
             std::smatch match;
 
             while (std::getline(source_file, line)) {

{includecpp-3.4.10.dist-info → includecpp-3.4.21.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: IncludeCPP
-Version: 3.4.10
+Version: 3.4.21
 Summary: Professional C++ Python bindings with type-generic templates, pystubs and native threading
 Home-page: https://github.com/liliassg/IncludeCPP
 Author: Lilias Hatterscheidt
@@ -621,10 +621,277 @@ Then check **"Enable Experimental Features"** and save.
 - Have breaking changes between versions
 - Be removed or significantly changed
 
-Use at your own discretion. Report issues at: https://github.com/hatte/IncludeCPP/issues
+Use at your own discretion. Report issues at: https://github.com/liliassg/IncludeCPP/issues
+
+# CSSL - CSO Service Script Language
+
+IncludeCPP includes CSSL, a scripting language with advanced data manipulation features.
+
+## Basic Usage
+
+```python
+from includecpp import CSSL
+
+# Execute CSSL code
+CSSL.exec('''
+    printl("Hello from CSSL!");
+
+    int x = 10;
+    for (i in range(0, 5)) {
+        x = x + i;
+    }
+    printl(x);
+''')
+
+# Execute with arguments
+result = CSSL.exec('''
+    int a = parameter.get(0);
+    int b = parameter.get(1);
+    parameter.return(a + b);
+''', 5, 3)
+print(result)  # 8
+```
+
+## Live Object Sharing
+
+Share Python objects with CSSL scripts. Changes in CSSL reflect back to Python:
+
+```python
+from includecpp import CSSL
+
+class Counter:
+    def __init__(self):
+        self.value = 100
+
+counter = Counter()
+cssl = CSSL.CsslLang()
+cssl.share(counter, "cnt")
+
+# Modify in CSSL - changes reflect in Python!
+cssl.exec('''
+    $cnt.value = $cnt.value - 10;
+    printl($cnt.value);  // 90
+''')
+
+print(counter.value)  # 90 - Changed!
+```
+
+### Shared Object Syntax
+
+- `$name` - Access shared object
+- `$name.property` - Access/modify properties
+- `$name.method()` - Call methods
+- `delete("name")` - Remove shared object
+
+## Data Types
+
+```cssl
+// Basic types
+int x = 42;
+float pi = 3.14;
+string name = "CSSL";
+bool active = true;
+
+// Collections
+array<int> arr;
+arr.push(1);
+arr.push(2);
+printl(arr.length());  // 2
+
+vector<string> vec;
+vec.push("A");
+vec.push("B");
+
+stack<int> s;
+s.push(10);
+s.pop();
+```
+
+## Control Flow
+
+```cssl
+// If/elif/else
+if (x > 10) {
+    printl("big");
+} elif (x > 5) {
+    printl("medium");
+} else {
+    printl("small");
+}
+
+// For loops
+for (i in range(0, 10)) {
+    printl(i);
+}
+
+for (i in range(0, 10, 2)) {  // with step
+    printl(i);  // 0, 2, 4, 6, 8
+}
+
+// Foreach
+array<string> items;
+items.push("A");
+items.push("B");
+foreach (item in items) {
+    printl(item);
+}
+
+// While
+int count = 0;
+while (count < 5) {
+    printl(count);
+    count = count + 1;
+}
+```
+
+## Functions
+
+```cssl
+// Basic function
+void greet(string name) {
+    printl("Hello, " + name + "!");
+}
+
+// Return value
+int add(int a, int b) {
+    return a + b;
+}
+
+// Global variables
+global version = "1.0.0";
+printl(@version);
+
+// r@ syntax for global declaration
+r@myGlobal = "value";
+printl(@myGlobal);
+```
+
+## BruteForce Injection System
+
+CSSL's unique injection operators for data manipulation:
+
+```cssl
+// <== Move data (replaces target)
+target <== source;
+
+// +<== Copy & add to target
+target +<== source;
+
+// -<== Move & remove from source
+target -<== source;
+
+// <<== Code infusion into functions
+myFunc() <<== {
+    printl("Injected code!");
+};
+
+// +<<== Add code without replacing
+myFunc() +<<== {
+    printl("Additional code!");
+};
+```
+
+## String Methods
+
+```cssl
+string s = "Hello World";
+
+// Methods
+s.length();           // 11
+s.toUpper();          // "HELLO WORLD"
+s.toLower();          // "hello world"
+s.contains("World");  // true
+s.startsWith("Hello"); // true
+s.endsWith("World");  // true
+s.replace("World", "CSSL");
+s.split(" ");         // ["Hello", "World"]
+s.trim();             // Remove whitespace
+s.substring(0, 5);    // "Hello"
+```
+
+## CSSL Modules
+
+```python
+# Create callable module
+module = CSSL.module('''
+    string name = parameter.get(0);
+    printl("Hello, " + name + "!");
+''')
+module("World")  # Prints: Hello, World!
+
+# Create module with functions
+math_mod = CSSL.makemodule('''
+    int add(int a, int b) {
+        return a + b;
+    }
+
+    int multiply(int a, int b) {
+        return a * b;
+    }
+''')
+print(math_mod.add(2, 3))       # 5
+print(math_mod.multiply(4, 5))  # 20
+```
+
+## Inline Payloads
+
+```python
+cssl = CSSL.CsslLang()
+
+# Register code as payload
+cssl.code("helpers", '''
+    global version = "1.0.0";
+    void log(string msg) {
+        printl("[LOG] " + msg);
+    }
+''')
+
+# Use in CSSL
+cssl.exec('''
+    payload("helpers");
+    @log("Application started");
+    printl(@version);
+''')
+```
 
 # Changelog
 
+## v3.4.20
+- **Documentation:**
+  - Added complete CSSL language documentation
+  - Live object sharing with `$name` syntax
+  - Data types, control flow, functions, injection system
+  - String methods, modules, and inline payloads
+
+## v3.4.19
+- **Critical Bug Fixes:**
+  - Fixed generator raw string literal in parser.cpp (regex pattern with `)"` prematurely terminated)
+  - Fixed shared object property writes inside loops not persisting to Python
+  - Added member_access handling in flow operations for shared objects
+
+## v3.4.18
+- **Bug Fix:**
+  - Attempted fix for shared object loop writes (partially fixed)
+
+## v3.4.17
+- **New Feature: Live Object Sharing**
+  - `cssl.share(instance, name)` - Share Python objects with CSSL
+  - `$name` syntax for accessing shared objects
+  - Live bidirectional updates - changes in CSSL reflect in Python
+  - `delete("name")` builtin for removing shared objects
+  - Shared object metadata stored in `%APPDATA%/IncludeCPP/shared_objects/`
+
+## v3.4.16
+- **CSSL Bug Fixes:**
+  - Fixed `startsWith()` and `endsWith()` parser errors
+
+## v3.4.15
+- **CSSL Enhancements:**
+  - Added `elif` keyword support
+  - Added `range(start, end, step)` with step parameter
+  - Added `begin()` and `end()` methods to all collection types
+  - Added `cssl.code(name, code)` for inline payload registration
+
 ## v3.4.2
 - **New Feature: `exec` Command**
   - Interactive REPL for quick code testing without creating files
@@ -806,4 +1073,4 @@ Use at your own discretion. Report issues at: https://github.com/hatte/IncludeCP
 
 ---
 
-MIT License | v3.4.2 | [GitHub](https://github.com/liliassg/IncludeCPP)
+MIT License | v3.4.20 | [GitHub](https://github.com/liliassg/IncludeCPP)