IncludeCPP 3.7.27__tar.gz → 3.8.2__tar.gz

{includecpp-3.7.27 → includecpp-3.8.2}/IncludeCPP.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: IncludeCPP
-Version: 3.7.27
+Version: 3.8.2
 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.7.27 → includecpp-3.8.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: IncludeCPP
-Version: 3.7.27
+Version: 3.8.2
 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.7.27 → includecpp-3.8.2}/includecpp/__init__.py

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

{includecpp-3.7.27 → includecpp-3.8.2}/includecpp/cli/commands.py

@@ -7457,11 +7457,24 @@ def cssl():
     pass
 
 
+@cssl.command(name='run')
+@click.argument('path', required=False, type=click.Path())
+@click.option('--code', '-c', type=str, help='Execute code directly')
+def cssl_run(path, code):
+    """Run/execute CSSL code or file."""
+    _cssl_execute(path, code)
+
+
 @cssl.command(name='exec')
 @click.argument('path', required=False, type=click.Path())
 @click.option('--code', '-c', type=str, help='Execute code directly')
 def cssl_exec(path, code):
-    """Execute CSSL code or file."""
+    """Execute CSSL code or file (alias for 'run')."""
+    _cssl_execute(path, code)
+
+
+def _cssl_execute(path, code):
+    """Internal: Execute CSSL code or file."""
     from pathlib import Path as PathLib
 
     try:
@@ -7923,16 +7936,18 @@ cli.add_command(cssl)
 
 @cli.command()
 @click.option('--force', '-f', is_flag=True, help='Force overwrite existing files')
+@click.option('--reinstall', '-r', is_flag=True, help='Reinstall extension (removes all versions first)')
 @click.option('--stubs-only', is_flag=True, help='Only update stubs, skip extension files')
-def vscode(force, stubs_only):
+def vscode(force, reinstall, stubs_only):
     """Initialize or update VSCode configuration for IncludeCPP/CSSL.
 
     Installs CSSL extension globally and sets up project stubs.
 
     \b
     Usage:
-      includecpp vscode           # Install/update extension + stubs
-      includecpp vscode --force   # Force reinstall extension
+      includecpp vscode             # Install/update extension + stubs
+      includecpp vscode --force     # Force reinstall extension
+      includecpp vscode --reinstall # Remove ALL versions & reinstall fresh
       includecpp vscode --stubs-only  # Only update stubs
 
     \b
@@ -7999,13 +8014,18 @@ def vscode(force, stubs_only):
                 target_dir = global_ext_dir / f'includecpp.cssl-{current_version}'
 
                 # Check if already installed with same or older version
-                needs_install = force
+                needs_install = force or reinstall
                 existing_version = None
 
                 # Find existing installations
                 for existing in global_ext_dir.glob('includecpp.cssl-*'):
                     existing_version = existing.name.split('-')[-1]
-                    if existing_version != current_version:
+                    if reinstall:
+                        # --reinstall: Remove ALL versions
+                        click.echo(f"  Removing version: {existing_version}")
+                        shutil.rmtree(existing)
+                        needs_install = True
+                    elif existing_version != current_version:
                         # Remove old version
                         click.echo(f"  Removing old version: {existing_version}")
                         shutil.rmtree(existing)

{includecpp-3.7.27 → includecpp-3.8.2}/includecpp/core/cssl/cssl_builtins.py

@@ -2612,7 +2612,8 @@ class PythonizedMethod:
             raise RuntimeError(f"Cannot call method '{self._method_name}' - no runtime available")
 
         # Execute the method through the runtime
-        result = self._runtime._call_method(self._instance, self._method_name, list(args))
+        # Pass the method AST node, not the method name
+        result = self._runtime._call_method(self._instance, self._method_ast, list(args), kwargs)
 
         # Pythonize the result if it's a CSSL instance
         from .cssl_types import CSSLInstance

{includecpp-3.7.27 → includecpp-3.8.2}/includecpp/core/cssl/cssl_parser.py

@@ -1025,7 +1025,11 @@ class CSSLParser:
         return result
 
     def _parse_typed_variable(self) -> Optional[ASTNode]:
-        """Parse a typed variable declaration: type varName; or type<T> varName = value;"""
+        """Parse a typed variable declaration: type varName; or type<T> *varName = value;
+
+        The * prefix indicates a non-nullable variable (can never be None/null).
+        Example: vector<dynamic> *MyVector - can never contain None values.
+        """
         # Get type name
         type_name = self._advance().value  # Consume type keyword
 
@@ -1039,6 +1043,11 @@ class CSSLParser:
                 element_type = self._advance().value
             self._expect(TokenType.COMPARE_GT)
 
+        # Check for * prefix (non-nullable indicator)
+        non_null = False
+        if self._match(TokenType.ASTERISK):
+            non_null = True
+
         # Get variable name
         if not self._check(TokenType.IDENTIFIER):
             return None
@@ -1056,14 +1065,16 @@ class CSSLParser:
             return ASTNode('instance_declaration', value={
                 'instance_name': element_type,
                 'name': var_name,
-                'value': value
+                'value': value,
+                'non_null': non_null
             })
 
         return ASTNode('typed_declaration', value={
             'type': type_name,
             'element_type': element_type,
             'name': var_name,
-            'value': value
+            'value': value,
+            'non_null': non_null
         })
 
     def parse_program(self) -> ASTNode:
@@ -1361,10 +1372,18 @@ class CSSLParser:
                     printl("Hello " + this->name);
                 }
             }
+
+        Non-null class (all methods return non-null):
+            class *MyClass { ... }
         """
