IncludeCPP 4.6.0__py3-none-any.whl → 4.9.3__py3-none-any.whl

includecpp/core/cssl_bridge.py

@@ -405,7 +405,7 @@ class CsslLang:
             return 'cssl-pl'
         return 'cssl'
 
-    def run(self, path_or_code: str, *args) -> Any:
+    def run(self, path_or_code: str, *args, force_python: bool = False) -> Any:
         """
         Execute CSSL code or file.
 
@@ -415,6 +415,7 @@ class CsslLang:
         Args:
             path_or_code: Path to .cssl file or CSSL code string
             *args: Arguments to pass to the script (accessible via parameter.get())
+            force_python: Force Python interpreter (for full builtin support)
 
         Returns:
             Execution result. If parameter.return() was called, returns
@@ -444,9 +445,63 @@ class CsslLang:
                 # Path too long or invalid - treat as code
                 pass
 
+        # v4.6.5: Check for native/unative keywords
+        import re
+        has_native = bool(re.search(r'\bnative\b', source))
+        has_unative = bool(re.search(r'\bunative\b', source))
+
+        # v4.8.5: Python-only builtins (not available in C++ runtime)
+        # Auto-detect and use Python when these are present
+        PYTHON_ONLY_BUILTINS = {
+            # os/sys replacements
+            'getcwd', 'chdir', 'mkdir', 'rmdir', 'rmfile', 'rename',
+            'argv', 'argc', 'platform', 'version', 'exit',
+            # File operations
+            'listdir', 'makedirs', 'removefile', 'removedir', 'copyfile', 'movefile',
+            'readfile', 'writefile', 'appendfile', 'readlines', 'filesize',
+            'pathexists', 'exists', 'isfile', 'isdir',
+            # Environment
+            'env', 'setenv',
+            # Module imports
+            'pyimport', 'cppimport', 'include', 'libinclude',
+            # Advanced features
+            'initpy', 'initsh', 'appexec', 'createcmd',
+            # Instance reflection
+            'instance_getMethods', 'instance_getClasses', 'instance_getVars',
+            'instance_getAll', 'instance_call', 'instance_has', 'instance_type',
+            # Console/terminal functions
+            'clear', 'input', 'color',
+            'red', 'green', 'blue', 'yellow', 'cyan', 'magenta', 'white', 'black',
+            'bold', 'dim', 'italic', 'underline', 'blink', 'reverse',
+            # v4.9.0: Memory introspection and snapshot (Python reflection)
+            'memory', 'snapshot', 'address', 'reflect',
+        }
+
+        # Check if source uses any Python-only builtins
+        needs_python = any(
+            re.search(rf'\b{builtin}\s*\(', source)
+            for builtin in PYTHON_ONLY_BUILTINS
+        )
+
+        # Also detect module usage that requires Python runtime
+        has_python_modules = bool(re.search(r'\b(fmt|Console|Process|Config|Server)::',  source))
+
+        # v4.9.3: Detect python:: namespace usage (parameter passing, pythonize, etc.)
+        has_python_namespace = bool(re.search(r'\bpython::', source))
+
+        # v4.9.0: Detect bit/byte/address type declarations (Python-only types)
+        has_binary_types = bool(re.search(r'\b(bit|byte|address)\s+\w+', source))
+
+        # unative forces Python execution (skip C++ entirely)
+        # force_python flag also skips C++ (for full builtin support like getcwd, listdir)
+        # Auto-detect Python-only builtins and use Python automatically
+        # v4.9.0: Also skip C++ for bit/byte types (Python-only)
+        # v4.9.3: Also skip C++ for python:: namespace usage
+        if has_unative or force_python or needs_python or has_python_modules or has_binary_types or has_python_namespace:
+            pass  # Skip C++ block, go directly to Python execution
         # Try C++ accelerated execution first (375x faster)
         # Only use C++ for simple scripts without parameter passing
-        if not args:
+        elif not args:
             try:
                 from .cssl import run_cssl, run_cssl_file
                 if is_file and file_path:
@@ -454,10 +509,17 @@ class CsslLang:
                 else:
                     return run_cssl(source)
             except Exception as cpp_error:
+                # native keyword forces C++ - no fallback allowed
+                if has_native:
+                    raise RuntimeError(f"C++ execution failed (native mode): {cpp_error}") from cpp_error
+
                 # Fall back to Python for unsupported features
-                # v4.5.2: Also fall back on "unexpected token" - C++ parser doesn't support all syntax
+                # v4.8.5: Extended fallback triggers for advanced CSSL syntax
                 error_msg = str(cpp_error).lower()
-                fallback_triggers = ['unsupported', 'not implemented', 'unexpected token']
+                fallback_triggers = [
+                    'unsupported', 'not implemented', 'unexpected', 'expected',
+                    'syntax error', 'unknown identifier', 'undefined', 'not defined'
+                ]
                 should_fallback = any(trigger in error_msg for trigger in fallback_triggers)
                 if not should_fallback:
                     # Real error - re-raise it
@@ -467,6 +529,10 @@ class CsslLang:
         # Python execution (for scripts with args or when C++ fails)
         runtime = self._get_runtime()
 
+        # v4.8.5: Strip unative directive before parsing (it's just a marker)
+        if has_unative:
+            source = re.sub(r'\bunative\s*;?\s*', '', source, count=1)
+
         # Set arguments in runtime scope
         from .cssl import Parameter
         param = Parameter(list(args))
@@ -1555,6 +1621,357 @@ def makemodule(
     return get_cssl().makemodule(main_script, payload_script, name, bind)
 
 
+# =============================================================================
+# v4.6.5: CsslWatcher - Live Python Instance Collection for CSSL Access
+# =============================================================================
+
+# Global registry of active watchers
+_active_watchers: Dict[str, 'CsslWatcher'] = {}
+
+
+class CsslWatcher:
+    """
+    Live Python instance watcher that collects all active instances, classes,
+    and functions from the Python scope and makes them available to CSSL.
+
+    Usage in Python:
+        from includecpp.core.cssl_bridge import CsslWatcher
+
+        cwatcher = CsslWatcher(id="MyWatcher")
+        cwatcher.start()
+
+        class Game:
+            def __init__(self):
+                self.score = 0
+            def start(self):
+                print("Game started!")
+
+        game = Game()
+
+        # ... later
+        cwatcher.end()
+
+    Usage in CSSL:
+        # Get all instances from a watcher
+        all_instances = watcher::get("MyWatcher");
+
+        # Access Python class/instance
+        pygameclass = all_instances['Game'];
+        game_instance = all_instances['game'];
+
+        # Call Python methods
+        game_instance.start();
+
+        # Bidirectional: CSSL can overwrite Python functions
+        int start() : overwrites all_instances['Game.start'] {
+            printl("Overwritten by CSSL!");
+            return 0;
+        }
+    """
+
+    def __init__(self, id: str, auto_collect: bool = True, depth: int = 1):
+        """
+        Initialize a new CsslWatcher.
+
+        Args:
+            id: Unique identifier for this watcher (used in watcher::get("id"))
+            auto_collect: If True, automatically collect instances periodically
+            depth: Stack frame depth to look for variables (1 = caller's scope)
+        """
+        self._id = id
+        self._auto_collect = auto_collect
+        self._depth = depth
+        self._running = False
+        self._thread: Optional[threading.Thread] = None
+        self._lock = threading.Lock()
+        self._instances: Dict[str, Any] = {}
+        self._classes: Dict[str, type] = {}
+        self._functions: Dict[str, Callable] = {}
+        self._caller_frame = None
+        self._caller_locals = {}
+        self._caller_globals = {}
+
+    @property
+    def id(self) -> str:
+        """Get the watcher ID."""
+        return self._id
+
+    def start(self) -> 'CsslWatcher':
+        """
+        Start the watcher. Collects instances from the caller's scope
+        and registers this watcher globally.
+
+        Returns:
+            self for chaining
+        """
+        import inspect
+
+        # Get caller's frame
+        frame = inspect.currentframe()
+        try:
+            # Go up the stack to find the caller
+            for _ in range(self._depth + 1):
+                if frame.f_back:
+                    frame = frame.f_back
+
+            self._caller_frame = frame
+            self._caller_locals = frame.f_locals
+            self._caller_globals = frame.f_globals
+        finally:
+            del frame
+
+        # Initial collection
+        self._collect_instances()
+
+        # Register globally
+        with self._lock:
+            _active_watchers[self._id] = self
+            self._running = True
+
+        # Start background thread if auto_collect
+        if self._auto_collect:
+            self._thread = threading.Thread(
+                target=self._background_collect,
+                daemon=True,
+                name=f"CsslWatcher-{self._id}"
+            )
+            self._thread.start()
+
+        return self
+
+    def end(self) -> None:
+        """Stop the watcher and unregister it."""
+        with self._lock:
+            self._running = False
+            if self._id in _active_watchers:
+                del _active_watchers[self._id]
+
+        if self._thread and self._thread.is_alive():
+            self._thread.join(timeout=1.0)
+
+        self._caller_frame = None
+        self._caller_locals = {}
+        self._caller_globals = {}
+
+    def stop(self) -> None:
+        """Alias for end()."""
+        self.end()
+
+    def _collect_instances(self) -> None:
+        """Collect all instances, classes, and functions from the watched scope."""
+        import inspect
+
+        with self._lock:
+            # Combine locals and globals
+            all_vars = {**self._caller_globals, **self._caller_locals}
+
+            for name, obj in all_vars.items():
+                # Skip private/magic names and modules
+                if name.startswith('_'):
+                    continue
+                if inspect.ismodule(obj):
+                    continue
+
+                # Classify the object
+                if inspect.isclass(obj):
+                    self._classes[name] = obj
+                    # Also collect class methods
+                    for method_name, method in inspect.getmembers(obj, predicate=inspect.isfunction):
+                        if not method_name.startswith('_'):
+                            self._functions[f"{name}.{method_name}"] = method
+                elif callable(obj) and not isinstance(obj, type):
+                    self._functions[name] = obj
+                elif hasattr(obj, '__class__') and not isinstance(obj, (int, float, str, bool, list, dict, tuple, set)):
+                    # It's an instance of a custom class
+                    self._instances[name] = obj
+                    # Also collect instance methods
+                    obj_class = obj.__class__
+                    for method_name in dir(obj):
+                        if not method_name.startswith('_'):
+                            try:
+                                method = getattr(obj, method_name)
+                                if callable(method):
+                                    self._functions[f"{name}.{method_name}"] = method
+                            except Exception:
+                                pass
+
+    def _background_collect(self) -> None:
+        """Background thread for periodic collection."""
+        import time
+        while self._running:
+            time.sleep(0.5)  # Collect every 500ms
+            if self._running:
+                try:
+                    self._collect_instances()
+                except Exception:
+                    pass
+
+    def refresh(self) -> None:
+        """Manually refresh the collected instances."""
+        self._collect_instances()
+
+    def get_all(self) -> Dict[str, Any]:
+        """
+        Get all collected items as a dictionary.
+
+        Returns:
+            Dict with all instances, classes, and functions
+        """
+        with self._lock:
+            result = {}
+            result.update(self._classes)
+            result.update(self._instances)
+            result.update(self._functions)
+            return result
+
+    def get(self, path: str) -> Any:
+        """
+        Get a specific item by path.
+
+        Args:
+            path: Name or dotted path like 'Game' or 'game.start'
+
+        Returns:
+            The requested object or None
+        """
+        with self._lock:
+            # Check direct matches first
+            if path in self._classes:
+                return self._classes[path]
+            if path in self._instances:
+                return self._instances[path]
+            if path in self._functions:
+                return self._functions[path]
+
+            # Handle dotted paths
+            if '.' in path:
+                parts = path.split('.', 1)
+                base = parts[0]
+                rest = parts[1]
+
+                # Get the base object
+                obj = self._instances.get(base) or self._classes.get(base)
+                if obj:
+                    try:
+                        # Navigate the path
+                        for part in rest.split('.'):
+                            obj = getattr(obj, part)
+                        return obj
+                    except AttributeError:
+                        pass
+
+            return None
+
+    def set(self, path: str, value: Any) -> bool:
+        """
+        Set/overwrite a value at the given path (bidirectional).
+
+        Args:
+            path: Name or dotted path like 'Game.start'
+            value: New value (function, class, or instance)
+
+        Returns:
+            True if successful
+        """
+        with self._lock:
+            if '.' in path:
+                parts = path.rsplit('.', 1)
+                base_path = parts[0]
+                attr_name = parts[1]
+
+                # Get the base object
+                obj = self.get(base_path)
+                if obj:
+                    try:
+                        setattr(obj, attr_name, value)
+                        # Update our registry
+                        self._functions[path] = value
+                        return True
+                    except Exception:
+                        pass
+            else:
+                # Direct assignment to scope
+                if callable(value) and not isinstance(value, type):
+                    self._functions[path] = value
+                elif isinstance(value, type):
+                    self._classes[path] = value
+                else:
+                    self._instances[path] = value
+
+                # Also update caller's scope
+                if path in self._caller_locals:
+                    self._caller_locals[path] = value
+                elif path in self._caller_globals:
+                    self._caller_globals[path] = value
+
+                return True
+
+        return False
+
+    def __getitem__(self, key: str) -> Any:
+        """Dict-like access: watcher['Game']"""
+        return self.get(key)
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        """Dict-like assignment: watcher['Game.start'] = new_func"""
+        self.set(key, value)
+
+    def __contains__(self, key: str) -> bool:
+        """Check if key exists: 'Game' in watcher"""
+        return self.get(key) is not None
+
+    def __repr__(self) -> str:
+        with self._lock:
+            return (f"CsslWatcher(id='{self._id}', "
+                    f"classes={len(self._classes)}, "
+                    f"instances={len(self._instances)}, "
+                    f"functions={len(self._functions)}, "
+                    f"running={self._running})")
+
+
+def watcher_get(watcher_id: str) -> Optional[Dict[str, Any]]:
+    """
+    Get all instances from a watcher by ID.
+    This is the Python-side implementation for watcher::get("id").
+
+    Args:
+        watcher_id: The watcher's unique ID
+
+    Returns:
+        Dict of all collected instances, classes, and functions
+    """
+    if watcher_id in _active_watchers:
+        return _active_watchers[watcher_id].get_all()
+    return None
+
+
+def watcher_set(watcher_id: str, path: str, value: Any) -> bool:
+    """
+    Set a value in a watcher (bidirectional overwrite).
+
+    Args:
+        watcher_id: The watcher's unique ID
+        path: Path to the item (e.g., 'Game.start')
+        value: New value
+
+    Returns:
+        True if successful
+    """
+    if watcher_id in _active_watchers:
+        return _active_watchers[watcher_id].set(path, value)
+    return False
+
+
+def get_watcher(watcher_id: str) -> Optional[CsslWatcher]:
+    """Get a watcher instance by ID."""
+    return _active_watchers.get(watcher_id)
+
+
+def list_watchers() -> List[str]:
+    """List all active watcher IDs."""
+    return list(_active_watchers.keys())
+
+
 # Export all
 __all__ = [
     'CsslLang',
@@ -1589,4 +2006,10 @@ __all__ = [
     'shared',
     'get_shared',
     'cleanup_shared',
+    # v4.6.5: CsslWatcher for live Python instance access
+    'CsslWatcher',
+    'watcher_get',
+    'watcher_set',
+    'get_watcher',
+    'list_watchers',
 ]

includecpp/core/error_catalog.py

@@ -10,6 +10,28 @@ from typing import Optional, Dict, Tuple
 # Error catalog: pattern -> (message, category)
 # Categories: beginner, compiler, linker, cmake, pybind11, runtime, plugin, import
 ERROR_CATALOG = {
+    # ========== PRIORITY: FILE LOCK ERRORS (checked FIRST) ==========
+    # These must be at the top to catch file-locked errors before other patterns match
+    "FILE_LOCKED_WIN32": {
+        "pattern": r"WinError 32|being used by another process|cannot access.*because.*used|process cannot access|PermissionError.*api\.pyd|Permission denied.*\.pyd",
+        "message": "Module file is locked by another process!\n\nThis usually means:\n  - A compiled .exe using this module is still running\n  - Another Python script has imported this module\n  - Your IDE has the file open\n\nFix:\n  1. Close any running .exe that uses this module\n  2. Close Python REPL/scripts using this module\n  3. Restart your IDE if it imported the module\n  4. Then run 'includecpp rebuild' again",
+        "category": "import"
+    },
+    "FILE_LOCKED_COPY": {
+        "pattern": r"copy.*failed.*permission|cannot (copy|overwrite|write).*\.pyd|failed.*copy.*bindings",
+        "message": "Cannot overwrite module file - it's locked!\n\nThe compiled .pyd/.so file is in use by another process.\n\nFix:\n  1. Close any running .exe that uses this module\n  2. Close all Python processes that imported this module\n  3. Run 'includecpp rebuild' again",
+        "category": "import"
+    },
+    "FILE_LOCKED_LINKER": {
+        "pattern": r"cannot open output file.*\.pyd|cannot open.*api\.pyd|ld\.exe:.*cannot open|ld\.exe:.*Permission denied|ld:.*cannot open output|error: unable to open output file|collect2.*ld.*Permission denied|LINK :.*cannot open.*\.pyd",
+        "message": "Linker cannot write output file - it's locked!\n\nThe .pyd/.so file is being used by another process.\n\nFix:\n  1. Close any running .exe using this module\n  2. Close Python/IDE that imported this module\n  3. Run 'includecpp rebuild --clean'",
+        "category": "linker"
+    },
+    "PERMISSION_DENIED_PYD": {
+        "pattern": r"Permission denied.*\.pyd|Permission denied.*\.so|PermissionError.*bindings",
+        "message": "Permission denied writing module file!\n\nThe .pyd/.so file is locked (probably by a running process).\n\nFix: Close any .exe or Python script using this module, then rebuild.",
+        "category": "import"
+    },
     # ========== A. BEGINNER MISTAKES (1-20) ==========
     "MODULE_NOT_BUILT": {
         "pattern": r"Module '(\w+)'.*not found|No module named '(\w+)'",
@@ -208,11 +230,8 @@ ERROR_CATALOG = {
         "message": "Array index possibly out of bounds.\n\nFix: Check array indices",
         "category": "compiler"
     },
-    "SIGNED_UNSIGNED": {
-        "pattern": r"signed.*unsigned|comparison.*signed",
-        "message": "Comparing signed and unsigned.\n\nFix: Cast one to match the other",
-        "category": "compiler"
-    },
+    # SIGNED_UNSIGNED removed in v4.6.6 - this is a warning, not an error
+    # pybind11 generates code that triggers this warning, we suppress it with -Wno-sign-compare
     "REDEFINITION": {
         "pattern": r"redefinition of ['\"`]([^'\"`]+)['\"`]",
         "message": "'{name}' defined twice.\n\nFix: Remove duplicate or use different names",
@@ -276,12 +295,12 @@ ERROR_CATALOG = {
         "category": "linker"
     },
     "MISSING_LIBSTDCPP": {
-        "pattern": r"libstdc\+\+|cannot find.*stdc\+\+",
+        "pattern": r"cannot find -lstdc\+\+|ld:.*cannot find.*libstdc\+\+|error:.*libstdc\+\+\.so.*not found|/usr/lib.*libstdc\+\+.*not found",
         "message": "C++ runtime missing.\n\nFix: Install gcc-libs/libstdc++ package",
         "category": "linker"
     },
     "MISSING_LIBPYTHON": {
-        "pattern": r"libpython|cannot find.*python",
+        "pattern": r"cannot find -lpython|cannot find.*libpython|error:.*libpython.*not found|ld:.*-lpython.*not found",
         "message": "Python dev libs missing.\n\nFix: Install python3-dev/python3-devel",
         "category": "linker"
     },
@@ -655,14 +674,39 @@ ERROR_CATALOG = {
         "message": "Module not in Python path.\n\nFix: Check PYTHONPATH or install location",
         "category": "import"
     },
+    "FILE_LOCKED_WINDOWS": {
+        "pattern": r"WinError 32|being used by another process|cannot access.*because.*used|process cannot access",
+        "message": "File is locked by another process!\n\nThis usually means:\n  - A compiled .exe is still running\n  - Another Python script is using this module\n  - An IDE has the file open\n\nFix: Close any running .exe or Python process that uses this module,\n     then run 'includecpp rebuild' again.",
+        "category": "import"
+    },
+    "FILE_LOCKED_LINUX": {
+        "pattern": r"ETXTBSY|EBUSY|Text file busy|Device or resource busy|\[Errno 16\]|\[Errno 26\]",
+        "message": "File is busy (in use by another process)!\n\nThis usually means:\n  - A running process is using this shared library\n  - Another Python script has imported this module\n\nFix: Close any process using this module, then run 'includecpp rebuild' again.",
+        "category": "import"
+    },
+    "MODULE_FILE_LOCKED": {
+        "pattern": r"(api\.pyd|\.pyd|\.so|\.dll).*(?:Permission|WinError|denied|locked|in use|busy)",
+        "message": "Module file (.pyd/.so/.dll) is locked!\n\nThe compiled module cannot be overwritten because it's in use.\n\nFix:\n  1. Close any running executable that uses this module\n  2. Close Python scripts/REPL using this module\n  3. Restart your IDE if it imported the module\n  4. Then run 'includecpp rebuild'",
+        "category": "import"
+    },
+    "PERMISSION_ERROR_WINDOWS": {
+        "pattern": r"WinError 5|WinError 13|Access is denied",
+        "message": "Permission denied (Windows).\n\nPossible causes:\n  - File is locked by another process (close running .exe)\n  - Antivirus blocking write access\n  - Need administrator rights\n\nFix: Close any process using this file, or run as administrator.",
+        "category": "import"
+    },
+    "PERMISSION_ERROR_LINUX": {
+        "pattern": r"\[Errno 13\]|EACCES|Operation not permitted|\[Errno 1\]",
+        "message": "Permission denied (Linux/Mac).\n\nPossible causes:\n  - File is locked by another process\n  - Insufficient permissions\n  - File owned by different user\n\nFix: Close any process using this file, check ownership, or use sudo.",
+        "category": "import"
+    },
     "PERMISSION_ERROR": {
         "pattern": r"permission denied|PermissionError|access.*denied",
-        "message": "Permission denied.\n\nFix: Check file permissions or run as admin",
+        "message": "Permission denied.\n\nFix: Check file permissions or close processes using the file",
         "category": "import"
     },
     "FILE_LOCKED": {
-        "pattern": r"file.*locked|file.*in use|being used.*another",
-        "message": "File in use by another process.\n\nFix: Close other Python processes",
+        "pattern": r"file.*locked|file.*in use|being used.*another|file is busy",
+        "message": "File in use by another process.\n\nFix: Close Python processes or executables using this module",
         "category": "import"
     },
     "REGISTRY_MISSING": {