IncludeCPP 4.2.2__py3-none-any.whl → 4.3.0__py3-none-any.whl

includecpp/core/cssl/cssl_builtins.py

@@ -350,22 +350,35 @@ class CSSLBuiltins:
 
     def builtin_print(self, *args, **kwargs) -> None:
         """Print without newline"""
+        import sys
         sep = kwargs.get('sep', ' ')
         end = kwargs.get('end', '')
         output = sep.join(str(a) for a in args) + end
         if self.runtime and hasattr(self.runtime, 'output'):
             self.runtime.output(output)
         else:
-            print(output, end='')
+            # Handle encoding issues on Windows console
+            try:
+                print(output, end='')
+            except UnicodeEncodeError:
+                encoded = output.encode(sys.stdout.encoding or 'utf-8', errors='replace')
+                print(encoded.decode(sys.stdout.encoding or 'utf-8', errors='replace'), end='')
 
     def builtin_println(self, *args, **kwargs) -> None:
         """Print with newline"""
+        import sys
         sep = kwargs.get('sep', ' ')
         output = sep.join(str(a) for a in args)
         if self.runtime and hasattr(self.runtime, 'output'):
             self.runtime.output(output + '\n')
         else:
-            print(output)
+            # Handle encoding issues on Windows console
+            try:
+                print(output)
+            except UnicodeEncodeError:
+                # Fallback: encode with errors='replace' for unsupported chars
+                encoded = output.encode(sys.stdout.encoding or 'utf-8', errors='replace')
+                print(encoded.decode(sys.stdout.encoding or 'utf-8', errors='replace'))
 
     def builtin_input(self, prompt: str = "") -> str:
         """Read user input from console.
@@ -2111,9 +2124,9 @@ class CSSLBuiltins:
 
         return CppModuleStub(name, source)
 
-    def builtin_payload(self, filepath: str) -> None:
+    def builtin_payload(self, filepath: str, libname: str = None) -> None:
         """
-        Load a CSSL payload file (.cssl-pl) and execute it in the current scope.
+        Load a CSSL payload file (.cssl-pl) and execute it.
 
         Payloads are like header files but for CSSL:
         - Define global variables (accessible via @name)
@@ -2122,8 +2135,19 @@ class CSSLBuiltins:
         - Set configuration values
 
         Usage in .cssl file:
+            // Standard: everything is applied globally
             payload("myconfig.cssl-pl");
-            // Now all globals, functions, and injections are active
+
+            // Namespaced: everything goes into a namespace
+            payload("myconfig.cssl-pl", "mylib");
+            mylib::myFunction();  // Access via namespace
+
+        Namespace behavior:
+            - Without libname: All changes are global (embedded replaces globally)
+            - With libname: All definitions go into namespace
+              - embedded new_exit &exit {} -> mylib::exit is new_exit
+              - Global exit remains unchanged
+              - Access via libname::function(), libname::MyClass
 
         Usage in Python:
             cssl = CSSL.CsslLang()
@@ -2155,6 +2179,10 @@ class CSSLBuiltins:
         if hasattr(self.runtime, '_inline_payloads') and filepath in self.runtime._inline_payloads:
             source = self.runtime._inline_payloads[filepath]
         else:
+            # v4.2.6: Auto-append .cssl-pl extension if not specified
+            # payload("engine") -> looks for engine.cssl-pl
+            original_filepath = filepath
+
             # Handle absolute paths
             is_absolute = os.path.isabs(filepath) or (len(filepath) > 2 and filepath[1] == ':')
 
@@ -2164,42 +2192,124 @@ class CSSLBuiltins:
                 if os.path.exists(cwd_path):
                     filepath = cwd_path
                 else:
-                    # Fall back to cso_root for service context
-                    filepath = self.builtin_cso_root(filepath)
-
-            # Check file exists
+                    # Try with .cssl-pl extension
+                    cwd_path_pl = os.path.join(os.getcwd(), filepath + '.cssl-pl')
+                    if os.path.exists(cwd_path_pl):
+                        filepath = cwd_path_pl
+                    else:
+                        # Fall back to cso_root for service context
+                        filepath = self.builtin_cso_root(filepath)
+
+            # Check file exists, try with .cssl-pl extension if not
             if not os.path.exists(filepath):
-                raise CSSLBuiltinError(f"Payload file not found: {filepath}")
+                # Try adding .cssl-pl extension
+                filepath_with_ext = filepath + '.cssl-pl'
+                if os.path.exists(filepath_with_ext):
+                    filepath = filepath_with_ext
+                else:
+                    raise CSSLBuiltinError(f"Payload file not found: {original_filepath} (tried {filepath} and {filepath_with_ext})")
 
             # 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:
+            # For namespaced payloads, use different cache key
+            cache_key = f"{filepath}::{libname}" if libname else filepath
+            if cache_key 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)
+            self.runtime._payload_cache.add(cache_key)
 
-        # Parse and execute the payload in current scope
-        # This makes all globals, functions, and injections available
+        # Parse and execute the payload
         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)
+            if libname:
+                # Namespaced execution: execute in isolated scope
+                self._execute_payload_namespaced(ast, libname, source)
+            else:
+                # Standard execution: apply globally
+                # 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 _execute_payload_namespaced(self, ast, libname: str, source: str) -> None:
+        """
+        Execute payload in a namespace.
+
+        All definitions go into the namespace dict.
+        embedded replacements are scoped to the namespace only.
+        """
+        # Create namespace dict
+        namespace = {}
+
+        # Save current scope state
+        old_scope = self.runtime.scope.copy()
+        old_global = self.runtime.global_scope.copy()
+
+        # Track what gets added during payload execution
+        scope_before = set(self.runtime.scope.keys())
+        global_before = set(self.runtime.global_scope.keys())
+
+        # Set a flag to tell runtime we're in namespace mode
+        self.runtime._payload_namespace_mode = libname
+
+        try:
+            # Execute the payload
+            self.runtime._execute_node(ast)
+
+            # Collect new definitions from scope
+            for key in self.runtime.scope:
+                if key not in scope_before:
+                    namespace[key] = self.runtime.scope[key]
+
+            # Collect new definitions from global_scope (but not the namespace itself)
+            for key in self.runtime.global_scope:
+                if key not in global_before and key != libname:
+                    namespace[key] = self.runtime.global_scope[key]
+
+            # Handle embedded replacements: move replaced targets into namespace
+            if hasattr(self.runtime, '_namespace_replacements'):
+                for target_name, new_impl in self.runtime._namespace_replacements.items():
+                    # Get the original from before execution
+                    original = old_scope.get(target_name) or old_global.get(target_name)
+                    if original is not None:
+                        # Restore original globally
+                        if target_name in old_scope:
+                            self.runtime.scope[target_name] = original
+                        if target_name in old_global:
+                            self.runtime.global_scope[target_name] = original
+                    # Put the replacement in namespace
+                    namespace[target_name] = new_impl
+                del self.runtime._namespace_replacements
+
+            # Remove new definitions from global scope (they're in namespace now)
+            for key in list(self.runtime.scope.keys()):
+                if key not in scope_before:
+                    del self.runtime.scope[key]
+
+            for key in list(self.runtime.global_scope.keys()):
+                if key not in global_before and key != libname:
+                    del self.runtime.global_scope[key]
+
+        finally:
+            # Clear namespace mode flag
+            self.runtime._payload_namespace_mode = None
+
+        # Register namespace in global scope
+        self.runtime.global_scope[libname] = namespace
+
     def builtin_get(self, source: Any, key: str = None) -> Any:
         """
         Get value from module, ServiceDefinition, or dict