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

includecpp/__init__.py

@@ -2,7 +2,7 @@ from .core.cpp_api import CppApi
 from .core import cssl_bridge as CSSL
 import warnings
 
-__version__ = "3.4.21"
+__version__ = "3.5.0"
 __all__ = ["CppApi", "CSSL"]
 
 # Module-level cache for C++ modules

includecpp/cli/commands.py

@@ -7139,20 +7139,21 @@ def cppy_types():
 # EXEC - Interactive Code Execution
 # ============================================================================
 
-@cli.command()
-@click.argument('lang', type=click.Choice(['py', 'cpp', 'python', 'c++']))
+@cli.command(name='exec')
+@click.argument('lang', type=click.Choice(['py', 'cpp', 'python', 'c++', 'cssl']))
 @click.argument('path', required=False, type=click.Path())
 @click.option('--all', 'import_all', is_flag=True, help='Import all available modules')
-def exec(lang, path, import_all):
+def exec_repl(lang, path, import_all):
     """Execute code interactively for quick testing.
 
-    Run Python or C++ code snippets without creating files.
+    Run Python, C++ or CSSL code snippets without creating files.
     Perfect for testing your IncludeCPP modules quickly.
 
     \b
     Usage:
       includecpp exec py              # Interactive Python
       includecpp exec cpp             # Interactive C++
+      includecpp exec cssl            # Interactive CSSL
       includecpp exec py mymodule     # Auto-import mymodule
       includecpp exec py plugins/x.cp # Auto-import from plugin
       includecpp exec py --all        # Import all modules
@@ -7178,7 +7179,8 @@ def exec(lang, path, import_all):
 
     # Normalize language
     is_python = lang in ('py', 'python')
-    lang_name = 'Python' if is_python else 'C++'
+    is_cssl = lang == 'cssl'
+    lang_name = 'Python' if is_python else ('CSSL' if is_cssl else 'C++')
 
     # Build imports/includes
     imports = []
@@ -7286,6 +7288,7 @@ def exec(lang, path, import_all):
 
     if is_python:
         # Execute Python code
+        import builtins
         full_code = '\n'.join(code_lines)
         try:
             # Use exec with captured output
@@ -7299,7 +7302,7 @@ def exec(lang, path, import_all):
             exec_globals = {'__name__': '__main__'}
 
             with redirect_stdout(stdout_capture), redirect_stderr(stderr_capture):
-                exec(full_code, exec_globals)
+                builtins.exec(full_code, exec_globals)
 
             stdout_val = stdout_capture.getvalue()
             stderr_val = stderr_capture.getvalue()
@@ -7315,6 +7318,29 @@ def exec(lang, path, import_all):
         except Exception as e:
             click.secho(f"Error: {e}", fg='red')
 
+    elif is_cssl:
+        # Execute CSSL code
+        full_code = '\n'.join(lines)
+        try:
+            from ..core.cssl_bridge import CsslLang
+            cssl_lang = CsslLang()
+            result = cssl_lang.exec(full_code)
+
+            # Print any output from the execution
+            output = cssl_lang.get_output()
+            if output:
+                for line in output:
+                    click.echo(line)
+
+            if result is not None:
+                click.echo(result)
+
+            if not output and result is None:
+                click.secho("(no output)", fg='bright_black')
+
+        except Exception as e:
+            click.secho(f"Error: {e}", fg='red')
+
     else:
         # Execute C++ code
         # Build a complete C++ program
@@ -7631,6 +7657,74 @@ void error(string message) {{
     click.echo(f"  CSSL.exec('{cssl_file}')")
 
 
+@cssl.command(name='vscode')
+def cssl_vscode():
+    """Install VSCode extension for CSSL syntax highlighting."""
+    from pathlib import Path as PathLib
+    import shutil
+    import os
+
+    # Find VSCode extensions directory
+    if os.name == 'nt':  # Windows
+        vscode_ext_dir = PathLib(os.environ.get('USERPROFILE', '')) / '.vscode' / 'extensions'
+    else:  # Linux/Mac
+        vscode_ext_dir = PathLib.home() / '.vscode' / 'extensions'
+
+    if not vscode_ext_dir.exists():
+        # Try VSCode Insiders
+        if os.name == 'nt':
+            vscode_ext_dir = PathLib(os.environ.get('USERPROFILE', '')) / '.vscode-insiders' / 'extensions'
+        else:
+            vscode_ext_dir = PathLib.home() / '.vscode-insiders' / 'extensions'
+
+    if not vscode_ext_dir.exists():
+        click.secho("VSCode extensions directory not found.", fg='red')
+        click.echo("Make sure VSCode is installed.")
+        click.echo()
+        click.echo("Expected locations:")
+        if os.name == 'nt':
+            click.echo(f"  %USERPROFILE%\\.vscode\\extensions")
+        else:
+            click.echo(f"  ~/.vscode/extensions")
+        return
+
+    # Find our bundled extension
+    package_dir = PathLib(__file__).parent.parent
+    source_ext_dir = package_dir / 'vscode' / 'cssl'
+
+    if not source_ext_dir.exists():
+        click.secho("CSSL extension files not found in package.", fg='red')
+        return
+
+    # Install extension
+    target_dir = vscode_ext_dir / 'includecpp.cssl-1.0.0'
+
+    try:
+        if target_dir.exists():
+            shutil.rmtree(target_dir)
+
+        shutil.copytree(source_ext_dir, target_dir)
+
+        click.secho("CSSL VSCode extension installed!", fg='green', bold=True)
+        click.echo()
+        click.echo(f"Installed to: {target_dir}")
+        click.echo()
+        click.echo("Features:")
+        click.echo("  - Syntax highlighting for .cssl, .cssl-pl, .cssl-mod files")
+        click.echo("  - BruteInjection operators: <==, ==>, <<==, +<==, etc.")
+        click.echo("  - Type highlighting: int, string, stack<T>, datastruct<T>")
+        click.echo("  - Global references: @Name, r@Name, s@Name")
+        click.echo("  - Shared objects: $Name")
+        click.echo("  - Filter helpers: string::contains, json::key, etc.")
+        click.echo()
+        click.secho("Restart VSCode to activate the extension.", fg='yellow')
+
+    except PermissionError:
+        click.secho("Permission denied. Try running as administrator.", fg='red')
+    except Exception as e:
+        click.secho(f"Installation failed: {e}", fg='red')
+
+
 # Register hidden cssl command group
 cli.add_command(cssl)
 

includecpp/core/cssl/cssl_runtime.py

@@ -145,6 +145,8 @@ class CSSLRuntime:
         self._running = False
         self._exit_code = 0
         self._output_callback = output_callback  # Callback for console output (text, level)
+        self._source_lines: List[str] = []  # Store source code lines for error reporting
+        self._current_file: str = "<code>"  # Current file being executed
 
         self._setup_modules()
         self._setup_builtins()
@@ -230,23 +232,68 @@ class CSSLRuntime:
 
         return obj
 
+    def _format_error(self, line: int, message: str, hint: str = None) -> CSSLRuntimeError:
+        """Format a detailed error with source context"""
+        error_parts = []
+
+        # Main error header
+        if line and line > 0:
+            error_parts.append(f"Error at line {line} in {self._current_file}:")
+        else:
+            error_parts.append(f"Error in {self._current_file}:")
+
+        # Extract message without existing line info
+        clean_msg = message
+        if "at line" in clean_msg.lower():
+            # Remove redundant line info from message
+            clean_msg = clean_msg.split(":", 1)[-1].strip() if ":" in clean_msg else clean_msg
+
+        error_parts.append(f"  {clean_msg}")
+
+        # Show source context (3 lines before and after)
+        if self._source_lines and line and line > 0:
+            error_parts.append("")
+            start = max(0, line - 3)
+            end = min(len(self._source_lines), line + 2)
+
+            for i in range(start, end):
+                line_num = i + 1
+                source_line = self._source_lines[i] if i < len(self._source_lines) else ""
+                marker = ">>>" if line_num == line else "   "
+                error_parts.append(f"  {marker} {line_num:4d} | {source_line}")
+
+        # Add hint
+        if hint:
+            error_parts.append("")
+            error_parts.append(f"  Hint: {hint}")
+
+        return CSSLRuntimeError("\n".join(error_parts), line)
+
+    def _get_source_line(self, line: int) -> str:
+        """Get source line by number (1-indexed)"""
+        if self._source_lines and 0 < line <= len(self._source_lines):
+            return self._source_lines[line - 1]
+        return ""
+
     def execute(self, source: str) -> Any:
         """Execute CSSL service source code"""
+        self._source_lines = source.splitlines()
         try:
             ast = parse_cssl(source)
             return self._execute_node(ast)
         except CSSLSyntaxError as e:
-            raise CSSLRuntimeError(str(e), e.line)
+            raise self._format_error(e.line, str(e))
         except SyntaxError as e:
             raise CSSLRuntimeError(f"Syntax error: {e}")
 
     def execute_program(self, source: str) -> Any:
         """Execute standalone CSSL program (no service wrapper)"""
+        self._source_lines = source.splitlines()
         try:
             ast = parse_cssl_program(source)
             return self._exec_program(ast)
         except CSSLSyntaxError as e:
-            raise CSSLRuntimeError(str(e), e.line)
+            raise self._format_error(e.line, str(e))
         except SyntaxError as e:
             raise CSSLRuntimeError(f"Syntax error: {e}")
 
@@ -256,12 +303,16 @@ class CSSLRuntime:
 
     def execute_file(self, filepath: str) -> Any:
         """Execute a CSSL service file"""
+        import os
+        self._current_file = os.path.basename(filepath)
         with open(filepath, 'r', encoding='utf-8') as f:
             source = f.read()
         return self.execute(source)
 
     def execute_program_file(self, filepath: str) -> Any:
         """Execute a standalone CSSL program file"""
+        import os
+        self._current_file = os.path.basename(filepath)
         with open(filepath, 'r', encoding='utf-8') as f:
             source = f.read()
         return self.execute_program(source)
@@ -1026,10 +1077,33 @@ class CSSLRuntime:
                 # === STRING HELPERS ===
                 if filter_type == 'string':
                     if helper == 'where':
+                        # Exact match
+                        if isinstance(result, str):
+                            result = result if result == filter_val else None
+                        elif isinstance(result, list):
+                            result = [item for item in result if isinstance(item, str) and item == filter_val]
+                    elif helper == 'contains':
+                        # Contains substring
                         if isinstance(result, str):
                             result = result if filter_val in result else None
                         elif isinstance(result, list):
                             result = [item for item in result if isinstance(item, str) and filter_val in item]
+                    elif helper == 'not':
+                        # Exclude matching
+                        if isinstance(result, str):
+                            result = result if result != filter_val else None
+                        elif isinstance(result, list):
+                            result = [item for item in result if not (isinstance(item, str) and item == filter_val)]
+                    elif helper == 'startsWith':
+                        if isinstance(result, str):
+                            result = result if result.startswith(filter_val) else None
+                        elif isinstance(result, list):
+                            result = [item for item in result if isinstance(item, str) and item.startswith(filter_val)]
+                    elif helper == 'endsWith':
+                        if isinstance(result, str):
+                            result = result if result.endswith(filter_val) else None
+                        elif isinstance(result, list):
+                            result = [item for item in result if isinstance(item, str) and item.endswith(filter_val)]
                     elif helper in ('length', 'lenght'):  # Support common typo
                         if isinstance(result, str):
                             result = result if len(result) == filter_val else None

includecpp/core/cssl_bridge.py

@@ -289,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:
         """

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"
+            }
+        ]
+    }
+}

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