+        # Check for * prefix (non-null class - all methods return non-null)
+        non_null = False
+        if self._match(TokenType.ASTERISK):
+            non_null = True
+
         class_name = self._advance().value
 
-        node = ASTNode('class', value={'name': class_name}, children=[])
+        node = ASTNode('class', value={'name': class_name, 'non_null': non_null}, children=[])
         self._expect(TokenType.BLOCK_START)
 
         while not self._check(TokenType.BLOCK_END) and not self._is_at_end():
@@ -1400,6 +1419,17 @@ class CSSLParser:
         return node
 
     def _parse_define(self) -> ASTNode:
+        """Parse define function declaration.
+
+        Syntax:
+            define MyFunc(args) { }
+            define *MyFunc(args) { }  // Non-null: must never return None
+        """
+        # Check for * prefix (non-null function - must return non-null)
+        non_null = False
+        if self._match(TokenType.ASTERISK):
+            non_null = True
+
         name = self._advance().value
         params = []
 
@@ -1415,6 +1445,9 @@ class CSSLParser:
                 # Handle reference operator &
                 if self._match(TokenType.AMPERSAND):
                     param_info['ref'] = True
+                # Handle * prefix for non-null parameters
+                if self._match(TokenType.ASTERISK):
+                    param_info['non_null'] = True
                 # Get parameter name
                 if self._check(TokenType.IDENTIFIER):
                     param_name = self._advance().value
@@ -1435,7 +1468,7 @@ class CSSLParser:
                     break
             self._expect(TokenType.PAREN_END)
 
-        node = ASTNode('function', value={'name': name, 'params': params}, children=[])
+        node = ASTNode('function', value={'name': name, 'params': params, 'non_null': non_null}, children=[])
         self._expect(TokenType.BLOCK_START)
 
         while not self._check(TokenType.BLOCK_END) and not self._is_at_end():
@@ -2610,12 +2643,24 @@ class CSSLParser:
                 'init_values': init_values
             })
 
-        # Check for type-parameterized function call: OpenFind<string>(0)
+        # Check for type-parameterized function call: OpenFind<string>(0) or OpenFind<dynamic, "name">
         if name in TYPE_PARAM_FUNCTIONS and self._check(TokenType.COMPARE_LT):
             self._advance()  # consume <
             type_param = 'dynamic'
