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

includecpp/core/cssl/cssl_builtins.py

@@ -41,6 +41,7 @@ class CSSLBuiltins:
         self._functions['error'] = self.builtin_error
         self._functions['warn'] = self.builtin_warn
         self._functions['log'] = self.builtin_log
+        self._functions['encode'] = self.builtin_encode  # v4.3.2: Safe unicode encoding
 
         # Type conversion
         self._functions['int'] = self.builtin_int
@@ -350,22 +351,73 @@ 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_encode(self, content: str, fallback: str = "?") -> str:
+        """Encode unicode/emoji characters for safe console output.
+
+        v4.3.2: Safely encode emojis and special unicode characters that may not
+        be supported by the current console encoding (e.g., Windows cp1252).
+
+        Usage:
+            printl("Status: " + encode("✅"));
+            printl("Result: " + encode("😂", "[emoji]"));
+
+            // With custom fallback
+            msg = encode("🎉 Success!", "[party]");
+
+        Args:
+            content: String containing unicode/emoji characters
+            fallback: Replacement string for unencodable characters (default: "?")
+
+        Returns:
+            String safe for console output
+        """
+        import sys
+        encoding = sys.stdout.encoding or 'utf-8'
+
+        try:
+            # Test if content can be encoded with current console encoding
+            content.encode(encoding)
+            return content
+        except UnicodeEncodeError:
+            # Replace unencodable characters with fallback
+            result = []
+            for char in content:
+                try:
+                    char.encode(encoding)
+                    result.append(char)
+                except UnicodeEncodeError:
+                    result.append(fallback)
+            return ''.join(result)
 
     def builtin_input(self, prompt: str = "") -> str:
         """Read user input from console.
@@ -632,19 +684,85 @@ class CSSLBuiltins:
     # ============= List Functions =============
 
     def builtin_push(self, lst: list, *items) -> list:
+        """Push items onto a list/stack/vector.
+
+        v4.5.1: For Stack/Vector/Array types, modifies in place.
+        For regular lists, creates a copy (immutable behavior).
+        """
+        if lst is None:
+            lst = []
+            lst.extend(items)
+            return lst
+
+        # v4.5.1: For CSSL typed containers, modify in place
+        from .cssl_types import Stack, Vector, Array, DataStruct
+        if isinstance(lst, (Stack, Vector, Array, DataStruct)):
+            for item in items:
+                lst.append(item)
+            return lst
+
+        # For regular lists, create a copy (immutable behavior)
         lst = list(lst)
         lst.extend(items)
         return lst
 
     def builtin_pop(self, lst: list, index: int = -1) -> Any:
+        """Pop item from list/stack/vector.
+
+        v4.5.1: For Stack/Vector/Array types, modifies in place.
+        """
+        if lst is None:
+            return None
+
+        # v4.5.1: For CSSL typed containers, modify in place
+        from .cssl_types import Stack, Vector, Array, DataStruct
+        if isinstance(lst, (Stack, Vector, Array, DataStruct)):
+            if len(lst) == 0:
+                return None
+            return lst.pop(index)
+
+        # For regular lists, create a copy
         lst = list(lst)
-        return lst.pop(index)
+        return lst.pop(index) if lst else None
 
     def builtin_shift(self, lst: list) -> Any:
+        """Remove and return first element.
+
+        v4.5.1: For Stack/Vector/Array types, modifies in place.
+        """
+        if lst is None:
+            return None
+
+        # v4.5.1: For CSSL typed containers, modify in place
+        from .cssl_types import Stack, Vector, Array, DataStruct
+        if isinstance(lst, (Stack, Vector, Array, DataStruct)):
+            if len(lst) == 0:
+                return None
+            return lst.pop(0)
+
+        # For regular lists, create a copy
         lst = list(lst)
         return lst.pop(0) if lst else None
 
     def builtin_unshift(self, lst: list, *items) -> list:
+        """Add items to the front of a list/stack/vector.
+
+        v4.5.1: For Stack/Vector/Array types, modifies in place.
+        """
+        if lst is None:
+            lst = []
+            for item in reversed(items):
+                lst.insert(0, item)
+            return lst
+
+        # v4.5.1: For CSSL typed containers, modify in place
+        from .cssl_types import Stack, Vector, Array, DataStruct
+        if isinstance(lst, (Stack, Vector, Array, DataStruct)):
+            for item in reversed(items):
+                lst.insert(0, item)
+            return lst
+
+        # For regular lists, create a copy
         lst = list(lst)
         for item in reversed(items):
             lst.insert(0, item)
@@ -2111,9 +2229,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 +2240,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 +2284,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 +2297,134 @@ 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.
+        Variables declared with 'global' keyword remain truly global (accessible via @).
+        """
+        # Create namespace dict
+        namespace = {}
+
+        # Save current scope state (copy the variables dicts)
+        old_scope_vars = dict(self.runtime.scope.variables)
+        old_global_vars = dict(self.runtime.global_scope.variables)
+        old_promoted_globals = dict(self.runtime._promoted_globals)
+
+        # Track what gets added during payload execution
+        scope_before = set(self.runtime.scope.variables.keys())
+        global_before = set(self.runtime.global_scope.variables.keys())
+        promoted_before = set(self.runtime._promoted_globals.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)
+
+            # Find which variables were explicitly promoted to global (via 'global' keyword)
+            new_promoted = set(self.runtime._promoted_globals.keys()) - promoted_before
+
+            # Collect new definitions from scope (but not promoted globals)
+            for key in self.runtime.scope.variables:
+                if key not in scope_before and key not in new_promoted:
+                    namespace[key] = self.runtime.scope.get(key)
+
+            # Collect new definitions from global_scope (but not namespace itself, not promoted globals)
+            for key in self.runtime.global_scope.variables:
+                if key not in global_before and key != libname and key not in new_promoted:
+                    namespace[key] = self.runtime.global_scope.get(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_vars.get(target_name) or old_global_vars.get(target_name)
+                    if original is not None:
+                        # Restore original globally
+                        if target_name in old_scope_vars:
+                            self.runtime.scope.set(target_name, original)
+                        if target_name in old_global_vars:
+                            self.runtime.global_scope.set(target_name, original)
+                    # Put the replacement in namespace
+                    namespace[target_name] = new_impl
+                del self.runtime._namespace_replacements
+
+            # Remove new definitions from scope (they're in namespace now)
+            # BUT keep promoted globals - they stay global!
+            for key in list(self.runtime.scope.variables.keys()):
+                if key not in scope_before and key not in new_promoted:
+                    del self.runtime.scope.variables[key]
+
+            for key in list(self.runtime.global_scope.variables.keys()):
+                if key not in global_before and key != libname and key not in new_promoted:
+                    del self.runtime.global_scope.variables[key]
+
+            # Promoted globals stay in _promoted_globals and global_scope (not moved to namespace)
+            # They are accessible via @name from anywhere
+
+        finally:
+            # Clear namespace mode flag
+            self.runtime._payload_namespace_mode = None
+
+        # Register namespace in global scope
+        self.runtime.global_scope.set(libname, namespace)
+
     def builtin_get(self, source: Any, key: str = None) -> Any:
         """
         Get value from module, ServiceDefinition, or dict