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

includecpp/core/cssl/__init__.py

@@ -14,29 +14,29 @@ Features:
 from .cssl_parser import (
     parse_cssl, parse_cssl_program, tokenize_cssl,
     CSSLSyntaxError, CSSLLexer, CSSLParser, ASTNode,
-    KEYWORDS, TYPE_GENERICS, INJECTION_HELPERS
+    KEYWORDS, TYPE_GENERICS, TYPE_PARAM_FUNCTIONS, INJECTION_HELPERS
 )
 from .cssl_runtime import CSSLRuntime, CSSLRuntimeError, CSSLServiceRunner, run_cssl, run_cssl_file
 from .cssl_types import (
     DataStruct, Shuffled, Iterator, Combo, DataSpace, OpenQuote,
-    OpenFind, Parameter, Stack, Vector,
+    OpenFind, Parameter, Stack, Vector, Array,
     create_datastruct, create_shuffled, create_iterator,
     create_combo, create_dataspace, create_openquote, create_parameter,
-    create_stack, create_vector
+    create_stack, create_vector, create_array
 )
 
 __all__ = [
     # Parser
     'parse_cssl', 'parse_cssl_program', 'tokenize_cssl',
     'CSSLSyntaxError', 'CSSLLexer', 'CSSLParser', 'ASTNode',
-    'KEYWORDS', 'TYPE_GENERICS', 'INJECTION_HELPERS',
+    'KEYWORDS', 'TYPE_GENERICS', 'TYPE_PARAM_FUNCTIONS', 'INJECTION_HELPERS',
     # Runtime
     'CSSLRuntime', 'CSSLRuntimeError', 'CSSLServiceRunner',
     'run_cssl', 'run_cssl_file',
     # Data Types
     'DataStruct', 'Shuffled', 'Iterator', 'Combo', 'DataSpace', 'OpenQuote',
-    'OpenFind', 'Parameter', 'Stack', 'Vector',
+    'OpenFind', 'Parameter', 'Stack', 'Vector', 'Array',
     'create_datastruct', 'create_shuffled', 'create_iterator',
     'create_combo', 'create_dataspace', 'create_openquote', 'create_parameter',
-    'create_stack', 'create_vector'
+    'create_stack', 'create_vector', 'create_array'
 ]

includecpp/core/cssl/cssl_builtins.py

@@ -255,6 +255,7 @@ class CSSLBuiltins:
         # CSSL Import System Functions
         self._functions['cso_root'] = self.builtin_cso_root
         self._functions['include'] = self.builtin_include
+        self._functions['payload'] = self.builtin_payload
         self._functions['get'] = self.builtin_get
 
         # NEW: Extended OS Functions
@@ -283,6 +284,9 @@ class CSSLBuiltins:
         # Print aliases for CSSL
         self._functions['printl'] = self.builtin_println  # CSSL uses printl for println
 
+        # Shared object functions
+        self._functions['delete'] = self.builtin_delete  # Delete shared object ($Name)
+
     def get_function(self, name: str) -> Optional[Callable]:
         """Get a built-in function by name"""
         return self._functions.get(name)
@@ -1403,16 +1407,29 @@ class CSSLBuiltins:
 
     def builtin_include(self, filepath: str) -> Any:
         """
-        Load and execute a CSSL file, returning its ServiceDefinition
+        Load and execute a CSSL file or .cssl-mod module, returning its ServiceDefinition
         Usage: include(cso_root('/services/utils.cssl'))
+               include('modules/math_utils.cssl-mod')
+               include('C:/absolute/path/module.cssl-mod')
         Returns: ServiceDefinition with structs, functions, etc.
         """
         if not self.runtime:
             raise CSSLBuiltinError("include requires runtime context")
 
-        # Resolve relative paths
-        if not os.path.isabs(filepath):
-            filepath = self.builtin_cso_root(filepath)
+        # Normalize path separators (support both / and \)
+        filepath = filepath.replace('\\', '/')
+
+        # Handle absolute paths (Windows: C:/, D:/, etc. and Unix: /)
+        is_absolute = os.path.isabs(filepath) or (len(filepath) > 2 and filepath[1] == ':')
+
+        if not is_absolute:
+            # Try relative to current working directory first
+            cwd_path = os.path.join(os.getcwd(), filepath)
+            if os.path.exists(cwd_path):
+                filepath = cwd_path
+            else:
+                # Fall back to cso_root for CSO service context
+                filepath = self.builtin_cso_root(filepath)
 
         # Check file exists
         if not os.path.exists(filepath):