@@ -0,0 +1,221 @@
+{
+    "$schema": "https://raw.githubusercontent.com/martinring/tmlanguage/master/tmlanguage.json",
+    "name": "CSSL",
+    "scopeName": "source.cssl",
+    "patterns": [
+        { "include": "#comments" },
+        { "include": "#strings" },
+        { "include": "#numbers" },
+        { "include": "#keywords" },
+        { "include": "#types" },
+        { "include": "#function-modifiers" },
+        { "include": "#injection-operators" },
+        { "include": "#filter-helpers" },
+        { "include": "#global-references" },
+        { "include": "#shared-references" },
+        { "include": "#module-references" },
+        { "include": "#function-calls" },
+        { "include": "#operators" },
+        { "include": "#constants" }
+    ],
+    "repository": {
+        "comments": {
+            "patterns": [
+                {
+                    "name": "comment.line.double-slash.cssl",
+                    "match": "//.*$"
+                },
+                {
+                    "name": "comment.block.cssl",
+                    "begin": "/\\*",
+                    "end": "\\*/"
+                }
+            ]
+        },
+        "strings": {
+            "patterns": [
+                {
+                    "name": "string.quoted.double.cssl",
+                    "begin": "\"",
+                    "end": "\"",
+                    "patterns": [
+                        {
+                            "name": "constant.character.escape.cssl",
+                            "match": "\\\\."
+                        },
+                        {
+                            "name": "variable.other.interpolated.cssl",
+                            "match": "<[a-zA-Z_][a-zA-Z0-9_]*>"
+                        }
+                    ]
+                },
+                {
+                    "name": "string.quoted.single.cssl",
+                    "begin": "'",
+                    "end": "'",
+                    "patterns": [
+                        {
+                            "name": "constant.character.escape.cssl",
+                            "match": "\\\\."
+                        }
+                    ]
+                }
+            ]
+        },
+        "numbers": {
+            "patterns": [
+                {
+                    "name": "constant.numeric.float.cssl",
+                    "match": "\\b[0-9]+\\.[0-9]+\\b"
+                },
+                {
+                    "name": "constant.numeric.integer.cssl",
+                    "match": "\\b[0-9]+\\b"
+                }
+            ]
+        },
+        "keywords": {
+            "patterns": [
+                {
+                    "name": "keyword.control.cssl",
+                    "match": "\\b(if|else|elif|while|for|foreach|in|range|switch|case|default|break|continue|return|try|catch|finally|throw)\\b"
+                },
+                {
+                    "name": "keyword.other.cssl",
+                    "match": "\\b(service-init|service-run|service-include|struct|structure|define|main|package|package-includes|exec|as|global|include|get|payload)\\b"
+                },
+                {
+                    "name": "keyword.operator.logical.cssl",
+                    "match": "\\b(and|or|not)\\b"
+                },
+                {
+                    "name": "keyword.other.async.cssl",
+                    "match": "\\b(start|stop|wait_for|on_event|emit_event|await)\\b"
+                }
+            ]
+        },
+        "types": {
+            "patterns": [
+                {
+                    "name": "storage.type.primitive.cssl",
+                    "match": "\\b(int|string|float|bool|void|json|dynamic)\\b"
+                },
+                {
+                    "name": "storage.type.container.cssl",
+                    "match": "\\b(array|vector|stack|datastruct|dataspace|shuffled|iterator|combo|openquote)\\b"
+                },
+                {
+                    "name": "storage.type.generic.cssl",
+                    "match": "\\b(array|vector|stack|datastruct|dataspace|shuffled|iterator|combo|openquote)\\s*<",
+                    "captures": {
+                        "1": { "name": "storage.type.container.cssl" }
+                    }
+                }
+            ]
+        },
+        "function-modifiers": {
+            "patterns": [
+                {
+                    "name": "storage.modifier.cssl",
+                    "match": "\\b(undefined|open|closed|private|virtual|meta|super|sqlbased)\\b"
+                }
+            ]
+        },
+        "injection-operators": {
+            "patterns": [
+                {
+                    "name": "keyword.operator.injection.cssl",
+                    "match": "(\\+<<==|<<==|-<<==|==>>\\+|==>>|-==>>)"
+                },
+                {
+                    "name": "keyword.operator.brute-injection.cssl",
+                    "match": "(\\+<==|<==|-<==|==>\\+|==>|-==>)"
+                }
+            ]
+        },
+        "filter-helpers": {
+            "patterns": [
+                {
+                    "name": "support.function.filter.cssl",
+                    "match": "\\b(string|integer|json|array|vector|combo|dynamic|sql)::(where|contains|not|startsWith|endsWith|length|lenght|key|value|index|filterdb|blocked|data)\\b"
+                }
+            ]
+        },
+        "global-references": {
+            "patterns": [
+                {
+                    "name": "variable.other.global.cssl",
+                    "match": "@[a-zA-Z_][a-zA-Z0-9_]*"
+                },
+                {
+                    "name": "variable.other.global-decl.cssl",
+                    "match": "r@[a-zA-Z_][a-zA-Z0-9_]*"
+                },
+                {
+                    "name": "variable.other.self-ref.cssl",
+                    "match": "s@[a-zA-Z_][a-zA-Z0-9_]*"
+                }
+            ]
+        },
+        "shared-references": {
+            "patterns": [
+                {
+                    "name": "variable.other.shared.cssl",
+                    "match": "\\$[a-zA-Z_][a-zA-Z0-9_]*"
+                }
+            ]
+        },
+        "module-references": {
+            "patterns": [
+                {
+                    "name": "entity.name.type.module.cssl",
+                    "match": "@[A-Z][a-zA-Z0-9_]*"
+                }
+            ]
+        },
+        "function-calls": {
+            "patterns": [
+                {
+                    "name": "entity.name.function.cssl",
+                    "match": "\\b([a-zA-Z_][a-zA-Z0-9_]*)\\s*(?=\\()"
+                },
+                {
+                    "name": "support.function.builtin.cssl",
+                    "match": "\\b(printl|print|println|len|type|toInt|toFloat|toString|toBool|range|input|exit|sleep|OpenFind|parameter\\.get|parameter\\.return)\\b"
+                }
+            ]
+        },
+        "operators": {
+            "patterns": [
+                {
+                    "name": "keyword.operator.comparison.cssl",
+                    "match": "(==|!=|<=|>=|<|>)"
+                },
+                {
+                    "name": "keyword.operator.arithmetic.cssl",
+                    "match": "(\\+\\+|--|\\+=|-=|\\+|-|\\*|/|%)"
+                },
+                {
+                    "name": "keyword.operator.logical.cssl",
+                    "match": "(&&|\\|\\||!)"
+                },
+                {
+                    "name": "keyword.operator.assignment.cssl",
+                    "match": "="
+                }
+            ]
+        },
+        "constants": {
+            "patterns": [
+                {
+                    "name": "constant.language.boolean.cssl",
+                    "match": "\\b(true|false|True|False)\\b"
+                },
+                {
+                    "name": "constant.language.null.cssl",
+                    "match": "\\b(null|None)\\b"
+                }
+            ]
+        }
+    }
+}

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: IncludeCPP
-Version: 3.4.21
+Version: 3.5.0
 Summary: Professional C++ Python bindings with type-generic templates, pystubs and native threading
 Home-page: https://github.com/liliassg/IncludeCPP
 Author: Lilias Hatterscheidt