+            param_name = None  # Optional: named parameter search
+
             if self._check(TokenType.KEYWORD) or self._check(TokenType.IDENTIFIER):
                 type_param = self._advance().value
+
+            # Check for second parameter: OpenFind<type, "name">
+            if self._check(TokenType.COMMA):
+                self._advance()  # consume comma
+                # Expect a string literal for the parameter name
+                if self._check(TokenType.STRING):
+                    param_name = self._advance().value
+                elif self._check(TokenType.IDENTIFIER):
+                    param_name = self._advance().value
+
             self._expect(TokenType.COMPARE_GT)  # consume >
 
             # Must be followed by ()
@@ -2632,6 +2677,7 @@ class CSSLParser:
                 return ASTNode('typed_call', value={
                     'name': name,
                     'type_param': type_param,
+                    'param_name': param_name,  # Named parameter for OpenFind
                     'args': args
                 })
 

{includecpp-3.7.27 → includecpp-3.8.2}/includecpp/core/cssl/cssl_runtime.py

@@ -772,12 +772,16 @@ class CSSLRuntime:
         """Execute typed variable declaration: type<T> varName = value;
 
         Creates appropriate type instances for stack, vector, datastruct, etc.
+
+        The * prefix indicates a non-nullable variable (can never be None/null).
+        Example: vector<dynamic> *MyVector - can never contain None values.
         """
         decl = node.value
         type_name = decl.get('type')
         element_type = decl.get('element_type', 'dynamic')
         var_name = decl.get('name')
         value_node = decl.get('value')
+        non_null = decl.get('non_null', False)
 
         # Create the appropriate type instance
         if type_name == 'stack':
@@ -825,11 +829,32 @@ class CSSLRuntime:
             # For container types, the value might be initialization data
             init_value = self._evaluate(value_node)
             if isinstance(init_value, (list, tuple)):
+                # For non-null containers, filter out None values
+                if non_null:
+                    init_value = [v for v in init_value if v is not None]
                 instance.extend(init_value)
             elif init_value is not None:
                 if hasattr(instance, 'append'):
                     instance.append(init_value)
 
+        # Non-null enforcement: container types get wrapped to filter None on operations
+        if non_null:
+            # Mark the instance as non-null for runtime checks
+            if hasattr(instance, '_non_null'):
+                instance._non_null = True
+            # Track non-null variables for assignment enforcement
+            if not hasattr(self, '_non_null_vars'):
+                self._non_null_vars = set()
+            self._non_null_vars.add(var_name)
+
+            # Ensure initial value is not None for non-null variables
+            if instance is None:
+                raise CSSLRuntimeError(
+                    f"Non-null variable '*{var_name}' cannot be initialized to None",
+                    node.line,
+                    hint="Use a default value or remove the * prefix"
+                )
+
         # Check for global modifier
         modifiers = decl.get('modifiers', [])
         is_global = 'global' in modifiers
@@ -1031,8 +1056,16 @@ class CSSLRuntime:
             # Check if this is an 'open' parameter - receives all args as a list
             if param_type == 'open' or param_name == 'Params':
                 # 'open Params' receives all arguments as a list
-                new_scope.set(param_name, list(args))
-                new_scope.set('Params', list(args))  # Also set 'Params' for OpenFind
+                # Check for non_null flag: open *Params filters out None values
+                is_non_null = isinstance(param, dict) and param.get('non_null', False)
+                args_list = list(args)
+                if is_non_null:
+                    args_list = [a for a in args_list if a is not None]
+                    # Also filter kwargs
+                    kwargs = {k: v for k, v in kwargs.items() if v is not None}
+                new_scope.set(param_name, args_list)
+                new_scope.set('Params', args_list)  # Also set 'Params' for OpenFind
+                new_scope.set('_OpenKwargs', kwargs)  # Store kwargs for OpenFind<type, "name">
             elif param_name in kwargs:
                 # Named argument takes priority
                 new_scope.set(param_name, kwargs[param_name])
@@ -2186,7 +2219,12 @@ class CSSLRuntime:
 
         if isinstance(target, ASTNode):
             if target.type == 'identifier':
