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

includecpp/core/cssl/cssl_syntax.py

@@ -1,7 +1,7 @@
 """
 CSSL Syntax Highlighting
 
-Provides syntax highlighting for CSSL (CSO Service Script Language) code.
+Provides syntax highlighting for CSSL code.
 Can be used with:
 - PyQt5/6 QSyntaxHighlighter
 - VSCode/TextMate grammar export
@@ -216,8 +216,8 @@ class CSSLSyntaxRules:
 class ColorScheme:
     """Color scheme for syntax highlighting"""
 
-    # CSO Theme (Orange accent, dark background)
-    CSO_THEME = {
+    # CSSL Theme (Orange accent, dark background)
+    CSSL_THEME = {
         TokenCategory.KEYWORD: '#508cff',      # Blue
         TokenCategory.BUILTIN: '#ff8c00',      # Orange
         TokenCategory.OPERATOR: '#c8c8d2',     # Light gray
@@ -261,13 +261,13 @@ def highlight_cssl(source: str, scheme: Dict[TokenCategory, str] = None) -> List
 
     Args:
         source: CSSL source code
-        scheme: Color scheme dict (defaults to CSO_THEME)
+        scheme: Color scheme dict (defaults to CSSL_THEME)
 
     Returns:
         List of (start, end, color, category) tuples
     """
     if scheme is None:
-        scheme = ColorScheme.CSO_THEME
+        scheme = ColorScheme.CSSL_THEME
 
     highlights = []
     rules = CSSLSyntaxRules.get_rules()
@@ -337,7 +337,7 @@ def highlight_cssl_ansi(source: str) -> str:
     }
     RESET = '\033[0m'
 
-    highlights = highlight_cssl(source, ColorScheme.CSO_THEME)
+    highlights = highlight_cssl(source, ColorScheme.CSSL_THEME)
 
     # Build highlighted string
     result = []
@@ -388,7 +388,7 @@ def get_pyqt_highlighter():
 
         def _setup_rules(self):
             """Setup highlighting rules"""
-            scheme = ColorScheme.CSO_THEME
+            scheme = ColorScheme.CSSL_THEME
 
             for rule in CSSLSyntaxRules.get_rules():
                 fmt = QTextCharFormat()

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 childProcess = spawn(pythonPath, args, {
+            cwd: path.dirname(filePath),
+            env: { ...process.env }
+        });
+
+        let hasError = false;
+
+        childProcess.stdout.on('data', (data) => {
+            outputChannel.append(data.toString());
+        });
+
+        childProcess.stderr.on('data', (data) => {
+            hasError = true;
+            outputChannel.append(data.toString());
+        });
+
+        childProcess.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}`);
+            }
+        });
+
+        childProcess.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.1",
     "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"
+                }
             }
-        ]
+        }
     }
 }