{includecpp-3.4.21.dist-info → includecpp-3.5.0.dist-info}/RECORD

@@ -1,9 +1,9 @@
-includecpp/__init__.py,sha256=LEEUAR8w2v0NHGgMiOX2nK47f4KlzUvZCq7mAIa-8bU,1673
+includecpp/__init__.py,sha256=Lg4ApbFSBpQVYm5SgU_irWBxdxpWkOJOmWYy9xG_wiQ,1672
 includecpp/__init__.pyi,sha256=c4gZW7_XQXcp6FBcTi5W7zXTmCtbgQhlC4cyeVqtRRM,7253
 includecpp/__main__.py,sha256=d6QK0PkvUe1ENofpmHRAg3bwNbZr8PiRscfI3-WRfVg,72
 includecpp/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 includecpp/cli/__init__.py,sha256=Yda-4a5QJb_tKu35YQNfc5lu-LewTsM5abqNNkzS47M,113
-includecpp/cli/commands.py,sha256=_KnxbpgUUdqdzEYGeHRSafXF0o9qt8JCfnM9l10gbh0,321214
+includecpp/cli/commands.py,sha256=RsG1ixzxSnnHHb1a42x_4hBapV1i360AIK9swQVZBRQ,324721
 includecpp/cli/config_parser.py,sha256=KveeYUg2TA9sC5hKVzYYfgdNm2WfLG5y7_yxgBWn9yM,4886
 includecpp/core/__init__.py,sha256=L1bT6oikTjdto-6Px7DpjePtM07ymo3Bnov1saZzsGg,390
 includecpp/core/ai_integration.py,sha256=PW6yFDqdXjfchpfKTKg59AOLhLry9kqJEGf_65BztrY,87603