-                self.scope.set(target.value, value)
+                # Check if we're in a class method and this is a class member
+                # If so, set the member instead of creating a local variable
+                if self._current_instance is not None and self._current_instance.has_member(target.value):
+                    self._current_instance.set_member(target.value, value)
+                else:
+                    self.scope.set(target.value, value)
             elif target.type == 'global_ref':
                 # r@Name = value - store in promoted globals
                 self._promoted_globals[target.value] = value
@@ -2303,6 +2341,9 @@ class CSSLRuntime:
 
         if node.type == 'literal':
             value = node.value
+            # Handle dict-format literals from parser: {'type': 'int', 'value': 0}
+            if isinstance(value, dict) and 'value' in value:
+                value = value['value']
             # String interpolation - replace {var} or <var> with scope values
             if isinstance(value, str):
                 has_fstring = '{' in value and '}' in value
@@ -2323,6 +2364,16 @@ class CSSLRuntime:
         if node.type == 'identifier':
             name = node.value
             value = self.scope.get(name)
+            # Check if it's a class member in current instance context
+            # This allows accessing members without 'this->' inside methods
+            if value is None and self._current_instance is not None:
+                if self._current_instance.has_member(name):
+                    value = self._current_instance.get_member(name)
+                elif self._current_instance.has_method(name):
+                    # Return bound method
+                    method_node = self._current_instance.get_method(name)
+                    instance = self._current_instance
+                    value = lambda *args, **kwargs: self._call_method(instance, method_node, list(args), kwargs)
             # Fallback to global scope
             if value is None:
                 value = self.global_scope.get(name)
@@ -2768,19 +2819,20 @@ class CSSLRuntime:
         )
 
     def _eval_typed_call(self, node: ASTNode) -> Any:
-        """Evaluate typed function call like OpenFind<string>(0)"""
+        """Evaluate typed function call like OpenFind<string>(0) or OpenFind<dynamic, "name">"""
         name = node.value.get('name')
         type_param = node.value.get('type_param', 'dynamic')
+        param_name = node.value.get('param_name')  # For OpenFind<type, "name">
         args = [self._evaluate(a) for a in node.value.get('args', [])]
 
-        # Handle OpenFind<type>(index)
+        # Handle OpenFind<type>(index) or OpenFind<type, "name">
         if name == 'OpenFind':
             # OpenFind searches for a value of the specified type
             # from the open parameters in scope
             open_params = self.scope.get('Params') or []
-            index = args[0] if args else 0
+            open_kwargs = self.scope.get('_OpenKwargs') or {}
 
-            # Search for value of matching type at or near the index
+            # Type mapping for type checking
             type_map = {
                 'string': str, 'str': str,
                 'int': int, 'integer': int,
@@ -2788,10 +2840,23 @@ class CSSLRuntime:
                 'bool': bool, 'boolean': bool,
                 'list': list, 'array': list,
                 'dict': dict, 'json': dict,
+                'dynamic': None,  # Accept any type
             }
-
             target_type = type_map.get(type_param.lower())
 
+            # If param_name is specified, search by name in kwargs
+            # OpenFind<dynamic, "tasks"> -> searches for MyFunc(tasks="value")
+            if param_name:
+                if param_name in open_kwargs:
+                    value = open_kwargs[param_name]
+                    # Type check if not dynamic
+                    if target_type is None or isinstance(value, target_type):
+                        return value
+                return None
+
+            # Otherwise, search by index in positional args
+            index = args[0] if args else 0
+
             if isinstance(open_params, (list, tuple)):
                 # Find first matching type starting from index
                 for i in range(index, len(open_params)):
@@ -2812,8 +2877,8 @@ class CSSLRuntime:
         raise CSSLRuntimeError(
             f"Unknown typed function: {name}<{type_param}>",
             node.line,
-            context=f"Available typed functions: OpenFind<type>",
-            hint="Typed functions use format: FunctionName<Type>(args)"
+            context=f"Available typed functions: OpenFind<type>, OpenFind<type, \"name\">",
+            hint="Use OpenFind<type>(index) for positional or OpenFind<type, \"name\"> for named params"
         )
 
     def _eval_new(self, node: ASTNode) -> CSSLInstance:

