IncludeCPP 3.4.10__py3-none-any.whl → 3.5.0__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.
@@ -175,7 +289,12 @@ class CsslLang:
 
             return result
         except Exception as e:
-            raise RuntimeError(f"CSSL Error: {e}") from e
+            # Format error message nicely
+            error_msg = str(e)
+            # Don't double-wrap error messages
+            if error_msg.startswith("CSSL Error:"):
+                raise RuntimeError(error_msg) from e
+            raise RuntimeError(f"CSSL Error:\n{error_msg}") from e
 
     def T_exec(self, path_or_code: str, *args, callback: Optional[Callable[[Any], None]] = None) -> threading.Thread:
         """
@@ -276,6 +395,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/vscode/__init__.py

@@ -0,0 +1 @@
+# VSCode extension resources for CSSL

includecpp/vscode/cssl/__init__.py

@@ -0,0 +1 @@
+# CSSL VSCode extension files

includecpp/vscode/cssl/language-configuration.json

@@ -0,0 +1,38 @@
+{
+    "comments": {
+        "lineComment": "//",
+        "blockComment": ["/*", "*/"]
+    },
+    "brackets": [
+        ["{", "}"],
+        ["[", "]"],
+        ["(", ")"],
+        ["<", ">"]
+    ],
+    "autoClosingPairs": [
+        { "open": "{", "close": "}" },
+        { "open": "[", "close": "]" },
+        { "open": "(", "close": ")" },
+        { "open": "<", "close": ">" },
+        { "open": "\"", "close": "\"", "notIn": ["string"] },
+        { "open": "'", "close": "'", "notIn": ["string", "comment"] }
+    ],
+    "surroundingPairs": [
+        ["{", "}"],
+        ["[", "]"],
+        ["(", ")"],
+        ["<", ">"],
+        ["\"", "\""],
+        ["'", "'"]
+    ],
+    "folding": {
+        "markers": {
+            "start": "^\\s*//\\s*#?region\\b",
+            "end": "^\\s*//\\s*#?endregion\\b"
+        }
+    },
+    "indentationRules": {
+        "increaseIndentPattern": "^.*\\{[^}]*$",
+        "decreaseIndentPattern": "^\\s*\\}"
+    }
+}

includecpp/vscode/cssl/package.json

@@ -0,0 +1,30 @@
+{
+    "name": "cssl",
+    "displayName": "CSSL - CSO Service Script Language",
+    "description": "Syntax highlighting and language support for CSSL scripts",
+    "version": "1.0.0",
+    "publisher": "IncludeCPP",
+    "engines": {
+        "vscode": "^1.60.0"
+    },
+    "categories": [
+        "Programming Languages"
+    ],
+    "contributes": {
+        "languages": [
+            {
+                "id": "cssl",
+                "aliases": ["CSSL", "cssl", "CSO Service Script"],
+                "extensions": [".cssl", ".cssl-pl", ".cssl-mod"],
+                "configuration": "./language-configuration.json"
+            }
+        ],
+        "grammars": [
+            {
+                "language": "cssl",
+                "scopeName": "source.cssl",
+                "path": "./syntaxes/cssl.tmLanguage.json"
+            }
+        ]
+    }
+}