@@ -11,7 +11,7 @@ includecpp/core/build_manager.py,sha256=uLuYsuiC6OsOGaU5wAJfl4M3IbdnIDgogfMd8VsV
 includecpp/core/cpp_api.py,sha256=8y_B1L18rhSBZln654xPPzqO2PdvAlLpJrfEjzl7Wnc,14039
 includecpp/core/cpp_api.pyi,sha256=IEiaKqaPItnn6rjL7aK32D3o9FYmRYCgCZbqiQNUwdc,3496
 includecpp/core/cppy_converter.py,sha256=b7yqu-aoa0wShNY0GvQT67TnNhYya4GyYmG7oDdqDV4,156686
-includecpp/core/cssl_bridge.py,sha256=1l4okSND3EAtdf4M_QVq3pOWfiPtE_Ei30LMGORRvEQ,24157
+includecpp/core/cssl_bridge.py,sha256=ZrFXkJmu0ikZu0CeNuxjKyaarzpb1O6Ph3ynf8ZomTE,24396
 includecpp/core/cssl_bridge.pyi,sha256=Q4zjc2Kf2wPJPnfgHS-koPEon3Kty6o3mCvp9E5Q8tE,7635
 includecpp/core/error_catalog.py,sha256=VS3N-P0yEbiHimsDPtcaYfrUb7mXQ-7pqw18PtSngaU,33869
 includecpp/core/error_formatter.py,sha256=7-MzRIT8cM4uODxy0IZ9pu7pqR4Pq2I8Si0QQZHjmVc,39239