{includecpp-3.7.27 → includecpp-3.8.2}/includecpp/vscode/cssl/package.json

@@ -2,7 +2,7 @@
     "name": "cssl",
     "displayName": "CSSL Language",
     "description": "Professional syntax highlighting, snippets, and language support for CSSL scripts (.cssl, .cssl-pl, .cssl-mod)",
-    "version": "1.3.0",
+    "version": "1.4.0",
     "publisher": "IncludeCPP",
     "icon": "images/cssl.png",
     "engines": {

{includecpp-3.7.27 → includecpp-3.8.2}/includecpp/vscode/cssl/syntaxes/cssl.tmLanguage.json

@@ -28,9 +28,63 @@
         { "include": "#builtins" },
         { "include": "#operators" },
         { "include": "#constants" },
+        { "include": "#non-null-declarations" },
         { "include": "#variables" }
     ],
     "repository": {
+        "non-null-declarations": {
+            "patterns": [
+                {
+                    "comment": "Non-null class: class *ClassName - light pink",
+                    "name": "meta.class.non-null.cssl",
+                    "match": "\\b(class)\\s+(\\*)([a-zA-Z_][a-zA-Z0-9_]*)",
+                    "captures": {
+                        "1": { "name": "storage.type.class.cssl" },
+                        "2": { "name": "keyword.operator.non-null.cssl" },
+                        "3": { "name": "entity.name.class.non-null.cssl" }
+                    }
+                },
+                {
+                    "comment": "Non-null function: define *FuncName - light pink",
+                    "name": "meta.function.non-null.cssl",
+                    "match": "\\b(define)\\s+(\\*)([a-zA-Z_][a-zA-Z0-9_]*)",
+                    "captures": {
+                        "1": { "name": "storage.type.function.cssl" },
+                        "2": { "name": "keyword.operator.non-null.cssl" },
+                        "3": { "name": "entity.name.function.non-null.cssl" }
+                    }
+                },
+                {
+                    "comment": "Non-null typed variable: type<T> *varName - light pink",
+                    "name": "meta.declaration.non-null.cssl",
+                    "match": "\\b(int|string|float|bool|dynamic|vector|stack|array|list|dict|json|datastruct|iterator)\\s*(<[^>]+>)?\\s+(\\*)([a-zA-Z_][a-zA-Z0-9_]*)",
+                    "captures": {
+                        "1": { "name": "storage.type.cssl" },
+                        "2": { "name": "storage.type.generic.cssl" },
+                        "3": { "name": "keyword.operator.non-null.cssl" },
+                        "4": { "name": "variable.other.non-null.cssl" }
+                    }
+                },
+                {
+                    "comment": "Non-null open parameter: open *Params - light pink",
+                    "name": "meta.parameter.non-null.cssl",
+                    "match": "\\b(open)\\s+(\\*)([a-zA-Z_][a-zA-Z0-9_]*)",
+                    "captures": {
+                        "1": { "name": "storage.modifier.open.cssl" },
+                        "2": { "name": "keyword.operator.non-null.cssl" },
+                        "3": { "name": "variable.parameter.non-null.cssl" }
+                    }
+                },
+                {
+                    "comment": "Return type -> * (non-null return)",
+                    "name": "meta.return-type.non-null.cssl",
+                    "match": "->\\s*\\*",
+                    "captures": {
+                        "0": { "name": "keyword.operator.non-null.return.cssl" }
+                    }
+                }
+            ]
+        },
         "super-functions": {
             "patterns": [
                 {

{includecpp-3.7.27 → includecpp-3.8.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "IncludeCPP"
-version = "3.7.27"
+version = "3.8.2"
 description = "Professional C++ Python bindings with type-generic templates, pystubs and native threading"
 readme = "README.md"
 requires-python = ">=3.9"