IncludeCPP 4.0.2__py3-none-any.whl → 4.2.2__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
@@ -365,6 +367,27 @@ class CSSLBuiltins:
         else:
             print(output)
 
+    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"""
         msg = ' '.join(str(a) for a in args)
@@ -1418,8 +1441,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 +1972,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.
@@ -2688,8 +2762,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 +2818,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)