@@ -25,7 +25,7 @@ includecpp/core/cssl/cssl_builtins.py,sha256=WJtSWPsNNOSYtXBHK0h4ImXLrqId8ElfykQ
 includecpp/core/cssl/cssl_events.py,sha256=nupIcXW_Vjdud7zCU6hdwkQRQ0MujlPM7Tk2u7eDAiY,21013
 includecpp/core/cssl/cssl_modules.py,sha256=cUg0-zdymMnWWTsA_BUrW5dx4R04dHpKcUhm-Wfiwwo,103006
 includecpp/core/cssl/cssl_parser.py,sha256=TxkqYHSGoY8ddHupD7qfaBgwKTCofhpmApzN-rWFCnY,91644
-includecpp/core/cssl/cssl_runtime.py,sha256=Mchv9eutE8x-y_XAUBKzRPwzyATe4dtjAIttcBmC3mQ,93608
+includecpp/core/cssl/cssl_runtime.py,sha256=g_R5BPWlqYgkk8wIEjawKr-_W7S_wdXAtkzrgJ-7yxs,97317
 includecpp/core/cssl/cssl_syntax.py,sha256=vgI-dgj6gs9cOHwNRff6JbwZZYW_fYutnwCkznlgZiE,17006
 includecpp/core/cssl/cssl_types.py,sha256=JaBhVFcByaC-Thdkd0J9IMkUzLkxriBWx1XfwPr6knM,30561
 includecpp/generator/__init__.py,sha256=Rsy41bwimaEloD3gDRR_znPfIJzIsCFuWZgCTJBLJlc,62
