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

includecpp/core/cssl/CSSL_DOCUMENTATION.md

@@ -1,6 +1,6 @@
 # CSSL - C-Style Scripting Language
 
-> Version 4.0.0 | A modern scripting language with C++-style syntax and unique features like CodeInfusion, BruteInjection, and Python Interop.
+> Version 4.1.0 | A modern scripting language with C++-style syntax and unique features like CodeInfusion, BruteInjection, Python Interop, and Multi-Language Support.
 
 ---
 
@@ -20,8 +20,9 @@
 12. [BruteInjection](#bruteinjection)
 13. [Value Capture](#value-capture)
 14. [Module System](#module-system)
-15. [Error Handling](#error-handling)
-16. [Quick Reference](#quick-reference)
+15. [Multi-Language Support](#multi-language-support)
+16. [Error Handling](#error-handling)
+17. [Quick Reference](#quick-reference)
 
 ---
 
@@ -101,15 +102,21 @@ printl("Hello")    // Works
 printl("Hello");   // Also works (recommended)
 ```
 
-### Output Functions
+### I/O Functions
 
 ```cssl
+// Output
 printl("Text");              // Print with newline
 print("No newline");         // Print without newline
 debug("Debug info");         // Print with [DEBUG] prefix
 error("Error message");      // Print with [ERROR] prefix
 warn("Warning");             // Print with [WARN] prefix
 log("INFO", "Message");      // Print with custom prefix
+
+// Input
+string name = input("Enter your name: ");
+int age = int(input("Enter your age: "));
+string raw = input();        // Without prompt
 ```
 
 ---
@@ -1398,6 +1405,161 @@ python -m includecpp cssl makemodule mylib.py -o mylib.cssl-mod
 
 ---
 
+## Multi-Language Support
+
+CSSL v4.1.0 introduces multi-language support for interoperability with other programming languages.
+
+### libinclude - Load Language Support
+
+Use `libinclude()` to load a language support module:
+
+```cssl
+// Load language support
+@py = libinclude("python");
+cpp = libinclude("c++");
+java = libinclude("java");
+csharp = libinclude("c#");
+js = libinclude("javascript");
+```
+
+**Supported Languages:**
+
+| Language | Identifiers |
+|----------|-------------|
+| Python | `python`, `py` |
+| C++ | `c++`, `cpp` |
+| Java | `java` |
+| C# | `c#`, `csharp` |
+| JavaScript | `javascript`, `js` |
+
+### supports - Multi-Language Syntax
+
+Use the `supports` keyword to write functions or classes using another language's syntax:
+
+```cssl
+// Python-style function
+define calculate(numbers) : supports @py {
+    total = 0
+    for n in numbers:
+        total = total + n
+    return total
+}
+
+// C++ style class
+class Engine : supports cpp {
+    int power;
+    bool running;
+
+    void start() {
+        this->running = true;
+    }
+}
+
+// JavaScript style function
+define fetchData(url) : supports js {
+    let response = fetch(url);
+    console.log("Fetched: " + url);
+    return response;
+}
+```
+
+### Cross-Language Instance Access
+
+Access instances shared from other languages using `lang$InstanceName` syntax:
+
+```cssl
+cpp = libinclude("c++");
+
+// Access C++ shared instance
+engine = cpp$MyEngine;
+printl(engine.power);
+
+// Cross-language inheritance
+class TurboEngine : extends cpp$Engine {
+    int turboBoost;
+
+    constr TurboEngine(int boost) {
+        this->turboBoost = boost;
+    }
+}
+```
+
+### Instance Sharing API
+
+Share instances between languages using the `share()` and `get_instance()` methods:
+
+```cssl
+// Get language support
+cpp = libinclude("c++");
+
+// Share a CSSL instance with C++
+class MyClass {
+    string value;
+}
+instance = new MyClass();
+cpp.share("MyClass", instance);
+
+// Access from C++:
+// auto* obj = CSSL_GET(MyClass, "MyClass");
+```
+
+### Language SDKs
+
+SDKs are available for sharing instances from other languages into CSSL:
+
+**C++ SDK:**
+```cpp
+#include "includecpp.h"
+
+class Engine { public: int power = 100; };
+
+Engine engine;
+CSSL_SHARE(Engine, &engine);
+// Now accessible as cpp$Engine in CSSL
+```
+
+**Java SDK:**
+```java
+import com.includecpp.CSSL;
+
+MyService svc = new MyService();
+CSSL.share("MyService", svc);
+// Now accessible as java$MyService in CSSL
+```
+
+**C# SDK:**
+```csharp
+using IncludeCPP;
+
+var service = new MyService();
+CSSL.Share("MyService", service);
+// Now accessible as csharp$MyService in CSSL
+```
+
+**JavaScript SDK:**
+```javascript
+import { CSSL } from 'includecpp-cssl';
+
+class DataProcessor { process(data) { } }
+CSSL.share('DataProcessor', new DataProcessor());
+// Now accessible as js$DataProcessor in CSSL
+```
+
+### SDK API Reference
+
+All language SDKs provide these methods:
+
+| Method | Description |
+|--------|-------------|
+| `share(name, instance)` | Share an instance by name |
+| `get(name)` | Get a shared instance |
+| `has(name)` | Check if instance exists |
+| `remove(name)` | Remove a shared instance |
+| `list()` | Get all instance names |
+| `clear()` | Clear all instances |
+
+---
+
 ## Error Handling
 
 ### Try / Catch
@@ -1495,7 +1657,26 @@ assert(x > 0, "x must be positive");
 | `global define func()` | Global function declaration |
 | `define @func()` | Global function (alt syntax) |
 | `new @ClassName()` | Instantiate global class |
+| `libinclude("lang")` | Load language support module |
+| `supports @lang` | Use other language syntax |
+| `lang$InstanceName` | Cross-language instance access |
+
+### Multi-Language Keywords
+
+| Keyword | Description |
+|---------|-------------|
+| `libinclude` | Load language support module |
+| `supports` | Use another language's syntax in function/class |
+
+### Cross-Language Syntax
+
+| Syntax | Description | Example |
+|--------|-------------|---------|
+| `libinclude("lang")` | Load language support | `cpp = libinclude("c++")` |
+| `: supports @lang` | Use language syntax | `define func() : supports @py { }` |
+| `lang$Name` | Access shared instance | `cpp$Engine`, `java$Service` |
+| `extends lang$Name` | Inherit from shared class | `class Child : extends cpp$Parent { }` |
 
 ---
 
-*CSSL v4.0.0 - Developed as part of IncludeCPP*
+*CSSL v4.1.0 - Developed as part of IncludeCPP*

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)
@@ -1937,6 +1960,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 +2750,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 +2806,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)