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

includecpp/core/cssl/cssl_builtins.py

@@ -36,6 +36,7 @@ class CSSLBuiltins:
         # Output functions
         self._functions['print'] = self.builtin_print
         self._functions['println'] = self.builtin_println
+        self._functions['input'] = self.builtin_input
         self._functions['debug'] = self.builtin_debug
         self._functions['error'] = self.builtin_error
         self._functions['warn'] = self.builtin_warn
@@ -291,6 +292,7 @@ class CSSLBuiltins:
         self._functions['include'] = self.builtin_include
         self._functions['payload'] = self.builtin_payload
         self._functions['get'] = self.builtin_get
+        self._functions['libinclude'] = self.builtin_libinclude  # v4.1.0: Multi-language support
 
         # NEW: Extended OS Functions
         self._functions['Listdir'] = self.builtin_listdir  # Alias with capital L
@@ -348,22 +350,56 @@ 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.
+
+        Usage:
+            name = input("Enter your name: ");
+            age = int(input("Enter your age: "));
+
+            // Without prompt
+            value = input();
+
+        Args:
+            prompt: Optional prompt text to display
+
+        Returns:
+            The user's input as a string
+        """
+        if self.runtime and hasattr(self.runtime, 'input'):
+            return self.runtime.input(prompt)
+        else:
+            return input(prompt)
 
     def builtin_debug(self, *args) -> None:
         """Debug output"""
@@ -1418,8 +1454,20 @@ class CSSLBuiltins:
         time.sleep(ms / 1000.0)
 
     def builtin_pyimport(self, module_name: str) -> Any:
-        """Import a Python module for use in CSSL"""
-        return __import__(module_name)
+        """
+        Import a Python module for use in CSSL.
+
+        v4.1.1: Fixed to use importlib.import_module for proper nested module support.
+
+        Usage:
+            module = pyimport("plugins.app")
+            result = module.my_function()
+
+            os = pyimport("os")
+            path = os.path.join("a", "b")
+        """
+        import importlib
+        return importlib.import_module(module_name)
 
     # ============= Extended String Functions =============
 
@@ -1937,6 +1985,45 @@ class CSSLBuiltins:
         except Exception as e:
             raise CSSLBuiltinError(f"Failed to include '{filepath}': {e}")
 
+    def builtin_libinclude(self, lang_id: str) -> Any:
+        """
+        Load a language support module for multi-language syntax support.
+
+        v4.1.0: Multi-language support for CSSL.
+
+        Usage:
+            @py = libinclude("python")
+            cpp = libinclude("c++")
+            java = libinclude("java")
+            js = libinclude("javascript")
+            csharp = libinclude("c#")
+
+        Returns: LanguageSupport object that can be used with 'supports' keyword.
+
+        Example:
+            @py = libinclude("python");
+
+            define my_func() : supports @py {
+                # Python syntax here!
+                for i in range(10):
+                    print(i)
+            }
+
+            class MyClass : extends cpp$BaseClass {
+                // Inherit from C++ class
+            }
+        """
+        from .cssl_languages import get_language
+
+        lang_support = get_language(lang_id)
+        if lang_support is None:
+            supported = ["python", "py", "java", "c#", "csharp", "c++", "cpp", "javascript", "js"]
+            raise CSSLBuiltinError(
+                f"Unknown language '{lang_id}'. Supported languages: {', '.join(supported)}"
+            )
+
+        return lang_support
+
     def _load_cssl_module(self, filepath: str, source: str) -> Any:
         """
         Load a .cssl-mod module file and return a callable module object.
@@ -2037,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)
@@ -2048,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()
@@ -2081,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] == ':')
 
@@ -2090,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
@@ -2688,8 +2872,8 @@ class PythonizedCSSLInstance:
             return value
 
         # Check for method
-        method = instance.get_method(name)
-        if method is not None:
+        if instance.has_method(name):
+            method = instance.get_method(name)
             # Return a callable wrapper for the method
             return PythonizedMethod(instance, name, method, runtime)
 
@@ -2744,6 +2928,29 @@ class PythonizedMethod:
         if self._runtime is None:
             raise RuntimeError(f"Cannot call method '{self._method_name}' - no runtime available")
 
+        # Validate argument count
+        # Method AST structure: node.value is a dict with 'params' key
+        method_info = getattr(self._method_ast, 'value', {}) or {}
+        method_params = method_info.get('params', []) if isinstance(method_info, dict) else []
+        param_names = [p.get('name', str(p)) if isinstance(p, dict) else (p.name if hasattr(p, 'name') else str(p)) for p in method_params]
+        expected_count = len(param_names)
+        actual_count = len(args)
+
+        if actual_count < expected_count:
+            missing = param_names[actual_count:]
+            class_name = self._instance._class.name
+            raise TypeError(
+                f"{class_name}.{self._method_name}() missing {len(missing)} required argument(s): {', '.join(repr(p) for p in missing)}\n"
+                f"  Expected: {self._method_name}({', '.join(param_names)})\n"
+                f"  Got:      {self._method_name}({', '.join(repr(a) for a in args)})"
+            )
+        elif actual_count > expected_count:
+            class_name = self._instance._class.name
+            raise TypeError(
+                f"{class_name}.{self._method_name}() takes {expected_count} argument(s) but {actual_count} were given\n"
+                f"  Expected: {self._method_name}({', '.join(param_names)})"
+            )
+
         # Execute the method through the runtime
         # Pass the method AST node, not the method name
         result = self._runtime._call_method(self._instance, self._method_ast, list(args), kwargs)