@@ -34,9 +34,14 @@ includecpp/generator/parser.h,sha256=EDm0b-pEesIIIQQ2PvH5h2qwlqJU9BH8SiMV7MWbsTo
 includecpp/generator/type_resolver.cpp,sha256=MmFK_4HXd1wqxALDiDyXVuU397SXoQL_o5zb_8N8Hzs,12346
 includecpp/generator/type_resolver.h,sha256=ZsaxQqcCcKJJApYn7KOp2dLlQ1VFVG_oZDjaK5LhBSg,2590
 includecpp/templates/cpp.proj.template,sha256=Iy-L8I4Cl3tIgBMx1Qp5h6gURvkqOAqyodVHuDJ0Luw,359
-includecpp-3.4.21.dist-info/licenses/LICENSE,sha256=fWCsGGsiWZir0UzDd20Hh-3wtRyk1zqUntvtVuAWhvc,1093
-includecpp-3.4.21.dist-info/METADATA,sha256=_C5lYdo9fpO18toixnsaWR0_thu6oPVQ9wvpapiqc8E,32123
-includecpp-3.4.21.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-includecpp-3.4.21.dist-info/entry_points.txt,sha256=6A5Mif9gi0139Bf03W5plAb3wnAgbNaEVe1HJoGE-2o,59
-includecpp-3.4.21.dist-info/top_level.txt,sha256=RFUaR1KG-M6mCYwP6w4ydP5Cgc8yNbP78jxGAvyjMa8,11
-includecpp-3.4.21.dist-info/RECORD,,
+includecpp/vscode/__init__.py,sha256=yLKw-_7MTX1Rx3jLk5JjharJQfFXbwtZVE7YqHpM7yg,39
+includecpp/vscode/cssl/__init__.py,sha256=rQJAx5X05v-mAwqX1Qb-rbZO219iR73MziFNRUCNUIo,31
+includecpp/vscode/cssl/language-configuration.json,sha256=vBZSVBpV0UFlTO4d0aQrhTpR4lHje0Tb2n889k9W_Uc,986
+includecpp/vscode/cssl/package.json,sha256=t_xEMMew3ohtxv9riyPdGo_T6TMJi-REJ-GDS_GYbCk,872
+includecpp/vscode/cssl/syntaxes/cssl.tmLanguage.json,sha256=lvg2EHN8If1Hw0RY_EqatLupclQmhq3oZlnBA0Zi-54,8023
+includecpp-3.5.0.dist-info/licenses/LICENSE,sha256=fWCsGGsiWZir0UzDd20Hh-3wtRyk1zqUntvtVuAWhvc,1093
+includecpp-3.5.0.dist-info/METADATA,sha256=5rCFLg7vB9EsiDxQdmIJaaTHm2T1rwOP_hZn2hNwyfI,32122
+includecpp-3.5.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+includecpp-3.5.0.dist-info/entry_points.txt,sha256=6A5Mif9gi0139Bf03W5plAb3wnAgbNaEVe1HJoGE-2o,59
+includecpp-3.5.0.dist-info/top_level.txt,sha256=RFUaR1KG-M6mCYwP6w4ydP5Cgc8yNbP78jxGAvyjMa8,11
+includecpp-3.5.0.dist-info/RECORD,,