@@ -1426,10 +1443,17 @@ class CSSLBuiltins:
             return self.runtime._include_cache[filepath]
 
         try:
-            # Read and parse the file
+            # Read the file
             with open(filepath, 'r', encoding='utf-8') as f:
                 source = f.read()
 
+            # Check if this is a .cssl-mod file
+            if filepath.endswith('.cssl-mod') or source.startswith('CSSLMOD1'):
+                result = self._load_cssl_module(filepath, source)
+                self.runtime._include_cache[filepath] = result
+                return result
+
+            # Regular CSSL file
             from .cssl_parser import parse_cssl
 
             ast = parse_cssl(source)
@@ -1445,6 +1469,195 @@ class CSSLBuiltins:
         except Exception as e:
             raise CSSLBuiltinError(f"Failed to include '{filepath}': {e}")
 
+    def _load_cssl_module(self, filepath: str, source: str) -> Any:
+        """
+        Load a .cssl-mod module file and return a callable module object.
+        Handles Python and C++ modules.
+        """
+        import base64
+        import pickle
+
+        # Parse the module format: CSSLMOD1\n<base64-encoded-pickle>
+        lines = source.strip().split('\n', 1)
+        if len(lines) < 2 or lines[0] != 'CSSLMOD1':
+            raise CSSLBuiltinError(f"Invalid .cssl-mod format: {filepath}")
+
+        # Decode the module data
+        try:
+            encoded_data = lines[1].strip()
+            module_data = pickle.loads(base64.b64decode(encoded_data))
+        except Exception as e:
+            raise CSSLBuiltinError(f"Failed to decode .cssl-mod: {e}")
+
+        module_name = module_data.get('name', 'unknown')
+        module_type = module_data.get('type', 'python')
+        module_source = module_data.get('source', '')
+
+        if module_type == 'python':
+            return self._execute_python_module(module_name, module_source, filepath)
+        elif module_type == 'cpp':
+            return self._load_cpp_module(module_name, module_source, filepath)
+        else:
+            raise CSSLBuiltinError(f"Unsupported module type: {module_type}")
+
+    def _execute_python_module(self, name: str, source: str, filepath: str) -> Any:
+        """
+        Execute Python source and return a module-like object with all functions.
+        """
+        # Create a namespace for the module
+        module_namespace = {
+            '__name__': name,
+            '__file__': filepath,
+            '__builtins__': __builtins__,
+        }
+
+        # Execute the Python source
+        try:
+            exec(source, module_namespace)
+        except Exception as e:
+            raise CSSLBuiltinError(f"Failed to execute Python module '{name}': {e}")
+
+        # Create a callable module wrapper
+        class CSSLModuleWrapper:
+            """Wrapper that makes Python functions callable from CSSL"""
+            def __init__(self, namespace, mod_name):
+                self._namespace = namespace
+                self._name = mod_name
+                self._functions = {}
+
+                # Extract all callable functions (not dunder methods)
+                for key, value in namespace.items():
+                    if callable(value) and not key.startswith('_'):
+                        self._functions[key] = value
+                        # Also set as attribute for @Module.func() syntax
+                        setattr(self, key, value)
+
+            def __getattr__(self, name):
+                if name.startswith('_'):
+                    raise AttributeError(f"'{self._name}' has no attribute '{name}'")
+                if name in self._functions:
+                    return self._functions[name]
+                if name in self._namespace:
+                    return self._namespace[name]
+                raise AttributeError(f"Module '{self._name}' has no function '{name}'")
+
+            def __repr__(self):
+                funcs = list(self._functions.keys())
+                return f"<CSSLModule '{self._name}' functions={funcs}>"
+
+            def __dir__(self):
+                return list(self._functions.keys())
+
+        return CSSLModuleWrapper(module_namespace, name)
+
+    def _load_cpp_module(self, name: str, source: str, filepath: str) -> Any:
+        """
+        Load a C++ module (stub for future implementation).
+        For now, returns a placeholder with the source available.
+        """
+        class CppModuleStub:
+            def __init__(self, mod_name, cpp_source):
+                self._name = mod_name
+                self._source = cpp_source
+
+            def __repr__(self):
+                return f"<CppModule '{self._name}' (not compiled)>"
+
+            def compile(self):
+                """Future: Compile and load the C++ module"""
+                raise NotImplementedError("C++ module compilation not yet implemented")
+
+        return CppModuleStub(name, source)
+
+    def builtin_payload(self, filepath: str) -> None:
+        """
+        Load a CSSL payload file (.cssl-pl) and execute it in the current scope.
+
+        Payloads are like header files but for CSSL:
+        - Define global variables (accessible via @name)
+        - Define helper functions (globally callable)
+        - Inject code into builtins (like exit() <<== {...})
+        - Set configuration values
+
+        Usage in .cssl file:
+            payload("myconfig.cssl-pl");
+            // Now all globals, functions, and injections are active
+
+        Usage in Python:
+            cssl = CSSL.CsslLang()
+            cssl.code("myhelper", "... cssl code ...")  # Creates inline payload
+            cssl.exec('payload("myhelper");')  # Loads the inline payload
+
+        .cssl-pl file format:
+            // Variables
+            global version = "1.0.0";
+            global debug = true;
+
+            // Injections
+            exit() <<== {
+                printl("Cleanup...");
+            }
+
+            // Helper functions
+            void log(string msg) {
+                if (@debug) printl("[LOG] " + msg);
+            }
+        """
+        if not self.runtime:
+            raise CSSLBuiltinError("payload requires runtime context")
+
+        # Normalize path separators
+        filepath = filepath.replace('\\', '/')
+
+        # Check if this is an inline payload (registered via cssl.code())
+        if hasattr(self.runtime, '_inline_payloads') and filepath in self.runtime._inline_payloads:
+            source = self.runtime._inline_payloads[filepath]
+        else:
+            # Handle absolute paths
+            is_absolute = os.path.isabs(filepath) or (len(filepath) > 2 and filepath[1] == ':')
+
+            if not is_absolute:
+                # Try relative to current working directory first
+                cwd_path = os.path.join(os.getcwd(), filepath)
+                if os.path.exists(cwd_path):
+                    filepath = cwd_path
+                else:
+                    # Fall back to cso_root for CSO service context
+                    filepath = self.builtin_cso_root(filepath)
+
+            # Check file exists
+            if not os.path.exists(filepath):
+                raise CSSLBuiltinError(f"Payload file not found: {filepath}")
+
+            # Check payload cache to prevent double loading
+            if not hasattr(self.runtime, '_payload_cache'):
+                self.runtime._payload_cache = set()
+
+            if filepath in self.runtime._payload_cache:
+                return  # Already loaded
+
+            # Read the payload file
+            with open(filepath, 'r', encoding='utf-8') as f:
+                source = f.read()
+
+            self.runtime._payload_cache.add(filepath)
+
+        # Parse and execute the payload in current scope
+        # This makes all globals, functions, and injections available
+        try:
+            from .cssl_parser import parse_cssl_program
+
+            ast = parse_cssl_program(source)
+
+            # Execute the payload - this will:
+            # - Register global variables (accessible via @name)
+            # - Define functions in current scope
+            # - Set up any code injections
+            self.runtime._execute_node(ast)
+
+        except Exception as e:
+            raise CSSLBuiltinError(f"Failed to load payload '{filepath}': {e}")
+
     def builtin_get(self, source: Any, key: str = None) -> Any:
         """
         Get value from module, ServiceDefinition, or dict
@@ -1614,6 +1827,31 @@ class CSSLBuiltins:
             # This is handled by the runtime which passes the path
             pass
 
+    def builtin_delete(self, name: str) -> bool:
+        """
+        Delete a shared object by name.
+        Usage: delete("MyLib") - removes the $MyLib shared object
+
+        Args:
+            name: Name of the shared object (without the $ prefix)
+
+        Returns:
+            True if deleted, False if not found
+        """
+        from ..cssl_bridge import _live_objects
+
+        # Remove from live objects registry
+        if name in _live_objects:
+            del _live_objects[name]
+            # Also remove from runtime's global scope if present
+            if self.runtime:
+                try:
+                    self.runtime.global_scope.delete(f'${name}')
+                except Exception:
+                    pass
+            return True
+        return False
+
     # ============= CSSL Data Type Constructors =============
 
     def builtin_datastruct(self, element_type: str = 'dynamic') -> Any: