IncludeCPP 3.7.9__py3-none-any.whl → 3.7.25__py3-none-any.whl

includecpp/core/cssl/cssl_types.py

@@ -1,5 +1,5 @@
 """
-CSSL Data Types - Advanced container types for CSO Service Script Language
+CSSL Data Types - Advanced container types for CSSL
 
 Types:
 - datastruct<T>: Universal container (lazy declarator) - can hold any type
@@ -64,6 +64,33 @@ class DataStruct(list):
             return target_type(self[0])
         return None
 
+    def length(self) -> int:
+        """Return datastruct length"""
+        return len(self)
+
+    def size(self) -> int:
+        """Return datastruct size (alias for length)"""
+        return len(self)
+
+    def push(self, item: Any) -> 'DataStruct':
+        """Push item to datastruct (alias for add)"""
+        self.append(item)
+        return self
+
+    def isEmpty(self) -> bool:
+        """Check if datastruct is empty"""
+        return len(self) == 0
+
+    def contains(self, item: Any) -> bool:
+        """Check if datastruct contains item"""
+        return item in self
+
+    def at(self, index: int) -> Any:
+        """Get item at index (safe access)"""
+        if 0 <= index < len(self):
+            return self[index]
+        return None
+
     def begin(self) -> int:
         """Return iterator to beginning (C++ style)"""
         return 0
@@ -99,6 +126,16 @@ class Stack(list):
         self.append(item)
         return self
 
+    def pop(self) -> Any:
+        """Pop and return top element from stack"""
+        if len(self) == 0:
+            return None
+        return super().pop()
+
+    def pop_back(self) -> Any:
+        """Pop and return top element (alias for pop)"""
+        return self.pop()
+
     def peek(self) -> Any:
         """View top item without removing"""
         return self[-1] if self else None
@@ -701,6 +738,39 @@ class List(list):
             self.extend([value] * count)
         return self
 
+    def map(self, func: Callable[[Any], Any]) -> 'List':
+        """Apply function to all elements"""
+        result = List(self._element_type)
+        result.extend(func(item) for item in self)
+        return result
+
+    def filter(self, predicate: Callable[[Any], bool]) -> 'List':
+        """Filter elements by predicate"""
+        result = List(self._element_type)
+        result.extend(item for item in self if predicate(item))
+        return result
+
+    def forEach(self, func: Callable[[Any], None]) -> 'List':
+        """Execute function for each element"""
+        for item in self:
+            func(item)
+        return self
+
+    def reduce(self, func: Callable[[Any, Any], Any], initial: Any = None) -> Any:
+        """Reduce list to single value"""
+        from functools import reduce as py_reduce
+        if initial is None:
+            return py_reduce(func, self)
+        return py_reduce(func, self, initial)
+
+    def every(self, predicate: Callable[[Any], bool]) -> bool:
+        """Check if all elements match predicate"""
+        return all(predicate(item) for item in self)
+
+    def some(self, predicate: Callable[[Any], bool]) -> bool:
+        """Check if any element matches predicate"""
+        return any(predicate(item) for item in self)
+
     def begin(self) -> int:
         """Return iterator to beginning"""
         return 0
@@ -1499,7 +1569,10 @@ class CSSLInstance:
                 object.__setattr__(self, name, value)
 
     def __repr__(self):
-        return f"<CSSLInstance of '{self._class.name}'>"
+        return f"<{self._class.name} instance at 0x{id(self):x}>"
+
+    def __str__(self):
+        return f"<{self._class.name} instance at 0x{id(self):x}>"
 
 
 __all__ = [

includecpp/core/cssl_bridge.py

@@ -11,6 +11,7 @@ v3.8.0 API:
     cssl.include(path, name)       - Register for payload(name)
 """
 
+import atexit
 import os
 import pickle
 import random
@@ -33,6 +34,23 @@ def _get_share_directory() -> Path:
     return share_dir
 
 
+def _cleanup_shared_objects() -> None:
+    """Clean up all shared object marker files on process exit."""
+    try:
+        share_dir = _get_share_directory()
+        if share_dir.exists():
+            for f in share_dir.glob('*.shareobj*'):
+                try:
+                    f.unlink()
+                except Exception:
+                    pass
+    except Exception:
+        pass
+
+# Register cleanup on process exit
+atexit.register(_cleanup_shared_objects)
+
+
 # Global live object registry - holds actual object references for live sharing
 _live_objects: Dict[str, Any] = {}
 
@@ -404,12 +422,19 @@ class CsslLang:
         """
         runtime = self._get_runtime()
 
-        # Check if it's a file path
-        path = Path(path_or_code)
-        if path.exists() and path.suffix in ('.cssl', '.cssl-mod', '.cssl-pl'):
-            source = path.read_text(encoding='utf-8')
-        else:
-            source = path_or_code
+        # Check if it's a file path (not code)
+        # Code detection: contains newlines, semicolons, or braces = definitely code
+        is_likely_code = '\n' in path_or_code or ';' in path_or_code or '{' in path_or_code
+        source = path_or_code
+
+        if not is_likely_code:
+            try:
+                path = Path(path_or_code)
+                if path.exists() and path.suffix in ('.cssl', '.cssl-mod', '.cssl-pl'):
+                    source = path.read_text(encoding='utf-8')
+            except OSError:
+                # Path too long or invalid - treat as code
+                pass
 
         # Set arguments in runtime scope
         from .cssl import Parameter
@@ -1064,6 +1089,38 @@ def shared(name: str) -> Optional[Any]:
     return get_shared(name)
 
 
+def cleanup_shared() -> int:
+    """
+    Manually clean up all shared object marker files.
+
+    Call this to remove stale .shareobj files from %APPDATA%/IncludeCPP/shared_objects/
+    that may have accumulated from previous sessions.
+
+    Returns:
+        Number of files deleted
+    """
+    global _live_objects, _global_shared_objects
+
+    count = 0
+    try:
+        share_dir = _get_share_directory()
+        if share_dir.exists():
+            for f in share_dir.glob('*.shareobj*'):
+                try:
+                    f.unlink()
+                    count += 1
+                except Exception:
+                    pass
+    except Exception:
+        pass
+
+    # Clear in-memory registries
+    _live_objects.clear()
+    _global_shared_objects.clear()
+
+    return count
+
+
 # Singleton for convenience
 _default_instance: Optional[CsslLang] = None
 
@@ -1308,4 +1365,5 @@ __all__ = [
     'unshare',
     'shared',
     'get_shared',
+    'cleanup_shared',
 ]

includecpp/vscode/cssl/extension.js

@@ -0,0 +1,133 @@
+// CSSL Language Extension for VS Code
+// Provides run functionality for .cssl files
+
+const vscode = require('vscode');
+const path = require('path');
+const { spawn } = require('child_process');
+
+let outputChannel;
+
+function activate(context) {
+    // Create output channel for CSSL
+    outputChannel = vscode.window.createOutputChannel('CSSL');
+
+    // Register the run command
+    const runCommand = vscode.commands.registerCommand('cssl.runFile', async () => {
+        const editor = vscode.window.activeTextEditor;
+
+        if (!editor) {
+            vscode.window.showErrorMessage('No active editor found');
+            return;
+        }
+
+        const document = editor.document;
+        const filePath = document.fileName;
+        const ext = path.extname(filePath).toLowerCase();
+
+        // Only allow .cssl files (not .cssl-mod or .cssl-pl)
+        if (ext !== '.cssl') {
+            vscode.window.showWarningMessage('Only .cssl files can be executed. Modules (.cssl-mod) and Payloads (.cssl-pl) cannot be run directly.');
+            return;
+        }
+
+        // Save the file before running
+        if (document.isDirty) {
+            await document.save();
+        }
+
+        // Get configuration
+        const config = vscode.workspace.getConfiguration('cssl');
+        const pythonPath = config.get('pythonPath', 'python');
+        const showOutput = config.get('showOutput', true);
+
+        // Show output channel
+        if (showOutput) {
+            outputChannel.show(true);
+        }
+
+        outputChannel.clear();
+        outputChannel.appendLine(`[CSSL] Running: ${path.basename(filePath)}`);
+        outputChannel.appendLine(`[CSSL] Path: ${filePath}`);
+        outputChannel.appendLine('─'.repeat(50));
+
+        // Run the CSSL file using includecpp cssl run
+        const args = ['-m', 'includecpp', 'cssl', 'run', filePath];
+
+        const process = spawn(pythonPath, args, {
+            cwd: path.dirname(filePath),
+            env: { ...process.env }
+        });
+
+        let hasError = false;
+
+        process.stdout.on('data', (data) => {
+            outputChannel.append(data.toString());
+        });
+
+        process.stderr.on('data', (data) => {
+            hasError = true;
+            outputChannel.append(data.toString());
+        });
+
+        process.on('close', (code) => {
+            outputChannel.appendLine('');
+            outputChannel.appendLine('─'.repeat(50));
+            if (code === 0) {
+                outputChannel.appendLine(`[CSSL] Finished successfully`);
+            } else {
+                outputChannel.appendLine(`[CSSL] Exited with code: ${code}`);
+            }
+        });
+
+        process.on('error', (err) => {
+            outputChannel.appendLine(`[CSSL] Error: ${err.message}`);
+            vscode.window.showErrorMessage(`Failed to run CSSL: ${err.message}. Make sure IncludeCPP is installed (pip install includecpp).`);
+        });
+    });
+
+    context.subscriptions.push(runCommand);
+    context.subscriptions.push(outputChannel);
+
+    // Register task provider for CSSL
+    const taskProvider = vscode.tasks.registerTaskProvider('cssl', {
+        provideTasks: () => {
+            return [];
+        },
+        resolveTask: (task) => {
+            if (task.definition.type === 'cssl') {
+                const config = vscode.workspace.getConfiguration('cssl');
+                const pythonPath = config.get('pythonPath', 'python');
+                const file = task.definition.file;
+
+                const execution = new vscode.ShellExecution(
+                    `${pythonPath} -m includecpp cssl run "${file}"`
+                );
+
+                return new vscode.Task(
+                    task.definition,
+                    vscode.TaskScope.Workspace,
+                    'Run CSSL',
+                    'cssl',
+                    execution,
+                    []
+                );
+            }
+            return undefined;
+        }
+    });
+
+    context.subscriptions.push(taskProvider);
+
+    console.log('CSSL extension activated');
+}
+
+function deactivate() {
+    if (outputChannel) {
+        outputChannel.dispose();
+    }
+}
+
+module.exports = {
+    activate,
+    deactivate
+};

includecpp/vscode/cssl/package.json

@@ -1,35 +1,60 @@
 {
     "name": "cssl",
-    "displayName": "CSSL - CSO Service Script Language",
+    "displayName": "CSSL Language",
     "description": "Professional syntax highlighting, snippets, and language support for CSSL scripts (.cssl, .cssl-pl, .cssl-mod)",
-    "version": "1.1.0",
+    "version": "1.3.0",
     "publisher": "IncludeCPP",
-    "icon": "images/cssl-icon.png",
+    "icon": "images/cssl.png",
     "engines": {
         "vscode": "^1.60.0"
     },
     "categories": [
         "Programming Languages",
-        "Snippets"
+        "Snippets",
+        "Debuggers"
     ],
     "keywords": [
         "cssl",
-        "cso",
         "script",
         "includecpp",
         "c++",
-        "python"
+        "python",
+        "run"
     ],
+    "activationEvents": [
+        "onLanguage:cssl"
+    ],
+    "main": "./extension.js",
     "contributes": {
         "languages": [
             {
                 "id": "cssl",
-                "aliases": ["CSSL", "cssl", "CSO Service Script"],
-                "extensions": [".cssl", ".cssl-pl", ".cssl-mod"],
+                "aliases": ["CSSL", "cssl"],
+                "extensions": [".cssl"],
+                "configuration": "./language-configuration.json",
+                "icon": {
+                    "light": "./images/cssl.png",
+                    "dark": "./images/cssl.png"
+                }
+            },
+            {
+                "id": "cssl-mod",
+                "aliases": ["CSSL Module", "cssl-mod"],
+                "extensions": [".cssl-mod"],
+                "configuration": "./language-configuration.json",
+                "icon": {
+                    "light": "./images/cssl_pl.png",
+                    "dark": "./images/cssl_pl.png"
+                }
+            },
+            {
+                "id": "cssl-pl",
+                "aliases": ["CSSL Payload", "cssl-pl"],
+                "extensions": [".cssl-pl"],
                 "configuration": "./language-configuration.json",
                 "icon": {
-                    "light": "./images/cssl-icon.png",
-                    "dark": "./images/cssl-icon.png"
+                    "light": "./images/cssl_pl.png",
+                    "dark": "./images/cssl_pl.png"
                 }
             }
         ],
@@ -38,13 +63,94 @@
                 "language": "cssl",
                 "scopeName": "source.cssl",
                 "path": "./syntaxes/cssl.tmLanguage.json"
+            },
+            {
+                "language": "cssl-mod",
+                "scopeName": "source.cssl",
+                "path": "./syntaxes/cssl.tmLanguage.json"
+            },
+            {
+                "language": "cssl-pl",
+                "scopeName": "source.cssl",
+                "path": "./syntaxes/cssl.tmLanguage.json"
             }
         ],
         "snippets": [
             {
                 "language": "cssl",
                 "path": "./snippets/cssl.snippets.json"
+            },
+            {
+                "language": "cssl-mod",
+                "path": "./snippets/cssl.snippets.json"
+            },
+            {
+                "language": "cssl-pl",
+                "path": "./snippets/cssl.snippets.json"
+            }
+        ],
+        "commands": [
+            {
+                "command": "cssl.runFile",
+                "title": "Run CSSL File",
+                "icon": "$(play)",
+                "enablement": "resourceExtname == .cssl"
+            }
+        ],
+        "menus": {
+            "editor/title/run": [
+                {
+                    "command": "cssl.runFile",
+                    "when": "resourceExtname == .cssl",
+                    "group": "navigation"
+                }
+            ],
+            "editor/context": [
+                {
+                    "command": "cssl.runFile",
+                    "when": "resourceExtname == .cssl",
+                    "group": "1_run"
+                }
+            ]
+        },
+        "keybindings": [
+            {
+                "command": "cssl.runFile",
+                "key": "f5",
+                "when": "resourceExtname == .cssl && !inDebugMode"
+            },
+            {
+                "command": "cssl.runFile",
+                "key": "ctrl+f5",
+                "when": "resourceExtname == .cssl"
+            }
+        ],
+        "taskDefinitions": [
+            {
+                "type": "cssl",
+                "required": ["file"],
+                "properties": {
+                    "file": {
+                        "type": "string",
+                        "description": "The CSSL file to run"
+                    }
+                }
+            }
+        ],
+        "configuration": {
+            "title": "CSSL",
+            "properties": {
+                "cssl.pythonPath": {
+                    "type": "string",
+                    "default": "python",
+                    "description": "Path to Python executable"
+                },
+                "cssl.showOutput": {
+                    "type": "boolean",
+                    "default": true,
+                    "description": "Show output panel when running CSSL files"
+                }
             }
-        ]
+        }
     }
 }

includecpp/vscode/cssl/syntaxes/cssl.tmLanguage.json

@@ -27,17 +27,20 @@
         { "include": "#function-calls" },
         { "include": "#builtins" },
         { "include": "#operators" },
-        { "include": "#constants" }
+        { "include": "#constants" },
+        { "include": "#variables" }
     ],
     "repository": {
         "super-functions": {
             "patterns": [
                 {
-                    "name": "markup.bold.super.builtin.cssl",
+                    "comment": "#$run, #$exec, #$printl - yellow/gold color",
+                    "name": "entity.name.tag.super.cssl",
                     "match": "#\\$(run|exec|printl|init)\\b"
                 },
                 {
-                    "name": "markup.bold.super.call.cssl",
+                    "comment": "#$anyFunction - yellow/gold color",
+                    "name": "entity.name.tag.super.cssl",
                     "match": "#\\$[a-zA-Z_][a-zA-Z0-9_]*"
                 }
             ]
@@ -122,6 +125,9 @@
                         { "include": "#class-member-declaration" },
                         { "include": "#types" },
                         { "include": "#this-access" },
+                        { "include": "#captured-references" },
+                        { "include": "#global-references" },
+                        { "include": "#shared-references" },
                         { "include": "#strings" },
                         { "include": "#numbers" },
                         { "include": "#keywords" },
@@ -267,23 +273,23 @@
         "injection-operators": {
             "patterns": [
                 {
-                    "comment": "Infuse operators <<== (REPLACE) - orange/gold color",
-                    "name": "markup.inserted.infuse.cssl",
+                    "comment": "Infuse operators <<== (REPLACE) - orange color",
+                    "name": "constant.character.escape.infuse.cssl",
                     "match": "(\\+<<==|<<==|-<<==)"
                 },
                 {
-                    "comment": "Infuse out operators ==>> - orange/gold color",
-                    "name": "markup.inserted.infuse.out.cssl",
+                    "comment": "Infuse out operators ==>> - orange color",
+                    "name": "constant.character.escape.infuse.out.cssl",
                     "match": "(==>>\\+|==>>|-==>>)"
                 },
                 {
                     "comment": "Brute injection <== (ADD) - cyan/blue color",
-                    "name": "support.constant.brute.cssl",
+                    "name": "support.function.brute.cssl",
                     "match": "(\\+<==|<==|-<==)"
                 },
                 {
                     "comment": "Brute injection out ==> - cyan/blue color",
-                    "name": "support.constant.brute.out.cssl",
+                    "name": "support.function.brute.out.cssl",
                     "match": "(==>\\+|==>|-==>)"
                 },
                 {
@@ -351,23 +357,30 @@
         "captured-references": {
             "patterns": [
                 {
-                    "name": "variable.other.captured.cssl",
-                    "match": "%[a-zA-Z_][a-zA-Z0-9_]*"
+                    "comment": "%identifier - % is light blue/cyan, identifier is pink",
+                    "match": "(%)([a-zA-Z_][a-zA-Z0-9_]*)",
+                    "captures": {
+                        "1": { "name": "support.type.cssl" },
+                        "2": { "name": "entity.other.inherited-class.cssl" }
+                    }
                 }
             ]
         },
         "global-references": {
             "patterns": [
                 {
-                    "name": "variable.other.global.cssl",
+                    "comment": "@identifier - magenta color (full)",
+                    "name": "constant.other.symbol.cssl",
                     "match": "@[a-zA-Z_][a-zA-Z0-9_]*"
                 },
                 {
-                    "name": "variable.other.global-decl.cssl",
+                    "comment": "r@identifier - magenta color",
+                    "name": "constant.other.symbol.cssl",
                     "match": "r@[a-zA-Z_][a-zA-Z0-9_]*"
                 },
                 {
-                    "name": "variable.other.self-ref.cssl",
+                    "comment": "s@identifier - magenta color",
+                    "name": "constant.other.symbol.cssl",
                     "match": "s@[a-zA-Z_][a-zA-Z0-9_]*"
                 }
             ]
@@ -375,11 +388,21 @@
         "shared-references": {
             "patterns": [
                 {
-                    "name": "variable.other.shared.cssl",
+                    "comment": "$identifier - same color as 'new' keyword (full)",
+                    "name": "keyword.operator.new.cssl",
                     "match": "\\$[a-zA-Z_][a-zA-Z0-9_]*"
                 }
             ]
         },
+        "variables": {
+            "patterns": [
+                {
+                    "comment": "Regular variables - pink/salmon color",
+                    "name": "entity.other.inherited-class.cssl",
+                    "match": "\\b[a-z_][a-zA-Z0-9_]*\\b"
+                }
+            ]
+        },
         "instance-references": {
             "patterns": [
                 {

{includecpp-3.7.9.dist-info → includecpp-3.7.25.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: IncludeCPP
-Version: 3.7.9
+Version: 3.7.25
 Summary: Professional C++ Python bindings with type-generic templates, pystubs and native threading
 Home-page: https://github.com/liliassg/IncludeCPP
 Author: Lilias Hatterscheidt
@@ -623,7 +623,7 @@ Then check **"Enable Experimental Features"** and save.
 
 Use at your own discretion. Report issues at: https://github.com/liliassg/IncludeCPP/issues
 
-# CSSL - CSO Service Script Language
+# CSSL - C-Style Scripting Language
 
 IncludeCPP includes CSSL, a scripting language with advanced data manipulation features.